Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-spz

Source of release 0.1.0

0.1.0 / tests / spz / format_checks.lucb

## The container: malformed and truncated files fail (never trap), version 1's
## f16 positions, and the coordinate system extension with conversions between
## all sixteen systems.
import memory
import interop
from luce_std import math32
import strings
from luce_geocore.geocore import Vector3
from luce_geocore.kernel import GeometrySet, Domain, dispose_set, set_detail
from luce_geocore.splats import sh_color
from luce_compress import gzip
from luce_spz.kernel import Warnings, Converter, decode, read_file, invalid, unsupported
from support import expect, value, position, draw, near

## Whether decoding `data` fails with `code` (and frees what it made).
func fails_with(data: const u8[], code: ErrorCode) -> bool:
    var warnings = Warnings()
    defer warnings.close()
    let made = decode(data, &warnings) catch failure:
        return failure.code == code
    dispose_set(made)
    return false

## Decoding `data` either fails cleanly or gives a set; never traps.
func survives(data: const u8[]):
    var warnings = Warnings()
    defer warnings.close()
    let made = decode(data, &warnings) catch failure:
        expect(failure.code == invalid or failure.code == unsupported or failure.code == memory.exhausted, "damage fails as invalid")
        return
    dispose_set(made)

func fixture(name: str) -> interop.Owned[const u8[]]!:
    var room: u8[128]
    return try read_file(try strings.format(room, f"../fixtures/{name}"))

pub func malformed() -> !:
    expect(fails_with(u8[]((u8*)0, 0), invalid), "an empty file is not SPZ")
    var header: u8[32]
    expect(fails_with(header, invalid), "zeros are not SPZ")
    # NGSP, version 5.
    let newer: u8[32] = [0x4e, 0x47, 0x53, 0x50, 5, 0, 0, 0, 1, 0, 0, 0, 0, 12, 0, 5, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    expect(fails_with(newer, unsupported), "a version past 4 is unsupported")
    var file = try fixture("reference0_v4.spz")
    defer file.release()
    let bytes = file.value
    # Every truncation of a version 4 file, and of a version 3 (gzip) one.
    for length in 0..<bytes.length: expect(fails_with(bytes[..<length], invalid), "a truncated version 4 file is invalid")
    var older = try fixture("reference0_v3.spz")
    defer older.release()
    for length in 0..<older.value.length: expect(fails_with(older.value[..<length], invalid), "a truncated version 3 file is invalid")
    # A byte after the streams.
    let longer = try new u8[bytes.length + 1] in memory.heap
    defer free(longer) in memory.heap
    memory.copy(longer[..<bytes.length], bytes, bytes.length)
    expect(fails_with(longer, invalid), "bytes after the streams are invalid")
    # Damage anywhere: fails or decodes, never traps.
    var damaged = try new u8[bytes.length] in memory.heap
    defer free(damaged) in memory.heap
    var state: u64 = 77
    for round in 0..<(usize)400:
        memory.copy(damaged, bytes, bytes.length)
        let at = (usize)(draw(&state) * (f64)bytes.length)
        damaged[at] = damaged[at] ^ (u8)(1 + (usize)(draw(&state) * 255.0))
        survives(damaged)
    print("ok    malformed, truncated and damaged files fail cleanly")

## A version 1 file by hand: f16 positions and first-three rotations, gzip.
pub func version_one() -> !:
    # Header, then two splats: positions (f16), alphas, colors, scales, rotations.
    let plain: u8[48] = [0x4e, 0x47, 0x53, 0x50, 1, 0, 0, 0, 2, 0, 0, 0, 0, 12, 1, 0,
                         0x00, 0x3c, 0x00, 0xc0, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         128, 255,
                         127, 128, 255, 0, 64, 192,
                         160, 160, 160, 0, 16, 32,
                         128, 128, 128, 255, 128, 128]
    let packed = try gzip.encode(plain)
    defer free(packed) in memory.heap
    var warnings = Warnings()
    defer warnings.close()
    let set = try decode(packed, &warnings)
    defer dispose_set(set)
    # RUB to RDF negates y and z: splat 0 stored at (1, -2, 0.5).
    let p = position(set, 0)
    expect(p.x == 1.0 and p.y == 2.0 and p.z == -0.5, "f16 positions, converted to RDF")
    expect(near(value(set, "rot_0", 0), 1.0, 1.0e-4) and value(set, "rot_1", 0) == (f64)((f32)128.0 * (f32)(1.0 / 127.5) - 1.0), "first-three rotations with w from the rest")
    expect(value(set, "scale_0", 1) == -10.0 and value(set, "scale_2", 1) == -8.0, "log scales")
    let detail = set_detail(set)
    expect(detail.find("gsplat_antialiased", Domain.detail) >= 0, "the antialiased flag is kept")
    print("ok    version 1: f16 positions, first-three rotations, the antialiased flag")

## Conversions: every system to RDF and back is the identity, and SH turned
## with their splat keep their colors toward turned directions.
pub func conversions() -> !:
    var state: u64 = 5
    for system in 1..<(u32)17:
        let there = Converter.between(system, 6)
        let back = Converter.between(6, system)
        for round in 0..<(usize)8:
            var sh: f32[45]
            for at in 0..<(usize)45: sh[at] = (f32)(draw(&state) * 2.0 - 1.0)
            var turned: f32[45] = sh
            there.sh_items(turned, 15)
            var d: f32[3] = [(f32)(draw(&state) - 0.5), (f32)(draw(&state) - 0.5), (f32)(draw(&state) - 0.5)]
            let direction = try Vector3((f64)d[0], (f64)d[1], (f64)d[2]).normalized()
            d = [(f32)direction.x, (f32)direction.y, (f32)direction.z]
            var moved: f32[3] = d
            there.position(moved)
            let before = sh_color(Vector3(0.1, 0.2, 0.3), sh, 15, direction)
            let after = sh_color(Vector3(0.1, 0.2, 0.3), turned, 15, Vector3((f64)moved[0], (f64)moved[1], (f64)moved[2]))
            expect(near(before.x, after.x, 1.0e-4) and near(before.y, after.y, 1.0e-4) and near(before.z, after.z, 1.0e-4), "SH colors follow the conversion")
            back.sh_items(turned, 15)
            for at in 0..<(usize)45: expect(near((f64)turned[at], (f64)sh[at], 1.0e-5), "a conversion and its inverse give the SH back")
            back.position(moved)
            for k in 0..<(usize)3: expect(near((f64)moved[k], (f64)d[k], 1.0e-6), "a conversion and its inverse give positions back")
            var q: f32[4] = [(f32)(draw(&state) - 0.5), (f32)(draw(&state) - 0.5), (f32)(draw(&state) - 0.5), (f32)(draw(&state) - 0.5)]
            let length = math32.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3])
            for k in 0..<(usize)4: q[k] = q[k] / length
            var r: f32[4] = q
            there.rotation(r)
            back.rotation(r)
            let dot = q[0] * r[0] + q[1] * r[1] + q[2] * r[2] + q[3] * r[3]
            expect(math32.abs(dot) > 0.99999, "a conversion and its inverse give rotations back")
    print("ok    16 coordinate systems: conversions invert, SH colors follow the axes")

