image-js 0.35.1 → 0.35.3

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = intermodes;
-
 /*
  *
  * see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
@@ -12,60 +11,50 @@ exports.default = intermodes;
  * "The analysis of cell images", Annals of the NewYork Academy of Sciences 128: 1035-1053
  *
  */
+
 function intermodes(histogram) {
   let iHisto = histogram.slice();
   let iter = 0;
-
   while (!bimodalTest(iHisto)) {
     // smooth with a 3 point running mean filter
     let previous = 0;
     let current = 0;
     let next = iHisto[0];
-
     for (let i = 0; i < histogram.length - 1; i++) {
       previous = current;
       current = next;
       next = iHisto[i + 1];
       iHisto[i] = (previous + current + next) / 3;
     }
-
     iHisto[histogram.length - 1] = (current + next) / 3;
     iter++;
-
     if (iter > 10000) {
       throw new Error('Intermodes Threshold not found after 10000 iterations');
     }
-  } // The threshold is the mean between the two peaks.
-
+  }
 
+  // The threshold is the mean between the two peaks.
   let tt = 0;
-
   for (let i = 1; i < histogram.length - 1; i++) {
     if (iHisto[i - 1] < iHisto[i] && iHisto[i + 1] < iHisto[i]) {
       tt += i;
     }
   }
-
   return Math.floor(tt / 2.0);
 }
