@manycore/aholo-splat-transform 1.2.6

package/dist/utils/math.js

@@ -0,0 +1,351 @@
+export class Quaternion {
+    x;
+    y;
+    z;
+    w;
+    static ONE = new Quaternion(0, 0, 0, 1);
+    constructor(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    set(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+    equals(q) {
+        return (q.x === this.x) && (q.y === this.y) && (q.z === this.z) && (q.w === this.w);
+    }
+    normalize() {
+        const length = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+        if (length === 0) {
+            return this;
+        }
+        const invLength = (1 / length) * (this.w < 0 ? -1 : 1);
+        this.x *= invLength;
+        this.y *= invLength;
+        this.z *= invLength;
+        this.w *= invLength;
+        return this;
+    }
+    multiply(q) {
+        return this.multiplyQuaternions(this, q);
+    }
+    premultiply(q) {
+        return this.multiplyQuaternions(q, this);
+    }
+    multiplyQuaternions(a, b) {
+        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+        const qax = a.x;
+        const qay = a.y;
+        const qaz = a.z;
+        const qaw = a.w;
+        const qbx = b.x;
+        const qby = b.y;
+        const qbz = b.z;
+        const qbw = b.w;
+        this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+        this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+        this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+        this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+        return this;
+    }
+    setRotationMatrix(m) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+        const te = m.elements;
+        const m11 = te[0];
+        const m12 = te[4];
+        const m13 = te[8];
+        const m21 = te[1];
+        const m22 = te[5];
+        const m23 = te[9];
+        const m31 = te[2];
+        const m32 = te[6];
+        const m33 = te[10];
+        const trace = m11 + m22 + m33;
+        let s;
+        if (trace > 0) {
+            s = 0.5 / Math.sqrt(trace + 1.0);
+            this.w = 0.25 / s;
+            this.x = (m32 - m23) * s;
+            this.y = (m13 - m31) * s;
+            this.z = (m21 - m12) * s;
+        }
+        else if (m11 > m22 && m11 > m33) {
+            s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+            this.w = (m32 - m23) / s;
+            this.x = 0.25 * s;
+            this.y = (m12 + m21) / s;
+            this.z = (m13 + m31) / s;
+        }
+        else if (m22 > m33) {
+            s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+            this.w = (m13 - m31) / s;
+            this.x = (m12 + m21) / s;
+            this.y = 0.25 * s;
+            this.z = (m23 + m32) / s;
+        }
+        else {
+            s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+            this.w = (m21 - m12) / s;
+            this.x = (m13 + m31) / s;
+            this.y = (m23 + m32) / s;
+            this.z = 0.25 * s;
+        }
+        return this;
+    }
+}
+export class Vector3 {
+    x;
+    y;
+    z;
+    static ONE = new Vector3(1, 1, 1);
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    set(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+    equals(v) {
+        return (v.x === this.x) && (v.y === this.y) && (v.z === this.z);
+    }
+    mul(v) {
+        this.x *= v.x;
+        this.y *= v.y;
+        this.z *= v.z;
+        return this;
+    }
+    applyMatrix4(m) {
+        const { x, y, z } = this;
+        const e = m.elements;
+        const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+        this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
+        this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
+        this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
+        return this;
+    }
+    clone() {
+        return new Vector3(this.x, this.y, this.z);
+    }
+}
+export class Matrix4 {
+    static ONE = new Matrix4();
+    elements = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+    constructor(elements, isRow = false) {
+        if (elements) {
+            this.set(elements);
+        }
+        if (isRow) {
+            this.transpose();
+        }
+    }
+    set(elements) {
+        for (let i = 0; i < 16; i++) {
+            this.elements[i] = elements[i];
+        }
+        return this;
+    }
+    equals(matrix) {
+        const te = this.elements;
+        const me = matrix.elements;
+        for (let i = 0; i < 16; i++) {
+            if (te[i] !== me[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    determinant() {
+        const te = this.elements;
+        const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12], n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13], n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14], n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15];
+        // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
+        return (n41 * (+n14 * n23 * n32
+            - n13 * n24 * n32
+            - n14 * n22 * n33
+            + n12 * n24 * n33
+            + n13 * n22 * n34
+            - n12 * n23 * n34) +
+            n42 * (+n11 * n23 * n34
+                - n11 * n24 * n33
+                + n14 * n21 * n33
+                - n13 * n21 * n34
+                + n13 * n24 * n31
+                - n14 * n23 * n31) +
+            n43 * (+n11 * n24 * n32
+                - n11 * n22 * n34
+                - n14 * n21 * n32
+                + n12 * n21 * n34
+                + n14 * n22 * n31
+                - n12 * n24 * n31) +
+            n44 * (-n13 * n22 * n31
+                - n11 * n23 * n32
+                + n11 * n22 * n33
+                + n13 * n21 * n32
+                - n12 * n21 * n33
+                + n12 * n23 * n31));
+    }
+    multiply(m) {
+        return this.multiplyMatrices(this, m);
+    }
+    multiplyMatrices(a, b) {
+        const te = this.elements;
+        const ae = a.elements;
+        const be = b.elements;
+        const a11 = ae[0];
+        const a12 = ae[4];
+        const a13 = ae[8];
+        const a14 = ae[12];
+        const a21 = ae[1];
+        const a22 = ae[5];
+        const a23 = ae[9];
+        const a24 = ae[13];
+        const a31 = ae[2];
+        const a32 = ae[6];
+        const a33 = ae[10];
+        const a34 = ae[14];
+        const a41 = ae[3];
+        const a42 = ae[7];
+        const a43 = ae[11];
+        const a44 = ae[15];
+        const b11 = be[0];
+        const b12 = be[4];
+        const b13 = be[8];
+        const b14 = be[12];
+        const b21 = be[1];
+        const b22 = be[5];
+        const b23 = be[9];
+        const b24 = be[13];
+        const b31 = be[2];
+        const b32 = be[6];
+        const b33 = be[10];
+        const b34 = be[14];
+        const b41 = be[3];
+        const b42 = be[7];
+        const b43 = be[11];
+        const b44 = be[15];
+        te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
+        te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
+        te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
+        te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
+        te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
+        te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
+        te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
+        te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
+        te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
+        te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
+        te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
+        te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
+        te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
+        te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
+        te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
+        te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
+        return this;
+    }
+    compose(position, quaternion, scale) {
+        const te = this.elements;
+        const x = quaternion.x, y = quaternion.y, z = quaternion.z, w = quaternion.w, x2 = x + x, y2 = y + y, z2 = z + z, xx = x * x2, xy = x * y2, xz = x * z2, yy = y * y2, yz = y * z2, zz = z * z2, wx = w * x2, wy = w * y2, wz = w * z2, sx = scale.x, sy = scale.y, sz = scale.z;
+        te[0] = (1 - (yy + zz)) * sx;
+        te[1] = (xy + wz) * sx;
+        te[2] = (xz - wy) * sx;
+        te[3] = 0;
+        te[4] = (xy - wz) * sy;
+        te[5] = (1 - (xx + zz)) * sy;
+        te[6] = (yz + wx) * sy;
+        te[7] = 0;
+        te[8] = (xz + wy) * sz;
+        te[9] = (yz - wx) * sz;
+        te[10] = (1 - (xx + yy)) * sz;
+        te[11] = 0;
+        te[12] = position.x;
+        te[13] = position.y;
+        te[14] = position.z;
+        te[15] = 1;
+        return this;
+    }
+    decompose(position, quaternion, scale) {
+        const te = this.elements;
+        let sx = tmpVec.set(te[0], te[1], te[2]).length();
+        const sy = tmpVec.set(te[4], te[5], te[6]).length();
+        const sz = tmpVec.set(te[8], te[9], te[10]).length();
+        const det = this.determinant();
+        if (det < 0) {
+            sx *= -1;
+        }
+        position.set(te[12], te[13], te[14]);
+        const invSX = 1 / sx;
+        const invSY = 1 / sy;
+        const invSZ = 1 / sz;
+        tmpMat4.set(this.elements);
+        tmpMat4.elements[0] *= invSX;
+        tmpMat4.elements[1] *= invSX;
+        tmpMat4.elements[2] *= invSX;
+        tmpMat4.elements[4] *= invSY;
+        tmpMat4.elements[5] *= invSY;
+        tmpMat4.elements[6] *= invSY;
+        tmpMat4.elements[8] *= invSZ;
+        tmpMat4.elements[9] *= invSZ;
+        tmpMat4.elements[10] *= invSZ;
+        quaternion.setRotationMatrix(tmpMat4);
+        scale.set(sx, sy, sz);
+        return this;
+    }
+    transpose() {
+        const te = this.elements;
+        let tmp;
+        tmp = te[1];
+        te[1] = te[4];
+        te[4] = tmp;
+        tmp = te[2];
+        te[2] = te[8];
+        te[8] = tmp;
+        tmp = te[6];
+        te[6] = te[9];
+        te[9] = tmp;
+        tmp = te[3];
+        te[3] = te[12];
+        te[12] = tmp;
+        tmp = te[7];
+        te[7] = te[13];
+        te[13] = tmp;
+        tmp = te[11];
+        te[11] = te[14];
+        te[14] = tmp;
+        return this;
+    }
+}
+export class Matrix3 {
+    elements = new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+    set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
+        const te = this.elements;
+        te[0] = n11;
+        te[1] = n21;
+        te[2] = n31;
+        te[3] = n12;
+        te[4] = n22;
+        te[5] = n32;
+        te[6] = n13;
+        te[7] = n23;
+        te[8] = n33;
+        return this;
+    }
+    setFromMatrix4(m) {
+        const me = m.elements;
+        this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
+        return this;
+    }
+}
+const tmpVec = new Vector3(0, 0, 0);
+const tmpMat4 = new Matrix4();

package/dist/utils/quantize-1d.d.ts

@@ -0,0 +1,4 @@
+export declare function quantize1d(fields: Float32Array[], k?: number, alpha?: number, transform?: (v: number) => number): {
+    centroids: Float32Array<ArrayBuffer>;
+    labels: Uint8Array<ArrayBuffer>[];
+};

package/dist/utils/quantize-1d.js

@@ -0,0 +1,164 @@
+// https://github.com/playcanvas/splat-transform/blob/main/src/lib/spatial/quantize-1d.ts
+export function quantize1d(fields, k = 256, alpha = 0.5, transform) {
+    const numColumns = fields.length;
+    const numRows = fields.length > 0 ? fields[0].length : 0;
+    // pool all columns into a flat 1D array
+    const N = numRows * numColumns;
+    if (N === 0) {
+        const centroids = new Float32Array(k);
+        const labels = fields.map(_ => new Uint8Array(numRows));
+        return { centroids, labels };
+    }
+    const data = new Float32Array(N);
+    for (let i = 0; i < numColumns; ++i) {
+        data.set(fields[i], i * numRows);
+    }
+    if (transform) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] = transform(data[i]);
+        }
+    }
+    // sort a copy for histogram binning (keep original for label assignment)
+    const sortedData = new Float32Array(data);
+    sortedData.sort();
+    const vMin = sortedData[0];
+    const vMax = sortedData[N - 1];
+    // handle degenerate case where all values are identical
+    if (vMax - vMin < 1e-20) {
+        const centroids = new Float32Array(k);
+        centroids.fill(vMin);
+        const labels = fields.map(_ => new Uint8Array(numRows));
+        return { centroids, labels };
+    }
+    // build histogram using blended uniform/quantile bin positions
+    const H = Math.min(1024, N);
+    const vRange = vMax - vMin;
+    // adaptive blend ratio: when outliers are extreme (IQR << range), lean
+    // strongly toward quantile to give the dense center adequate bins; when
+    // the distribution has moderate tails (IQR ~ range), reduce quantile
+    // bias somewhat, but keep at least 50% quantile to preserve density
+    const iqr = sortedData[Math.floor(N * 0.75)] - sortedData[Math.floor(N * 0.25)];
+    const beta = Math.max(0.5, Math.min(0.999, 1 - iqr / vRange));
+    const counts = new Float64Array(H);
+    const sums = new Float64Array(H);
+    for (let i = 0; i < N; ++i) {
+        const uniformPos = (sortedData[i] - vMin) / vRange;
+        const quantilePos = i / N;
+        const bin = Math.min(H - 1, Math.floor(H * (beta * quantilePos + (1 - beta) * uniformPos)));
+        counts[bin]++;
+        sums[bin] += sortedData[i];
+    }
+    const centers = new Float64Array(H);
+    for (let i = 0; i < H; ++i) {
+        centers[i] = counts[i] > 0 ? sums[i] / counts[i] : vMin + (i + 0.5) / H * vRange;
+    }
+    // compute weights: w = count^alpha (sub-linear density weighting)
+    const weights = new Float64Array(H);
+    for (let i = 0; i < H; ++i) {
+        weights[i] = counts[i] > 0 ? Math.pow(counts[i], alpha) : 0;
+    }
+    // prefix sums for O(1) range cost queries
+    //   cost(a,b) = sum_wxx - sum_wx^2 / sum_w
+    //   centroid(a,b) = sum_wx / sum_w
+    const prefW = new Float64Array(H + 1);
+    const prefWX = new Float64Array(H + 1);
+    const prefWXX = new Float64Array(H + 1);
+    for (let i = 0; i < H; ++i) {
+        prefW[i + 1] = prefW[i] + weights[i];
+        prefWX[i + 1] = prefWX[i] + weights[i] * centers[i];
+        prefWXX[i + 1] = prefWXX[i] + weights[i] * centers[i] * centers[i];
+    }
+    const rangeCost = (a, b) => {
+        const w = prefW[b + 1] - prefW[a];
+        if (w <= 0) {
+            return 0;
+        }
+        const wx = prefWX[b + 1] - prefWX[a];
+        const wxx = prefWXX[b + 1] - prefWXX[a];
+        return wxx - (wx * wx) / w;
+    };
+    const rangeMean = (a, b) => {
+        const w = prefW[b + 1] - prefW[a];
+        if (w <= 0) {
+            return (centers[a] + centers[b]) * 0.5;
+        }
+        return (prefWX[b + 1] - prefWX[a]) / w;
+    };
+    const nonEmpty = counts.reduce((n, c) => n + (c > 0 ? 1 : 0), 0);
+    const effectiveK = Math.min(k, nonEmpty);
+    // DP: dp[m][j] = min weighted SSE of quantizing bins 0..j into m centroids
+    // Use two rows to save memory (only need previous row)
+    const INF = 1e30;
+    let dpPrev = new Float64Array(H).fill(INF);
+    let dpCurr = new Float64Array(H).fill(INF);
+    const splitTable = new Array(effectiveK + 1);
+    // base case: m = 1
+    const split1 = new Int32Array(H);
+    for (let j = 0; j < H; ++j) {
+        dpPrev[j] = rangeCost(0, j);
+        split1[j] = -1;
+    }
+    splitTable[1] = split1;
+    // fill DP for m = 2..effectiveK
+    for (let m = 2; m <= effectiveK; ++m) {
+        dpCurr.fill(INF);
+        const splitM = new Int32Array(H);
+        for (let j = m - 1; j < H; ++j) {
+            let bestCost = INF;
+            let bestS = m - 2;
+            for (let s = m - 2; s < j; ++s) {
+                const cost = dpPrev[s] + rangeCost(s + 1, j);
+                if (cost < bestCost) {
+                    bestCost = cost;
+                    bestS = s;
+                }
+            }
+            dpCurr[j] = bestCost;
+            splitM[j] = bestS;
+        }
+        splitTable[m] = splitM;
+        // swap rows
+        const tmp = dpPrev;
+        dpPrev = dpCurr;
+        dpCurr = tmp;
+    }
+    // backtrack to find centroid values
+    const centroidValues = new Float32Array(effectiveK);
+    let j = H - 1;
+    for (let m = effectiveK; m >= 1; --m) {
+        const s = m > 1 ? splitTable[m][j] : -1;
+        centroidValues[m - 1] = rangeMean(s + 1, j);
+        j = s;
+    }
+    // sort centroids (should already be sorted, but ensure)
+    centroidValues.sort();
+    // pad to k entries if effectiveK < k (duplicate last centroid)
+    const finalCentroids = new Float32Array(k);
+    finalCentroids.set(centroidValues);
+    for (let i = effectiveK; i < k; ++i) {
+        finalCentroids[i] = centroidValues[effectiveK - 1];
+    }
+    // assign each data point to nearest centroid via binary search
+    const labels = new Uint8Array(N);
+    for (let i = 0; i < N; ++i) {
+        const v = data[i];
+        // binary search for nearest centroid
+        let lo = 0;
+        let hi = k - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            // compare against midpoint between centroids mid and mid+1
+            if (v < (finalCentroids[mid] + finalCentroids[mid + 1]) * 0.5) {
+                hi = mid;
+            }
+            else {
+                lo = mid + 1;
+            }
+        }
+        labels[i] = lo;
+    }
+    return {
+        labels: fields.map((_, i) => labels.subarray(i * numRows, (i + 1) * numRows)),
+        centroids: finalCentroids,
+    };
+}

package/dist/utils/sh-rotate.d.ts

@@ -0,0 +1,2 @@
+import { Matrix3 } from './math.js';
+export declare function createSHRotateFn(mat: Matrix3): (shN: number[]) => void;