@manycore/aholo-splat-transform 1.2.7 → 1.2.9

package/dist/tasks/SkeletonLodTask.js

@@ -1,156 +1,176 @@
-import { SplatData } from '../SplatData.js';
-import { BaseTask } from './BaseTask.js';
-const VOXEL_CHUNK_SIZE = 0.02;
-const VOXEL_CHUNK_SCALE = 1.3;
-export class SkeletonLodTask extends BaseTask {
-    async exec(config, { logger, resources }) {
-        const { input, output, counts = 85000, ratio = 0.1 } = config;
-        const splat = resources.get(input);
-        logger.info(`loaded -> "${input}"`);
-        const target = Math.min(Math.ceil(splat.counts * ratio), counts);
-        logger.info(`expected -> ${target}(${((target / splat.counts) * 100).toFixed(2)}%) | ratio=${ratio} counts=${counts}`);
-        const xCol = splat.table[0 /* ColIdx.x */];
-        const yCol = splat.table[1 /* ColIdx.y */];
-        const zCol = splat.table[2 /* ColIdx.z */];
-        let minX = Infinity;
-        let minY = Infinity;
-        let minZ = Infinity;
-        for (let i = 0; i < splat.counts; i++) {
-            const x = xCol[i];
-            const y = yCol[i];
-            const z = zCol[i];
-            if (x < minX) {
-                minX = x;
-            }
-            if (y < minY) {
-                minY = y;
-            }
-            if (z < minZ) {
-                minZ = z;
-            }
-        }
-        const chunkMap = new Map();
-        for (let i = 0; i < splat.counts; i++) {
-            const x = ((xCol[i] - minX) / VOXEL_CHUNK_SIZE) | 0;
-            const y = ((yCol[i] - minY) / VOXEL_CHUNK_SIZE) | 0;
-            const z = ((zCol[i] - minZ) / VOXEL_CHUNK_SIZE) | 0;
-            const key = `${x},${y},${z}`;
-            let arr = chunkMap.get(key);
-            if (!arr) {
-                arr = [];
-                chunkMap.set(key, arr);
-            }
-            arr.push(i);
-        }
-        const chunks = Array.from(chunkMap.values());
-        const CHUNK_RATIO = chunks.reduce((p, c) => p + c.length ** VOXEL_CHUNK_SCALE, 0) / (target * 0.1);
-        const mergeChucks = [];
-        for (let i = 0; i < chunks.length; i++) {
-            const chunk = chunks[i];
-            const size = Math.max(1, Math.ceil((chunk.length ** VOXEL_CHUNK_SCALE) / CHUNK_RATIO));
-            if (size === 1) {
-                mergeChucks.push(chunk);
-                continue;
-            }
-            let minX = Infinity;
-            let minY = Infinity;
-            let minZ = Infinity;
-            let maxX = -Infinity;
-            let maxY = -Infinity;
-            let maxZ = -Infinity;
-            for (let j = 0; j < chunk.length; j++) {
-                const offset = chunk[j];
-                const x = xCol[offset];
-                const y = yCol[offset];
-                const z = zCol[offset];
-                if (x < minX) {
-                    minX = x;
-                }
-                if (y < minY) {
-                    minY = y;
-                }
-                if (z < minZ) {
-                    minZ = z;
-                }
-                if (x > maxX) {
-                    maxX = x;
-                }
-                if (y > maxY) {
-                    maxY = y;
-                }
-                if (z > maxZ) {
-                    maxZ = z;
-                }
-            }
-            const subChuckSize = Math.ceil(Math.cbrt(size));
-            const scaleX = subChuckSize / Math.max(maxX - minX, 1e-9);
-            const scaleY = subChuckSize / Math.max(maxY - minY, 1e-9);
-            const scaleZ = subChuckSize / Math.max(maxZ - minZ, 1e-9);
-            const subChunkMap = new Map();
-            for (let j = 0; j < chunk.length; j++) {
-                const idx = chunk[j];
-                const x = ((xCol[idx] - minX) * scaleX) | 0;
-                const y = ((yCol[idx] - minY) * scaleY) | 0;
-                const z = ((zCol[idx] - minZ) * scaleZ) | 0;
-                const key = `${x},${y},${z}`;
-                let arr = subChunkMap.get(key);
-                if (!arr) {
-                    arr = [];
-                    subChunkMap.set(key, arr);
-                }
-                arr.push(idx);
-            }
-            const subChunks = Array.from(subChunkMap.values());
-            if (subChunks.length > size) {
-                subChunks.sort((a, b) => b.length - a.length);
-                subChunks.length = size;
-            }
-            for (let j = 0; j < subChunks.length; j++) {
-                mergeChucks.push(subChunks[j]);
-            }
-        }
-        if (mergeChucks.length > target) {
-            mergeChucks.sort((a, b) => b.length - a.length);
-            mergeChucks.length = target;
-        }
-        const raw = new SplatData().init(mergeChucks.length, 0);
-        const result = {
-            x: 0, y: 0, z: 0,
-            sx: 0.005, sy: 0.005, sz: 0.005,
-            qx: 0, qy: 0, qz: 0, qw: 1,
-            r: 0, g: 0, b: 0, a: 0,
-            shN: [],
-        };
-        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: [],
-        };
-        for (let i = 0; i < mergeChucks.length; i++) {
-            const chunk = mergeChucks[i];
-            for (let j = 0; j < chunk.length; j++) {
-                splat.get(chunk[j], single);
-                result.x += single.x;
-                result.y += single.y;
-                result.z += single.z;
-                result.r += single.r;
-                result.g += single.g;
-                result.b += single.b;
-                result.a += single.a;
-            }
-            result.x /= chunk.length;
-            result.y /= chunk.length;
-            result.z /= chunk.length;
-            result.r /= chunk.length;
-            result.g /= chunk.length;
-            result.b /= chunk.length;
-            result.a /= chunk.length;
-            raw.set(i, result);
-            result.x = result.y = result.z = result.r = result.g = result.b = result.a = 0;
-        }
-        resources.set(output, raw);
-        logger.info(`stored -> key="${output}"`);
-    }
-}
+import { ColIdx, SplatData } from '../SplatData.js';
+import { BaseTask } from './BaseTask.js';
+const VOXEL_CHUNK_SIZE = 0.02;
+const VOXEL_CHUNK_SCALE = 1.3;
+export class SkeletonLodTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, counts = 85000, ratio = 0.1 } = config;
+        const splat = resources.get(input);
+        logger.info(`loaded -> "${input}"`);
+        const target = Math.min(Math.ceil(splat.counts * ratio), counts);
+        logger.info(`expected -> ${target}(${((target / splat.counts) * 100).toFixed(2)}%) | ratio=${ratio} counts=${counts}`);
+        const xCol = splat.table[ColIdx.x];
+        const yCol = splat.table[ColIdx.y];
+        const zCol = splat.table[ColIdx.z];
+        let minX = Infinity;
+        let minY = Infinity;
+        let minZ = Infinity;
+        for (let i = 0; i < splat.counts; i++) {
+            const x = xCol[i];
+            const y = yCol[i];
+            const z = zCol[i];
+            if (x < minX) {
+                minX = x;
+            }
+            if (y < minY) {
+                minY = y;
+            }
+            if (z < minZ) {
+                minZ = z;
+            }
+        }
+        const chunkMap = new Map();
+        for (let i = 0; i < splat.counts; i++) {
+            const x = ((xCol[i] - minX) / VOXEL_CHUNK_SIZE) | 0;
+            const y = ((yCol[i] - minY) / VOXEL_CHUNK_SIZE) | 0;
+            const z = ((zCol[i] - minZ) / VOXEL_CHUNK_SIZE) | 0;
+            const key = `${x},${y},${z}`;
+            let arr = chunkMap.get(key);
+            if (!arr) {
+                arr = [];
+                chunkMap.set(key, arr);
+            }
+            arr.push(i);
+        }
+        const chunks = Array.from(chunkMap.values());
+        const CHUNK_RATIO = chunks.reduce((p, c) => p + c.length ** VOXEL_CHUNK_SCALE, 0) / (target * 0.1);
+        const mergeChucks = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const size = Math.max(1, Math.ceil(chunk.length ** VOXEL_CHUNK_SCALE / CHUNK_RATIO));
+            if (size === 1) {
+                mergeChucks.push(chunk);
+                continue;
+            }
+            let minX = Infinity;
+            let minY = Infinity;
+            let minZ = Infinity;
+            let maxX = -Infinity;
+            let maxY = -Infinity;
+            let maxZ = -Infinity;
+            for (let j = 0; j < chunk.length; j++) {
+                const offset = chunk[j];
+                const x = xCol[offset];
+                const y = yCol[offset];
+                const z = zCol[offset];
+                if (x < minX) {
+                    minX = x;
+                }
+                if (y < minY) {
+                    minY = y;
+                }
+                if (z < minZ) {
+                    minZ = z;
+                }
+                if (x > maxX) {
+                    maxX = x;
+                }
+                if (y > maxY) {
+                    maxY = y;
+                }
+                if (z > maxZ) {
+                    maxZ = z;
+                }
+            }
+            const subChuckSize = Math.ceil(Math.cbrt(size));
+            const scaleX = subChuckSize / Math.max(maxX - minX, 1e-9);
+            const scaleY = subChuckSize / Math.max(maxY - minY, 1e-9);
+            const scaleZ = subChuckSize / Math.max(maxZ - minZ, 1e-9);
+            const subChunkMap = new Map();
+            for (let j = 0; j < chunk.length; j++) {
+                const idx = chunk[j];
+                const x = ((xCol[idx] - minX) * scaleX) | 0;
+                const y = ((yCol[idx] - minY) * scaleY) | 0;
+                const z = ((zCol[idx] - minZ) * scaleZ) | 0;
+                const key = `${x},${y},${z}`;
+                let arr = subChunkMap.get(key);
+                if (!arr) {
+                    arr = [];
+                    subChunkMap.set(key, arr);
+                }
+                arr.push(idx);
+            }
+            const subChunks = Array.from(subChunkMap.values());
+            if (subChunks.length > size) {
+                subChunks.sort((a, b) => b.length - a.length);
+                subChunks.length = size;
+            }
+            for (let j = 0; j < subChunks.length; j++) {
+                mergeChucks.push(subChunks[j]);
+            }
+        }
+        if (mergeChucks.length > target) {
+            mergeChucks.sort((a, b) => b.length - a.length);
+            mergeChucks.length = target;
+        }
+        const raw = new SplatData().init(mergeChucks.length, 0);
+        const result = {
+            x: 0,
+            y: 0,
+            z: 0,
+            sx: 0.005,
+            sy: 0.005,
+            sz: 0.005,
+            qx: 0,
+            qy: 0,
+            qz: 0,
+            qw: 1,
+            r: 0,
+            g: 0,
+            b: 0,
+            a: 0,
+            shN: [],
+        };
+        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: [],
+        };
+        for (let i = 0; i < mergeChucks.length; i++) {
+            const chunk = mergeChucks[i];
+            for (let j = 0; j < chunk.length; j++) {
+                splat.get(chunk[j], single);
+                result.x += single.x;
+                result.y += single.y;
+                result.z += single.z;
+                result.r += single.r;
+                result.g += single.g;
+                result.b += single.b;
+                result.a += single.a;
+            }
+            result.x /= chunk.length;
+            result.y /= chunk.length;
+            result.z /= chunk.length;
+            result.r /= chunk.length;
+            result.g /= chunk.length;
+            result.b /= chunk.length;
+            result.a /= chunk.length;
+            raw.set(i, result);
+            result.x = result.y = result.z = result.r = result.g = result.b = result.a = 0;
+        }
+        resources.set(output, raw);
+        logger.info(`stored -> key="${output}"`);
+    }
+}

