Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.9

0.7.9 / src / curves / sketch.lucb

## Luce's Edit Sketch operations: planar sketches as curves. Shapes (line,
## polyline, arc, circle, rectangle, spline) are made on the set's sketch
## plane (sketch_pick.lucb);
## steps name control points, segments or curves by a group on the pick
## cloud they were made on (sketch_pick.lucb) and move, delete, close, open
## or snap them. Every change of positions goes through `placed_curves`, the
## one place a constraint solver would adjust targets before they land.
## Other components of the set pass through.

pub struct Sketches:
    let reserved: u8 = 0

    ## The sketch plane: its origin, normal and in-plane axes.
    pub static func plane_origin(geometry: interop.Reference[GeometrySet]) -> Vector3!:
        return (try sketch_plane_of(try geometry.get())).origin

    pub static func plane_normal(geometry: interop.Reference[GeometrySet]) -> Vector3!:
        return (try sketch_plane_of(try geometry.get())).normal

    pub static func plane_u(geometry: interop.Reference[GeometrySet]) -> Vector3!:
        return (try sketch_plane_of(try geometry.get())).u

    pub static func plane_v(geometry: interop.Reference[GeometrySet]) -> Vector3!:
        return (try sketch_plane_of(try geometry.get())).v

    ## The set with its sketch plane through `origin` facing `normal`
    ## (curves already drawn stay where they are).
    pub static func with_plane(geometry: interop.Reference[GeometrySet], origin: Vector3, normal: Vector3) -> interop.Reference[GeometrySet]!:
        let plane = try SketchPlane.of(origin, normal)
        let placed = try geometry.value().with_detail("sketch.plane_origin", [plane.origin.x, plane.origin.y, plane.origin.z], 1)
        defer placed.release()
        return try placed.value().with_detail("sketch.plane_normal", [plane.normal.x, plane.normal.y, plane.normal.z], 3)

    pub static func curve_count(geometry: interop.Reference[GeometrySet]) -> i64!:
        let curves = set_curves(try geometry.get()) else return 0
        return (i64)curves.curve_count()

    ## The set with shape `shape` added on its sketch plane, centred at plane
    ## coordinates (`a`, `b`): 0 a line (length), 1 a polyline (width,
    ## height), 2 an arc (radius, start and end degrees), 3 a circle
    ## (radius), 4 a rectangle (width, height), 5 a spline (width, height).
    ## Arcs and circles are exact NURBS; the spline is a cubic NURBS.
    pub static func with_shape(geometry: interop.Reference[GeometrySet], shape: i64, sizes: const f64[], a: f64, b: f64) -> interop.Reference[GeometrySet]!:
        let source = try geometry.get()
        let existing = set_curves(source)
        let plane = try sketch_plane_of(source)
        let first = sized(sizes, 0, 2.0)
        let second = sized(sizes, 1, 1.0)
        var out = CurvesBuilder()
        defer out.close()
        if let curves = existing:
            for curve in 0..<curves.curve_count(): try out.copy_curve(curves, curve)
        if shape == 2 or shape == 3:
            var arc = Owned(try arc_curves(first, sized(sizes, 1, 0.0) if shape == 2 else 0.0, sized(sizes, 2, 90.0) if shape == 2 else 360.0, 1, 2, 0, default_resolution))
            defer arc.release()
            try copy_onto(&out, arc.value(), plane, a, b)
        elif shape == 0:
            try out.begin(CurveType.poly)
            try out.point(plane.at(a - first * 0.5, b))
            try out.point(plane.at(a + first * 0.5, b))
        elif shape == 4:
            try out.begin(CurveType.poly, true)
            for corner in 0..<(usize)4:
                let sx = 0.5 if corner == 1 or corner == 2 else -0.5
                let sy = 0.5 if corner >= 2 else -0.5
                try out.point(plane.at(a + first * sx, b + second * sy))
        elif shape == 1 or shape == 5:
            try out.begin(CurveType.nurbs if shape == 5 else CurveType.poly)
            let steps: f64[4] = [-0.5, -0.1666666666666667, 0.1666666666666667, 0.5]
            for at in 0..<(usize)4:
                try out.point(plane.at(a + first * steps[at], b + second * (0.5 if at % 2 == 1 else -0.5)))
        else:
            error(errors.invalid, "a sketch shape is 0..5")
        let made = try out.finish(existing)
        return try adopt_set(try with_curves(source, made))

    ## What level `level` picks on: 0 Object and 1 Segments the sample cloud,
    ## 2 Points the control points (an empty mesh without curves).
    pub static func pick(geometry: interop.Reference[GeometrySet], level: i64) -> interop.Reference[Mesh]!:
        let curves = set_curves(try geometry.get()) else return try Mesh.empty()
        if level == 2: return try control_cloud(curves)
        return try sample_cloud(curves)

    ## The set with what `group` names (on `group_type`, see SketchChoice)
    ## moved by Transform Components' numbers; the translation stays in the
    ## sketch plane. The centroid pivot is the picked points'. Edit Sketch's
    ## snapping follows the fifteen numbers: a grid spacing (the moved
    ## points land on the plane's grid) and an end reach (a moved end of an
    ## open curve lands on an unmoved end within it); 0 is off.
    pub static func moved(geometry: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, group_type: i64, numbers: const f64[]) -> interop.Reference[GeometrySet]!:
        let source = try geometry.get()
        let curves = set_curves(source) else error(errors.invalid, "Edit Sketch has no curves to move")
        var chosen = try SketchChoice.of(curves, try pick.get(), group, group_type)
        defer chosen.close()
        let plane = try sketch_plane_of(source)
        let transform = try ComponentTransform.of(numbers, chosen.centroid)
        let linear = transform.linear
        # The translation stays in the plane.
        let shift = transform.translation.subtract(plane.normal.multiply_scalar(transform.translation.dot(plane.normal)))
        let delta = transform.matrix(shift)
        var targets = Growing[Vector3]()
        defer targets.close()
        let grid = numbers[15] if numbers.length > 15 else 0.0
        let reach = numbers[16] if numbers.length > 16 else 0.0
        for at in 0..<curves.point_count():
            let here = curves.point(at)
            if not chosen.points.items[at]:
                try targets.push(here)
                continue
            let moved = delta.transform_point(here)
            try targets.push(on_grid(plane, moved, grid) if grid > 0.0 else moved)
        if reach > 0.0:
            var ends = try EndHash.of(curves, reach)
            defer ends.close()
            for end in ends.ends.view():
                if not chosen.points.items[end]: continue
                let other = ends.nearest(targets.items[end], reach, chosen.points.view(), end, false)
                if other >= 0: targets.items[end] = curves.point((usize)other)
        return try adopt_set(try with_curves(source, try placed_curves(curves, targets.view(), chosen.points.view(), linear)))

    ## The set with the chosen control points snapped to a grid of
    ## `spacing` in the sketch plane (their height off it kept).
    pub static func snapped(geometry: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, group_type: i64, spacing: f64) -> interop.Reference[GeometrySet]!:
        if not (spacing > 0.0): error(errors.invalid, "a grid needs a positive spacing")
        let source = try geometry.get()
        let curves = set_curves(source) else error(errors.invalid, "Edit Sketch has no curves to snap")
        var chosen = try SketchChoice.of(curves, try pick.get(), group, group_type)
        defer chosen.close()
        let plane = try sketch_plane_of(source)
        var targets = Growing[Vector3]()
        defer targets.close()
        for at in 0..<curves.point_count():
            let here = curves.point(at)
            if not chosen.points.items[at]:
                try targets.push(here)
                continue
            try targets.push(on_grid(plane, here, spacing))
        return try adopt_set(try with_curves(source, try placed_curves(curves, targets.view(), chosen.points.view(), Matrix4())))

    ## The set with each chosen end point of an open curve moved onto the
    ## nearest end point of another curve (or its own other end) within
    ## `tolerance`.
    pub static func joined(geometry: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, group_type: i64, tolerance: f64) -> interop.Reference[GeometrySet]!:
        if not (tolerance > 0.0): error(errors.invalid, "snapping ends needs a positive tolerance")
        let source = try geometry.get()
        let curves = set_curves(source) else error(errors.invalid, "Edit Sketch has no curves to join")
        var chosen = try SketchChoice.of(curves, try pick.get(), group, group_type)
        defer chosen.close()
        var ends = try EndHash.of(curves, tolerance)
        defer ends.close()
        var targets = Growing[Vector3]()
        defer targets.close()
        for at in 0..<curves.point_count(): try targets.push(curves.point(at))
        for end in ends.ends.view():
            if not chosen.points.items[end]: continue
            let other = ends.nearest(curves.point(end), tolerance, chosen.points.view(), end, true)
            if other >= 0: targets.items[end] = curves.point((usize)other)
        return try adopt_set(try with_curves(source, try placed_curves(curves, targets.view(), chosen.points.view(), Matrix4())))

    ## The set without what `group` names: control points (their curves keep
    ## the rest), segments (open curves split there; closed ones open) or
    ## whole curves. Curves left under two points go.
    pub static func without(geometry: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, group_type: i64) -> interop.Reference[GeometrySet]!:
        let source = try geometry.get()
        let curves = set_curves(source) else error(errors.invalid, "Edit Sketch has no curves to delete")
        var chosen = try SketchChoice.of(curves, try pick.get(), group, group_type)
        defer chosen.close()
        var out = CurvesBuilder()
        defer out.close()
        var run = Growing[usize]()
        defer run.close()
        var segment_base: usize = 0
        for curve in 0..<curves.curve_count():
            let (first, points) = curves.range(curve)
            let cyclic = curves.settings(curve).cyclic
            let segments = segment_count(curves, curve)
            let base = segment_base
            segment_base += segments
            if not chosen.curves.items[curve]:
                try out.copy_curve(curves, curve)
                continue
            if group_type == 3: continue
            if group_type == 1:
                run.clear()
                for at in first..<first + points:
                    if not chosen.points.items[at]: try run.push(at)
                if run.count >= 2: try copy_points(&out, curves, curve, run.view(), cyclic and run.count >= 3)
                continue
            # Segments: runs of kept segments become curves, a closed curve
            # starting after its first removed segment.
            var start: usize = 0
            while start < segments and not chosen.segments.items[base + start]: start += 1
            if start == segments:
                try out.copy_curve(curves, curve)
                continue
            start = (start + 1) % segments if cyclic else 0
            run.clear()
            for step in 0..<segments:
                let segment = (start + step) % segments
                if chosen.segments.items[base + segment]:
                    if run.count >= 2: try copy_points(&out, curves, curve, run.view(), false)
                    run.clear()
                    continue
                if run.count == 0: try run.push(first + segment)
                try run.push(first + (segment + 1) % points)
            if run.count >= 2: try copy_points(&out, curves, curve, run.view(), false)
        return try adopt_set(try with_curves(source, try out.finish(curves)))

    ## The set with the curves `group` touches closed (`cyclic`) or opened.
    pub static func with_closure(geometry: interop.Reference[GeometrySet], pick: interop.Reference[Mesh], group: str, group_type: i64, cyclic: bool) -> interop.Reference[GeometrySet]!:
        let source = try geometry.get()
        let curves = set_curves(source) else error(errors.invalid, "Edit Sketch has no curves")
        var chosen = try SketchChoice.of(curves, try pick.get(), group, group_type)
        defer chosen.close()
        var out = CurvesBuilder()
        defer out.close()
        var every = Growing[usize]()
        defer every.close()
        for curve in 0..<curves.curve_count():
            let (first, points) = curves.range(curve)
            if not chosen.curves.items[curve] or points < 2 or (cyclic and points < 3):
                try out.copy_curve(curves, curve)
                continue
            every.clear()
            for at in first..<first + points: try every.push(at)
            try copy_points(&out, curves, curve, every.view(), cyclic)
        return try adopt_set(try with_curves(source, try out.finish(curves)))

