Merge pull request #2556 from joannacirillo/fix-get-tuple

finetjul · web-flow · commit 6112615184ef · 2022-09-02T23:10:44.000+02:00
fix(dataarray): getTuple
diff --git a/Sources/Common/Core/DataArray/index.d.ts b/Sources/Common/Core/DataArray/index.d.ts
@@ -93,17 +93,20 @@ export interface vtkDataArray extends vtkObject {
 	/**
 	 * Get the tuple at the given index.
 	 *
-	 * The recommended use is the following:
+	 * For performance reasons, it is advised to pass a 'tupleToFill':
 	 * `const x = [];`
-	 * `dataArray.getTuple(idx, x);`
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  dataArray.getTuple(idx, x);`
+	 * `  ...`
 	 * instead of:
-	 * `const x = dataArray.getTuple(idx);`
-	 *
+	 * `for (int i = 0; i < N; ++i) {
+	 * `  const x = dataArray.getTuple(idx);`
+	 * `...`
 	 * @param {Number} idx
-	 * @param {Array<Number>} [tupleToFill] (default [])
-	 * @returns {Array<Number>}
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getTuple(idx: number, tupleToFill?: Array<number>): Array<number>;
+	getTuple(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 	
 	/**
 	 * Get the tuples between fromId (inclusive) and toId (exclusive).
diff --git a/Sources/Common/Core/DataArray/index.js b/Sources/Common/Core/DataArray/index.js
@@ -4,7 +4,6 @@ import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
 
 const { vtkErrorMacro } = macro;
 const { DefaultDataType } = Constants;
-const TUPLE_HOLDER = [];
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -103,8 +102,10 @@ function getDataType(typedArray) {
 function getMaxNorm(normArray) {
   const numComps = normArray.getNumberOfComponents();
   let maxNorm = 0.0;
+  const tuple = new Array(numComps);
   for (let i = 0; i < normArray.getNumberOfTuples(); ++i) {
-    const norm = vtkMath.norm(normArray.getTuple(i), numComps);
+    normArray.getTuple(i, tuple);
+    const norm = vtkMath.norm(tuple, numComps);
     if (norm > maxNorm) {
       maxNorm = norm;
     }
@@ -299,11 +300,8 @@ function vtkDataArray(publicAPI, model) {
     return publicAPI.insertTuples(idx, tuples);
   };
 
-  publicAPI.getTuple = (idx, tupleToFill = TUPLE_HOLDER) => {
+  publicAPI.getTuple = (idx, tupleToFill = []) => {
     const numberOfComponents = model.numberOfComponents || 1;
-    if (tupleToFill.length !== numberOfComponents) {
-      tupleToFill.length = numberOfComponents;
-    }
     const offset = idx * numberOfComponents;
     // Check most common component sizes first
     // to avoid doing a for loop if possible
@@ -321,7 +319,7 @@ function vtkDataArray(publicAPI, model) {
         tupleToFill[0] = model.values[offset];
         break;
       default:
-        for (let i = 0; i < numberOfComponents; i++) {
+        for (let i = numberOfComponents - 1; i >= 0; --i) {
           tupleToFill[i] = model.values[offset + i];
         }
     }
@@ -427,14 +425,11 @@ function vtkDataArray(publicAPI, model) {
       vtkErrorMacro('numberOfComponents must match');
     }
 
-    const tuple1 = [];
-    const tuple2 = [];
+    const tuple1 = source1.getTuple(source1Idx);
+    const tuple2 = source2.getTuple(source2Idx);
     const out = [];
     out.length = numberOfComponents;
 
-    source1.getTuple(source1Idx, tuple1);
-    source2.getTuple(source2Idx, tuple2);
-
     // Check most common component sizes first
     // to avoid doing a for loop if possible
     switch (numberOfComponents) {
diff --git a/Sources/Common/Core/DataArray/test/testDataArray.js b/Sources/Common/Core/DataArray/test/testDataArray.js
@@ -1,6 +1,7 @@
 import test from 'tape-catch';
 import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
 import { VtkDataTypes } from 'vtk.js/Sources/Common/Core/DataArray/Constants';
+import * as vtkMath from 'vtk.js/Sources/Common/Core/Math';
 
 test('Test vtkDataArray instance', (t) => {
   t.ok(vtkDataArray, 'Make sure the class definition exists');
@@ -29,6 +30,33 @@ test('Test vtkDataArray getRange function with single-channel data.', (t) => {
   t.end();
 });
 
+test('Test vtkDataArray getTuple', (t) => {
+  const da = vtkDataArray.newInstance({
+    numberOfComponents: 3,
+    values: new Uint8Array([0, 1, 2, 3, 4, 5]),
+  });
+  const da2 = vtkDataArray.newInstance({
+    numberOfComponents: 3,
+    values: new Uint8Array([0, 1, 2, 3, 4, 5]),
+  });
+
+  t.ok(vtkMath.areEquals(da.getTuple(0), [0, 1, 2]), 'get first tuple');
+  t.ok(vtkMath.areEquals(da.getTuple(1), [3, 4, 5]), 'get 2nd tuple');
+  t.ok(da.getTuple(0) !== da.getTuple(1), 'getTuple twice');
+  t.ok(da.getTuple(0) !== da2.getTuple(0), 'getTuple twice');
+  const tuple = [];
+  t.equal(da.getTuple(0, tuple), tuple, 'getTuple with tupleToFill');
+  t.equal(tuple.length, 3, 'getTuple length');
+  const typedArray = new Uint8Array(3);
+  t.equal(
+    da.getTuple(0, typedArray),
+    typedArray,
+    'getTuple with typed tupleToFill'
+  );
+  t.ok(vtkMath.areEquals(typedArray, [0, 1, 2]), 'get typed first tuple');
+  t.end();
+});
+
 test('Test vtkDataArray getRange function with multi-channel data.', (t) => {
   // create a data array with 3 channel data.
   const newArray = new Uint16Array(256 * 3);
diff --git a/Sources/Common/Core/Points/index.d.ts b/Sources/Common/Core/Points/index.d.ts
@@ -1,5 +1,5 @@
 import vtkDataArray from '../../../Common/Core/DataArray';
-import { Bounds } from '../../../types';
+import { Bounds, TypedArray } from '../../../types';
 
 /**
  *
@@ -26,10 +26,10 @@ export interface vtkPoints extends vtkDataArray {
 	/**
 	 * Get the coordinate of a point.
 	 * @param {Number} idx The index of point.
-	 * @param {Number[]} [tupleToFill] 
-	 * @default []
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
 	 */
-	getPoint(idx: number, tupleToFill?: number[]): number[];
+	getPoint(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
 
 	/**
 	 * Get the number of points for this object can hold.
diff --git a/Sources/Common/Core/StringArray/index.js b/Sources/Common/Core/StringArray/index.js
@@ -1,7 +1,5 @@
 import macro from 'vtk.js/Sources/macros';
 
-const TUPLE_HOLDER = [];
-
 // ----------------------------------------------------------------------------
 // vtkStringArray methods
 // ----------------------------------------------------------------------------
@@ -31,7 +29,7 @@ function vtkStringArray(publicAPI, model) {
 
   publicAPI.getData = () => model.values;
 
-  publicAPI.getTuple = (idx, tupleToFill = TUPLE_HOLDER) => {
+  publicAPI.getTuple = (idx, tupleToFill = []) => {
     const numberOfComponents = model.numberOfComponents || 1;
     if (tupleToFill.length) {
       tupleToFill.length = numberOfComponents;
diff --git a/Sources/Common/Core/VariantArray/index.js b/Sources/Common/Core/VariantArray/index.js
@@ -1,7 +1,5 @@
 import macro from 'vtk.js/Sources/macros';
 
-const TUPLE_HOLDER = [];
-
 // ----------------------------------------------------------------------------
 // vtkVariantArray methods
 // ----------------------------------------------------------------------------
@@ -31,7 +29,7 @@ function vtkVariantArray(publicAPI, model) {
 
   publicAPI.getData = () => model.values;
 
-  publicAPI.getTuple = (idx, tupleToFill = TUPLE_HOLDER) => {
+  publicAPI.getTuple = (idx, tupleToFill = []) => {
     const numberOfComponents = model.numberOfComponents || 1;
     if (tupleToFill.length) {
       tupleToFill.length = numberOfComponents;
diff --git a/Sources/Filters/Core/Cutter/test/testCutter.js b/Sources/Filters/Core/Cutter/test/testCutter.js
@@ -31,8 +31,7 @@ test('Test vtkCutter cutCube', (t) => {
   correctPoints.forEach((correctPoint) => {
     let isContaining = false;
     for (let i = 0; i < points.getNumberOfPoints(); i++) {
-      const p = [];
-      points.getPoint(i, p);
+      const p = points.getPoint(i);
       isContaining =
         p[0] === correctPoint[0] &&
         p[1] === correctPoint[1] &&
diff --git a/Sources/Filters/General/ClipClosedSurface/index.js b/Sources/Filters/General/ClipClosedSurface/index.js
@@ -77,10 +77,8 @@ function vtkClipClosedSurface(publicAPI, model) {
     }
 
     // Get the edge and interpolate the new point
-    const p0 = [];
-    const p1 = [];
-    points.getPoint(i0, p0);
-    points.getPoint(i1, p1);
+    const p0 = points.getPoint(i0);
+    const p1 = points.getPoint(i1);
 
     const f = v0 / (v0 - v1);
     const s = 1.0 - f;
diff --git a/Sources/Filters/General/ImageStreamline/index.js b/Sources/Filters/General/ImageStreamline/index.js
@@ -137,8 +137,9 @@ function vtkImageStreamline(publicAPI, model) {
     velAtArg[0] = 0.0;
     velAtArg[1] = 0.0;
     velAtArg[2] = 0.0;
+    const vel = new Array(3);
     for (let i = 0; i < 8; i++) {
-      const vel = velArray.getTuple(voxelIndices[i]);
+      velArray.getTuple(voxelIndices[i], vel);
       for (let j = 0; j < 3; j++) {
         velAtArg[j] += weights[i] * vel[j];
       }
@@ -236,13 +237,10 @@ function vtkImageStreamline(publicAPI, model) {
     let offset = 0;
     const datas = [];
     const vectors = input.getPointData().getVectors();
+    const point = [];
     for (let i = 0; i < nSeeds; i++) {
-      const retVal = publicAPI.streamIntegrate(
-        vectors,
-        input,
-        seedPts.getTuple(i),
-        offset
-      );
+      seedPts.getTuple(i, point);
+      const retVal = publicAPI.streamIntegrate(vectors, input, point, offset);
       offset += retVal[0].length / 3;
       datas.push(retVal);
     }
diff --git a/Sources/Filters/General/PaintFilter/index.js b/Sources/Filters/General/PaintFilter/index.js
@@ -98,9 +98,10 @@ function vtkPaintFilter(publicAPI, model) {
     let diffIdx = 0;
     if (model.voxelFunc) {
       const bgScalars = model.backgroundImage.getPointData().getScalars();
+      const voxel = [];
       for (let i = 0; i < maskLabelMap.length; i++) {
         if (maskLabelMap[i]) {
-          const voxel = bgScalars.getTuple(i);
+          bgScalars.getTuple(i, voxel);
           // might not fill up snapshot
           if (model.voxelFunc(voxel, i, label)) {
             snapshot[diffIdx++] = [i, data[i]];
diff --git a/Sources/Filters/General/TubeFilter/index.js b/Sources/Filters/General/TubeFilter/index.js
@@ -226,6 +226,7 @@ function vtkTubeFilter(publicAPI, model) {
     const normal = [0.0, 0.0, 0.0];
     let sFactor = 1.0;
     let ptId = offset;
+    const vector = [];
     for (let j = 0; j < npts; ++j) {
       // First point
       if (j === 0) {
@@ -297,7 +298,7 @@ function vtkTubeFilter(publicAPI, model) {
         model.varyRadius === VaryRadius.VARY_RADIUS_BY_VECTOR
       ) {
         sFactor = Math.sqrt(
-          maxSpeed / vtkMath.norm(inVectors.getTuple(pts[j]))
+          maxSpeed / vtkMath.norm(inVectors.getTuple(pts[j], vector))
         );
         if (sFactor > model.radiusFactor) {
           sFactor = model.radiusFactor;
diff --git a/Sources/Filters/General/WindowedSincPolyDataFilter/index.js b/Sources/Filters/General/WindowedSincPolyDataFilter/index.js
@@ -186,17 +186,17 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
               // TODO: support polygons
               // vtkPolygon::ComputeNormal(inPts,npts,pts,normal);
               vtkTriangle.computeNormal(
-                [...inPts.getPoint(pts[0])],
-                [...inPts.getPoint(pts[1])],
-                [...inPts.getPoint(pts[2])],
+                inPts.getPoint(pts[0]),
+                inPts.getPoint(pts[1]),
+                inPts.getPoint(pts[2]),
                 normal
               );
               const { cellPointIds } = mesh.getCellPoints(nei);
               // vtkPolygon::ComputeNormal(inPts,numNeiPts,neiPts,neiNormal);
               vtkTriangle.computeNormal(
-                [...inPts.getPoint(cellPointIds[0])],
-                [...inPts.getPoint(cellPointIds[1])],
-                [...inPts.getPoint(cellPointIds[2])],
+                inPts.getPoint(cellPointIds[0]),
+                inPts.getPoint(cellPointIds[1]),
+                inPts.getPoint(cellPointIds[2]),
                 neiNormal
               );
 
@@ -275,12 +275,9 @@ function vtkWindowedSincPolyDataFilter(publicAPI, model) {
           ++numFixed;
         } // check angle between edges
         else {
-          const x1 = [0, 0, 0];
-          inPts.getPoint(verts[i].edges[0], x1);
-          const x2 = [0, 0, 0];
-          inPts.getPoint(i, x2);
-          const x3 = [0, 0, 0];
-          inPts.getPoint(verts[i].edges[1], x3);
+          const x1 = inPts.getPoint(verts[i].edges[0]);
+          const x2 = inPts.getPoint(i);
+          const x3 = inPts.getPoint(verts[i].edges[1]);
 
           const l1 = [0, 0, 0];
           const l2 = [0, 0, 0];
diff --git a/Sources/Rendering/Core/HardwareSelector/example/index.js b/Sources/Rendering/Core/HardwareSelector/example/index.js
@@ -210,18 +210,15 @@ function processSelections(selections) {
       hardwareSelector.getFieldAssociation() ===
       FieldAssociations.FIELD_ASSOCIATION_POINTS
     ) {
-      const points = input.getPoints();
-      const point = points.getTuple(attributeID);
-      cursorPosition = [...point];
+      cursorPosition = input.getPoints().getTuple(attributeID);
     } else {
       const cellPoints = input.getCellPoints(attributeID);
       if (cellPoints) {
         const pointIds = cellPoints.cellPointIds;
-        const points = [];
         // Find the closest cell point, and use that as cursor position
-        pointIds.forEach((pointId) => {
-          points.push(input.getPoints().getPoint(pointId, []));
-        });
+        const points = pointIds.map((pointId) =>
+          input.getPoints().getPoint(pointId)
+        );
         const distance = (pA, pB) =>
           vtkMath.distance2BetweenPoints(pA, worldPosition) -
           vtkMath.distance2BetweenPoints(pB, worldPosition);
diff --git a/Sources/Rendering/OpenGL/PolyDataMapper2D/index.js b/Sources/Rendering/OpenGL/PolyDataMapper2D/index.js
@@ -225,8 +225,10 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         const p = vtkPoints.newInstance();
         const numPts = points.getNumberOfPoints();
         p.setNumberOfPoints(numPts);
+        const point = [];
         for (let i = 0; i < numPts; ++i) {
-          transformCoordinate.setValue(points.getPoint(i));
+          points.getPoint(i, point);
+          transformCoordinate.setValue(point);
           const v = transformCoordinate.getComputedDoubleViewportValue(ren);
           p.setPoint(i, v[0], v[1], 0.0);
         }