## The coordinate system extension: a version 4 file marked LUF (7) or RFU
## (12) decodes to its positions in those axes, converted to RDF.
pub func extension() -> !:
    var file = try fixture("reference0_v4.spz")
    defer file.release()
    let bytes = file.value
    var warnings = Warnings()
    defer warnings.close()
    let plain = try decode(bytes, &warnings)
    defer dispose_set(plain)
    for system in [(u32)7, (u32)12]:
        # The header, a 12-byte record, then the table and streams as they were.
        let marked = try new u8[bytes.length + 12] in memory.heap
        defer free(marked) in memory.heap
        memory.copy(marked[..<32], bytes[..<32], 32)
        marked[14] = marked[14] | 2
        marked[16] = 44
        let record: u8[12] = [0x03, 0x00, 0xBE, 0xAD, 4, 0, 0, 0, (u8)system, 0, 0, 0]
        memory.copy(marked[32..<44], record, 12)
        memory.copy(marked[44..], bytes[32..], bytes.length - 32)
        let set = try decode(marked, &warnings)
        defer dispose_set(set)
        for at in 0..<(usize)100:
            # The stored values: RUB's decode undone (x, -y, -z).
            let rdf = position(plain, at)
            let s = Vector3(rdf.x, -rdf.y, -rdf.z)
            let p = position(set, at)
            if system == 7: expect(p.x == -s.x and p.y == -s.y and p.z == s.z, "LUF to RDF negates x and y")
            else: expect(p.x == s.x and p.y == -s.z and p.z == s.y, "RFU to RDF turns about X")
    print("ok    the coordinate system extension: LUF and RFU files decode to RDF")