Merge pull request #2592 from finetjul/improve-edge-locator-perfs

finetjul · web-flow · commit 19ed33d61036 · 2022-10-30T22:13:53.000+01:00
fix(imagemarchingcubes): avoid duplicated points in marching cubes al…
diff --git a/Sources/Common/DataModel/EdgeLocator/index.d.ts b/Sources/Common/DataModel/EdgeLocator/index.d.ts
@@ -0,0 +1,78 @@
+/**
+ *
+ */
+export interface IEdgeLocatorInitialValues {
+	oriented?: boolean;
+}
+
+export interface vtkEdgeLocator {
+	/**
+	 * Remove all the edges previously added.
+	 */
+	 initialize(): void;
+
+	/**
+	 * Returns the inserted edge or null if no edge was inserted.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @return {key, edgeId, value} or null
+	 */
+	isInsertedEdge(pointId0: number, pointId1: number): { key: any; edgeId: number; value?: any } | null;
+
+	/**
+	 * Insert edge if it does not already exist.
+	 * Returns the existing or newly inserted edge.
+	 *
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {any} value Optional value option
+	 * @return {key, edgeId, value}
+	 * @see insertEdge()
+	 * @see isInsertedEdge()
+	 */
+	insertUniqueEdge(
+		pointId0: number,
+		pointId1: number,
+		value?: any
+	): { key: any; edgeId: number; value?: any };
+
+	/**
+	 * Insert edge. If the edge already exists, it is overwritten by this
+	 * new edge. You may verify that the edge did not previously exist with
+	 * `isInsertedEdge()`.
+	 * Returns the newly inserted edge.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {any} value Optional value option
+	 * @return {key, edgeId, value} or null
+	 * @see isInsertedEdge
+	 * @see insertUniqueEdge
+	 */
+	insertEdge(pointId0: number,
+		pointId1: number,
+		value?: any
+	): { key: any; edgeId: number; value?: any };
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkEdgeLocator
+ * @param {IEdgeLocatorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IEdgeLocatorInitialValues
+): vtkEdgeLocator;
+
+/**
+ * vtkEdgeLocator
+ */
+export declare const vtkEdgeLocator: {
+	newInstance: typeof newInstance;
+};
+
+export default vtkEdgeLocator;
diff --git a/Sources/Common/DataModel/EdgeLocator/index.js b/Sources/Common/DataModel/EdgeLocator/index.js
@@ -0,0 +1,56 @@
+class EdgeLocator {
+  constructor(oriented = false) {
+    this.oriented = oriented;
+    this.edgeMap = new Map();
+  }
+
+  initialize() {
+    this.edgeMap.clear();
+  }
+
+  computeEdgeKey(pointId0, pointId1) {
+    return this.oriented || pointId0 < pointId1
+      ? // Cantor pairing function:
+        0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1
+      : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+  }
+
+  insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+    // Generate a unique key
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    let node = this.edgeMap.get(key);
+    if (!node) {
+      // Didn't find key, so add a new edge entry
+      node = { key, edgeId: this.edgeMap.size, value: newEdgeValue };
+      this.edgeMap.set(key, node);
+    }
+    return node;
+  }
+
+  insertEdge(pointId0, pointId1, newEdgeValue) {
+    // Generate a unique key
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    // Didn't find key, so add a new edge entry
+    const node = { key, edgeId: this.edgeMap.size, value: newEdgeValue };
+    this.edgeMap.set(key, node);
+    return node;
+  }
+
+  isInsertedEdge(pointId0, pointId1) {
+    const key = this.computeEdgeKey(pointId0, pointId1);
+    return this.edgeMap.get(key);
+  }
+
+  static getEdgePointIds(node) {
+    const n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+    const pointId0 = node.key - 0.5 * (n + 1) * n;
+    const pointId1 = n - pointId0;
+    return [pointId0, pointId1];
+  }
+}
+
+function newInstance(initialValues = {}) {
+  return new EdgeLocator(initialValues.oriented);
+}
+
+export default { newInstance };
diff --git a/Sources/Common/DataModel/EdgeLocator/test/testEdgeLocator.js b/Sources/Common/DataModel/EdgeLocator/test/testEdgeLocator.js
@@ -0,0 +1,44 @@
+import test from 'tape-catch';
+
+import vtkEdgeLocator from 'vtk.js/Sources/Common/DataModel/EdgeLocator';
+
+test('Test unique edge', (t) => {
+  const edgeLocator = vtkEdgeLocator.newInstance();
+  const edge = edgeLocator.insertUniqueEdge(10, 13);
+  t.ok(edge != null, 'First edge');
+  t.equal(edge.edgeId, 0, 'Edge id');
+
+  const sameEdge = edgeLocator.insertUniqueEdge(10, 13);
+  t.ok(sameEdge === edge, 'Same edge');
+  const oppositeEdge = edgeLocator.insertUniqueEdge(13, 10);
+  t.ok(oppositeEdge === edge, 'Opposite edge');
+  t.equal(oppositeEdge.edgeId, 0, 'Opposite edge id');
+
+  const otherEdge = edgeLocator.insertUniqueEdge(11, 13);
+  t.ok(otherEdge != null);
+  t.ok(otherEdge !== edge);
+  t.equal(otherEdge.edgeId, 1);
+
+  const edgeWithValue = edgeLocator.insertUniqueEdge(12, 13, 42);
+  t.equal(edgeWithValue.value, 42, 'edge with value 42');
+
+  edgeWithValue.value = 54;
+  const sameEdgeWithValue = edgeLocator.insertUniqueEdge(12, 13);
+  t.equal(sameEdgeWithValue.value, 54, 'same edge with value 54');
+
+  t.end();
+});
+
+test('Test oriented edge', (t) => {
+  const edgeLocator = vtkEdgeLocator.newInstance({ oriented: true });
+  const edge = edgeLocator.insertUniqueEdge(10, 13);
+  t.ok(edge != null, 'First oriented edge');
+  t.equal(edge.edgeId, 0, 'Oriented edge Id');
+  const sameEdge = edgeLocator.insertUniqueEdge(10, 13);
+  t.ok(sameEdge === edge, 'Same oriented edge');
+  const oppositeEdge = edgeLocator.insertUniqueEdge(13, 10);
+  t.ok(oppositeEdge !== edge, 'Opposite edge');
+  t.equal(oppositeEdge.edgeId, 1, 'Opposite edge id');
+
+  t.end();
+});
diff --git a/Sources/Filters/General/ClipClosedSurface/ccsEdgeLocator.js b/Sources/Filters/General/ClipClosedSurface/ccsEdgeLocator.js
diff --git a/Sources/Filters/General/ClipClosedSurface/index.js b/Sources/Filters/General/ClipClosedSurface/index.js
@@ -7,9 +7,9 @@ import vtkPoints from 'vtk.js/Sources/Common/Core/Points';
 import vtkDataSetAttributes from 'vtk.js/Sources/Common/DataModel/DataSetAttributes';
 import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
 import vtkContourTriangulator from 'vtk.js/Sources/Filters/General/ContourTriangulator';
