dymokomi/luce-cad
Source of release 0.9.2
0.9.2 / src / polygons / grid.lucb
## Insert a regular planar lattice without changing the constrained boundary.
pub func insert_grid(source: interop.Reference[Mesh], normal: Vector3, spacing: f64, second_spacing: f64 = 0.0, constraints: TrimConstraints = TrimConstraints()) -> interop.Reference[Mesh]!:
if spacing == 0.0:
return source.clone()
if not math.is_finite(spacing) or spacing < 0.0:
error(invalid, "edge size must be finite and nonnegative")
let vertical = second_spacing if second_spacing > 0.0 else spacing
if not math.is_finite(vertical):
error(invalid, "second grid spacing must be finite")
let n = try normal.normalized()
let reference = Vector3(1.0, 0.0, 0.0) if math.abs(n.x) < 0.9 else Vector3(0.0, 1.0, 0.0)
let u = try reference.subtract(n.multiply_scalar(reference.dot(n))).normalized()
let v = n.cross(u)
let input = source.value()
let origin = try input.point(0)
var umin: f64 = 0.0
var umax: f64 = 0.0
var vmin: f64 = 0.0
var vmax: f64 = 0.0
var mesh = try MeshBuilder(precise = true)
defer mesh.close()
try mesh.copy_points(input)
for face in 0..<input.face_count():
try mesh.copy_face(input, face)
for index in 0..<input.point_count():
let p = (try input.point(index)).subtract(origin)
umin = math.min(umin, p.dot(u))
umax = math.max(umax, p.dot(u))
vmin = math.min(vmin, p.dot(v))
vmax = math.max(vmax, p.dot(v))
let nx = math.ceil((umax - umin) / spacing)
let ny = math.ceil((vmax - vmin) / vertical)
if nx * ny > 8192.0:
error(invalid, "edge size produces more than 8192 grid cells on a face; increase it")
let epsilon = math.max(0.000000000001, spacing * vertical * 0.000000001)
for iy in 0..<(usize)ny:
for ix in 0..<(usize)nx:
let p = origin.add(u.multiply_scalar(umin + ((f64)ix + 0.5) * spacing)).add(v.multiply_scalar(vmin + ((f64)iy + 0.5) * vertical))
# Avoid near-duplicate samples. Boundary-edge insertions below are
# rejected so a face cannot independently split a shared CAD edge.
var near = false
for point in mesh.points[..<mesh.np]:
let relative = point.subtract(p)
if math.abs(relative.dot(u)) < spacing * 0.2 and math.abs(relative.dot(v)) < vertical * 0.2:
near = true
break
if near:
continue
for face in 0..<mesh.nf:
let a = mesh.corners[face * 3]
let b = mesh.corners[face * 3 + 1]
let c = mesh.corners[face * 3 + 2]
let pa = mesh.points[(usize)a]
let pb = mesh.points[(usize)b]
let pc = mesh.points[(usize)c]
let ab = pb.subtract(pa).cross(p.subtract(pa)).dot(n)
let bc = pc.subtract(pb).cross(p.subtract(pb)).dot(n)
let ca = pa.subtract(pc).cross(p.subtract(pc)).dot(n)
if ab < -epsilon or bc < -epsilon or ca < -epsilon:
continue
if ab <= epsilon or bc <= epsilon or ca <= epsilon:
let x = a if ab <= epsilon else (b if bc <= epsilon else c)
let y = b if ab <= epsilon else (c if bc <= epsilon else a)
if constraints.contains(x,y): break
let opposite = c if ab <= epsilon else (a if bc <= epsilon else b)
var neighbor: i64 = -1
var other: i64 = -1
for nf in 0..<mesh.nf:
if nf == face:
continue
for at in 0..<(usize)3:
if mesh.corners[nf * 3 + at] == y and mesh.corners[nf * 3 + (at + 1) % 3] == x:
neighbor = (i64)nf
other = mesh.corners[nf * 3 + (at + 2) % 3]
if neighbor < 0:
break
let px = mesh.points[(usize)x]
let py = mesh.points[(usize)y]
let po = mesh.points[(usize)opposite]
let pq = mesh.points[(usize)other]
# An almost-on-edge point must not create zero-area slivers
# on either side, especially in anisotropic UV lattices.
if p.subtract(px).cross(po.subtract(px)).dot(n) <= epsilon or py.subtract(p).cross(po.subtract(p)).dot(n) <= epsilon or p.subtract(py).cross(pq.subtract(py)).dot(n) <= epsilon or px.subtract(p).cross(pq.subtract(p)).dot(n) <= epsilon:
break
let id = try mesh.point(p)
replace(&mesh, face, x, id, opposite)
try append(&mesh, id, y, opposite)
replace(&mesh, (usize)neighbor, y, id, other)
try append(&mesh, id, x, other)
else:
let id = try mesh.point(p)
replace(&mesh, face, a, b, id)
try append(&mesh, b, c, id)
try append(&mesh, c, a, id)
break
return try mesh.finish()
func replace(mesh: MeshBuilder*, face: usize, a: i64, b: i64, c: i64):
mesh.corners[face * 3] = a
mesh.corners[face * 3 + 1] = b
mesh.corners[face * 3 + 2] = c
func append(mesh: MeshBuilder*, a: i64, b: i64, c: i64) -> !:
try mesh.face(3)
try mesh.corner(a)
try mesh.corner(b)
try mesh.corner(c)