@threepipe/plugin-gaussian-splatting 0.2.1 → 0.2.3

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

@@ -1,238 +0,0 @@
-import { SplatBuffer } from './SplatBuffer.js';
-import { fetchWithProgress, delayedExecute } from '../Util.js';
-import { LoaderStatus } from './LoaderStatus.js';
-import { Constants } from '../Constants.js';
-
-const MINIMUM_REQUIRED_MAJOR_VERSION = 0;
-const MINIMUM_REQUIRED_MINOR_VERSION = 1;
-
-export class KSplatLoader {
-
-    constructor(splatBuffer = null) {
-        this.splatBuffer = splatBuffer;
-        this.downLoadLink = null;
-    }
-
-   static checkVersion(buffer) {
-        const header = SplatBuffer.parseHeader(buffer);
-        if (header.versionMajor === MINIMUM_REQUIRED_MAJOR_VERSION && header.versionMinor >= MINIMUM_REQUIRED_MINOR_VERSION ||
-            header.versionMajor > MINIMUM_REQUIRED_MAJOR_VERSION) {
-           return true;
-        } else {
-            throw new Error(`KSplat version not supported: v${header.versionMajor}.${header.versionMinor}. ` +
-                            `Minimum required: v${MINIMUM_REQUIRED_MAJOR_VERSION}.${MINIMUM_REQUIRED_MINOR_VERSION}`);
-        }
-    };
-
-    loadFromURL(fileName, onProgress, streamBuiltSections, onSectionBuilt) {
-        let bytesLoaded = 0;
-        let totalStorageSizeBytes = 0;
-
-        let streamBuffer;
-        let streamSplatBuffer;
-
-        let headerBuffer;
-        let header;
-        let headerLoaded = false;
-        let headerLoading = false;
-
-        let sectionHeadersBuffer;
-        let sectionHeaders = [];
-        let sectionHeadersLoaded = false;
-        let sectionHeadersLoading = false;
-
-        let lastStreamUpdateBytes = 0;
-        let streamSectionSizeBytes = Constants.StreamingSectionSize;
-        let totalBytesToDownload = 0;
-
-        let loadComplete = false;
-
-        let chunks = [];
-
-        let streamLoadCompleteResolver;
-        let streamLoadPromise = new Promise((resolve) => {
-            streamLoadCompleteResolver = resolve;
-        });
-
-        const checkAndLoadHeader = () => {
-            if (!headerLoaded && !headerLoading && bytesLoaded >= SplatBuffer.HeaderSizeBytes) {
-                headerLoading = true;
-                const headerAssemblyPromise = new Blob(chunks).arrayBuffer();
-                headerAssemblyPromise.then((bufferData) => {
-                    headerBuffer = new ArrayBuffer(SplatBuffer.HeaderSizeBytes);
-                    new Uint8Array(headerBuffer).set(new Uint8Array(bufferData, 0, SplatBuffer.HeaderSizeBytes));
-                    KSplatLoader.checkVersion(headerBuffer);
-                    headerLoading = false;
-                    headerLoaded = true;
-                    header = SplatBuffer.parseHeader(headerBuffer);
-                    window.setTimeout(() => {
-                        checkAndLoadSectionHeaders();
-                    }, 1);
-                });
-            }
-        };
-
-        let queuedCheckAndLoadSectionsCount = 0;
-        const queueCheckAndLoadSections = () => {
-            if (queuedCheckAndLoadSectionsCount === 0) {
-                queuedCheckAndLoadSectionsCount++;
-                window.setTimeout(() => {
-                    queuedCheckAndLoadSectionsCount--;
-                    checkAndLoadSections(true);
-                }, 1);
-            }
-        };
-
-        const checkAndLoadSectionHeaders = () => {
-            const performLoad = () => {
-                sectionHeadersLoading = true;
-                const sectionHeadersAssemblyPromise = new Blob(chunks).arrayBuffer();
-                sectionHeadersAssemblyPromise.then((bufferData) => {
-                    sectionHeadersLoading = false;
-                    sectionHeadersLoaded = true;
-                    sectionHeadersBuffer = new ArrayBuffer(header.maxSectionCount * SplatBuffer.SectionHeaderSizeBytes);
-                    new Uint8Array(sectionHeadersBuffer).set(new Uint8Array(bufferData, SplatBuffer.HeaderSizeBytes,
-                                                                            header.maxSectionCount * SplatBuffer.SectionHeaderSizeBytes));
-                    sectionHeaders = SplatBuffer.parseSectionHeaders(header, sectionHeadersBuffer, 0, false);
-                    let totalSectionStorageStorageByes = 0;
-                    for (let i = 0; i < header.maxSectionCount; i++) {
-                        totalSectionStorageStorageByes += sectionHeaders[i].storageSizeBytes;
-                    }
-                    totalStorageSizeBytes = SplatBuffer.HeaderSizeBytes + header.maxSectionCount *
-                                            SplatBuffer.SectionHeaderSizeBytes + totalSectionStorageStorageByes;
-                    if (!streamBuffer) {
-                        streamBuffer = new ArrayBuffer(totalStorageSizeBytes);
-                        let offset = 0;
-                        for (let i = 0; i < chunks.length; i++) {
-                            const chunk = chunks[i];
-                            new Uint8Array(streamBuffer, offset, chunk.byteLength).set(new Uint8Array(chunk));
-                            offset += chunk.byteLength;
-                        }
-                    }
-
-                    totalBytesToDownload = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount;
-                    for (let i = 0; i <= sectionHeaders.length && i < header.maxSectionCount; i++) {
-                        totalBytesToDownload += sectionHeaders[i].storageSizeBytes;
-                    }
-
-                    queueCheckAndLoadSections();
-                });
-            };
-
-            if (!sectionHeadersLoading && !sectionHeadersLoaded && headerLoaded &&
-                bytesLoaded >= SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount) {
-                performLoad();
-            }
-        };
-
-        const checkAndLoadSections = () => {
-            if (sectionHeadersLoaded) {
-
-                if (loadComplete) return;
-
-                loadComplete = bytesLoaded >= totalBytesToDownload;
-
-                const bytesLoadedSinceLastSection = bytesLoaded - lastStreamUpdateBytes;
-                if (bytesLoadedSinceLastSection > streamSectionSizeBytes || loadComplete) {
-
-                    lastStreamUpdateBytes = bytesLoaded;
-
-                    if (!streamSplatBuffer) streamSplatBuffer = new SplatBuffer(streamBuffer, false);
-
-                    const baseDataOffset = SplatBuffer.HeaderSizeBytes + SplatBuffer.SectionHeaderSizeBytes * header.maxSectionCount;
-                    let sectionBase = 0;
-                    let reachedSections = 0;
-                    let loadedSplatCount = 0;
-                    for (let i = 0; i < header.maxSectionCount; i++) {
-                        const sectionHeader = sectionHeaders[i];
-                        const bucketsDataOffset = sectionBase + sectionHeader.partiallyFilledBucketCount * 4 +
-                                                  sectionHeader.bucketStorageSizeBytes * sectionHeader.bucketCount;
-                        const bytesRequiredToReachSectionSplatData = baseDataOffset + bucketsDataOffset;
-                        if (bytesLoaded >= bytesRequiredToReachSectionSplatData) {
-                            reachedSections++;
-                            const bytesPastSSectionSplatDataStart = bytesLoaded - bytesRequiredToReachSectionSplatData;
-                            const bytesPerSplat = SplatBuffer.CompressionLevels[header.compressionLevel].BytesPerSplat;
-                            let loadedSplatsForSection = Math.floor(bytesPastSSectionSplatDataStart / bytesPerSplat);
-                            loadedSplatsForSection = Math.min(loadedSplatsForSection, sectionHeader.maxSplatCount);
-                            loadedSplatCount += loadedSplatsForSection;
-                            streamSplatBuffer.updateLoadedCounts(reachedSections, loadedSplatCount);
-                            streamSplatBuffer.updateSectionLoadedCounts(i, loadedSplatsForSection);
-                        } else {
-                            break;
-                        }
-                        sectionBase += sectionHeader.storageSizeBytes;
-                    }
-
-                    onSectionBuilt(streamSplatBuffer, loadComplete);
-
-                    if (loadComplete) {
-                        streamLoadCompleteResolver();
-                    }
-                }
-            }
-        };
-
-        const localOnProgress = (percent, percentStr, chunk) => {
-
-            if (chunk) {
-                chunks.push(chunk);
-                if (streamBuffer) {
-                    new Uint8Array(streamBuffer, bytesLoaded, chunk.byteLength).set(new Uint8Array(chunk));
-                }
-                bytesLoaded += chunk.byteLength;
-            }
-            if (streamBuiltSections) {
-                checkAndLoadHeader();
-                checkAndLoadSectionHeaders();
-                checkAndLoadSections();
-            }
-            if (onProgress) onProgress(percent, percentStr, LoaderStatus.Downloading);
-        };
-
-        return fetchWithProgress(fileName, localOnProgress, !streamBuiltSections).then((fullBuffer) => {
-            if (onProgress) onProgress(0, '0%', LoaderStatus.Processing);
-            return delayedExecute(() => {
-                function finish(buffer) {
-                    if (onProgress) onProgress(100, '100%', LoaderStatus.Done);
-                    if (buffer instanceof SplatBuffer) return buffer;
-                    else {
-                        KSplatLoader.checkVersion(buffer);
-                        return new SplatBuffer(buffer);
-                    }
-                }
-                if (streamBuiltSections) {
-                    return streamLoadPromise.then(() => {
-                        return finish(streamSplatBuffer);
-                    });
-                } else {
-                    return finish(fullBuffer);
-                }
-            });
-        });
-    }
-
-    setFromBuffer(splatBuffer) {
-        this.splatBuffer = splatBuffer;
-    }
-
-    static downloadFile = function() {
-
-        let downLoadLink;
-
-        return function(splatBuffer, fileName) {
-            const blob = new Blob([splatBuffer.bufferData], {
-                type: 'application/octet-stream',
-            });
-
-            if (!downLoadLink) {
-                downLoadLink = document.createElement('a');
-                document.body.appendChild(downLoadLink);
-            }
-            downLoadLink.download = fileName;
-            downLoadLink.href = URL.createObjectURL(blob);
-            downLoadLink.click();
-        };
-
-    }();
-
-}

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

