@threepipe/plugin-gaussian-splatting 0.2.1 → 0.2.4

package/src/gaussian-splats-3d/loaders/SplatBufferGenerator.js

@@ -1,31 +0,0 @@
-import * as THREE from 'threepipe';
-import {SplatPartitioner} from './SplatPartitioner.js';
-import {SplatBuffer} from './SplatBuffer.js';
-
-export class SplatBufferGenerator {
-
-    constructor (splatPartitioner, alphaRemovalThreshold, compressionLevel, sectionSize, sceneCenter, blockSize, bucketSize) {
-        this.splatPartitioner = splatPartitioner;
-        this.alphaRemovalThreshold = alphaRemovalThreshold;
-        this.compressionLevel = compressionLevel;
-        this.sectionSize = sectionSize;
-        this.sceneCenter = sceneCenter ? new THREE.Vector3().copy(sceneCenter) : undefined;
-        this.blockSize = blockSize;
-        this.bucketSize = bucketSize;
-    }
-
-    generateFromUncompressedSplatArray (splatArray) {
-        const partitionResults = this.splatPartitioner.partitionUncompressedSplatArray(splatArray);
-        return SplatBuffer.generateFromUncompressedSplatArrays(partitionResults.splatArrays,
-            this.alphaRemovalThreshold, this.compressionLevel,
-            this.sceneCenter, this.blockSize, this.bucketSize,
-            partitionResults.parameters);
-    }
-
-    static getStandardGenerator (alphaRemovalThreshold = 1, compressionLevel = 1, sectionSize = 0, sceneCenter = new THREE.Vector3(),
-        blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) {
-        const splatPartitioner = SplatPartitioner.getStandardPartitioner(sectionSize, sceneCenter, blockSize, bucketSize);
-        return new SplatBufferGenerator(splatPartitioner, alphaRemovalThreshold, compressionLevel,
-            sectionSize, sceneCenter, blockSize, bucketSize);
-    }
-}

package/src/gaussian-splats-3d/loaders/SplatLoader.js

