feat(cellpicker): add edge picking support

Author: bourdaisj

Sources/Common/DataModel/CellTypes/index.js

@@ -40,6 +40,14 @@ function isLinear(type) {
   );
 }
 
+function hasSubCells(cellType) {
+  return (
+    cellType === CellType.VTK_TRIANGLE_STRIP ||
+    cellType === CellType.VTK_POLY_LINE ||
+    cellType === CellType.VTK_POLY_VERTEX
+  );
+}
+
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
@@ -48,6 +56,7 @@ export const STATIC = {
   getClassNameFromTypeId,
   getTypeIdFromClassName,
   isLinear,
+  hasSubCells,
 };
 
 // ----------------------------------------------------------------------------

Sources/Common/DataModel/Line/index.js

@@ -63,15 +63,9 @@ function intersection(a1, a2, b1, b2, u, v) {
   v[0] = 0.0;
 
   // Determine line vectors.
-  a21[0] = a2[0] - a1[0];
-  a21[1] = a2[1] - a1[1];
-  a21[2] = a2[2] - a1[2];
-  b21[0] = b2[0] - b1[0];
-  b21[1] = b2[1] - b1[1];
-  b21[2] = b2[2] - b1[2];
-  b1a1[0] = b1[0] - a1[0];
-  b1a1[1] = b1[1] - a1[1];
-  b1a1[2] = b1[2] - a1[2];
+  vtkMath.subtract(a2, a1, a21);
+  vtkMath.subtract(b2, b1, b21);
+  vtkMath.subtract(b1, a1, b1a1);
 
   // Compute the system (least squares) matrix.
   const A = [];
@@ -217,6 +211,7 @@ function vtkLine(publicAPI, model) {
     }
     return outObj;
   };
+
   publicAPI.evaluatePosition = (
     x,
     closestPoint,
@@ -225,6 +220,20 @@ function vtkLine(publicAPI, model) {
     dist2,
     weights
   ) => {}; // virtual
+
+  publicAPI.evaluateLocation = (pcoords, x, weights) => {
+    const a1 = [];
+    const a2 = [];
+    model.points.getPoint(0, a1);
+    model.points.getPoint(1, a2);
+
+    for (let i = 0; i < 3; i++) {
+      x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);
+    }
+
+    weights[0] = 1.0 - pcoords[0];
+    weights[1] = pcoords[0];
+  };
 }
 
 // ----------------------------------------------------------------------------

Sources/Rendering/Core/CellPicker/index.js

@@ -1,15 +1,25 @@
 import macro from 'vtk.js/Sources/macros';
-import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
+import vtkCellTypes from 'vtk.js/Sources/Common/DataModel/CellTypes';
+import vtkLine from 'vtk.js/Sources/Common/DataModel/Line';
 import vtkPicker from 'vtk.js/Sources/Rendering/Core/Picker';
-import vtkPoints from 'vtk.js/Sources/Common/Core/Points';
+import vtkPolyLine from 'vtk.js/Sources/Common/DataModel/PolyLine';
 import vtkTriangle from 'vtk.js/Sources/Common/DataModel/Triangle';
-
+import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
+import { CellType } from 'vtk.js/Sources/Common/DataModel/CellTypes/Constants';
 import { vec3 } from 'gl-matrix';
 
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
+function createCellMap() {
+  return {
+    [CellType.VTK_LINE]: vtkLine.newInstance(),
+    [CellType.VTK_POLY_LINE]: vtkPolyLine.newInstance(),
+    [CellType.VTK_TRIANGLE]: vtkTriangle.newInstance(),
+  };
+}
+
 function clipLineWithPlane(mapper, matrix, p1, p2) {
   const outObj = { planeId: -1, t1: 0.0, t2: 1.0, intersect: 0 };
   const nbClippingPlanes = mapper.getNumberOfClippingPlanes();
@@ -238,8 +248,10 @@ function vtkCellPicker(publicAPI, model) {
     const minXYZ = [0, 0, 0];
     let pDistMin = Number.MAX_VALUE;
     const minPCoords = [0, 0, 0];
-    let minCellId = -1;
-    const minCell = vtkTriangle.newInstance();
+    let minCellId = null;
+    let minCell = null;
+    let minCellType = null;
+    let subId = null;
     const x = [];
     const data = mapper.getInputData();
     const isPolyData = 1;
@@ -263,31 +275,47 @@ function vtkCellPicker(publicAPI, model) {
     const locator = null;
     if (locator) {
       // TODO when cell locator will be implemented
-    } else if (data.getPolys) {
-      const cellObject = data.getPolys();
-      const points = data.getPoints();
-      const cellData = cellObject.getData();
-      let cellId = 0;
-      const pointsIdList = [-1, -1, -1];
-      const cell = vtkTriangle.newInstance();
-      const cellPoints = vtkPoints.newInstance();
-      // cross all cells
-      for (let i = 0; i < cellData.length; cellId++) {
+    } else if (data.getCells) {
+      if (!data.getCells()) {
+        data.buildLinks();
+      }
+
+      const tempCellMap = createCellMap();
+      const minCellMap = createCellMap();
+
+      const numberOfCells = data.getNumberOfCells();
+
+      for (let cellId = 0; cellId < numberOfCells; cellId++) {
         const pCoords = [0, 0, 0];
-        const nbPointsInCell = cellData[i++];
 
-        cellPoints.setNumberOfPoints(nbPointsInCell);
-        // Extract cell points
-        for (let j = 0; j < nbPointsInCell; j++) {
-          pointsIdList[j] = cellData[i++];
+        minCellType = data.getCellType(cellId);
+        const cell = tempCellMap[minCellType];
+
+        if (cell == null) {
+          // eslint-disable-next-line no-continue
+          continue;
         }
 
-        // Create cell from points
-        cell.initialize(points, pointsIdList);
+        minCell = minCellMap[minCellType];
+
+        data.getCell(cellId, cell);
 
         let cellPicked;
+
         if (isPolyData) {
-          cellPicked = cell.intersectWithLine(p1, p2, tol, x, pCoords);
+          if (vtkCellTypes.hasSubCells(minCellType)) {
+            cellPicked = cell.intersectWithLine(
+              t1,
+              t2,
+              p1,
+              p2,
+              tol,
+              x,
+              pCoords
+            );
+          } else {
+            cellPicked = cell.intersectWithLine(p1, p2, tol, x, pCoords);
+          }
         } else {
           cellPicked = cell.intersectWithLine(q1, q2, tol, x, pCoords);
           if (t1 !== 0.0 || t2 !== 1.0) {
@@ -302,9 +330,11 @@ function vtkCellPicker(publicAPI, model) {
           cellPicked.t <= t2
         ) {
           const pDist = cell.getParametricDistance(pCoords);
+
           if (pDist < pDistMin || (pDist === pDistMin && cellPicked.t < tMin)) {
             tMin = cellPicked.t;
             pDistMin = pDist;
+            subId = cellPicked.subId;
             minCellId = cellId;
             cell.deepCopy(minCell);
             for (let k = 0; k < 3; k++) {
@@ -324,7 +354,12 @@ function vtkCellPicker(publicAPI, model) {
         weights[i] = 0.0;
       }
       const point = [];
-      minCell.evaluateLocation(minPCoords, point, weights);
+
+      if (vtkCellTypes.hasSubCells(minCellType)) {
+        minCell.evaluateLocation(subId, minPCoords, point, weights);
+      } else {
+        minCell.evaluateLocation(minPCoords, point, weights);
+      }
 
       // Return the polydata to the user
       model.dataSet = data;