Interactive demonstrator · runs in your browser

PointCloud-ID

Implements Profile 1.1.2

A deterministic identity for a point cloud, not for one file of it. The same survey as LAS, LAZ or COPC gives three different file hashes; this gives one identity. Drop a LAS file below and watch it computed here in your browser — nothing is uploaded.

Reproduce the claims in 90 seconds Try it with your own file

Guided reproduction

Five claims, five checks

Each step states what should happen, then runs in this browser against the committed test vector. Nothing to install, nothing to upload.

Browser capability check

      How it works

      Five construction stages, plus optional signing

      Follow one point from the committed test vector through every stage. Select a stage to see where it happens on this page.

      Schematic cross-encoding example

      Three encodings, three SHA-256 digests, one PointCloud-ID

      This example models one way LAS, LAZ, and COPC differ: record order. Real conversions also rewrite headers, add and drop VLRs, and can renegotiate scale and offset, none of which a browser page reproduces. Even from record order alone a file hash disagrees on all three. Canonicalize the content first, and the PointCloud-ID is identical. The three panels are JSON stand-ins that carry the same points in different orders, not parsed LAS/LAZ/COPC binaries; the manuscript’s E1 evaluation runs the same experiment on real files. Hashes below are computed live with Web Crypto SHA-256.

      PointCloud-ID (all three files)
      computing…
      Same content, one identity. A byte hash cannot tell honest re-encoding from tampering; this can, and it localizes what changed. It also tells you when two files sitting on your own disk are the same survey in different formats.

      Reproduce it yourself

      Compute a PointCloud-ID

      Paste or edit a JSON array of points, then compute. Anything that is not a usable point is named before hashing starts, so you get a specific reason rather than a wrong identity. Attributes are LAS-native domains (intensity u16, classification u8, GPS time float64, RGB u16, returns u8). The profile is the paper’s toy profile (scale 0.5, offset 0, chunk depth 1). The unedited vector must return 526048e1…, the ID committed in the repository.

      Profile notice This demonstrator reproduces the evaluated Profile v1.1.2 vectors. Profile v2.0.2 is an implemented association-sensitive revision that removes the demonstrated coincident-cell contamination; it has not been through the full E1–E5 protocol, and that validation is future work.

      The rules this identity is computed under

      Two files get the same identity when they hold the same points and agree on these rules. Change any of them and watch what happens.

      or drop a LAS survey here — it is read in this tab and never uploaded.
      LAZ and COPC are compressed; this page reads uncompressed LAS. JSON points work too.

      Tamper laboratory

      Try five changes

      Every experiment runs on the toy vector in this tab. The table underneath shows which per-attribute root moved and which did not, which is what “attribute-aware localization” means in practice.

      Canonicalization table — every intermediate value for the toy vector

      What the profile does

      Canonicalization explorer

      The same points, quantized to the grid, encoded as 63-bit Morton codes, and put in canonical order. This order is a pure function of content, which is why reordering a file changes nothing. Chunks are the Morton prefix. A single in-place attribute edit ordinarily localizes to one chunk–attribute pair; insertions, deletions and coincident-point cases may affect more.

      #xyzqxqyqzmortonchunk

      Check a claim without the cloud

      Verify a proof or a signed manifest

      A membership proof shows one (chunk × attribute) leaf is committed to a published ID using only an O(log n) sibling path. A signed manifest checks the COSE / Ed25519 signature over the canonical bytes. Both run here with Web Crypto.

      How the proof folds Three steps, using the document currently in the box.
        Awaiting a document
        Load a proof or signed manifest, then verify.
        What this settles, and what it leaves open

        Scope

        What it settles, and what it leaves open

        Worth reading before you rely on any of this. The boundary is deliberate, and most of the value comes from knowing exactly where it sits.

        PointCloud-ID can establish

        • Two encodings canonicalize to the same in-scope content
        • Signed canonical content has not changed since signing
        • Which spatial regions and which attribute domains differ
        • That a leaf belongs to a committed attribute tree

        It cannot establish

        • That the scene recorded was truthful
        • That the signer is trustworthy
        • That a conversion followed one particular history
        • That nothing moved below one grid step
        • That attributes outside the declared profile are unchanged
        Committed test vectors

        Committed, reproducible

        Test vectors

        The browser recomputes or verifies the browser-compatible vectors below; the final row provides the command for the separately implemented NumPy reproduction.

        Everything else

        Docs, API, and source

        Reference API

        // stage 1: canonicalize (spec §3)
        quantize(v, offset, scale) → int in [0, 2²¹)
        encodeMorton3(qx, qy, qz) → 63-bit code
        canonicalize(points, profile) → chunks
        // stage 2: identity (spec §4-5)
        buildAttributeTree(chunks, attr) → root
        pointCloudId(trees, profile) → 32-byte ID
        proveMembership(…, attr, chunk) → proof
        // stage 3: sign (spec §6)
        signManifest(bytes, key) → COSE_Sign1
        verifyMembershipProof(doc) → verdict

        Reproduce locally

        $ npm run typecheck && npm test # vectors, proofs, signatures, grid domain
        $ npm run gen:vector # toy-10pt → 526048e1…
        $ python eval/pointcloud_id.py # separate NumPy recomputation

        Resources

        Methods paperavailable on publication Canonicalization profile v1available on publication Reference implementationavailable on publication Evaluation protocol E1–E5available on publication LicenseMIT + CC-BY-4.0, on publication

        Open source & research

        Reference impl (TypeScript, zero runtime deps), a separately implemented Python/NumPy recomputation, and a deterministic evaluation harness accompany the paper. Identity is defined only under a declared canonicalization profile.