@playcanvas/splat-transform 0.5.0 → 0.5.2

package/LICENSE

@@ -1,19 +1,19 @@
-Copyright (c) 2011-2024 PlayCanvas Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+Copyright (c) 2011-2025 PlayCanvas Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,127 +1,127 @@
-# SplatTransform - 3D Gaussian Splat Converter
-
-SplatTransform is an open source CLI tool for reading gaussian splat PLY files and writing them to PLY, Compressed PLY, CSV, and SOGS format.
-
-Multiple files may be combined and transformed before being written to the output.
-
-## Installation
-
-First install the package globally:
-
-```bash
-npm install -g @playcanvas/splat-transform
-```
-
-## Usage
-
-```bash
-splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
-```
-
-**Key points:**
-- Every time an `*.ply*` appears, it becomes the current working set; the following ACTIONS are applied in the order listed
-- The last file on the command line is treated as the output; anything after it is interpreted as actions that modify the final result
-
-## Supported Formats
-
-**Input:**
-- `.ply` - Standard PLY format
-- `.splat` - Binary splat format (antimatter15 format)
-- `.ksplat` - Compressed binary splat format (mkkellogg format)
-
-**Output:**
-- `.ply` - Standard PLY format
-- `.compressed.ply` - Compressed PLY format
-- `meta.json` - SOGS format (JSON + WebP images)
-- `.csv` - Comma-separated values
-
-## Actions
-
-Actions can be repeated and applied in any order:
-
-```bash
--t, --translate  x,y,z                  Translate splats by (x, y, z)
--r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
--s, --scale      x                      Uniformly scale splats by factor x
--n, --filterNaN                         Remove any Gaussian containing NaN/Inf
--c, --filterByValue name,cmp,value      Keep splats where <name> <cmp> <value>
-                                        cmp ∈ {lt,lte,gt,gte,eq,neq}
--b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
-```
-
-## Global Options
-
-```bash
--w, --overwrite                         Overwrite output file if it already exists
--h, --help                              Show help and exit
--v, --version                           Show version and exit
--g, --no-gpu                            Disable gpu when compressing spherical harmonics.
--i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
-```
-
-## Examples
-
-### Basic Operations
-
-```bash
-# Simple format conversion
-splat-transform input.ply output.csv
-
-# Convert from .splat format
-splat-transform input.splat output.ply
-
-# Convert from .ksplat format
-splat-transform input.ksplat output.ply
-
-# Convert to compressed PLY
-splat-transform input.ply output.compressed.ply
-
-# Convert to SOGS format
-splat-transform input.ply output/meta.json
-```
-
-### Transformations
-
-```bash
-# Scale and translate
-splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
-
-# Rotate by 90 degrees around Y axis
-splat-transform input.ply -r 0,90,0 output.ply
-
-# Chain multiple transformations
-splat-transform input.ply -s 2 -t 1,0,0 -r 0,0,45 output.ply
-```
-
-### Filtering
-
-```bash
-# Remove entries containing NaN and Inf
-splat-transform input.ply --filterNaN output.ply
-
-# Filter by opacity values (keep only splats with opacity > 0.5)
-splat-transform input.ply -c opacity,gt,0.5 output.ply
-
-# Strip spherical harmonic bands higher than 2
-splat-transform input.ply --filterBands 2 output.ply
-```
-
-### Advanced Usage
-
-```bash
-# Combine multiple files with different transforms
-splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
-
-# Apply final transformations to combined result
-splat-transform input1.ply input2.ply output.ply -t 0,0,10 -s 0.5
-```
-
-## Getting Help
-
-```bash
-# Show version
-splat-transform --version
-
-# Show help
-splat-transform --help
-```
+# SplatTransform - 3D Gaussian Splat Converter
+
+SplatTransform is an open source CLI tool for reading gaussian splat PLY files and writing them to PLY, Compressed PLY, CSV, and SOGS format.
+
+Multiple files may be combined and transformed before being written to the output.
+
+## Installation
+
+First install the package globally:
+
+```bash
+npm install -g @playcanvas/splat-transform
+```
+
+## Usage
+
+```bash
+splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
+```
+
+**Key points:**
+- Every time an `*.ply*` appears, it becomes the current working set; the following ACTIONS are applied in the order listed
+- The last file on the command line is treated as the output; anything after it is interpreted as actions that modify the final result
+
+## Supported Formats
+
+**Input:**
+- `.ply` - Standard PLY format
+- `.splat` - Binary splat format (antimatter15 format)
+- `.ksplat` - Compressed binary splat format (mkkellogg format)
+
+**Output:**
+- `.ply` - Standard PLY format
+- `.compressed.ply` - Compressed PLY format
+- `meta.json` - SOGS format (JSON + WebP images)
+- `.csv` - Comma-separated values
+
+## Actions
+
+Actions can be repeated and applied in any order:
+
+```bash
+-t, --translate  x,y,z                  Translate splats by (x, y, z)
+-r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
+-s, --scale      x                      Uniformly scale splats by factor x
+-n, --filterNaN                         Remove any Gaussian containing NaN/Inf
+-c, --filterByValue name,cmp,value      Keep splats where <name> <cmp> <value>
+                                        cmp ∈ {lt,lte,gt,gte,eq,neq}
+-b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
+```
+
+## Global Options
+
+```bash
+-w, --overwrite                         Overwrite output file if it already exists
+-h, --help                              Show help and exit
+-v, --version                           Show version and exit
+-g, --no-gpu                            Disable gpu when compressing spherical harmonics.
+-i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
+```
+
+## Examples
+
+### Basic Operations
+
+```bash
+# Simple format conversion
+splat-transform input.ply output.csv
+
+# Convert from .splat format
+splat-transform input.splat output.ply
+
+# Convert from .ksplat format
+splat-transform input.ksplat output.ply
+
+# Convert to compressed PLY
+splat-transform input.ply output.compressed.ply
+
+# Convert to SOGS format
+splat-transform input.ply output/meta.json
+```
+
+### Transformations
+
+```bash
+# Scale and translate
+splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
+
+# Rotate by 90 degrees around Y axis
+splat-transform input.ply -r 0,90,0 output.ply
+
+# Chain multiple transformations
+splat-transform input.ply -s 2 -t 1,0,0 -r 0,0,45 output.ply
+```
+
+### Filtering
+
+```bash
+# Remove entries containing NaN and Inf
+splat-transform input.ply --filterNaN output.ply
+
+# Filter by opacity values (keep only splats with opacity > 0.5)
+splat-transform input.ply -c opacity,gt,0.5 output.ply
+
+# Strip spherical harmonic bands higher than 2
+splat-transform input.ply --filterBands 2 output.ply
+```
+
+### Advanced Usage
+
+```bash
+# Combine multiple files with different transforms
+splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
+
+# Apply final transformations to combined result
+splat-transform input1.ply input2.ply output.ply -t 0,0,10 -s 0.5
+```
+
+## Getting Help
+
+```bash
+# Show version
+splat-transform --version
+
+# Show help
+splat-transform --help
+```

