Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / modeling / local_blend_result.lucb

## Writing a direct fillet's result (local_blend.lucb): the body's faces
## with their loops rebuilt around the strips and corners, the strips' and
## corners' faces, every loop oriented, as a new B-rep.

## The result's faces and B-rep: the body's faces rebuilt (or copied),
## the strips', the corners'; turned to agree and checked closed.
func local_result(b: Local*, tag: str) -> interop.Reference[CadModel]!:
    let w = b.w
    var uses = Growing[i64]()
    defer uses.close()
    var sizes = Growing[i64]()
    defer sizes.close()
    # Faces of the body.
    for f in 0..<w.faces.count:
        uses.clear()
        sizes.clear()
        let face_uses = w.face_uses(f)
        var at: usize = 0
        for size in w.face_sizes(f):
            let before = uses.count
            try rebuild_loop(b, f, face_uses[at..<at + (usize)size], &uses)
            try sizes.push((i64)(uses.count - before))
            at += (usize)size
        let face = w.faces.items[f]
        try b.out.add_face(face.surface, face.sense, uses.view(), sizes.view(), try b.out.add_name(w.face_name(f)))
    let fixed = b.out.faces.count
    # The strips.
    for s in 0..<b.strips.count:
        let strip = b.strips.items[s]
        uses.clear()
        let line0 = strip.lines[0]
        let line1 = strip.lines[1]
        if line0 < 0 or line1 < 0: error(invalid, "a fillet's contact line was not made")
        try uses.push(line0 + 1)
        try b.walk((usize)strip.sections[1], strip.contacts[2], &uses)
        try uses.push(-(line1 + 1))
        try b.walk((usize)strip.sections[0], strip.contacts[1], &uses)
        sizes.clear()
        try sizes.push((i64)uses.count)
        b.name.clear()
        try blend_name(w, strip.edge, tag, &b.name)
        try b.out.add_face(strip.surface, strip.sense, uses.view(), sizes.view(), try b.out.add_name((str)b.name.view()))
    # The corners'.
    for extra in b.extras.view():
        sizes.clear()
        try sizes.push((i64)extra.count)
        try b.out.add_face(extra.surface, extra.sense, b.store.view()[extra.first..<extra.first + extra.count], sizes.view(), extra.name)
    try orient(&b.out, fixed)
    let solid = try used_brep(&b.out)
    defer solid.release()
    return try CadModel.of_brep(solid)

## Body face `f`'s loop `loop` rebuilt onto `out`: each edge as it now
## runs (a chosen one by its contact line), and at each corner the curves
## the corner leaves on the face.
func rebuild_loop(b: Local*, f: usize, loop: const i64[], out: Growing[i64]*) -> !:
    let w = b.w
    let n = loop.length
    for k in 0..<n:
        let use = loop[k]
        let e = edge_index(use)
        let edge = w.edges.items[e]
        let forward = use > 0
        let tail = edge.end if forward else edge.start
        # This use, then what the corner at its tail leaves on the face.
        let (id, tail_point) = try edge_on_face(b, e, f, forward)
        try out.push((id + 1) if forward else -(id + 1))
        let next_use = loop[(k + 1) % n]
        let next_e = edge_index(next_use)
        let next_point = try head_point(b, next_e, f, next_use > 0)
        if next_point == tail_point: continue
        var linked = false
        for link in b.links.view():
            if link.vertex != tail or link.face != f: continue
            try b.walk(link.chain, tail_point, out)
            if b.other_end(link.chain, tail_point) != next_point: error(invalid, "a corner's curve on a face does not reach the next edge")
            linked = true
            break
        if not linked: error(invalid, "a face's loop does not close at a corner")

