dymokomi/luce-geocore
Source of release 0.7.7
0.7.7 / tests / mesh / retopology_checks.lucb
## Retopology checks (POLY-MODELING.md Stage 6): Shrinkwrap onto a sphere
## (nearest: every point on it; an offset that far off it; half strength
## halfway; along a vector straight down, the points past its edge staying
## with a warning; along normals out to a bigger sphere), refused without a
## reference; Relax on a reference keeping every point on it; Poly Pen on
## the 4 by 4 grid over -1..1 in XZ (point z*5+x, face z*4+x): a boundary
## edge extended into a quad (its positions in either order) and into a
## triangle, an inner edge refused, a corner filled back after its face was
## deleted, an edge split in both its faces.
import interop
import memory
from luce_std import math
from luce_geocore.geocore import Mesh, MeshPrimitives, Verbs, Vector3
from luce_geocore.kernel import clear_group_cache
from tool_fixtures import counts, near, near_point, surface
pub func exercise() -> !:
defer clear_group_cache()
try shrinkwrap_checks()
try relax_checks()
try pen_checks()
print("PASS retopology: Shrinkwrap nearest, offset, strength, along a vector and along normals onto a reference, refused without one; Relax kept on a reference; Poly Pen extends an edge into a quad or a triangle, fills a corner, splits an edge")
## Verb `name` on `mesh` with `reference`: its mesh and its warning.
func wrapped(name: str, mesh: interop.Reference[Mesh], group: str, numbers: const f64[], reference: interop.Reference[Mesh]) -> (interop.Reference[Mesh], str)!:
let result = try Verbs.run(name, mesh, group, 1, numbers, 0, false, "", reference)
defer result.release()
return (try result.value().mesh(), result.value().warning())
## A grid of 9 by 9 points over -0.8..0.8 in XZ, at height `y`.
func raised(y: f64) -> interop.Reference[Mesh]!:
let grid = try MeshPrimitives.grid(1.6, 8)
defer grid.release()
return try grid.value().transformed(Vector3(0.0, y, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
func shrinkwrap_checks() -> !:
let ball = try MeshPrimitives.sphere(1.0, 64)
defer ball.release()
let center = Vector3(0.0, 1.0, 0.0)
let grid = try raised(3.0)
defer grid.release()
# Nearest: on the sphere's facets (within their sag below the radius).
let nearest: f64[3] = [0.0, 0.0, 1.0]
let (onto, quiet) = try wrapped("Shrinkwrap", grid, "", nearest[..<3], ball)
defer onto.release()
assert(quiet == "")
for at in 0..<onto.value().point_count():
let p = try onto.value().point(at)
near(try ball.value().surface_distance(p), 0.0, 0.00001)
assert(p.subtract(center).length() > 0.997 and p.subtract(center).length() < 1.00001)
# Offset 0.25 off the surface, along its normal there.
let offset: f64[3] = [0.0, 0.25, 1.0]
let (off, _) = try wrapped("Shrinkwrap", grid, "", offset[..<3], ball)
defer off.release()
for at in 0..<off.value().point_count():
near(try ball.value().surface_distance(try off.value().point(at)), 0.25, 0.00001)
# Half strength: halfway there.
let half: f64[3] = [0.0, 0.0, 0.5]
let (halfway, _) = try wrapped("Shrinkwrap", grid, "", half[..<3], ball)
defer halfway.release()
for at in 0..<halfway.value().point_count():
let p = try grid.value().point(at)
let q = try onto.value().point(at)
near_point(try halfway.value().point(at), p.add(q).multiply_scalar(0.5), 0.00001)
# Straight down: x and z kept, onto the top of the sphere; the points
# past its edge (x² + z² > 1) stay, and the warning says so.
let down: f64[6] = [2.0, 0.0, 1.0, 0.0, -1.0, 0.0]
let wide = try raised(3.0)
defer wide.release()
let scaled = try wide.value().transformed(Vector3(), Vector3(), Vector3(1.5, 1.0, 1.5))
defer scaled.release()
let (dropped, warning) = try wrapped("Shrinkwrap", scaled, "", down[..<6], ball)
defer dropped.release()
assert(warning.length > 0)
for at in 0..<dropped.value().point_count():
let before = try scaled.value().point(at)
let after = try dropped.value().point(at)
near(after.x, before.x, 0.000001)
near(after.z, before.z, 0.000001)
if before.x * before.x + before.z * before.z < 0.9:
near(try ball.value().surface_distance(after), 0.0, 0.00001)
assert(after.y > 1.0)
elif before.x * before.x + before.z * before.z > 1.0:
near(after.y, 3.0, 0.000001)
# Along normals: a small sphere's points out onto a bigger one.
let small = try MeshPrimitives.sphere(0.5, 16)
defer small.release()
let lifted = try small.value().transformed(Vector3(0.0, 0.5, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer lifted.release()
let along: f64[3] = [1.0, 0.0, 1.0]
let (outward, _) = try wrapped("Shrinkwrap", lifted, "", along[..<3], ball)
defer outward.release()
for at in 0..<outward.value().point_count():
let distance = (try outward.value().point(at)).subtract(center).length()
assert(distance > 0.997 and distance < 1.00001)
# A group moves only its points.
let (some, _) = try wrapped("Shrinkwrap", grid, "0-8", nearest[..<3], ball)
defer some.release()
near_point(try some.value().point(9), try grid.value().point(9))
assert((try some.value().point(0)).y < 2.0)
# No reference: refused, as the node's missing second input.
assert(try unreferenced(grid, nearest[..<3]))
## Whether Shrinkwrap without a reference refuses (memory propagates).
func unreferenced(mesh: interop.Reference[Mesh], numbers: const f64[]) -> bool!:
let result = Verbs.run("Shrinkwrap", mesh, "", 1, numbers) catch failure:
if failure.code == memory.exhausted: error(failure.code, failure.message)
return true
result.release()
return false
func relax_checks() -> !:
# A quad sphere's points relaxed over a finer sphere stay on it.
let reference = try MeshPrimitives.sphere(1.0, 48)
defer reference.release()
let numbers: f64[2] = [1.0, 4.0]
let empty = try Mesh.empty()
defer empty.release()
let made = try Verbs.run("Quad Sphere", empty, "", 0, numbers[..<2])
defer made.release()
let quads = try made.value().mesh()
defer quads.release()
let relax: f64[3] = [0.5, 5.0, 0.0]
let (relaxed, _) = try wrapped("Relax", quads, "", relax[..<3], reference)
defer relaxed.release()
var moved = false
for at in 0..<relaxed.value().point_count():
let p = try relaxed.value().point(at)
near(try reference.value().surface_distance(p), 0.0, 0.00001)
if p.subtract(try quads.value().point(at)).length() > 0.001: moved = true
assert(moved)
try surface(relaxed, true)
## Poly Pen's action `action` on `group` (on `group_type`) with positions.
func pen(mesh: interop.Reference[Mesh], action: f64, group: str, group_type: i64, positions: const Vector3[]) -> interop.Reference[Mesh]!:
var numbers: f64[9] = [action, 0.00001, (f64)positions.length, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
for at in 0..<positions.length:
numbers[3 + at * 3] = positions[at].x
numbers[4 + at * 3] = positions[at].y
numbers[5 + at * 3] = positions[at].z
let result = try Verbs.run("Poly Pen", mesh, group, group_type, numbers[..<3 + positions.length * 3])
defer result.release()
assert(result.value().warning().length == 0)
return try result.value().mesh()
func pen_refuses(mesh: interop.Reference[Mesh], action: f64, group: str, group_type: i64, positions: const Vector3[]) -> bool!:
let made = pen(mesh, action, group, group_type, positions) catch failure:
if failure.code == memory.exhausted: error(failure.code, failure.message)
return true
made.release()
return false
func pen_checks() -> !:
let grid = try MeshPrimitives.grid(2.0, 4)
defer grid.release()
# Edge 0-1 (z = -1) grows a quad out to z = -1.5, facing up as the grid.
let outward: Vector3[2] = [Vector3(-1.0, 0.0, -1.5), Vector3(-0.5, 0.0, -1.5)]
let quad = try pen(grid, 0.0, "p0-1", 2, outward[..<2])
defer quad.release()
try counts(quad, 27, 17)
try surface(quad, false)
assert((try quad.value().face_normal(16)).y > 0.99)
# The positions in the other order make the same face.
let swapped: Vector3[2] = [Vector3(-0.5, 0.0, -1.5), Vector3(-1.0, 0.0, -1.5)]
let same = try pen(grid, 0.0, "p0-1", 2, swapped[..<2])
defer same.release()
for corner in 0..<(i64)4: near_point(try same.value().point(try same.value().face_point(16, corner)), try quad.value().point(try quad.value().face_point(16, corner)))
# Edge 1-2 beside it, extended onto the quad's new corner (it snaps):
# one new point, the two quads sharing an edge.
let beside: Vector3[2] = [Vector3(-0.5, 0.0, -1.5), Vector3(0.0, 0.0, -1.5)]
let strip = try pen(quad, 0.0, "p1-2", 2, beside[..<2])
defer strip.release()
try counts(strip, 28, 18)
try surface(strip, false)
# One position: a triangle.
let tip: Vector3[1] = [Vector3(-0.75, 0.0, -1.5)]
let triangle = try pen(grid, 0.0, "p0-1", 2, tip[..<1])
defer triangle.release()
try counts(triangle, 26, 17)
assert((try triangle.value().face_size(16)) == 3 and (try triangle.value().face_normal(16)).y > 0.99)
# An inner edge has a face on each side: refused.
assert(try pen_refuses(grid, 0.0, "p6-7", 2, tip[..<1]))
# Face 0 deleted (and its unused point 0: the others number one less):
# point 5, once 6, sits where two boundary edges meet; its corner filled
# at point 0's old place gives the face back.
let opened = try Verbs.run("Delete", grid, "0", 3, [0.0])
defer opened.release()
let holed = try opened.value().mesh()
defer holed.release()
let corner_at: Vector3[1] = [Vector3(-1.0, 0.0, -1.0)]
let filled = try pen(holed, 1.0, "5", 1, corner_at[..<1])
defer filled.release()
try counts(filled, 25, 16)
try surface(filled, false)
assert((try filled.value().face_normal(15)).y > 0.99)
# Edge 6-7 split at its middle: a point more, both its faces five-sided.
let middle: Vector3[1] = [Vector3(-0.25, 0.0, -0.5)]
let split = try pen(grid, 2.0, "p6-7", 2, middle[..<1])
defer split.release()
try counts(split, 26, 16)
assert((try split.value().face_size(1)) == 5 and (try split.value().face_size(5)) == 5)
try surface(split, false)