Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.2

0.9.2 / src / modeling / setback.lucb

## Three G2 or G3 fillets meeting at a corner of three flat faces. No ball
## is tangent to such fillets: their sections are not circles. So, as
## Fusion and SolidWorks do, each fillet stops short of the corner, at its
## setback: a plane square to its edge. The hole between the fillets' end
## sections and the faces is filled by a patch with the fillets'
## continuity (patch_fit.lucb). The corner tool is the region between the
## sharp corner and the patch, cut off by the setback planes. It is taken
## away after the edges' tools (added, at an inside corner), and it leaves
## the patch. Its sides meet the body's faces only along curves both
## carry, which the booleans take as touching (splines.lucb).

## A setback corner: its vertex; its three edges, ordered so that face i
## holds edges i and i + 1; each edge's unit way from the corner; how far
## along it the fillets stop. `inside` marks an inside corner, whose tool
## is added.
struct Setback:
    var vertex: i64
    var edges: usize[3]
    var ways: Vector3[3]
    var distances: f64[3]
    var inside: bool

## A setback corner of fillets of `radius` at vertex `v`, where `edges`
## (three, one per line through it) meet. Each fillet stops past where the
## next fillets' contacts cross on the faces, by half the largest contact
## distance. That is 1.5 times the radius at a square corner, Fusion's
## default. `hollow` marks an inside corner.
func setback_at(w: const Shape*, v: i64, edges: const usize[], radius: f64, hollow: bool) -> Setback!:
    if edges.length != 3: error(invalid, "a setback corner needs three edges")
    # Ordered so edges i and i + 1 share a face.
    var ordered: usize[3] = [edges[0], edges[1], edges[2]]
    if try shared_face(w, ordered[0], ordered[1]) < 0:
        ordered[1] = edges[2]
        ordered[2] = edges[1]
    var corner = Setback(v, ordered, [Vector3(), Vector3(), Vector3()], [0.0, 0.0, 0.0], hollow)
    for i in 0..<(usize)3:
        let edge = w.edges.items[ordered[i]]
        corner.ways[i] = try w.leaving(ordered[i], 0 if edge.start == v else 1)
    let frame = try setback_frame(w, &corner, radius)
    let p = w.points.items[(usize)v]
    var most = 0.0
    for r in frame.reaches: most = math.max(most, r)
    for i in 0..<(usize)3:
        let before = (i + 2) % 3
        let next = (i + 1) % 3
        let after = try contacts_cross(p, corner.ways[i], frame.intos[i * 2 + 1], frame.reaches[i], corner.ways[next], frame.intos[next * 2], frame.reaches[next])
        let behind = try contacts_cross(p, corner.ways[before], frame.intos[before * 2 + 1], frame.reaches[before], corner.ways[i], frame.intos[i * 2], frame.reaches[i])
        corner.distances[i] = math.max(after.subtract(p).dot(corner.ways[i]), behind.subtract(p).dot(corner.ways[i])) + most * 0.5
    return corner

## Of a setback corner: each edge's contact distance (reaches[i]); its
## ways into its faces, perpendicular to it (into face i - 1 at
## intos[2 i], into face i at intos[2 i + 1]); and the faces (face i holds
## edges i and i + 1).
struct Frame:
    var reaches: f64[3]
    var intos: Vector3[6]
    var faces: usize[3]

func setback_frame(w: const Shape*, corner: const Setback*, radius: f64) -> Frame!:
    var faces: usize[3] = [0, 0, 0]
    for i in 0..<(usize)3:
        let f = try shared_face(w, corner.edges[i], corner.edges[(i + 1) % 3])
        if f < 0 or w.surfaces.items[(usize)w.faces.items[(usize)f].surface].kind != surface_plane: error(invalid, "fillets meeting at a corner need flat faces there")
        faces[i] = (usize)f
    var reaches: f64[3] = [0.0, 0.0, 0.0]
    var intos: Vector3[6] = [Vector3(), Vector3(), Vector3(), Vector3(), Vector3(), Vector3()]
    for i in 0..<(usize)3:
        let along = corner.ways[i]
        intos[i * 2] = try into_face(w, faces[(i + 2) % 3], corner.edges[i], along)
        intos[i * 2 + 1] = try into_face(w, faces[i], corner.edges[i], along)
        let angle = math.acos(math.clamp(intos[i * 2].dot(intos[i * 2 + 1]), -1.0, 1.0))
        reaches[i] = radius / math.tan(angle * 0.5)
    return Frame(reaches, intos, faces)