package/dist/tasks/VoxelTask.d.ts

@@ -1,30 +1,35 @@
-import { Context, BaseTask } from './BaseTask.js';
-export interface VoxelTaskConfig {
-    input: string;
-    output: string;
-    voxelResolution?: number;
-    opacityCutoff?: number;
-    backend?: 'cpu' | 'gpu';
-    collisionMesh?: boolean | 'smooth' | 'faces';
-    navExteriorRadius?: number;
-    floorFill?: boolean;
-    floorFillDilation?: number;
-    cpuWorkerCount?: number;
-    box?: {
-        minCorner: [number, number, number];
-        maxCorner: [number, number, number];
-    };
-    navCapsule?: {
-        height: number;
-        radius: number;
-    };
-    navSeed?: {
-        x: number;
-        y: number;
-        z: number;
-    };
-}
-export declare class VoxelTask extends BaseTask<VoxelTaskConfig> {
-    exec(config: VoxelTaskConfig, { logger, resources }: Context): Promise<void>;
-    requiresGPU(_config: VoxelTaskConfig): boolean;
-}
+import type { FilterClusterOptions } from '../utils/voxel/filter-cluster.js';
+import type { VoxelNodeEncoding } from '../utils/voxel/binary.js';
+import { type Context, BaseTask } from './BaseTask.js';
+export interface VoxelTaskConfig {
+    input: string;
+    output: string;
+    voxelResolution?: number;
+    opacityCutoff?: number;
+    backend?: 'cpu' | 'gpu';
+    collisionMesh?: boolean | 'smooth' | 'faces';
+    navExteriorRadius?: number;
+    floorFill?: boolean;
+    floorFillDilation?: number;
+    cpuWorkerCount?: number;
+    box?: {
+        minCorner: [number, number, number];
+        maxCorner: [number, number, number];
+    };
+    navCapsule?: {
+        height: number;
+        radius: number;
+    };
+    navSeed?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    gzip?: boolean;
+    nodeEncoding?: VoxelNodeEncoding;
+    filterCluster?: boolean | FilterClusterOptions;
+}
+export declare class VoxelTask extends BaseTask<VoxelTaskConfig> {
+    exec(config: VoxelTaskConfig, { logger, resources }: Context): Promise<void>;
+    requiresGPU(_config: VoxelTaskConfig): boolean;
+}

