@manycore/aholo-splat-transform 1.2.6

package/CHANGELOG.md

@@ -0,0 +1,102 @@
+# ChangeLOG
+
+## 1.2.6
+
+- 体素化新增 cpu 实现以及部分算法优化
+- 体素化输出格式优化
+
+## 1.2.5
+
+- 修复 SplatData.counts = 0 时构造 lod 异常
+
+## 1.2.4
+
+- 支持生成体素碰撞体
+- avif 编解码支持多任务
+- 使用 glibc 构建 linux 版本
+- 修复小文件生成 lod chunk 失败
+- 优化 logger
+
+## 1.2.3
+
+- 优化内部代码，移除无用实现
+- 修改 chunk-lod 的 forward box 计算逻辑，匹配业务需求
+
+## 1.2.2
+
+- 添加`libavif`
+- 整理文件结构，删除 IData 结构
+- 修复 modify 和 chunk-lod 冲突造成删除失败
+
+## 1.2.1
+
+- 支持`GPU`设备选择
+- write 支持 MortonSort 用以提升压缩率
+
+## 1.2.0
+
+- 重构 cli 命令
+- 底层修改成 pipeline task 支持组合，减少文件保存数量
+- 过程计算采用双精度，移除无效代码
+- 增加`getOrCreateDevice`用于共享 GPU 设备
+- 改进`auto-lod`使其更接近目标值
+- 优化输出
+
+## 1.1.2
+
+- 加入 nanogs 检索算法
+- 增加 --max-chunk-counts 参数
+
+## 1.1.1
+
+- 优化 lod 参数，防止出现长时间执行
+
+## 1.1.0
+
+- 修改 cli 调用参数
+- 优化 lod:auto 时内存无法及时释放导致 oom 的情况
+- 新增 lod:auto-chunk 命令
+- 多级 lod 支持指数步进
+- auto-chunk 优化输出结果
+
+## 1.0.8
+
+- 优化高斯空间分割
+- 优化高斯包围盒，移除偏移过大的数据
+- 修复`webP`有损编码`quality`读取错误的问题
+- 修复 lod 命令异常
+- 优化`cluster_average`并行粒度
+
+## 1.0.7
+
+- 支持 SOG 格式输出
+
+## 1.0.6
+
+- 优化 lod 内置参数
+
+## 1.0.5
+
+- 优化 lod 内置参数
+
+## 1.0.4
+
+- 修复`create`解析`deletedIndicesBitMap`异常
+
+## 1.0.3
+
+- 优化`autoLod`效果和实现
+
+## 1.0.2
+
+- 支持流式解析和写入，减少内存占用
+- 支持`autoLod`对 3dgs 生成 lod 结果
+  - `splat-transform lod --type auto --ratio 0.3 simiao.ply simiao-lod.spz`
+
+## 1.0.1
+
+- 新增`bin.est`防止和`@playcanvas/splat-transform`一起使用时出现冲突
+
+## 1.0.0
+
+- 发包正式包

package/README.md

@@ -0,0 +1,33 @@
+# splat-transform
+
+A 3DGS modifier used by aholo
+
+## Requirement
+
+- node >= 20.19.0
+- system
+  - windows: windows 22H2+, D3D12 or Vulkan compatible GPU(When use GPU features, dedicated GPU for better performance)
+  - linux: glibc >=2.34, libstdc++ >= 3.4.30, Vulkan compatible GPU(When use GPU features, dedicated GPU for better performance)
+  - osx: Not Supported
+
+## Usage
+
+```bash
+splat-transform --help
+
+Execute a task pipeline from configuration file
+
+Arguments:
+  path                                       pipeline config filepath
+
+Options:
+  -V, --version                              output the version number
+  -h, --help                                 display help for command
+
+Commands:
+  create <input> <output>                    Merge & Transform gaussian splat file
+  lod:loading [options] <input> <output>     Generate loading-lod for gaussian splat file
+  lod:flex [options] <input> <output>        Generate flex-lod for gaussian splat file
+  lod:auto [options] <input> <output>        Generate auto-lod for gaussian splat file
+  lod:auto-chunk [options] <input> <output>  Generate auto-chunk-lod for gaussian splat file
+```

