@d5techs/3dgs-lib 1.4.17 → 1.4.19

package/dist/3dgs-lib.js

@@ -6148,14 +6148,43 @@ const SH_C0 = 0.28209479177387814;
 function symLog(x) {
   return Math.sign(x) * Math.log(1 + Math.abs(x));
 }
-function buildCodebook(values, size = 256, iterations = 8) {
+function kmeansppInit(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 = 20) {
   if (values.length === 0) return new Array(size).fill(0);
-  const sorted = Float32Array.from(values).sort();
-  const codebook = new Float64Array(size);
-  for (let i = 0; i < size; i++) {
-    codebook[i] = sorted[Math.floor(i / (size - 1) * (sorted.length - 1))];
+  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 = kmeansppInit(values, size);
   const assignments = new Uint8Array(values.length);
+  const sums = new Float64Array(size);
+  const counts = new Uint32Array(size);
   for (let iter = 0; iter < iterations; iter++) {
     for (let i = 0; i < values.length; i++) {
       let bestIdx = 0;
@@ -6169,29 +6198,74 @@ function buildCodebook(values, size = 256, iterations = 8) {
       }
       assignments[i] = bestIdx;
     }
-    const sums = new Float64Array(size);
-    const counts = new Uint32Array(size);
+    sums.fill(0);
+    counts.fill(0);
     for (let i = 0; i < values.length; i++) {
       sums[assignments[i]] += values[i];
       counts[assignments[i]]++;
     }
+    let changed = false;
     for (let j = 0; j < size; j++) {
-      if (counts[j] > 0) codebook[j] = sums[j] / counts[j];
+      if (counts[j] > 0) {
+        const newVal = sums[j] / counts[j];
+        if (newVal !== codebook[j]) {
+          codebook[j] = newVal;
+          changed = true;
+        }
+      }
     }
+    if (!changed) break;
   }
-  return Array.from(codebook);
+  const result = Array.from(codebook);
+  result.sort((a, b) => a - b);
+  return result;
 }
-function findNearest(codebook, value) {
-  let bestIdx = 0;
-  let bestDist = Math.abs(value - codebook[0]);
-  for (let j = 1; j < codebook.length; j++) {
-    const d = Math.abs(value - codebook[j]);
-    if (d < bestDist) {
-      bestDist = d;
-      bestIdx = j;
-    }
+function findNearest(sortedCodebook, value) {
+  let lo = 0, hi = sortedCodebook.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (sortedCodebook[mid] < value) lo = mid + 1;
+    else hi = mid;
   }
-  return bestIdx;
+  if (lo > 0 && Math.abs(sortedCodebook[lo - 1] - value) <= Math.abs(sortedCodebook[lo] - value)) {
+    return lo - 1;
+  }
+  return lo;
+}
+function mortonSort(positions, count) {
+  let minx = Infinity, miny = Infinity, minz = Infinity;
+  let maxx = -Infinity, maxy = -Infinity, maxz = -Infinity;
+  for (let i = 0; i < count; i++) {
+    const x = positions[i * 3], y = positions[i * 3 + 1], z = positions[i * 3 + 2];
+    if (x < minx) minx = x;
+    if (x > maxx) maxx = x;
+    if (y < miny) miny = y;
+    if (y > maxy) maxy = y;
+    if (z < minz) minz = z;
+    if (z > maxz) maxz = z;
+  }
+  const xlen = maxx - minx || 1;
+  const ylen = maxy - miny || 1;
+  const zlen = maxz - minz || 1;
+  const part1By2 = (x) => {
+    x &= 1023;
+    x = (x ^ x << 16) & 4278190335;
+    x = (x ^ x << 8) & 50393103;
+    x = (x ^ x << 4) & 51130563;
+    x = (x ^ x << 2) & 153391689;
+    return x;
+  };
+  const morton = new Uint32Array(count);
+  const indices = new Uint32Array(count);
+  for (let i = 0; i < count; i++) {
+    const ix = Math.min(1023, Math.floor(1024 * (positions[i * 3] - minx) / xlen));
+    const iy = Math.min(1023, Math.floor(1024 * (positions[i * 3 + 1] - miny) / ylen));
+    const iz = Math.min(1023, Math.floor(1024 * (positions[i * 3 + 2] - minz) / zlen));
+    morton[i] = (part1By2(iz) << 2) + (part1By2(iy) << 1) + part1By2(ix);
+    indices[i] = i;
+  }
+  indices.sort((a, b) => morton[a] - morton[b]);
+  return indices;
 }
 function calcImageDimensions(count) {
   const width = Math.ceil(Math.sqrt(count));
@@ -6227,13 +6301,56 @@ async function encodeWebP(width, height, pixelData) {
   }
   return new Uint8Array(await blob.arrayBuffer());
 }
-async function serializeSOG(data) {
-  const { count, positions, scales, rotations, colors, opacities } = data;
+async function serializeSOG(data, coordinateSystem = "blender") {
+  const { count, colors, opacities } = data;
+  let { positions, scales, rotations } = data;
+  if (coordinateSystem === "blender") {
+    positions = new Float32Array(positions);
+    scales = new Float32Array(scales);
+    rotations = new Float32Array(rotations);
+    for (let i = 0; i < count; i++) {
+      const i3 = i * 3, i4 = i * 4;
+      const py = positions[i3 + 1], pz = positions[i3 + 2];
+      positions[i3 + 1] = -pz;
+      positions[i3 + 2] = py;
+      const sy = scales[i3 + 1], sz = scales[i3 + 2];
+      scales[i3 + 1] = sz;
+      scales[i3 + 2] = sy;
+      const ry = rotations[i4 + 2], rz = rotations[i4 + 3];
+      rotations[i4 + 2] = -rz;
+      rotations[i4 + 3] = ry;
+    }
+  }
+  const sortOrder = mortonSort(positions, count);
+  const sortedPositions = new Float32Array(count * 3);
+  const sortedScales = new Float32Array(count * 3);
+  const sortedRotations = new Float32Array(count * 4);
+  const sortedColors = new Float32Array(count * 3);
+  const sortedOpacities = new Float32Array(count);
+  for (let dst = 0; dst < count; dst++) {
+    const src = sortOrder[dst];
+    const s3 = src * 3, d3 = dst * 3;
+    sortedPositions[d3] = positions[s3];
+    sortedPositions[d3 + 1] = positions[s3 + 1];
+    sortedPositions[d3 + 2] = positions[s3 + 2];
+    sortedScales[d3] = scales[s3];
+    sortedScales[d3 + 1] = scales[s3 + 1];
+    sortedScales[d3 + 2] = scales[s3 + 2];
+    sortedColors[d3] = colors[s3];
+    sortedColors[d3 + 1] = colors[s3 + 1];
+    sortedColors[d3 + 2] = colors[s3 + 2];
+    const s4 = src * 4, d4 = dst * 4;
+    sortedRotations[d4] = rotations[s4];
+    sortedRotations[d4 + 1] = rotations[s4 + 1];
+    sortedRotations[d4 + 2] = rotations[s4 + 2];
+    sortedRotations[d4 + 3] = rotations[s4 + 3];
+    sortedOpacities[dst] = opacities[src];
+  }
   const { width, height } = calcImageDimensions(count);
   const totalPixels = width * height;
   const logPositions = new Float32Array(count * 3);
   for (let i = 0; i < count * 3; i++) {
-    logPositions[i] = symLog(positions[i]);
+    logPositions[i] = symLog(sortedPositions[i]);
   }
   const mins = [Infinity, Infinity, Infinity];
   const maxs = [-Infinity, -Infinity, -Infinity];
@@ -6262,7 +6379,7 @@ async function serializeSOG(data) {
   }
   const logScales = new Float32Array(count * 3);
   for (let i = 0; i < count * 3; i++) {
-    logScales[i] = Math.log(Math.max(1e-8, scales[i]));
+    logScales[i] = Math.log(Math.max(1e-8, sortedScales[i]));
   }
   const scaleCodebook = buildCodebook(logScales);
   const scalesData = new Uint8ClampedArray(totalPixels * 4);
@@ -6279,10 +6396,18 @@ async function serializeSOG(data) {
   const SQRT2 = Math.SQRT2;
   for (let i = 0; i < count; i++) {
     const off = i * 4;
-    let qw = rotations[i * 4 + 0];
-    let qx = rotations[i * 4 + 1];
-    let qy = rotations[i * 4 + 2];
-    let qz = rotations[i * 4 + 3];
+    let qw = sortedRotations[i * 4 + 0];
+    let qx = sortedRotations[i * 4 + 1];
+    let qy = sortedRotations[i * 4 + 2];
+    let qz = sortedRotations[i * 4 + 3];
+    const len = Math.sqrt(qw * qw + qx * qx + qy * qy + qz * qz);
+    if (len > 0) {
+      const inv = 1 / len;
+      qw *= inv;
+      qx *= inv;
+      qy *= inv;
+      qz *= inv;
+    }
     const comps = [qw, qx, qy, qz];
     let largest = 0;
     let largestAbs = Math.abs(comps[0]);
@@ -6324,9 +6449,9 @@ async function serializeSOG(data) {
   }
   const dcValues = new Float32Array(count * 3);
   for (let i = 0; i < count; i++) {
-    dcValues[i * 3 + 0] = (colors[i * 3 + 0] - 0.5) / SH_C0;
-    dcValues[i * 3 + 1] = (colors[i * 3 + 1] - 0.5) / SH_C0;
-    dcValues[i * 3 + 2] = (colors[i * 3 + 2] - 0.5) / SH_C0;
+    dcValues[i * 3 + 0] = (sortedColors[i * 3 + 0] - 0.5) / SH_C0;
+    dcValues[i * 3 + 1] = (sortedColors[i * 3 + 1] - 0.5) / SH_C0;
+    dcValues[i * 3 + 2] = (sortedColors[i * 3 + 2] - 0.5) / SH_C0;
   }
   const dcCodebook = buildCodebook(dcValues);
   const sh0Data = new Uint8ClampedArray(totalPixels * 4);
@@ -6336,7 +6461,7 @@ async function serializeSOG(data) {
     sh0Data[off + 0] = findNearest(dcCodebook, dcValues[i * 3 + 0]);
     sh0Data[off + 1] = findNearest(dcCodebook, dcValues[i * 3 + 1]);
     sh0Data[off + 2] = findNearest(dcCodebook, dcValues[i * 3 + 2]);
-    sh0Data[off + 3] = Math.round(Math.max(0, Math.min(255, opacities[i] * 255)));
+    sh0Data[off + 3] = Math.round(Math.max(0, Math.min(255, sortedOpacities[i] * 255)));
   }
   const [meansLWebP, meansUWebP, scalesWebP, quatsWebP, sh0WebP] = await Promise.all([
     encodeWebP(width, height, meansLData),