3dtiles-inspector 0.2.13 → 0.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3dtiles-inspector",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Inspect, align, and save local 3D Tiles root transforms in an interactive browser session.",
   "author": "William Liu <lyz15972107087@gmail.com>",
   "license": "Apache-2.0",
@@ -55,8 +55,8 @@
   },
   "devDependencies": {
     "@sparkjsdev/spark": "2.1.0",
-    "3d-tiles-renderer": "0.4.27",
-    "3d-tiles-rendererjs-3dgs-plugin": "0.1.11",
+    "3d-tiles-renderer": "0.4.28",
+    "3d-tiles-rendererjs-3dgs-plugin": "0.1.14",
     "esbuild": "^0.25.11"
   },
   "dependencies": {

package/src/server/splatCrop/gaussianPrimitives.js

@@ -2,6 +2,23 @@ const { InspectorError } = require('../../errors');
 const { normalizeMatrix4Array } = require('./normalize');
 const { getNodeLocalMatrix } = require('./gltfResource');
 
+const KHR_GAUSSIAN_SPLATTING_EXTENSION = 'KHR_gaussian_splatting';
+const KHR_GAUSSIAN_SPLATTING_SPZ_EXTENSION =
+  'KHR_gaussian_splatting_compression_spz_2';
+const EXT_SPLAT_OPACITY_EXTENSION = 'EXT_splat_opacity';
+
+function getGaussianSplattingExtensions(primitive) {
+  return primitive?.extensions?.[KHR_GAUSSIAN_SPLATTING_EXTENSION]?.extensions;
+}
+
+function getGaussianSplatOpacityExtension(primitive) {
+  const extensions = getGaussianSplattingExtensions(primitive);
+  return (
+    extensions?.[EXT_SPLAT_OPACITY_EXTENSION] ??
+    primitive?.extensions?.[EXT_SPLAT_OPACITY_EXTENSION]
+  );
+}
+
 function getTileLocalTransform(THREE, tile) {
   const matrix = new THREE.Matrix4();
   if (Array.isArray(tile?.transform)) {
@@ -37,10 +54,22 @@ function getRootUpRotationMatrix(THREE, tileset) {
 }
 
 function primitiveHasGaussianSpzExtension(primitive) {
-  return (
-    primitive?.extensions?.KHR_gaussian_splatting?.extensions
-      ?.KHR_gaussian_splatting_compression_spz_2 != null
-  );
+  const extensions = getGaussianSplattingExtensions(primitive);
+  return extensions?.[KHR_GAUSSIAN_SPLATTING_SPZ_EXTENSION] != null;
+}
+
+function getGaussianSplatOpacityAccessorIndex(primitive) {
+  const opacityAccessor = getGaussianSplatOpacityExtension(primitive)
+    ?.opacityAccessor;
+  if (opacityAccessor == null) {
+    return null;
+  }
+  if (!Number.isInteger(opacityAccessor) || opacityAccessor < 0) {
+    throw new InspectorError(
+      'EXT_splat_opacity opacityAccessor must be a non-negative integer.',
+    );
+  }
+  return opacityAccessor;
 }
 
 function collectGaussianPrimitiveDescriptors(
@@ -87,12 +116,12 @@ function collectGaussianPrimitiveDescriptors(
       const mesh = meshes[node.mesh];
       if (mesh && Array.isArray(mesh.primitives)) {
         mesh.primitives.forEach((primitive, primitiveIndex) => {
+          const extensions = getGaussianSplattingExtensions(primitive);
           const gaussianExtension =
-            primitive?.extensions?.KHR_gaussian_splatting?.extensions
-              ?.KHR_gaussian_splatting_compression_spz_2;
+            extensions?.[KHR_GAUSSIAN_SPLATTING_SPZ_EXTENSION];
           const bufferView = gaussianExtension?.bufferView;
           if (bufferView == null) {
-            if (primitive?.extensions?.KHR_gaussian_splatting) {
+            if (primitive?.extensions?.[KHR_GAUSSIAN_SPLATTING_EXTENSION]) {
               throw new InspectorError(
                 'Only KHR_gaussian_splatting_compression_spz_2 Gaussian primitives are supported for crop deletion.',
               );
@@ -288,6 +317,7 @@ function updateGaussianPrimitiveAccessorCounts(resource, descriptors, count) {
 
 module.exports = {
   collectGaussianPrimitiveDescriptors,
+  getGaussianSplatOpacityAccessorIndex,
   getRootUpRotationMatrix,
   getTileLocalTransform,
   getTileWorldTransform,

package/src/server/splatCrop/traversal.js

@@ -16,6 +16,7 @@ const {
 } = require('./gltfResource');
 const {
   collectGaussianPrimitiveDescriptors,
+  getGaussianSplatOpacityAccessorIndex,
   getTileLocalTransform,
   hasNonGaussianScenePrimitives,
   hasScenePrimitives,
@@ -24,6 +25,10 @@ const {
 } = require('./gaussianPrimitives');
 const { SPLAT_CROP_WORKER_COUNT } = require('./workerPool');
 
+const ACCESSOR_COMPONENT_TYPE_FLOAT = 5126;
+const ACCESSOR_TYPE_SCALAR = 'SCALAR';
+const FLOAT32_BYTE_LENGTH = 4;
+
 class AsyncLimiter {
   constructor(limit) {
     this.active = 0;
@@ -618,6 +623,154 @@ function markSplatResourceProgress(context, resourcePath) {
   });
 }
 
+function getPrimitiveForDescriptor(resource, descriptor) {
+  if (
+    !Number.isInteger(descriptor.meshIndex) ||
+    !Number.isInteger(descriptor.primitiveIndex)
+  ) {
+    return null;
+  }
+  return resource.json.meshes?.[descriptor.meshIndex]?.primitives?.[
+    descriptor.primitiveIndex
+  ];
+}
+
+function getAccessorDefinition(resource, accessorIndex, label) {
+  const accessor = resource.json.accessors?.[accessorIndex];
+  if (!accessor || typeof accessor !== 'object') {
+    throw new InspectorError(`${label} references missing accessor ${accessorIndex}.`);
+  }
+  if (accessor.componentType !== ACCESSOR_COMPONENT_TYPE_FLOAT) {
+    throw new InspectorError(`${label} must use FLOAT componentType.`);
+  }
+  if (accessor.type !== ACCESSOR_TYPE_SCALAR) {
+    throw new InspectorError(`${label} must use SCALAR type.`);
+  }
+  if (accessor.sparse) {
+    throw new InspectorError(`${label} sparse accessors are not supported.`);
+  }
+  if (!Number.isInteger(accessor.bufferView)) {
+    throw new InspectorError(`${label} must reference a bufferView.`);
+  }
+  if (!Number.isInteger(accessor.count) || accessor.count < 0) {
+    throw new InspectorError(`${label} count must be a non-negative integer.`);
+  }
+
+  const byteOffset = Number(accessor.byteOffset ?? 0);
+  if (!Number.isInteger(byteOffset) || byteOffset < 0) {
+    throw new InspectorError(`${label} byteOffset must be a non-negative integer.`);
+  }
+  const bufferView = resource.json.bufferViews?.[accessor.bufferView];
+  if (!bufferView || typeof bufferView !== 'object') {
+    throw new InspectorError(`${label} references missing bufferView.`);
+  }
+  const byteStride = Number(bufferView.byteStride ?? FLOAT32_BYTE_LENGTH);
+  if (!Number.isInteger(byteStride) || byteStride < FLOAT32_BYTE_LENGTH) {
+    throw new InspectorError(
+      `${label} byteStride must be at least ${FLOAT32_BYTE_LENGTH}.`,
+    );
+  }
+
+  return { accessor, bufferView, byteOffset, byteStride };
+}
+
+function makeFloat32ScalarAccessorSubsetReplacement(
+  resource,
+  accessorIndex,
+  survivors,
+) {
+  const label = `EXT_splat_opacity accessor ${accessorIndex}`;
+  const { accessor, bufferView, byteOffset, byteStride } = getAccessorDefinition(
+    resource,
+    accessorIndex,
+    label,
+  );
+  const slice = getBufferViewSlice(resource, accessor.bufferView);
+  const sourceLength =
+    accessor.count === 0
+      ? 0
+      : (accessor.count - 1) * byteStride + FLOAT32_BYTE_LENGTH;
+  const sourceEnd = byteOffset + sourceLength;
+
+  if (sourceEnd > slice.bytes.length) {
+    throw new InspectorError(`${label} exceeds its bufferView.`);
+  }
+
+  const out = Buffer.allocUnsafe(survivors.length * FLOAT32_BYTE_LENGTH);
+  let min = Infinity;
+  let max = -Infinity;
+
+  for (let index = 0; index < survivors.length; index++) {
+    const sourceIndex = survivors[index];
+    if (
+      !Number.isInteger(sourceIndex) ||
+      sourceIndex < 0 ||
+      sourceIndex >= accessor.count
+    ) {
+      throw new InspectorError(`${label} survivor index is out of range.`);
+    }
+
+    const value = slice.bytes.readFloatLE(
+      byteOffset + sourceIndex * byteStride,
+    );
+    out.writeFloatLE(value, index * FLOAT32_BYTE_LENGTH);
+    if (value < min) min = value;
+    if (value > max) max = value;
+  }
+
+  accessor.count = survivors.length;
+  delete accessor.byteOffset;
+  delete bufferView.byteStride;
+  if (survivors.length > 0) {
+    accessor.min = [min];
+    accessor.max = [max];
+  }
+
+  return {
+    bufferIndex: slice.bufferIndex,
+    bufferViewIndex: accessor.bufferView,
+    bytes: out,
+    end: slice.end,
+    start: slice.start,
+  };
+}
+
+function addGaussianSplatOpacityAccessorReplacements(
+  resource,
+  descriptors,
+  survivors,
+  replacementsByBuffer,
+) {
+  if (!(survivors instanceof Uint32Array) || survivors.length === 0) {
+    return 0;
+  }
+
+  const opacityAccessors = new Set();
+  descriptors.forEach((descriptor) => {
+    const primitive = getPrimitiveForDescriptor(resource, descriptor);
+    const accessorIndex = getGaussianSplatOpacityAccessorIndex(primitive);
+    if (accessorIndex !== null) {
+      opacityAccessors.add(accessorIndex);
+    }
+  });
+
+  let replacementCount = 0;
+  opacityAccessors.forEach((accessorIndex) => {
+    const replacement = makeFloat32ScalarAccessorSubsetReplacement(
+      resource,
+      accessorIndex,
+      survivors,
+    );
+    if (!replacementsByBuffer.has(replacement.bufferIndex)) {
+      replacementsByBuffer.set(replacement.bufferIndex, []);
+    }
+    addReplacement(replacementsByBuffer.get(replacement.bufferIndex), replacement);
+    replacementCount += 1;
+  });
+
+  return replacementCount;
+}
+
 async function processGltfResource({
   THREE,
   filePath,
@@ -679,6 +832,15 @@ async function processGltfResource({
       continue;
     }
     if (Number.isInteger(rewrite.survivorCount)) {
+      if (rewrite.deleted > 0) {
+        modified =
+          addGaussianSplatOpacityAccessorReplacements(
+            resource,
+            viewDescriptors,
+            rewrite.survivors,
+            replacementsByBuffer,
+          ) > 0 || modified;
+      }
       modified =
         updateGaussianPrimitiveAccessorCounts(
           resource,

package/src/server/splatCrop/worker.js

@@ -345,6 +345,7 @@ function rewriteSpzBytes({
     deleted,
     empty: false,
     splatCount: parsed.sourceCount,
+    survivors,
     survivorCount: survivors.length,
   };
 }
@@ -373,6 +374,11 @@ parentPort.on('message', async (message) => {
       bytes = getTransferableBytes(result.bytes);
       transferList.push(bytes.buffer);
     }
+    let survivors = null;
+    if (result.survivors) {
+      survivors = result.survivors;
+      transferList.push(survivors.buffer);
+    }
 
     parentPort.postMessage(
       {
@@ -383,6 +389,7 @@ parentPort.on('message', async (message) => {
           deleted: result.deleted,
           empty: result.empty,
           splatCount: result.splatCount,
+          survivors,
           survivorCount: result.survivorCount,
         },
       },

package/src/server/splatCrop/workerPool.js

@@ -110,6 +110,8 @@ class SplatCropWorkerPool {
         deleted: Number(result.deleted || 0),
         empty: !!result.empty,
         splatCount: Number(result.splatCount || 0),
+        survivors:
+          result.survivors instanceof Uint32Array ? result.survivors : null,
         survivorCount: Number(result.survivorCount || 0),
       });
     }