## Body edge `e` on face `f` as the result has it, and the out point its
## use ends at (`forward`: from its start to its end): a chosen edge's
## contact line on `f`; a sharp edge, shortened at a rounded corner, or as
## it was.
func edge_on_face(b: Local*, e: usize, f: usize, forward: bool) -> (i64, i64)!:
    let w = b.w
    let s = b.strip_of.items[e]
    if s >= 0:
        let strip = &b.strips.items[(usize)s]
        let side: usize = 0 if strip.faces[0] == f else 1
        if strip.lines[side] < 0:
            # The contact line must keep the edge's way: else the corners
            # at its ends overlap (the radius is too large for it).
            if b.at(strip.contacts[2 + side]).subtract(b.at(strip.contacts[side])).dot(strip.along) <= b.w.tolerance: error(invalid, "a fillet's contact line has no length left")
            strip.lines[side] = try b.line(strip.contacts[side], strip.contacts[2 + side])
        return (strip.lines[side], strip.contacts[2 + side] if forward else strip.contacts[side])
    let edge = w.edges.items[e]
    let start = b.ends.items[e * 2] if b.ends.items[e * 2] >= 0 else try b.point(edge.start)
    let end = b.ends.items[e * 2 + 1] if b.ends.items[e * 2 + 1] >= 0 else try b.point(edge.end)
    if b.kept.items[e] < 0:
        if b.ends.items[e * 2] < 0 and b.ends.items[e * 2 + 1] < 0:
            b.kept.items[e] = try b.out.add_edge(ShapeEdge(edge.carrier, edge.t0, edge.t1, start, end))
        else:
            if w.carriers.items[(usize)edge.carrier].kind != curve_line: error(invalid, "a curved sharp edge meets a rounded corner")
            # Shortened, it must keep its way.
            let before = w.points.items[(usize)edge.end].subtract(w.points.items[(usize)edge.start])
            if b.at(end).subtract(b.at(start)).dot(before) <= 0.0: error(invalid, "a fillet consumes an edge")
            b.kept.items[e] = try b.line(start, end)
    return (b.kept.items[e], end if forward else start)

## The out point body edge `e`'s use on face `f` starts at.
func head_point(b: Local*, e: usize, f: usize, forward: bool) -> i64!:
    let s = b.strip_of.items[e]
    if s >= 0:
        let strip = b.strips.items[(usize)s]
        let side: usize = 0 if strip.faces[0] == f else 1
        return strip.contacts[side] if forward else strip.contacts[2 + side]
    let edge = b.w.edges.items[e]
    if forward: return b.ends.items[e * 2] if b.ends.items[e * 2] >= 0 else try b.point(edge.start)
    return b.ends.items[e * 2 + 1] if b.ends.items[e * 2 + 1] >= 0 else try b.point(edge.end)

