dymokomi/luce-geocore
Source of release 0.7.7
0.7.7 / tests / mesh / primitive_checks.lucb
## Primitive checks (POLY-MODELING.md Stage 6): every primitive verb run on
## an empty mesh, by closed forms. Counts per option; every sphere's points
## on its sphere (UV, ico at each subdivision, quad); boxes with divisions
## (one each way is Mesh.cube itself) and rounded by a bevel; caps of every
## kind with rings, cones, frustums and tubes by their polygon volumes;
## discs by their polygon area; tori and twisted tori on their tube; the
## capsule a closed surface within its radius of its axis; the Platonic
## solids resting on a face; the helix closed by its caps; placement by
## Position, Up and Turn; pieces named /box1, /box2 with Name piece, and
## their faces selected.
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, volume, area, surface
pub func exercise() -> !:
defer clear_group_cache()
try box_checks()
try grid_checks()
try sphere_checks()
try round_checks()
try torus_checks()
try solid_checks()
print("PASS primitives: box divisions and bevel, grid and plane, UV/ico/quad spheres on their spheres, capsule, cylinder caps (none, n-gon, fan, grid, rings), cone, frustum, tube, disc, torus and twist, Platonic solids, helix; placement and pieces")
## Primitive `name` with `numbers` on an empty mesh (or on `onto`).
func primitive(name: str, numbers: const f64[], onto: interop.Reference[Mesh]? = none) -> interop.Reference[Mesh]!:
let empty = try Mesh.empty()
defer empty.release()
let input = onto else empty
let result = try Verbs.run(name, input, "", 0, numbers)
defer result.release()
assert(result.value().warning().length == 0)
let product = try result.value().mesh()
errdefer product.release()
# The new faces are the output selection.
let selection = try result.value().selection()
defer selection.release()
assert(selection.value().count() == product.value().face_count() - input.value().face_count())
return product
## Whether primitive `name` refuses `numbers` (memory propagates).
func refuses(name: str, numbers: const f64[]) -> bool!:
let empty = try Mesh.empty()
defer empty.release()
let result = Verbs.run(name, empty, "", 0, numbers) catch failure:
if failure.code == memory.exhausted: error(failure.code, failure.message)
return true
result.release()
return false
## V - E + F.
func euler(mesh: interop.Reference[Mesh]) -> i64!:
return mesh.value().point_count() - (try mesh.value().edge_count()) + mesh.value().face_count()
## Every point `distance` from `center` (within f32 rounding).
func on_sphere(mesh: interop.Reference[Mesh], center: Vector3, distance: f64) -> !:
for at in 0..<mesh.value().point_count():
near((try mesh.value().point(at)).subtract(center).length(), distance, 0.000002 * distance + 0.0000002)
## The area of a regular n-gon of circumradius r.
func ngon(sides: i64, r: f64) -> f64:
return (f64)sides * 0.5 * r * r * math.sin(2.0 * math.pi / (f64)sides)
## How many faces have `size` corners.
func sized(mesh: interop.Reference[Mesh], size: i64) -> i64!:
var count: i64 = 0
for face in 0..<mesh.value().face_count():
if (try mesh.value().face_size(face)) == size: count += 1
return count
func path_of(mesh: interop.Reference[Mesh], face: i64) -> str!:
return try mesh.value().attribute_text(mesh.value().find_attribute("path", 2), face)
func box_checks() -> !:
# One division each way: Mesh.cube, point for point and face for face.
let cube = try Mesh.cube(2.0)
defer cube.release()
let plain = try primitive("Box", no_numbers[..<0])
defer plain.release()
try counts(plain, 8, 6)
for at in 0..<(i64)8: near_point(try plain.value().point(at), try cube.value().point(at))
for face in 0..<(i64)6:
for corner in 0..<(i64)4: assert((try plain.value().face_point(face, corner)) == (try cube.value().face_point(face, corner)))
# A node's shape names nothing; with Name piece on (Edit Mesh's steps),
# /box1, then /box2 beside it.
assert(plain.value().find_attribute("path", 2) < 0)
let named = try primitive("Box", named_box[..<16])
defer named.release()
assert((try path_of(named, 0)) == "/box1")
# Divisions 2, 3, 4: the 3×4×5 lattice's 54 surface points.
let divided_numbers: f64[6] = [2.0, 3.0, 4.0, 2.0, 3.0, 4.0]
let divided = try primitive("Box", divided_numbers[..<6])
defer divided.release()
try counts(divided, 54, 52)
try surface(divided, true)
near(try volume(divided), 24.0, 0.00001)
assert((try euler(divided)) == 2)
# A second box on the first: its own piece, its faces selected.
let twice = try primitive("Box", named_box[..<16], divided)
defer twice.release()
try counts(twice, 62, 58)
assert((try path_of(twice, 0)) == "" and (try path_of(twice, 57)) == "/box1")
let third = try primitive("Box", named_box[..<16], twice)
defer third.release()
assert((try path_of(third, 57)) == "/box1" and (try path_of(third, 63)) == "/box2")
# Rounded edges at 3 segments: Bevel's corners, 8 triangles, the rest quads.
let round_numbers: f64[8] = [2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 0.25, 3.0]
let rounded = try primitive("Box", round_numbers[..<8])
defer rounded.release()
try surface(rounded, true)
assert((try sized(rounded, 3)) == 8 and (try sized(rounded, 4)) == rounded.value().face_count() - 8)
let box = rounded.value().bounds()
near_point(box.minimum, Vector3(-1.0, 0.0, -1.0), 0.00001)
near_point(box.maximum, Vector3(1.0, 2.0, 1.0), 0.00001)
assert((try volume(rounded)) < 7.75 and (try volume(rounded)) > 7.5)
# Placed: standing along +X from (1, 2, 3); the frame's X is world -Z.
let placed_numbers: f64[15] = [2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 0.0, 3.0, 1.0, 2.0, 3.0, 1.0, 0.0, 0.0, 0.0]
let placed = try primitive("Box", placed_numbers[..<15])
defer placed.release()
near_point(placed.value().bounds().minimum, Vector3(1.0, 1.0, 2.0), 0.00001)
near_point(placed.value().bounds().maximum, Vector3(3.0, 3.0, 4.0), 0.00001)
near(try volume(placed), 8.0, 0.00001)
# Turned 90° about Up (+Y): a 4 by 2 base becomes 2 by 4.
let turned_numbers: f64[15] = [4.0, 1.0, 2.0, 1.0, 1.0, 1.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 90.0]
let turned = try primitive("Box", turned_numbers[..<15])
defer turned.release()
near_point(turned.value().bounds().maximum, Vector3(1.0, 1.0, 2.0), 0.00001)
let no_numbers: f64[1] = [0.0]
let named_box: f64[16] = [2.0, 2.0, 2.0, 1.0, 1.0, 1.0, 0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0]
func grid_checks() -> !:
let first = try MeshPrimitives.grid(2.0, 4)
defer first.release()
let grid = try primitive("Grid", no_numbers[..<0])
defer grid.release()
try counts(grid, 25, 16)
for at in 0..<(i64)25: near_point(try grid.value().point(at), try first.value().point(at))
assert((try grid.value().face_normal(0)).y > 0.99)
let wide_numbers: f64[4] = [3.0, 1.0, 3.0, 2.0]
let wide = try primitive("Grid", wide_numbers[..<4])
defer wide.release()
try counts(wide, 12, 6)
try surface(wide, false)
near_point(wide.value().bounds().maximum, Vector3(1.5, 0.0, 0.5))
let plane = try primitive("Plane", no_numbers[..<0])
defer plane.release()
try counts(plane, 4, 1)
near(try area(plane, 0), 4.0)
func sphere_checks() -> !:
# UV: the first sphere's points, then any columns and rows.
let old = try MeshPrimitives.sphere(1.0, 8)
defer old.release()
let eight_numbers: f64[3] = [1.0, 8.0, 4.0]
let eight = try primitive("Sphere", eight_numbers[..<3])
defer eight.release()
try counts(eight, old.value().point_count(), old.value().face_count())
for at in 0..<old.value().point_count(): near_point(try eight.value().point(at), try old.value().point(at))
let uv_numbers: f64[3] = [1.5, 7.0, 5.0]
let uv = try primitive("Sphere", uv_numbers[..<3])
defer uv.release()
try counts(uv, 30, 35)
try on_sphere(uv, Vector3(0.0, 1.5, 0.0), 1.5)
try surface(uv, true)
assert((try volume(uv)) > 0.0 and (try volume(uv)) < 4.0 / 3.0 * math.pi * 3.375)
# Ico: 10 × 4ⁿ + 2 points and 20 × 4ⁿ faces at each subdivision.
var before = 0.0
for n in 0..<(i64)5:
let numbers: f64[2] = [1.0, (f64)n]
let ico = try primitive("Icosphere", numbers[..<2])
defer ico.release()
let power = (i64)math.pow(4.0, (f64)n)
try counts(ico, 10 * power + 2, 20 * power)
try on_sphere(ico, Vector3(0.0, 1.0, 0.0), 1.0)
try surface(ico, true)
assert((try euler(ico)) == 2)
let held = try volume(ico)
assert(held > before and held < 4.0 / 3.0 * math.pi)
before = held
# A point straight up and one straight down.
near(ico.value().bounds().maximum.y, 2.0, 0.000002)
near(ico.value().bounds().minimum.y, 0.0, 0.000002)
# Quad: 6d² + 2 points, 6d² quads.
for d in 1..<(i64)6:
let numbers: f64[2] = [2.0, (f64)d]
let quad = try primitive("Quad Sphere", numbers[..<2])
defer quad.release()
try counts(quad, 6 * d * d + 2, 6 * d * d)
try on_sphere(quad, Vector3(0.0, 2.0, 0.0), 2.0)
try surface(quad, true)
assert((try sized(quad, 4)) == 6 * d * d)
# Capsule: 4 cap rows each end and 3 rows between: 10 rings of 16.
let capsule_numbers: f64[5] = [0.5, 2.0, 16.0, 4.0, 3.0]
let capsule = try primitive("Capsule", capsule_numbers[..<5])
defer capsule.release()
try counts(capsule, 162, 176)
try surface(capsule, true)
assert((try euler(capsule)) == 2)
for at in 0..<capsule.value().point_count():
let p = try capsule.value().point(at)
let along = math.max(0.5, math.min(1.5, p.y))
near(p.subtract(Vector3(0.0, along, 0.0)).length(), 0.5, 0.000002)
# As tall as it is wide: a sphere (the two equators are one).
let round_numbers: f64[5] = [0.5, 1.0, 16.0, 4.0, 3.0]
let ball = try primitive("Capsule", round_numbers[..<5])
defer ball.release()
try counts(ball, 2 + 7 * 16, 8 * 16)
try on_sphere(ball, Vector3(0.0, 0.5, 0.0), 0.5)
func round_checks() -> !:
# Caps of each kind on 8 sides and 2 rows: the side's 16 quads and 24 points.
let kinds: i64[8] = [0, 1, 1, 2, 2, 3, 3, 1]
let rings: i64[8] = [1, 1, 2, 1, 2, 1, 2, 3]
let points: i64[8] = [24, 24, 40, 26, 42, 26, 42, 56]
let faces: i64[8] = [16, 18, 34, 32, 48, 24, 40, 50]
for at in 0..<(usize)8:
let numbers: f64[6] = [1.0, 2.0, 8.0, 2.0, (f64)kinds[at], (f64)rings[at]]
let cylinder = try primitive("Cylinder", numbers[..<6])
defer cylinder.release()
try counts(cylinder, points[at], faces[at])
try surface(cylinder, kinds[at] != 0)
if kinds[at] != 0:
near(try volume(cylinder), 2.0 * ngon(8, 1.0), 0.00001)
assert((try euler(cylinder)) == 2)
# A grid cap needs the sides in fours.
let odd: f64[6] = [1.0, 2.0, 6.0, 1.0, 3.0, 1.0]
assert(try refuses("Cylinder", odd[..<6]))
# A cone closes to its apex; a frustum's volume is h/3 (A + a + √(Aa)).
let cone_numbers: f64[7] = [1.0, 0.0, 2.0, 12.0, 3.0, 2.0, 1.0]
let cone = try primitive("Cone", cone_numbers[..<7])
defer cone.release()
try counts(cone, 12 * 3 + 1 + 1, 36 + 12)
try surface(cone, true)
near(try volume(cone), 2.0 / 3.0 * ngon(12, 1.0), 0.00001)
let frustum_numbers: f64[7] = [1.0, 0.5, 2.0, 12.0, 1.0, 1.0, 1.0]
let frustum = try primitive("Cone", frustum_numbers[..<7])
defer frustum.release()
try surface(frustum, true)
let big = ngon(12, 1.0)
let small = ngon(12, 0.5)
near(try volume(frustum), 2.0 / 3.0 * (big + small + math.sqrt(big * small)), 0.00001)
# A tube's wall: the ring between its polygons, times the height.
let tube_numbers: f64[5] = [1.0, 0.25, 2.0, 10.0, 3.0]
let tube = try primitive("Pipe", tube_numbers[..<5])
defer tube.release()
try counts(tube, 80, 80)
try surface(tube, true)
near(try volume(tube), 2.0 * (ngon(10, 1.0) - ngon(10, 0.75)), 0.00001)
let open_numbers: f64[5] = [1.0, 0.0, 2.0, 10.0, 3.0]
let open = try primitive("Pipe", open_numbers[..<5])
defer open.release()
try counts(open, 40, 30)
try surface(open, false)
# Discs: every fill covers the n-gon, facing up.
let fills: i64[3] = [0, 1, 2]
let disc_faces: i64[3] = [13, 24, 21]
for at in 0..<(usize)3:
let numbers: f64[4] = [1.0, 12.0, (f64)fills[at], 2.0]
let disc = try primitive("Disc", numbers[..<4])
defer disc.release()
assert(disc.value().face_count() == disc_faces[at])
var total = 0.0
for face in 0..<disc.value().face_count():
total += try area(disc, face)
assert((try disc.value().face_normal(face)).y > 0.99)
near(total, ngon(12, 1.0), 0.00001)
try surface(disc, false)
func torus_checks() -> !:
for twist in 0..<(i64)3:
let numbers: f64[5] = [1.0, 0.25, 12.0, 6.0, (f64)twist]
let torus = try primitive("Torus", numbers[..<5])
defer torus.release()
try counts(torus, 72, 72)
try surface(torus, true)
assert((try euler(torus)) == 0)
for at in 0..<torus.value().point_count():
let p = try torus.value().point(at)
let out = math.sqrt(p.x * p.x + p.z * p.z) - 1.0
near(math.sqrt(out * out + (p.y - 0.25) * (p.y - 0.25)), 0.25, 0.000002)
assert((try volume(torus)) > 0.0)
# The first torus's numbering.
let old = try MeshPrimitives.torus(1.0, 0.3, 8)
defer old.release()
let same_numbers: f64[5] = [1.0, 0.3, 8.0, 8.0, 0.0]
let same = try primitive("Torus", same_numbers[..<5])
defer same.release()
for face in 0..<old.value().face_count():
for corner in 0..<(i64)4: assert((try same.value().face_point(face, corner)) == (try old.value().face_point(face, corner)))
func solid_checks() -> !:
let points: i64[5] = [4, 8, 6, 20, 12]
let faces: i64[5] = [4, 6, 8, 12, 20]
let sizes: i64[5] = [3, 4, 3, 5, 3]
for kind in 0..<(usize)5:
let numbers: f64[2] = [(f64)kind, 1.5]
let solid = try primitive("Platonic", numbers[..<2])
defer solid.release()
try counts(solid, points[kind], faces[kind])
assert((try sized(solid, sizes[kind])) == faces[kind])
try surface(solid, true)
assert((try euler(solid)) == 2 and (try volume(solid)) > 0.0)
# Every corner the radius from the center; resting on a face.
var center = Vector3()
for at in 0..<solid.value().point_count(): center = center.add(try solid.value().point(at))
center = center.multiply_scalar(1.0 / (f64)solid.value().point_count())
try on_sphere(solid, center, 1.5)
near(solid.value().bounds().minimum.y, 0.0, 0.000002)
var resting: i64 = 0
for at in 0..<solid.value().point_count():
if (try solid.value().point(at)).y < 0.00001: resting += 1
assert(resting == sizes[kind])
# Helix: 2 turns of 8 steps, 6 sides: 17 rings, capped.
let helix_numbers: f64[7] = [1.0, 0.1, 2.0, 1.0, 8.0, 6.0, 1.0]
let helix = try primitive("Helix", helix_numbers[..<7])
defer helix.release()
try counts(helix, 102, 98)
try surface(helix, true)
assert((try euler(helix)) == 2 and (try volume(helix)) > 0.0)
# Its wire's middle rises from Wire to Wire + Height.
assert(helix.value().bounds().minimum.y > -0.000001 and helix.value().bounds().maximum.y < 1.2 + 0.000001)
let open_numbers: f64[7] = [1.0, 0.1, 2.0, 1.0, 8.0, 6.0, 0.0]
let open = try primitive("Helix", open_numbers[..<7])
defer open.release()
try counts(open, 102, 96)
try surface(open, false)