3dtiles-inspector 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on Keep a Changelog and this project follows Semantic Versio
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-04-27
+
+### Changed
+
+- Changed `Layer Multiplier` to use the tileset-wide minimum leaf geometric error as the baseline, so non-minimum leaf tiles are scaled too.
+
+## [0.1.6] - 2026-04-27
+
+### Changed
+
+- Changed `Layer Multiplier` to scale each tile's geometric-error difference from its leaf baseline instead of applying a depth-based multiplier.
+- Expanded the `Layer Multiplier` range to `1/8x` through `8x`.
+
 ## [0.1.5] - 2026-04-27
 
 ### Added

package/README.md

@@ -76,13 +76,15 @@ const {
 
 ## Inspector Features
 
+<img src="https://raw.githubusercontent.com/WilliamLiu-1997/3DTiles-Inspector/main/screenshot.png" alt="screenshot" width="960" />
+
 - `Translate`, `Rotate`, and `Reset` for root transform edits
 - `Move Camera` to a WGS84 latitude / longitude / height
 - `Move Tiles` to relocate the tileset root with an ENU-aligned transform
 - `Set Position` to click the globe, terrain, or loaded tiles and place the tileset there
 - `Terrain` to toggle Cesium World Terrain while keeping satellite imagery
 - `Geometric Error` scaling from `1/16x` to `16x`
-- `Layer Multiplier` scaling from `1/1.5x` to `1.5x` for leaf-based geometric error changes between tile depths
+- `Layer Multiplier` scaling from `1/8x` to `8x` for each tile's geometric-error difference from the tileset's global leaf baseline
 - `Save` to persist the updated root transform and geometric-error scale back to disk
 
 If `build_summary.json` exists next to the root tileset, `Save` also updates:

package/dist/inspector-assets/viewer/app.js

@@ -65496,14 +65496,9 @@ var saveButton = document.getElementById("save");
 var GEOMETRIC_ERROR_SCALE_MIN_EXPONENT = -4;
 var GEOMETRIC_ERROR_SCALE_MAX_EXPONENT = 4;
 var GEOMETRIC_ERROR_SCALE_STEP = 0.1;
-var GEOMETRIC_ERROR_LAYER_SCALE_MAX = 1.5;
-var GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -Math.log2(
-  GEOMETRIC_ERROR_LAYER_SCALE_MAX
-);
-var GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = Math.log2(
-  GEOMETRIC_ERROR_LAYER_SCALE_MAX
-);
-var GEOMETRIC_ERROR_LAYER_SCALE_STEP = "any";
+var GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -3;
+var GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = 3;
+var GEOMETRIC_ERROR_LAYER_SCALE_STEP = 0.1;
 var DEFAULT_ERROR_TARGET = 16;
 var DEFAULT_TERRAIN_ERROR_TARGET = 16;
 var RUNTIME_STATS_UPDATE_INTERVAL_MS = 250;
@@ -65860,22 +65855,6 @@ function getEffectiveGeometricErrorScale() {
 function getEffectiveGeometricErrorLayerScale() {
   return lastSavedGeometricErrorLayerScale * geometricErrorLayerScale;
 }
-function getKnownTileLeafDistance(tile, visited = /* @__PURE__ */ new Set()) {
-  if (!tile || typeof tile !== "object" || visited.has(tile)) {
-    return 0;
-  }
-  visited.add(tile);
-  let maxDistance = 0;
-  const children = Array.isArray(tile.children) ? tile.children : [];
-  for (const child of children) {
-    maxDistance = Math.max(
-      maxDistance,
-      getKnownTileLeafDistance(child, visited) + 1
-    );
-  }
-  visited.delete(tile);
-  return maxDistance;
-}
 function getOriginalTileGeometricError(tile) {
   if (!tile || typeof tile !== "object") {
     return null;
@@ -65889,21 +65868,52 @@ function getOriginalTileGeometricError(tile) {
   }
   return originalTileGeometricErrors.get(tile);
 }
-function applyGeometricErrorLayerScaleToTile(tile) {
+function getKnownTileLeafGeometricError(tile, visited = /* @__PURE__ */ new Set()) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  if (originalGeometricError === null || !tile || typeof tile !== "object" || visited.has(tile)) {
+    return originalGeometricError;
+  }
+  visited.add(tile);
+  let leafGeometricError = null;
+  const children = Array.isArray(tile.children) ? tile.children : [];
+  for (const child of children) {
+    const childLeafGeometricError = getKnownTileLeafGeometricError(
+      child,
+      visited
+    );
+    if (childLeafGeometricError !== null) {
+      leafGeometricError = leafGeometricError === null ? childLeafGeometricError : Math.min(leafGeometricError, childLeafGeometricError);
+    }
+  }
+  visited.delete(tile);
+  return leafGeometricError === null ? originalGeometricError : leafGeometricError;
+}
+function getGlobalTileLeafGeometricError(tile) {
+  const rootLeafGeometricError = tiles?.root ? getKnownTileLeafGeometricError(tiles.root) : null;
+  const tileLeafGeometricError = getKnownTileLeafGeometricError(tile);
+  if (rootLeafGeometricError === null) {
+    return tileLeafGeometricError;
+  }
+  if (tileLeafGeometricError === null) {
+    return rootLeafGeometricError;
+  }
+  return Math.min(rootLeafGeometricError, tileLeafGeometricError);
+}
+function applyGeometricErrorLayerScaleToTile(tile, leafGeometricError = getGlobalTileLeafGeometricError(tile)) {
   const originalGeometricError = getOriginalTileGeometricError(tile);
-  if (originalGeometricError === null) {
+  if (originalGeometricError === null || leafGeometricError === null) {
     return;
   }
-  const leafDistance = getKnownTileLeafDistance(tile);
-  tile.geometricError = originalGeometricError * getEffectiveGeometricErrorLayerScale() ** leafDistance;
+  tile.geometricError = leafGeometricError + (originalGeometricError - leafGeometricError) * getEffectiveGeometricErrorLayerScale();
 }
 function applyGeometricErrorLayerScaleToTileset() {
   if (!tiles) {
     return;
   }
+  const leafGeometricError = getGlobalTileLeafGeometricError(tiles.root);
   tiles.traverse(
     (tile) => {
-      applyGeometricErrorLayerScaleToTile(tile);
+      applyGeometricErrorLayerScaleToTile(tile, leafGeometricError);
       return false;
     },
     null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "3dtiles-inspector",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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",

package/src/viewer/app.js

@@ -112,14 +112,9 @@ const saveButton = document.getElementById('save');
 const GEOMETRIC_ERROR_SCALE_MIN_EXPONENT = -4;
 const GEOMETRIC_ERROR_SCALE_MAX_EXPONENT = 4;
 const GEOMETRIC_ERROR_SCALE_STEP = 0.1;
-const GEOMETRIC_ERROR_LAYER_SCALE_MAX = 1.5;
-const GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -Math.log2(
-  GEOMETRIC_ERROR_LAYER_SCALE_MAX,
-);
-const GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = Math.log2(
-  GEOMETRIC_ERROR_LAYER_SCALE_MAX,
-);
-const GEOMETRIC_ERROR_LAYER_SCALE_STEP = 'any';
+const GEOMETRIC_ERROR_LAYER_SCALE_MIN_EXPONENT = -3;
+const GEOMETRIC_ERROR_LAYER_SCALE_MAX_EXPONENT = 3;
+const GEOMETRIC_ERROR_LAYER_SCALE_STEP = 0.1;
 const DEFAULT_ERROR_TARGET = 16;
 const DEFAULT_TERRAIN_ERROR_TARGET = 16;
 const RUNTIME_STATS_UPDATE_INTERVAL_MS = 250;
@@ -537,24 +532,6 @@ function getEffectiveGeometricErrorLayerScale() {
   return lastSavedGeometricErrorLayerScale * geometricErrorLayerScale;
 }
 
-function getKnownTileLeafDistance(tile, visited = new Set()) {
-  if (!tile || typeof tile !== 'object' || visited.has(tile)) {
-    return 0;
-  }
-
-  visited.add(tile);
-  let maxDistance = 0;
-  const children = Array.isArray(tile.children) ? tile.children : [];
-  for (const child of children) {
-    maxDistance = Math.max(
-      maxDistance,
-      getKnownTileLeafDistance(child, visited) + 1,
-    );
-  }
-  visited.delete(tile);
-  return maxDistance;
-}
-
 function getOriginalTileGeometricError(tile) {
   if (!tile || typeof tile !== 'object') {
     return null;
@@ -571,16 +548,68 @@ function getOriginalTileGeometricError(tile) {
   return originalTileGeometricErrors.get(tile);
 }
 
-function applyGeometricErrorLayerScaleToTile(tile) {
+function getKnownTileLeafGeometricError(tile, visited = new Set()) {
+  const originalGeometricError = getOriginalTileGeometricError(tile);
+  if (
+    originalGeometricError === null ||
+    !tile ||
+    typeof tile !== 'object' ||
+    visited.has(tile)
+  ) {
+    return originalGeometricError;
+  }
+
+  visited.add(tile);
+  let leafGeometricError = null;
+  const children = Array.isArray(tile.children) ? tile.children : [];
+  for (const child of children) {
+    const childLeafGeometricError = getKnownTileLeafGeometricError(
+      child,
+      visited,
+    );
+    if (childLeafGeometricError !== null) {
+      leafGeometricError =
+        leafGeometricError === null
+          ? childLeafGeometricError
+          : Math.min(leafGeometricError, childLeafGeometricError);
+    }
+  }
+  visited.delete(tile);
+  return leafGeometricError === null
+    ? originalGeometricError
+    : leafGeometricError;
+}
+
+function getGlobalTileLeafGeometricError(tile) {
+  const rootLeafGeometricError = tiles?.root
+    ? getKnownTileLeafGeometricError(tiles.root)
+    : null;
+  const tileLeafGeometricError = getKnownTileLeafGeometricError(tile);
+
+  if (rootLeafGeometricError === null) {
+    return tileLeafGeometricError;
+  }
+
+  if (tileLeafGeometricError === null) {
+    return rootLeafGeometricError;
+  }
+
+  return Math.min(rootLeafGeometricError, tileLeafGeometricError);
+}
+
+function applyGeometricErrorLayerScaleToTile(
+  tile,
+  leafGeometricError = getGlobalTileLeafGeometricError(tile),
+) {
   const originalGeometricError = getOriginalTileGeometricError(tile);
-  if (originalGeometricError === null) {
+  if (originalGeometricError === null || leafGeometricError === null) {
     return;
   }
 
-  const leafDistance = getKnownTileLeafDistance(tile);
   tile.geometricError =
-    originalGeometricError *
-    getEffectiveGeometricErrorLayerScale() ** leafDistance;
+    leafGeometricError +
+    (originalGeometricError - leafGeometricError) *
+      getEffectiveGeometricErrorLayerScale();
 }
 
 function applyGeometricErrorLayerScaleToTileset() {
@@ -588,9 +617,10 @@ function applyGeometricErrorLayerScaleToTileset() {
     return;
   }
 
+  const leafGeometricError = getGlobalTileLeafGeometricError(tiles.root);
   tiles.traverse(
     (tile) => {
-      applyGeometricErrorLayerScaleToTile(tile);
+      applyGeometricErrorLayerScaleToTile(tile, leafGeometricError);
       return false;
     },
     null,

package/src/viewer/session.js

@@ -174,7 +174,14 @@ function normalizePositiveFinite(value, name) {
   return number;
 }
 
-function scaleGeometricErrorValue(target, key, scale, label) {
+function scaleGeometricErrorValue(
+  target,
+  key,
+  geometricErrorScale,
+  geometricErrorLayerScale,
+  leafGeometricError,
+  label,
+) {
   if (target[key] == null) {
     return;
   }
@@ -184,7 +191,14 @@ function scaleGeometricErrorValue(target, key, scale, label) {
     throw new InspectorError(`${label} must be a finite number.`);
   }
 
-  const next = number * scale;
+  if (!Number.isFinite(leafGeometricError)) {
+    throw new InspectorError(`${label} leaf geometricError must be finite.`);
+  }
+
+  const adjusted =
+    leafGeometricError +
+    (number - leafGeometricError) * geometricErrorLayerScale;
+  const next = adjusted * geometricErrorScale;
   if (!Number.isFinite(next)) {
     throw new InspectorError(`${label} scaled value must be finite.`);
   }
@@ -192,20 +206,6 @@ function scaleGeometricErrorValue(target, key, scale, label) {
   target[key] = next;
 }
 
-function getGeometricErrorScaleForLeafDistance(
-  geometricErrorScale,
-  geometricErrorLayerScale,
-  leafDistance,
-  label,
-) {
-  const scale =
-    geometricErrorScale * geometricErrorLayerScale ** Math.max(0, leafDistance);
-  if (!Number.isFinite(scale)) {
-    throw new InspectorError(`${label} scale must be a finite number.`);
-  }
-  return scale;
-}
-
 function assertTilesetPathInsideRoot(resolvedPath, rootDir) {
   if (
     resolvedPath !== rootDir &&
@@ -250,15 +250,15 @@ function getLocalExternalTilesetPaths(tile, baseDir) {
   return paths;
 }
 
-function getTilesetRootLeafDistance(
+function getTilesetRootLeafGeometricError(
   tilesetPath,
   rootDir,
-  leafDistanceCache,
+  leafGeometricErrorCache,
   stack,
 ) {
   const resolvedPath = path.resolve(tilesetPath);
-  if (leafDistanceCache.has(resolvedPath)) {
-    return leafDistanceCache.get(resolvedPath);
+  if (leafGeometricErrorCache.has(resolvedPath)) {
+    return leafGeometricErrorCache.get(resolvedPath);
   }
 
   if (stack.has(resolvedPath)) {
@@ -279,56 +279,72 @@ function getTilesetRootLeafDistance(
   }
 
   stack.add(resolvedPath);
-  const leafDistance = getTileLeafDistance(
+  const leafGeometricError = getTileLeafGeometricError(
     tileset.root,
     path.dirname(resolvedPath),
     rootDir,
-    leafDistanceCache,
+    leafGeometricErrorCache,
     stack,
   );
   stack.delete(resolvedPath);
-  leafDistanceCache.set(resolvedPath, leafDistance);
-  return leafDistance;
+  leafGeometricErrorCache.set(resolvedPath, leafGeometricError);
+  return leafGeometricError;
 }
 
-function getTileLeafDistance(tile, baseDir, rootDir, leafDistanceCache, stack) {
+function getTileLeafGeometricError(
+  tile,
+  baseDir,
+  rootDir,
+  leafGeometricErrorCache,
+  stack,
+) {
   if (!tile || typeof tile !== 'object') {
     return 0;
   }
 
-  let maxDistance = 0;
+  const ownGeometricError = Number(tile.geometricError);
+  if (!Number.isFinite(ownGeometricError)) {
+    return 0;
+  }
+
+  let leafGeometricError = null;
   if (Array.isArray(tile.children)) {
     tile.children.forEach((child) => {
-      maxDistance = Math.max(
-        maxDistance,
-        getTileLeafDistance(child, baseDir, rootDir, leafDistanceCache, stack) +
-          1,
+      const childLeafGeometricError = getTileLeafGeometricError(
+        child,
+        baseDir,
+        rootDir,
+        leafGeometricErrorCache,
+        stack,
       );
+      leafGeometricError =
+        leafGeometricError === null
+          ? childLeafGeometricError
+          : Math.min(leafGeometricError, childLeafGeometricError);
     });
   }
 
   getLocalExternalTilesetPaths(tile, baseDir).forEach((childTilesetPath) => {
-    maxDistance = Math.max(
-      maxDistance,
-      getTilesetRootLeafDistance(
-        childTilesetPath,
-        rootDir,
-        leafDistanceCache,
-        stack,
-      ) + 1,
+    const childLeafGeometricError = getTilesetRootLeafGeometricError(
+      childTilesetPath,
+      rootDir,
+      leafGeometricErrorCache,
+      stack,
     );
+    leafGeometricError =
+      leafGeometricError === null
+        ? childLeafGeometricError
+        : Math.min(leafGeometricError, childLeafGeometricError);
   });
 
-  return maxDistance;
+  return leafGeometricError === null ? ownGeometricError : leafGeometricError;
 }
 
 function scaleTilesetGeometricErrors(
   tile,
   geometricErrorScale,
   geometricErrorLayerScale,
-  baseDir,
-  rootDir,
-  leafDistanceCache,
+  leafGeometricError,
   pathLabel = 'tileset.root',
 ) {
   if (!tile || typeof tile !== 'object') {
@@ -338,12 +354,9 @@ function scaleTilesetGeometricErrors(
   scaleGeometricErrorValue(
     tile,
     'geometricError',
-    getGeometricErrorScaleForLeafDistance(
-      geometricErrorScale,
-      geometricErrorLayerScale,
-      getTileLeafDistance(tile, baseDir, rootDir, leafDistanceCache, new Set()),
-      pathLabel,
-    ),
+    geometricErrorScale,
+    geometricErrorLayerScale,
+    leafGeometricError,
     `${pathLabel}.geometricError`,
   );
 
@@ -356,9 +369,7 @@ function scaleTilesetGeometricErrors(
       child,
       geometricErrorScale,
       geometricErrorLayerScale,
-      baseDir,
-      rootDir,
-      leafDistanceCache,
+      leafGeometricError,
       `${pathLabel}.children[${index}]`,
     );
   });
@@ -406,7 +417,8 @@ function updateTilesetJsonFile(
     geometricErrorScale,
     rootDir,
     rootTransform = null,
-    leafDistanceCache = new Map(),
+    leafGeometricErrorCache = new Map(),
+    globalLeafGeometricError = null,
   },
   visited = new Set(),
 ) {
@@ -434,30 +446,30 @@ function updateTilesetJsonFile(
   }
 
   const tilesetDir = path.dirname(resolvedPath);
+  const effectiveLeafGeometricError =
+    globalLeafGeometricError == null
+      ? getTileLeafGeometricError(
+          tileset.root,
+          tilesetDir,
+          rootDir,
+          leafGeometricErrorCache,
+          new Set(),
+        )
+      : globalLeafGeometricError;
+
   scaleGeometricErrorValue(
     tileset,
     'geometricError',
-    getGeometricErrorScaleForLeafDistance(
-      geometricErrorScale,
-      geometricErrorLayerScale,
-      getTileLeafDistance(
-        tileset.root,
-        tilesetDir,
-        rootDir,
-        leafDistanceCache,
-        new Set(),
-      ),
-      resolvedPath,
-    ),
+    geometricErrorScale,
+    geometricErrorLayerScale,
+    effectiveLeafGeometricError,
     `${resolvedPath}.geometricError`,
   );
   scaleTilesetGeometricErrors(
     tileset.root,
     geometricErrorScale,
     geometricErrorLayerScale,
-    tilesetDir,
-    rootDir,
-    leafDistanceCache,
+    effectiveLeafGeometricError,
     `${resolvedPath}.root`,
   );
   writeJsonAtomic(resolvedPath, tileset);
@@ -470,7 +482,8 @@ function updateTilesetJsonFile(
       {
         geometricErrorLayerScale,
         geometricErrorScale,
-        leafDistanceCache,
+        leafGeometricErrorCache,
+        globalLeafGeometricError: effectiveLeafGeometricError,
         rootDir,
       },
       visited,
@@ -936,8 +949,8 @@ function buildViewerHtml(viewerConfig) {
       .toolbar {
         display: grid;
         align-content: start;
-        gap: 10px;
-        padding: 14px;
+        gap: 8px;
+        padding: 10px 14px;
         border: 1px solid rgba(22, 50, 79, 0.12);
         border-top: 0;
         border-radius: 0 0 20px 20px;
@@ -1102,7 +1115,7 @@ function buildViewerHtml(viewerConfig) {
 
       .range-field {
         display: grid;
-        gap: 8px;
+        gap: 4px;
         min-width: 0;
       }
 
@@ -1316,9 +1329,9 @@ function buildViewerHtml(viewerConfig) {
             <input
               id="geometric-error-layer-scale"
               type="range"
-              min="-0.5849625007211562"
-              max="0.5849625007211562"
-              step="any"
+              min="-3"
+              max="3"
+              step="0.1"
               value="0"
             />
           </label>