image-js 0.35.1 → 0.35.3

package/lib/image/transform/mask/otsu.js

@@ -4,41 +4,35 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = otsu;
-
 /*
  * The method is present in: Otsu, N (1979), "A threshold selection method from gray-level histograms", IEEE Trans. Sys., Man., Cyber. 9: 62-66
  * The Otsu implementation is based on: https://en.wikipedia.org/wiki/Otsu's_method
  * @param histogram - the histogram of the image
  * @returns {number} - the threshold
  */
+
 function otsu(histogramCounts, total) {
   let sumB = 0;
   let wB = 0;
   let maximum = 0;
   let level = 0;
   let sum1 = 0;
-
   for (let i = 0; i < histogramCounts.length; i++) {
     sum1 += i * histogramCounts[i];
   }
-
   for (let ii = 0; ii < histogramCounts.length; ii++) {
     wB = wB + histogramCounts[ii];
     const wF = total - wB;
-
     if (wB === 0 || wF === 0) {
       continue;
     }
-
     sumB = sumB + ii * histogramCounts[ii];
     const mF = (sum1 - sumB) / wF;
     const between = wB * wF * (sumB / wB - mF) * (sumB / wB - mF);
-
     if (between >= maximum) {
       level = ii;
       maximum = between;
     }
   }
-
   return level;
 }

package/lib/image/transform/mask/percentile.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = percentile;
-
 // See http://imagej.nih.gov/ij/download/tools/source/ij/process/AutoThresholder.java
 // W. Doyle, "Operation useful for similarity-invariant pattern recognition,"
 // Journal of the Association for Computing Machinery, vol. 9,pp. 259-267, 1962.
@@ -15,29 +14,22 @@ exports.default = percentile;
 function percentile(histogram) {
   let threshold = -1;
   let percentile = 0.5; // default fraction of foreground pixels
-
   let avec = new Array(histogram.length);
   let total = partialSum(histogram, histogram.length - 1);
   let temp = 1.0;
-
   for (let i = 0; i < histogram.length; i++) {
     avec[i] = Math.abs(partialSum(histogram, i) / total - percentile);
-
     if (avec[i] < temp) {
       temp = avec[i];
       threshold = i;
     }
   }
-
   return threshold;
 }
-
 function partialSum(histogram, endIndex) {
   let x = 0;
-
   for (let i = 0; i <= endIndex; i++) {
     x += histogram[i];
   }
-
   return x;
 }

package/lib/image/transform/mask/renyiEntropy.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = renyiEntropy;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // Kapur J.N., Sahoo P.K., and Wong A.K.C. (1985) "A New Method for
 // Gray-Level Picture Thresholding Using the Entropy of the Histogram"
