@d5techs/3dgs-lib 1.4.18 → 1.4.20

package/dist/3dgs-lib.js

@@ -5975,7 +5975,7 @@ function unzipSync(data, opts) {
   return files;
 }
 const SH_C0$1 = 0.28209479177387814;
-const COEFFS_PER_BAND = [3, 8, 15];
+const COEFFS_PER_BAND$1 = [3, 8, 15];
 function lerp(a, b, t) {
   return a + (b - a) * t;
 }
@@ -6005,7 +6005,7 @@ async function decodeWebP(bytes) {
   return { width: w, height: h, data: ctx.getImageData(0, 0, w, h).data };
 }
 function decodeSHPalette(centroidsImg, codebook, paletteSize, bands) {
-  const numCoeffs = COEFFS_PER_BAND[bands - 1];
+  const numCoeffs = COEFFS_PER_BAND$1[bands - 1];
   const palette = new Array(paletteSize);
   for (let n = 0; n < paletteSize; n++) {
     const entry = new Float32Array(numCoeffs * 3);
@@ -6072,7 +6072,7 @@ async function deserializeSOG(data, onProgress) {
   let shPalette = null;
   let shBandCoeffs = 0;
   if (meta.shN && centroidsImg) {
-    shBandCoeffs = COEFFS_PER_BAND[meta.shN.bands - 1];
+    shBandCoeffs = COEFFS_PER_BAND$1[meta.shN.bands - 1];
     shPalette = decodeSHPalette(
       centroidsImg,
       meta.shN.codebook,
@@ -6145,18 +6145,95 @@ async function deserializeSOG(data, onProgress) {
   return { count, positions, scales, rotations, colors, opacities, shCoeffs };
 }
 const SH_C0 = 0.28209479177387814;
+const COEFFS_PER_BAND = [3, 8, 15];
 function symLog(x) {
   return Math.sign(x) * Math.log(1 + Math.abs(x));
 }
-function buildCodebook(values, size = 256, iterations = 8) {
-  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))];
+function inverseSHTransformYZSwap(sh, base, perChannel) {
+  const SQRT3_2 = Math.sqrt(3) / 2;
+  {
+    for (let ch = 0; ch < 3; ch++) {
+      const a = sh[base + ch];
+      const b = sh[base + 3 + ch];
+      sh[base + ch] = -b;
+      sh[base + 3 + ch] = a;
+    }
+  }
+  {
+    for (let ch = 0; ch < 3; ch++) {
+      const g0 = sh[base + 9 + ch];
+      const g1 = sh[base + 12 + ch];
+      const g2 = sh[base + 15 + ch];
+      const g3 = sh[base + 18 + ch];
+      const g4 = sh[base + 21 + ch];
+      sh[base + 9 + ch] = -g3;
+      sh[base + 12 + ch] = -g1;
+      sh[base + 15 + ch] = -0.5 * g2 - SQRT3_2 * g4;
+      sh[base + 18 + ch] = g0;
+      sh[base + 21 + ch] = -SQRT3_2 * g2 + 0.5 * g4;
+    }
   }
-  const assignments = new Uint8Array(values.length);
+  {
+    const A = Math.sqrt(10) / 4;
+    const B = Math.sqrt(6) / 4;
+    const P = Math.sqrt(15) / 4;
+    for (let ch = 0; ch < 3; ch++) {
+      const g0 = sh[base + 24 + ch];
+      const g1 = sh[base + 27 + ch];
+      const g2 = sh[base + 30 + ch];
+      const g3 = sh[base + 33 + ch];
+      const g4 = sh[base + 36 + ch];
+      const g5 = sh[base + 39 + ch];
+      const g6 = sh[base + 42 + ch];
+      sh[base + 24 + ch] = A * g3 - B * g5;
+      sh[base + 27 + ch] = -g1;
+      sh[base + 30 + ch] = B * g3 + A * g5;
+      sh[base + 33 + ch] = -A * g0 - B * g2;
+      sh[base + 36 + ch] = -0.25 * g4 - P * g6;
+      sh[base + 39 + ch] = B * g0 - A * g2;
+      sh[base + 42 + ch] = -P * g4 + 0.25 * g6;
+    }
+  }
+}
+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]);
@@ -6167,31 +6244,167 @@ function buildCodebook(values, size = 256, iterations = 8) {
           bestIdx = j;
         }
       }