package/dist/tasks/VoxelTask.js

@@ -1,37 +1,40 @@
-import { SplatData } from '../SplatData.js';
-import { writeVoxelFiles } from '../file/voxel.js';
-import { BaseTask } from './BaseTask.js';
-export class VoxelTask extends BaseTask {
-    async exec(config, { logger, resources }) {
-        const { input, output, voxelResolution = 0.05, opacityCutoff = 0.1, backend = 'gpu', collisionMesh = false, navExteriorRadius, floorFill = false, floorFillDilation = 0, cpuWorkerCount = -1, box = { minCorner: [-100, -100, -100], maxCorner: [100, 100, 100] }, navCapsule, navSeed } = config;
-        const source = resources.get(input);
-        if (!(source instanceof SplatData)) {
-            throw new Error(`VoxelTask: resource "${input}" must be SplatData`);
-        }
-        const options = {
-            voxelResolution,
-            opacityCutoff,
-            backend,
-            collisionMesh,
-            floorFill,
-            floorFillDilation,
-            cpuWorkerCount,
-            box
-        };
-        if (navExteriorRadius !== undefined) {
-            options.navExteriorRadius = navExteriorRadius;
-        }
-        if (navCapsule !== undefined) {
-            options.navCapsule = navCapsule;
-        }
-        if (navSeed !== undefined) {
-            options.navSeed = navSeed;
-        }
-        logger.info(`writing voxel -> dir="${output}" count=${source.counts} SH=${source.shDegree}`);
-        await writeVoxelFiles(output, source, options);
-        logger.info('voxelizing done');
-    }
-    requiresGPU(_config) {
-        return (_config.backend ?? 'gpu') === 'gpu';
-    }
-}
+import { SplatData } from '../SplatData.js';
+import { writeVoxelFiles } from '../file/voxel.js';
+import { BaseTask } from './BaseTask.js';
+export class VoxelTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, voxelResolution = 0.05, opacityCutoff = 0.1, backend = 'gpu', collisionMesh = false, navExteriorRadius, floorFill = false, floorFillDilation = 0, cpuWorkerCount = -1, box = { minCorner: [-100, -100, -100], maxCorner: [100, 100, 100] }, navCapsule, navSeed, gzip = false, nodeEncoding = 'raw', filterCluster = true, } = config;
+        const source = resources.get(input);
+        if (!(source instanceof SplatData)) {
+            throw new Error(`VoxelTask: resource "${input}" must be SplatData`);
+        }
+        const options = {
+            voxelResolution,
+            opacityCutoff,
+            backend,
+            collisionMesh,
+            floorFill,
+            floorFillDilation,
+            cpuWorkerCount,
+            box,
+            gzip,
+            nodeEncoding,
+            filterCluster,
+        };
+        if (navExteriorRadius !== undefined) {
+            options.navExteriorRadius = navExteriorRadius;
+        }
+        if (navCapsule !== undefined) {
+            options.navCapsule = navCapsule;
+        }
+        if (navSeed !== undefined) {
+            options.navSeed = navSeed;
+        }
+        logger.info(`writing voxel -> dir="${output}" count=${source.counts} SH=${source.shDegree}`);
+        await writeVoxelFiles(output, source, options);
+        logger.info('voxelizing done');
+    }
+    requiresGPU(_config) {
+        return (_config.backend ?? 'gpu') === 'gpu';
+    }
+}