@@ -14,18 +13,14 @@ exports.default = renyiEntropy;
 // Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
 function renyiEntropy(histogram, total) {
   let optThreshold; // Optimal threshold
-
   let firstBin; // First non-zero bin
-
   let lastBin; // last non-zero bin
 
   let normHisto = new Array(histogram.length); // normalized histogram
-
   let P1 = new Array(histogram.length); // acumulative normalized histogram
-
   let P2 = new Array(histogram.length); // acumulative normalized histogram
-  // Entropy Variables
 
+  // Entropy Variables
   let threshold1 = 0;
   let threshold2 = 0;
   let threshold3 = 0;
@@ -36,95 +31,76 @@ function renyiEntropy(histogram, total) {
   let term2 = 1.0 / (1.0 - alpha2);
   let alpha3 = 2.0;
   let term3 = 1.0 / (1.0 - alpha3);
-
   for (let ih = 0; ih < histogram.length; ih++) {
     normHisto[ih] = histogram[ih] / total;
   }
-
   P1[0] = normHisto[0];
   P2[0] = 1.0 - P1[0];
-
   for (let ih = 1; ih < histogram.length; ih++) {
     P1[ih] = P1[ih - 1] + normHisto[ih];
     P2[ih] = 1.0 - P1[ih];
   }
-  /* Determine the first non-zero bin */
-
 
+  /* Determine the first non-zero bin */
   firstBin = 0;
-
   for (let ih = 0; ih < histogram.length; ih++) {
     if (Math.abs(P1[ih]) >= Number.EPSILON) {
       firstBin = ih;
       break;
     }
   }
-  /* Determine the last non-zero bin */
-
 
+  /* Determine the last non-zero bin */
   lastBin = histogram.length - 1;
-
   for (let ih = histogram.length - 1; ih >= firstBin; ih--) {
     if (Math.abs(P2[ih]) >= Number.EPSILON) {
       lastBin = ih;
       break;
     }
   }
-  /* Maximum Entropy Thresholding - BEGIN */
 
+  /* Maximum Entropy Thresholding - BEGIN */
   /* ALPHA = 1.0 */
-
   /* Calculate the total entropy each gray-level
      and find the threshold that maximizes it
      */
-
-
   for (let it = firstBin; it <= lastBin; it++) {
     /* Entropy of the background pixels */
     let entBack1 = 0.0;
     let entBack2 = 0.0;
     let entBack3 = 0.0;
-
     for (let ih = 0; ih <= it; ih++) {
       if (histogram[ih] !== 0) {
         entBack1 -= normHisto[ih] / P1[it] * Math.log(normHisto[ih] / P1[it]);
       }
-
       entBack2 += Math.sqrt(normHisto[ih] / P1[it]);
       entBack3 += normHisto[ih] * normHisto[ih] / (P1[it] * P1[it]);
     }
-    /* Entropy of the object pixels */
-
 
+    /* Entropy of the object pixels */
     let entObj1 = 0.0;
     let entObj2 = 0.0;
     let entObj3 = 0.0;
-
     for (let ih = it + 1; ih < histogram.length; ih++) {
       if (histogram[ih] !== 0) {
         entObj1 -= normHisto[ih] / P2[it] * Math.log(normHisto[ih] / P2[it]);
       }
-
       entObj2 += Math.sqrt(normHisto[ih] / P2[it]);
       entObj3 += normHisto[ih] * normHisto[ih] / (P2[it] * P2[it]);
     }
-    /* Total entropy */
-
 
+    /* Total entropy */
     let totEnt1 = entBack1 + entObj1;
     let totEnt2 = term2 * (entBack2 * entObj2 > 0.0 ? Math.log(entBack2 * entObj2) : 0.0);
     let totEnt3 = term3 * (entBack3 * entObj3 > 0.0 ? Math.log(entBack3 * entObj3) : 0.0);
-
     if (totEnt1 > maxEnt1) {
       maxEnt1 = totEnt1;
       threshold1 = it;
     }
-
     if (totEnt2 > maxEnt2) {
       maxEnt2 = totEnt2;
       threshold2 = it;
     }
-
     if (totEnt3 > maxEnt3) {
       maxEnt3 = totEnt3;
       threshold3 = it;
@@ -132,12 +108,11 @@ function renyiEntropy(histogram, total) {
   }
   /* End Maximum Entropy Thresholding */
 
-
   let tStars = [threshold1, threshold2, threshold3];
   tStars.sort((a, b) => a - b);
   let betas;
-  /* Adjust beta values */
 
+  /* Adjust beta values */
   if (Math.abs(tStars[0] - tStars[1]) <= 5) {
     if (Math.abs(tStars[1] - tStars[2]) <= 5) {
       betas = [1, 2, 1];
@@ -151,9 +126,8 @@ function renyiEntropy(histogram, total) {
       betas = [1, 2, 1];
     }
   }
-  /* Determine the optimal threshold value */
-
 
+  /* Determine the optimal threshold value */
   let omega = P1[tStars[2]] - P1[tStars[0]];
   optThreshold = Math.round(tStars[0] * (P1[tStars[0]] + 0.25 * omega * betas[0]) + 0.25 * tStars[1] * omega * betas[1] + tStars[2] * (P2[tStars[2]] + 0.25 * omega * betas[2]));
   return optThreshold;

package/lib/image/transform/mask/shanbhag.js

@@ -4,92 +4,75 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = shanbhag;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // Shanhbag A.G. (1994) "Utilization of Information Measure as a Means of
 // Image Thresholding" Graphical Models and Image Processing, 56(5): 414-419
 // Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+
 function shanbhag(histogram, total) {
   let normHisto = new Array(histogram.length); // normalized histogram
-
   for (let ih = 0; ih < histogram.length; ih++) {
     normHisto[ih] = histogram[ih] / total;
   }
-
   let P1 = new Array(histogram.length); // cumulative normalized histogram
-
   let P2 = new Array(histogram.length);
   P1[0] = normHisto[0];
   P2[0] = 1.0 - P1[0];
-
   for (let ih = 1; ih < histogram.length; ih++) {
     P1[ih] = P1[ih - 1] + normHisto[ih];
     P2[ih] = 1.0 - P1[ih];
   }
-  /* Determine the first non-zero bin */
-
 
+  /* Determine the first non-zero bin */
   let firstBin = 0;
-
   for (let ih = 0; ih < histogram.length; ih++) {
     if (Math.abs(P1[ih]) >= Number.EPSILON) {
       firstBin = ih;
       break;
     }
   }
-  /* Determine the last non-zero bin */
-
 
+  /* Determine the last non-zero bin */
   let lastBin = histogram.length - 1;
-
   for (let ih = histogram.length - 1; ih >= firstBin; ih--) {
     if (Math.abs(P2[ih]) >= Number.EPSILON) {
       lastBin = ih;
       break;
     }
-  } // Calculate the total entropy each gray-level
-  // and find the threshold that maximizes it
-
+  }
 
+  // Calculate the total entropy each gray-level
+  // and find the threshold that maximizes it
   let threshold = -1;
   let minEnt = Number.MAX_VALUE; // min entropy
 
   let term;
   let totEnt; // total entropy
-
   let entBack; // entropy of the background pixels at a given threshold
-
   let entObj; // entropy of the object pixels at a given threshold
-
   for (let it = firstBin; it <= lastBin; it++) {
     /* Entropy of the background pixels */
     entBack = 0.0;
     term = 0.5 / P1[it];
-
     for (let ih = 1; ih <= it; ih++) {
       entBack -= normHisto[ih] * Math.log(1.0 - term * P1[ih - 1]);
     }
-
     entBack *= term;
-    /* Entropy of the object pixels */
 
+    /* Entropy of the object pixels */
     entObj = 0.0;
     term = 0.5 / P2[it];
-
     for (let ih = it + 1; ih < histogram.length; ih++) {
       entObj -= normHisto[ih] * Math.log(1.0 - term * P2[ih]);
     }
-
     entObj *= term;
-    /* Total entropy */
 
+    /* Total entropy */
     totEnt = Math.abs(entBack - entObj);
-
     if (totEnt < minEnt) {
       minEnt = totEnt;
       threshold = it;
     }
   }
-
   return threshold;
 }

package/lib/image/transform/mask/thresholdAlgorithms.js

@@ -4,42 +4,26 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.names = exports.methods = void 0;
-
 var _huang = _interopRequireDefault(require("./huang"));
-
 var _intermodes = _interopRequireDefault(require("./intermodes"));
-
 var _isodata = _interopRequireDefault(require("./isodata"));
-
 var _li = _interopRequireDefault(require("./li"));
-
 var _maxEntropy = _interopRequireDefault(require("./maxEntropy"));
-
 var _mean = _interopRequireDefault(require("./mean"));
-
 var _minError = _interopRequireDefault(require("./minError"));
-
 var _minimum = _interopRequireDefault(require("./minimum"));
-
 var _moments = _interopRequireDefault(require("./moments"));
-
 var _otsu = _interopRequireDefault(require("./otsu"));
-
 var _percentile = _interopRequireDefault(require("./percentile"));
-
 var _renyiEntropy = _interopRequireDefault(require("./renyiEntropy.js"));
-
 var _shanbhag = _interopRequireDefault(require("./shanbhag"));
-
 var _triangle = _interopRequireDefault(require("./triangle"));
-
 var _yen = _interopRequireDefault(require("./yen"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @typedef {('huang'|'intermodes'|'isodata'|'li'|'maxentropy'|'mean'|'minerror'|'minimum'|'moments'|'otsu'|'percentile'|'renyientropy'|'shanbhag'|'triangle'|'yen')} ThresholdAlgorithm
  */
+
 const methods = {
   huang: _huang.default,
   intermodes: _intermodes.default,

package/lib/image/transform/mask/triangle.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = triangle;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // Zack, G. W., Rogers, W. E. and Latt, S. A., 1977,
 // Automatic Measurement of Sister Chromatid Exchange Frequency,
@@ -17,101 +16,87 @@ function triangle(histogram) {
   let dmax = 0;
   let max = 0;
   let min2 = 0;
-
   for (let i = 0; i < histogram.length; i++) {
     if (histogram[i] > 0) {
       min = i;
       break;
     }
   }
-
   if (min > 0) {
     // line to the (p==0) point, not to histogram[min]
     min--;
-  } // The Triangle algorithm cannot tell whether the data is skewed to one side or another.
+  }
+
+  // The Triangle algorithm cannot tell whether the data is skewed to one side or another.
   // This causes a problem as there are 2 possible thresholds between the max and the 2 extremes
   // of the histogram.
   // Here I propose to find out to which side of the max point the data is furthest, and use that as
   //  the other extreme.
-
-
   for (let i = histogram.length - 1; i > 0; i--) {
     if (histogram[i] > 0) {
       min2 = i;
       break;
     }
   }
-
   if (min2 < histogram.length - 1) {
     // line to the (p==0) point, not to data[min]
     min2++;
   }
-
   for (let i = 0; i < histogram.length; i++) {
     if (histogram[i] > dmax) {
       max = i;
       dmax = histogram[i];
     }
-  } // find which is the furthest side
-
+  }
 
+  // find which is the furthest side
   let inverted = false;
-
   if (max - min < min2 - max) {
     // reverse the histogram
     inverted = true;
     let left = 0; // index of leftmost element
-
     let right = histogram.length - 1; // index of rightmost element
-
     while (left < right) {
       // exchange the left and right elements
       let temp = histogram[left];
       histogram[left] = histogram[right];
-      histogram[right] = temp; // move the bounds toward the center
-
+      histogram[right] = temp;
+      // move the bounds toward the center
       left++;
       right--;
     }
-
     min = histogram.length - 1 - min2;
     max = histogram.length - 1 - max;
   }
-
   if (min === max) {
     return min;
-  } // describe line by nx * x + ny * y - d = 0
-
-
-  let nx, ny, d; // nx is just the max frequency as the other point has freq=0
+  }
 
+  // describe line by nx * x + ny * y - d = 0
+  let nx, ny, d;
+  // nx is just the max frequency as the other point has freq=0
   nx = histogram[max]; // -min; // data[min]; //  lowest value bmin = (p=0)% in the image
-
   ny = min - max;
   d = Math.sqrt(nx * nx + ny * ny);
   nx /= d;
   ny /= d;
-  d = nx * min + ny * histogram[min]; // find split point
+  d = nx * min + ny * histogram[min];
 
+  // find split point
   let split = min;
   let splitDistance = 0;
-
   for (let i = min + 1; i <= max; i++) {
     let newDistance = nx * i + ny * histogram[i] - d;
-
     if (newDistance > splitDistance) {
       split = i;
       splitDistance = newDistance;
     }
   }
-
   split--;
-
   if (inverted) {
     // The histogram might be used for something else, so let's reverse it back
     let left = 0;
     let right = histogram.length - 1;
-
     while (left < right) {
       let temp = histogram[left];
       histogram[left] = histogram[right];
@@ -119,7 +104,6 @@ function triangle(histogram) {
       left++;
       right--;
     }
-
     return histogram.length - 1 - split;
   } else {
     return split;

package/lib/image/transform/mask/yen.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = yen;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // Implements Yen  thresholding method
 // 1) Yen J.C., Chang F.J., and Chang S. (1995) "A New Criterion
@@ -18,49 +17,38 @@ exports.default = yen;
 // M. Emre Celebi
 // 06.15.2007
 // Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+
 function yen(histogram, total) {
   let normHisto = new Array(histogram.length); // normalized histogram
-
   for (let ih = 0; ih < histogram.length; ih++) {
     normHisto[ih] = histogram[ih] / total;
   }
-
   let P1 = new Array(histogram.length); // cumulative normalized histogram
-
   P1[0] = normHisto[0];
-
   for (let ih = 1; ih < histogram.length; ih++) {
     P1[ih] = P1[ih - 1] + normHisto[ih];
   }
-
   let P1Sq = new Array(histogram.length);
   P1Sq[0] = normHisto[0] * normHisto[0];
-
   for (let ih = 1; ih < histogram.length; ih++) {
     P1Sq[ih] = P1Sq[ih - 1] + normHisto[ih] * normHisto[ih];
   }
-
   let P2Sq = new Array(histogram.length);
   P2Sq[histogram.length - 1] = 0.0;
-
   for (let ih = histogram.length - 2; ih >= 0; ih--) {
     P2Sq[ih] = P2Sq[ih + 1] + normHisto[ih + 1] * normHisto[ih + 1];
   }
-  /* Find the threshold that maximizes the criterion */
-
 
+  /* Find the threshold that maximizes the criterion */
   let threshold = -1;
   let maxCrit = Number.MIN_VALUE;
   let crit;
-
   for (let it = 0; it < histogram.length; it++) {
     crit = -1.0 * (P1Sq[it] * P2Sq[it] > 0.0 ? Math.log(P1Sq[it] * P2Sq[it]) : 0.0) + 2 * (P1[it] * (1.0 - P1[it]) > 0.0 ? Math.log(P1[it] * (1.0 - P1[it])) : 0.0);
-
     if (crit > maxCrit) {
       maxCrit = crit;
       threshold = it;
     }
   }
-
   return threshold;
 }

package/lib/image/transform/pad.js

@@ -4,15 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = pad;
-
 var _newArray = _interopRequireDefault(require("new-array"));
-
 var _Image = _interopRequireDefault(require("../Image"));
-
 var _copy = _interopRequireDefault(require("../internal/copy"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 /**
  * @memberof Image
  * @instance
@@ -31,12 +26,10 @@ function pad(options = {}) {
   this.checkProcessable('pad', {
     bitDepth: [8, 16]
   });
-
   if (algorithm === 'set') {
     if (color.length !== this.channels) {
       throw new Error(`pad: the color array must have the same length as the number of channels. Here: ${this.channels}`);
     }
-
     for (let i = 0; i < color.length; i++) {
       if (color[i] === 0) {
         color[i] = 0.001;
@@ -45,53 +38,40 @@ function pad(options = {}) {
   } else {
     color = (0, _newArray.default)(this.channels, null);
   }
-
   if (!Array.isArray(size)) {
     size = [size, size];
   }
-
   let newWidth = this.width + size[0] * 2;
   let newHeight = this.height + size[1] * 2;
   let channels = this.channels;
-
   let newImage = _Image.default.createFrom(this, {
     width: newWidth,
     height: newHeight
   });
-
   (0, _copy.default)(this, newImage, size[0], size[1]);
-
   for (let i = size[0]; i < newWidth - size[0]; i++) {
     for (let k = 0; k < channels; k++) {
       let value = color[k] || newImage.data[(size[1] * newWidth + i) * channels + k];
-
       for (let j = 0; j < size[1]; j++) {
         newImage.data[(j * newWidth + i) * channels + k] = value;
       }
-
       value = color[k] || newImage.data[((newHeight - size[1] - 1) * newWidth + i) * channels + k];
-
       for (let j = newHeight - size[1]; j < newHeight; j++) {
         newImage.data[(j * newWidth + i) * channels + k] = value;
       }
     }
   }
-
   for (let j = 0; j < newHeight; j++) {
     for (let k = 0; k < channels; k++) {
       let value = color[k] || newImage.data[(j * newWidth + size[0]) * channels + k];
-
       for (let i = 0; i < size[0]; i++) {
         newImage.data[(j * newWidth + i) * channels + k] = value;
       }
-
       value = color[k] || newImage.data[(j * newWidth + newWidth - size[0] - 1) * channels + k];
-
       for (let i = newWidth - size[0]; i < newWidth; i++) {
         newImage.data[(j * newWidth + i) * channels + k] = value;
       }
     }
   }
-
   return newImage;
 }

package/lib/image/transform/resize/nearestNeighbor.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = nearestNeighbor;
-
 /**
  * Nearest neighbor resizing algorithm
  * @private
@@ -15,14 +14,11 @@ exports.default = nearestNeighbor;
 function nearestNeighbor(newImage, newWidth, newHeight) {
   const wRatio = this.width / newWidth;
   const hRatio = this.height / newHeight;
-
   if (this.bitDepth > 1) {
     for (let i = 0; i < newWidth; i++) {
       const w = Math.floor((i + 0.5) * wRatio);
-
       for (let j = 0; j < newHeight; j++) {
         const h = Math.floor((j + 0.5) * hRatio);
-
         for (let c = 0; c < this.channels; c++) {
           newImage.setValueXY(i, j, c, this.getValueXY(w, h, c));
         }
@@ -31,10 +27,8 @@ function nearestNeighbor(newImage, newWidth, newHeight) {
   } else {
     for (let i = 0; i < newWidth; i++) {
       const w = Math.floor((i + 0.5) * wRatio);
-
       for (let j = 0; j < newHeight; j++) {
         const h = Math.floor((j + 0.5) * hRatio);
-
         if (this.getBitXY(w, h)) {
           newImage.setBitXY(i, j);
         }