-      assignments[i] = bestIdx;
-    }
-    const sums = new Float64Array(size);
-    const counts = new Uint32Array(size);
-    for (let i = 0; i < values.length; i++) {
-      sums[assignments[i]] += values[i];
-      counts[assignments[i]]++;
+      sums[bestIdx] += values[i];
+      counts[bestIdx]++;
     }
+    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 v = sums[j] / counts[j];
+        if (v !== codebook[j]) {
+          codebook[j] = v;
+          changed = true;
+        }
+      }
     }
+    if (!changed) break;
+  }
+  const result = Array.from(codebook);
+  result.sort((a, b) => a - b);
+  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;
   }
-  return Array.from(codebook);
+  if (lo > 0 && Math.abs(sortedCB[lo - 1] - value) <= Math.abs(sortedCB[lo] - value)) {
+    return lo - 1;
+  }
+  return lo;
 }
-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 kmeansVectors(vectors, dim, k, iterations) {
+  const n = vectors.length;
+  const labels = new Uint16Array(n);
+  if (n <= k) {
+    const centroids2 = [];
+    for (let i = 0; i < n; i++) {
+      centroids2.push(new Float32Array(vectors[i]));
+      labels[i] = i;
+    }
+    while (centroids2.length < k) centroids2.push(new Float32Array(dim));
+    return { centroids: centroids2, labels };
+  }
+  const centroids = [];
+  centroids.push(new Float32Array(vectors[Math.floor(Math.random() * n)]));
+  const dist = new Float64Array(n);
+  dist.fill(Infinity);
+  for (let c = 1; c < k; c++) {
+    const last = centroids[c - 1];
+    let totalDist = 0;
+    for (let i = 0; i < n; i++) {
+      let d2 = 0;
+      for (let d = 0; d < dim; d++) {
+        const diff = vectors[i][d] - last[d];
+        d2 += diff * diff;
+      }
+      if (d2 < dist[i]) dist[i] = d2;
+      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;
+      }
+    }
+    centroids.push(new Float32Array(vectors[chosen]));
+  }
+  for (let iter = 0; iter < iterations; iter++) {
+    for (let i = 0; i < n; i++) {
+      let bestK = 0;
+      let bestD = Infinity;
+      for (let c = 0; c < k; c++) {
+        let d2 = 0;
+        for (let d = 0; d < dim; d++) {
+          const diff = vectors[i][d] - centroids[c][d];
+          d2 += diff * diff;
+        }
+        if (d2 < bestD) {
+          bestD = d2;
+          bestK = c;
+        }
+      }
+      labels[i] = bestK;
+    }
+    const sums = [];
+    for (let c = 0; c < k; c++) sums.push(new Float64Array(dim));
+    const counts = new Uint32Array(k);
+    for (let i = 0; i < n; i++) {
+      const l = labels[i];
+      counts[l]++;
+      for (let d = 0; d < dim; d++) sums[l][d] += vectors[i][d];
+    }
+    let changed = false;
+    for (let c = 0; c < k; c++) {
+      if (counts[c] > 0) {
+        for (let d = 0; d < dim; d++) {
+          const v = sums[c][d] / counts[c];
+          if (v !== centroids[c][d]) {
+            centroids[c][d] = v;
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) break;
+  }
+  for (let i = 0; i < n; i++) {
+    let bestK = 0;
+    let bestD = Infinity;
+    for (let c = 0; c < k; c++) {
+      let d2 = 0;
+      for (let d = 0; d < dim; d++) {
+        const diff = vectors[i][d] - centroids[c][d];
+        d2 += diff * diff;
+      }
+      if (d2 < bestD) {
+        bestD = d2;
+        bestK = c;
+      }
     }
+    labels[i] = bestK;
   }
-  return bestIdx;
+  return { centroids: centroids.map((c) => new Float32Array(c)), labels };
+}
+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,9 +6440,11 @@ async function encodeWebP(width, height, pixelData) {
   }
   return new Uint8Array(await blob.arrayBuffer());
 }
-async function serializeSOG(data, coordinateSystem = "blender") {
+async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
+  const { maxSHBands = 3, iterations = 10, paletteSize = 1024 } = options;
   const { count, colors, opacities } = data;
   let { positions, scales, rotations } = data;
+  let shCoeffs = data.shCoeffs ? new Float32Array(data.shCoeffs) : void 0;
   if (coordinateSystem === "blender") {
     positions = new Float32Array(positions);
     scales = new Float32Array(scales);
@@ -6246,18 +6461,51 @@ async function serializeSOG(data, coordinateSystem = "blender") {
       rotations[i4 + 2] = -rz;
       rotations[i4 + 3] = ry;
     }
+    if (shCoeffs) {
+      for (let i = 0; i < count; i++) {
+        inverseSHTransformYZSwap(shCoeffs, i * 45);
+      }
+    }
+  }
+  const sortOrder = mortonSort(positions, count);
+  const sPos = new Float32Array(count * 3);
+  const sSca = new Float32Array(count * 3);
+  const sRot = new Float32Array(count * 4);
+  const sCol = new Float32Array(count * 3);
+  const sOpa = new Float32Array(count);
+  const sSH = shCoeffs ? new Float32Array(count * 45) : void 0;
+  for (let dst = 0; dst < count; dst++) {
+    const src = sortOrder[dst];
+    const s3 = src * 3, d3 = dst * 3;
+    sPos[d3] = positions[s3];
+    sPos[d3 + 1] = positions[s3 + 1];
+    sPos[d3 + 2] = positions[s3 + 2];
+    sSca[d3] = scales[s3];
+    sSca[d3 + 1] = scales[s3 + 1];
+    sSca[d3 + 2] = scales[s3 + 2];
+    sCol[d3] = colors[s3];
+    sCol[d3 + 1] = colors[s3 + 1];
+    sCol[d3 + 2] = colors[s3 + 2];
+    const s4 = src * 4, d4 = dst * 4;
+    sRot[d4] = rotations[s4];
+    sRot[d4 + 1] = rotations[s4 + 1];
+    sRot[d4 + 2] = rotations[s4 + 2];
+    sRot[d4 + 3] = rotations[s4 + 3];
+    sOpa[dst] = opacities[src];
+    if (sSH && shCoeffs) {
+      const sb = src * 45, db = dst * 45;
+      for (let j = 0; j < 45; j++) sSH[db + j] = shCoeffs[sb + j];
+    }
   }
   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]);
