dymokomi/luce-cad
Source of release 0.9.2
0.9.2 / src / modeling / boolean_result.lucb
## A boolean's result (boolean.lucb steps 6 and 7): the pieces the
## operation keeps, merged where they lie on one surface, written as a new
## B-rep; an edge not used exactly twice, once each way, is an error.
## Steps 4 to 7: split, classify, select and write.
func assemble(work: Work*, op: i64, others: Others*) -> interop.Reference[CadModel]!:
let w = &work.w
var traced = try final_shape(work)
defer traced.close()
var halves = Growing[HalfEdge]()
defer halves.close()
var kept = Growing[(usize, usize, bool)]()
defer kept.close()
var pieces = try new_pieces()
defer pieces.close()
var piece_face = Growing[usize]()
defer piece_face.close()
# Each piece's name: its face's, or merged faces' names together.
var piece_name = Growing[i64]()
defer piece_name.close()
for f in 0..<w.faces.count:
halves.clear()
# The boundary, piece by piece, the way the face uses each edge.
for use in w.face_uses(f):
let e = edge_index(use)
let first = work.piece_starts.items[e]
let last = work.piece_starts.items[e + 1]
for k in 0..<last - first:
let id = work.piece_ids.items[first + k if use > 0 else last - 1 - k]
let forward = (id > 0) == (use > 0)
try halves.push(HalfEdge((id if id > 0 else -id) - 1, forward))
let boundary = halves.count
# New edges across it, both ways, unless already on its boundary.
for at in 0..<work.sections.count:
let section = work.sections.items[at]
if section.fa != (i64)f and section.fb != (i64)f: continue
try add_both(&halves, boundary, work.section_ids.items[at])
for mark in work.imprints.view():
if mark.face != f: continue
let first = work.piece_starts.items[mark.edge]
let last = work.piece_starts.items[mark.edge + 1]
for k in first..<last:
let id = work.piece_ids.items[k]
let final = work.finals.items[edge_index(id)]
let middle = try w.at(final.carrier, (final.t0 + final.t1) * 0.5)
if try face_contains(w, f, middle, work.tol) == inside_face: try add_both(&halves, boundary, id)
let before = pieces.piece_count()
try split_face(&traced, f, halves.view(), try face_pole(w, f), &pieces)
for _ in before..<pieces.piece_count():
try piece_face.push(f)
try piece_name.push(w.faces.items[f].name)
# Classify and select.
try find_blocks(work, &traced, &pieces, piece_face.view(), others)
var keep = Growing[bool]()
defer keep.close()
var turn = Growing[bool]()
defer turn.close()
for p in 0..<pieces.piece_count():
let f = piece_face.items[p]
let class = try classify(work, &traced, f, &pieces, p, others)
let first = work.is_a(f)
var take = false
var flip = false
if op == op_union:
take = class == class_out or (class == class_same and first)
elif op == op_subtract:
if first: take = class == class_out or class == class_opposite
else:
take = class == class_in
flip = true
else:
take = class == class_in or (class == class_same and first)
try keep.push(take)
try turn.push(flip)
try merge_pieces(work, &traced, &pieces, &piece_face, &piece_name, &keep, &turn)
try seam_zones(work, &traced, &pieces, piece_face.view(), keep.view())
return try write_result(work, &pieces, piece_face.view(), piece_name.view(), keep.view(), turn.view())
## Add final edge `id` (signed) to `halves` both ways, unless one of the
## first `boundary` halves is it.
func add_both(halves: Growing[HalfEdge]*, boundary: usize, id: i64) -> !:
let edge = (id if id > 0 else -id) - 1
for at in 0..<boundary:
if halves.items[at].edge == edge: return
for at in boundary..<halves.count:
if halves.items[at].edge == edge: return
try halves.push(HalfEdge(edge, true))
try halves.push(HalfEdge(edge, false))
## The shape faces are split in: the final edges over the merged
## vertices, with the work shape's carriers, surfaces and faces (their
## surfaces and senses; their loops are what is being split).
func final_shape(work: Work*) -> Shape!:
var s = empty_shape(work.tol)
errdefer s.close()
for p in work.vertices.view(): try s.points.push(p)
for c in work.w.carriers.view(): try s.carriers.push(c)
for sp in work.w.splines.view(): try s.splines.push(sp)
for p in work.w.spline_points.view(): try s.spline_points.push(p)
for x in work.w.spline_weights.view(): try s.spline_weights.push(x)
for k in work.w.spline_knots.view(): try s.spline_knots.push(k)
for e in work.finals.view(): try s.edges.push(e)
for su in work.w.surfaces.view():
try s.surfaces.push(try Surface(su.kind, su.origin, su.x, su.z, su.radius, su.angle, su.points, su.weights, su.ku, su.kv, su.nu, su.nv, su.du, su.dv))
for face in work.w.faces.view():
try s.faces.push(ShapeFace(face.surface, face.sense, 0, 0, 0, 0))
return s
## Step 7: the kept pieces as a new B-rep.
func write_result(work: Work*, pieces: const Pieces*, piece_face: const usize[], piece_name: const i64[], keep: const bool[], turn: const bool[]) -> interop.Reference[CadModel]!:
let w = &work.w
var uses_count = Growing[i64]()
defer uses_count.close()
var direction = Growing[i64]()
defer direction.close()
for _ in 0..<work.finals.count:
try uses_count.push(0)
try direction.push(0)
for p in 0..<pieces.piece_count():
if not keep[p]: continue
for c in pieces.piece_cycles(p):
for use in pieces.cycle(c):
let e = edge_index(use)
uses_count.items[e] += 1
direction.items[e] += (1 if use > 0 else -1) * (-1 if turn[p] else 1)
var open_edges = 0
for e in 0..<work.finals.count:
if uses_count.items[e] != 0 and (uses_count.items[e] != 2 or direction.items[e] != 0):
open_edges += 1
if open_edges > 0:
error(invalid, "the result is not a closed solid (some edges are not shared by two faces); this operation is not supported for these shapes yet")
# Merged vertices sit within ten tolerances of their curves.
let output = try BrepModel.held(math.max(work.tol * 20.0, least_tolerance))
defer output.release()
let b = output.value()
var vertex_ids = Growing[i64]()
defer vertex_ids.close()
for _ in work.vertices.view(): try vertex_ids.push(-1)
var edge_ids = Growing[i64]()
defer edge_ids.close()
for e in 0..<work.finals.count:
if uses_count.items[e] == 0:
try edge_ids.push(-1)
continue
let edge = work.finals.items[e]
if vertex_ids.items[(usize)edge.start] < 0: vertex_ids.items[(usize)edge.start] = try b.add_vertex(work.vertices.items[(usize)edge.start])
if vertex_ids.items[(usize)edge.end] < 0: vertex_ids.items[(usize)edge.end] = try b.add_vertex(work.vertices.items[(usize)edge.end])
let start = vertex_ids.items[(usize)edge.start]
let end = vertex_ids.items[(usize)edge.end]
let c = w.carriers.items[(usize)edge.carrier]
let forward = edge.t1 > edge.t0
var id: i64 = -1
if c.kind == curve_line: id = try b.add_line(start, end)
elif c.kind == curve_circle: id = try b.add_circle(start, end, c.origin, c.x.cross(c.y), c.x, c.a, forward)
elif c.kind == curve_ellipse: id = try b.add_ellipse(start, end, c.origin, c.x.cross(c.y), c.x, c.a, c.b, forward)
else:
let (points, weights, knots, degree) = w.spline_net(c.spline)
id = try b.add_spline_edge(start, end, points, weights, degree, knots, forward)
try edge_ids.push(id)
var surface_ids = Growing[i64]()
defer surface_ids.close()
for _ in w.surfaces.view(): try surface_ids.push(-1)
var uses = Growing[i64]()
defer uses.close()
var sizes = Growing[i64]()
defer sizes.close()
for p in 0..<pieces.piece_count():
if not keep[p]: continue
let face = w.faces.items[piece_face[p]]
let si = (usize)face.surface
if surface_ids.items[si] < 0:
let s = w.surfaces.items[si]
surface_ids.items[si] = (try b.add_spline_surface(s.points, s.weights, s.nu, s.nv, s.du, s.dv, s.ku, s.kv)) if s.kind == surface_spline else (try b.add_surface(s.kind, s.origin, s.z, s.x, s.radius, s.angle))
uses.clear()
sizes.clear()
for c in pieces.piece_cycles(p):
let cycle = pieces.cycle(c)
if cycle.length == 0: continue
for k in 0..<cycle.length:
# A turned piece runs each loop backwards.
var use = cycle[k]
if turn[p]: use = -cycle[cycle.length - 1 - k]
let e = edge_index(use)
try uses.push((edge_ids.items[e] + 1) * (1 if use > 0 else -1))
try sizes.push((i64)cycle.length)
let made = try b.add_face(surface_ids.items[si], uses.view(), sizes.view(), face.sense != turn[p])
try b.set_face_name(made, w.name(piece_name[p]))
return try CadModel.of_brep(output)