package/dist/tasks/WriteTask.d.ts

@@ -1,11 +1,12 @@
-import { Context, BaseTask } from './BaseTask.js';
-export interface Config {
-    input: string;
-    output: string;
-    enableMortonSort?: boolean;
-    compressLevel?: number;
-}
-export declare class WriteTask extends BaseTask<Config> {
-    exec(config: Config, { logger, resources }: Context): Promise<void>;
-    requiresGPU(config: Config): boolean;
-}
+import { type Context, BaseTask } from './BaseTask.js';
+export interface Config {
+    input: string;
+    output: string;
+    enableMortonSort?: boolean;
+    compressLevel?: number;
+    spzVersion?: number;
+}
+export declare class WriteTask extends BaseTask<Config> {
+    exec(config: Config, { logger, resources }: Context): Promise<void>;
+    requiresGPU(config: Config): boolean;
+}

package/dist/tasks/WriteTask.js

@@ -1,70 +1,70 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Writable } from 'node:stream';
-import { SplatData } from '../SplatData.js';
-import { createSplatFile, detectSplatFileType, SplatFileType } from '../utils/index.js';
-import { BaseTask } from './BaseTask.js';
-async function writeSplatFile(filepath, data, enableMortonSort, compressLevel) {
-    let indices;
-    if (!enableMortonSort) {
-        indices = new Uint32Array(data.counts);
-        for (let i = 0; i < data.counts; i++) {
-            indices[i] = i;
-        }
-    }
-    const file = createSplatFile(filepath, undefined, compressLevel);
-    const stream = Writable.toWeb(fs.createWriteStream(filepath));
-    await file.write(stream, data, indices);
-}
-export class WriteTask extends BaseTask {
-    async exec(config, { logger, resources }) {
-        const { input, output, enableMortonSort = true, compressLevel } = config;
-        const source = resources.get(input);
-        if (source instanceof SplatData) {
-            logger.info(`writing splat -> file="${output}" count=${source.counts} SH=${source.shDegree}`);
-            await writeSplatFile(output, source, enableMortonSort, compressLevel);
-            logger.info(`writing done`);
-            return;
-        }
-        if (fs.existsSync(output)) {
-            fs.rmSync(output, { recursive: true });
-            logger.info(`exist dir ${output}, removed`);
-        }
-        fs.mkdirSync(output);
-        logger.info(`writing bundle -> dir="${output}" files=${source.length}`);
-        logger.silent = true;
-        const sogList = [];
-        const promises = [];
-        let idx = 1;
-        const totals = source.length;
-        for (let i = 0; i < source.length; i++) {
-            const { name, content, preserveOrder = false } = source[i];
-            const filepath = path.join(output, name);
-            if (typeof content === 'string') {
-                logger.info(`- ${filepath} (${idx++}/${totals})`, true);
-                fs.writeFileSync(filepath, content);
-                continue;
-            }
-            const type = detectSplatFileType(filepath);
-            if (type === SplatFileType.SOG) {
-                sogList.push({ name, content: content });
-                continue;
-            }
-            logger.info(`- ${filepath} (${idx++}/${totals})`, true);
-            const promise = writeSplatFile(filepath, content, enableMortonSort && !preserveOrder, compressLevel);
-            promises.push(promise);
-        }
-        await Promise.all(promises);
-        for (let i = 0; i < sogList.length; i++) {
-            const { name, content } = sogList[i];
-            const filepath = path.join(output, name);
-            logger.info(`- ${filepath} (${idx++}/${totals})`, true);
-            await writeSplatFile(filepath, content, false);
-        }
-        logger.silent = false;
-        logger.info(`writing bundle done -> dir="${output}" files=${source.length}`);
-    }
-    requiresGPU(config) {
-        return config.output.endsWith('sog');
-    }
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { Writable } from 'node:stream';
+import { SplatData } from '../SplatData.js';
+import { createSplatFile, detectSplatFileType, SplatFileType } from '../utils/index.js';
+import { BaseTask } from './BaseTask.js';
+async function writeSplatFile(filepath, data, enableMortonSort, compressLevel, spzVersion) {
+    let indices;
+    if (!enableMortonSort) {
+        indices = new Uint32Array(data.counts);
+        for (let i = 0; i < data.counts; i++) {
+            indices[i] = i;
+        }
+    }
+    const file = createSplatFile(filepath, undefined, compressLevel, spzVersion);
+    const stream = Writable.toWeb(fs.createWriteStream(filepath));
+    await file.write(stream, data, indices);
+}
+export class WriteTask extends BaseTask {
+    async exec(config, { logger, resources }) {
+        const { input, output, enableMortonSort = true, compressLevel, spzVersion } = config;
+        const source = resources.get(input);
+        if (source instanceof SplatData) {
+            logger.info(`writing splat -> file="${output}" count=${source.counts} SH=${source.shDegree}`);
+            await writeSplatFile(output, source, enableMortonSort, compressLevel, spzVersion);
+            logger.info(`writing done`);
+            return;
+        }
+        if (fs.existsSync(output)) {
+            fs.rmSync(output, { recursive: true });
+            logger.info(`exist dir ${output}, removed`);
+        }
+        fs.mkdirSync(output, { recursive: true });
+        logger.info(`writing bundle -> dir="${output}" files=${source.length}`);
+        logger.silent = true;
+        const sogList = [];
+        const promises = [];
+        let idx = 1;
+        const totals = source.length;
+        for (let i = 0; i < source.length; i++) {
+            const { name, content, preserveOrder = false } = source[i];
+            const filepath = path.join(output, name);
+            if (typeof content === 'string') {
+                logger.info(`- ${filepath} (${idx++}/${totals})`, true);
+                fs.writeFileSync(filepath, content);
+                continue;
+            }
+            const type = detectSplatFileType(filepath);
+            if (type === SplatFileType.SOG) {
+                sogList.push({ name, content: content });
+                continue;
+            }
+            logger.info(`- ${filepath} (${idx++}/${totals})`, true);
+            const promise = writeSplatFile(filepath, content, enableMortonSort && !preserveOrder, compressLevel, spzVersion);
+            promises.push(promise);
+        }
+        await Promise.all(promises);
+        for (let i = 0; i < sogList.length; i++) {
+            const { name, content } = sogList[i];
+            const filepath = path.join(output, name);
+            logger.info(`- ${filepath} (${idx++}/${totals})`, true);
+            await writeSplatFile(filepath, content, false);
+        }
+        logger.silent = false;
+        logger.info(`writing bundle done -> dir="${output}" files=${source.length}`);
+    }
+    requiresGPU(config) {
+        return config.output.endsWith('sog');
+    }
+}