dymokomi/luce-geocore
Source of release 0.7.5
0.7.5 / 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 = Growing[usize]()
defer ends.close()
try open_ends(curves, &ends)
for end in ends.view():
if not chosen.points.items[end]: continue
var best = reach
for other in ends.view():
if chosen.points.items[other]: continue
let distance = curves.point(other).subtract(targets.items[end]).length()
if distance <= best:
best = distance
targets.items[end] = curves.point(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 = Growing[usize]()
defer ends.close()
try open_ends(curves, &ends)
var targets = Growing[Vector3]()
defer targets.close()
for at in 0..<curves.point_count(): try targets.push(curves.point(at))
for end in ends.view():
if not chosen.points.items[end]: continue
let here = curves.point(end)
var best = tolerance
for other in ends.view():
if other == end: continue
let distance = curves.point(other).subtract(here).length()
if distance <= best and not (chosen.points.items[other] and other < end):
best = distance
targets.items[end] = curves.point(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).
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 let w = weights: out.weight((f64)w[at])
let knots = source.custom_knots(curve)
for value in knots: try out.knots.push(value)
if knots.length > 0: out.any_knots = true
## 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 let w = weights: out.weight((f64)w[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 let w = weights: out.weight((f64)w[at])
let knots = curves.custom_knots(curve)
for value in knots: try out.knots.push(value)
if knots.length > 0: out.any_knots = true
return try out.finish(curves)