-  }
+  const logPos = new Float32Array(count * 3);
+  for (let i = 0; i < count * 3; i++) logPos[i] = symLog(sPos[i]);
   const mins = [Infinity, Infinity, Infinity];
   const maxs = [-Infinity, -Infinity, -Infinity];
   for (let i = 0; i < count; i++) {
     for (let c = 0; c < 3; c++) {
-      const v = logPositions[i * 3 + c];
+      const v = logPos[i * 3 + c];
       if (v < mins[c]) mins[c] = v;
       if (v > maxs[c]) maxs[c] = v;
     }
@@ -6270,7 +6518,7 @@ async function serializeSOG(data, coordinateSystem = "blender") {
     const off = i * 4;
     for (let c = 0; c < 3; c++) {
       const range = maxs[c] - mins[c];
-      const norm = range < 1e-10 ? 0 : (logPositions[i * 3 + c] - mins[c]) / range;
+      const norm = range < 1e-10 ? 0 : (logPos[i * 3 + c] - mins[c]) / range;
       const q16 = Math.round(norm * 65535);
       meansLData[off + c] = q16 & 255;
       meansUData[off + c] = q16 >> 8 & 255;
@@ -6279,15 +6527,13 @@ async function serializeSOG(data, coordinateSystem = "blender") {
     meansUData[off + 3] = 255;
   }
   const logScales = new Float32Array(count * 3);
-  for (let i = 0; i < count * 3; i++) {
-    logScales[i] = Math.log(Math.max(1e-8, scales[i]));
-  }
-  const scaleCodebook = buildCodebook(logScales);
+  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 scalesData = new Uint8ClampedArray(totalPixels * 4);
   scalesData.fill(255);
   for (let i = 0; i < count; i++) {
     const off = i * 4;
-    scalesData[off + 0] = findNearest(scaleCodebook, logScales[i * 3 + 0]);
+    scalesData[off] = findNearest(scaleCodebook, logScales[i * 3]);
     scalesData[off + 1] = findNearest(scaleCodebook, logScales[i * 3 + 1]);
     scalesData[off + 2] = findNearest(scaleCodebook, logScales[i * 3 + 2]);
     scalesData[off + 3] = 255;
@@ -6297,13 +6543,17 @@ async function serializeSOG(data, coordinateSystem = "blender") {
   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 = sRot[i * 4], qx = sRot[i * 4 + 1], qy = sRot[i * 4 + 2], qz = sRot[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]);
+    let largest = 0, largestAbs = Math.abs(comps[0]);
     for (let j = 1; j < 4; j++) {
       const a = Math.abs(comps[j]);
       if (a > largestAbs) {
@@ -6335,65 +6585,115 @@ async function serializeSOG(data, coordinateSystem = "blender") {
       r1 = qx;
       r2 = qy;
     }
-    quatsData[off + 0] = Math.round(Math.max(0, Math.min(255, (r0 / SQRT2 + 0.5) * 255)));
+    quatsData[off] = Math.round(Math.max(0, Math.min(255, (r0 / SQRT2 + 0.5) * 255)));
     quatsData[off + 1] = Math.round(Math.max(0, Math.min(255, (r1 / SQRT2 + 0.5) * 255)));
     quatsData[off + 2] = Math.round(Math.max(0, Math.min(255, (r2 / SQRT2 + 0.5) * 255)));
     quatsData[off + 3] = largest + 252;
   }
   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] = (sCol[i * 3] - 0.5) / SH_C0;
+    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);
+  const dcCodebook = buildCodebook(dcValues, 256, iterations);
   const sh0Data = new Uint8ClampedArray(totalPixels * 4);
   sh0Data.fill(255);
   for (let i = 0; i < count; i++) {
     const off = i * 4;
-    sh0Data[off + 0] = findNearest(dcCodebook, dcValues[i * 3 + 0]);
+    sh0Data[off] = findNearest(dcCodebook, dcValues[i * 3]);
     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, sOpa[i] * 255)));
   }