## `point` on the grid of `spacing` in `plane` (its height off it kept).
func on_grid(plane: SketchPlane, point: Vector3, spacing: f64) -> Vector3:
    let offset = point.subtract(plane.origin)
    let a = math.round(offset.dot(plane.u) / spacing) * spacing
    let b = math.round(offset.dot(plane.v) / spacing) * spacing
    return plane.at(a, b).add(plane.normal.multiply_scalar(offset.dot(plane.normal)))

## The end points of the open curves (global point ids).
## Open curves' end points in a spatial hash of cells one snapping reach
## wide, so snapping each moved end looks at the ends near it instead of
## every end (an all-pairs search on a large sketch).
struct EndHash:
    var ends: Growing[usize]
    var points: Growing[Vector3]
    var grid: PointHash

    static func of(curves: const Curves*, reach: f64) -> EndHash!:
        var ends = Growing[usize]()
        errdefer ends.close()
        try open_ends(curves, &ends)
        var points = Growing[Vector3]()
        errdefer points.close()
        for end in ends.view(): try points.push(curves.point(end))
        let grid = try PointHash.build(points.view(), reach)
        return EndHash(ends, points, grid)

    ## The end nearest `point` within `reach` (ties: the later end, as a
    ## scan in end order keeps), other than `end`, that is not chosen; with
    ## `ordered`, a chosen end after `end` counts (joining two chosen ends
    ## moves only the later one). -1 when none.
    func nearest(point: Vector3, reach: f64, chosen: const bool[], end: usize, ordered: bool) -> i64:
        let home = self.grid.cell_of(point)
        var best = reach * reach
        var found: i64 = -1
        var found_slot: i32 = -1
        for dx in (i64)-1..<(i64)2:
            for dy in (i64)-1..<(i64)2:
                for dz in (i64)-1..<(i64)2:
                    var slot = self.grid.first(home.moved(dx, dy, dz))
                    while slot >= 0:
                        let other = self.ends.items[(usize)slot]
                        let allowed = other != end and (not chosen[other] or (ordered and other > end))
                        if allowed:
                            let offset = self.points.items[(usize)slot].subtract(point)
                            let distance = offset.dot(offset)
                            if distance < best or (distance == best and slot > found_slot):
                                best = distance
                                found = (i64)other
                                found_slot = slot
                        slot = self.grid.after(slot)
        return found

    func close():
        self.ends.close()
        self.points.close()
        self.grid.close()