package/bin/cli.mjs

@@ -1,5 +1,5 @@
-#!/usr/bin/env node
-
-import { main } from '../dist/index.mjs';
-
-await main();
+#!/usr/bin/env node
+
+import { main } from '../dist/index.mjs';
+
+await main();

package/dist/index.mjs

@@ -1884,7 +1884,7 @@ let Quat$1 = class Quat {
 		}
 };
 
-var version$1 = "0.5.0";
+var version$1 = "0.5.2";
 
 class Column {
     name;
@@ -89014,116 +89014,131 @@ class KdTree {
     }
 }
 
-const clusterWgsl = (numColumns, numPoints, numCentroids) => {
-    return `
-
-enable f16;
-
-@group(0) @binding(0) var<storage, read> points: array<f16>;
-@group(0) @binding(1) var<storage, read> centroids: array<f16>;
-@group(0) @binding(2) var<storage, read_write> results: array<u32>;
-
-const numColumns = ${numColumns};
-const numPoints = ${numPoints};
-const numCentroids = ${numCentroids};
-
-const chunkSize = 128u; // must be a multiple of 64
-var<workgroup> sharedChunk: array<f16, numColumns * chunkSize>;
-
-// calculate the squared distance between the point and centroid
-fn calcDistanceSqr(point: array<f16, numColumns>, centroid: u32) -> f32 {
-    var result = 0.0;
-
-    var ci = centroid * numColumns;
-
-    for (var i = 0u; i < numColumns; i++) {
-        let v = f32(point[i] - sharedChunk[ci+i]);
-        result += v * v;
-    }
-
-    return result;
-}
-
-@compute @workgroup_size(64)
-fn main(
-    @builtin(local_invocation_index) local_id : u32,
-    @builtin(global_invocation_id) global_id: vec3u,
-    @builtin(num_workgroups) num_workgroups: vec3u
-) {
-    // calculate row index for this thread point
-    let pointIndex = global_id.x + global_id.y * num_workgroups.x * 64;
-
-    // copy the point data from global memory
-    var point: array<f16, numColumns>;
-    if (pointIndex < numPoints) {
-        for (var i = 0u; i < numColumns; i++) {
-            point[i] = points[pointIndex * numColumns + i];
-        }
-    }
-
-    var mind = 1000000.0;
-    var mini = 0u;
-
-    // work through the list of centroids in shared memory chunks
-    let numChunks = u32(ceil(f32(numCentroids) / f32(chunkSize)));
-    for (var i = 0u; i < numChunks; i++) {
-
-        // copy this thread's slice of the centroid shared chunk data
-        let dstRow = local_id * (chunkSize / 64u);
-        let srcRow = min(numCentroids, i * chunkSize + local_id * chunkSize / 64u);
-        let numRows = min(numCentroids, srcRow + chunkSize / 64u) - srcRow;
-
-        var dst = dstRow * numColumns;
-        var src = srcRow * numColumns;
-
-        for (var c = 0u; c < numRows * numColumns; c++) {
-            sharedChunk[dst + c] = centroids[src + c];
-        }
-
-        // wait for all threads to finish writing their part of centroids shared memory buffer
-        workgroupBarrier();
-
-        // loop over the next chunk of centroids finding the closest
-        if (pointIndex < numPoints) {
-            let thisChunkSize = min(chunkSize, numCentroids - i * chunkSize);
-            for (var c = 0u; c < thisChunkSize; c++) {
-                let d = calcDistanceSqr(point, c);
-                if (d < mind) {
-                    mind = d;
-                    mini = i * chunkSize + c;
-                }
-            }
-        }
-
-        // next loop will overwrite the shared memory, so wait
-        workgroupBarrier();
-    }
-
-    if (pointIndex < numPoints) {
-        results[pointIndex] = mini;
-    }
-}
+const clusterWgsl = (numColumns, numPoints, numCentroids, useF16) => {
+    const floatType = useF16 ? 'f16' : 'f32';
+    return `
+${useF16 ? 'enable f16;' : ''}
+
+@group(0) @binding(0) var<storage, read> points: array<${floatType}>;
+@group(0) @binding(1) var<storage, read> centroids: array<${floatType}>;
+@group(0) @binding(2) var<storage, read_write> results: array<u32>;
+
+const numColumns = ${numColumns};
+const numPoints = ${numPoints};
+const numCentroids = ${numCentroids};
+
+const chunkSize = 128u; // must be a multiple of 64
+var<workgroup> sharedChunk: array<${floatType}, numColumns * chunkSize>;
+
+// calculate the squared distance between the point and centroid
+fn calcDistanceSqr(point: array<${floatType}, numColumns>, centroid: u32) -> f32 {
+    var result = 0.0;
+
+    var ci = centroid * numColumns;
+
+    for (var i = 0u; i < numColumns; i++) {
+        let v = f32(point[i] - sharedChunk[ci+i]);
+        result += v * v;
+    }
+
+    return result;
+}
+
+@compute @workgroup_size(64)
+fn main(
+    @builtin(local_invocation_index) local_id : u32,
+    @builtin(global_invocation_id) global_id: vec3u,
+    @builtin(num_workgroups) num_workgroups: vec3u
+) {
+    // calculate row index for this thread point
+    let pointIndex = global_id.x + global_id.y * num_workgroups.x * 64;
+
+    // copy the point data from global memory
+    var point: array<${floatType}, numColumns>;
+    if (pointIndex < numPoints) {
+        for (var i = 0u; i < numColumns; i++) {
+            point[i] = points[pointIndex * numColumns + i];
+        }
+    }
+
+    var mind = 1000000.0;
+    var mini = 0u;
+
+    // work through the list of centroids in shared memory chunks
+    let numChunks = u32(ceil(f32(numCentroids) / f32(chunkSize)));
+    for (var i = 0u; i < numChunks; i++) {
+
+        // copy this thread's slice of the centroid shared chunk data
+        let dstRow = local_id * (chunkSize / 64u);
+        let srcRow = min(numCentroids, i * chunkSize + local_id * chunkSize / 64u);
+        let numRows = min(numCentroids, srcRow + chunkSize / 64u) - srcRow;
+
+        var dst = dstRow * numColumns;
+        var src = srcRow * numColumns;
+
+        for (var c = 0u; c < numRows * numColumns; c++) {
+            sharedChunk[dst + c] = centroids[src + c];
+        }
+
+        // wait for all threads to finish writing their part of centroids shared memory buffer
+        workgroupBarrier();
+
+        // loop over the next chunk of centroids finding the closest
+        if (pointIndex < numPoints) {
+            let thisChunkSize = min(chunkSize, numCentroids - i * chunkSize);
+            for (var c = 0u; c < thisChunkSize; c++) {
+                let d = calcDistanceSqr(point, c);
+                if (d < mind) {
+                    mind = d;
+                    mini = i * chunkSize + c;
+                }
+            }
+        }
+
+        // next loop will overwrite the shared memory, so wait
+        workgroupBarrier();
+    }
+
+    if (pointIndex < numPoints) {
+        results[pointIndex] = mini;
+    }
+}
 `;
 };
 const roundUp = (value, multiple) => {
     return Math.ceil(value / multiple) * multiple;
 };
-const interleaveData = (dataTable) => {
+const interleaveData = (dataTable, useF16) => {
     const { numRows, numColumns } = dataTable;
-    const result = new Uint16Array(roundUp(numColumns * numRows, 2));
-    for (let c = 0; c < numColumns; ++c) {
-        const column = dataTable.columns[c];
-        for (let r = 0; r < numRows; ++r) {
-            result[r * numColumns + c] = FloatPacking.float2Half(column.data[r]);
+    if (useF16) {
+        const result = new Uint16Array(roundUp(numColumns * numRows, 2));
+        for (let c = 0; c < numColumns; ++c) {
+            const column = dataTable.columns[c];
+            for (let r = 0; r < numRows; ++r) {
+                result[r * numColumns + c] = FloatPacking.float2Half(column.data[r]);
+            }
         }
+        return result;
+    }
+    else {
+        const result = new Float32Array(numColumns * numRows);
+        for (let c = 0; c < numColumns; ++c) {
+            const column = dataTable.columns[c];
+            for (let r = 0; r < numRows; ++r) {
+                result[r * numColumns + c] = column.data[r];
+            }
+        }
+        return result;
     }
-    return result;
 };
 class GpuCluster {
     execute;
     destroy;
     constructor(gpuDevice, points, numCentroids) {
         const device = gpuDevice.app.graphicsDevice;
+        // Check if device supports f16
+        const useF16 = !!('supportsShaderF16' in device && device.supportsShaderF16);
+        const bytesPerFloat = useF16 ? 2 : 4;
         const bindGroupFormat = new BindGroupFormat(device, [
             new BindStorageBufferFormat('pointsBuffer', SHADERSTAGE_COMPUTE, true),
             new BindStorageBufferFormat('centroidsBuffer', SHADERSTAGE_COMPUTE, true),
@@ -89134,16 +89149,16 @@ class GpuCluster {
         const shader = new Shader(device, {
             name: 'compute-cluster',
             shaderLanguage: SHADERLANGUAGE_WGSL,
-            cshader: clusterWgsl(numColumns, numPoints, numCentroids),
+            cshader: clusterWgsl(numColumns, numPoints, numCentroids, useF16),
             // @ts-ignore
             computeBindGroupFormat: bindGroupFormat
         });
         const compute = new Compute(device, shader, 'compute-cluster');
-        const pointsBuffer = new StorageBuffer(device, roundUp(numColumns * numPoints, 2) * 2, BUFFERUSAGE_COPY_DST);
-        const centroidsBuffer = new StorageBuffer(device, numColumns * numCentroids * 2, BUFFERUSAGE_COPY_DST);
+        const pointsBuffer = new StorageBuffer(device, useF16 ? roundUp(numColumns * numPoints, 2) * 2 : numColumns * numPoints * 4, BUFFERUSAGE_COPY_DST);
+        const centroidsBuffer = new StorageBuffer(device, numColumns * numCentroids * bytesPerFloat, BUFFERUSAGE_COPY_DST);
         const resultsBuffer = new StorageBuffer(device, numPoints * 4, BUFFERUSAGE_COPY_SRC | BUFFERUSAGE_COPY_DST);
         // interleave the points table data and write to gpu
-        const interleavedPoints = interleaveData(points);
+        const interleavedPoints = interleaveData(points, useF16);
         pointsBuffer.write(0, interleavedPoints, 0, interleavedPoints.length);
         compute.setParameter('columns', numColumns);
         compute.setParameter('points', numPoints);
@@ -89153,7 +89168,7 @@ class GpuCluster {
         compute.setParameter('resultsBuffer', resultsBuffer);
         this.execute = async (centroids, labels) => {
             // interleave centroids and write to gpu
-            const interleavedCentroids = interleaveData(centroids);
+            const interleavedCentroids = interleaveData(centroids, useF16);
             centroidsBuffer.write(0, interleavedCentroids, 0, interleavedCentroids.length);
             // calculate the workgroup layout to minimize the number of empty workgroups
             const groups = Math.ceil(points.numRows / 64);
@@ -89758,46 +89773,46 @@ const parseArguments = () => {
     }
     return { files, options };
 };
-const usage = `
-Apply geometric transforms & filters to Gaussian-splat point clouds
-===================================================================
-
-USAGE
-  splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
-
-  • Every time an input file appears, it becomes the current working set; the following
-    ACTIONS are applied in the order listed.  
-  • The last file on the command line is treated as the output; anything after it is
-    interpreted as actions that modify the final result.
-
-SUPPORTED INPUTS
-    .ply   .splat   .ksplat
-
-SUPPORTED OUTPUTS
-    .ply   .compressed.ply   meta.json (SOGS)   .csv
-
-ACTIONS (can be repeated, in any order)
-    -t, --translate  x,y,z                  Translate splats by (x, y, z)
-    -r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
-    -s, --scale      x                      Uniformly scale splats by factor x
-    -n, --filterNaN                         Remove any Gaussian containing NaN/Inf
-    -c, --filterByValue name,cmp,value      Keep splats where  <name> <cmp> <value>
-                                            cmp ∈ {lt,lte,gt,gte,eq,neq}
-    -b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
-
-GLOBAL OPTIONS
-    -w, --overwrite                         Overwrite output file if it already exists. Default is false.
-    -h, --help                              Show this help and exit.
-    -v, --version                           Show version and exit.
-    -g, --no-gpu                            Disable gpu when compressing spherical harmonics.
-    -i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
-
-EXAMPLES
-    # Simple scale-then-translate
-    splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
-
-    # Chain two inputs and write compressed output, overwriting if necessary
-    splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
+const usage = `
+Apply geometric transforms & filters to Gaussian-splat point clouds
+===================================================================
+
+USAGE
+  splat-transform [GLOBAL]  <input.{ply|splat|ksplat}> [ACTIONS]  ...  <output.{ply|compressed.ply|meta.json|csv}> [ACTIONS]
+
+  • Every time an input file appears, it becomes the current working set; the following
+    ACTIONS are applied in the order listed.  
+  • The last file on the command line is treated as the output; anything after it is
+    interpreted as actions that modify the final result.
+
+SUPPORTED INPUTS
+    .ply   .splat   .ksplat
+
+SUPPORTED OUTPUTS
+    .ply   .compressed.ply   meta.json (SOGS)   .csv
+
+ACTIONS (can be repeated, in any order)
+    -t, --translate  x,y,z                  Translate splats by (x, y, z)
+    -r, --rotate     x,y,z                  Rotate splats by Euler angles (deg)
+    -s, --scale      x                      Uniformly scale splats by factor x
+    -n, --filterNaN                         Remove any Gaussian containing NaN/Inf
+    -c, --filterByValue name,cmp,value      Keep splats where  <name> <cmp> <value>
+                                            cmp ∈ {lt,lte,gt,gte,eq,neq}
+    -b, --filterBands  {0|1|2|3}            Strip spherical-harmonic bands > N
+
+GLOBAL OPTIONS
+    -w, --overwrite                         Overwrite output file if it already exists. Default is false.
+    -h, --help                              Show this help and exit.
+    -v, --version                           Show version and exit.
+    -g, --no-gpu                            Disable gpu when compressing spherical harmonics.
+    -i, --iterations  <number>              Specify the number of iterations when compressing spherical harmonics. More iterations generally lead to better results. Default is 10.
+
+EXAMPLES
+    # Simple scale-then-translate
+    splat-transform bunny.ply -s 0.5 -t 0,0,10 bunny_scaled.ply
+
+    # Chain two inputs and write compressed output, overwriting if necessary
+    splat-transform -w cloudA.ply -r 0,90,0 cloudB.ply -s 2 merged.compressed.ply
 `;
 const main = async () => {
     console.log(`splat-transform v${version$1}`);