@d5techs/3dgs-lib 1.4.21 → 1.4.23

package/dist/3dgs-lib.cjs

@@ -6197,171 +6197,337 @@ 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;
 }
-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;
+function getGpuClusterShader(dim) {
+  return (
+    /* wgsl */
+    `
+struct Uniforms {
+  numPoints: u32,
+  numCentroids: u32
+};
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var<storage, read> points: array<f32>;
+@group(0) @binding(2) var<storage, read> centroids: array<f32>;
+@group(0) @binding(3) var<storage, read_write> results: array<u32>;
+
+const DIM = ${dim}u;
+const CHUNK_SIZE = 128u;
+var<workgroup> sharedChunk: array<f32, ${dim * 128}>;
+
+fn calcDistSqr(point: array<f32, ${dim}>, cIdx: u32) -> f32 {
+  var result = 0.0;
+  var ci = cIdx * DIM;
+  for (var i = 0u; i < DIM; i++) {
+    let v = point[i] - sharedChunk[ci + i];
+    result += v * v;
+  }
+  return result;
+}
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(local_invocation_index) localId: u32,
+  @builtin(global_invocation_id) globalId: vec3u,
+  @builtin(num_workgroups) numWgs: vec3u
+) {
+  let pointIdx = globalId.x + globalId.y * numWgs.x * 64u;
+
+  var point: array<f32, ${dim}>;
+  if (pointIdx < uniforms.numPoints) {
+    for (var i = 0u; i < DIM; i++) {
+      point[i] = points[pointIdx * DIM + 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];
+
+  var mind = 1e20;
+  var mini = 0u;
+
+  let numChunks = (uniforms.numCentroids + CHUNK_SIZE - 1u) / CHUNK_SIZE;
+  for (var chunk = 0u; chunk < numChunks; chunk++) {
+
+    let rowsPerThread = CHUNK_SIZE / 64u;
+    let dstRow = localId * rowsPerThread;
+    let srcRow = min(uniforms.numCentroids, chunk * CHUNK_SIZE + dstRow);
+    let numRows = min(uniforms.numCentroids, srcRow + rowsPerThread) - srcRow;
+
+    var dst = dstRow * DIM;
+    var src = srcRow * DIM;
+    for (var c = 0u; c < numRows * DIM; c++) {
+      sharedChunk[dst + c] = centroids[src + c];
     }
-    let target = Math.random() * totalDist;
-    let chosen = 0;
-    for (let i = 0; i < n; i++) {
-      target -= dist[i];
-      if (target <= 0) {
-        chosen = i;
-        break;
+
+    workgroupBarrier();
+
+    if (pointIdx < uniforms.numPoints) {
+      let thisChunkSize = min(CHUNK_SIZE, uniforms.numCentroids - chunk * CHUNK_SIZE);
+      for (var c = 0u; c < thisChunkSize; c++) {
+        let d = calcDistSqr(point, c);
+        if (d < mind) {
+          mind = d;
+          mini = chunk * CHUNK_SIZE + c;
+        }
       }
     }
-    centroids.push(new Float32Array(vectors[chosen]));
+
+    workgroupBarrier();
   }
-  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;
+
+  if (pointIdx < uniforms.numPoints) {
+    results[pointIdx] = mini;
+  }
+}`
+  );
+}
+let _cachedDevice = null;
+let _deviceFailed = false;
+async function getGpuDevice() {
+  if (_cachedDevice) return _cachedDevice;
+  if (_deviceFailed) return null;
+  try {
+    if (typeof navigator === "undefined" || !navigator.gpu) {
+      _deviceFailed = true;
+      return null;
     }
-    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];
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) {
+      _deviceFailed = true;
+      return null;
     }
