@manycore/aholo-splat-transform 1.2.6

package/dist/tasks/WriteTask.d.ts

@@ -0,0 +1,11 @@
+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;
+}

package/dist/tasks/WriteTask.js

@@ -0,0 +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');
+    }
+}

package/dist/utils/BufferReader.d.ts

@@ -0,0 +1,12 @@
+export declare class BufferReader {
+    head: number;
+    tail: number;
+    buffer: Uint8Array;
+    view: DataView;
+    get remaining(): number;
+    constructor(buffer?: Uint8Array);
+    private grow;
+    private compact;
+    write(chunk: Uint8Array): void;
+    read(counts: number): Uint8Array;
+}

package/dist/utils/BufferReader.js

@@ -0,0 +1,47 @@
+export class BufferReader {
+    head = 0;
+    tail = 0;
+    buffer;
+    view;
+    get remaining() {
+        return this.tail - this.head;
+    }
+    constructor(buffer = new Uint8Array()) {
+        this.buffer = buffer;
+        this.view = new DataView(this.buffer.buffer);
+    }
+    grow(required) {
+        const newCap = Math.max(required, this.buffer.length * 2);
+        const next = new Uint8Array(newCap);
+        next.set(this.buffer.subarray(this.head, this.tail), 0);
+        this.tail -= this.head;
+        this.head = 0;
+        this.buffer = next;
+        this.view = new DataView(next.buffer);
+    }
+    compact() {
+        if (this.head === 0) {
+            return;
+        }
+        this.buffer.copyWithin(0, this.head, this.tail);
+        this.tail -= this.head;
+        this.head = 0;
+    }
+    write(chunk) {
+        const remaining = this.tail - this.head;
+        const required = remaining + chunk.length;
+        if (this.buffer.length < required) {
+            this.grow(required);
+        }
+        else if (this.head > 0 && this.buffer.length - this.tail < chunk.length) {
+            this.compact();
+        }
+        this.buffer.set(chunk, this.tail);
+        this.tail += chunk.length;
+    }
+    read(counts) {
+        const head = this.head;
+        const tail = this.head = head + counts;
+        return this.buffer.subarray(head, tail);
+    }
+}

package/dist/utils/Logger.d.ts

@@ -0,0 +1,11 @@
+export declare class Logger {
+    prefix: string;
+    silent: boolean;
+    private format;
+    info(msg: string, force?: boolean): void;
+    warn(msg: string, force?: boolean): void;
+    error(msg: string, force?: boolean): void;
+    time(label: string): void;
+    timeEnd(label: string): void;
+}
+export declare const logger: Logger;

package/dist/utils/Logger.js

@@ -0,0 +1,38 @@
+export class Logger {
+    prefix = '';
+    silent = false;
+    format(msg) {
+        return this.prefix ? `${this.prefix} ${msg}` : msg;
+    }
+    info(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.log(this.format(msg));
+    }
+    warn(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.warn(this.format(msg));
+    }
+    error(msg, force = false) {
+        if (this.silent && !force) {
+            return;
+        }
+        console.error(this.format(msg));
+    }
+    time(label) {
+        if (this.silent) {
+            return;
+        }
+        console.time(this.format(label));
+    }
+    timeEnd(label) {
+        if (this.silent) {
+            return;
+        }
+        console.timeEnd(this.format(label));
+    }
+}
+export const logger = new Logger();

package/dist/utils/StreamChunkDecoder.d.ts

@@ -0,0 +1,16 @@
+import { BufferReader } from './BufferReader.js';
+export interface ChunkDecoder {
+    init(): [number, number];
+    decode(offset: number, counts: number, buffer: Uint8Array): void;
+}
+export declare class StreamChunkDecoder {
+    private reader;
+    private decoders;
+    private decodedTotals;
+    private currentIndex;
+    private currentTotals;
+    private currentItemSize;
+    constructor(reader: BufferReader);
+    setDecoders(decoders: ChunkDecoder[]): void;
+    flush(): void;
+}

package/dist/utils/StreamChunkDecoder.js

