Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / tests / bench / geometry.lucb

## The geometry-family benchmark: curves at scale (building, evaluating,
## frames, the curve verbs), fields, and large n-gons' display
## triangulation. Prints one `name<TAB>milliseconds<TAB>count`
## line per case, as verbs.lucb does; run.py makes the table. Each figure is
## one run of a --native --opt 3 build.
import time
from luce_std import math
import interop
import memory
from luce_geocore import geocore, kernel as geocore_kernel
from luce_geocore.geocore import Vector3, Mesh, MeshPrimitives, GeometrySet
from luce_geocore.kernel import Curves, CurvesBuilder, CurveType, evaluated_positions, evaluated_frames, curves_dispose, curves_type, set_curves, empty_set, dispose_set, adopt_set, run_set_verb, find_set_verb, save_geometry, load_geometry
from luce_geocore.core.growing import Growing
from luce_geocore.kernel import SdfOp, primitive_sdf, combined_sdf, release_sdf, sampled_sdf, surface_mesh, release_grid, mesh_level_set, points_level_set, mesh_dispose
from io import path
from luce_std import parallel as std_parallel

func row(name: str, started: u64, count: usize):
    print(f"{name}\t{(f64)time.since(started) / 1000000.0}\t{count}\t")

## `count` wavy curves of `points` points each, of `kind`.
func wavy(count: usize, points: usize, kind: CurveType) -> Curves*!:
    var builder = CurvesBuilder()
    defer builder.close()
    for curve in 0..<count:
        try builder.begin(kind, false, 12, 4)
        for at in 0..<points:
            let x = (f64)at * 0.1
            try builder.point(Vector3(x, math.sin(x + (f64)curve), (f64)curve * 0.05))
    return try builder.finish()

func set_of(curves: Curves*) -> interop.Reference[GeometrySet]!:
    let storage = try empty_set()
    try storage.put(curves_type(), (void*)curves)
    return try adopt_set(storage)

func verb(name: str, set: const GeometrySet*, numbers: const f64[]) -> interop.Reference[GeometrySet]!:
    let found = find_set_verb(name) else trap("no verb")
    var output = try run_set_verb(&found, set, none, "", 0, numbers, [""])
    defer output.close()
    let made = output.set else trap("no set")
    output.set = none
    return try adopt_set(made)

## The n×n quad grid of the verb benchmark (837: 702,244 points, 700,569
## faces).
func quad_grid(n: usize) -> interop.Reference[Mesh]!:
    let points = try new Vector3[(n + 1) * (n + 1)] --- in memory.heap
    defer free(points) in memory.heap
    let sizes = try new i64[n * n] --- in memory.heap
    defer free(sizes) in memory.heap
    let corners = try new i64[n * n * 4] --- in memory.heap
    defer free(corners) in memory.heap
    for z in 0..<n + 1:
        for x in 0..<n + 1: points[z * (n + 1) + x] = Vector3((f64)x - (f64)n * 0.5, 0.0, (f64)z - (f64)n * 0.5)
    for z in 0..<n:
        for x in 0..<n:
            let a = (i64)(z * (n + 1) + x)
            let face = z * n + x
            sizes[face] = 4
            corners[face * 4] = a
            corners[face * 4 + 1] = a + (i64)n + 1
            corners[face * 4 + 2] = a + (i64)n + 2
            corners[face * 4 + 3] = a + 1
    return try interop.Reference[Mesh].adopt(try new Mesh(points, sizes, corners) in memory.heap, geocore.mesh_type, memory.heap)

