@d5techs/3dgs-lib 1.4.20 → 1.4.22

package/dist/3dgs-lib.js

@@ -6195,83 +6195,109 @@ function inverseSHTransformYZSwap(sh, base, perChannel) {
     }
   }
 }
-function kmeansppInit1D(values, k) {
-  const n = values.length;
-  const centers = new Float64Array(k);
-  centers[0] = values[Math.floor(Math.random() * n)];
-  const dist = new Float64Array(n);
-  dist.fill(Infinity);
-  for (let c = 1; c < k; c++) {
-    let totalDist = 0;
-    for (let i = 0; i < n; i++) {
-      const d = (values[i] - centers[c - 1]) ** 2;
-      if (d < dist[i]) dist[i] = d;
-      totalDist += dist[i];
-    }
-    let target = Math.random() * totalDist;
-    let chosen = 0;
-    for (let i = 0; i < n; i++) {
-      target -= dist[i];
-      if (target <= 0) {
-        chosen = i;
-        break;
-      }
-    }
-    centers[c] = values[chosen];
-  }
-  return centers;
-}
-function buildCodebook(values, size = 256, iterations = 10) {
-  if (values.length === 0) return new Array(size).fill(0);
-  if (values.length <= size) {
-    const cb = Array.from(new Set(Array.from(values))).sort((a, b) => a - b);
-    while (cb.length < size) cb.push(cb[cb.length - 1]);
-    return cb.slice(0, size);
-  }
-  const codebook = kmeansppInit1D(values, size);
-  const sums = new Float64Array(size);
-  const counts = new Uint32Array(size);
-  for (let iter = 0; iter < iterations; iter++) {
-    sums.fill(0);
-    counts.fill(0);
-    for (let i = 0; i < values.length; i++) {
-      let bestIdx = 0;
-      let bestDist = Math.abs(values[i] - codebook[0]);
-      for (let j = 1; j < size; j++) {
-        const d = Math.abs(values[i] - codebook[j]);
-        if (d < bestDist) {
-          bestDist = d;
-          bestIdx = j;
-        }
-      }
-      sums[bestIdx] += values[i];
-      counts[bestIdx]++;
-    }
-    let changed = false;
-    for (let j = 0; j < size; j++) {
-      if (counts[j] > 0) {
-        const v = sums[j] / counts[j];
-        if (v !== codebook[j]) {
-          codebook[j] = v;
-          changed = true;
+function buildCodebook(values, k = 256) {
+  const N = values.length;
+  if (N === 0) return new Array(k).fill(0);
+  const sorted = new Float32Array(values);
+  sorted.sort();
+  const vMin = sorted[0];
+  const vMax = sorted[N - 1];
+  if (vMax - vMin < 1e-20) return new Array(k).fill(vMin);
+  const H = Math.min(1024, N);
+  const vRange = vMax - vMin;
+  const iqr = sorted[Math.floor(N * 0.75)] - sorted[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 = (sorted[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] += sorted[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;
+  }
+  const alpha = 0.5;
+  const weights = new Float64Array(H);
+  for (let i = 0; i < H; i++) {
+    weights[i] = counts[i] > 0 ? Math.pow(counts[i], alpha) : 0;
+  }
+  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;
+  };
+  let nonEmpty = 0;
+  for (let i = 0; i < H; i++) if (counts[i] > 0) nonEmpty++;
+  const effectiveK = Math.min(k, nonEmpty);
+  const INF = 1e30;
+  let dpPrev = new Float64Array(H).fill(INF);
+  let dpCurr = new Float64Array(H).fill(INF);
+  const splitTable = new Array(effectiveK + 1);
+  const split1 = new Int32Array(H);
+  for (let j = 0; j < H; j++) {
+    dpPrev[j] = rangeCost(0, j);
+    split1[j] = -1;
+  }
+  splitTable[1] = split1;
+  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;
         }
       }
-    }
-    if (!changed) break;
-  }
-  const result = Array.from(codebook);
-  result.sort((a, b) => a - b);
+      dpCurr[j] = bestCost;
+      splitM[j] = bestS;
+    }
+    splitTable[m] = splitM;
+    const tmp = dpPrev;
+    dpPrev = dpCurr;
+    dpCurr = tmp;
+  }
+  const centroidValues = new Float32Array(effectiveK);
+  let jj = H - 1;
+  for (let m = effectiveK; m >= 1; m--) {
+    const s = m > 1 ? splitTable[m][jj] : -1;
+    centroidValues[m - 1] = rangeMean(s + 1, jj);
+    jj = s;
+  }
+  centroidValues.sort();
+  const result = new Array(k);
+  for (let i = 0; i < effectiveK; i++) result[i] = centroidValues[i];
+  for (let i = effectiveK; i < k; i++) result[i] = centroidValues[effectiveK - 1];
   return result;
 }
 function findNearest(sortedCB, value) {
   let lo = 0, hi = sortedCB.length - 1;
   while (lo < hi) {
     const mid = lo + hi >> 1;
-    if (sortedCB[mid] < value) lo = mid + 1;
-    else hi = mid;
-  }
-  if (lo > 0 && Math.abs(sortedCB[lo - 1] - value) <= Math.abs(sortedCB[lo] - value)) {
-    return lo - 1;
+    if (value < (sortedCB[mid] + sortedCB[mid + 1]) * 0.5) hi = mid;
+    else lo = mid + 1;
   }
   return lo;
 }
@@ -6528,7 +6554,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
   }
   const logScales = new Float32Array(count * 3);
   for (let i = 0; i < count * 3; i++) logScales[i] = Math.log(Math.max(1e-8, sSca[i]));
-  const scaleCodebook = buildCodebook(logScales, 256, iterations);
+  const scaleCodebook = buildCodebook(logScales, 256);
   const scalesData = new Uint8ClampedArray(totalPixels * 4);
   scalesData.fill(255);
   for (let i = 0; i < count; i++) {
@@ -6596,7 +6622,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     dcValues[i * 3 + 1] = (sCol[i * 3 + 1] - 0.5) / SH_C0;
     dcValues[i * 3 + 2] = (sCol[i * 3 + 2] - 0.5) / SH_C0;
   }
-  const dcCodebook = buildCodebook(dcValues, 256, iterations);
+  const dcCodebook = buildCodebook(dcValues, 256);
   const sh0Data = new Uint8ClampedArray(totalPixels * 4);
   sh0Data.fill(255);
   for (let i = 0; i < count; i++) {
@@ -6631,7 +6657,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     for (let c = 0; c < centroids.length; c++) {
       for (let d = 0; d < shDim; d++) allCoeffValues[c * shDim + d] = centroids[c][d];
     }
-    const shCodebook = buildCodebook(allCoeffValues, 256, iterations);
+    const shCodebook = buildCodebook(allCoeffValues, 256);
     const centW = 64 * numCoeffs;
     const centH = Math.ceil(effectivePaletteSize / 64);
     const centData = new Uint8ClampedArray(centW * centH * 4);