refactor(imagedata): simplify bounds usage

Author: finetjul

Sources/Common/DataModel/BoundingBox/api.md

@@ -23,6 +23,14 @@ Note that the bounding box may have 0 volume if its bounds
 were just initialized.
 Returns the updated bounds
 
+### addPoints(bounds[6], points)
+
+Change bounding box so it includes the points.
+points can be a list of lists (e.g. [[0,0,0], [1, 0, 0], ...]) or
+a flat list (e.g. [0, 0, 0, 1, 0, 0, ...])
+Note that the bounding box may have 0 volume if its bounds
+were just initialized.
+
 ### addBounds(bounds[6], xMin, xMax, yMin, yMax, zMin, zMax)
 
 Change the bounding box so it includes bounds (defined by vtk standard)

Sources/Common/DataModel/BoundingBox/index.js

@@ -56,6 +56,22 @@ export function addPoint(bounds, ...xyz) {
   return bounds;
 }
 
+export function addPoints(bounds, points) {
+  if (points.length === 0) {
+    return bounds;
+  }
+  if (Array.isArray(points[0])) {
+    for (let i = 0; i < points.length; ++i) {
+      addPoint(bounds, points[i]);
+    }
+  } else {
+    for (let i = 0; i < points.length; i += 3) {
+      addPoint(bounds, points.slice(i, i + 3));
+    }
+  }
+  return bounds;
+}
+
 export function addBounds(bounds, xMin, xMax, yMin, yMax, zMin, zMax) {
   const [_xMin, _xMax, _yMin, _yMax, _zMin, _zMax] = bounds;
   if (zMax === undefined) {
@@ -624,6 +640,10 @@ class BoundingBox {
     return addPoint(this.bounds, xyz);
   }
 
+  addPoints(points) {
+    return addPoints(this.bounds, points);
+  }
+
   addBounds(xMin, xMax, yMin, yMax, zMin, zMax) {
     return addBounds(this.bounds, xMin, xMax, yMin, yMax, zMin, zMax);
   }
@@ -744,6 +764,7 @@ export const STATIC = {
   setBounds,
   reset,
   addPoint,
+  addPoints,
   addBounds,
   setMinPoint,
   setMaxPoint,

Sources/Common/DataModel/ImageData/index.js

@@ -28,15 +28,9 @@ function vtkImageData(publicAPI, model) {
       return false;
     }
 
-    let changeDetected = false;
-    model.extent.forEach((item, index) => {
-      if (item !== extentArray[index]) {
-        if (changeDetected) {
-          return;
-        }
-        changeDetected = true;
-      }
-    });
+    const changeDetected = model.extent.some(
+      (item, index) => item !== extentArray[index]
+    );
 
     if (changeDetected) {
       model.extent = extentArray.slice();
@@ -195,51 +189,27 @@ function vtkImageData(publicAPI, model) {
   publicAPI.extentToBounds = (ex) => {
     // prettier-ignore
     const corners = [
-      ex[0], ex[2], ex[4],
-      ex[1], ex[2], ex[4],
-      ex[0], ex[3], ex[4],
-      ex[1], ex[3], ex[4],
-      ex[0], ex[2], ex[5],
-      ex[1], ex[2], ex[5],
-      ex[0], ex[3], ex[5],
-      ex[1], ex[3], ex[5]];
-
-    const idx = new Float64Array([corners[0], corners[1], corners[2]]);
-    const vout = new Float64Array(3);
-    publicAPI.indexToWorld(idx, vout);
-    const bounds = [vout[0], vout[0], vout[1], vout[1], vout[2], vout[2]];
-    for (let i = 3; i < 24; i += 3) {
-      vec3.set(idx, corners[i], corners[i + 1], corners[i + 2]);
-      publicAPI.indexToWorld(idx, vout);
-      if (vout[0] < bounds[0]) {
-        bounds[0] = vout[0];
-      }
-      if (vout[1] < bounds[2]) {
-        bounds[2] = vout[1];
-      }
-      if (vout[2] < bounds[4]) {
-        bounds[4] = vout[2];
-      }
-      if (vout[0] > bounds[1]) {
-        bounds[1] = vout[0];
-      }
-      if (vout[1] > bounds[3]) {
-        bounds[3] = vout[1];
-      }
-      if (vout[2] > bounds[5]) {
-        bounds[5] = vout[2];
-      }
+      [ex[0], ex[2], ex[4]],
+      [ex[1], ex[2], ex[4]],
+      [ex[0], ex[3], ex[4]],
+      [ex[1], ex[3], ex[4]],
+      [ex[0], ex[2], ex[5]],
+      [ex[1], ex[2], ex[5]],
+      [ex[0], ex[3], ex[5]],
+      [ex[1], ex[3], ex[5]]
+    ];
+
+    const bounds = [...vtkBoundingBox.INIT_BOUNDS];
+    const vout = [];
+    for (let i = 0; i < 8; ++i) {
+      publicAPI.indexToWorld(corners[i], vout);
+      vtkBoundingBox.addPoint(bounds, ...vout);
     }
-
     return bounds;
   };
 
-  publicAPI.getSpatialExtent = () => {
-    const boundingBox = vtkBoundingBox.newInstance();
-    boundingBox.setBounds(model.extent);
-    boundingBox.inflate(0.5);
-    return boundingBox.getBounds();
-  };
+  publicAPI.getSpatialExtent = () =>
+    vtkBoundingBox.inflate([...model.extent], 0.5);
 
   // Internal, shouldn't need to call this manually.
   publicAPI.computeTransforms = () => {
@@ -350,16 +320,7 @@ function vtkImageData(publicAPI, model) {
   publicAPI.onModified(publicAPI.computeTransforms);
   publicAPI.computeTransforms();
 
-  publicAPI.getCenter = () => {
-    const bounds = publicAPI.getBounds();
-    const center = [];
-
-    for (let i = 0; i < 3; i++) {
-      center[i] = (bounds[2 * i + 1] + bounds[2 * i]) / 2;
-    }
-
-    return center;
-  };
+  publicAPI.getCenter = () => vtkBoundingBox.getCenter(publicAPI.getBounds());
 
   publicAPI.computeHistogram = (worldBounds, voxelFunc = null) => {
     const bounds = [0, 0, 0, 0, 0, 0];