-
 function bimodalTest(iHisto) {
   let b = false;
   let modes = 0;
-
   for (let k = 1; k < iHisto.length - 1; k++) {
     if (iHisto[k - 1] < iHisto[k] && iHisto[k + 1] < iHisto[k]) {
       modes++;
-
       if (modes > 2) {
         return false;
       }
     }
   }
-
   if (modes === 2) {
     b = true;
   }
-
   return b;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = isodata;
-
 /*
  * see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
  * Isodata: Ridler, TW & Calvard, S (1978), "Picture thresholding using an iterative selection method"
@@ -13,13 +12,9 @@ exports.default = isodata;
  */
 function isodata(histogram) {
   let l; // the average grey value of pixels with intensities < g
-
   let toth; // the the average grey value of pixels with intensities > g
-
   let totl; // the total the average grey value of pixels with intensities < g
-
   let h; // the average grey value of pixels with intensities > g
-
   let g = 0; // threshold value
 
   for (let i = 1; i < histogram.length; i++) {
@@ -28,39 +23,30 @@ function isodata(histogram) {
       break;
     }
   }
-
   while (true) {
     l = 0;
     totl = 0;
-
     for (let i = 0; i < g; i++) {
       totl = totl + histogram[i];
       l = l + histogram[i] * i;
     }
-
     h = 0;
     toth = 0;
-
     for (let i = g + 1; i < histogram.length; i++) {
       toth += histogram[i];
       h += histogram[i] * i;
     }
-
     if (totl > 0 && toth > 0) {
       l /= totl;
       h /= toth;
-
       if (g === Math.round((l + h) / 2.0)) {
         break;
       }
     }
-
     g++;
-
     if (g > histogram.length - 2) {
       throw new Error('Threshold not found');
     }
   }
-
   return g;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = li;
-
 /*
  * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
  * The method is present in: Implements Li's Minimum Cross Entropy thresholding method
@@ -18,80 +17,53 @@ exports.default = li;
  * @param total - the number of pixels in the image
  * @returns {number} - the threshold
  */
+
 function li(histogram, total) {
   let threshold;
-  let sumBack;
-  /* sum of the background pixels at a given threshold */
-
-  let sumObj;
-  /* sum of the object pixels at a given threshold */
-
-  let numBack;
-  /* number of background pixels at a given threshold */
-
-  let numObj;
-  /* number of object pixels at a given threshold */
-
+  let sumBack; /* sum of the background pixels at a given threshold */
+  let sumObj; /* sum of the object pixels at a given threshold */
+  let numBack; /* number of background pixels at a given threshold */
+  let numObj; /* number of object pixels at a given threshold */
   let oldThresh;
   let newThresh;
-  let meanBack;
-  /* mean of the background pixels at a given threshold */
-
-  let meanObj;
-  /* mean of the object pixels at a given threshold */
-
-  let mean;
-  /* mean gray-level in the image */
-
-  let tolerance;
-  /* threshold tolerance */
-
+  let meanBack; /* mean of the background pixels at a given threshold */
+  let meanObj; /* mean of the object pixels at a given threshold */
+  let mean; /* mean gray-level in the image */
+  let tolerance; /* threshold tolerance */
   let temp;
   tolerance = 0.5;
-  /* Calculate the mean gray-level */
 
+  /* Calculate the mean gray-level */
   mean = 0.0;
-
   for (let ih = 0; ih < histogram.length; ih++) {
     mean += ih * histogram[ih];
   }
-
   mean /= total;
   /* Initial estimate */
-
   newThresh = mean;
-
   do {
     oldThresh = newThresh;
-    threshold = oldThresh + 0.5 | 0;
-    /* range */
+    threshold = oldThresh + 0.5 | 0; /* range */
 
     /* Calculate the means of background and object pixels */
-
     /* Background */
-
     sumBack = 0;
     numBack = 0;
-
     for (let ih = 0; ih <= threshold; ih++) {
       sumBack += ih * histogram[ih];
       numBack += histogram[ih];
     }
-
     meanBack = numBack === 0 ? 0.0 : sumBack / numBack;
-    /* Object */
 
+    /* Object */
     sumObj = 0;
     numObj = 0;
-
     for (let ih = threshold + 1; ih < histogram.length; ih++) {
       sumObj += ih * histogram[ih];
       numObj += histogram[ih];
     }
-
     meanObj = numObj === 0 ? 0.0 : sumObj / numObj;
     temp = (meanBack - meanObj) / (Math.log(meanBack) - Math.log(meanObj));
-
     if (temp < -Number.EPSILON) {
       newThresh = temp - 0.5 | 0;
     } else {
@@ -99,8 +71,6 @@ function li(histogram, total) {
     }
     /*  Stop the iterations when the difference between the
          new and old threshold values is less than the tolerance */
-
   } while (Math.abs(newThresh - oldThresh) > tolerance);
-
   return threshold;
 }

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

@@ -4,16 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = mask;
-
 var _converter = require("../../../util/converter");
-
 var _Image = _interopRequireDefault(require("../../Image"));
-
 var _getThreshold = _interopRequireDefault(require("../../utility/getThreshold"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const THRESHOLD = 'threshold';
+
 /**
  * Creation of binary mask is based on the determination of a threshold
  * You may either choose among the provided algorithm or just specify a threshold value
@@ -26,7 +22,6 @@ const THRESHOLD = 'threshold';
  * @param {boolean} [options.invert=false] - Invert the resulting image
  * @return {Image} - Binary image containing the mask
  */
-
 function mask(options = {}) {
   let {
     algorithm = THRESHOLD,
@@ -38,27 +33,22 @@ function mask(options = {}) {
     components: 1,
     bitDepth: [8, 16]
   });
-
   if (algorithm === THRESHOLD) {
     threshold = (0, _converter.getThreshold)(threshold, this.maxValue);
   } else {
     threshold = _getThreshold.default.call(this, options);
   }
-
   let newImage = new _Image.default(this.width, this.height, {
     kind: 'BINARY',
     parent: this
   });
   let ptr = 0;
-
   if (this.alpha && useAlpha) {
     for (let i = 0; i < this.data.length; i += this.channels) {
       let value = this.data[i] + (this.maxValue - this.data[i]) * (this.maxValue - this.data[i + 1]) / this.maxValue;
-
       if (invert && value <= threshold || !invert && value >= threshold) {
         newImage.setBit(ptr);
       }
-
       ptr++;
     }
   } else {
@@ -66,10 +56,8 @@ function mask(options = {}) {
       if (invert && this.data[i] <= threshold || !invert && this.data[i] >= threshold) {
         newImage.setBit(ptr);
       }
-
       ptr++;
     }
   }
-
   return newImage;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = maxEntropy;
-
 /*
  * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
  * The method is present in: Implements Kapur-Sahoo-Wong (Maximum Entropy) thresholding method:
@@ -14,86 +13,70 @@ exports.default = maxEntropy;
  *        total - the number of pixels in the image
  * @returns {number} - the threshold
  */
+
 function maxEntropy(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 totEnt; // total entropy
-
   let maxEnt = Number.MIN_VALUE; // max 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;
-
     for (let ih = 0; ih <= it; ih++) {
       if (histogram[ih] !== 0) {
         entBack -= normHisto[ih] / P1[it] * Math.log(normHisto[ih] / P1[it]);
       }
     }
-    /* Entropy of the object pixels */
-
 
+    /* Entropy of the object pixels */
     entObj = 0.0;
-
     for (let ih = it + 1; ih < histogram.length; ih++) {
       if (histogram[ih] !== 0) {
         entObj -= normHisto[ih] / P2[it] * Math.log(normHisto[ih] / P2[it]);
       }
     }
-    /* Total entropy */
-
 
+    /* Total entropy */
     totEnt = entBack + entObj;
-
     if (maxEnt < totEnt) {
       maxEnt = totEnt;
       threshold = it;
     }
   }
-
   return threshold;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = mean;
-
 /*
  * The method is present in: Uses the mean of grey levels as the threshold. It is described in:
  * Glasbey, CA (1993), "An analysis of histogram-based thresholding algorithms",
@@ -13,12 +12,11 @@ exports.default = mean;
  * @param total - the number of pixels in the image
  * @returns {number} - the threshold
  */
+
 function mean(histogram, total) {
   let sum = 0;
-
   for (let i = 0; i < histogram.length; i++) {
     sum += i * histogram[i];
   }
-
   return Math.floor(sum / total);
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = minError;
-
 /*
  * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
  * The method is present in: An iterative implementation of Kittler and Illingworth's Minimum Error
@@ -13,21 +12,19 @@ exports.default = minError;
  * @param total - the number of pixels in the image
  * @returns {number} - the threshold
  */
+
 function minError(histogram, total) {
   let threshold;
   let Tprev = -2;
   let mu, nu, p, q, sigma2, tau2, w0, w1, w2, sqterm, temp;
-  /* Calculate the mean gray-level */
 
+  /* Calculate the mean gray-level */
   let mean = 0.0;
-
   for (let ih = 0; ih < histogram.length; ih++) {
     mean += ih * histogram[ih];
   }
-
   mean /= total;
   threshold = mean;
-
   while (threshold !== Tprev) {
     // Calculate some statistics.
     let sumA1 = sumA(histogram, threshold);
@@ -41,59 +38,51 @@ function minError(histogram, total) {
     p = sumA1 / sumA2;
     q = (sumA2 - sumA1) / sumA2;
     sigma2 = sumC1 / sumA1 - mu * mu;
-    tau2 = (sumC2 - sumC1) / (sumA2 - sumA1) - nu * nu; // The terms of the quadratic equation to be solved.
+    tau2 = (sumC2 - sumC1) / (sumA2 - sumA1) - nu * nu;
 
+    // The terms of the quadratic equation to be solved.
     w0 = 1.0 / sigma2 - 1.0 / tau2;
     w1 = mu / sigma2 - nu / tau2;
-    w2 = mu * mu / sigma2 - nu * nu / tau2 + Math.log10(sigma2 * (q * q) / (tau2 * (p * p))); // If the next threshold would be imaginary, return with the current one.
+    w2 = mu * mu / sigma2 - nu * nu / tau2 + Math.log10(sigma2 * (q * q) / (tau2 * (p * p)));
 
+    // If the next threshold would be imaginary, return with the current one.
     sqterm = w1 * w1 - w0 * w2;
-
     if (sqterm < 0) {
       return threshold;
-    } // The updated threshold is the integer part of the solution of the quadratic equation.
-
+    }
 
+    // The updated threshold is the integer part of the solution of the quadratic equation.
     Tprev = threshold;
     temp = (w1 + Math.sqrt(sqterm)) / w0;
-
     if (isNaN(temp)) {
       threshold = Tprev;
     } else {
       threshold = Math.floor(temp);
     }
   }
-
   return threshold;
-} // aux func
+}
 
+// aux func
 
 function sumA(y, j) {
   let x = 0;
-
   for (let i = 0; i <= j; i++) {
     x += y[i];
   }
-
   return x;
 }
-
 function sumB(y, j) {
   let x = 0;
-
   for (let i = 0; i <= j; i++) {
     x += i * y[i];
   }
-
   return x;
 }
-
 function sumC(y, j) {
   let x = 0;
-
   for (let i = 0; i <= j; i++) {
     x += i * i * y[i];
   }
-
   return x;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = minimum;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // J. M. S. Prewitt and M. L. Mendelsohn, "The analysis of cell images," in
 // Annals of the New York Academy of Sciences, vol. 128, pp. 1035-1053, 1966.
@@ -17,81 +16,62 @@ function minimum(histogram) {
     // validate that the histogram has at least two color values
     return 0;
   }
-
   let iterations = 0; // number of iterations of the smoothing process
-
   let threshold = -1;
   let max = -1; // maximum color value with a greater number of pixels to 0
-
   let histogramCopy = new Array(histogram.length); // a copy of the histogram
-
   for (let i = 0; i < histogram.length; i++) {
     histogramCopy[i] = histogram[i];
-
     if (histogram[i] > 0) {
       max = i;
     }
   }
-
   while (!bimodalTest(histogramCopy)) {
     histogramCopy = smoothed(histogramCopy);
     iterations++;
-
     if (iterations > 10000) {
       // if they occur more than 10000 iterations it returns -1
       return threshold;
     }
   }
-
   threshold = minimumBetweenPeeks(histogramCopy, max);
   return threshold;
 }
-
 function smoothed(histogram) {
   // Smooth with a 3 point running mean filter
   let auHistogram = new Array(histogram.length); // a copy of the histograma for the smoothing process
-
   for (let i = 1; i < histogram.length - 1; i++) {
     auHistogram[i] = (histogram[i - 1] + histogram[i] + histogram[i + 1]) / 3;
   }
-
   auHistogram[0] = (histogram[0] + histogram[1]) / 3;
   auHistogram[histogram.length - 1] = (histogram[histogram.length - 2] + histogram[histogram.length - 1]) / 3;
   return auHistogram;
 }
-
 function minimumBetweenPeeks(histogramBimodal, max) {
   let threshold;
-
   for (let i = 1; i < max; i++) {
     if (histogramBimodal[i - 1] > histogramBimodal[i] && histogramBimodal[i + 1] >= histogramBimodal[i]) {
       threshold = i;
       break;
     }
   }
-
   return threshold;
 }
-
 function bimodalTest(histogram) {
   // It is responsible for determining if a histogram is bimodal
   let len = histogram.length;
   let isBimodal = false;
   let peaks = 0;
-
   for (let k = 1; k < len - 1; k++) {
     if (histogram[k - 1] < histogram[k] && histogram[k + 1] < histogram[k]) {
       peaks++;
-
       if (peaks > 2) {
         return false;
       }
     }
   }
-
   if (peaks === 2) {
     isBimodal = true;
   }
-
   return isBimodal;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = moments;
-
 // see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
 // W. Tsai, "Moment-preserving thresholding: a new approach," Computer Vision,
 // Graphics, and Image Processing, vol. 29, pp. 377-393, 1985.
@@ -21,19 +20,14 @@ function moments(histogram, total) {
   let m3 = 0.0;
   let sum = 0.0;
   let p0;
-  let cd, c0, c1, z0, z1;
-  /* auxiliary variables */
-
+  let cd, c0, c1, z0, z1; /* auxiliary variables */
   let threshold = -1;
   let histogramLength = histogram.length;
   let normalizedHistogram = new Array(histogramLength);
-
   for (let i = 0; i < histogramLength; i++) {
     normalizedHistogram[i] = histogram[i] / total;
   }
   /* Calculate the first, second, and third order moments */
-
-
   for (let i = 0; i < histogramLength; i++) {
     m1 += i * normalizedHistogram[i];
     m2 += i * i * normalizedHistogram[i];
@@ -44,27 +38,20 @@ function moments(histogram, total) {
      of the target binary image. This leads to 4 equalities whose solutions
      are given in the Appendix of Ref. 1
      */
-
-
   cd = m0 * m2 - m1 * m1; // determinant of the matriz of hankel for moments 2x2
-
   c0 = (-m2 * m2 + m1 * m3) / cd;
-  c1 = (m0 * -m3 + m2 * m1) / cd; // new two gray values where z0<z1
-
+  c1 = (m0 * -m3 + m2 * m1) / cd;
+  // new two gray values where z0<z1
   z0 = 0.5 * (-c1 - Math.sqrt(c1 * c1 - 4.0 * c0));
   z1 = 0.5 * (-c1 + Math.sqrt(c1 * c1 - 4.0 * c0));
-  p0 = (z1 - m1) / (z1 - z0);
-  /* Fraction of the object pixels in the target binary image (p0z0+p1z1=m1) */
+  p0 = (z1 - m1) / (z1 - z0); /* Fraction of the object pixels in the target binary image (p0z0+p1z1=m1) */
   // The threshold is the gray-level closest to the p0-tile of the normalized histogram
-
   for (let i = 0; i < histogramLength; i++) {
     sum += normalizedHistogram[i];
-
     if (sum > p0) {
       threshold = i;
       break;
     }
   }
-
   return threshold;
 }