feat(segmentation_user_layer) implemented getObjectPosition for MeshLayer, finds the closest loaded associated mesh vertex to the global position

Author: chrisj

src/layer/segmentation/index.ts

@@ -41,7 +41,6 @@ import {
   MultiscaleMeshLayer,
   MultiscaleMeshSource,
 } from "#src/mesh/frontend.js";
-import type { RenderLayerTransform } from "#src/render_coordinate_transform.js";
 import {
   RenderScaleHistogram,
   trackableRenderScaleTarget,
@@ -108,6 +107,7 @@ import { DisplayOptionsTab } from "#src/ui/segmentation_display_options_tab.js";
 import { Uint64Map } from "#src/uint64_map.js";
 import { Uint64OrderedSet } from "#src/uint64_ordered_set.js";
 import { Uint64Set } from "#src/uint64_set.js";
+import { gatherUpdate } from "#src/util/array.js";
 import {
   packColor,
   parseRGBColorSpecification,
@@ -1229,13 +1229,31 @@ export class SegmentationUserLayer extends Base {
 
   moveToSegment(id: Uint64) {
     for (const layer of this.renderLayers) {
-      if (!(layer instanceof MultiscaleMeshLayer)) continue;
-      const layerPosition = layer.getObjectPosition(id);
-      if (layerPosition === undefined) continue;
-      this.setLayerPosition(
-        layer.displayState.transform.value as RenderLayerTransform,
-        layerPosition,
+      if (
+        !(layer instanceof MultiscaleMeshLayer || layer instanceof MeshLayer)
+      ) {
+        continue;
+      }
+      const transform = layer.displayState.transform.value;
+      if (transform.error !== undefined) return undefined;
+      const { rank, globalToRenderLayerDimensions } = transform;
+      const { globalPosition } = this.manager.root;
+      const globalLayerPosition = new Float32Array(rank);
+      const renderToGlobalLayerDimensions = [];
+      for (let i = 0; i < rank; i++) {
+        renderToGlobalLayerDimensions[globalToRenderLayerDimensions[i]] = i;
+      }
+      gatherUpdate(
+        globalLayerPosition,
+        globalPosition.value,
+        renderToGlobalLayerDimensions,
       );
+      const layerPosition =
+        layer instanceof MeshLayer
+          ? layer.getObjectPosition(id, globalLayerPosition)
+          : layer.getObjectPosition(id);
+      if (layerPosition === undefined) continue;
+      this.setLayerPosition(transform, layerPosition);
       return;
     }
     StatusMessage.showTemporaryMessage(

src/mesh/frontend.ts

@@ -582,6 +582,76 @@ export class MeshLayer extends PerspectiveViewRenderLayer<ThreeDimensionalRender
     );
     return ready;
   }
+
+  getObjectPosition(
+    id: Uint64,
+    nearestTo: Float32Array,
+  ): Float32Array | undefined {
+    const transform = this.displayState.transform.value;
+    if (transform.error !== undefined) return undefined;
+    const chunk = this.source.chunks.get(getObjectKey(id));
+    if (chunk === undefined) return undefined;
+    const { rank } = transform;
+    const inverseModelToRenderLayerTransform = new Float32Array(
+      transform.modelToRenderLayerTransform.length,
+    );
+    matrix.inverse(
+      inverseModelToRenderLayerTransform,
+      rank + 1,
+      transform.modelToRenderLayerTransform,
+      rank + 1,
+      rank + 1,
+    );
+    const nearestPositionInModal = new Float32Array(rank);
+    matrix.transformPoint(
+      nearestPositionInModal,
+      inverseModelToRenderLayerTransform,
+      rank + 1,
+      nearestTo,
+      rank,
+    );
+    const { fragmentIds } = chunk;
+    const closestVertex = new Float32Array(rank);
+    let closestDistanceSq = Number.POSITIVE_INFINITY;
+    for (const fragmentId of fragmentIds) {
+      const fragmentChunk = this.source.fragmentSource.chunks.get(fragmentId);
+      if (fragmentChunk === undefined) continue;
+      const { state, meshData } = fragmentChunk;
+      if (
+        state !== ChunkState.SYSTEM_MEMORY &&
+        state !== ChunkState.GPU_MEMORY
+      ) {
+        continue;
+      }
+      const { vertexPositions } = meshData;
+      if (vertexPositions.length < rank) continue;
+      for (let i = 0; i < vertexPositions.length; i += rank) {
+        let distanceSq = 0;
+        for (let j = 0; j < rank; j++) {
+          distanceSq += Math.pow(
+            vertexPositions[i + j] - nearestPositionInModal[j],
+            2,
+          );
+        }
+        if (distanceSq < closestDistanceSq) {
+          closestDistanceSq = distanceSq;
+          for (let j = 0; j < rank; j++) {
+            closestVertex[j] = vertexPositions[i + j];
+          }
+        }
+      }
+    }
+    if (closestDistanceSq === Number.POSITIVE_INFINITY) return undefined;
+    const layerCenter = new Float32Array(rank);
+    matrix.transformPoint(
+      layerCenter,
+      transform.modelToRenderLayerTransform,
+      rank + 1,
+      closestVertex,
+      rank,
+    );
+    return layerCenter;
+  }
 }
 
 export class ManifestChunk extends Chunk {