@@ -1,129 +0,0 @@
-import * as THREE from 'threepipe';
-import {SplatBuffer} from './SplatBuffer.js';
-import {SplatBufferGenerator} from './SplatBufferGenerator.js';
-import {SplatParser} from './SplatParser.js';
-import {delayedExecute, fetchWithProgress} from '../Util.js';
-import {LoaderStatus} from './LoaderStatus.js';
-import {Constants} from '../Constants.js';
-
-export class SplatLoader {
-
-    constructor (splatBuffer = null) {
-        this.splatBuffer = splatBuffer;
-        this.downLoadLink = null;
-    }
-
-    loadFromURL (fileName, onProgress, stream, onStreamedSectionProgress, compressionLevel,
-        minimumAlpha, optimizeSplatData, sectionSize, sceneCenter, blockSize, bucketSize) {
-
-        let streamBufferIn;
-        let streamBufferOut;
-        let streamSplatBuffer;
-        let lastSectionBytes = 0;
-        let streamSectionSizeBytes = Constants.StreamingSectionSize;
-        let sectionCount = 1;
-        let maxSplatCount = 0;
-        let splatCount = 0;
-
-        let streamLoadCompleteResolver;
-        let streamLoadPromise = new Promise((resolve) => {
-            streamLoadCompleteResolver = resolve;
-        });
-
-        let bytesLoaded = 0;
-        let chunks = [];
-
-        const localOnProgress = (percent, percentStr, chunk, fileSize) => {
-            const loadComplete = percent >= 100;
-            if (!fileSize) stream = false;
-            if (stream) {
-                const splatDataOffsetBytes = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes;
-                if (!streamBufferIn) {
-                    maxSplatCount = fileSize / SplatParser.RowSizeBytes;
-                    streamBufferIn = new ArrayBuffer(fileSize);
-                    const splatBufferSizeBytes = splatDataOffsetBytes + SplatBuffer.CompressionLevels[0].BytesPerSplat * maxSplatCount;
-                    streamBufferOut = new ArrayBuffer(splatBufferSizeBytes);
-                    SplatBuffer.writeHeaderToBuffer({
-                        versionMajor: 0,
-                        versionMinor: 1,
-                        maxSectionCount: sectionCount,
-                        sectionCount: sectionCount,
-                        maxSplatCount: maxSplatCount,
-                        splatCount: splatCount,
-                        compressionLevel: 0,
-                        sceneCenter: new THREE.Vector3(),
-                    }, streamBufferOut);
-                }
-
-                if (chunk) {
-                    chunks.push(chunk);
-                    new Uint8Array(streamBufferIn, bytesLoaded, chunk.byteLength).set(new Uint8Array(chunk));
-                    bytesLoaded += chunk.byteLength;
-
-                    const bytesLoadedSinceLastSection = bytesLoaded - lastSectionBytes;
-                    if (bytesLoadedSinceLastSection > streamSectionSizeBytes || loadComplete) {
-                        const bytesToUpdate = loadComplete ? bytesLoadedSinceLastSection : streamSectionSizeBytes;
-                        const addedSplatCount = bytesToUpdate / SplatParser.RowSizeBytes;
-                        const newSplatCount = splatCount + addedSplatCount;
-                        SplatParser.parseToUncompressedBufferSection(splatCount, newSplatCount, streamBufferIn, 0,
-                            streamBufferOut, splatDataOffsetBytes);
-                        splatCount = newSplatCount;
-                        if (!streamSplatBuffer) {
-                            SplatBuffer.writeSectionHeaderToBuffer({
-                                maxSplatCount: maxSplatCount,
-                                splatCount: splatCount,
-                                bucketSize: 0,
-                                bucketCount: 0,
-                                bucketBlockSize: 0,
-                                compressionScaleRange: 0,
-                                storageSizeBytes: 0,
-                                fullBucketCount: 0,
-                                partiallyFilledBucketCount: 0,
-                            }, 0, streamBufferOut, SplatBuffer.HeaderSizeBytes);
-                            streamSplatBuffer = new SplatBuffer(streamBufferOut, false);
-                        }
-                        streamSplatBuffer.updateLoadedCounts(1, splatCount);
-                        onStreamedSectionProgress(streamSplatBuffer, loadComplete);
-                        lastSectionBytes += streamSectionSizeBytes;
-                    }
-                }
-                if (loadComplete) {
-                    streamLoadCompleteResolver();
-                }
-            }
-            if (onProgress) onProgress(percent, percentStr, LoaderStatus.Downloading);
-            return stream;
-        };
-
-        return fetchWithProgress(fileName, localOnProgress, true).then((fullBuffer) => {
-            if (onProgress) onProgress(0, '0%', LoaderStatus.Processing);
-            if (stream) {
-                return streamLoadPromise.then(() => {
-                    if (onProgress) onProgress(100, '100%', LoaderStatus.Done);
-                    return streamSplatBuffer;
-                });
-            } else {
-                return delayedExecute(() => {
-                    const splatArray = SplatParser.parseStandardSplatToUncompressedSplatArray(fullBuffer);
-                    let splatBuffer;
-                    if (optimizeSplatData) {
-                        const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha, compressionLevel,
-                            sectionSize, sceneCenter, blockSize,
-                            bucketSize);
-                        splatBuffer = splatBufferGenerator.generateFromUncompressedSplatArray(splatArray);
-                    } else {
-                        splatBuffer = SplatBuffer.generateFromUncompressedSplatArrays([splatArray], minimumAlpha, 0,
-                            new THREE.Vector3());
-                    }
-                    if (onProgress) onProgress(100, '100%', LoaderStatus.Done);
-                    return splatBuffer;
-                });
-            }
-        });
-    }
-
-    setFromBuffer (splatBuffer) {
-        this.splatBuffer = splatBuffer;
-    }
-
-}

package/src/gaussian-splats-3d/loaders/SplatParser.js