package/bin/cli.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { program } from 'commander';
+import packageJson from '../package.json' with { type: 'json' };
+import { runner } from '../dist/index.js';
+
+const ExtraText = `
+Transform Gaussian splats file
+===================================
+SUPPORTED INPUTS
+    .ply   .compressed.ply   .sog   meta.json   .ksplat   .splat   .spz   .lcc
+
+SUPPORTED OUTPUTS
+    .ply   .spz   .uspz   .splat   .sog
+`;
+
+program
+    .name(packageJson.name)
+    .version(packageJson.version)
+    .addHelpText('beforeAll', ExtraText);
+
+program
+    .description('Execute a task pipeline from configuration file')
+    .argument('<path>', 'pipeline config filepath')
+    .action((path) => {
+        const content = fs.readFileSync(path, { encoding: 'utf-8' });
+        runner(JSON.parse(content));
+    });
+
+program
+    .command('create')
+    .description('Merge & Transform gaussian splat file')
+    .argument('<input>', 'input filepath')
+    .argument('<output>', 'output filepath')
+    .action((input, output) => {
+        runner({
+            version: 1,
+            tasks: [
+                { id: '0', type: 'Read', config: { inputs: [input], output: 'cache0' } },
+                { id: '1', type: 'Modify', config: { input: 'cache0', output: 'cache0' } },
+                { id: '2', type: 'Write', config: { input: 'cache0', output: output } },
+            ],
+        });
+    });
+
+program
+    .command('lod:loading')
+    .description('Generate loading-lod for gaussian splat file')
+    .option('--ratio <number>')
+    .argument('<input>', 'input filepath')
+    .argument('<output>', 'output filepath')
+    .action(async (input, output, arg) => {
+        runner({
+            version: 1,
+            tasks: [
+                { id: '0', type: 'Read', config: { inputs: [input], output: 'cache0' } },
+                { id: '1', type: 'SkeletonLod', config: { input: 'cache0', output: 'cache0', ratio: arg.ratio } },
+                { id: '2', type: 'Write', config: { input: 'cache0', output: output } },
+            ],
+        });
+    });
+
+program
+    .command('lod:flex')
+    .description('Generate flex-lod for gaussian splat file')
+    .requiredOption('--score <string>')
+    .option('--ratio <number>')
+    .argument('<input>', 'input filepath')
+    .argument('<output>', 'output filepath')
+    .action(async (input, output, arg) => {
+        runner({
+            version: 1,
+            tasks: [
+                { id: '0', type: 'Read', config: { inputs: [input], output: 'cache0' } },
+                { id: '1', type: 'FlexLod', config: { input: 'cache0', output: 'cache0', ratio: arg.ratio, scorePath: arg.score } },
+                { id: '2', type: 'Write', config: { input: 'cache0', output: output } },
+            ],
+        });
+    });
+
+program
+    .command('lod:auto')
+    .description('Generate auto-lod for gaussian splat file')
+    .option('--ratio <number>')
+    .argument('<input>', 'input filepath')
+    .argument('<output>', 'output filepath')
+    .action(async (input, output, arg) => {
+        runner({
+            version: 1,
+            tasks: [
+                { id: '0', type: 'Read', config: { inputs: [input], output: 'cache0' } },
+                { id: '1', type: 'AutoLod', config: { input: 'cache0', output: 'cache0', ratio: arg.ratio } },
+                { id: '2', type: 'Write', config: { input: 'cache0', output: output } },
+            ],
+        });
+    });
+
+const fileTypeOption = program.createOption('-t, --type <type>', 'output file type').choices(['ply', 'spz', 'splat', 'sog']);
+fileTypeOption.required = true;
+program
+    .command('lod:auto-chunk')
+    .description('Generate auto-chunk-lod for gaussian splat file')
+    .addOption(fileTypeOption)
+    .option('--max-chunk-counts <number>')
+    .argument('<input>', 'input filepath')
+    .argument('<output>', 'output directory')
+    .action(async (input, output, arg) => {
+        runner({
+            version: 1,
+            tasks: [
+                { id: '0', type: 'Read', config: { inputs: [input], output: 'cache0' } },
+                { id: '1', type: 'AutoChunkLod', config: { input: 'cache0', output: 'cache0', type: arg.type, maxChunkCounts: arg.maxChunkCounts } },
+                { id: '2', type: 'Write', config: { input: 'cache0', output: output } },
+            ],
+        });
+    });
+
+program.parse();