-  const [meansLWebP, meansUWebP, scalesWebP, quatsWebP, sh0WebP] = await Promise.all([
+  const actualBands = sSH && maxSHBands > 0 ? maxSHBands : 0;
+  const numCoeffs = actualBands > 0 ? COEFFS_PER_BAND[actualBands - 1] : 0;
+  const shDim = numCoeffs * 3;
+  let shNMeta;
+  const webpPromises = [
     encodeWebP(width, height, meansLData),
     encodeWebP(width, height, meansUData),
     encodeWebP(width, height, scalesData),
     encodeWebP(width, height, quatsData),
     encodeWebP(width, height, sh0Data)
-  ]);
+  ];
+  if (actualBands > 0 && sSH) {
+    const vectors = new Array(count);
+    for (let i = 0; i < count; i++) {
+      const v = new Float32Array(shDim);
+      const b = i * 45;
+      for (let j = 0; j < shDim; j++) v[j] = sSH[b + j];
+      vectors[i] = v;
+    }
+    const effectivePaletteSize = Math.min(paletteSize, count);
+    const { centroids, labels } = kmeansVectors(vectors, shDim, effectivePaletteSize, iterations);
+    const allCoeffValues = new Float32Array(centroids.length * shDim);
+    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 centW = 64 * numCoeffs;
+    const centH = Math.ceil(effectivePaletteSize / 64);
+    const centData = new Uint8ClampedArray(centW * centH * 4);
+    centData.fill(255);
+    for (let n = 0; n < effectivePaletteSize; n++) {
+      const entry = centroids[n];
+      for (let c = 0; c < numCoeffs; c++) {
+        const u = n % 64 * numCoeffs + c;
+        const v = Math.floor(n / 64);
+        const off = (v * centW + u) * 4;
+        centData[off] = findNearest(shCodebook, entry[c * 3]);
+        centData[off + 1] = findNearest(shCodebook, entry[c * 3 + 1]);
+        centData[off + 2] = findNearest(shCodebook, entry[c * 3 + 2]);
+        centData[off + 3] = 255;
+      }
+    }
+    const labelsData = new Uint8ClampedArray(totalPixels * 4);
+    labelsData.fill(255);
+    for (let i = 0; i < count; i++) {
+      const off = i * 4;
+      labelsData[off] = labels[i] & 255;
+      labelsData[off + 1] = labels[i] >> 8 & 255;
+      labelsData[off + 2] = 255;
+      labelsData[off + 3] = 255;
+    }
+    webpPromises.push(
+      encodeWebP(centW, centH, centData),
+      encodeWebP(width, height, labelsData)
+    );
+    shNMeta = {
+      count: effectivePaletteSize,
+      bands: actualBands,
+      codebook: shCodebook,
+      files: ["sh_centroids.webp", "sh_labels.webp"]
+    };
+  }
+  const webps = await Promise.all(webpPromises);
+  const [meansLWebP, meansUWebP, scalesWebP, quatsWebP, sh0WebP] = webps;
   const meta = {
     version: 2,
     asset: { generator: "d5techs/3dgs-lib" },
     count,
     antialias: false,
-    means: {
-      mins,
-      maxs,
-      files: ["means_l.webp", "means_u.webp"]
-    },
-    scales: {
-      codebook: scaleCodebook,
-      files: ["scales.webp"]
-    },
-    quats: {
-      files: ["quats.webp"]
-    },
-    sh0: {
-      codebook: dcCodebook,
-      files: ["sh0.webp"]
-    }
+    means: { mins, maxs, files: ["means_l.webp", "means_u.webp"] },
+    scales: { codebook: scaleCodebook, files: ["scales.webp"] },
+    quats: { files: ["quats.webp"] },
+    sh0: { codebook: dcCodebook, files: ["sh0.webp"] }
   };
