perf(Math): Create and use arrayMin and arrayMax

Create and use vtkMath.arrayMin and vtkMath.arrayMax as suggested by:

  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Using_apply_and_built-in_functions

Apply in Texture and PiecewiseGaussianWidget.

This improves volume rendering performance by ~15%.

Author: thewtex

Sources/Common/Core/Math/api.md

@@ -34,13 +34,13 @@ Same as Math.min().
 
 Same as Math.max().
 
-### isPowerOfTwo(number) : Boolean
+### arrayMin(array)
 
-NOT IMPLEMENTED
+Minimum of the array.
 
-### nearestPowerOfTwo(number) : int
+### arrayMax(a, b)
 
-NOT IMPLEMENTED
+Maximum of the array.
 
 ### factorial(n) : number
 

Sources/Common/Core/Math/index.js

@@ -12,6 +12,7 @@ const { vtkErrorMacro, vtkWarningMacro } = macro;
 let randomSeedValue = 0;
 const VTK_MAX_ROTATIONS = 20;
 const VTK_SMALL_NUMBER = 1.0e-12;
+const MAX_FUNCTION_ARGUMENTS = 32768;
 
 function notImplemented(method) {
   return () => vtkErrorMacro(`vtkMath::${method} - NOT IMPLEMENTED`);
@@ -41,6 +42,33 @@ const Pi = () => Math.PI;
 const radiansFromDegrees = (deg) => deg / 180 * Math.PI;
 const degreesFromRadians = (rad) => rad * 180 / Math.PI;
 const { round, floor, ceil, min, max } = Math;
+
+function arrayMin(arr) {
+  let minValue = Infinity;
+  for (let i = 0, len = arr.length; i < len; i += MAX_FUNCTION_ARGUMENTS) {
+    const submin = Math.min.apply(
+      null,
+      arr.slice(i, Math.min(i + MAX_FUNCTION_ARGUMENTS, len))
+    );
+    minValue = Math.min(submin, minValue);
+  }
+
+  return minValue;
+}
+
+function arrayMax(arr) {
+  let maxValue = -Infinity;
+  for (let i = 0, len = arr.length; i < len; i += MAX_FUNCTION_ARGUMENTS) {
+    const submax = Math.max.apply(
+      null,
+      arr.slice(i, Math.min(i + MAX_FUNCTION_ARGUMENTS, len))
+    );
+    maxValue = Math.max(submax, maxValue);
+  }
+
+  return maxValue;
+}
+
 const ceilLog2 = notImplemented('ceilLog2');
 const factorial = notImplemented('factorial');
 
@@ -1993,6 +2021,8 @@ export default {
   ceilLog2,
   min,
   max,
+  arrayMin,
+  arrayMax,
   isPowerOfTwo,
   nearestPowerOfTwo,
   factorial,

Sources/Interaction/Widgets/PiecewiseGaussianWidget/index.js

@@ -1,4 +1,5 @@
 import macro from 'vtk.js/Sources/macro';
+import vtkMath from 'vtk.js/Sources/Common/Core/Math';
 
 /* eslint-disable no-continue */
 
@@ -438,13 +439,8 @@ function vtkPiecewiseGaussianWidget(publicAPI, model) {
     numberOfBinsToSkip = 1
   ) => {
     model.histogramArray = array;
-    const size = array.length;
-    let max = array[0];
-    let min = array[0];
-    for (let i = 1; i < size; i++) {
-      max = Math.max(max, array[i]);
-      min = Math.min(min, array[i]);
-    }
+    const max = vtkMath.arrayMax(array);
+    const min = vtkMath.arrayMin(array);
 
     const delta = max - min;
     model.dataRange = [min, max];

Sources/Rendering/OpenGL/Texture/index.js

@@ -930,12 +930,8 @@ function vtkOpenGLTexture(publicAPI, model) {
     const numPixelsIn = width * height * depth;
 
     // compute min and max values
-    let min = data[0];
-    let max = data[0];
-    for (let i = 0; i < numPixelsIn; ++i) {
-      min = Math.min(min, data[i]);
-      max = Math.max(max, data[i]);
-    }
+    const min = vtkMath.arrayMin(data);
+    let max = vtkMath.arrayMax(data);
     if (min === max) {
       max = min + 1.0;
     }
@@ -1115,6 +1111,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     // have to compute the gradient to get the normal
     // and magnitude
     const tmpArray = new Float32Array(width * height * depth * 4);
+    const tmpMagArray = new Float32Array(width * height * depth);
 
     let inPtr = 0;
     let outPtr = 0;
@@ -1151,18 +1148,20 @@ function vtkOpenGLTexture(publicAPI, model) {
           );
 
           const mag = vec3.length(grad);
-          minMag = Math.min(mag, minMag);
-          maxMag = Math.max(mag, maxMag);
-
           vec3.normalize(grad, grad);
           tmpArray[outPtr++] = grad[0];
           tmpArray[outPtr++] = grad[1];
           tmpArray[outPtr++] = grad[2];
           tmpArray[outPtr++] = mag;
+	  tmpMagArray[inPtr] = mag;
           inPtr++;
         }
       }
     }
+    const arrayMinMag = vtkMath.arrayMin(tmpMagArray);
+    const arrayMaxMag = vtkMath.arrayMax(tmpMagArray);
+    minMag = Math.min(arrayMinMag, minMag);
+    maxMag = Math.max(arrayMaxMag, maxMag);
 
     // store the information, we will need it later
     model.volumeInfo = { min: minMag, max: maxMag };