## The face edges `a` and `b` share, or -1.
func shared_face(w: const Shape*, a: usize, b: usize) -> i64!:
    let (fa, fb) = try edge_faces(w, a)
    let (ga, gb) = try edge_faces(w, b)
    if fa == ga or fa == gb: return (i64)fa
    if fb == ga or fb == gb: return (i64)fb
    return -1

## Where two fillets' contact lines cross on the face they share: fillet
## `a` runs along `way_a` from corner `p`, its contact `reach_a` into the
## face along `into_a`; likewise `b`.
func contacts_cross(p: Vector3, way_a: Vector3, into_a: Vector3, reach_a: f64, way_b: Vector3, into_b: Vector3, reach_b: f64) -> Vector3!:
    let pa = p.add(into_a.multiply_scalar(reach_a))
    let pb = p.add(into_b.multiply_scalar(reach_b))
    let k = way_a.dot(way_b)
    let det = 1.0 - k * k
    if det < 1e-12: error(invalid, "fillets meeting at a corner run along one line")
    let r = pa.subtract(pb)
    let s = (k * r.dot(way_b) - r.dot(way_a)) / det
    return pa.add(way_a.multiply_scalar(s))

## A setback corner's tool for fillets of `radius` and `continuity` (2 or
## 3): the region between the sharp corner and the patch, within the
## setback planes. The patch's quads are named `name`.
func setback_tool(w: const Shape*, corner: const Setback*, radius: f64, continuity: i64, name: str) -> interop.Reference[CadModel]!:
    var quads = Growing[Vector3]()
    defer quads.close()
    var quad_knots = Growing[f64]()
    defer quad_knots.close()
    try setback_patch(w, corner, radius, continuity, &quads, &quad_knots)
    let p = w.points.items[(usize)corner.vertex]
    let cone = try corner_cone(w, corner, radius)
    return try corner_solid(p, corner, quads.view(), cone[..<3], quad_knots.view(), quad_knots.count - 6, name)

## Each face's outward normal at a setback corner, turned to face away
## from the corner's inside (along the edge not on the face).
func corner_cone(w: const Shape*, corner: const Setback*, radius: f64) -> Vector3[3]!:
    let frame = try setback_frame(w, corner, radius)
    var cone: Vector3[3] = [Vector3(), Vector3(), Vector3()]
    for i in 0..<(usize)3:
        let n = face_outward(w, frame.faces[i])
        cone[i] = n if n.dot(corner.ways[(i + 2) % 3]) > 0.0 else n.multiply_scalar(-1.0)
    return cone

## A setback corner's patch for fillets of `radius` and `continuity`: six
## quads onto `quads` (patch_fit.lucb's order), their knots onto
## `quad_knots`. Its control points must stay between the faces and the
## setback planes (so it meets the body only along curves both carry).
func setback_patch(w: const Shape*, corner: const Setback*, radius: f64, continuity: i64, quads: Growing[Vector3]*, quad_knots: Growing[f64]*) -> !:
    let frame = try setback_frame(w, corner, radius)
    let reaches = frame.reaches
    let intos = frame.intos
    let faces = frame.faces
    let p = w.points.items[(usize)corner.vertex]
    # The hole's six curves: each fillet's end section (as its tool's
    # profile makes it) from face i - 1 to face i, then the curve on face i
    # to the next fillet's contact, legs along the contact lines. All are
    # the fillet's section (fillet_section), so they share knots.
    var curves = Growing[Vector3]()
    defer curves.close()
    var knots = Growing[f64]()
    defer knots.close()
    var sides = Growing[HoleSide]()
    defer sides.close()
    for i in 0..<(usize)3:
        let next = (i + 1) % 3
        let foot = p.add(corner.ways[i].multiply_scalar(corner.distances[i]))
        let ta = foot.add(intos[i * 2].multiply_scalar(reaches[i]))
        let tb = foot.add(intos[i * 2 + 1].multiply_scalar(reaches[i]))
        knots.clear()
        try fillet_section(ta, tb, foot, continuity, &curves, &knots)
        try sides.push(HoleSide(true, corner.ways[i]))
        let cross = try contacts_cross(p, corner.ways[i], intos[i * 2 + 1], reaches[i], corner.ways[next], intos[next * 2], reaches[next])
        let foot_next = p.add(corner.ways[next].multiply_scalar(corner.distances[next]))
        let tc = foot_next.add(intos[next * 2].multiply_scalar(reaches[next]))
        knots.clear()
        try fillet_section(tb, tc, cross, continuity, &curves, &knots)
        try sides.push(HoleSide(false, face_outward(w, faces[i])))
    try corner_patch(curves.view(), knots.view(), sides.view(), continuity, quads, quad_knots)
    let slack = radius * 1e-9
    let cone = try corner_cone(w, corner, radius)
    for q in quads.view():
        for i in 0..<(usize)3:
            if q.subtract(p).dot(cone[i]) < -slack or q.subtract(p).dot(corner.ways[i]) > corner.distances[i] + slack:
                error(invalid, "the G2 corner patch would leave its corner: use G1 there")

