@playcanvas/splat-transform 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -1884,7 +1884,7 @@ let Quat$1 = class Quat {
 		}
 };
 
-var version$1 = "0.6.0";
+var version$1 = "0.7.0";
 
 class Column {
     name;
@@ -89417,6 +89417,164 @@ const createDevice = async () => {
     return new GpuDevice(app, backbuffer);
 };
 
+// write data to a file stream
+class FileWriter {
+    write;
+    close;
+    constructor(stream) {
+        let cursor = 0;
+        this.write = async (data) => {
+            cursor += data.byteLength;
+            await stream.write(data);
+        };
+        this.close = async () => {
+            await stream.truncate(cursor);
+            return true;
+        };
+    }
+}
+
+const crc32_table = (() => {
+    const tbl = [];
+    let c;
+    for (let n = 0; n < 256; n++) {
+        c = n;
+        for (let k = 0; k < 8; k++) {
+            c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
+        }
+        tbl[n] = c;
+    }
+    return tbl;
+})();
+class Crc {
+    reset;
+    update;
+    value;
+    constructor() {
+        let bits = -1;
+        this.update = (data) => {
+            for (let i = 0; i < data.length; i++) {
+                bits = (bits >>> 8) ^ crc32_table[(bits ^ data[i]) & 0xFF];
+            }
+        };
+        this.value = () => (bits ^ (-1)) >>> 0;
+    }
+}
+
+// https://gist.github.com/rvaiya/4a2192df729056880a027789ae3cd4b7
+// zip archive writer. data is streamed to the output writer.
+class ZipWriter {
+    // start a new file
+    start;
+    // write func
+    write;
+    // finish the archive by writing the footer
+    close;
+    // helper function to start and write file contents
+    async file(filename, content) {
+        // start a new file
+        await this.start(filename);
+        // write file content
+        if (typeof content === 'string') {
+            await this.write(new TextEncoder().encode(content));
+        }
+        else if (content instanceof Uint8Array) {
+            await this.write(content);
+        }
+        else {
+            for (let i = 0; i < content.length; i++) {
+                await this.write(content[i]);
+            }
+        }
+    }
+    // write uncompressed data to a zip file using the passed-in writer
+    constructor(writer) {
+        const textEncoder = new TextEncoder();
+        const files = [];
+        const date = new Date();
+        const dosTime = (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2);
+        const dosDate = ((date.getFullYear() - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+        const writeHeader = async (filename) => {
+            const filenameBuf = textEncoder.encode(filename);
+            const nameLen = filenameBuf.length;
+            const header = new Uint8Array(30 + nameLen);
+            const view = new DataView(header.buffer);
+            view.setUint32(0, 0x04034b50, true);
+            view.setUint16(4, 20, true); // version needed to extract = 2.0
+            view.setUint16(6, 0x8 | 0x800, true); // indicate crc and size comes after, utf-8 encoding
+            view.setUint16(8, 0, true); // method = 0 (store)
+            view.setUint16(10, dosTime, true);
+            view.setUint16(12, dosDate, true);
+            view.setUint16(26, nameLen, true);
+            header.set(filenameBuf, 30);
+            await writer.write(header);
+            files.push({ filename: filenameBuf, crc: new Crc(), sizeBytes: 0 });
+        };
+        const writeFooter = async () => {
+            const file = files[files.length - 1];
+            const { crc, sizeBytes } = file;
+            const data = new Uint8Array(16);
+            const view = new DataView(data.buffer);
+            view.setUint32(0, 0x08074b50, true);
+            view.setUint32(4, crc.value(), true);
+            view.setUint32(8, sizeBytes, true);
+            view.setUint32(12, sizeBytes, true);
+            await writer.write(data);
+        };
+        this.start = async (filename) => {
+            // write previous file footer
+            if (files.length > 0) {
+                await writeFooter();
+            }
+            await writeHeader(filename);
+        };
+        this.write = async (data) => {
+            const file = files[files.length - 1];
+            file.sizeBytes += data.length;
+            file.crc.update(data);
+            await writer.write(data);
+        };
+        this.close = async () => {
+            // write last file's footer
+            await writeFooter();
+            // write cd records
+            let offset = 0;
+            for (const file of files) {
+                const { filename, crc, sizeBytes } = file;
+                const nameLen = filename.length;
+                const cdr = new Uint8Array(46 + nameLen);
+                const view = new DataView(cdr.buffer);
+                view.setUint32(0, 0x02014b50, true);
+                view.setUint16(4, 20, true);
+                view.setUint16(6, 20, true);
+                view.setUint16(8, 0x8 | 0x800, true);
+                view.setUint16(10, 0, true);
+                view.setUint16(12, dosTime, true);
+                view.setUint16(14, dosDate, true);
+                view.setUint32(16, crc.value(), true);
+                view.setUint32(20, sizeBytes, true);
+                view.setUint32(24, sizeBytes, true);
+                view.setUint16(28, nameLen, true);
+                view.setUint32(42, offset, true);
+                cdr.set(filename, 46);
+                await writer.write(cdr);
+                offset += 30 + nameLen + sizeBytes + 16; // 30 local header + name + data + 16 descriptor
+            }
+            const filenameLength = files.reduce((tot, file) => tot + file.filename.length, 0);
+            const dataLength = files.reduce((tot, file) => tot + file.sizeBytes, 0);
+            // write eocd record
+            const eocd = new Uint8Array(22);
+            const eocdView = new DataView(eocd.buffer);
+            eocdView.setUint32(0, 0x06054b50, true);
+            eocdView.setUint16(8, files.length, true);
+            eocdView.setUint16(10, files.length, true);
+            eocdView.setUint32(12, filenameLength + files.length * 46, true);
+            eocdView.setUint32(16, filenameLength + files.length * (30 + 16) + dataLength, true);
+            await writer.write(eocd);
+        };
+    }
+}
+
 class KdTree {
     centroids;
     root;
@@ -89699,6 +89857,24 @@ const initializeCentroids = (dataTable, centroids, row) => {
         centroids.setRow(i, row);
     }
 };
+// in the 1d case we can initialize centroids evenly over the input range
+const initializeCentroids1D = (dataTable, centroids) => {
+    // calculate min/max
+    let m = Infinity;
+    let M = -Infinity;
+    const data = dataTable.getColumn(0).data;
+    for (let i = 0; i < dataTable.numRows; ++i) {
+        const value = data[i];
+        if (value < m)
+            m = value;
+        if (value > M)
+            M = value;
+    }
+    const centroidsData = centroids.getColumn(0).data;
+    for (let i = 0; i < centroids.numRows; ++i) {
+        centroidsData[i] = m + (M - m) * i / (centroids.numRows - 1);
+    }
+};
 const calcAverage = (dataTable, cluster, row) => {
     const keys = dataTable.columnNames;
     for (let i = 0; i < keys.length; ++i) {
@@ -89754,7 +89930,12 @@ const kmeans = async (points, k, iterations, device) => {
     const row = {};
     // construct centroids data table and assign initial values
     const centroids = new DataTable(points.columns.map(c => new Column(c.name, new Float32Array(k))));
-    initializeCentroids(points, centroids, row);
+    if (points.numColumns === 1) {
+        initializeCentroids1D(points, centroids);
+    }
+    else {
+        initializeCentroids(points, centroids, row);
+    }
     const gpuClustering = device && new GpuClustering(device, points.numColumns, k);
     const labels = new Uint32Array(points.numRows);
     let converged = false;
@@ -89770,8 +89951,16 @@ const kmeans = async (points, k, iterations, device) => {
         // calculate the new centroid positions
         const groups = groupLabels(labels, k);
         for (let i = 0; i < centroids.numRows; ++i) {
-            calcAverage(points, groups[i], row);
-            centroids.setRow(i, row);
+            if (groups[i].length === 0) {
+                // re-seed this centroid to a random point to avoid zero vector
+                const idx = Math.floor(Math.random() * points.numRows);
+                points.getRow(idx, row);
+                centroids.setRow(i, row);
+            }
+            else {
+                calcAverage(points, groups[i], row);
+                centroids.setRow(i, row);
+            }
         }
         steps++;
         if (steps >= iterations) {
@@ -89818,20 +90007,82 @@ const generateIndices = (dataTable) => {
     generateOrdering(dataTable, result);
     return result;
 };
+// convert a dataTable with multiple columns into a single column
+// calculate 256 clusters using kmeans
+// return
+//      - the resulting labels in a new datatable having same shape as the input
+//      - array of 256 centroids
+const cluster1d = async (dataTable, iterations, device) => {
+    const { numColumns, numRows } = dataTable;
+    // construct 1d points from the columns of data
+    const data = new Float32Array(numRows * numColumns);
+    for (let i = 0; i < numColumns; ++i) {
+        data.set(dataTable.getColumn(i).data, i * numRows);
+    }
+    const src = new DataTable([new Column('data', data)]);
+    const { centroids, labels } = await kmeans(src, 256, iterations, device);
+    // order centroids smallest to largest
+    const centroidsData = centroids.getColumn(0).data;
+    const order = centroidsData.map((_, i) => i);
+    order.sort((a, b) => centroidsData[a] - centroidsData[b]);
+    // reorder centroids
+    const tmp = centroidsData.slice();
+    for (let i = 0; i < order.length; ++i) {
+        centroidsData[i] = tmp[order[i]];
+    }
+    const invOrder = [];
+    for (let i = 0; i < order.length; ++i) {
+        invOrder[order[i]] = i;
+    }
+    // reorder labels
+    for (let i = 0; i < labels.length; i++) {
+        labels[i] = invOrder[labels[i]];
+    }
+    const result = new DataTable(dataTable.columnNames.map(name => new Column(name, new Uint8Array(numRows))));
+    for (let i = 0; i < numColumns; ++i) {
+        result.getColumn(i).data.set(labels.subarray(i * numRows, (i + 1) * numRows));
+    }
+    return {
+        centroids,
+        labels: result
+    };
+};
 const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10, shMethod, indices = generateIndices(dataTable)) => {
+    // initialize output stream
+    const isBundle = outputFilename.toLowerCase().endsWith('.sog');
+    const fileWriter = isBundle && new FileWriter(fileHandle);
+    const zipWriter = fileWriter && new ZipWriter(fileWriter);
     const numRows = indices.length;
-    const width = Math.ceil(Math.sqrt(numRows) / 16) * 16;
-    const height = Math.ceil(numRows / width / 16) * 16;
+    const width = Math.ceil(Math.sqrt(numRows) / 4) * 4;
+    const height = Math.ceil(numRows / width / 4) * 4;
     const channels = 4;
-    const write = (filename, data, w = width, h = height) => {
+    // the layout function determines how the data is packed into the output texture.
+    const layout = identity; // rectChunks;
+    const write = async (filename, data, w = width, h = height) => {
         const pathname = resolve$2(dirname(outputFilename), filename);
         console.log(`writing '${pathname}'...`);
-        return sharp(data, { raw: { width: w, height: h, channels } })
-            .webp({ lossless: true })
-            .toFile(pathname);
+        const webp = sharp(data, { raw: { width: w, height: h, channels } }).webp({ lossless: true });
+        if (zipWriter) {
+            await zipWriter.file(filename, await webp.toBuffer());
+        }
+        else {
+            await webp.toFile(pathname);
+        }
+    };
+    const writeTableData = (filename, dataTable, w = width, h = height) => {
+        const data = new Uint8Array(w * h * channels);
+        const columns = dataTable.columns.map(c => c.data);
+        const numColumns = columns.length;
+        for (let i = 0; i < indices.length; ++i) {
+            const idx = indices[i];
+            const ti = layout(i);
+            data[ti * channels + 0] = columns[0][idx];
+            data[ti * channels + 1] = numColumns > 1 ? columns[1][idx] : 0;
+            data[ti * channels + 2] = numColumns > 2 ? columns[2][idx] : 0;
+            data[ti * channels + 3] = numColumns > 3 ? columns[3][idx] : 255;
+        }
+        return write(filename, data, w, h);
     };
-    // the layout function determines how the data is packed into the output texture.
-    const layout = identity; // rectChunks;
     const row = {};
     // convert position/means
     const meansL = new Uint8Array(width * height * channels);
@@ -89898,39 +90149,25 @@ const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10
         quats[ti * 4 + 3] = 252 + maxComp;
     }
     await write('quats.webp', quats);
-    // scales
-    const scales = new Uint8Array(width * height * channels);
-    const scaleNames = ['scale_0', 'scale_1', 'scale_2'];
-    const scaleColumns = scaleNames.map(name => dataTable.getColumnByName(name));
-    const scaleMinMax = calcMinMax(dataTable, scaleNames, indices);
-    for (let i = 0; i < indices.length; ++i) {
-        dataTable.getRow(indices[i], row, scaleColumns);
-        const ti = layout(i);
-        scales[ti * 4] = 255 * (row.scale_0 - scaleMinMax[0][0]) / (scaleMinMax[0][1] - scaleMinMax[0][0]);
-        scales[ti * 4 + 1] = 255 * (row.scale_1 - scaleMinMax[1][0]) / (scaleMinMax[1][1] - scaleMinMax[1][0]);
-        scales[ti * 4 + 2] = 255 * (row.scale_2 - scaleMinMax[2][0]) / (scaleMinMax[2][1] - scaleMinMax[2][0]);
-        scales[ti * 4 + 3] = 0xff;
-    }
-    await write('scales.webp', scales);
-    // colors
-    const sh0 = new Uint8Array(width * height * channels);
-    const sh0Names = ['f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity'];
-    const sh0Columns = sh0Names.map(name => dataTable.getColumnByName(name));
-    const sh0MinMax = calcMinMax(dataTable, sh0Names, indices);
-    for (let i = 0; i < indices.length; ++i) {
-        dataTable.getRow(indices[i], row, sh0Columns);
-        const ti = layout(i);
-        sh0[ti * 4] = 255 * (row.f_dc_0 - sh0MinMax[0][0]) / (sh0MinMax[0][1] - sh0MinMax[0][0]);
-        sh0[ti * 4 + 1] = 255 * (row.f_dc_1 - sh0MinMax[1][0]) / (sh0MinMax[1][1] - sh0MinMax[1][0]);
-        sh0[ti * 4 + 2] = 255 * (row.f_dc_2 - sh0MinMax[2][0]) / (sh0MinMax[2][1] - sh0MinMax[2][0]);
-        sh0[ti * 4 + 3] = 255 * (row.opacity - sh0MinMax[3][0]) / (sh0MinMax[3][1] - sh0MinMax[3][0]);
-    }
-    await write('sh0.webp', sh0);
-    // write meta.json
+    const gpuDevice = shMethod === 'gpu' ? await createDevice() : null;
+    // convert scale
+    const scaleData = await cluster1d(new DataTable(['scale_0', 'scale_1', 'scale_2'].map(name => dataTable.getColumnByName(name))), shIterations, gpuDevice);
+    await writeTableData('scales.webp', scaleData.labels);
+    // color and opacity
+    const colorData = await cluster1d(new DataTable(['f_dc_0', 'f_dc_1', 'f_dc_2'].map(name => dataTable.getColumnByName(name))), shIterations, gpuDevice);
+    // generate and store sigmoid(opacity) [0..1]
+    const opacity = dataTable.getColumnByName('opacity').data;
+    const opacityData = new Uint8Array(opacity.length);
+    for (let i = 0; i < numRows; ++i) {
+        opacityData[i] = Math.max(0, Math.min(255, sigmoid(opacity[i]) * 255));
+    }
+    colorData.labels.addColumn(new Column('opacity', opacityData));
+    await writeTableData('sh0.webp', colorData.labels);
+    // construct meta.json
     const meta = {
+        version: 2,
+        count: numRows,
         means: {
-            shape: [numRows, 3],
-            dtype: 'float32',
             mins: meansMinMax.map(v => v[0]),
             maxs: meansMinMax.map(v => v[1]),
             files: [
@@ -89939,29 +90176,19 @@ const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10
             ]
         },
         scales: {
-            shape: [numRows, 3],
-            dtype: 'float32',
-            mins: scaleMinMax.map(v => v[0]),
-            maxs: scaleMinMax.map(v => v[1]),
+            codebook: Array.from(scaleData.centroids.getColumn(0).data),
             files: ['scales.webp']
         },
         quats: {
-            shape: [numRows, 4],
-            dtype: 'uint8',
-            encoding: 'quaternion_packed',
             files: ['quats.webp']
         },
         sh0: {
-            shape: [numRows, 1, 4],
-            dtype: 'float32',
-            mins: sh0MinMax.map(v => v[0]),
-            maxs: sh0MinMax.map(v => v[1]),
+            codebook: Array.from(colorData.centroids.getColumn(0).data),
             files: ['sh0.webp']
         }
     };
     // spherical harmonics
     const shBands = { '9': 1, '24': 2, '-1': 3 }[shNames.findIndex(v => !dataTable.hasColumn(v))] ?? 0;
-    // @ts-ignore
     if (shBands > 0) {
         const shCoeffs = [0, 3, 8, 15][shBands];
         const shColumnNames = shNames.slice(0, shCoeffs * 3);
@@ -89974,23 +90201,21 @@ const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10
         const shDataTable = new DataTable(shColumns);
         const paletteSize = Math.min(64, 2 ** Math.floor(Math.log2(indices.length / 1024))) * 1024;
         // calculate kmeans
-        const gpuDevice = shMethod === 'gpu' ? await createDevice() : null;
         const { centroids, labels } = await kmeans(shDataTable, paletteSize, shIterations, gpuDevice);
+        // construct a codebook for all spherical harmonic coefficients
+        const codebook = await cluster1d(centroids, shIterations, gpuDevice);
         // write centroids
         const centroidsBuf = new Uint8Array(64 * shCoeffs * Math.ceil(centroids.numRows / 64) * channels);
-        const centroidsMinMax = calcMinMax(shDataTable, shColumnNames, indices);
-        const centroidsMin = centroidsMinMax.map(v => v[0]).reduce((a, b) => Math.min(a, b));
-        const centroidsMax = centroidsMinMax.map(v => v[1]).reduce((a, b) => Math.max(a, b));
         const centroidsRow = {};
         for (let i = 0; i < centroids.numRows; ++i) {
-            centroids.getRow(i, centroidsRow);
+            codebook.labels.getRow(i, centroidsRow);
             for (let j = 0; j < shCoeffs; ++j) {
                 const x = centroidsRow[shColumnNames[shCoeffs * 0 + j]];
                 const y = centroidsRow[shColumnNames[shCoeffs * 1 + j]];
                 const z = centroidsRow[shColumnNames[shCoeffs * 2 + j]];
-                centroidsBuf[i * shCoeffs * 4 + j * 4 + 0] = 255 * ((x - centroidsMin) / (centroidsMax - centroidsMin));
-                centroidsBuf[i * shCoeffs * 4 + j * 4 + 1] = 255 * ((y - centroidsMin) / (centroidsMax - centroidsMin));
-                centroidsBuf[i * shCoeffs * 4 + j * 4 + 2] = 255 * ((z - centroidsMin) / (centroidsMax - centroidsMin));
+                centroidsBuf[i * shCoeffs * 4 + j * 4 + 0] = x;
+                centroidsBuf[i * shCoeffs * 4 + j * 4 + 1] = y;
+                centroidsBuf[i * shCoeffs * 4 + j * 4 + 2] = z;
                 centroidsBuf[i * shCoeffs * 4 + j * 4 + 3] = 0xff;
             }
         }
@@ -90000,25 +90225,29 @@ const writeSog = async (fileHandle, dataTable, outputFilename, shIterations = 10
         for (let i = 0; i < indices.length; ++i) {
             const label = labels[indices[i]];
             const ti = layout(i);
-            labelsBuf[ti * 4] = label & 0xff;
-            labelsBuf[ti * 4 + 1] = (label >> 8) & 0xff;
+            labelsBuf[ti * 4 + 0] = 0xff & label;
+            labelsBuf[ti * 4 + 1] = 0xff & (label >> 8);
             labelsBuf[ti * 4 + 2] = 0;
             labelsBuf[ti * 4 + 3] = 0xff;
         }
         await write('shN_labels.webp', labelsBuf);
         meta.shN = {
-            shape: [indices.length, shCoeffs],
-            dtype: 'float32',
-            mins: centroidsMin,
-            maxs: centroidsMax,
-            quantization: 8,
+            codebook: Array.from(codebook.centroids.getColumn(0).data),
             files: [
                 'shN_centroids.webp',
                 'shN_labels.webp'
             ]
         };
     }
-    await fileHandle.write((new TextEncoder()).encode(JSON.stringify(meta, null, 4)));
+    const metaJson = (new TextEncoder()).encode(JSON.stringify(meta));
+    if (zipWriter) {
+        await zipWriter.file('meta.json', metaJson);
+        await zipWriter.close();
+        await fileWriter.close();
+    }
+    else {
+        await fileHandle.write(metaJson);
+    }
 };
 
 const readFile = async (filename) => {
@@ -90056,7 +90285,7 @@ const getOutputFormat = (filename) => {
     if (lowerFilename.endsWith('.csv')) {
         return 'csv';
     }
-    else if (lowerFilename.endsWith('meta.json')) {
+    else if (lowerFilename.endsWith('.sog') || lowerFilename.endsWith('meta.json')) {
         return 'sog';
     }
     else if (lowerFilename.endsWith('.compressed.ply')) {
@@ -90303,10 +90532,10 @@ USAGE
     interpreted as actions that modify the final result.
 
 SUPPORTED INPUTS
-    .ply   .splat   .ksplat
+    .ply   .compressed.ply   .splat   .ksplat
 
 SUPPORTED OUTPUTS
-    .ply   .compressed.ply   meta.json (SOGS)   .csv
+    .ply   .compressed.ply   meta.json (SOG)   .sog   .csv
 
 ACTIONS (can be repeated, in any order)
     -t, --translate  x,y,z                  Translate splats by (x, y, z)