pub func main(arguments: str[]) -> i32!:
    std_parallel.warm()
    var started = time.now()
    let bezier = try wavy(10000, 32, CurveType.bezier)
    row("Curves: build 10k Bezier curves of 32 points", started, bezier.point_count())
    let set = try set_of(bezier)
    defer set.release()
    started = time.now()
    let points = try evaluated_positions(bezier)
    row("Curves: evaluate 10k Bezier curves, resolution 12", started, points.length)
    started = time.now()
    let frames = try evaluated_frames(bezier)
    row("Curves: tangents, normals and lengths of those", started, frames.tangents.length)
    let nurbs = try wavy(10000, 32, CurveType.nurbs)
    defer curves_dispose(nurbs)
    started = time.now()
    let spline = try evaluated_positions(nurbs)
    row("Curves: evaluate 10k NURBS curves (order 4), resolution 12", started, spline.length)
    started = time.now()
    let resampled = try verb("Resample Curve", set.value(), [0.0, 64.0, 0.1])
    row("Resample Curve: 10k curves to 64 points", started, (set_curves(resampled.value()) else trap("curves")).point_count())
    resampled.release()
    let few = try set_of(try wavy(1000, 32, CurveType.catmull_rom))
    defer few.release()
    started = time.now()
    let tubes = try verb("Curve to Mesh", few.value(), [0.0, 0.02, 12.0, 1.0, 1.0, 0.0])
    let tube_mesh = (try tubes.value().mesh()) else trap("mesh")
    row("Curve to Mesh: 1k Catmull-Rom curves, 12-point circle", started, (usize)tube_mesh.value().face_count())
    tube_mesh.release()
    tubes.release()
    let grid = try quad_grid(837)
    defer grid.release()
    let sheet = try GeometrySet.of_mesh(grid)
    defer sheet.release()
    _ = try grid.value().edge_count()
    started = time.now()
    let outline = try verb("Mesh to Curve", sheet.value(), [1.0])
    row("Mesh to Curve: the 837x837 grid's boundary", started, (set_curves(outline.value()) else trap("curves")).point_count())
    outline.release()
    # The codec: the grid with uv, saved to a .prism crate and loaded back.
    let mapped = try geocore.AttributeKernels.uv_project(grid, 1.0)
    defer mapped.release()
    let textured = try GeometrySet.of_mesh(mapped)
    defer textured.release()
    var file = Growing[u8]()
    defer file.close()
    try file.assign(path.temp().bytes)
    for byte in "/luce-geocore-bench.prism".bytes: try file.push(byte)
    started = time.now()
    let saved = try save_geometry(textured.value(), (str)file.view(), 1, 268435456)
    row("Save: the 837x837 grid with uv to .prism", started, saved)
    started = time.now()
    let loaded = try adopt_set(try load_geometry((str)file.view()))
    row("Load: that .prism back", started, (usize)((try loaded.value().mesh()) else trap("mesh")).value().face_count())
    loaded.release()
    started = time.now()
    let wires = try verb("Mesh to Curve", sheet.value(), [0.0])
    row("Mesh to Curve: every edge of the 837x837 grid", started, (set_curves(wires.value()) else trap("curves")).curve_count())
    wires.release()
    try fields()
    try large_faces()
    return 0