## Faces after the first `fixed` turned to agree with their neighbors
## (each edge used once each way), from the fixed ones outward; then every
## edge checked to be used twice, once each way.
## With `open`, an edge may be used once (an open body's boundary).
func orient(s: Shape*, fixed: usize, open: bool = false) -> !:
    let faces = s.faces.count
    var done = Growing[bool]()
    defer done.close()
    try done.fill(faces, false)
    for f in 0..<fixed: done.items[f] = true
    # Each edge's signed use by an oriented face (0: none yet).
    var signs = Growing[i64]()
    defer signs.close()
    try signs.fill(s.edges.count, 0)
    for f in 0..<fixed:
        for use in s.face_uses(f): signs.items[edge_index(use)] = 1 if use > 0 else -1
    var progress = true
    while progress:
        progress = false
        for f in fixed..<faces:
            if done.items[f]: continue
            var vote = 0
            for use in s.face_uses(f):
                let sign = signs.items[edge_index(use)]
                if sign == 0: continue
                vote = -1 if sign == (1 if use > 0 else -1) else 1
                break
            if vote == 0: continue
            if vote < 0:
                # Each loop backwards.
                let face = s.faces.items[f]
                var at = face.first
                for size in s.face_sizes(f):
                    let count = (usize)size
                    for k in 0..<count // 2:
                        let left = s.uses.items[at + k]
                        s.uses.items[at + k] = -s.uses.items[at + count - 1 - k]
                        s.uses.items[at + count - 1 - k] = -left
                    if count % 2 == 1: s.uses.items[at + count // 2] = -s.uses.items[at + count // 2]
                    at += count
            for use in s.face_uses(f): signs.items[edge_index(use)] = 1 if use > 0 else -1
            done.items[f] = true
            progress = true
    for f in 0..<faces:
        if not done.items[f]: error(invalid, "a direct fillet's face touches nothing")
    var count = Growing[i64]()
    defer count.close()
    try count.fill(s.edges.count * 2, 0)
    for f in 0..<faces:
        for use in s.face_uses(f):
            let e = edge_index(use)
            count.items[e * 2 + (0 if use > 0 else 1)] += 1
    for e in 0..<s.edges.count:
        let forward = count.items[e * 2]
        let backward = count.items[e * 2 + 1]
        if forward + backward == 0: continue
        if open and forward + backward == 1: continue
        if forward != 1 or backward != 1: error(invalid, "a direct fillet is not closed")

## `s` as a B-rep, its points, edges and surfaces only where faces use them.
func used_brep(s: const Shape*) -> interop.Reference[BrepModel]!:
    var all = Growing[bool]()
    defer all.close()
    try all.fill(s.faces.count, true)
    return try kept_brep(s, all.view())

## The faces of `s` that `keep` marks as a B-rep, with only the points,
## edges and surfaces they use.
func kept_brep(s: const Shape*, keep: const bool[]) -> interop.Reference[BrepModel]!:
    let output = try BrepModel.held(s.tolerances, math.max(s.display, least_tolerance))
    errdefer output.release()
    let b = output.value()
    var points = Growing[i64]()
    defer points.close()
    try points.fill(s.points.count, -1)
    var edges = Growing[i64]()
    defer edges.close()
    try edges.fill(s.edges.count, -1)
    var surfaces = Growing[i64]()
    defer surfaces.close()
    try surfaces.fill(s.surfaces.count, -1)
    var uses = Growing[i64]()
    defer uses.close()
    for f in 0..<s.faces.count:
        if not keep[f]: continue
        uses.clear()
        for use in s.face_uses(f):
            let e = edge_index(use)
            if edges.items[e] < 0:
                let edge = s.edges.items[e]
                let ends: i64[2] = [edge.start, edge.end]
                for v in ends:
                    if points.items[(usize)v] >= 0: continue
                    points.items[(usize)v] = try b.add_vertex(s.points.items[(usize)v])
                    # Tolerant vertices and edges stay tolerant (as brep_of).
                    if s.point_slack_of((usize)v) > b.base_tolerance(): try b.set_vertex_precision(points.items[(usize)v], s.point_slack_of((usize)v))
                let start = points.items[(usize)edge.start]
                let end = points.items[(usize)edge.end]
                let c = s.carriers.items[(usize)edge.carrier]
                let forward = edge.t1 > edge.t0
                if c.kind == curve_line: edges.items[e] = try b.add_line(start, end)
                elif c.kind == curve_circle: edges.items[e] = try b.add_circle(start, end, c.origin, c.x.cross(c.y), c.x, c.a, forward)
                elif c.kind == curve_ellipse: edges.items[e] = try b.add_ellipse(start, end, c.origin, c.x.cross(c.y), c.x, c.a, c.b, forward)
                else:
                    let (net, weights, knots, degree) = s.spline_net(c.spline)
                    edges.items[e] = try b.add_spline_edge(start, end, net, weights, degree, knots, forward)
                if s.edge_slack_of(e) > b.base_tolerance(): try b.set_edge_precision(edges.items[e], s.edge_slack_of(e))
            try uses.push((edges.items[e] + 1) * (1 if use > 0 else -1))
        let face = s.faces.items[f]
        let si = (usize)face.surface
        if surfaces.items[si] < 0:
            let su = s.surfaces.items[si]
            surfaces.items[si] = (try b.add_spline_surface(su.points, su.weights, su.nu, su.nv, su.du, su.dv, su.ku, su.kv)) if su.kind == surface_spline else (try b.add_surface(su.kind, su.origin, su.z, su.x, su.radius, su.angle))
        let made = try b.add_face(surfaces.items[si], uses.view(), s.face_sizes(f), face.sense)
        try b.set_face_name(made, s.face_name(f))
    return output