image-js 0.35.1 → 0.35.3

package/lib/image/roi/creator/fromMaxima.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = fromMaxima;
-
 var _RoiMap = _interopRequireDefault(require("../RoiMap"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @memberof RoiManager
  * @instance
@@ -29,24 +26,21 @@ function fromMaxima(options = {}) {
     components: [1]
   });
   const PROCESS_TOP = 1;
-  const PROCESS_NORMAL = 2; // split will always return an array of images
+  const PROCESS_NORMAL = 2;
 
+  // split will always return an array of images
   let positiveID = 0;
   let negativeID = 0;
   let data = new Int16Array(image.size); // maxValue: 32767, minValue: -32768
-
   let processed = new Int8Array(image.size);
   let variations = new Float32Array(image.size);
   let MAX_ARRAY = 0x0fffff; // should be enough for most of the cases
-
   let xToProcess = new Uint16Array(MAX_ARRAY + 1); // assign dynamically ????
-
   let yToProcess = new Uint16Array(MAX_ARRAY + 1); // mask +1 is of course mandatory !!!
 
   let from = 0;
   let to = 0;
   let xToProcessTop = new Uint16Array(MAX_ARRAY + 1); // assign dynamically ????
-
   let yToProcessTop = new Uint16Array(MAX_ARRAY + 1); // mask +1 is of course mandatory !!!
 
   let fromTop = 0;
@@ -54,73 +48,61 @@ function fromMaxima(options = {}) {
   appendMaxima(image, {
     maxima: !invert
   });
-
   while (from < to) {
     let currentX = xToProcess[from & MAX_ARRAY];
     let currentY = yToProcess[from & MAX_ARRAY];
     process(currentX, currentY, PROCESS_NORMAL);
     from++;
   }
+  return new _RoiMap.default(image, data);
 
-  return new _RoiMap.default(image, data); // we will look for the maxima (or minima) that is present in the picture
+  // we will look for the maxima (or minima) that is present in the picture
   // a maxima is a point that is surrounded by lower values
   // should deal with allowCorner and invert
-
   function appendMaxima({
     maxima = true
   }) {
     for (let y = 1; y < image.height - 1; y++) {
       for (let x = 1; x < image.width - 1; x++) {
         let index = x + y * image.width;
-
         if (processed[index] === 0) {
           let currentValue = maxima ? image.data[index] : -image.data[x + y * image.width];
-
           if (image.data[y * image.width + x - 1] > currentValue) {
             // LEFT
             continue;
           }
-
           if (image.data[y * image.width + x + 1] > currentValue) {
             // RIGHT
             continue;
           }
-
           if (image.data[(y - 1) * image.width + x] > currentValue) {
             // TOP
             continue;
           }
-
           if (image.data[(y + 1) * image.width + x] > currentValue) {
             // BOTTOM
             continue;
           }
-
           if (allowCorner) {
             if (image.data[(y - 1) * image.width + x - 1] > currentValue) {
               // LEFT TOP
               continue;
             }
-
             if (image.data[(y - 1) * image.width + x + 1] > currentValue) {
               // RIGHT TOP
               continue;
             }
-
             if (image.data[(y + 1) * image.width + x - 1] > currentValue) {
               // LEFT BOTTOM
               continue;
             }
-
             if (image.data[(y + 1) * image.width + x + 1] > currentValue) {
               // RIGHT BOTTOM
               continue;
             }
           }
-
           data[index] = maxima ? ++positiveID : --negativeID;
           let valid = processTop(x, y, PROCESS_TOP);
-
           if (!valid) {
             if (maxima) {
               --positiveID;
@@ -131,28 +113,25 @@ function fromMaxima(options = {}) {
         }
       }
     }
-  } // we will try to get all the points of the top (same value)
+  }
+
+  // we will try to get all the points of the top (same value)
   // and to check if the whole group is surrounded by lower value
   // as soon as one of them if not part we need to reverse the process
   // and just for get those points
-
-
   function processTop(xToProcess, yToProcess) {
     let currentTo = to; // in case if fails we come back
-
     fromTop = 0;
     toTop = 1;
     xToProcessTop[0] = xToProcess;
     yToProcessTop[0] = yToProcess;
     let valid = true;
-
     while (fromTop < toTop) {
       let currentX = xToProcessTop[fromTop & MAX_ARRAY];
       let currentY = yToProcessTop[fromTop & MAX_ARRAY];
       valid &= process(currentX, currentY, PROCESS_TOP);
       fromTop++;
     }
-
     if (!valid) {
       // need to clear all the calculated data because the top is not surrounded by negative values
       for (let i = 0; i < toTop; i++) {
@@ -161,33 +140,27 @@ function fromMaxima(options = {}) {
         let index = currentY * image.width + currentX;
         data[index] = 0;
       }
-
       to = currentTo;
     }
-
     return valid;
   }
+
   /*
      For a specific point we will check the points around, increase the area of interests and add
      them to the processing list
      type=0 : top
      type=1 : normal
      */
-
-
   function process(xCenter, yCenter, type) {
     let currentID = data[yCenter * image.width + xCenter];
     let currentValue = image.data[yCenter * image.width + xCenter];
-
     for (let y = yCenter - 1; y <= yCenter + 1; y++) {
       for (let x = xCenter - 1; x <= xCenter + 1; x++) {
         let index = y * image.width + x;
-
         if (processed[index] === 0) {
-          processed[index] = 1; // we store the variation compare to the parent pixel
-
+          processed[index] = 1;
+          // we store the variation compare to the parent pixel
           variations[index] = image.data[index] - currentValue;
-
           switch (type) {
             case PROCESS_TOP:
               if (variations[index] === 0) {
@@ -196,7 +169,6 @@ function fromMaxima(options = {}) {
                 if (x === 0 || y === 0 || x === image.width - 1 || y === image.height - 1) {
                   return false;
                 }
-
                 data[index] = currentID;
                 xToProcessTop[toTop & MAX_ARRAY] = x;
                 yToProcessTop[toTop & MAX_ARRAY] = y;
@@ -213,9 +185,7 @@ function fromMaxima(options = {}) {
                   to++;
                 }
               }
-
               break;
-
             case PROCESS_NORMAL:
               if (variations[index] <= 0) {
                 // we look for maxima
@@ -224,16 +194,13 @@ function fromMaxima(options = {}) {
                 yToProcess[to & MAX_ARRAY] = y;
                 to++;
               }
-
               break;
-
             default:
               throw new Error('unreachable');
           }
         }
       }
     }
-
     return true;
   }
 }

package/lib/image/roi/creator/fromPoints.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = fromPoints;
-
 var _Shape = _interopRequireDefault(require("../../../util/Shape"));
-
 var _RoiMap = _interopRequireDefault(require("../RoiMap"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @memberof RoiManager
  * @instance
@@ -19,27 +15,23 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @return {RoiMap}
  */
 function fromPoints(pointsToPaint, options = {}) {
-  let shape = new _Shape.default(options); // based on a binary image we will create plenty of small images
+  let shape = new _Shape.default(options);
 
+  // based on a binary image we will create plenty of small images
   let data = new Int16Array(this.size); // maxValue: 32767, minValue: -32768
-
   let positiveID = 0;
   let shapePoints = shape.getPoints();
-
   for (let i = 0; i < pointsToPaint.length; i++) {
     positiveID++;
     let xP = pointsToPaint[i][0];
     let yP = pointsToPaint[i][1];
-
     for (let j = 0; j < shapePoints.length; j++) {
       let xS = shapePoints[j][0];
       let yS = shapePoints[j][1];
-
       if (xP + xS >= 0 && yP + yS >= 0 && xP + xS < this.width && yP + yS < this.height) {
         data[xP + xS + (yP + yS) * this.width] = positiveID;
       }
     }
   }
-
   return new _RoiMap.default(this, data);
 }

package/lib/image/roi/creator/fromWaterShed.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = fromWaterShed;
-
 var _jsPriorityQueue = _interopRequireDefault(require("js-priority-queue"));
-
 var _dxdy = require("../../../util/dxdy.js");
-
 var _RoiMap = _interopRequireDefault(require("../RoiMap"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * This method allows to create a ROIMap using the water shed algorithm. By default this algorithm
  * will fill the holes and therefore the lowest value of the image (black zones).
@@ -48,21 +43,22 @@ function fromWaterShed(options = {}) {
     bitDepth: [8, 16],
     components: 1
   });
+
   /*
      We need to invert the logic because we are always using method to look for maxima and not minima and
      here water is expected to fill the minima first ...
     */
 
-  invert = !invert; // WaterShed is done from points in the image. We can either specify those points in options,
-  // or it is gonna take the minimum locals of the image by default.
+  invert = !invert;
 
+  // WaterShed is done from points in the image. We can either specify those points in options,
+  // or it is gonna take the minimum locals of the image by default.
   if (!points) {
     points = currentImage.getLocalMaxima({
       invert,
       mask
     });
   }
-
   let maskExpectedValue = invert ? 0 : 1;
   let data = new Int16Array(currentImage.size);
   let width = currentImage.width;
@@ -71,32 +67,26 @@ function fromWaterShed(options = {}) {
     comparator: (a, b) => a[2] - b[2],
     strategy: _jsPriorityQueue.default.BinaryHeapStrategy
   });
-
   for (let i = 0; i < points.length; i++) {
     let index = points[i][0] + points[i][1] * width;
     data[index] = i + 1;
     let intensity = currentImage.data[index];
-
     if (invert && intensity <= fillMaxValue || !invert && intensity >= fillMaxValue) {
       toProcess.queue([points[i][0], points[i][1], intensity]);
     }
-  } // Then we iterate through each points
-
+  }
 
+  // Then we iterate through each points
   while (toProcess.length > 0) {
     let currentPoint = toProcess.dequeue();
     let currentValueIndex = currentPoint[0] + currentPoint[1] * width;
-
     for (let dir = 0; dir < 4; dir++) {
       let newX = currentPoint[0] + _dxdy.dxs[dir];
       let newY = currentPoint[1] + _dxdy.dys[dir];
-
       if (newX >= 0 && newY >= 0 && newX < width && newY < height) {
         let currentNeighbourIndex = newX + newY * width;
-
         if (!mask || mask.getBit(currentNeighbourIndex) === maskExpectedValue) {
           let intensity = currentImage.data[currentNeighbourIndex];
-
           if (invert && intensity <= fillMaxValue || !invert && intensity >= fillMaxValue) {
             if (data[currentNeighbourIndex] === 0) {
               data[currentNeighbourIndex] = data[currentValueIndex];
@@ -107,6 +97,5 @@ function fromWaterShed(options = {}) {
       }
     }
   }
-
   return new _RoiMap.default(currentImage, data);
 }

package/lib/image/roi/feretDiameters.js

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = feretDiameters;
-
 var _points = require("../../util/points");
-
 var _monotoneChainConvexHull = _interopRequireDefault(require("../compute/monotoneChainConvexHull"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * Computes the Feret diameters
  * https://www.sympatec.com/en/particle-measurement/glossary/particle-shape/#
@@ -25,7 +21,6 @@ function feretDiameters(options = {}) {
   const {
     originalPoints = _monotoneChainConvexHull.default.call(this)
   } = options;
-
   if (originalPoints.length === 0) {
     return {
       min: 0,
@@ -35,7 +30,6 @@ function feretDiameters(options = {}) {
       aspectRatio: 1
     };
   }
-
   if (originalPoints.length === 1) {
     return {
       min: 1,
@@ -45,47 +39,42 @@ function feretDiameters(options = {}) {
       aspectRatio: 1
     };
   }
+  const temporaryPoints = new Array(originalPoints.length);
 
-  const temporaryPoints = new Array(originalPoints.length); // CALCULATE MIN VALUE
-
+  // CALCULATE MIN VALUE
   let minWidth = +Infinity;
   let minWidthAngle = 0;
   let minLine = [];
-
   for (let i = 0; i < originalPoints.length; i++) {
-    let angle = getAngle(originalPoints[i], originalPoints[(i + 1) % originalPoints.length]); // we rotate so that it is parallel to X axis
+    let angle = getAngle(originalPoints[i], originalPoints[(i + 1) % originalPoints.length]);
 
+    // we rotate so that it is parallel to X axis
     (0, _points.rotate)(-angle, originalPoints, temporaryPoints);
     let currentWidth = 0;
     let currentMinLine = [];
-
     for (let j = 0; j < originalPoints.length; j++) {
       let absWidth = Math.abs(temporaryPoints[i][1] - temporaryPoints[j][1]);
-
       if (absWidth > currentWidth) {
         currentWidth = absWidth;
         currentMinLine = [];
         currentMinLine.push([temporaryPoints[j][0], temporaryPoints[i][1]], [temporaryPoints[j][0], temporaryPoints[j][1]]);
       }
     }
-
     if (currentWidth < minWidth) {
       minWidth = currentWidth;
       minWidthAngle = angle;
       minLine = currentMinLine;
     }
   }
+  (0, _points.rotate)(minWidthAngle, minLine, minLine);
 
-  (0, _points.rotate)(minWidthAngle, minLine, minLine); // CALCULATE MAX VALUE
-
+  // CALCULATE MAX VALUE
   let maxWidth = 0;
   let maxLine = [];
   let maxSquaredWidth = 0;
-
   for (let i = 0; i < originalPoints.length - 1; i++) {
     for (let j = i + 1; j < originalPoints.length; j++) {
       let currentSquaredWidth = (originalPoints[i][0] - originalPoints[j][0]) ** 2 + (originalPoints[i][1] - originalPoints[j][1]) ** 2;
-
       if (currentSquaredWidth > maxSquaredWidth) {
         maxSquaredWidth = currentSquaredWidth;
         maxWidth = Math.sqrt(currentSquaredWidth);
@@ -93,7 +82,6 @@ function feretDiameters(options = {}) {
       }
     }
   }
-
   return {
     min: minWidth,
     minLine,
@@ -101,10 +89,10 @@ function feretDiameters(options = {}) {
     maxLine,
     aspectRatio: minWidth / maxWidth
   };
-} // the angle that allows to make the line going through p1 and p2 horizontal
-// this is an optimized version because it assume one vector is horizontal
-
+}
 
+// the angle that allows to make the line going through p1 and p2 horizontal
+// this is an optimized version because it assume one vector is horizontal
 function getAngle(p1, p2) {
   let diff = (0, _points.difference)(p2, p1);
   let vector = (0, _points.normalize)(diff);