## Display triangulation of single large faces (ear clipping on a ring):
## a regular 20,000-gon, a 5,003-corner comb of thin teeth over a bar, a
## 5,000-corner spiral corridor, and a Mesh of one 20,000-corner face.
func large_faces() -> !:
    let names: str[3] = ["Triangulate: a regular 20,000-gon", "Triangulate: a 5,003-corner comb", "Triangulate: a 5,000-corner spiral"]
    for shape in 0..<(usize)3:
        let count: usize = 20000 if shape == 0 else (5003 if shape == 1 else 5000)
        var points = Growing[Vector3]()
        defer points.close()
        if shape == 0:
            for at in 0..<count:
                let angle = (f64)at * 6.283185307179586 / (f64)count
                try points.push(Vector3(math.cos(angle), math.sin(angle), 0.0))
        elif shape == 1:
            let teeth = (count - 3) // 4
            try points.push(Vector3(0.0, 0.0, 0.0))
            try points.push(Vector3((f64)teeth, 0.0, 0.0))
            try points.push(Vector3((f64)teeth, 1.0, 0.0))
            var tooth = teeth
            while tooth > 0:
                tooth -= 1
                let x = (f64)tooth
                try points.push(Vector3(x + 0.5, 1.0, 0.0))
                try points.push(Vector3(x + 0.5, 11.0, 0.0))
                try points.push(Vector3(x, 11.0, 0.0))
                try points.push(Vector3(x, 1.0, 0.0))
        else:
            let side = count // 2
            for wall in [(usize)0, 1]:
                for step in 0..<side:
                    let at = step if wall == 0 else side - 1 - step
                    let angle = 6.0 * 3.141592653589793 * (f64)at / (f64)(side - 1)
                    let radius = 1.0 + 0.25 * angle / 3.141592653589793 + (0.2 if wall == 0 else 0.0)
                    try points.push(Vector3(radius * math.cos(angle), radius * math.sin(angle), 0.0))
        let corners = try new i64[points.count] --- in memory.heap
        defer free(corners) in memory.heap
        for at in 0..<points.count: corners[at] = (i64)at
        let output = try new i64[(points.count - 2) * 3] --- in memory.heap
        defer free(output) in memory.heap
        let started = time.now()
        try geocore_kernel.triangulate_polygon(points.view(), corners, 0, points.count, Vector3(0.0, 0.0, 1.0), output)
        row(names[shape], started, output.length // 3)
        if shape == 0:
            let built = time.now()
            var face = try Mesh(points.view(), [(i64)count], corners)
            defer face.close()
            row("Mesh: one 20,000-corner face (validated, triangulated)", built, (usize)face.index_count() // 3)

## Volumes and SDFs: sampling, surface nets, a mesh's and points' level sets.
func fields() -> !:
    let ball = try primitive_sdf(SdfOp.sphere, [0.0, 0.0, 0.0, 1.0])
    defer release_sdf(ball)
    let block = try primitive_sdf(SdfOp.rounded_box, [0.8, 0.0, 0.0, 0.6, 0.6, 0.6, 0.1])
    defer release_sdf(block)
    let shape = try combined_sdf(ball, block, SdfOp.smooth_unite, 0.3)
    defer release_sdf(shape)
    var started = time.now()
    let grid = try sampled_sdf(shape, 0.005, 3.0, "surface")
    defer release_grid(grid)
    row("SDF to Volume: a smooth union, voxel 1/400 of its size", started, grid.active_count())
    started = time.now()
    let surface = try surface_mesh(grid, 0.0, none)
    row("Surface nets: that level set", started, (usize)surface.face_count())
    mesh_dispose(surface)
    started = time.now()
    let exact = try surface_mesh(grid, 0.0, shape)
    row("Surface nets projected onto the SDF", started, (usize)exact.face_count())
    mesh_dispose(exact)
    let big = try quad_grid(837)
    defer big.release()
    started = time.now()
    let flat = try mesh_level_set(big.value(), 837.0 / 256.0, 3.0, "surface")
    row("Mesh to SDF: the 837x837 grid, 256 voxels across", started, flat.active_count())
    release_grid(flat)
    let sphere = try MeshPrimitives.sphere(1.0, 64)
    defer sphere.release()
    started = time.now()
    let solid = try mesh_level_set(sphere.value(), 0.01, 3.0, "surface")
    row("Mesh to SDF: a 64-segment sphere, voxel 0.01", started, solid.active_count())
    release_grid(solid)
    var points = Growing[Vector3]()
    defer points.close()
    for at in 0..<(usize)100000:
        let t = (f64)at * 0.001
        try points.push(Vector3(math.cos(t * 7.0) * (1.0 + 0.1 * math.sin(t)), t * 0.01, math.sin(t * 7.0)))
    started = time.now()
    let blobs = try points_level_set(points.view(), 0.02, 0.01, 3.0, "surface")
    row("Volume from Points: 100k points, radius 0.02, voxel 0.01", started, blobs.active_count())
    release_grid(blobs)