@manycore/aholo-splat-transform 1.2.6

package/dist/file/ksplat.js

@@ -0,0 +1,232 @@
+import { SH_MAPS } from '../constant.js';
+import { fromHalf } from '../utils/index.js';
+const KSPLAT_COMPRESSION = {
+    0: {
+        bytesPerCenter: 12,
+        bytesPerScale: 12,
+        bytesPerRotation: 16,
+        bytesPerColor: 4,
+        bytesPerSphericalHarmonicsComponent: 4,
+        scaleOffsetBytes: 12,
+        rotationOffsetBytes: 24,
+        colorOffsetBytes: 40,
+        sphericalHarmonicsOffsetBytes: 44,
+        scaleRange: 1,
+    },
+    1: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        bytesPerSphericalHarmonicsComponent: 2,
+        scaleOffsetBytes: 6,
+        rotationOffsetBytes: 12,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+    },
+    2: {
+        bytesPerCenter: 6,
+        bytesPerScale: 6,
+        bytesPerRotation: 8,
+        bytesPerColor: 4,
+        bytesPerSphericalHarmonicsComponent: 1,
+        scaleOffsetBytes: 6,
+        rotationOffsetBytes: 12,
+        colorOffsetBytes: 20,
+        sphericalHarmonicsOffsetBytes: 24,
+        scaleRange: 32767,
+    },
+};
+const SHIndex = [
+    0, 3, 6, 1, 4, 7, 2, 5, 8, // sh1
+    9, 14, 19, 10, 15, 20, 11, 16, 21, 12, 17, 22, 13, 18, 23, // sh2
+    24, 31, 38, 25, 32, 39, 26, 33, 40, 27, 34, 41, 28, 35, 42, 29, 36, 43, 30, 37, 44, // sh3
+];
+const HEADER_BYTES = 4096;
+const SECTION_BYTES = 1024;
+export class KsplatFile {
+    counts = 0;
+    shDegree = 0;
+    header;
+    sections;
+    buffer;
+    load(buffer) {
+        this.buffer = buffer;
+        const header = new DataView(buffer.buffer, 0, HEADER_BYTES);
+        const versionMajor = header.getUint8(0);
+        const versionMinor = header.getUint8(1);
+        if (versionMajor !== 0 || versionMinor < 1) {
+            throw new Error(`Unsupported .ksplat version: ${versionMajor}.${versionMinor}`);
+        }
+        const maxSectionCount = header.getUint32(4, true);
+        const sectionCount = header.getUint32(8, true);
+        const maxSplatCount = header.getUint32(12, true);
+        const splatCount = header.getUint32(16, true);
+        const compressionLevel = header.getUint16(20, true);
+        if (compressionLevel < 0 || compressionLevel > 2) {
+            throw new Error(`Invalid .ksplat compression level: ${compressionLevel}`);
+        }
+        const sceneCenterX = header.getFloat32(24, true);
+        const sceneCenterY = header.getFloat32(28, true);
+        const sceneCenterZ = header.getFloat32(32, true);
+        const minSH = header.getFloat32(36, true) || -1.5;
+        const maxSH = header.getFloat32(40, true) || 1.5;
+        let maxSHDegree = 0;
+        const sections = [];
+        for (let i = 0; i < maxSectionCount; i++) {
+            const section = new DataView(buffer.buffer, HEADER_BYTES + i * SECTION_BYTES, SECTION_BYTES);
+            const sectionSplatCount = section.getUint32(0, true);
+            const sectionMaxSplatCount = section.getUint32(4, true);
+            const bucketSize = section.getUint32(8, true);
+            const bucketCount = section.getUint32(12, true);
+            const bucketBlockSize = section.getFloat32(16, true);
+            const bucketStorageSizeBytes = section.getUint16(20, true);
+            const compressionScaleRange = section.getUint32(24, true);
+            const fullBucketCount = section.getUint32(32, true);
+            const partiallyFilledBucketCount = section.getUint32(36, true);
+            const shDegree = section.getUint16(40, true);
+            maxSHDegree = Math.max(maxSHDegree, shDegree);
+            sections.push({
+                sectionSplatCount,
+                sectionMaxSplatCount,
+                bucketSize,
+                bucketCount,
+                bucketBlockSize,
+                bucketStorageSizeBytes,
+                compressionScaleRange: compressionScaleRange || KSPLAT_COMPRESSION[compressionLevel].scaleRange,
+                fullBucketCount,
+                partiallyFilledBucketCount,
+                shDegree,
+            });
+        }
+        this.header = {
+            versionMajor,
+            versionMinor,
+            maxSectionCount,
+            sectionCount,
+            maxSplatCount,
+            splatCount,
+            compressionLevel,
+            sceneCenter: [sceneCenterX, sceneCenterY, sceneCenterZ],
+            shRange: [minSH, maxSH],
+        };
+        this.sections = sections;
+        this.counts = splatCount;
+        this.shDegree = maxSHDegree;
+    }
+    async read(stream, contentLength, data) {
+        let BlockOffset = 0;
+        {
+            const buffer = new Uint8Array(contentLength);
+            const reader = stream.getReader();
+            let offset = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer.set(value, offset);
+                offset += value.length;
+            }
+            this.load(buffer);
+            BlockOffset = await data.initBlock(this.counts, this.shDegree);
+        }
+        const setFn = data.set.bind(data);
+        const setShFn = data.setShN.bind(data);
+        const { buffer, header, sections, shDegree: maxSHDegree } = this;
+        const { maxSectionCount, compressionLevel, shRange: [minSH, maxSH] } = header;
+        const isHighQualitySplatData = compressionLevel === 0;
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        const maxSHSize = SH_MAPS[maxSHDegree];
+        const shData = new Array(maxSHSize);
+        let sectionBase = HEADER_BYTES + maxSectionCount * SECTION_BYTES;
+        for (let i = 0; i < maxSectionCount; i++) {
+            const { sectionSplatCount, sectionMaxSplatCount, bucketSize, bucketCount, bucketBlockSize, bucketStorageSizeBytes, fullBucketCount, partiallyFilledBucketCount, compressionScaleRange, shDegree, } = sections[i];
+            const fullBucketSplats = fullBucketCount * bucketSize;
+            const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
+            const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
+            const shComponents = SH_MAPS[shDegree];
+            const { bytesPerCenter, bytesPerScale, bytesPerRotation, bytesPerColor, bytesPerSphericalHarmonicsComponent, scaleOffsetBytes, rotationOffsetBytes, colorOffsetBytes, sphericalHarmonicsOffsetBytes, } = KSPLAT_COMPRESSION[compressionLevel];
+            const bytesPerSplat = bytesPerCenter + bytesPerScale + bytesPerRotation + bytesPerColor +
+                shComponents * bytesPerSphericalHarmonicsComponent;
+            const splatDataStorageSizeBytes = bytesPerSplat * sectionMaxSplatCount;
+            const storageSizeBytes = splatDataStorageSizeBytes + bucketsStorageSizeBytes;
+            const compressionScaleFactor = bucketBlockSize / 2 / compressionScaleRange;
+            const bucketsBase = sectionBase + bucketsMetaDataSizeBytes;
+            const dataBase = sectionBase + bucketsStorageSizeBytes;
+            const data = new DataView(buffer.buffer, dataBase, splatDataStorageSizeBytes);
+            const bucketArray = new Float32Array(buffer.buffer, bucketsBase, bucketCount * 3);
+            const partiallyFilledBucketLengths = new Uint32Array(buffer.buffer, sectionBase, partiallyFilledBucketCount);
+            let partialBucketIndex = fullBucketCount;
+            let partialBucketBase = fullBucketSplats;
+            for (let j = 0; j < sectionSplatCount; j++) {
+                const splatOffset = j * bytesPerSplat;
+                let bucketIndex;
+                if (j < fullBucketSplats) {
+                    bucketIndex = Math.floor(j / bucketSize);
+                }
+                else {
+                    const bucketLength = partiallyFilledBucketLengths[partialBucketIndex - fullBucketCount];
+                    if (j >= partialBucketBase + bucketLength) {
+                        partialBucketIndex += 1;
+                        partialBucketBase += bucketLength;
+                    }
+                    bucketIndex = partialBucketIndex;
+                }
+                if (isHighQualitySplatData) {
+                    single.x = data.getFloat32(splatOffset + 0, true);
+                    single.y = data.getFloat32(splatOffset + 4, true);
+                    single.z = data.getFloat32(splatOffset + 8, true);
+                    single.sx = data.getFloat32(splatOffset + scaleOffsetBytes + 0, true);
+                    single.sy = data.getFloat32(splatOffset + scaleOffsetBytes + 4, true);
+                    single.sz = data.getFloat32(splatOffset + scaleOffsetBytes + 8, true);
+                    single.qw = data.getFloat32(splatOffset + rotationOffsetBytes + 0, true);
+                    single.qx = data.getFloat32(splatOffset + rotationOffsetBytes + 4, true);
+                    single.qy = data.getFloat32(splatOffset + rotationOffsetBytes + 8, true);
+                    single.qz = data.getFloat32(splatOffset + rotationOffsetBytes + 12, true);
+                }
+                else {
+                    single.x = (data.getUint16(splatOffset + 0, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 0];
+                    single.y = (data.getUint16(splatOffset + 2, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 1];
+                    single.z = (data.getUint16(splatOffset + 4, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 2];
+                    single.sx = fromHalf(data.getUint16(splatOffset + scaleOffsetBytes + 0, true));
+                    single.sy = fromHalf(data.getUint16(splatOffset + scaleOffsetBytes + 2, true));
+                    single.sz = fromHalf(data.getUint16(splatOffset + scaleOffsetBytes + 4, true));
+                    single.qw = fromHalf(data.getUint16(splatOffset + rotationOffsetBytes + 0, true));
+                    single.qx = fromHalf(data.getUint16(splatOffset + rotationOffsetBytes + 2, true));
+                    single.qy = fromHalf(data.getUint16(splatOffset + rotationOffsetBytes + 4, true));
+                    single.qz = fromHalf(data.getUint16(splatOffset + rotationOffsetBytes + 6, true));
+                }
+                single.r = data.getUint8(splatOffset + colorOffsetBytes + 0) / 255;
+                single.g = data.getUint8(splatOffset + colorOffsetBytes + 1) / 255;
+                single.b = data.getUint8(splatOffset + colorOffsetBytes + 2) / 255;
+                single.a = data.getUint8(splatOffset + colorOffsetBytes + 3) / 255;
+                setFn(j + BlockOffset, single);
+                const shOffsetBytes = splatOffset + sphericalHarmonicsOffsetBytes;
+                for (let k = 0; k < shComponents; k++) {
+                    shData[k] = compressionLevel === 0 ?
+                        data.getFloat32(shOffsetBytes + SHIndex[k] * 4, true) :
+                        compressionLevel === 1 ?
+                            fromHalf(data.getUint16(shOffsetBytes + SHIndex[k] * 2, true)) :
+                            (minSH + data.getUint8(shOffsetBytes + SHIndex[k]) / 255 * (maxSH - minSH));
+                }
+                for (let k = maxSHSize - 1; k >= shComponents; k--) {
+                    shData[k] = 0;
+                }
+                setShFn(j + BlockOffset, shData);
+            }
+            sectionBase += storageSizeBytes;
+        }
+        data.finishBlock();
+    }
+    async write(_stream, _data) {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/file/lcc.d.ts

@@ -0,0 +1,11 @@
+import { SplatData } from '../SplatData.js';
+import { IFile } from './IFile.js';
+export declare class LccFile implements IFile {
+    private counts;
+    private shDegree;
+    private meta;
+    private refs;
+    private load;
+    read(stream: ReadableStream<Uint8Array>, contentLength: number, data: SplatData): Promise<void>;
+    write(_stream: WritableStream<Uint8Array>, _data: SplatData): Promise<void>;
+}

package/dist/file/lcc.js

@@ -0,0 +1,157 @@
+import { unzipSync } from 'fflate';
+import { extractFromRootDir } from '../utils/index.js';
+const ZIP_MAGIC = 0x04034b50;
+const SQRT_2 = 1.414213562373095;
+const SQRT_2_INV = 0.7071067811865475;
+function decodeRotation(v) {
+    const d0 = (v & 1023) / 1023.0;
+    const d1 = ((v >> 10) & 1023) / 1023.0;
+    const d2 = ((v >> 20) & 1023) / 1023.0;
+    const d3 = (v >> 30) & 3;
+    const qx = d0 * SQRT_2 - SQRT_2_INV;
+    const qy = d1 * SQRT_2 - SQRT_2_INV;
+    const qz = d2 * SQRT_2 - SQRT_2_INV;
+    let sum = qx * qx + qy * qy + qz * qz;
+    sum = Math.min(1.0, sum);
+    const qw = Math.sqrt(1 - sum);
+    if (d3 === 0) {
+        return [qw, qx, qy, qz];
+    }
+    else if (d3 === 1) {
+        return [qx, qw, qy, qz];
+    }
+    else if (d3 === 2) {
+        return [qx, qy, qw, qz];
+    }
+    return [qx, qy, qz, qw];
+}
+;
+function DecodePacked_11_10_11(enc) {
+    return [
+        (enc & 0x7FF) / 2047.0,
+        ((enc >> 11) & 0x3FF) / 1023.0,
+        ((enc >> 21) & 0x7FF) / 2047.0,
+    ];
+}
+;
+function mix(min, max, s) {
+    return (1.0 - s) * min + s * max;
+}
+;
+export class LccFile {
+    counts = 0;
+    shDegree = 0;
+    meta;
+    refs = {};
+    load(buffer) {
+        const view = new DataView(buffer.buffer);
+        if (view.getUint32(0, true) !== ZIP_MAGIC) {
+            throw new Error('LCC file is not a valid zip archive.');
+        }
+        this.refs = extractFromRootDir(unzipSync(buffer));
+        if (!['meta.lcc', 'index.bin', 'data.bin'].every(name => !!this.refs[name])) {
+            throw new Error('LCC file is missing required files.');
+        }
+        this.meta = JSON.parse(new TextDecoder().decode(this.refs['meta.lcc']));
+        this.counts = this.meta.splats[0];
+        this.shDegree = !!this.refs['shcoef.bin'] ? 3 : 0;
+    }
+    async read(stream, contentLength, data) {
+        let BlockOffset = 0;
+        {
+            const buffer = new Uint8Array(contentLength);
+            const reader = stream.getReader();
+            let offset = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer.set(value, offset);
+                offset += value.length;
+            }
+            this.load(buffer);
+            BlockOffset = await data.initBlock(this.counts, this.shDegree);
+        }
+        const setFn = data.set.bind(data);
+        const setShFn = data.setShN.bind(data);
+        const { meta, refs } = this;
+        const infos = [];
+        {
+            const index = new DataView(refs['index.bin'].buffer);
+            const infoCounts = Math.floor(index.byteLength / (4 + 16 * meta.totalLevel));
+            let offset = 0;
+            for (let i = 0; i < infoCounts; i++) {
+                const x = index.getInt16(offset, true);
+                offset += 2;
+                const y = index.getInt16(offset, true);
+                offset += 2;
+                const lods = [];
+                for (let j = 0; j < meta.totalLevel; j++) {
+                    const points = index.getInt32(offset, true);
+                    offset += 4;
+                    const ldOffset = Number(index.getBigInt64(offset, true));
+                    offset += 8;
+                    const size = index.getInt32(offset, true);
+                    offset += 4;
+                    lods.push({ points, offset: ldOffset, size });
+                }
+                infos.push({ x, y, lods });
+            }
+        }
+        const attributes = meta.attributes.reduce((p, c) => {
+            p[c.name] = c;
+            return p;
+        }, {});
+        const { scale: { min: scaleMin, max: scaleMax }, shcoef: { min: shMin, max: shMax } } = attributes;
+        const single = {
+            x: 0, y: 0, z: 0,
+            sx: 0, sy: 0, sz: 0,
+            qx: 0, qy: 0, qz: 0, qw: 0,
+            r: 0, g: 0, b: 0, a: 0,
+            shN: [],
+        };
+        const shData = new Array(45);
+        let index = BlockOffset;
+        for (let i = 0; i < infos.length; i++) {
+            const info = infos[i];
+            const { points, offset, size } = info.lods[0];
+            const dataview = new DataView(refs['data.bin'].buffer, offset, size);
+            const shN = refs['shcoef.bin'] ? new DataView(refs['shcoef.bin'].buffer, offset * 2, size * 2) : undefined;
+            for (let j = 0; j < points; j++) {
+                const off = j * 32;
+                single.x = dataview.getFloat32(off + 0, true);
+                single.y = dataview.getFloat32(off + 4, true);
+                single.z = dataview.getFloat32(off + 8, true);
+                single.r = dataview.getUint8(off + 12) / 255.0;
+                single.g = dataview.getUint8(off + 13) / 255.0;
+                single.b = dataview.getUint8(off + 14) / 255.0;
+                single.a = dataview.getUint8(off + 15) / 255.0;
+                single.sx = mix(scaleMin[0], scaleMax[0], dataview.getUint16(off + 16, true) / 65535.0);
+                single.sy = mix(scaleMin[1], scaleMax[1], dataview.getUint16(off + 18, true) / 65535.0);
+                single.sz = mix(scaleMin[2], scaleMax[2], dataview.getUint16(off + 20, true) / 65535.0);
+                const quat = decodeRotation(dataview.getUint32(off + 22, true));
+                single.qx = quat[0];
+                single.qy = quat[1];
+                single.qz = quat[2];
+                single.qw = quat[3];
+                setFn(index, single);
+                if (shN) {
+                    const shOff = off * 2;
+                    for (let k = 0; k < 15; k++) {
+                        const v = DecodePacked_11_10_11(shN.getUint32(shOff + k * 4, true));
+                        shData[k * 3] = mix(shMin[0], shMax[0], v[0]);
+                        shData[k * 3 + 1] = mix(shMin[1], shMax[1], v[1]);
+                        shData[k * 3 + 2] = mix(shMin[2], shMax[2], v[2]);
+                    }
+                    setShFn(index, shData);
+                }
+                index++;
+            }
+        }
+        data.finishBlock();
+    }
+    async write(_stream, _data) {
+        throw new Error('Method not implemented.');
+    }
+}

package/dist/file/ply.d.ts

@@ -0,0 +1,13 @@
+import { SplatData } from '../SplatData.js';
+import { IFile } from './IFile.js';
+export declare class PlyFile implements IFile {
+    private littleEndian;
+    private comments;
+    private elements;
+    private isSuperSplatCompressed;
+    private counts;
+    private shDegree;
+    private initHeader;
+    read(stream: ReadableStream<Uint8Array>, _contentLength: number, data: SplatData): Promise<void>;
+    write(stream: WritableStream<Uint8Array>, data: SplatData, indices?: Uint32Array): Promise<void>;
+}