Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / layout / phase.lucb

## Circular logical-side station transfer, including split STEP coedge chains.

## Transfer angular positions, not just interval counts, across different frames
## and senses. A logical side can contain several arcs on the same circle;
## coedge endpoints are mandatory angular stations on the opposite side too.
## Otherwise equal counts still connect different angles and create fans.
pub func compatible(face: BrepFace, edges: const Curve[], side: PatchSides, pair: usize) -> bool!:
    let first = edges[edge_index(face.uses[side.starts[pair]])]
    if first.kind != curve_circle: return false
    let axis = first.x.cross(first.y)
    for current in [pair,pair+2]:
        for at in 0..<side.lengths[current]:
            let edge = edges[edge_index(face.uses[(side.starts[current]+at)%face.uses.length])]
            if edge.kind != curve_circle or math.abs(axis.dot(edge.x.cross(edge.y))) < 1.0-1e-9: return false
            let delta = edge.origin.subtract(first.origin)
            if delta.subtract(axis.multiply_scalar(delta.dot(axis))).length() > math.max(1.0,first.radius)*1e-7: return false
    # Require equal angular coverage before registering any new cuts.
    for current in [pair,pair+2]:
        let opposite = pair+2 if current == pair else pair
        for at in 0..<side.lengths[current]:
            let a = edges[edge_index(face.uses[(side.starts[current]+at)%face.uses.length])]
            for fraction in [0.0,0.5,1.0]:
                let p = (try a.at(fraction)).subtract(a.origin).multiply_scalar(1.0/a.radius)
                var covered = false
                for item in 0..<side.lengths[opposite]:
                    let b = edges[edge_index(face.uses[(side.starts[opposite]+item)%face.uses.length])]
                    covered = covered or arc_parameter(b,math.atan2(p.dot(b.y),p.dot(b.x))) >= 0.0
                if not covered: return false
    return true

pub func align_sides(face: BrepFace, edges: const Curve[], side: PatchSides, pair: usize, cuts: Stations[], tolerance: f64) -> bool!:
    if not (try compatible(face,edges,side,pair)): return false
    var changed = false
    for current in [pair,pair+2]:
        let opposite = pair+2 if current == pair else pair
        for at in 0..<side.lengths[current]:
            let ai = (side.starts[current]+at)%face.uses.length
            let a = edges[edge_index(face.uses[ai])]
            for station in 0..<cuts[ai].count:
                let p = (try a.at(cuts[ai].values[station])).subtract(a.origin).multiply_scalar(1.0/a.radius)
                for item in 0..<side.lengths[opposite]:
                    let bi = (side.starts[opposite]+item)%face.uses.length
                    if ai == bi: continue
                    let b = edges[edge_index(face.uses[bi])]
                    let t = arc_parameter(b,math.atan2(p.dot(b.y),p.dot(b.x)))
                    if t < 0.0: continue
                    let epsilon = math.max(cuts[bi].epsilon,tolerance*0.01/math.max(1e-30,b.radius*math.abs(b.sweep)))
                    let added = try cuts[bi].insert(t,epsilon)
                    changed = changed or added
    return changed

pub func arc_parameter(edge: Curve, angle: f64) -> f64:
    let midpoint = edge.angle+edge.sweep*0.5
    let theta = angle+2.0*math.pi*math.floor((midpoint-angle)/(2.0*math.pi)+0.5)
    let t = (theta-edge.angle)/edge.sweep
    if t < -1e-9 or t > 1.0+1e-9: return -1.0
    return math.clamp(t,0.0,1.0)