dymokomi/luce-geocore
Source of release 0.7.3
0.7.3 / tests / mesh / modeling_checks.lucb
## Golden checks of the modeling verbs (PolyBevel, Inset, Extrude modes,
## Loop cut and the rest): element counts, closed surfaces staying closed,
## output selections, determinism, and uv, group and integer attributes
## carried through. The grid fixture is 4 by 4 over -1..1 (point z*5+x,
## face z*4+x) with uv = (x, z), so a correct corner blend keeps every
## corner's uv equal to its point's x and z.
import interop
from luce_std import math
from luce_geocore.geocore import Mesh, MeshPrimitives, AttributeKernels, Verbs, VerbResult, Vector3
from luce_geocore.kernel import clear_group_cache
from verb_run import no_numbers
pub func exercise() -> !:
defer clear_group_cache()
let grid = try fixture()
defer grid.release()
let cube = try Mesh.cube()
defer cube.release()
try bevel_checks(grid, cube)
try extrude_checks(grid, cube)
try loop_cut_checks(grid, cube)
try bridge_checks(grid, cube)
try merge_fill_dissolve_checks(grid, cube)
func fixture() -> interop.Reference[Mesh]!:
let grid = try MeshPrimitives.grid(2.0, 4)
defer grid.release()
let uv = try AttributeKernels.uv_project(grid, 1.0)
defer uv.release()
let top = try uv.value().with_group("top", 2, [12, 13, 14, 15])
defer top.release()
let pinned = try top.value().with_group("pinned", 0, [0, 4, 20, 24])
defer pinned.release()
var ids: f64[16]
for face in 0..<(usize)16: ids[face] = (f64)face * 10.0
return try pinned.value().with_attribute("id", 2, 1, ids, true)
## Run a verb and return its mesh, checking the output selection's size.
func made(mesh: interop.Reference[Mesh], name: str, group: str, group_type: i64, numbers: const f64[], selected: i64) -> interop.Reference[Mesh]!:
let result = try Verbs.run(name, mesh, group, group_type, numbers)
defer result.release()
let selection = try result.value().selection()
defer selection.release()
if selection.value().count() != selected:
print(f"{name} {group}: selected {selection.value().count()}, expected {selected}")
let bad = try result.value().mesh()
defer bad.release()
try dump(bad)
assert(false)
return try result.value().mesh()
## The fixture's attributes and groups came through: uv, the integer face
## ids (each a multiple of ten), the face and point groups.
func carried(mesh: interop.Reference[Mesh]) -> !:
assert(mesh.value().find_attribute("uv", 1) >= 0)
assert(mesh.value().group_size("top", 2) >= 0 and mesh.value().group_size("pinned", 0) >= 0)
let id = mesh.value().find_attribute("id", 2)
assert(id >= 0)
for face in 0..<mesh.value().face_count():
let value = try mesh.value().attribute_value(id, face)
assert(value >= 0.0 and value <= 150.0 and math.abs(value / 10.0 - math.round(value / 10.0)) < 0.000001)
## The same run twice makes the same topology and points.
func stable(mesh: interop.Reference[Mesh], name: str, group: str, group_type: i64, numbers: const f64[]) -> !:
let first = try Verbs.run(name, mesh, group, group_type, numbers)
defer first.release()
let second = try Verbs.run(name, mesh, group, group_type, numbers)
defer second.release()
let a = try first.value().mesh()
defer a.release()
let b = try second.value().mesh()
defer b.release()
assert(a.value().topology_hash() == b.value().topology_hash() and a.value().point_count() == b.value().point_count())
for point in 0..<a.value().point_count():
let p = try a.value().point(point)
let q = try b.value().point(point)
assert(p.x == q.x and p.y == q.y and p.z == q.z)
func near(a: f64, b: f64):
if math.abs(a - b) >= 0.00001: print(f"near: {a} vs {b}")
assert(math.abs(a - b) < 0.00001)
func counts(mesh: interop.Reference[Mesh], points: i64, faces: i64):
if mesh.value().point_count() != points or mesh.value().face_count() != faces:
print(f"counts: {mesh.value().point_count()} points, {mesh.value().face_count()} faces; expected {points}, {faces}")
assert(false)
## Closed and manifold: every edge in two corners, Euler characteristic 2.
func closed(mesh: interop.Reference[Mesh]) -> !:
let edges = try mesh.value().edge_count()
let corners = try mesh.value().domain_count(1)
assert(corners == edges * 2 and mesh.value().point_count() - edges + mesh.value().face_count() == 2)
## Every corner's uv is its point's (x, z): the fixture's planar projection.
func planar_uv(mesh: interop.Reference[Mesh]) -> !:
let uv = mesh.value().find_attribute("uv", 1)
assert(uv >= 0)
for corner in 0..<(try mesh.value().domain_count(1)):
let point = try mesh.value().point(try mesh.value().corner_point(corner))
near(try mesh.value().attribute_value(uv, corner, 0), point.x)
near(try mesh.value().attribute_value(uv, corner, 1), point.z)
func bevel_checks(grid: interop.Reference[Mesh], cube: interop.Reference[Mesh]) -> !:
let round: f64[4] = [0.2, 1.0, 0.5, 1.0]
# One cube edge: its ends go, two slides each; one strip.
let one = try made(cube, "PolyBevel", "p0-1", 2, round, 1)
defer one.release()
counts(one, 10, 7)
try closed(one)
# Two segments: a profile point per end and a patch where the straight
# cut of the third face meets the curved profile.
var two_segments = round
two_segments[1] = 2.0
let curved = try made(cube, "PolyBevel", "p0-1", 2, two_segments, 4)
defer curved.release()
counts(curved, 12, 10)
try closed(curved)
# Every edge: a meet point per face corner, a triangle per cube corner.
let all = try made(cube, "PolyBevel", "", 0, round, 20)
defer all.release()
counts(all, 24, 26)
try closed(all)
let bounds = all.value().bounds()
near(bounds.maximum.x, 1.0)
near(bounds.minimum.y, 0.0)
var three = round
three[1] = 3.0
let rounder = try made(cube, "PolyBevel", "", 0, three, 44)
defer rounder.release()
counts(rounder, 72, 50)
try closed(rounder)
# The same run twice builds the same topology and points.
let again = try made(cube, "PolyBevel", "", 0, three, 44)
defer again.release()
assert(again.value().topology_hash() == rounder.value().topology_hash())
near((try again.value().point(40)).y, (try rounder.value().point(40)).y)
# A line across the grid: strips share their profiles at the points
# they pass through, whose slides replace them.
let line = try made(grid, "PolyBevel", "p10-11-12-13-14", 2, [0.1, 2.0, 0.5, 1.0], 8)
defer line.release()
counts(line, 35, 24)
try planar_uv(line)
assert(line.value().group_size("top", 2) == 4 and line.value().group_size("pinned", 0) == 4)
try carried(line)
try stable(grid, "PolyBevel", "p10-11-12-13-14", 2, [0.1, 2.0, 0.5, 1.0])
# A region's edges with three segments: the strips' ends on the mesh's
# boundary stay open without a warning.
let region = try Verbs.run("PolyBevel", grid, "0-5", 3, [0.1, 3.0, 0.5, 1.0])
defer region.release()
assert(region.value().warning() == "")
# An edge ending inside: its ends stay, in a six-sided strip.
let inner = try made(grid, "PolyBevel", "p11-12", 2, round, 1)
defer inner.release()
counts(inner, 29, 17)
assert((try inner.value().face_size(16)) == 6)
try planar_uv(inner)
let edges = try inner.value().edge_count()
assert(inner.value().point_count() - edges + inner.value().face_count() == 1)
let fanned = try made(grid, "PolyBevel", "p11-12", 2, [0.1, 2.0, 0.5, 1.0], 2)
defer fanned.release()
counts(fanned, 29, 18)
try planar_uv(fanned)
# Two edges meeting at a cube corner share the profile between them.
let corner = try made(cube, "PolyBevel", "p1-0-3", 2, round, 2)
defer corner.release()
counts(corner, 11, 8)
try closed(corner)
let shared = try made(cube, "PolyBevel", "p1-0-3", 2, two_segments, 6)
defer shared.release()
counts(shared, 14, 12)
try closed(shared)
# Only boundary edges: nothing to bevel, the input passes through.
let border = try Verbs.run("PolyBevel", grid, "p0-1", 2, round)
defer border.release()
assert(border.value().warning().length > 0)
let same = try border.value().mesh()
defer same.release()
counts(same, 25, 16)
print("PASS PolyBevel: cube edge, segments, every edge, a line across a grid, an inner edge, boundary pass-through")
func extrude_checks(grid: interop.Reference[Mesh], cube: interop.Reference[Mesh]) -> !:
# A region of four faces: one front point per region point, the inner
# point moved (its input copy goes), walls on the region's boundary.
let region = try made(grid, "PolyExtrude", "5 6 9 10", 3, [0.5, 0.0, 1.0, 0.0, 1.0], 4)
defer region.release()
counts(region, 33, 24)
near((try region.value().face_center(5)).y, 0.5)
near(try region.value().attribute_value(region.value().find_attribute("id", 2), 9), 90.0)
assert(region.value().group_size("top", 2) == 4)
try carried(region)
try stable(grid, "PolyExtrude", "5 6", 3, [0.5, 0.1, 2.0, 1.0, 1.0])
# One by one: every face its own front and walls.
let apart = try made(grid, "PolyExtrude", "5 6", 3, [0.5, 0.0, 1.0, 1.0, 1.0], 2)
defer apart.release()
counts(apart, 33, 24)
# Divisions: rows of wall faces.
let rows = try made(grid, "PolyExtrude", "5", 3, [1.0, 0.0, 2.0, 0.0, 1.0], 1)
defer rows.release()
counts(rows, 33, 24)
near((try rows.value().point(29)).y, 0.5)
# A whole closed cube has no boundary: it moves out, no walls.
let shell = try made(cube, "PolyExtrude", "", 0, [0.5, 0.0, 1.0, 0.0, 1.0], 6)
defer shell.release()
counts(shell, 8, 6)
try closed(shell)
near(shell.value().bounds().maximum.x, 1.0 + 0.5 / math.sqrt(3.0))
# Inset by a distance: the region's rim moves in 0.1 across its faces,
# and the inner corners' uv follow their points.
let inset = try made(grid, "Inset", "5 6", 3, [0.1, 0.0, 0.0, 1.0], 2)
defer inset.release()
counts(inset, 31, 22)
try planar_uv(inset)
try carried(inset)
try stable(grid, "Inset", "5 6", 3, [0.1, 0.0, 0.0, 1.0])
let inner = try inset.value().face_center(5)
near(inner.x, -0.25 + 0.05)
near(inner.z, -0.25)
let each = try made(grid, "Inset", "5 6", 3, [0.1, 0.2, 1.0, 1.0], 2)
defer each.release()
counts(each, 33, 24)
near((try each.value().face_center(6)).y, 0.2)
# Clamped: a thickness past half the face stops at half its edges.
let clamped = try made(grid, "Inset", "5", 3, [2.0, 0.0, 0.0, 1.0], 1)
defer clamped.release()
counts(clamped, 29, 20)
# Edges extrude into quads, outward for a boundary edge; the front edges
# are selected and the input's open side grows.
let flap = try made(grid, "PolyExtrude", "p0-1-2", 2, [0.5, 0.0, 1.0, 0.0, 1.0], 2)
defer flap.release()
counts(flap, 28, 18)
let result = try Verbs.run("PolyExtrude", grid, "p0-1-2", 2, [0.5, 0.0, 1.0, 0.0, 1.0])
defer result.release()
let fronts = try result.value().selection()
defer fronts.release()
assert(fronts.value().domain() == 4)
near((try flap.value().point(26)).z, -1.5)
# Nothing to extrude passes through with a warning.
let none_left = try Verbs.run("PolyExtrude", grid, "p0-1", 2, [0.0, 0.0, 1.0, 0.0, 1.0])
defer none_left.release()
assert(none_left.value().warning().length > 0)
print("PASS PolyExtrude and Inset: regions, individual faces, divisions, closed shells, distance insets, clamping, edges")
func loop_cut_checks(grid: interop.Reference[Mesh], cube: interop.Reference[Mesh]) -> !:
# The ring through a grid's edge: a new loop across its column of quads,
# the new edges selected, the uv following the points.
let one = try made(grid, "Loop Cut", "p0-1", 2, [1.0, 0.0, 1.0], 4)
defer one.release()
counts(one, 30, 20)
try planar_uv(one)
try carried(one)
try stable(grid, "Loop Cut", "p0-1", 2, [2.0, 0.3, 1.0])
near((try one.value().point(25)).x, -0.75)
# Two cuts slid toward the ring's start.
let two = try made(grid, "Loop Cut", "p0-1", 2, [2.0, -0.5, 1.0], 8)
defer two.release()
counts(two, 35, 24)
try planar_uv(two)
near((try two.value().point(25)).x, -1.0 + 0.5 / 3.0 - 0.5 * 0.98 * 0.5 / 3.0)
# Around a cube: closed, 4 quads cut; two crossing rings stay closed.
let ring = try made(cube, "Loop Cut", "p0-1", 2, [1.0, 0.0, 1.0], 4)
defer ring.release()
counts(ring, 12, 10)
try closed(ring)
let crossing = try Verbs.run("Loop Cut", cube, "p0-1 p0-3", 2, [1.0, 0.0, 1.0])
defer crossing.release()
let crossed = try crossing.value().mesh()
defer crossed.release()
try closed(crossed)
# Only between the group's edges: one quad.
let between = try made(grid, "Loop Cut", "p0-1 p5-6", 2, [1.0, 0.0, 0.0], 1)
defer between.release()
counts(between, 27, 17)
let alone = try Verbs.run("Loop Cut", grid, "p0-1", 2, [1.0, 0.0, 0.0])
defer alone.release()
assert(alone.value().warning().length > 0)
print("PASS Loop Cut: grid ring, cuts and slide, cube ring, crossing rings, group-only cut, pass-through")
func bridge_checks(grid: interop.Reference[Mesh], cube: interop.Reference[Mesh]) -> !:
# Two rows of a grid apart: bridging their facing runs with two
# divisions rebuilds the missing rows, uv and all.
let apart = try made(grid, "Delete", "4-11", 3, [0.0], 0)
defer apart.release()
counts(apart, 20, 8)
let rebuilt = try made(apart, "Bridge", "p5-6-7-8-9 p10-11-12-13-14", 2, [2.0, 0.0], 8)
defer rebuilt.release()
counts(rebuilt, 25, 16)
try planar_uv(rebuilt)
try carried(rebuilt)
try stable(apart, "Bridge", "p5-6-7-8-9 p10-11-12-13-14", 2, [2.0, 0.0])
let edges = try rebuilt.value().edge_count()
assert(rebuilt.value().point_count() - edges + rebuilt.value().face_count() == 1)
# Runs of different lengths zip together with triangles.
let zipped = try made(apart, "Bridge", "p5-6-7-8-9 p10-11-12", 2, [1.0, 0.0], 6)
defer zipped.release()
counts(zipped, 20, 14)
# Holes through two opposite sides of a cube: bridged, a tunnel makes
# a closed surface of genus one.
let insets = try made(cube, "Inset", "4 5", 3, [0.4, 0.0, 1.0, 1.0], 2)
defer insets.release()
let holes = try made(insets, "Delete", "4 5", 3, [0.0], 0)
defer holes.release()
let tunnel = try made(holes, "Bridge", "", 0, [1.0, 0.0], 4)
defer tunnel.release()
counts(tunnel, 16, 16)
let tunnel_edges = try tunnel.value().edge_count()
assert((try tunnel.value().domain_count(1)) == tunnel_edges * 2 and tunnel.value().point_count() - tunnel_edges + tunnel.value().face_count() == 0)
# One run alone has nothing to bridge to.
let alone = try Verbs.run("Bridge", apart, "p5-6-7", 2, [1.0, 0.0])
defer alone.release()
assert(alone.value().warning().length > 0)
print("PASS Bridge: runs with divisions, zipped runs, a tunnel through a cube, pass-through")
func merge_fill_dissolve_checks(grid: interop.Reference[Mesh], cube: interop.Reference[Mesh]) -> !:
# Merge at the center: a face's four points become one; the faces
# around lose a corner, the face itself goes.
let center = try made(grid, "Merge Points", "6 7 11 12", 1, [0.0, 0.001], 1)
defer center.release()
counts(center, 22, 15)
try carried(center)
try stable(grid, "Merge Points", "6 7 11 12", 1, [0.0, 0.001])
let at_first = try made(grid, "Merge Points", "6 7", 1, [1.0, 0.001], 1)
defer at_first.release()
counts(at_first, 24, 16)
near((try at_first.value().point(6)).x, -0.5)
let at_last = try made(grid, "Merge Points", "6 7", 1, [2.0, 0.001], 1)
defer at_last.release()
near((try at_last.value().point(6)).x, 0.0)
# Islands: two separate pairs merge separately, each at its center.
let islands = try made(grid, "Merge Points", "0 1 23 24", 1, [3.0, 0.001], 2)
defer islands.release()
counts(islands, 23, 16)
near((try islands.value().point(0)).x, -0.75)
# By distance: split faces fuse back.
let split = try made(grid, "Split", "0", 3, no_numbers(), 1)
defer split.release()
let fused = try made(split, "Merge Points", "*", 1, [4.0, 0.001], 4)
defer fused.release()
counts(fused, 25, 16)
# Fill as a fan: a center point and a triangle per boundary edge.
let holed = try made(grid, "Delete", "5", 3, [0.0], 0)
defer holed.release()
let fan = try made(holed, "Fill", "p6-11-12-7-6", 2, [1.0], 4)
defer fan.release()
counts(fan, 26, 19)
try planar_uv(fan)
try carried(fan)
try stable(holed, "Fill", "p6-11-12-7-6", 2, [1.0])
near((try fan.value().point(25)).x, -0.25)
# Dissolve points: an inner point's faces join into one and the point
# goes; a border point between two edges leaves its faces.
let inner = try made(grid, "Dissolve", "12", 1, no_numbers(), 1)
defer inner.release()
counts(inner, 24, 13)
try carried(inner)
try stable(grid, "Dissolve", "12", 1, no_numbers())
# A face group dissolves only the edges between its faces: the first
# two columns join into one face, their inner points gone.
let pairs = try made(grid, "Dissolve", "0-15:2,4", 3, no_numbers(), 1)
defer pairs.release()
counts(pairs, 22, 9)
let border = try made(grid, "Dissolve", "2", 1, no_numbers(), 1)
defer border.release()
counts(border, 24, 15)
# Cube corner: its three faces join into one face without it.
let corner = try made(cube, "Dissolve", "0", 1, no_numbers(), 1)
defer corner.release()
counts(corner, 7, 4)
print("PASS Merge Points (center, first, last, islands, distance), Fill fan, Dissolve points and face groups; uv, groups and ids carried; runs repeat exactly")
func dump(mesh: interop.Reference[Mesh]) -> !:
print(f"{mesh.value().point_count()} points {mesh.value().face_count()} faces")
for point in 0..<mesh.value().point_count():
let p = try mesh.value().point(point)
print(f" p{point} {p.x} {p.y} {p.z}")
for face in 0..<mesh.value().face_count():
let size = try mesh.value().face_size(face)
let a = try mesh.value().face_point(face, 0)
let b = try mesh.value().face_point(face, 1)
let c = try mesh.value().face_point(face, 2)
let d = try mesh.value().face_point(face, 3) if size > 3 else -1
print(f" f{face} size {size}: {a} {b} {c} {d}")