Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / tests / mesh / reduce_checks.lucb

## Triangulate's methods, Tris to Quads and Decimate (POLY-MODELING.md
## Stage 5): a grid split along fixed diagonals and joined back into the
## grid; a 16-gon split by Beauty no worse than clipped; Decimate's
## collapse halving a sphere's triangles (closed, its volume near) and a
## flat grid's keeping its square outline; Un-subdivide giving a grid and a
## subdivided cube back, twice over; Planar joining a flat grid. The grid
## is 4 by 4 over -1..1 in XZ.
import interop
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 made, counts, near, near_point, volume, area, surface

pub func exercise() -> !:
    defer clear_group_cache()
    let grid = try MeshPrimitives.grid(2.0, 4)
    defer grid.release()
    try triangle_checks(grid)
    try decimate_checks(grid)
    print("PASS Triangulate, Tris to Quads, Decimate: fixed diagonals joined back into the grid, Beauty no worse than clipping; a sphere halved, a flat grid's outline kept; grids and cubes un-subdivided; Planar")

## Every face's area, summed.
func total_area(mesh: interop.Reference[Mesh]) -> f64!:
    var total = 0.0
    for face in 0..<mesh.value().face_count(): total += try area(mesh, face)
    return total

## The smallest angle among `mesh`'s triangles from face `first` on.
func smallest(mesh: interop.Reference[Mesh], first: i64) -> f64!:
    var least = 10.0
    for face in first..<mesh.value().face_count():
        var p: Vector3[3] = [Vector3(), Vector3(), Vector3()]
        for k in 0..<(i64)3: p[(usize)k] = try mesh.value().point(try mesh.value().face_point(face, k))
        for k in 0..<(usize)3:
            let u = p[(k + 1) % 3].subtract(p[k])
            let v = p[(k + 2) % 3].subtract(p[k])
            least = math.min(least, math.acos(u.dot(v) / (u.length() * v.length())))
    return least

func triangle_checks(grid: interop.Reference[Mesh]) -> !:
    let fixed: f64[2] = [1.0, 0.0]
    let split = try made(grid, "Triangulate", "", 3, fixed[..<2], 32)
    defer split.release()
    try counts(split, 25, 32)
    let methods: f64[4] = [0.0, 2.0, 3.0, 4.0]
    for method in methods:
        let numbers: f64[2] = [method, 0.0]
        let other = try made(grid, "Triangulate", "", 3, numbers[..<2], 32)
        other.release()
    let joining: f64[6] = [40.0, 40.0, 0.0, 0.0, 0.0, 0.0]
    let joined = try made(split, "Quadrangulate", "", 3, joining[..<6], 16)
    defer joined.release()
    try counts(joined, 25, 16)
    for face in 0..<joined.value().face_count(): assert((try joined.value().face_size(face)) == 4)
    near(try total_area(joined), 4.0)
    # A 16-sided cap: Beauty's smallest angle at least the clip's.
    let cylinder = try MeshPrimitives.cylinder(1.0, 2.0, 16)
    defer cylinder.release()
    let beauty: f64[2] = [0.0, 0.0]
    let round = try made(cylinder, "Triangulate", "1", 3, beauty[..<2], 14)
    defer round.release()
    let clipping: f64[2] = [0.0, 1.0]
    let clipped = try made(cylinder, "Triangulate", "1", 3, clipping[..<2], 14)
    defer clipped.release()
    try surface(round, true)
    near(try volume(round), try volume(cylinder))
    let cap = round.value().face_count() - 14
    assert((try smallest(round, cap)) >= (try smallest(clipped, cap)) - 0.000001)

## Decimate's numbers: mode, ratio, iterations, angle, lock boundary.
func reducing(mode: f64, ratio: f64 = 0.5, iterations: f64 = 1.0, lock: bool = false) -> f64[5]:
    return [mode, ratio, iterations, 5.0, 1.0 if lock else 0.0]

func decimate_checks(grid: interop.Reference[Mesh]) -> !:
    let sphere = try MeshPrimitives.sphere(1.0, 24)
    defer sphere.release()
    let all: f64[2] = [0.0, 0.0]
    let triangulated = try Verbs.run("Triangulate", sphere, "", 3, all[..<2])
    defer triangulated.release()
    let tris = try triangulated.value().mesh()
    defer tris.release()
    let before = tris.value().face_count()
    let half = reducing(0.0)
    let result = try Verbs.run("PolyReduce", tris, "", 3, half[..<5])
    defer result.release()
    let halved = try result.value().mesh()
    defer halved.release()
    let after = halved.value().face_count()
    assert(after <= before // 2 + 1 and after >= before * 2 // 5)
    try surface(halved, true)
    assert(math.abs((try volume(halved)) - (try volume(tris))) < 0.05 * (try volume(tris)))
    # A flat 16 by 16 grid to a quarter: the outline stays a square of
    # area 4; locked, its boundary points stay too.
    let fine = try MeshPrimitives.grid(2.0, 16)
    defer fine.release()
    let quarter = reducing(0.0, ratio = 0.25)
    let flat = try Verbs.run("PolyReduce", fine, "", 3, quarter[..<5])
    defer flat.release()
    let thinned = try flat.value().mesh()
    defer thinned.release()
    near(try total_area(thinned), 4.0)
    near(thinned.value().bounds().minimum.x, -1.0)
    near(thinned.value().bounds().maximum.z, 1.0)
    try surface(thinned, false)
    assert(thinned.value().face_count() <= 16 * 16 * 2 // 4 + 1)
    let locking = reducing(0.0, ratio = 0.25, lock = true)
    let locked_run = try Verbs.run("PolyReduce", fine, "", 3, locking[..<5])
    defer locked_run.release()
    let locked = try locked_run.value().mesh()
    defer locked.release()
    var outline: i64 = 0
    for point in 0..<locked.value().point_count():
        let p = try locked.value().point(point)
        if math.abs(math.abs(p.x) - 1.0) < 0.000001 or math.abs(math.abs(p.z) - 1.0) < 0.000001: outline += 1
    assert(outline == 64)
    # Un-subdivide: the 4 by 4 grid to 2 by 2; a cube subdivided once and
    # twice comes back.
    let undo = reducing(1.0)
    let coarse = try made(grid, "PolyReduce", "", 3, undo[..<5], 4)
    defer coarse.release()
    try counts(coarse, 9, 4)
    near(try total_area(coarse), 4.0)
    let cube = try Mesh.cube()
    defer cube.release()
    let linear: f64[3] = [2.0, 0.0, 0.0]
    let twice = try made(cube, "Subdivide", "", 3, linear[..<3], 96)
    defer twice.release()
    let undo_twice = reducing(1.0, iterations = 2.0)
    let back = try made(twice, "PolyReduce", "", 3, undo_twice[..<5], 6)
    defer back.release()
    try counts(back, 8, 6)
    try surface(back, true)
    near(try volume(back), 8.0)
    # Planar: a flat grid is one face.
    let planar = reducing(2.0)
    let one = try made(grid, "PolyReduce", "", 3, planar[..<5], 1)
    defer one.release()
    assert(one.value().face_count() == 1)