Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.2

0.7.2 / 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}")