dymokomi/luce-cad
Source of release 0.9.4
0.9.4 / src / sketch / face_projection.lucb
## Fusion's auto-projection of a face: a sketch on a body's face gets the
## face's outer and inner loops as fixed curves, each linked to its edge
## by the edge's reference (projection.lucb's links), so relinking casts
## them again when the body changes upstream. Curves meeting at a vertex
## share one sketch point, so a loop stays one closed chain (a profile, and
## a chain Offset takes whole). The face is remembered by name: relinking
## adds the shadows of edges its loops gained.
## Project the loops of `model`'s faces named `name` (any alias: a face
## split by later features is all its pieces) onto `sketch`'s plane
## through `origin` (axes `u`, `v`): one fixed, linked curve per edge,
## neighbors sharing their points. The curves made onto `out`.
pub func project_face_loops(sketch: Sketch*, model: const CadModel*, name: str, origin: Vector3, u: Vector3, v: Vector3, out: Growing[i64]*) -> !:
out.clear()
if name == "": error(invalid, "pick the face to project")
var w = try shape_of(model)
defer w.close()
# The sketch point of each body vertex, made when first used.
var points = Growing[i64]()
defer points.close()
try points.fill(w.points.count, -1)
var run = Growing[f64]()
defer run.close()
var reference = Growing[u8]()
defer reference.close()
var found = false
for f in 0..<w.faces.count:
if not (try names_meet(w.face_name(f), name)): continue
found = true
for use in w.face_uses(f):
let made = try project_use(sketch, &w, use, origin, u, v, &points, &run, &reference)
if made >= 0: try out.push(made)
if not found: error(invalid, "the face to project is no longer on the body")
try sketch.project_face_name(name)
## Project the edge of loop use `use` of `w` (signed: +(edge + 1) forward)
## as a curve from its start's sketch point to its end's (`points`, by body
## vertex), fixed and linked; the curve, or -1 for an edge seen end-on
## (its two ends become one point).
func project_use(sketch: Sketch*, w: const Shape*, use: i64, origin: Vector3, u: Vector3, v: Vector3, points: Growing[i64]*, run: Growing[f64]*, reference: Growing[u8]*) -> i64!:
let e = edge_index(use)
let edge = w.edges.items[e]
let forward = use > 0
let (start, end) = (edge.start, edge.end) if forward else (edge.end, edge.start)
run.clear()
try cast_edge(w, e, origin, u, v, run)
if not forward: reverse_pairs(run)
let tolerance = 1e-6 * math.max(1.0, size_of(sketch))
if end_on(run.view(), tolerance):
# Seen end-on: both ends at one point.
let p = try vertex_point(sketch, points, start, run.items[0], run.items[1])
if points.items[(usize)end] < 0: points.items[(usize)end] = p
return -1
let n = run.count // 2
let kind = shadow_kind(run.view(), tolerance)
var made: i64 = -1
if kind == EntityKind.circle:
# A whole circle: no ends to share.
let circle = circle_through(run.view(), tolerance) else error(invalid, "a circular shadow has no circle")
made = try sketch.add_circle(try sketch.add_point(circle[0], circle[1]), circle[2])
_ = try sketch.constrain(ConstraintKind.fix, made)
try references_of(w, [(i64)e], reference)
try sketch.link(made, (str)reference.view())
return made
let a = try vertex_point(sketch, points, start, run.items[0], run.items[1])
let b = try vertex_point(sketch, points, end, run.items[2 * n - 2], run.items[2 * n - 1])
if kind == EntityKind.line:
made = try sketch.add_line(a, b)
elif kind == EntityKind.arc:
let circle = circle_through(run.view(), tolerance) else error(invalid, "a circular shadow has no circle")
let center = try sketch.add_point(circle[0], circle[1])
# Arcs run counterclockwise: from the end when the samples turn
# clockwise.
let r = run.view()
let turning = (r[2] - r[0]) * (r[1] - circle[1]) - (r[3] - r[1]) * (r[0] - circle[0])
made = try sketch.add_arc(center, b if turning > 0.0 else a, a if turning > 0.0 else b)
else:
# A fit point spline through every fourth sample, between the
# shared ends.
var through = Growing[i64]()
defer through.close()
try through.push(a)
var k: usize = 4
while k + 1 < n:
try through.push(try sketch.add_point(run.items[2 * k], run.items[2 * k + 1]))
k += 4
try through.push(b)
made = try sketch.add_spline(through.view(), true)
_ = try sketch.constrain(ConstraintKind.fix, made)
try references_of(w, [(i64)e], reference)
try sketch.link(made, (str)reference.view())
return made
## The sketch point of body vertex `vertex`, made at (`x`, `y`) when it has
## none yet.
func vertex_point(sketch: Sketch*, points: Growing[i64]*, vertex: i64, x: f64, y: f64) -> i64!:
let at = (usize)vertex
if points.items[at] < 0: points.items[at] = try sketch.add_point(x, y)
return points.items[at]
## The x, y pairs of `run` in the other order.
func reverse_pairs(run: Growing[f64]*):
let n = run.count // 2
for k in 0..<n // 2:
let j = n - 1 - k
let (x, y) = (run.items[2 * k], run.items[2 * k + 1])
run.items[2 * k] = run.items[2 * j]
run.items[2 * k + 1] = run.items[2 * j + 1]
run.items[2 * j] = x
run.items[2 * j + 1] = y
## The edges of `w`'s faces named as `sketch`'s projected faces that no
## link resolved to (`followed` marks the resolved ones), their shadows
## added as projected curves (their own points, fixed and linked); how many.
pub func add_gained_edges(sketch: Sketch*, w: const Shape*, followed: const bool[], origin: Vector3, u: Vector3, v: Vector3) -> i64!:
var gained: i64 = 0
var run = Growing[f64]()
defer run.close()
var reference = Growing[u8]()
defer reference.close()
var done = Growing[bool]()
defer done.close()
try done.fill(w.edges.count, false)
let tolerance = 1e-6 * math.max(1.0, size_of(sketch))
for face in sketch.faces.view():
let name = sketch.face_reference(face)
for f in 0..<w.faces.count:
if not (try names_meet(w.face_name(f), name)): continue
for use in w.face_uses(f):
let e = edge_index(use)
if followed[e] or done.items[e]: continue
done.items[e] = true
run.clear()
try cast_edge(w, e, origin, u, v, &run)
if end_on(run.view(), tolerance): continue
try references_of(w, [(i64)e], &reference)
_ = try add_shadow(sketch, run.view(), (str)reference.view())
gained += 1
return gained