@@ -1,6 +0,0 @@
-export const LoaderStatus = {
-    'Downloading': 0,
-    'Processing': 1,
-    'Done': 2,
-};
-

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

@@ -1,32 +0,0 @@
-import {PlyParser} from './PlyParser.js';
-import {delayedExecute, fetchWithProgress} from '../Util.js';
-import {LoaderStatus} from './LoaderStatus.js';
-import {SplatBufferGenerator} from './SplatBufferGenerator.js';
-
-export class PlyLoader {
-
-    constructor () {
-        this.splatBuffer = null;
-    }
-
-    loadFromURL (fileName, onProgress, compressionLevel, minimumAlpha, sectionSize, sceneCenter, blockSize, bucketSize) {
-        const downloadProgress = (percent, percentLabel) => {
-            if (onProgress) onProgress(percent, percentLabel, LoaderStatus.Downloading);
-        };
-        return fetchWithProgress(fileName, downloadProgress).then((plyFileData) => {
-            if (onProgress) onProgress(0, '0%', LoaderStatus.Processing);
-            return delayedExecute(() => {
-                return new PlyParser(plyFileData).parseToUncompressedSplatArray();
-            });
-        })
-            .then((splatArray) => {
-                const splatBufferGenerator = SplatBufferGenerator.getStandardGenerator(minimumAlpha,
-                    compressionLevel, sectionSize,
-                    sceneCenter, blockSize, bucketSize);
-                const splatBuffer = splatBufferGenerator.generateFromUncompressedSplatArray(splatArray);
-                if (onProgress) onProgress(100, '100%', LoaderStatus.Done);
-                return splatBuffer;
-            });
-    }
-
-}

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