@@ -0,0 +1,36 @@
+export class StreamChunkDecoder {
+    reader;
+    decoders;
+    decodedTotals;
+    currentIndex = 0;
+    currentTotals;
+    currentItemSize;
+    constructor(reader) {
+        this.reader = reader;
+    }
+    setDecoders(decoders) {
+        this.decoders = decoders;
+        this.decodedTotals = new Uint32Array(decoders.length);
+        const [totals, itemSize] = decoders[this.currentIndex].init();
+        this.currentTotals = totals;
+        this.currentItemSize = itemSize;
+    }
+    flush() {
+        const { reader, decoders, decodedTotals, currentIndex, currentTotals, currentItemSize } = this;
+        const stage = decoders[currentIndex];
+        const decoded = decodedTotals[currentIndex];
+        const counts = Math.min(currentTotals - decoded, (reader.remaining / currentItemSize) | 0);
+        const buf = reader.read(counts * currentItemSize);
+        stage.decode(decoded, counts, buf);
+        decodedTotals[currentIndex] += counts;
+        if (decodedTotals[currentIndex] === currentTotals) {
+            this.currentIndex++;
+            if (this.currentIndex < decoders.length) {
+                const [totals, itemSize] = decoders[this.currentIndex].init();
+                this.currentTotals = totals;
+                this.currentItemSize = itemSize;
+                this.flush();
+            }
+        }
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,27 @@
+interface Deferred<T = void> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: any) => void;
+    promise: Promise<T>;
+}
+export declare function deferred<T = void>(): Deferred<T>;
+export declare function sleep(timeout: number): Promise<void>;
+export declare function clamp(v: number, min: number, max: number): number;
+export declare function isUrl(str: string): boolean;
+export declare function extractFromRootDir(entries: Record<string, Uint8Array>): Record<string, Uint8Array>;
+export declare function fromHalf(h: number): number;
+export * from './Logger.js';
+export * from './BufferReader.js';
+export * from './StreamChunkDecoder.js';
+export * from './math.js';
+export * from './sh-rotate.js';
+export * from './splat.js';
+export * from './k-means.js';
+export * from './quantize-1d.js';
+export * from './webgpu.js';
+export * from './voxel/common.js';
+export * from './voxel/voxelize.js';
+export * from './voxel/postprocess.js';
+export * from './voxel/nav.js';
+export * from './voxel/mesh.js';
+export * from './voxel/voxel-faces.js';
+export * from './voxel/gpu-dilation.js';

package/dist/utils/index.js

@@ -0,0 +1,101 @@
+export function deferred() {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise(function (resolveInner, rejectInner) {
+        resolve = resolveInner;
+        reject = rejectInner;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+export function sleep(timeout) {
+    return new Promise(resolve => {
+        setTimeout(resolve, timeout);
+    });
+}
+export function clamp(v, min, max) {
+    return Math.min(Math.max(v, min), max);
+}
+export function isUrl(str) {
+    let url;
+    try {
+        url = new URL(str);
+    }
+    catch {
+        return false;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}
+export function extractFromRootDir(entries) {
+    let dir = '';
+    for (const path in entries) {
+        if (path.endsWith('/')) {
+            dir = path;
+            break;
+        }
+    }
+    const result = {};
+    for (const path in entries) {
+        result[path.replace(dir, '')] = entries[path];
+    }
+    return result;
+}
+const f32buffer = new Float32Array(1);
+const u32buffer = new Uint32Array(f32buffer.buffer);
+export function fromHalf(h) {
+    const sign = (h >> 15) & 0x1;
+    const exp = (h >> 10) & 0x1f;
+    const frac = h & 0x3ff;
+    let f32bits;
+    if (exp === 0) {
+        if (frac === 0) {
+            f32bits = sign << 31;
+        }
+        else {
+            let mant = frac;
+            let e = -14;
+            while ((mant & 0x400) === 0) {
+                mant <<= 1;
+                e--;
+            }
+            mant &= 0x3ff;
+            const newExp = e + 127;
+            const newFrac = mant << 13;
+            f32bits = (sign << 31) | (newExp << 23) | newFrac;
+        }
+    }
+    else if (exp === 0x1f) {
+        if (frac === 0) {
+            f32bits = (sign << 31) | 0x7f800000;
+        }
+        else {
+            f32bits = (sign << 31) | 0x7fc00000;
+        }
+    }
+    else {
+        const newExp = exp - 15 + 127;
+        const newFrac = frac << 13;
+        f32bits = (sign << 31) | (newExp << 23) | newFrac;
+    }
+    u32buffer[0] = f32bits;
+    return f32buffer[0];
+}
+export * from './Logger.js';
+export * from './BufferReader.js';
+export * from './StreamChunkDecoder.js';
+export * from './math.js';
+export * from './sh-rotate.js';
+export * from './splat.js';
+export * from './k-means.js';
+export * from './quantize-1d.js';
+export * from './webgpu.js';
+export * from './voxel/common.js';
+export * from './voxel/voxelize.js';
+export * from './voxel/postprocess.js';
+export * from './voxel/nav.js';
+export * from './voxel/mesh.js';
+export * from './voxel/voxel-faces.js';
+export * from './voxel/gpu-dilation.js';

package/dist/utils/k-means.d.ts

@@ -0,0 +1,4 @@
+export declare function kmeans(points: Float32Array[], k: number, iterations: number, device: GPUDevice): Promise<{
+    centroids: Float32Array<ArrayBufferLike>[];
+    labels: Uint32Array<ArrayBuffer>;
+}>;