package/dist/SplatData.d.ts

@@ -0,0 +1,67 @@
+export interface ISingleSplat {
+    x: number;
+    y: number;
+    z: number;
+    sx: number;
+    sy: number;
+    sz: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    shN: number[];
+}
+export declare const enum ColIdx {
+    x = 0,
+    y = 1,
+    z = 2,
+    sx = 3,
+    sy = 4,
+    sz = 5,
+    qx = 6,
+    qy = 7,
+    qz = 8,
+    qw = 9,
+    r = 10,
+    g = 11,
+    b = 12,
+    a = 13,
+    shOffset = 14
+}
+export declare class SplatData {
+    counts: number;
+    shDegree: number;
+    shCounts: number;
+    maxShDegree: number;
+    table: Float32Array[];
+    constructor(blockCounts?: number, maxShDegree?: number);
+    blockOffsets: number[];
+    blockContentCounts: number[];
+    private blockCounts;
+    private totalBlockCounts;
+    private totalBlockShDegree;
+    private blockExecs;
+    private currentBlockIndex;
+    initBlock(counts: number, shDegree: number): Promise<number>;
+    finishBlock(): void;
+    init(counts: number, shDegree: number): this;
+    set(i: number, single: ISingleSplat): void;
+    setCenter(i: number, x: number, y: number, z: number): void;
+    setScale(i: number, sx: number, sy: number, sz: number): void;
+    setQuat(i: number, qx: number, qy: number, qz: number, qw: number): void;
+    setColor(i: number, r: number, g: number, b: number): void;
+    setAlpha(i: number, a: number): void;
+    setShN(i: number, shN: number[]): void;
+    get(i: number, single: ISingleSplat): void;
+    getCenter(i: number, single: ISingleSplat): void;
+    getScale(i: number, single: ISingleSplat): void;
+    getQuat(i: number, single: ISingleSplat): void;
+    getColor(i: number, single: ISingleSplat): void;
+    getAlpha(i: number, single: ISingleSplat): void;
+    getShN(i: number, shN: number[]): void;
+    destroy(): void;
+}

package/dist/SplatData.js