func open_ends(curves: const Curves*, ends: Growing[usize]*) -> !:
    for curve in 0..<curves.curve_count():
        let (first, points) = curves.range(curve)
        if points < 2 or curves.settings(curve).cyclic: continue
        try ends.push(first)
        try ends.push(first + points - 1)

## Size `at` of a shape's sizes, else `fallback`.
func sized(sizes: const f64[], at: usize, fallback: f64) -> f64:
    return sizes[at] if at < sizes.length else fallback

## Every curve of `source` onto `out`, mapped from the XY plane onto
## `plane` around its coordinates (a, b), weights and knots kept.
func copy_onto(out: CurvesBuilder*, source: const Curves*, plane: SketchPlane, a: f64, b: f64) -> !:
    let weights = weight_span(source)
    for curve in 0..<source.curve_count():
        try out.begin_like(source, curve)
        let (first, points) = source.range(curve)
        for at in first..<first + points:
            let p = source.point(at)
            try out.point(plane.at(a + p.x, b + p.y))
            if weights != none: out.weight(source.weight_at(at))
        try out.knots_like(source, curve)

## Control points `indices` (global ids, in order) of curve `curve` as a new
## curve like it, closed when `cyclic`. Custom knots do not survive a
## change of points: such a curve takes endpoint knots.
func copy_points(out: CurvesBuilder*, source: const Curves*, curve: usize, indices: const usize[], cyclic: bool) -> !:
    let settings = source.settings(curve)
    try out.begin(settings.kind, cyclic, (i64)settings.resolution, (i64)settings.order, KnotMode.endpoint if settings.knot_mode == KnotMode.custom else settings.knot_mode, (i32)curve)
    let left = float3_span(source, "handle_l")
    let right = float3_span(source, "handle_r")
    let weights = weight_span(source)
    for at in indices:
        try out.point(source.point(at), (i32)at)
        if let l = left:
            if let r = right: out.handles(l[at].vector().add(source.origin), r[at].vector().add(source.origin))
        if weights != none: out.weight(source.weight_at(at))

## `curves` with its control points at `targets` (world, one per point):
## the moved points' (`moved`) Bezier handles turn by `linear` and follow
## them. The single entry for changing sketch positions: a constraint
## solver would adjust `targets` here, holding what the user moved.
pub func placed_curves(curves: const Curves*, targets: const Vector3[], moved: const bool[], linear: Matrix4) -> Curves*!:
    var out = CurvesBuilder()
    defer out.close()
    let left = float3_span(curves, "handle_l")
    let right = float3_span(curves, "handle_r")
    let weights = weight_span(curves)
    for curve in 0..<curves.curve_count():
        try out.begin_like(curves, curve, (i32)curve)
        let (first, points) = curves.range(curve)
        for at in first..<first + points:
            try out.point(targets[at], (i32)at)
            if let l = left:
                if let r = right:
                    let here = curves.point(at)
                    let turn = linear if moved[at] else Matrix4()
                    out.handles(targets[at].add(turn.transform_direction(l[at].vector().add(curves.origin).subtract(here))),
                                targets[at].add(turn.transform_direction(r[at].vector().add(curves.origin).subtract(here))))
            if weights != none: out.weight(curves.weight_at(at))
        try out.knots_like(curves, curve)
    return try out.finish(curves)