@@ -1,88 +0,0 @@
-import * as THREE from 'threepipe';
-import {SplatBuffer} from './SplatBuffer.js';
-import {UncompressedSplatArray} from './UncompressedSplatArray.js';
-
-export class SplatParser {
-
-    static RowSizeBytes = 32;
-    static CenterSizeBytes = 12;
-    static ScaleSizeBytes = 12;
-    static RotationSizeBytes = 4;
-    static ColorSizeBytes = 4;
-
-    static parseToUncompressedBufferSection (fromSplat, toSplat, fromBuffer, fromOffset, toBuffer, toOffset) {
-
-        const outBytesPerCenter = SplatBuffer.CompressionLevels[0].BytesPerCenter;
-        const outBytesPerScale = SplatBuffer.CompressionLevels[0].BytesPerScale;
-        const outBytesPerRotation = SplatBuffer.CompressionLevels[0].BytesPerRotation;
-        const outBytesPerSplat = SplatBuffer.CompressionLevels[0].BytesPerSplat;
-
-        for (let i = fromSplat; i < toSplat; i++) {
-            const inBase = i * SplatParser.RowSizeBytes + fromOffset;
-            const inCenter = new Float32Array(fromBuffer, inBase, 3);
-            const inScale = new Float32Array(fromBuffer, inBase + SplatParser.CenterSizeBytes, 3);
-            const inColor = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes, 4);
-            const inRotation = new Uint8Array(fromBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes +
-                                              SplatParser.RotationSizeBytes, 4);
-
-            const quat = new THREE.Quaternion((inRotation[1] - 128) / 128, (inRotation[2] - 128) / 128,
-                (inRotation[3] - 128) / 128, (inRotation[0] - 128) / 128);
-            quat.normalize();
-
-            const outBase = i * outBytesPerSplat + toOffset;
-            const outCenter = new Float32Array(toBuffer, outBase, 3);
-            const outScale = new Float32Array(toBuffer, outBase + outBytesPerCenter, 3);
-            const outRotation = new Float32Array(toBuffer, outBase + outBytesPerCenter + outBytesPerScale, 4);
-            const outColor = new Uint8Array(toBuffer, outBase + outBytesPerCenter + outBytesPerScale + outBytesPerRotation, 4);
-
-            outCenter[0] = inCenter[0];
-            outCenter[1] = inCenter[1];
-            outCenter[2] = inCenter[2];
-
-            outScale[0] = inScale[0];
-            outScale[1] = inScale[1];
-            outScale[2] = inScale[2];
-
-            outRotation[0] = quat.w;
-            outRotation[1] = quat.x;
-            outRotation[2] = quat.y;
-            outRotation[3] = quat.z;
-
-            outColor[0] = inColor[0];
-            outColor[1] = inColor[1];
-            outColor[2] = inColor[2];
-            outColor[3] = inColor[3];
-        }
-    }
-
-    static parseStandardSplatToUncompressedSplatArray (inBuffer) {
-        // Standard .splat row layout:
-        // XYZ - Position (Float32)
-        // XYZ - Scale (Float32)
-        // RGBA - colors (uint8)
-        // IJKL - quaternion/rot (uint8)
-
-        const splatCount = inBuffer.byteLength / SplatParser.RowSizeBytes;
-
-        const splatArray = new UncompressedSplatArray();
-
-        for (let i = 0; i < splatCount; i++) {
-            const inBase = i * SplatParser.RowSizeBytes;
-            const inCenter = new Float32Array(inBuffer, inBase, 3);
-            const inScale = new Float32Array(inBuffer, inBase + SplatParser.CenterSizeBytes, 3);
-            const inColor = new Uint8Array(inBuffer, inBase + SplatParser.CenterSizeBytes + SplatParser.ScaleSizeBytes, 4);
-            const inRotation = new Uint8Array(inBuffer, inBase + SplatParser.CenterSizeBytes +
-                                              SplatParser.ScaleSizeBytes + SplatParser.ColorSizeBytes, 4);
-
-            const quat = new THREE.Quaternion((inRotation[1] - 128) / 128, (inRotation[2] - 128) / 128,
-                (inRotation[3] - 128) / 128, (inRotation[0] - 128) / 128);
-            quat.normalize();
-
-            splatArray.addSplatFromComonents(inCenter[0], inCenter[1], inCenter[2], inScale[0], inScale[1], inScale[2],
-                quat.w, quat.x, quat.y, quat.z, inColor[0], inColor[1], inColor[2], inColor[3]);
-        }
-
-        return splatArray;
-    }
-
-}