@@ -1,188 +0,0 @@
-import {UncompressedSplatArray} from './UncompressedSplatArray.js';
-
-export class PlyParser {
-
-    static HeaderEndToken = 'end_header';
-
-    constructor (plyBuffer) {
-        this.plyBuffer = plyBuffer;
-    }
-
-    static decodeHeader (plyBuffer) {
-        const decoder = new TextDecoder();
-        let headerOffset = 0;
-        let headerText = '';
-
-        // console.log('.PLY size: ' + plyBuffer.byteLength + ' bytes');
-
-        const readChunkSize = 100;
-
-        while (true) {
-            if (headerOffset + readChunkSize >= plyBuffer.byteLength) {
-                throw new Error('End of file reached while searching for end of header');
-            }
-            const headerChunk = new Uint8Array(plyBuffer, headerOffset, readChunkSize);
-            headerText += decoder.decode(headerChunk);
-            headerOffset += readChunkSize;
-
-            const endHeaderTestChunk = new Uint8Array(plyBuffer, Math.max(0, headerOffset - readChunkSize * 2), readChunkSize * 2);
-            const endHeaderTestText = decoder.decode(endHeaderTestChunk);
-            if (endHeaderTestText.includes('end_header')) {
-                break;
-            }
-        }
-
-        const headerLines = headerText.split('\n');
-
-        let splatCount = 0;
-        let propertyTypes = {};
-
-        for (let i = 0; i < headerLines.length; i++) {
-            const line = headerLines[i].trim();
-            if (line.startsWith('element vertex')) {
-                const splatCountMatch = line.match(/\d+/);
-                if (splatCountMatch) {
-                    splatCount = parseInt(splatCountMatch[0]);
-                }
-            } else if (line.startsWith('property')) {
-                const propertyMatch = line.match(/(\w+)\s+(\w+)\s+(\w+)/);
-                if (propertyMatch) {
-                    const propertyType = propertyMatch[2];
-                    const propertyName = propertyMatch[3];
-                    propertyTypes[propertyName] = propertyType;
-                }
-            } else if (line === 'end_header') {
-                break;
-            }
-        }
-
-        const vertexByteOffset = headerText.indexOf('end_header') + PlyParser.HeaderEndToken.length + 1;
-        const vertexData = new DataView(plyBuffer, vertexByteOffset);
-
-        return {
-            'splatCount': splatCount,
-            'propertyTypes': propertyTypes,
-            'vertexData': vertexData,
-            'headerOffset': headerOffset,
-        };
-    }
-
-    static readRawVertexFast (vertexData, offset, fieldOffsets, propertiesToRead, propertyTypes, outVertex) {
-        let rawVertex = outVertex || {};
-        for (let property of propertiesToRead) {
-            const propertyType = propertyTypes[property];
-            if (propertyType === 'float') {
-                rawVertex[property] = vertexData.getFloat32(offset + fieldOffsets[property], true);
-            } else if (propertyType === 'uchar') {
-                rawVertex[property] = vertexData.getUint8(offset + fieldOffsets[property]) / 255.0;
-            }
-        }
-    }
-
-    parseToUncompressedSplatArray () {
-
-        // const startTime = performance.now();
-
-        // console.log('Parsing PLY to SPLAT...');
-
-        const {splatCount, propertyTypes, vertexData} = PlyParser.decodeHeader(this.plyBuffer);
-
-        // figure out the SH degree from the number of coefficients
-        let nRestCoeffs = 0;
-        for (const propertyName in propertyTypes) {
-            if (propertyName.startsWith('f_rest_')) {
-                nRestCoeffs += 1;
-            }
-        }
-        const nCoeffsPerColor = nRestCoeffs / 3;
-
-        // TODO: Eventually properly support multiple degree spherical harmonics
-        // const sphericalHarmonicsDegree = Math.sqrt(nCoeffsPerColor + 1) - 1;
-        // const sphericalHarmonicsDegree = 0;
-        // console.log('Detected degree', sphericalHarmonicsDegree, 'with ', nCoeffsPerColor, 'coefficients per color');
-
-        // figure out the order in which spherical harmonics should be read
-        const shFeatureOrder = [];
-        for (let rgb = 0; rgb < 3; ++rgb) {
-            shFeatureOrder.push(`f_dc_${rgb}`);
-        }
-        for (let i = 0; i < nCoeffsPerColor; ++i) {
-            for (let rgb = 0; rgb < 3; ++rgb) {
-                shFeatureOrder.push(`f_rest_${rgb * nCoeffsPerColor + i}`);
-            }
-        }
-
-        let plyRowSize = 0;
-        let fieldOffsets = {};
-        const fieldSize = {
-            'double': 8,
-            'int': 4,
-            'uint': 4,
-            'float': 4,
-            'short': 2,
-            'ushort': 2,
-            'uchar': 1,
-        };
-        for (let fieldName in propertyTypes) {
-            if (propertyTypes.hasOwnProperty(fieldName)) {
-                const type = propertyTypes[fieldName];
-                fieldOffsets[fieldName] = plyRowSize;
-                plyRowSize += fieldSize[type];
-            }
-        }
-
-        let rawVertex = {};
-
-        const propertiesToRead = ['scale_0', 'scale_1', 'scale_2', 'rot_0', 'rot_1', 'rot_2', 'rot_3',
-            'x', 'y', 'z', 'f_dc_0', 'f_dc_1', 'f_dc_2', 'opacity'];
-
-        const splatArray = new UncompressedSplatArray();
-
-        for (let row = 0; row < splatCount; row++) {
-            PlyParser.readRawVertexFast(vertexData, row * plyRowSize, fieldOffsets, propertiesToRead, propertyTypes, rawVertex);
-            const newSplat = splatArray.addDefaultSplat();
-            if (rawVertex['scale_0'] !== undefined) {
-                newSplat[UncompressedSplatArray.OFFSET.SCALE0] = Math.exp(rawVertex['scale_0']);
-                newSplat[UncompressedSplatArray.OFFSET.SCALE1] = Math.exp(rawVertex['scale_1']);
-                newSplat[UncompressedSplatArray.OFFSET.SCALE2] = Math.exp(rawVertex['scale_2']);
-            } else {
-                newSplat[UncompressedSplatArray.OFFSET.SCALE0] = 0.01;
-                newSplat[UncompressedSplatArray.OFFSET.SCALE1] = 0.01;
-                newSplat[UncompressedSplatArray.OFFSET.SCALE2] = 0.01;
-            }
-
-            if (rawVertex['f_dc_0'] !== undefined) {
-                const SH_C0 = 0.28209479177387814;
-                newSplat[UncompressedSplatArray.OFFSET.FDC0] = (0.5 + SH_C0 * rawVertex['f_dc_0']) * 255;
-                newSplat[UncompressedSplatArray.OFFSET.FDC1] = (0.5 + SH_C0 * rawVertex['f_dc_1']) * 255;
-                newSplat[UncompressedSplatArray.OFFSET.FDC2] = (0.5 + SH_C0 * rawVertex['f_dc_2']) * 255;
-            } else {
-                newSplat[UncompressedSplatArray.OFFSET.FDC0] = 0;
-                newSplat[UncompressedSplatArray.OFFSET.FDC1] = 0;
-                newSplat[UncompressedSplatArray.OFFSET.FDC2] = 0;
-            }
-            if (rawVertex['opacity'] !== undefined) {
-                newSplat[UncompressedSplatArray.OFFSET.OPACITY] = (1 / (1 + Math.exp(-rawVertex['opacity']))) * 255;
-            }
-
-            newSplat[UncompressedSplatArray.OFFSET.ROTATION0] = rawVertex['rot_0'];
-            newSplat[UncompressedSplatArray.OFFSET.ROTATION1] = rawVertex['rot_1'];
-            newSplat[UncompressedSplatArray.OFFSET.ROTATION2] = rawVertex['rot_2'];
-            newSplat[UncompressedSplatArray.OFFSET.ROTATION3] = rawVertex['rot_3'];
-
-            newSplat[UncompressedSplatArray.OFFSET.X] = rawVertex['x'];
-            newSplat[UncompressedSplatArray.OFFSET.Y] = rawVertex['y'];
-            newSplat[UncompressedSplatArray.OFFSET.Z] = rawVertex['z'];
-        }
-
-        return splatArray;
-
-        // console.log('Total valid splats: ', splatBuffer.getSplatCount(), 'out of', splatCount);
-
-        // const endTime = performance.now();
-
-        // console.log('Parsing PLY to SPLAT complete!');
-        // console.log('Total time: ', (endTime - startTime).toFixed(2) + ' ms');
-    }
-
-}

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

@@ -1,5 +0,0 @@
-export const SceneFormat = {
-    'Splat': 0,
-    'KSplat': 1,
-    'Ply': 2
-};