-    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;
-          }
-        }
+    _cachedDevice = await adapter.requestDevice({
+      requiredLimits: {
+        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+        maxBufferSize: adapter.limits.maxBufferSize
       }
+    });
+    _cachedDevice.lost.then(() => {
+      _cachedDevice = null;
+    });
+    return _cachedDevice;
+  } catch {
+    _deviceFailed = true;
+    return null;
+  }
+}
+async function gpuAssignLabels(device, pointsFlat, centroidsFlat, numPoints, numCentroids, dim) {
+  const WORKGROUP_SIZE2 = 64;
+  const BATCH_SIZE = 1024 * WORKGROUP_SIZE2;
+  const numBatches = Math.ceil(numPoints / BATCH_SIZE);
+  const shaderModule = device.createShaderModule({ code: getGpuClusterShader(dim) });
+  const bindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
+      { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
+      { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: "read-only-storage" } },
+      { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } }
+    ]
+  });
+  const pipeline = device.createComputePipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+  const uniformBuf = device.createBuffer({ size: 8, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+  const centroidsBuf = device.createBuffer({ size: centroidsFlat.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  device.queue.writeBuffer(centroidsBuf, 0, centroidsFlat.buffer);
+  const pointsBufSize = BATCH_SIZE * dim * 4;
+  const pointsBuf = device.createBuffer({ size: pointsBufSize, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+  const resultsBufSize = BATCH_SIZE * 4;
+  const resultsBuf = device.createBuffer({ size: resultsBufSize, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
+  const readbackBuf = device.createBuffer({ size: resultsBufSize, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+  const labels = new Uint32Array(numPoints);
+  const bindGroup = device.createBindGroup({
+    layout: bindGroupLayout,
+    entries: [
+      { binding: 0, resource: { buffer: uniformBuf } },
+      { binding: 1, resource: { buffer: pointsBuf } },
+      { binding: 2, resource: { buffer: centroidsBuf } },
+      { binding: 3, resource: { buffer: resultsBuf } }
+    ]
+  });
+  for (let batch = 0; batch < numBatches; batch++) {
+    const offset = batch * BATCH_SIZE;
+    const currentBatchSize = Math.min(numPoints - offset, BATCH_SIZE);
+    const groups = Math.ceil(currentBatchSize / WORKGROUP_SIZE2);
+    device.queue.writeBuffer(uniformBuf, 0, new Uint32Array([currentBatchSize, numCentroids]));
+    device.queue.writeBuffer(pointsBuf, 0, pointsFlat.buffer, offset * dim * 4, currentBatchSize * dim * 4);
+    const encoder = device.createCommandEncoder();
+    const pass = encoder.beginComputePass();
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.dispatchWorkgroups(groups);
+    pass.end();
+    encoder.copyBufferToBuffer(resultsBuf, 0, readbackBuf, 0, currentBatchSize * 4);
+    device.queue.submit([encoder.finish()]);
+    await readbackBuf.mapAsync(GPUMapMode.READ);
+    const mapped = new Uint32Array(readbackBuf.getMappedRange(0, currentBatchSize * 4));
+    labels.set(mapped, offset);
+    readbackBuf.unmap();
+  }
+  uniformBuf.destroy();
+  centroidsBuf.destroy();
+  pointsBuf.destroy();
+  resultsBuf.destroy();
+  readbackBuf.destroy();
+  return labels;
+}
+async function kmeansGpu(pointsFlat, n, dim, k, iterations, onProgress) {
+  const labels = new Uint32Array(n);
+  if (n <= k) {
+    const centroids2 = new Float32Array(k * dim);
+    for (let i = 0; i < n; i++) {
+      centroids2.set(pointsFlat.subarray(i * dim, i * dim + dim), i * dim);
+      labels[i] = i;
     }
-    if (!changed) break;
+    return { centroids: centroids2, labels };
   }
+  const centroids = new Float32Array(k * dim);
+  const indices = pickRandomIndices(n, k);
+  for (let i = 0; i < k; i++) {
+    centroids.set(pointsFlat.subarray(indices[i] * dim, indices[i] * dim + dim), i * dim);
+  }
+  const device = await getGpuDevice();
+  for (let iter = 0; iter < iterations; iter++) {
+    onProgress == null ? void 0 : onProgress(iter, iterations);
+    if (device) {
+      const newLabels = await gpuAssignLabels(device, pointsFlat, centroids, n, k, dim);
+      labels.set(newLabels);
+    } else {
+      assignLabelsCpu(pointsFlat, centroids, labels, n, k, dim);
+    }
+    updateCentroids(pointsFlat, centroids, labels, n, k, dim);
+  }
+  onProgress == null ? void 0 : onProgress(iterations, iterations);
+  if (device) {
+    const finalLabels = await gpuAssignLabels(device, pointsFlat, centroids, n, k, dim);
+    labels.set(finalLabels);
+  } else {
+    assignLabelsCpu(pointsFlat, centroids, labels, n, k, dim);
+  }
+  return { centroids, labels };
+}
+function pickRandomIndices(n, m) {
+  const chosen = /* @__PURE__ */ new Set();
+  for (let j = n - m; j < n; j++) {
+    const t = Math.floor(Math.random() * (j + 1));
+    chosen.add(chosen.has(t) ? j : t);
+  }
+  return [...chosen];
+}
+function assignLabelsCpu(points, centroids, labels, n, k, dim) {
   for (let i = 0; i < n; i++) {
-    let bestK = 0;
-    let bestD = Infinity;
+    const pOff = i * dim;
+    let bestK = 0, bestD = Infinity;
     for (let c = 0; c < k; c++) {
+      const cOff = c * dim;
       let d2 = 0;
       for (let d = 0; d < dim; d++) {
-        const diff = vectors[i][d] - centroids[c][d];
+        const diff = points[pOff + d] - centroids[cOff + d];
         d2 += diff * diff;
       }
       if (d2 < bestD) {
@@ -6371,7 +6537,25 @@ function kmeansVectors(vectors, dim, k, iterations) {
     }
     labels[i] = bestK;
   }
-  return { centroids: centroids.map((c) => new Float32Array(c)), labels };
+}
+function updateCentroids(points, centroids, labels, n, k, dim) {
+  const sums = new Float64Array(k * dim);
+  const counts = new Uint32Array(k);
+  for (let i = 0; i < n; i++) {
+    const l = labels[i];
+    counts[l]++;
+    const pOff = i * dim, sOff = l * dim;
+    for (let d = 0; d < dim; d++) sums[sOff + d] += points[pOff + d];
+  }
+  for (let c = 0; c < k; c++) {
+    if (counts[c] > 0) {
+      const off = c * dim;
+      for (let d = 0; d < dim; d++) centroids[off + d] = sums[off + d] / counts[c];
+    } else {
+      const idx = Math.floor(Math.random() * n);
+      centroids.set(points.subarray(idx * dim, idx * dim + dim), c * dim);
+    }
+  }
 }
 function mortonSort(positions, count) {
   let minx = Infinity, miny = Infinity, minz = Infinity;
@@ -6442,11 +6626,12 @@ async function encodeWebP(width, height, pixelData) {
   }
   return new Uint8Array(await blob.arrayBuffer());
 }
-async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
+async function serializeSOG(data, coordinateSystem = "blender", options = {}, onProgress) {
   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;
+  onProgress == null ? void 0 : onProgress("坐标系变换", 0);
   if (coordinateSystem === "blender") {
     positions = new Float32Array(positions);
     scales = new Float32Array(scales);
@@ -6469,6 +6654,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
       }
     }
   }
+  onProgress == null ? void 0 : onProgress("Morton 排序", 0.05);
   const sortOrder = mortonSort(positions, count);
   const sPos = new Float32Array(count * 3);
   const sSca = new Float32Array(count * 3);
@@ -6501,6 +6687,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
   }
   const { width, height } = calcImageDimensions(count);
   const totalPixels = width * height;
+  onProgress == null ? void 0 : onProgress("编码位置", 0.1);
   const logPos = new Float32Array(count * 3);
   for (let i = 0; i < count * 3; i++) logPos[i] = symLog(sPos[i]);
   const mins = [Infinity, Infinity, Infinity];
@@ -6528,9 +6715,10 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     meansLData[off + 3] = 255;
     meansUData[off + 3] = 255;
   }
+  onProgress == null ? void 0 : onProgress("编码缩放", 0.2);
   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++) {
@@ -6540,6 +6728,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     scalesData[off + 2] = findNearest(scaleCodebook, logScales[i * 3 + 2]);
     scalesData[off + 3] = 255;
   }
+  onProgress == null ? void 0 : onProgress("编码四元数", 0.3);
   const quatsData = new Uint8ClampedArray(totalPixels * 4);
   quatsData.fill(255);
   const SQRT2 = Math.SQRT2;
@@ -6592,13 +6781,14 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     quatsData[off + 2] = Math.round(Math.max(0, Math.min(255, (r2 / SQRT2 + 0.5) * 255)));
     quatsData[off + 3] = largest + 252;
   }
+  onProgress == null ? void 0 : onProgress("编码颜色", 0.4);
   const dcValues = new Float32Array(count * 3);
   for (let i = 0; i < count; i++) {
     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, 256, iterations);
+  const dcCodebook = buildCodebook(dcValues, 256);
   const sh0Data = new Uint8ClampedArray(totalPixels * 4);
   sh0Data.fill(255);
   for (let i = 0; i < count; i++) {
@@ -6620,33 +6810,43 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     encodeWebP(width, height, sh0Data)
   ];
   if (actualBands > 0 && sSH) {
-    const vectors = new Array(count);
+    onProgress == null ? void 0 : onProgress("压缩球谐系数 (GPU)", 0.5);
+    const pointsFlat = new Float32Array(count * shDim);
     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;
+      for (let j = 0; j < shDim; j++) pointsFlat[i * shDim + j] = sSH[b + j];
     }
     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 { centroids, labels } = await kmeansGpu(
+      pointsFlat,
+      count,
+      shDim,
+      effectivePaletteSize,
+      iterations,
+      (iter, total) => {
+        const p = 0.5 + 0.35 * (iter / total);
+        onProgress == null ? void 0 : onProgress(`球谐聚类 ${iter}/${total}`, p);
+      }
+    );
+    onProgress == null ? void 0 : onProgress("量化球谐 codebook", 0.88);
+    const allCoeffValues = new Float32Array(effectivePaletteSize * shDim);
+    for (let c = 0; c < effectivePaletteSize; c++) {
+      for (let d = 0; d < shDim; d++) allCoeffValues[c * shDim + d] = centroids[c * shDim + 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);
     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]);
+        const cOff = n * shDim;
+        centData[off] = findNearest(shCodebook, centroids[cOff + c * 3]);
+        centData[off + 1] = findNearest(shCodebook, centroids[cOff + c * 3 + 1]);
+        centData[off + 2] = findNearest(shCodebook, centroids[cOff + c * 3 + 2]);
         centData[off + 3] = 255;
       }
     }
@@ -6670,6 +6870,7 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
       files: ["sh_centroids.webp", "sh_labels.webp"]
     };
   }
+  onProgress == null ? void 0 : onProgress("编码 WebP 图像", 0.92);
   const webps = await Promise.all(webpPromises);
   const [meansLWebP, meansUWebP, scalesWebP, quatsWebP, sh0WebP] = webps;
   const meta = {
@@ -6695,7 +6896,9 @@ async function serializeSOG(data, coordinateSystem = "blender", options = {}) {
     zipEntries["sh_centroids.webp"] = webps[5];
     zipEntries["sh_labels.webp"] = webps[6];
   }
+  onProgress == null ? void 0 : onProgress("打包 ZIP", 0.98);
   const zipData = zipSync(zipEntries, { level: 0 });
+  onProgress == null ? void 0 : onProgress("完成", 1);
   return zipData.buffer;
 }
 const WORKGROUP_SIZE$1 = 256;