@@ -0,0 +1,156 @@
+import { Quaternion, deferred } from './utils/index.js';
+import { SH_MAPS } from './constant.js';
+const tempQuat = new Quaternion(0, 0, 0, 1);
+export class SplatData {
+    counts;
+    shDegree;
+    shCounts;
+    maxShDegree;
+    table;
+    constructor(blockCounts = 1, maxShDegree = 3) {
+        this.blockCounts = blockCounts;
+        this.maxShDegree = maxShDegree;
+    }
+    blockOffsets = [];
+    blockContentCounts = [];
+    blockCounts;
+    totalBlockCounts = 0;
+    totalBlockShDegree = 3;
+    blockExecs = [];
+    currentBlockIndex = 0;
+    initBlock(counts, shDegree) {
+        this.blockContentCounts.push(counts);
+        this.blockOffsets.push(this.totalBlockCounts);
+        this.totalBlockCounts += counts;
+        this.totalBlockShDegree = Math.min(shDegree, this.totalBlockShDegree);
+        const { promise, resolve } = deferred();
+        this.blockExecs.push(resolve);
+        if (this.blockOffsets.length === this.blockCounts) {
+            this.init(this.totalBlockCounts, this.totalBlockShDegree);
+            this.blockExecs[this.currentBlockIndex](this.blockOffsets[0]);
+        }
+        return promise;
+    }
+    finishBlock() {
+        this.currentBlockIndex++;
+        this.blockExecs[this.currentBlockIndex]?.(this.blockOffsets[this.currentBlockIndex]);
+    }
+    init(counts, shDegree) {
+        this.counts = counts;
+        this.shDegree = Math.min(shDegree, this.maxShDegree);
+        const shCounts = this.shCounts = SH_MAPS[this.shDegree];
+        this.table = new Array(14 + shCounts).fill(0).map(() => new Float32Array(counts));
+        return this;
+    }
+    set(i, single) {
+        const { table } = this;
+        table[0 /* ColIdx.x */][i] = single.x;
+        table[1 /* ColIdx.y */][i] = single.y;
+        table[2 /* ColIdx.z */][i] = single.z;
+        table[3 /* ColIdx.sx */][i] = single.sx;
+        table[4 /* ColIdx.sy */][i] = single.sy;
+        table[5 /* ColIdx.sz */][i] = single.sz;
+        tempQuat.set(single.qx, single.qy, single.qz, single.qw).normalize();
+        table[6 /* ColIdx.qx */][i] = tempQuat.x;
+        table[7 /* ColIdx.qy */][i] = tempQuat.y;
+        table[8 /* ColIdx.qz */][i] = tempQuat.z;
+        table[9 /* ColIdx.qw */][i] = tempQuat.w;
+        table[10 /* ColIdx.r */][i] = single.r;
+        table[11 /* ColIdx.g */][i] = single.g;
+        table[12 /* ColIdx.b */][i] = single.b;
+        table[13 /* ColIdx.a */][i] = single.a;
+    }
+    setCenter(i, x, y, z) {
+        const { table } = this;
+        table[0 /* ColIdx.x */][i] = x;
+        table[1 /* ColIdx.y */][i] = y;
+        table[2 /* ColIdx.z */][i] = z;
+    }
+    setScale(i, sx, sy, sz) {
+        const { table } = this;
+        table[3 /* ColIdx.sx */][i] = sx;
+        table[4 /* ColIdx.sy */][i] = sy;
+        table[5 /* ColIdx.sz */][i] = sz;
+    }
+    setQuat(i, qx, qy, qz, qw) {
+        const { table } = this;
+        tempQuat.set(qx, qy, qz, qw).normalize();
+        table[6 /* ColIdx.qx */][i] = tempQuat.x;
+        table[7 /* ColIdx.qy */][i] = tempQuat.y;
+        table[8 /* ColIdx.qz */][i] = tempQuat.z;
+        table[9 /* ColIdx.qw */][i] = tempQuat.w;
+    }
+    setColor(i, r, g, b) {
+        const { table } = this;
+        table[10 /* ColIdx.r */][i] = r;
+        table[11 /* ColIdx.g */][i] = g;
+        table[12 /* ColIdx.b */][i] = b;
+    }
+    setAlpha(i, a) {
+        const { table } = this;
+        table[13 /* ColIdx.a */][i] = a;
+    }
+    setShN(i, shN) {
+        const { table, shCounts } = this;
+        for (let j = 0; j < shCounts; j++) {
+            table[14 /* ColIdx.shOffset */ + j][i] = shN[j];
+        }
+    }
+    ;
+    get(i, single) {
+        const { table } = this;
+        single.x = table[0 /* ColIdx.x */][i];
+        single.y = table[1 /* ColIdx.y */][i];
+        single.z = table[2 /* ColIdx.z */][i];
+        single.sx = table[3 /* ColIdx.sx */][i];
+        single.sy = table[4 /* ColIdx.sy */][i];
+        single.sz = table[5 /* ColIdx.sz */][i];
+        single.qx = table[6 /* ColIdx.qx */][i];
+        single.qy = table[7 /* ColIdx.qy */][i];
+        single.qz = table[8 /* ColIdx.qz */][i];
+        single.qw = table[9 /* ColIdx.qw */][i];
+        single.r = table[10 /* ColIdx.r */][i];
+        single.g = table[11 /* ColIdx.g */][i];
+        single.b = table[12 /* ColIdx.b */][i];
+        single.a = table[13 /* ColIdx.a */][i];
+    }
+    getCenter(i, single) {
+        const { table } = this;
+        single.x = table[0 /* ColIdx.x */][i];
+        single.y = table[1 /* ColIdx.y */][i];
+        single.z = table[2 /* ColIdx.z */][i];
+    }
+    getScale(i, single) {
+        const { table } = this;
+        single.sx = table[3 /* ColIdx.sx */][i];
+        single.sy = table[4 /* ColIdx.sy */][i];
+        single.sz = table[5 /* ColIdx.sz */][i];
+    }
+    getQuat(i, single) {
+        const { table } = this;
+        single.qx = table[6 /* ColIdx.qx */][i];
+        single.qy = table[7 /* ColIdx.qy */][i];
+        single.qz = table[8 /* ColIdx.qz */][i];
+        single.qw = table[9 /* ColIdx.qw */][i];
+    }
+    getColor(i, single) {
+        const { table } = this;
+        single.r = table[10 /* ColIdx.r */][i];
+        single.g = table[11 /* ColIdx.g */][i];
+        single.b = table[12 /* ColIdx.b */][i];
+    }
+    getAlpha(i, single) {
+        const { table } = this;
+        single.a = table[13 /* ColIdx.a */][i];
+    }
+    getShN(i, shN) {
+        const { shCounts, table } = this;
+        for (let j = 0; j < shCounts; j++) {
+            shN[j] = table[14 /* ColIdx.shOffset */ + j][i];
+        }
+    }
+    destroy() {
+        this.counts = 0;
+        this.table = [];
+    }
+}