package/src/gaussian-splats-3d/loaders/SplatPartitioner.js

@@ -1,99 +0,0 @@
-import * as THREE from 'threepipe';
-import {UncompressedSplatArray} from './UncompressedSplatArray.js';
-import {SplatBuffer} from './SplatBuffer.js';
-
-export class SplatPartitioner {
-
-    constructor (sectionCount, sectionFilters, groupingParameters, partitionGenerator) {
-        this.sectionCount = sectionCount;
-        this.sectionFilters = sectionFilters;
-        this.groupingParameters = groupingParameters;
-        this.partitionGenerator = partitionGenerator;
-    }
-
-    partitionUncompressedSplatArray (splatArray) {
-        let groupingParameters;
-        let sectionCount;
-        let sectionFilters;
-        if (this.partitionGenerator) {
-            const results = this.partitionGenerator(splatArray);
-            groupingParameters = results.groupingParameters;
-            sectionCount = results.sectionCount;
-            sectionFilters = results.sectionFilters;
-        } else {
-            groupingParameters = this.groupingParameters;
-            sectionCount = this.sectionCount;
-            sectionFilters = this.sectionFilters;
-        }
-
-        const newArrays = [];
-        for (let s = 0; s < sectionCount; s++) {
-            const sectionSplats = new UncompressedSplatArray();
-            const sectionFilter = sectionFilters[s];
-            for (let i = 0; i < splatArray.splatCount; i++) {
-                if (sectionFilter(i)) {
-                    sectionSplats.addSplatFromArray(splatArray, i);
-                }
-            }
-            newArrays.push(sectionSplats);
-        }
-        return {
-            splatArrays: newArrays,
-            parameters: groupingParameters,
-        };
-    }
-
-    static getStandardPartitioner (partitionSize = 0, sceneCenter = new THREE.Vector3(),
-        blockSize = SplatBuffer.BucketBlockSize, bucketSize = SplatBuffer.BucketSize) {
-        const partitionGenerator = (splatArray) => {
-
-            if (partitionSize <= 0) partitionSize = splatArray.splatCount;
-
-            const centerA = new THREE.Vector3();
-            const centerB = new THREE.Vector3();
-            const clampDistance = 0.5;
-            const clampPoint = (point) => {
-                point.x = Math.floor(point.x / clampDistance) * clampDistance;
-                point.y = Math.floor(point.y / clampDistance) * clampDistance;
-                point.z = Math.floor(point.z / clampDistance) * clampDistance;
-            };
-            splatArray.splats.sort((a, b) => {
-                centerA.set(a[UncompressedSplatArray.OFFSET.X],
-                    a[UncompressedSplatArray.OFFSET.Y],
-                    a[UncompressedSplatArray.OFFSET.Z]).sub(sceneCenter);
-                clampPoint(centerA);
-                const centerADist = centerA.lengthSq();
-                centerB.set(b[UncompressedSplatArray.OFFSET.X],
-                    b[UncompressedSplatArray.OFFSET.Y],
-                    b[UncompressedSplatArray.OFFSET.Z]).sub(sceneCenter);
-                clampPoint(centerB);
-                const centerBDist = centerB.lengthSq();
-                if (centerADist > centerBDist) return 1;
-                else return -1;
-            });
-
-            const sectionFilters = [];
-            const groupingParameters = [];
-            partitionSize = Math.min(splatArray.splatCount, partitionSize);
-            const patitionCount = Math.ceil(splatArray.splatCount / partitionSize);
-            let currentStartSplat = 0;
-            for (let i = 0; i < patitionCount; i++) {
-                let startSplat = currentStartSplat;
-                sectionFilters.push((splatIndex) => {
-                    return splatIndex >= startSplat && splatIndex < startSplat + partitionSize;
-                });
-                groupingParameters.push({
-                    'blocksSize': blockSize,
-                    'bucketSize': bucketSize,
-                });
-                currentStartSplat += partitionSize;
-            }
-            return {
-                'sectionCount': sectionFilters.length,
-                sectionFilters,
-                groupingParameters,
-            };
-        };
-        return new SplatPartitioner(undefined, undefined, undefined, partitionGenerator);
-    }
-}

