Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.4

0.7.4 / tests / mesh / contract_checks.lucb

## Contracts of the verb framework and mesh assembly: parameters left out
## take their initial values and extra ones are refused, every registered
## verb runs on its defaults, the group and subdivision caches tell meshes
## apart, assembly
## refuses meshes past the limits, Fuse merges a large grid of loose quads, and
## distances to faces without area stay finite.
import interop
import memory
from luce_std import math
from luce_geocore import geocore
from luce_geocore.geocore import Mesh, MeshPrimitives, GeometrySet, Verbs, VerbCatalog, Vector3
from luce_geocore.kernel import subdivided_display, mesh_dispose, Domain, Float3, group_bits_of, assembled, max_faces, mesh_level_set, release_grid, clear_group_cache, run_set_verb, find_set_verb
from luce_geocore.core.shared import Column
from luce_geocore.core.growing import Growing
from verb_run import verb_mesh, no_numbers

pub func exercise() -> !:
    defer clear_group_cache()
    try short_parameters()
    try registry_sweep()
    try group_cache_keys()
    try flat_triangle_distance()
    try subdivision_plan_keys()

pub func run() -> !:
    try exercise()
    try assembly_limits()
    try fuse_loose_grid(400)
    print("PASS contracts: parameter defaults, the verb registry, group cache keys, subdivision plan keys, assembly limits, Fuse at scale, distances to flat faces")

## Transform Components with only its translation equals the run with all
## fifteen numbers; a sixteenth is refused.
func short_parameters() -> !:
    let cube = try Mesh.cube(2.0)
    defer cube.release()
    let full = try verb_mesh("Transform Components", cube, "", 0, [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0])
    defer full.release()
    let short = try verb_mesh("Transform Components", cube, "", 0, [0.0, 1.0, 0.0])
    defer short.release()
    let a = full.value().point_span()
    let b = short.value().point_span()
    assert(a.length == 8 and a.length == b.length)
    for at in 0..<a.length: assert(a[at] == b[at])
    assert(math.abs(full.value().bounds().minimum.y - cube.value().bounds().minimum.y - 1.0) < 0.000001)
    let long: f64[16] = [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.0, 0.0]
    assert(try refused(cube, "Transform Components", long))

## Whether verb `name` refuses `numbers` as invalid (memory propagates).
func refused(mesh: interop.Reference[Mesh], name: str, numbers: const f64[]) -> bool!:
    defer clear_group_cache()
    let result = Verbs.run(name, mesh, "", 0, numbers) catch failure:
        if failure.code == memory.exhausted: error(failure.code, failure.message)
        return failure.code == geocore.invalid
    result.release()
    return false

## Every verb's name is unique and each runs on a cube with its initial
## values: it succeeds or refuses the input as invalid, nothing else.
func registry_sweep() -> !:
    let count = VerbCatalog.count()
    assert(count > Verbs.count())
    for index in 0..<count:
        for other in 0..<index: assert(VerbCatalog.name(index) != VerbCatalog.name(other))
        assert(VerbCatalog.number_count(index) >= VerbCatalog.parm_count(index))
    let cube = try Mesh.cube(2.0)
    defer cube.release()
    for index in 0..<Verbs.count():
        _ = try refused(cube, Verbs.name(index), no_numbers())
    let set = try GeometrySet.of_mesh(cube)
    defer set.release()
    for index in Verbs.count()..<count:
        let verb = find_set_verb(VerbCatalog.name(index)) else trap("a catalog verb is registered")
        var output = run_set_verb(&verb, set.value(), set.value(), "", 0, no_numbers(), [""]) catch failure:
            if failure.code == memory.exhausted: error(failure.code, failure.message)
            assert(failure.code == geocore.invalid)
            continue
        output.close()