## The corner tool's B-rep: the six quads, a cap on each setback plane and
## a piece of each face, between corner `p` and the patch.
func corner_solid(p: Vector3, corner: const Setback*, quads: const Vector3[], cone: const Vector3[], knots: const f64[], m: usize, name: str) -> interop.Reference[CadModel]!:
    let size = (quads[0].subtract(p)).length() * 4.0
    let solid = try BrepModel.sized(size)
    defer solid.release()
    let b = solid.value()
    let mm = m * m
    let apex = try b.add_vertex(p)
    var feet: i64[3] = [0, 0, 0]
    for i in 0..<(usize)3: feet[i] = try b.add_vertex(p.add(corner.ways[i].multiply_scalar(corner.distances[i])))
    # The hole's corners (quad k's corner (0, 0)), its curves' middles
    # (quad k's (1, 0)) and the center.
    var corners: i64[6] = [0, 0, 0, 0, 0, 0]
    var middles: i64[6] = [0, 0, 0, 0, 0, 0]
    for k in 0..<(usize)6:
        corners[k] = try b.add_vertex(quads[k * mm])
        middles[k] = try b.add_vertex(quads[k * mm + (m - 1) * m])
    let center = try b.add_vertex(quads[mm - 1])
    var lines: i64[3] = [0, 0, 0]
    var toward_before: i64[3] = [0, 0, 0]
    var toward_after: i64[3] = [0, 0, 0]
    for i in 0..<(usize)3:
        lines[i] = try b.add_line(apex, feet[i])
        toward_before[i] = try b.add_line(feet[i], corners[i * 2])
        toward_after[i] = try b.add_line(feet[i], corners[i * 2 + 1])
    # Each curve's halves and each seam, from the quads' own rows (a half
    # run from the middle back takes the knots reversed).
    var reversed = Growing[f64]()
    defer reversed.close()
    var k_ = knots.length
    while k_ > 0:
        k_ -= 1
        try reversed.push(1.0 - knots[k_])
    var weights = Growing[f64]()
    defer weights.close()
    try weights.fill(mm, 1.0)
    var net = Growing[Vector3]()
    defer net.close()
    var firsts: i64[6] = [0, 0, 0, 0, 0, 0]
    var seconds: i64[6] = [0, 0, 0, 0, 0, 0]
    var seams: i64[6] = [0, 0, 0, 0, 0, 0]
    for k in 0..<(usize)6:
        let next = (k + 1) % 6
        net.clear()
        for a in 0..<m: try net.push(quads[k * mm + a * m])
        firsts[k] = try b.add_spline_edge(corners[k], middles[k], net.view(), weights.view()[..<m], 5, knots, true)
        net.clear()
        for b_ in 0..<m: try net.push(quads[next * mm + m - 1 - b_])
        seconds[k] = try b.add_spline_edge(middles[k], corners[next], net.view(), weights.view()[..<m], 5, reversed.view(), true)
        net.clear()
        for b_ in 0..<m: try net.push(quads[k * mm + (m - 1) * m + b_])
        seams[k] = try b.add_spline_edge(middles[k], center, net.view(), weights.view()[..<m], 5, knots, true)
    # The quads: outward (away from the corner) is du x dv or against it.
    var bu: f64[36]
    var bv: f64[36]
    spline_basis(knots, 0.75, bu[..<36])
    spline_basis(knots, 0.75, bv[..<36])
    let sizes: i64[1] = [4]
    for k in 0..<(usize)6:
        let before = (k + 5) % 6
        var du = Vector3()
        var dv = Vector3()
        var at = Vector3()
        for a in 0..<m:
            for b_ in 0..<m:
                let q = quads[k * mm + a * m + b_]
                du = du.add(q.multiply_scalar(bu[9 + a] * bv[b_]))
                dv = dv.add(q.multiply_scalar(bu[a] * bv[9 + b_]))
                at = at.add(q.multiply_scalar(bu[a] * bv[b_]))
        let surface = try b.add_spline_surface(quads[k * mm..<(k + 1) * mm], weights.view(), (i64)m, (i64)m, 5, 5, knots, knots)
        let outward = du.cross(dv).dot(at.subtract(p)) > 0.0
        let forward: i64[4] = [firsts[k] + 1, seams[k] + 1, -(seams[before] + 1), seconds[before] + 1]
        let backward: i64[4] = [-(seconds[before] + 1), seams[before] + 1, -(seams[k] + 1), -(firsts[k] + 1)]
        var face: i64 = 0
        if outward: face = try b.add_face(surface, forward[..<4], sizes[..<1], true)
        else: face = try b.add_face(surface, backward[..<4], sizes[..<1], false)
        try b.set_face_name(face, name)
    # The caps, outward along each edge, and the faces' pieces, outward
    # away from the corner's inside.
    for i in 0..<(usize)3:
        let foot = p.add(corner.ways[i].multiply_scalar(corner.distances[i]))
        let uses: i64[4] = [toward_before[i] + 1, firsts[i * 2] + 1, seconds[i * 2] + 1, -(toward_after[i] + 1)]
        let around: Vector3[4] = [foot, quads[i * 2 * mm], quads[i * 2 * mm + (m - 1) * m], quads[(i * 2 + 1) * mm]]
        try flat_face(b, foot, corner.ways[i], uses[..<4], around[..<4])
    for i in 0..<(usize)3:
        let next = (i + 1) % 3
        let uses: i64[6] = [lines[i] + 1, toward_after[i] + 1, firsts[i * 2 + 1] + 1, seconds[i * 2 + 1] + 1, -(toward_before[next] + 1), -(lines[next] + 1)]
        let around: Vector3[6] = [p, p.add(corner.ways[i].multiply_scalar(corner.distances[i])), quads[(i * 2 + 1) * mm], quads[(i * 2 + 1) * mm + (m - 1) * m],
                                  quads[(i * 2 + 2) % 6 * mm], p.add(corner.ways[next].multiply_scalar(corner.distances[next]))]
        try flat_face(b, p, cone[i].multiply_scalar(-1.0), uses[..<6], around[..<6])
    return try CadModel.of_brep(solid)

## A flat face of `b` through `origin`, outward `normal`, bounded by
## `uses`: their order reversed when the points `around` them (their
## starts) turn the other way about the normal.
func flat_face(b: BrepModel*, origin: Vector3, normal: Vector3, uses: const i64[], around: const Vector3[]) -> !:
    # Newell's normal of the loop.
    var turn = Vector3()
    for k in 0..<around.length:
        let a = around[k]
        let c = around[(k + 1) % around.length]
        turn = turn.add(Vector3((a.y - c.y) * (a.z + c.z), (a.z - c.z) * (a.x + c.x), (a.x - c.x) * (a.y + c.y)))
    var loop = Growing[i64]()
    defer loop.close()
    if turn.dot(normal) > 0.0:
        try loop.assign(uses)
    else:
        var k = uses.length
        while k > 0:
            k -= 1
            try loop.push(-uses[k])
    let plane = try b.add_surface(0, origin, normal, try across(normal))
    let sizes: i64[1] = [(i64)uses.length]
    _ = try b.add_face(plane, loop.view(), sizes[..<1])