package/src/gaussian-splats-3d/loaders/UncompressedSplatArray.js

@@ -1,49 +0,0 @@
-
-export class UncompressedSplatArray {
-
-    static OFFSET = {
-        X: 0,
-        Y: 1,
-        Z: 2,
-        SCALE0: 3,
-        SCALE1: 4,
-        SCALE2: 5,
-        ROTATION0: 6,
-        ROTATION1: 7,
-        ROTATION2: 8,
-        ROTATION3: 9,
-        FDC0: 10,
-        FDC1: 11,
-        FDC2: 12,
-        OPACITY: 13,
-    };
-
-    constructor () {
-        this.splats = [];
-        this.splatCount = 0;
-    }
-
-    addSplat (splat) {
-        this.splats.push(splat);
-        this.splatCount++;
-    }
-
-    addDefaultSplat () {
-        const newSplat = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
-        this.addSplat(newSplat);
-        return newSplat;
-    }
-
-    addSplatFromComonents (x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity) {
-        const newSplat = [x, y, z, scale0, scale1, scale2, rot0, rot1, rot2, rot3, r, g, b, opacity];
-        this.addSplat(newSplat);
-        return newSplat;
-    }
-
-    addSplatFromArray (src, srcIndex) {
-        const srcSplat = src.splats[srcIndex];
-        this.addSplatFromComonents(srcSplat[0], srcSplat[1], srcSplat[2], srcSplat[3], srcSplat[4], srcSplat[5],
-            srcSplat[6], srcSplat[7], srcSplat[8], srcSplat[9],
-            srcSplat[10], srcSplat[11], srcSplat[12], srcSplat[13]);
-    }
-}

package/src/gaussian-splats-3d/loaders/Utils.js

@@ -1,8 +0,0 @@
-import { SceneFormat } from './SceneFormat.js';
-
-export const sceneFormatFromPath = (path) => {
-    if (path.endsWith('.ply')) return SceneFormat.Ply;
-    else if (path.endsWith('.splat')) return SceneFormat.Splat;
-    else if (path.endsWith('.ksplat')) return SceneFormat.KSplat;
-    return null;
-};

package/src/gaussian-splats-3d/loaders-ts/SplatLoader.ts

@@ -1,33 +0,0 @@
-import {SplatLoader as SplatLoaderJs} from '../loaders/SplatLoader.js'
-import {ILoader, Loader} from 'threepipe'
-import {GaussianSplatMesh} from '../../three-gaussian-splat'
-
-export class SplatLoader extends Loader implements ILoader {
-    private _loader = new SplatLoaderJs()
-    load(url: string, onLoad?: (splat: any) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void) {
-        const onProgress1 = (percent: number, percentStr: string, status: number /* LoaderStatus*/)=>{
-            console.log('SplatLoader onProgress', {percent, percentStr, status})
-            onProgress && onProgress(new ProgressEvent('progress', {loaded: percent, total: 100}))
-        }
-        const streamBuiltSections = false
-        const onSectionBuilt = (streamSplatBuffer: any /* SplatBuffer */, loadComplete: boolean)=>{
-            console.log('SplatLoader streamSectionProgress', {streamSplatBuffer, loadComplete})
-            onLoad && onLoad(streamSplatBuffer)
-        }
-        const splatAlphaRemovalThreshold = 1
-        this._loader.loadFromURL(
-            url, onProgress1, streamBuiltSections, onSectionBuilt,
-            0, splatAlphaRemovalThreshold, false).then((buffer: any)=>{
-            console.log(buffer)
-            console.log('SplatLoader onLoad', buffer)
-            onLoad && onLoad(buffer)
-        }).catch((err: any)=>{
-            console.error(err)
-            onError && onError(new ErrorEvent('error', {error: err}))
-        })
-    }
-
-    public async loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GaussianSplatMesh> {
-        return new Promise((resolve, reject) => this.load(url, resolve, onProgress, reject))
-    }
-}