## One expression on two meshes whose `top` groups differ gives each its own
## bits, however often the cache is asked.
func group_cache_keys() -> !:
    defer clear_group_cache()
    let grid = try MeshPrimitives.grid(2.0, 4)
    defer grid.release()
    let high = try grid.value().with_group("top", 2, [12, 13, 14, 15])
    defer high.release()
    let low = try grid.value().with_group("top", 2, [0, 1])
    defer low.release()
    for _ in 0..<2:
        var first = try group_bits_of(high.value(), "top", Domain.face)
        defer first.bits.release()
        var second = try group_bits_of(low.value(), "top", Domain.face)
        defer second.bits.release()
        assert(first.bits.view()[0] == 0xF000 and second.bits.view()[0] == 0x3)

## A closed tetrahedron with a triangle of three collinear points beside it:
## every sampled distance is finite.
func flat_triangle_distance() -> !:
    let points: Vector3[7] = [Vector3(0.0, 0.0, 0.0), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), Vector3(0.0, 0.0, 1.0), Vector3(2.0, 0.0, 0.0), Vector3(2.5, 0.0, 0.0), Vector3(3.0, 0.0, 0.0)]
    let sizes: i64[5] = [3, 3, 3, 3, 3]
    let corners: i64[15] = [0, 2, 1, 0, 1, 3, 0, 3, 2, 1, 2, 3, 4, 5, 6]
    let mesh = try interop.Reference[Mesh].adopt(try new Mesh(points, sizes, corners) in memory.heap, geocore.mesh_type, memory.heap)
    defer mesh.release()
    let grid = try mesh_level_set(mesh.value(), 0.25, 2.0, "surface")
    defer release_grid(grid)
    assert(grid.values.count() > 0)
    for value in grid.values.view(): assert(math.is_finite((f64)value))

## Offsets claiming one face more than the limit are refused before their
## contents are read.
func assembly_limits() -> !:
    var offsets = try Column[i32].allocate(max_faces + 2)
    _ = assembled(Column[Float3](), Vector3(), offsets, Column[i32](), Column[i32](), Column[Float3](), Column[Vector3]()) catch failure:
        assert(failure.code == geocore.limit)
        return
    trap("assembled took a mesh past the face limit")

## A grid of `cells` by `cells` loose quads (four points each) fuses into
## the grid's points: the spatial hash grows with the mesh.
func fuse_loose_grid(cells: usize) -> !:
    var points = Growing[Vector3]()
    defer points.close()
    var sizes = Growing[i64]()
    defer sizes.close()
    var corners = Growing[i64]()
    defer corners.close()
    let steps: usize[4] = [0, 1, 3, 2]
    for row in 0..<cells:
        for column in 0..<cells:
            try sizes.push(4)
            for step in steps:
                try corners.push((i64)points.count)
                try points.push(Vector3((f64)(column + step % 2) * 0.01, 0.0, (f64)(row + step // 2) * 0.01))
    let loose = try interop.Reference[Mesh].adopt(try new Mesh(points.view(), sizes.view(), corners.view()) in memory.heap, geocore.mesh_type, memory.heap)
    defer loose.release()
    let fused = try verb_mesh("Fuse", loose, "", 0, [0.001])
    defer fused.release()
    assert(fused.value().point_count() == (i64)((cells + 1) * (cells + 1)) and fused.value().face_count() == (i64)(cells * cells))

## A creased cage and the same cage with its `crease` renamed share their
## topology and columns: only the full plan key (which holds attribute
## names) tells them apart, so the renamed cage subdivides smooth.
func subdivision_plan_keys() -> !:
    let cube = try Mesh.cube(2.0)
    defer cube.release()
    # Crease last, so the renamed attribute keeps its place in the order.
    let subdivided = try verb_mesh("Subdivision", cube, "", 0, [1.0, 2.0, 2.0, 1.0])
    defer subdivided.release()
    let marked = try verb_mesh("Crease", subdivided, "", 0, [10.0, 0.0])
    defer marked.release()
    let renamed = try marked.value().renamed_attribute("crease", "kept", 4)
    defer renamed.release()
    let sharp = (try subdivided_display(marked.value())) else trap("no display")
    defer mesh_dispose(sharp)
    let smooth = (try subdivided_display(renamed.value())) else trap("no display")
    defer mesh_dispose(smooth)
    assert(math.abs(sharp.bounds().maximum.x - 1.0) < 0.000001)
    assert(smooth.bounds().maximum.x < 0.99)