Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.5

0.9.5 / src / surfacing / sheets.lucb

## Set Planar, and the sheet Extrude and Revolve of free curves (surfacing
## Stage 5: Alias's Set Planar, Extrude and Revolve; Rhino's PlanarSrf,
## ExtrudeCrv and Revolve; §4.6 and §6.6 of luced-3d's
## docs/research/SURFACING-ALIAS-PLASTICITY.md).
##
## Set Planar fills closed curves lying in one plane: a plane face wide
## enough is trimmed by the curves (trim.lucb, as Trim does), keeping the
## regions inside an odd number of them, so a curve inside another is a
## hole. Extrude carries a curve along a direction (degree 1 that way: the
## curve's own control points moved), and Revolve turns it about an axis
## (each control point round its own circle, rational quadratic arcs): both
## exact, a sheet per curve, joined where they meet.

## Set Planar: curves off their plane by more than `planar_share` of their
## size do not lie in one; the sheet reaches past them by a fifth and by
## `planar_margin` of their size. Revolve may pass a whole turn by this
## (degrees: rounding in the angles given).
let planar_share: f64 = 1e-4
let planar_margin: f64 = 0.05
let whole_turn_degrees: f64 = 1e-9

## A plane face square to `normal` through `center`, `x` one of its sides'
## directions, `half` x `half_y` either way: a body of one face named
## `name`.
func plane_rectangle(tolerances: CadTolerances, center: Vector3, normal: Vector3, x: Vector3, half: f64, half_y: f64, name: str) -> interop.Reference[CadModel]!:
    let y = normal.cross(x)
    let output = try BrepModel.held(tolerances)
    defer output.release()
    let b = output.value()
    var corners: i64[4] = [0, 0, 0, 0]
    let xs: f64[4] = [-half, half, half, -half]
    let ys: f64[4] = [-half_y, -half_y, half_y, half_y]
    for k in 0..<(usize)4: corners[k] = try b.add_vertex(center.add(x.multiply_scalar(xs[k])).add(y.multiply_scalar(ys[k])))
    var loop: i64[4] = [0, 0, 0, 0]
    for k in 0..<(usize)4: loop[k] = (try b.add_line(corners[k], corners[(k + 1) % 4])) + 1
    let plane = try b.add_surface(surface_plane, center, normal, x)
    let sizes: i64[1] = [4]
    let made = try b.add_face(plane, loop[..<4], sizes[..<1])
    try b.set_face_name(made, name)
    return try CadModel.of_brep(output)

## Whether (x, y) lies inside the closed polygon `xs`, `ys` (even-odd).
func inside_polygon(xs: const f64[], ys: const f64[], x: f64, y: f64) -> bool:
    var inside = false
    var j = xs.length - 1
    for i in 0..<xs.length:
        if (ys[i] > y) != (ys[j] > y):
            let cross = xs[j] + (y - ys[j]) * (xs[i] - xs[j]) / (ys[i] - ys[j])
            if x < cross: inside = not inside
        j = i
    return inside

## Set Planar of the curves `words` (Align's master words apart by `;`):
## a body of one trimmed plane face named `name`.
func set_planar(tolerances: CadTolerances, set: interop.Reference[GeometrySet], words: str, name: str) -> interop.Reference[CadModel]!:
    var masters = Growing[Master]()
    defer close_masters(&masters)
    try builder_masters(set, words, &masters)
    if masters.count == 0: error(invalid, "Set Planar: pick the closed curves to fill")
    var curves = Growing[Spline]()
    defer close_splines_of(&curves)
    for m in masters.view(): try curves.push(try m.curve.copy())
    let size = curves_size(curves.view())
    # The plane: Newell's normal of the curves' samples, through their middle.
    let samples: usize = 128
    var points = Growing[Vector3]()
    defer points.close()
    var normal = Vector3()
    var center = Vector3()
    for c in curves.view():
        let first = points.count
        for k in 0..<samples:
            try points.push(c.point_at(c.low() + (c.high() - c.low()) * (f64)k / (f64)samples))
        for k in 0..<samples:
            let a = points.items[first + k]
            let b = points.items[first + (k + 1) % samples]
            normal = normal.add(Vector3((a.y - b.y) * (a.z + b.z), (a.z - b.z) * (a.x + b.x), (a.x - b.x) * (a.y + b.y)))
    for p in points.view(): center = center.add(p)
    center = center.multiply_scalar(1.0 / (f64)points.count)
    let n = normal.normalized() catch failure: error(invalid, "Set Planar: the curves enclose no area (pick closed curves)")
    var off = 0.0
    for p in points.view(): off = math.max(off, math.abs(p.subtract(center).dot(n)))
    let precision = math.max(size * fit_share, off)
    if off > size * planar_share:
        var buffer: u8[160]
        error(invalid, try strings.format(buffer, f"Set Planar: the curves do not lie in one plane (one lies {off:.6f} off it)"))
    let x = try square_to(n)
    let y = n.cross(x)
    var reach_x = 0.0
    var reach_y = 0.0
    for p in points.view():
        reach_x = math.max(reach_x, math.abs(p.subtract(center).dot(x)))
        reach_y = math.max(reach_y, math.abs(p.subtract(center).dot(y)))
    let sheet = try plane_rectangle(tolerances, center, n, x, reach_x * 1.2 + size * planar_margin, reach_y * 1.2 + size * planar_margin, name)
    defer sheet.release()
    # The curves, cast onto the plane, cut it.
    var w = try shape_of(sheet.value())
    defer w.close()
    var cuts = empty_shape(w.tolerances, w.tolerance)
    defer cuts.close()
    for c in curves.view():
        var flat = Growing[Vector3]()
        defer flat.close()
        var weights = Growing[f64]()
        defer weights.close()
        for q in c.points.view():
            let p = q.point()
            try flat.push(p.subtract(n.multiply_scalar(p.subtract(center).dot(n))))
            try weights.push(q.w)
        let stored = try cuts.add_spline(flat.view(), weights.view(), c.knots.view(), c.degree)
        _ = try cuts.add_carrier(Carrier(curve_spline, Vector3(), Vector3(), Vector3(), 0.0, 0.0, stored))
    var regions = try trim_regions(sheet.value(), name, &cuts)
    defer regions.close()
    if regions.loose.count > 0: error(invalid, "Set Planar: a curve does not close (its ends meet nothing); pick closed curves")
    # Inside an odd number of the curves: kept.
    var picks = Growing[Vector3]()
    defer picks.close()
    for marker in regions.markers.view():
        var count = 0
        var at: usize = 0
        for _ in curves.view():
            var xs = Growing[f64]()
            defer xs.close()
            var ys = Growing[f64]()
            defer ys.close()
            for k in 0..<samples:
                let d = points.items[at + k].subtract(center)
                try xs.push(d.dot(x))
                try ys.push(d.dot(y))
            let m = marker.subtract(center)
            if inside_polygon(xs.view(), ys.view(), m.dot(x), m.dot(y)): count += 1
            at += samples
        if count % 2 == 1: try picks.push(marker)
    if picks.count == 0: error(invalid, "Set Planar: the curves enclose nothing (pick closed curves)")
    return try trim_face(sheet.value(), name, &cuts, picks.view(), 0, name, precision)

