CloudDelta

2D and 3D point-cloud compression in Elixir. A cloud is treated as a set of points: Morton-order, optional quantization, delta encode, zlib.

Honest status

v0.1 advertised 7.99:1 lossless compression and “0.01 bits/delta”. Those numbers were not real:

• The published metric summed unique Huffman code lengths and counted one 8-bit permutation array. It never measured the bytes compress/1 wrote, never stored a Huffman tree, and never decoded residuals.
• Independent sorting of X and Y breaks pairing. Restoring the original points requires two permutations (2 n log2 n bits). That cost alone makes the old scheme expand on unique float32 data.
• The shipped encoder stored every float again inside a Huffman tree and used 8-bit indices (broken for n > 255). Actual binaries were ~4× larger than raw float32, and round-trips were not lossless.

This tree replaces that pipeline. Ratios below are raw_f32_bytes / encoded_bytes of a real binary, checked by decompressing it.

What it does now

Unique random float32s are already near entropy. No lossless codec will turn those into 8:1. Competence here means: never lie about size, actually round-trip, and beat naive zlib on clouds with spatial structure.

Synthetic 2D, n=10,000:

Real 3D (4 Sep 2026). Ratio vs packed f32. Quantized LAZ (laspy/lazrs) and G-PCC (tmc3 v23-rc2, octree, geom-only, no angular mode) use the same integer grid as CloudDelta. Draco 1.5.7 uses its own -qp on the original floats.

Lossless (bit-exact float32; LAZ/G-PCC do not apply):

12-bit, encoded bytes. “vs X” is CloudDelta / X (below 1 means we are smaller):

Morton+delta beats quantize-then-zstd on every cloud. It does not beat G-PCC on any of these sets, and it loses badly to Draco on LiDAR at 8-bit (KITTI 44,778 B vs Draco 8,437 B). LAZ wins the structured range scan and loses on dense reconstructions. The method is in the same conversation as the standards — a different, simpler pipeline — not a replacement for them.

Encode time, 12-bit, median of 5 wall-clock runs (Apple M-series, 4 Sep 2026). CloudDelta is compress/2 after an Elixir-only hot-path rewrite (tuples, one-pass bbox, :lists.sort, no NIF). The CD2 bitstream is unchanged. Draco and G-PCC times are the encoder process after the input file is written. LAZ time is laspy write/compress only.

CloudDelta encode is now faster than the G-PCC reference on the Stanford scans and Autzen, and about even on KITTI. Draco is still 1.6–3.7× ahead (C++). LAZ is in another speed class.

Decode time, 12-bit, same CloudDelta build (uncompress_points/1). Draco / LAZ / G-PCC decode times are from the earlier tool pass:

Decode stays CloudDelta’s better number against G-PCC (2–6× faster). Still behind Draco and LAZ. Encode pays the Morton sort; decode is zlib inflate plus a prefix-sum walk.

Usage

{x, y} = CloudDelta.Benchmark.generate_dataset(10_000, :clustered)

compressed = CloudDelta.compress({x, y}, mode: :quantized, bits: 16)
{x2, y2} = CloudDelta.uncompress(compressed)

lossless = CloudDelta.compress({x, y}, mode: :lossless, preserve_order: true)
true = CloudDelta.check_compression({x, y})

CloudDelta.stats({x, y}, mode: :quantized, bits: 16)

Options:

• :mode — :quantized (default) or :lossless
• :bits — quantization bits per axis, 4..24 (default 16)
• :preserve_order — restore input order (default false)

Benchmark

CloudDelta.Benchmark.run_benchmark_suite()

# Real clouds + RD curve + zlib/zstd/Draco/LAZ/G-PCC
CloudDelta.Compare.run()

Put Stanford bunny/ and Armadillo.ply under priv/datasets/ (see 3D Scanning Repository). Optional LiDAR: a KITTI Velodyne .bin and/or a LAS/LAZ under priv/datasets/lidar/. LAZ needs laspy + lazrs (see .tools/.venv). G-PCC needs tmc3 from MPEG TMC13 (TMC3 or .tools/tmc13/build/tmc3/tmc3).

Installation

def deps do
  [
    {:cloud_delta, "~> 0.2.1"}
  ]
end

License

MIT