package/dist/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const SH_C0 = 0.28209479177387814;
+export declare const SH_MAPS: Record<number, number>;
+export declare const NUM_F_REST_TO_SH_DEGREE: Record<number, number>;

package/dist/constant.js

@@ -0,0 +1,13 @@
+export const SH_C0 = 0.28209479177387814;
+export const SH_MAPS = {
+    0: 0,
+    1: 9,
+    2: 24,
+    3: 45,
+};
+export const NUM_F_REST_TO_SH_DEGREE = {
+    0: 0,
+    9: 1,
+    24: 2,
+    45: 3,
+};

package/dist/file/IFile.d.ts

@@ -0,0 +1,5 @@
+import { SplatData } from '../SplatData.js';
+export interface IFile {
+    read(stream: ReadableStream<Uint8Array>, contentLength: number, data: SplatData): Promise<void>;
+    write(stream: WritableStream<Uint8Array>, data: SplatData, indices?: Uint32Array): Promise<void>;
+}

package/dist/file/IFile.js

@@ -0,0 +1 @@
+export {};

package/dist/file/index.d.ts

@@ -0,0 +1,7 @@
+export { IFile } from './IFile.js';
+export { KsplatFile } from './ksplat.js';
+export { PlyFile } from './ply.js';
+export { SogFile } from './sog.js';
+export { SplatFile } from './splat.js';
+export { SpzFile } from './spz.js';
+export { LccFile } from './lcc.js';

package/dist/file/index.js

@@ -0,0 +1,6 @@
+export { KsplatFile } from './ksplat.js';
+export { PlyFile } from './ply.js';
+export { SogFile } from './sog.js';
+export { SplatFile } from './splat.js';
+export { SpzFile } from './spz.js';
+export { LccFile } from './lcc.js';

package/dist/file/ksplat.d.ts

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