## The sheets the curves `words` sweep (Extrude along `direction` by
## `distance`, from `-distance` with `both`; or Revolve about the axis
## through `origin` along `axis` from `start` to `end` degrees), joined
## where they meet: a body named `name` (its faces `name`, `name`2, ...).
func swept_sheets(tolerances: CadTolerances, set: interop.Reference[GeometrySet], words: str, revolve: bool, direction: Vector3, distance: f64, both: bool, origin: Vector3, axis: Vector3,
                  start: f64, end: f64, name: str) -> interop.Reference[CadModel]!:
    var masters = Growing[Master]()
    defer close_masters(&masters)
    try builder_masters(set, words, &masters)
    if masters.count == 0: error(invalid, "pick the curves to sweep")
    var bodies = Growing[interop.Reference[CadModel]]()
    defer:
        for m in bodies.view(): m.release()
        bodies.close()
    var size = 0.0
    for at in 0..<masters.count:
        let c = &masters.items[at].curve
        var net = empty_net()
        defer net.close()
        net.du = c.degree
        net.nu = c.points.count
        try net.ku.assign(c.knots.view())
        if revolve:
            let a = axis.normalized() catch failure: error(invalid, "Revolve: the axis needs a direction")
            if not (end > start): error(invalid, "Revolve: the end angle must pass the start")
            if end - start > 360.0 + whole_turn_degrees: error(invalid, "Revolve turns a whole turn at most")
            var arc = Growing[Vector3]()
            defer arc.close()
            var arc_weights = Growing[f64]()
            defer arc_weights.close()
            var arc_knots = Growing[f64]()
            defer arc_knots.close()
            try arc_spline(start * math.pi / 180.0, end * math.pi / 180.0, &arc, &arc_weights, &arc_knots)
            net.dv = 2
            net.nv = arc.count
            for k in 0..<arc_knots.count: try net.kv.push((arc_knots.items[k] - arc_knots.items[0]) / (arc_knots.items[arc_knots.count - 1] - arc_knots.items[0]))
            for q in c.points.view():
                let p = q.point()
                let foot = origin.add(a.multiply_scalar(p.subtract(origin).dot(a)))
                let radial = p.subtract(foot)
                let side = a.cross(radial)
                for k in 0..<arc.count:
                    let r = arc.items[k]
                    try net.points.push(weighted(foot.add(radial.multiply_scalar(r.x)).add(side.multiply_scalar(r.y)), q.w * arc_weights.items[k]))
        else:
            let d = direction.normalized() catch failure: error(invalid, "Extrude: the direction needs a length")
            if not (distance > 0.0): error(invalid, "Extrude: the distance must be more than zero")
            let low = -distance if both else 0.0
            net.dv = 1
            net.nv = 2
            let linear: f64[4] = [0.0, 0.0, 1.0, 1.0]
            try net.kv.assign(linear[..<4])
            for q in c.points.view():
                let p = q.point()
                try net.points.push(weighted(p.add(d.multiply_scalar(low)), q.w))
                try net.points.push(weighted(p.add(d.multiply_scalar(distance)), q.w))
        size = math.max(size, size_of(c))
        var buffer: u8[128]
        let face_name = name if at == 0 else try strings.format(buffer, f"{name}{at + 1}")
        try bodies.push(try net_body(tolerances, &net, face_name, true))
    if bodies.count == 1: return bodies.items[0].clone()
    let sewn = try stitch_models(bodies.view(), size * fit_share)
    return sewn.model