-  const metaBytes = new TextEncoder().encode(JSON.stringify(meta));
-  const zipData = zipSync({
-    "meta.json": metaBytes,
+  if (shNMeta) meta.shN = shNMeta;
+  const zipEntries = {
+    "meta.json": new TextEncoder().encode(JSON.stringify(meta)),
     "means_l.webp": meansLWebP,
     "means_u.webp": meansUWebP,
     "scales.webp": scalesWebP,
     "quats.webp": quatsWebP,
     "sh0.webp": sh0WebP
-  }, { level: 0 });
+  };
+  if (webps.length > 5) {
+    zipEntries["sh_centroids.webp"] = webps[5];
+    zipEntries["sh_labels.webp"] = webps[6];
+  }
+  const zipData = zipSync(zipEntries, { level: 0 });
   return zipData.buffer;
 }
 const WORKGROUP_SIZE$1 = 256;
@@ -17220,6 +17520,8 @@ class SplatEditor {
     const rotations = new Float32Array(keepCount * 4);
     const colors = new Float32Array(keepCount * 3);
     const opacities = new Float32Array(keepCount);
+    const hasSH = !!src.shCoeffs;
+    const shCoeffs = hasSH ? new Float32Array(keepCount * 45) : void 0;
     let dst = 0;
     for (let i = 0; i < count; i++) {
       if (data[i] & State.deleted) continue;
@@ -17239,9 +17541,13 @@ class SplatEditor {
       rotations[d4 + 2] = src.rotations[i4 + 2];
       rotations[d4 + 3] = src.rotations[i4 + 3];
       opacities[dst] = src.opacities[i];
+      if (shCoeffs && src.shCoeffs) {
+        const sb = i * 45, db = dst * 45;
+        for (let j = 0; j < 45; j++) shCoeffs[db + j] = src.shCoeffs[sb + j];
+      }
       dst++;
     }
-    return { count: keepCount, positions, scales, rotations, colors, opacities };
+    return { count: keepCount, positions, scales, rotations, colors, opacities, shCoeffs };
   }
   downloadPLY(filename = "edited.ply") {
     const buffer = this.exportPLY();