+import vtkEdgeLocator from 'vtk.js/Sources/Common/DataModel/EdgeLocator';
 
 import Constants from './Constants';
-import CCSEdgeLocator from './ccsEdgeLocator';
 
 const { vtkErrorMacro, capitalize } = macro;
 const { ScalarMode } = Constants;
@@ -71,9 +71,9 @@ function vtkClipClosedSurface(publicAPI, model) {
     // After the above swap, i0 will be kept, and i1 will be clipped
 
     // Check to see if this point has already been computed
-    const node = locator.insertUniqueEdge(i0, i1);
-    if (node.edgeId !== -1) {
-      return node.edgeId;
+    const edge = locator.insertUniqueEdge(i0, i1);
+    if (edge.value != null) {
+      return edge.value;
     }
 
     // Get the edge and interpolate the new point
@@ -94,28 +94,28 @@ function vtkClipClosedSurface(publicAPI, model) {
 
     // Make sure that new point is far enough from kept point
     if (vtkMath.distance2BetweenPoints(p, p0) < tol2) {
-      node.edgeId = i0;
+      edge.value = i0;
       return i0;
     }
 
     if (vtkMath.distance2BetweenPoints(p, p1) < tol2) {
-      node.edgeId = i1;
+      edge.value = i1;
       return i1;
     }
 
-    node.edgeId = points.insertNextTuple(p);
-    pointData.interpolateData(pointData, i0, i1, node.edgeId, t);
+    edge.value = points.insertNextTuple(p);
+    pointData.interpolateData(pointData, i0, i1, edge.value, t);
 
-    return node.edgeId;
+    return edge.value;
   }
 
   /**
    * Method for clipping lines and copying the scalar data.
    *
    * @param {vtkPoints} points
    * @param {vtkDataArray} pointScalars
-   * @param {vtvtkDataSetAttributesk} pointData
-   * @param {CCSEdgeLocator} edgeLocator
+   * @param {vtkDataSetAttributesk} pointData
+   * @param {vtkEdgeLocator} edgeLocator
    * @param {vtkCellArray} inputLines
    * @param {vtkCellArray} outputLines
    * @param {vtkDataSetAttributes} inLineData
@@ -394,7 +394,7 @@ function vtkClipClosedSurface(publicAPI, model) {
    * @param {vtkPoints} points
    * @param {vtkDataArray} pointScalars
    * @param {vtkDataSetAttributes} pointData
-   * @param {CCSEdgeLocator} edgeLocator
+   * @param {vtkEdgeLocator} edgeLocator
    * @param {Number} triangulate
    * @param {vtkCellArray} inputPolys
    * @param {vtkCellArray} outputPolys
@@ -670,7 +670,7 @@ function vtkClipClosedSurface(publicAPI, model) {
     }
 
     // An edge locator to avoid point duplication while clipping
-    const edgeLocator = new CCSEdgeLocator();
+    const edgeLocator = vtkEdgeLocator.newInstance();
 
     // A temporary polydata for the contour lines that are triangulated
     const tmpContourData = vtkPolyData.newInstance();
diff --git a/Sources/Filters/General/ImageMarchingCubes/index.js b/Sources/Filters/General/ImageMarchingCubes/index.js
@@ -1,5 +1,6 @@
 import macro from 'vtk.js/Sources/macros';
 import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
+import vtkEdgeLocator from 'vtk.js/Sources/Common/DataModel/EdgeLocator';
 import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
 import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
 
@@ -19,7 +20,7 @@ function vtkImageMarchingCubes(publicAPI, model) {
   const voxelScalars = [];
   const voxelGradients = [];
   const voxelPts = [];
-  const edgeMap = new Map();
+  const edgeLocator = vtkEdgeLocator.newInstance();
 
   // Retrieve scalars and voxel coordinates. i-j-k is origin of voxel.
   publicAPI.getVoxelScalars = (i, j, k, slice, dims, origin, spacing, s) => {
@@ -213,8 +214,6 @@ function vtkImageMarchingCubes(publicAPI, model) {
     const xyz = [];
     const n = [];
     let pId;
-    let tmp;
-    const edge = [];
 
     publicAPI.getVoxelScalars(i, j, k, slice, dims, origin, spacing, scalars);
 
@@ -247,14 +246,10 @@ function vtkImageMarchingCubes(publicAPI, model) {
         const edgeVerts = vtkCaseTable.getEdge(voxelTris[idx + eid]);
         pId = undefined;
         if (model.mergePoints) {
-          edge[0] = ids[edgeVerts[0]];
-          edge[1] = ids[edgeVerts[1]];
-          if (edge[0] > edge[1]) {
-            tmp = edge[0];
-            edge[0] = edge[1];
-            edge[1] = tmp;
-          }
-          pId = edgeMap.get(edge);
+          pId = edgeLocator.isInsertedEdge(
+            ids[edgeVerts[0]],
+            ids[edgeVerts[1]]
+          )?.value;
         }
         if (pId === undefined) {
           const t =
@@ -285,14 +280,7 @@ function vtkImageMarchingCubes(publicAPI, model) {
           }
 
           if (model.mergePoints) {
-            edge[0] = ids[edgeVerts[0]];
-            edge[1] = ids[edgeVerts[1]];
-            if (edge[0] > edge[1]) {
-              tmp = edge[0];
-              edge[0] = edge[1];
-              edge[1] = tmp;
-            }
-            edgeMap[edge] = pId;
+            edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
           }
         }
         tris.push(pId);
diff --git a/Sources/Filters/General/ImageMarchingSquares/index.js b/Sources/Filters/General/ImageMarchingSquares/index.js
