dymokomi/luce-cad
Source of release 0.9.1
0.9.1 / src / brep / model.lucb
## The B-rep as a structure of arrays: vertices, curves, surfaces, faces and
## loops each a set of columns (brep_store.lucb), shared by count between
## copies of a model. Edge IDs are shared across incident faces. The
## surfaces' control vertices form the `cv` domain (brep_cvs.lucb). The
## tessellator reads owned records (brep_types.lucb) made from the columns
## once per model and kept until the model changes.
import interop
import memory
from luce_geocore.core import parallel
from luce_std import math
import sync
from luce_geocore.geocore import Vector3, Matrix4, Mesh, invalid
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import BitsBuilder, GeometryWriter, GeometryReader, PropertyHeader, dtype_float64, dtype_int32, dtype_uint8
from luce_geocore.core.shared import Column
from luce_geocore.kernel import TableBuilder, Domain, text_attribute
from tessellation.surface import NurbsSurface, NurbsCurve
from brep_types import Curve, Surface, BrepFace
from brep_store import Store
from brep_mesh import tessellate
from face_cache import FaceCache, dispose_cache, inherited
from face_mesh import face_mesh
from curve_trim import parameter
from surface_trim import project, evaluate
from luce_geocore.kernel import moved_storage, mesh_adopt, precise_span, Float3, Attribute
## Values per curve frame: origin, x and y axes, radius, start angle, sweep.
let curve_stride: usize = 12
## Values per surface frame: origin, x and z axes, radius, angle.
let surface_stride: usize = 11
## The tessellator's records, made once from the columns: the first
## `made_*` of each array are valid.
pub struct Records:
pub var edges: Curve[]
pub var surfaces: Surface[]
pub var faces: BrepFace[]
var made_edges: usize = 0
var made_surfaces: usize = 0
var made_faces: usize = 0
pub func close():
for edge in self.edges[..<self.made_edges]: edge.close()
for surface in self.surfaces[..<self.made_surfaces]: surface.close()
for face in self.faces[..<self.made_faces]: face.close()
free(self.edges) in memory.heap
free(self.surfaces) in memory.heap
free(self.faces) in memory.heap
## A whole-model tessellation kept for its parameters.
struct KeptMesh:
let divisions: i64
let edge_size: f64
let curvature: bool
let directions: bool
let mesh: interop.Reference[Mesh]
## What a model derives from its columns on demand (from any thread): the
## tessellator's records, the per-face tessellation cache and the last few
## whole tessellations. Behind a pointer, so reading a model can fill it.
struct Derived:
var lock: sync.Mutex
var records: Records*?
var faces: FaceCache*?
var meshes: Growing[KeptMesh]
## A copy with moved cvs: where its quick preview comes from, and the
## preview once made (quick.lucb).
var quick: QuickSource*? = none
var quick_result: interop.Reference[Mesh]? = none
## The edges' polylines (overlay.lucb), made once; copies with moved
## cvs share every edge, so they start with them.
var boundaries: Growing[Vector3] = Growing[Vector3]()
pub struct BrepModel:
let tolerance: f64
var vertices: Store[Vector3]
# Curves: kind (0 line, 1 circle arc, 2 B-spline interval, 3 ellipse
# arc), end vertices, frame, degree, sense, control points (lines keep
# their two ends), weights (an ellipse its minor radius) and knots.
var curve_kind: Store[u8]
var curve_ends: Store[i32]
var curve_frame: Store[f64]
var curve_degree: Store[i32]
var curve_sense: Store[u8]
var curve_point_offsets: Store[i32]
var curve_points: Store[Vector3]
var curve_weight_offsets: Store[i32]
var curve_weights: Store[f64]
var curve_knot_offsets: Store[i32]
var curve_knots: Store[f64]
# Surfaces: kind (0 plane, 1 cylinder, 2 cone, 3 rational B-spline,
# 4 sphere, 5 torus), frame, dimensions (nu, nv, du, dv), control
# vertices (the cv domain: positions and weights), knots (u then v), and
# whether its cvs were moved since import (its trims may leave it).
var surface_kind: Store[u8]
var surface_edited: Store[u8]
var surface_frame: Store[f64]
var surface_dims: Store[i32]
var surface_cv_offsets: Store[i32]
var cv_positions: Store[Vector3]
var surface_weight_offsets: Store[i32]
var cv_weights: Store[f64]
var surface_knot_offsets: Store[i32]
var surface_knots: Store[f64]
# Faces: support surface, sense, edge uses (signed: +(edge + 1) forward),
# loop sizes (outer first), placement, color and path.
var face_surface: Store[i32]
var face_sense: Store[u8]
var face_use_offsets: Store[i32]
var face_uses: Store[i32]
var face_loop_offsets: Store[i32]
var loop_sizes: Store[i32]
var face_placement: Store[Matrix4]
var face_color: Store[Vector3]
var face_colored: Store[u8]
var face_paths: Growing[interop.Packet[str]?]
var derived: Derived*
pub func init(tolerance: f64 = 0.000001) -> !:
if not math.is_finite(tolerance) or tolerance < 0.000000001 or tolerance > 1.0:
error(invalid, "CAD tolerance must be finite and between 1e-9 and 1 source unit")
self.tolerance = tolerance
self.vertices = Store[Vector3]()
self.curve_kind = Store[u8]()
self.curve_ends = Store[i32]()
self.curve_frame = Store[f64]()
self.curve_degree = Store[i32]()
self.curve_sense = Store[u8]()
self.curve_point_offsets = Store[i32]()
self.curve_points = Store[Vector3]()
self.curve_weight_offsets = Store[i32]()
self.curve_weights = Store[f64]()
self.curve_knot_offsets = Store[i32]()
self.curve_knots = Store[f64]()
self.surface_kind = Store[u8]()
self.surface_edited = Store[u8]()
self.surface_frame = Store[f64]()
self.surface_dims = Store[i32]()
self.surface_cv_offsets = Store[i32]()
self.cv_positions = Store[Vector3]()
self.surface_weight_offsets = Store[i32]()
self.cv_weights = Store[f64]()
self.surface_knot_offsets = Store[i32]()
self.surface_knots = Store[f64]()
self.face_surface = Store[i32]()
self.face_sense = Store[u8]()
self.face_use_offsets = Store[i32]()
self.face_uses = Store[i32]()
self.face_loop_offsets = Store[i32]()
self.loop_sizes = Store[i32]()
self.face_placement = Store[Matrix4]()
self.face_color = Store[Vector3]()
self.face_colored = Store[u8]()
self.face_paths = Growing[interop.Packet[str]?]()
self.derived = try new Derived(sync.Mutex(), none, none, Growing[KeptMesh]()) in memory.heap
# A failure below lets go of what is made so far.
errdefer self.close()
try self.curve_point_offsets.push(0)
try self.curve_weight_offsets.push(0)
try self.curve_knot_offsets.push(0)
try self.surface_cv_offsets.push(0)
try self.surface_weight_offsets.push(0)
try self.surface_knot_offsets.push(0)
try self.face_use_offsets.push(0)
try self.face_loop_offsets.push(0)
pub func face_count() -> i64:
return (i64)self.face_surface.count
pub func edge_count() -> i64:
return (i64)self.curve_kind.count
pub func vertex_count() -> i64:
return (i64)self.vertices.count
pub func surface_count() -> i64:
return (i64)self.surface_kind.count
func check_face(face: i64) -> !:
if face < 0 or face >= self.face_count(): error(invalid, "CAD face index out of range")
## Support type: plane=0, cylinder=1, cone=2, NURBS=3, sphere=4, torus=5.
pub func face_surface_kind(face: i64) -> i64!:
try self.check_face(face)
return (i64)self.surface_kind.get((usize)self.face_surface.get((usize)face))
## A format-independent object path attached to an analytic face.
pub func face_path(face: i64) -> str!:
try self.check_face(face)
return (self.face_paths.items[(usize)face] else interop.Packet[str]("")).value
pub func set_face_path(face: i64, path: str) -> !:
try self.check_face(face)
let copy = try interop.text_transfer.copy(path)
if let previous = self.face_paths.items[(usize)face]: previous.release()
self.face_paths.items[(usize)face] = copy
## The edge uses of face `face` (signed) and its loop sizes.
func uses_of(face: usize) -> const i32[]:
return self.face_uses.range((usize)self.face_use_offsets.get(face), (usize)self.face_use_offsets.get(face + 1))
func loops_of(face: usize) -> const i32[]:
return self.loop_sizes.range((usize)self.face_loop_offsets.get(face), (usize)self.face_loop_offsets.get(face + 1))
## Extract faces with compact shared topology; unrelated points and curves
## are not copied into the result. Face paths/colors/placements survive.
pub func subset(selection: const i64[]) -> interop.Reference[BrepModel]!:
let output = try interop.Reference[BrepModel].adopt(new BrepModel(self.tolerance) in memory.heap, brep_model_type, memory.heap)
errdefer output.release()
let target = output.value()
let vertices = try new i64[self.vertices.count] --- in memory.heap
defer free(vertices) in memory.heap
let edges = try new i64[self.curve_kind.count] --- in memory.heap
defer free(edges) in memory.heap
let surfaces = try new i64[self.surface_kind.count] --- in memory.heap
defer free(surfaces) in memory.heap
for index in 0..<vertices.length: vertices[index] = -1
for index in 0..<edges.length: edges[index] = -1
for index in 0..<surfaces.length: surfaces[index] = -1
var uses = Growing[i64]()
defer uses.close()
var sizes = Growing[i64]()
defer sizes.close()
for id in selection:
try self.check_face(id)
uses.clear()
sizes.clear()
for use in self.uses_of((usize)id):
let index = (usize)(use - 1 if use > 0 else -use - 1)
if edges[index] < 0:
for side in 0..<(usize)2:
let point = (usize)self.curve_ends.get(index * 2 + side)
if vertices[point] < 0: vertices[point] = try target.add_vertex(self.vertices.get(point))
edges[index] = try target.copy_curve(&self, index, vertices)
try uses.push((edges[index] + 1) * (1 if use > 0 else -1))
for size in self.loops_of((usize)id): try sizes.push((i64)size)
let sid = (usize)self.face_surface.get((usize)id)
if surfaces[sid] < 0:
surfaces[sid] = try target.copy_surface(&self, sid)
try target.surface_edited.set((usize)surfaces[sid], self.surface_edited.get(sid))
let copied = try target.add_face(surfaces[sid], uses.view(), sizes.view(), self.face_sense.get((usize)id) == 1)
try target.face_placement.set((usize)copied, self.face_placement.get((usize)id))
try target.face_color.set((usize)copied, self.face_color.get((usize)id))
try target.face_colored.set((usize)copied, self.face_colored.get((usize)id))
try target.set_face_path(copied, try self.face_path(id))
return output
## Curve `index` of `source`, its end vertices mapped through `vertices`.
func copy_curve(source: const BrepModel*, index: usize, vertices: const i64[]) -> i64!:
let start = vertices[(usize)source.curve_ends.get(index * 2)]
let end = vertices[(usize)source.curve_ends.get(index * 2 + 1)]
try self.push_curve(source.curve_kind.get(index), start, end, source.curve_frame.range(index * curve_stride, (index + 1) * curve_stride),
source.curve_points_of(index), source.curve_weights_of(index), source.curve_knots_of(index), (i64)source.curve_degree.get(index), source.curve_sense.get(index) == 1)
return self.edge_count() - 1
func copy_surface(source: const BrepModel*, index: usize) -> i64!:
let dims = source.surface_dims.range(index * 4, index * 4 + 4)
try self.push_surface(source.surface_kind.get(index), source.surface_frame.range(index * surface_stride, (index + 1) * surface_stride),
source.cvs_of(index), source.cv_weights_of(index), source.knots_of(index, 0), source.knots_of(index, 1), dims)
return self.surface_count() - 1
func curve_points_of(index: usize) -> const Vector3[]:
return self.curve_points.range((usize)self.curve_point_offsets.get(index), (usize)self.curve_point_offsets.get(index + 1))
func curve_weights_of(index: usize) -> const f64[]:
return self.curve_weights.range((usize)self.curve_weight_offsets.get(index), (usize)self.curve_weight_offsets.get(index + 1))
func curve_knots_of(index: usize) -> const f64[]:
return self.curve_knots.range((usize)self.curve_knot_offsets.get(index), (usize)self.curve_knot_offsets.get(index + 1))
## Surface `index`'s control vertices (the cv domain range) and weights.
func cvs_of(index: usize) -> const Vector3[]:
return self.cv_positions.range((usize)self.surface_cv_offsets.get(index), (usize)self.surface_cv_offsets.get(index + 1))
func cv_weights_of(index: usize) -> const f64[]:
return self.cv_weights.range((usize)self.surface_weight_offsets.get(index), (usize)self.surface_weight_offsets.get(index + 1))
## Surface `index`'s knots in u (`axis` 0) or v (1).
func knots_of(index: usize, axis: usize) -> const f64[]:
let at = index * 2 + axis
return self.surface_knots.range((usize)self.surface_knot_offsets.get(at), (usize)self.surface_knot_offsets.get(at + 1))
pub func face_edge_count(face: i64) -> i64!:
try self.check_face(face)
return (i64)self.uses_of((usize)face).length
func use_at(face: i64, use_index: i64) -> i64!:
let count = try self.face_edge_count(face)
if use_index < 0 or use_index >= count:
error(invalid, "CAD edge use index out of range")
return (i64)self.uses_of((usize)face)[(usize)use_index]
pub func face_edge_point(face: i64, use_index: i64, fraction: f64) -> Vector3!:
let use = try self.use_at(face, use_index)
let edge = try self.curve((usize)(use - 1 if use > 0 else -use - 1))
defer edge.close()
return self.face_placement.get((usize)face).transform_point(try edge.at(fraction if use > 0 else 1.0 - fraction))
pub func face_edge_linear(face: i64, use_index: i64) -> bool!:
let use = try self.use_at(face, use_index)
return self.curve_kind.get((usize)(use - 1 if use > 0 else -use - 1)) == 0
pub func face_edge_id(face: i64, use_index: i64) -> i64!:
let use = try self.use_at(face, use_index)
return use - 1 if use > 0 else -use - 1
pub func set_face_color(face: i64, color: Vector3) -> !:
if face < 0 or face >= self.face_count() or not color.is_finite() or color.x < 0.0 or color.x > 1.0 or color.y < 0.0 or color.y > 1.0 or color.z < 0.0 or color.z > 1.0:
error(invalid, "invalid CAD face color")
try self.face_color.set((usize)face, color)
try self.face_colored.set((usize)face, 1)
self.changed()
## Preserve rigid assembly placement without changing support geometry.
pub func set_face_placement(face: i64, matrix: Matrix4) -> !:
if face < 0 or face >= self.face_count() or not matrix.is_finite() or math.abs(matrix.determinant() - 1.0) > 0.000001:
error(invalid, "invalid rigid CAD face placement")
try self.face_placement.set((usize)face, matrix)
self.changed()
pub func add_vertex(point: Vector3) -> i64!:
if not point.is_finite(): error(invalid, "invalid B-rep vertex")
try self.vertices.push(point)
self.changed()
return self.vertex_count() - 1
func check_edge(start: i64, end: i64) -> !:
if start < 0 or end < 0 or start >= self.vertex_count() or end >= self.vertex_count():
error(invalid, "invalid B-rep edge endpoints")
## Append one curve's columns.
func push_curve(kind: u8, start: i64, end: i64, frame: const f64[], points: const Vector3[], weights: const f64[], knots: const f64[], degree: i64, sense: bool) -> !:
try self.curve_kind.push(kind)
try self.curve_ends.push((i32)start)
try self.curve_ends.push((i32)end)
try self.curve_frame.append(frame)
try self.curve_degree.push((i32)degree)
try self.curve_sense.push(1 if sense else 0)
try self.curve_points.append(points)
try self.curve_point_offsets.push((i32)self.curve_points.count)
try self.curve_weights.append(weights)
try self.curve_weight_offsets.push((i32)self.curve_weights.count)
try self.curve_knots.append(knots)
try self.curve_knot_offsets.push((i32)self.curve_knots.count)
self.changed()
pub func add_line(start: i64, end: i64) -> i64!:
try self.check_edge(start, end)
if start == end:
error(invalid, "collapsed B-rep line")
var empty: f64[1]
let frame = curve_frame(Vector3(), Vector3(), Vector3(), 0.0, 0.0, 0.0)
try self.push_curve(0, start, end, frame[..<frame.length], [self.vertices.get((usize)start), self.vertices.get((usize)end)], empty[..<0], empty[..<0], 0, true)
return self.edge_count() - 1
pub func add_circle(start: i64, end: i64, origin: Vector3, axis: Vector3, reference: Vector3, radius: f64, sense: bool = true) -> i64!:
try self.check_edge(start, end)
let z = try axis.normalized()
let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
let y = z.cross(x)
if not origin.is_finite() or not math.is_finite(radius) or radius <= 0.0:
error(invalid, "invalid B-rep circle")
let a = self.vertices.get((usize)start).subtract(origin)
let b = self.vertices.get((usize)end).subtract(origin)
if math.abs(a.dot(z)) > self.tolerance or math.abs(b.dot(z)) > self.tolerance or math.abs(a.length() - radius) > self.tolerance or math.abs(b.length() - radius) > self.tolerance:
error(invalid, "circle endpoints are not on the curve")
let angle = math.atan2(a.dot(y), a.dot(x))
let sweep = swept(math.atan2(b.dot(y), b.dot(x)) - angle, sense)
var empty: f64[1]
let frame = curve_frame(origin, x, y, radius, angle, sweep)
try self.push_curve(1, start, end, frame[..<frame.length], self.vertices.view()[..<0], empty[..<0], empty[..<0], 0, sense)
return self.edge_count() - 1
## Retain an exact elliptical arc, with angles recovered from its endpoints.
pub func add_ellipse(start: i64, end: i64, origin: Vector3, axis: Vector3, reference: Vector3, major: f64, minor: f64, sense: bool = true) -> i64!:
try self.check_edge(start, end)
if not origin.is_finite() or not math.is_finite(major) or not math.is_finite(minor) or major <= 0.0 or minor <= 0.0:
error(invalid, "invalid B-rep ellipse")
let z = try axis.normalized()
let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
let y = z.cross(x)
let a = self.vertices.get((usize)start).subtract(origin)
let b = self.vertices.get((usize)end).subtract(origin)
let angle = math.atan2(a.dot(y) / minor, a.dot(x) / major)
let end_angle = math.atan2(b.dot(y) / minor, b.dot(x) / major)
if a.subtract(x.multiply_scalar(major * math.cos(angle)).add(y.multiply_scalar(minor * math.sin(angle)))).length() > self.tolerance or b.subtract(x.multiply_scalar(major * math.cos(end_angle)).add(y.multiply_scalar(minor * math.sin(end_angle)))).length() > self.tolerance:
error(invalid, "ellipse endpoints are not on the curve")
let sweep = swept(end_angle - angle, sense)
var empty: f64[1]
let frame = curve_frame(origin, x, y, major, angle, sweep)
try self.push_curve(3, start, end, frame[..<frame.length], self.vertices.view()[..<0], [minor], empty[..<0], 0, sense)
return self.edge_count() - 1
pub func add_spline_edge(start: i64, end: i64, points: const Vector3[], weights: const f64[], degree: i64, knots: const f64[], sense: bool) -> i64!:
try self.check_edge(start, end)
if degree < 1 or (usize)degree >= knots.length or points.length >= knots.length:
error(invalid, "invalid B-spline edge")
let low = knots[(usize)degree]
let high = knots[points.length]
let a = try parameter(points, weights, degree, knots, self.vertices.get((usize)start), low if sense else high, self.tolerance)
let b = try parameter(points, weights, degree, knots, self.vertices.get((usize)end), high if sense else low, self.tolerance)
var sweep = b - a
if (sense and sweep <= 0.0) or (not sense and sweep >= 0.0):
let first = try NurbsCurve.at(points, weights, degree, knots, low)
let last = try NurbsCurve.at(points, weights, degree, knots, high)
if first.subtract(last).length() > self.tolerance:
error(invalid, "B-spline trim orientation contradicts the edge sense")
sweep += (high - low) * (1.0 if sense else -1.0)
let frame = curve_frame(Vector3(), Vector3(), Vector3(), 0.0, a, sweep)
try self.push_curve(2, start, end, frame[..<frame.length], points, weights, knots, degree, sense)
return self.edge_count() - 1
## Append one surface's columns.
func push_surface(kind: u8, frame: const f64[], points: const Vector3[], weights: const f64[], ku: const f64[], kv: const f64[], dims: const i32[]) -> !:
try self.surface_kind.push(kind)
try self.surface_edited.push(0)
try self.surface_frame.append(frame)
try self.surface_dims.append(dims)
try self.cv_positions.append(points)
try self.surface_cv_offsets.push((i32)self.cv_positions.count)
try self.cv_weights.append(weights)
try self.surface_weight_offsets.push((i32)self.cv_weights.count)
try self.surface_knots.append(ku)
try self.surface_knot_offsets.push((i32)self.surface_knots.count)
try self.surface_knots.append(kv)
try self.surface_knot_offsets.push((i32)self.surface_knots.count)
self.changed()
## kind 0 plane, 1 cylinder, 2 cone, 4 sphere, 5 torus.
## For a torus radius/angle are major/minor radii. Placements stay exact.
pub func add_surface(kind: i64, origin: Vector3, axis: Vector3, reference: Vector3, radius: f64 = 0.0, angle: f64 = 0.0) -> i64!:
if kind < 0 or kind == 3 or kind > 5 or not origin.is_finite() or not math.is_finite(radius) or not math.is_finite(angle) or (kind > 0 and radius <= 0.0) or (kind == 2 and math.abs(angle) >= 1.5707963267948966) or (kind == 5 and angle <= 0.0):
error(invalid, "invalid analytic B-rep surface")
let z = try axis.normalized()
let x = try reference.subtract(z.multiply_scalar(reference.dot(z))).normalized()
let frame: f64[11] = [origin.x, origin.y, origin.z, x.x, x.y, x.z, z.x, z.y, z.z, radius, angle]
var empty: f64[1]
let dims: i32[4] = [0, 0, 0, 0]
try self.push_surface((u8)kind, frame[..<frame.length], self.vertices.view()[..<0], empty[..<0], empty[..<0], empty[..<0], dims[..<4])
return self.surface_count() - 1
pub func add_spline_surface(points: const Vector3[], weights: const f64[], nu: i64, nv: i64, du: i64, dv: i64, ku: const f64[], kv: const f64[]) -> i64!:
try NurbsSurface.check(points, weights, nu, nv, du, dv, ku, kv)
let frame: f64[11] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
let dims: i32[4] = [(i32)nu, (i32)nv, (i32)du, (i32)dv]
try self.push_surface(3, frame[..<frame.length], points, weights, ku, kv, dims[..<4])
return self.surface_count() - 1
## Signed edge uses: +(edge ID + 1) forward, -(edge ID + 1) reversed.
## Outer loop first, holes afterward, any number of each. Reject
## disconnected topological loops.
pub func add_face(surface: i64, uses: const i64[], sizes: const i64[], sense: bool = true) -> i64!:
if surface < 0 or surface >= self.surface_count() or sizes.length == 0:
error(invalid, "invalid B-rep face")
let edges = self.edge_count()
for use in uses:
if use == 0 or use < -edges or use > edges:
error(invalid, "B-rep face references a missing edge")
var offset: usize = 0
for size in sizes:
if size < 1 or (usize)size > uses.length - offset:
error(invalid, "invalid B-rep loop size")
for at in 0..<(usize)size:
let use = uses[offset + at]
let next = uses[offset + (at + 1) % (usize)size]
let edge = (usize)(use - 1 if use > 0 else -use - 1)
let following = (usize)(next - 1 if next > 0 else -next - 1)
let arrives = self.curve_ends.get(edge * 2 + (1 if use > 0 else 0))
let leaves = self.curve_ends.get(following * 2 + (0 if next > 0 else 1))
if arrives != leaves:
error(invalid, "disconnected B-rep loop")
offset += (usize)size
if offset != uses.length:
error(invalid, "B-rep loop sizes do not describe every edge use")
try self.face_surface.push((i32)surface)
try self.face_sense.push(1 if sense else 0)
for use in uses: try self.face_uses.push((i32)use)
try self.face_use_offsets.push((i32)self.face_uses.count)
for size in sizes: try self.loop_sizes.push((i32)size)
try self.face_loop_offsets.push((i32)self.loop_sizes.count)
try self.face_placement.push(Matrix4())
try self.face_color.push(Vector3(1.0, 1.0, 1.0))
try self.face_colored.push(0)
try self.face_paths.push(none)
self.changed()
return self.face_count() - 1
## Owned records of curve `index` and surface `index`, and of face `index`
## (edge uses, loops, sense, placement, color).
func curve(index: usize) -> Curve!:
let frame = self.curve_frame.range(index * curve_stride, (index + 1) * curve_stride)
return try Curve((i64)self.curve_kind.get(index), (i64)self.curve_ends.get(index * 2), (i64)self.curve_ends.get(index * 2 + 1),
Vector3(frame[0], frame[1], frame[2]), Vector3(frame[3], frame[4], frame[5]), Vector3(frame[6], frame[7], frame[8]), frame[9],
self.curve_points_of(index), self.curve_weights_of(index), self.curve_knots_of(index), (i64)self.curve_degree.get(index),
self.curve_sense.get(index) == 1, frame[10], frame[11])
func surface(index: usize) -> Surface!:
let frame = self.surface_frame.range(index * surface_stride, (index + 1) * surface_stride)
let dims = self.surface_dims.range(index * 4, index * 4 + 4)
var record = try Surface((i64)self.surface_kind.get(index), Vector3(frame[0], frame[1], frame[2]), Vector3(frame[3], frame[4], frame[5]), Vector3(frame[6], frame[7], frame[8]),
frame[9], frame[10], self.cvs_of(index), self.cv_weights_of(index), self.knots_of(index, 0), self.knots_of(index, 1),
(i64)dims[0], (i64)dims[1], (i64)dims[2], (i64)dims[3])
record.edited = self.surface_edited.get(index) == 1
return record
func face(index: usize) -> BrepFace!:
var uses = Growing[i64]()
defer uses.close()
var sizes = Growing[i64]()
defer sizes.close()
for use in self.uses_of(index): try uses.push((i64)use)
for size in self.loops_of(index): try sizes.push((i64)size)
var record = try BrepFace((i64)self.face_surface.get(index), uses.view(), sizes.view(), self.face_sense.get(index) == 1)
record.placement = self.face_placement.get(index)
record.color = self.face_color.get(index)
record.colored = self.face_colored.get(index) == 1
return record
## The tessellator's records: made on first use, kept until a change.
func tessellation_records() -> const Records*!:
let derived = self.derived
derived.lock.lock()
defer derived.lock.unlock()
if let made = derived.records: return made
let made = try make_records(&self)
derived.records = made
return made
## The per-face tessellation cache, made on first use.
func face_cache() -> FaceCache*!:
let derived = self.derived
derived.lock.lock()
defer derived.lock.unlock()
if let made = derived.faces: return made
let made = try new FaceCache() in memory.heap
derived.faces = made
return made
## A kept tessellation for these parameters (another owner), or none.
func kept_mesh(divisions: i64, edge_size: f64, curvature: bool, directions: bool) -> interop.Reference[Mesh]?:
let derived = self.derived
derived.lock.lock()
defer derived.lock.unlock()
for kept in derived.meshes.view():
if kept.divisions == divisions and kept.edge_size == edge_size and kept.curvature == curvature and kept.directions == directions: return kept.mesh.clone()
return none
## Keep `mesh` for these parameters (the last four are kept).
func keep_mesh(divisions: i64, edge_size: f64, curvature: bool, directions: bool, mesh: interop.Reference[Mesh]) -> !:
let derived = self.derived
derived.lock.lock()
defer derived.lock.unlock()
if derived.meshes.count == 4:
derived.meshes.items[0].mesh.release()
for at in 1..<4: derived.meshes.items[at - 1] = derived.meshes.items[at]
derived.meshes.count = 3
let owner = mesh.clone()
derived.meshes.push(KeptMesh(divisions, edge_size, curvature, directions, owner)) catch failure:
owner.release()
error(failure.code, failure.message)
## Drop what was derived before a change.
func changed():
let derived = self.derived
if let made = derived.records:
made.close()
free(made) in memory.heap
derived.records = none
if let cache = derived.faces:
dispose_cache(cache)
derived.faces = none
for kept in derived.meshes.view(): kept.mesh.release()
derived.meshes.count = 0
drop_quick(derived)
derived.boundaries.clear()
## Disposable per-face display mesh; independent of the whole-model budget.
pub func preview_face(face: i64, divisions: i64 = 8) -> interop.Reference[Mesh]!:
try self.check_face(face)
let records = try self.tessellation_records()
let entry = records.faces[(usize)face]
return try published(try face_mesh(self.vertices.view(), records.edges, records.surfaces[(usize)entry.surface], entry, divisions, self.tolerance))
## Boundary-conforming tessellation; each shared edge is sampled once.
## `curvature` adds corner attributes curvature.k1/k2 (principal
## curvatures, k1 >= k2, positive where convex); `directions` adds the unit
## principal directions curvature.d1/d2. Both are off by default.
## With `quick`, a copy with moved cvs may answer with its quick preview
## (quick.lucb) instead of tessellating.
pub func mesh(divisions: i64 = 16, edge_size: f64 = 0.0, progress: interop.Callback[f64, unit]? = none, curvature: bool = false, directions: bool = false, quick: bool = false) -> interop.Reference[Mesh]!:
if not math.is_finite(edge_size) or edge_size < 0.0:
error(invalid, "edge size must be finite and nonnegative")
# The same parameters give the same mesh: share the kept one.
if let kept = self.kept_mesh(divisions, edge_size, curvature, directions): return kept
if quick:
if let fast = try self.quick_mesh(divisions, edge_size, curvature, directions): return fast
let records = try self.tessellation_records()
let raw = try published(try tessellate(self.vertices.view(), records.edges, records.surfaces, records.faces, divisions, self.tolerance, edge_size, progress, -1, curvature, directions, try self.face_cache()))
let made = try self.with_paths(raw)
errdefer made.release()
try self.keep_mesh(divisions, edge_size, curvature, directions, made)
return made
## Takes `mesh`: with each face's B-rep path (by its `cad_face`) in the
## `path` text attribute, when any face has one.
func with_paths(mesh: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
var any = false
for path in self.face_paths.view():
if let text = path: any = any or text.value != ""
let source = mesh.value().find_attribute("cad_face", 2)
if not any or source < 0: return mesh
defer mesh.release()
var strings = TableBuilder()
defer strings.close()
let count = self.face_paths.count
let face_paths = try new i32[count] --- in memory.heap
defer free(face_paths) in memory.heap
for face in 0..<count:
face_paths[face] = -1
if let text = self.face_paths.items[face]:
if text.value != "": face_paths[face] = try strings.intern(text.value)
let faces = (usize)mesh.value().face_count()
let values = try new i32[faces] --- in memory.heap
defer free(values) in memory.heap
for face in 0..<faces:
let original = (i64)(try mesh.value().attribute_value(source, (i64)face))
values[face] = face_paths[(usize)original] if original >= 0 and (usize)original < count else -1
return try mesh.value().with_attribute_entry(try text_attribute("path", Domain.face, faces, &strings, values))
## Diagnostic face mesh using the complete model's shared edge/layout plan.
## Other face jobs are skipped; success does not establish whole-model validity.
pub func planned_face(face: i64, divisions: i64 = 16, edge_size: f64 = 0.0) -> interop.Reference[Mesh]!:
try self.check_face(face)
if not math.is_finite(edge_size) or edge_size < 0.0: error(invalid, "edge size must be finite and nonnegative")
let records = try self.tessellation_records()
let result = try tessellate(self.vertices.view(), records.edges, records.surfaces, records.faces, divisions, self.tolerance, edge_size, none, face)
defer result.release()
return try published(try result.value().compacted())
pub func close():
self.changed()
self.derived.meshes.close()
self.derived.boundaries.close()
free(self.derived) in memory.heap
self.vertices.close()
self.curve_kind.close()
self.curve_ends.close()
self.curve_frame.close()
self.curve_degree.close()
self.curve_sense.close()
self.curve_point_offsets.close()
self.curve_points.close()
self.curve_weight_offsets.close()
self.curve_weights.close()
self.curve_knot_offsets.close()
self.curve_knots.close()
self.surface_kind.close()
self.surface_edited.close()
self.surface_frame.close()
self.surface_dims.close()
self.surface_cv_offsets.close()
self.cv_positions.close()
self.surface_weight_offsets.close()
self.cv_weights.close()
self.surface_knot_offsets.close()
self.surface_knots.close()
self.face_surface.close()
self.face_sense.close()
self.face_use_offsets.close()
self.face_uses.close()
self.face_loop_offsets.close()
self.loop_sizes.close()
self.face_placement.close()
self.face_color.close()
self.face_colored.close()
for path in self.face_paths.view():
if let text = path: text.release()
self.face_paths.close()
pub let brep_model_type: interop.Type[BrepModel] = interop.Type[BrepModel]("BrepModel", BrepModel.close, closeable = true)
## A curve frame's values.
func curve_frame(origin: Vector3, x: Vector3, y: Vector3, radius: f64, angle: f64, sweep: f64) -> f64[12]:
return [origin.x, origin.y, origin.z, x.x, x.y, x.z, y.x, y.y, y.z, radius, angle, sweep]
## A sweep taken the way `sense` runs, never zero.
func swept(value: f64, sense: bool) -> f64:
var sweep = value
if sense:
while sweep <= 0.000000000001: sweep += 6.283185307179586
else:
while sweep >= -0.000000000001: sweep -= 6.283185307179586
return sweep
## Every record, in model order.
func make_records(model: const BrepModel*) -> Records*!:
let edges = try new Curve[(usize)model.edge_count()] --- in memory.heap
errdefer free(edges) in memory.heap
let surfaces = try new Surface[(usize)model.surface_count()] --- in memory.heap
errdefer free(surfaces) in memory.heap
let faces = try new BrepFace[(usize)model.face_count()] --- in memory.heap
errdefer free(faces) in memory.heap
let made = try new Records(edges, surfaces, faces) in memory.heap
errdefer:
for edge in made.edges[..<made.made_edges]: edge.close()
for surface in made.surfaces[..<made.made_surfaces]: surface.close()
for face in made.faces[..<made.made_faces]: face.close()
free(made) in memory.heap
for index in 0..<edges.length:
edges[index] = try model.curve(index)
made.made_edges += 1
for index in 0..<surfaces.length:
surfaces[index] = try model.surface(index)
made.made_surfaces += 1
for index in 0..<faces.length:
faces[index] = try model.face(index)
made.made_faces += 1
return made
## Tessellation works on precise meshes (f64 points; see geocore's
## Mesh); what it hands out is an ordinary f32 mesh. Takes `mesh`.
pub func published(mesh: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
defer mesh.release()
return try mesh.value().without_precision()