image-js 1.0.0-alpha.3 → 1.1.0

package/src/operations/thresholds/minError.js

@@ -1,92 +0,0 @@
-/*
- * 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
- * thresholding:Kittler, J & Illingworth, J (1986), "Minimum error thresholding", Pattern Recognition 19: 41-47
- * @param histogram - the histogram of the image
- * @param total - the number of pixels in the image
- * @returns {number} - the threshold
- */
-
-export default 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 */
-  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.
-    const sumA1 = sumA(histogram, threshold);
-    const sumA2 = sumA(histogram, histogram.length - 1);
-    const sumB1 = sumB(histogram, threshold);
-    const sumB2 = sumB(histogram, histogram.length - 1);
-    const sumC1 = sumC(histogram, threshold);
-    const sumC2 = sumC(histogram, histogram.length - 1);
-
-    mu = sumB1 / sumA1;
-    nu = (sumB2 - sumB1) / (sumA2 - sumA1);
-    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.
-    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.
-    sqterm = w1 * w1 - w0 * w2;
-    if (sqterm < 0) {
-      return threshold;
-    }
-
-    // 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
-
-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/src/operations/thresholds/minimum.js

@@ -1,75 +0,0 @@
-// 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.
-// ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
-// Original Matlab code Copyright (C) 2004 Antti Niemisto
-// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
-// and the original Matlab code
-export default function minimum(histogram) {
-  if (histogram.length < 2) {
-    // 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
-  const 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
-  const 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/src/operations/thresholds/moments.js

@@ -1,52 +0,0 @@
-// 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.
-// Ported to ImageJ plugin by G.Landini from the the open source project FOURIER 0.8
-// by M. Emre Celebi , Department of Computer Science, Louisiana State University in Shreveport
-// Shreveport, LA 71115, USA
-// http://sourceforge.net/projects/fourier-ipal
-// http://www.lsus.edu/faculty/~ecelebi/fourier.htm
-export default function moments(histogram, total) {
-  // moments
-  const m0 = 1.0;
-  let m1 = 0.0;
-  let m2 = 0.0;
-  let m3 = 0.0;
-  let sum = 0.0;
-  let threshold = -1;
-  const histogramLength = histogram.length;
-  const 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];
-    m3 += i * i * i * normalizedHistogram[i];
-  }
-  /*
-     First 4 moments of the gray-level image should match the first 4 moments
-     of the target binary image. This leads to 4 equalities whose solutions
-     are given in the Appendix of Ref. 1
-     */
-  const cd = m0 * m2 - m1 * m1; // determinant of the matriz of hankel for moments 2x2
-  const c0 = (-m2 * m2 + m1 * m3) / cd;
-  const c1 = (m0 * -m3 + m2 * m1) / cd;
-  // new two gray values where z0<z1
-  const z0 = 0.5 * (-c1 - Math.sqrt(c1 * c1 - 4.0 * c0));
-  const z1 = 0.5 * (-c1 + Math.sqrt(c1 * c1 - 4.0 * c0));
-  const 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;
-}

package/src/operations/thresholds/percentile.js

@@ -1,33 +0,0 @@
-// 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.
-// ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
-// Original Matlab code Copyright (C) 2004 Antti Niemisto
-// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
-// and the original Matlab code.
-export default function percentile(histogram) {
-  let threshold = -1;
-  const percentile = 0.5; // default fraction of foreground pixels
-  const avec = new Array(histogram.length);
-
-  const 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/src/operations/thresholds/renyiEntropy.js

@@ -1,142 +0,0 @@
-// 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"
-// Graphical Models and Image Processing, 29(3): 273-285
-// M. Emre Celebi
-// 06.15.2007
-// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
-import { asc as sortAsc } from 'num-sort';
-
-export default function renyiEntropy(histogram, total) {
-  let firstBin; // First non-zero bin
-  let lastBin; // last non-zero bin
-
-  const normHisto = new Array(histogram.length); // normalized histogram
-  const P1 = new Array(histogram.length); // acumulative normalized histogram
-  const P2 = new Array(histogram.length); // acumulative normalized histogram
-
-  // Entropy Variables
-  let threshold1 = 0;
-  let threshold2 = 0;
-  let threshold3 = 0;
-  let maxEnt1 = 0.0;
-  let maxEnt2 = 0.0;
-  let maxEnt3 = 0.0;
-  const alpha2 = 0.5;
-  const term2 = 1.0 / (1.0 - alpha2);
-  const alpha3 = 2.0;
-  const 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 */
-  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 */
-  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 */
-  /* 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 */
-    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 */
-    const totEnt1 = entBack1 + entObj1;
-    const totEnt2 =
-      term2 * (entBack2 * entObj2 > 0.0 ? Math.log(entBack2 * entObj2) : 0.0);
-    const 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;
-    }
-  }
-  /* End Maximum Entropy Thresholding */
-
-  const tStars = [threshold1, threshold2, threshold3];
-  tStars.sort(sortAsc);
-
-  let betas;
-
-  /* Adjust beta values */
-  if (Math.abs(tStars[0] - tStars[1]) <= 5) {
-    if (Math.abs(tStars[1] - tStars[2]) <= 5) {
-      betas = [1, 2, 1];
-    } else {
-      betas = [0, 1, 3];
-    }
-  } else {
-    if (Math.abs(tStars[1] - tStars[2]) <= 5) {
-      betas = [3, 1, 0];
-    } else {
-      betas = [1, 2, 1];
-    }
-  }
-
-  /* Determine the optimal threshold value */
-  const omega = P1[tStars[2]] - P1[tStars[0]];
-  const 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/src/operations/thresholds/shanbhag.js

@@ -1,74 +0,0 @@
-// 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
-
-export default function shanbhag(histogram, total) {
-  const normHisto = new Array(histogram.length); // normalized histogram
-  for (let ih = 0; ih < histogram.length; ih++) {
-    normHisto[ih] = histogram[ih] / total;
-  }
-
-  const P1 = new Array(histogram.length); // cumulative normalized histogram
-  const 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 */
-  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 */
-  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
-  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 */
-    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 */
-    totEnt = Math.abs(entBack - entObj);
-
-    if (totEnt < minEnt) {
-      minEnt = totEnt;
-      threshold = it;
-    }
-  }
-  return threshold;
-}

package/src/operations/thresholds/yen.js

@@ -1,56 +0,0 @@
-// 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
-//    for Automatic Multilevel Thresholding" IEEE Trans. on Image
-//    Processing, 4(3): 370-378
-// 2) Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding
-//    Techniques and Quantitative Performance Evaluation" Journal of
-//    Electronic Imaging, 13(1): 146-165
-//    http://citeseer.ist.psu.edu/sezgin04survey.html
-//
-// M. Emre Celebi
-// 06.15.2007
-// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
-
-export default function yen(histogram, total) {
-  const normHisto = new Array(histogram.length); // normalized histogram
-  for (let ih = 0; ih < histogram.length; ih++) {
-    normHisto[ih] = histogram[ih] / total;
-  }
-
-  const 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];
-  }
-
-  const 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];
-  }
-
-  const 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 */
-  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/src/types.ts

@@ -1,13 +0,0 @@
-export enum BorderType {
-  CONSTANT = 'CONSTANT',
-  REPLICATE = 'REPLICATE',
-  REFLECT = 'REFLECT',
-  WRAP = 'WRAP',
-  REFLECT_101 = 'REFLECT_101'
-}
-
-export enum InterpolationType {
-  NEAREST = 'NEAREST',
-  BILINEAR = 'BILINEAR',
-  BICUBIC = 'BICUBIC'
-}

package/src/utils/kinds.ts

@@ -1,27 +0,0 @@
-import { ImageKind } from '../Image';
-
-interface IKindDefinitions {
-  [key: string]: {
-    channels: number;
-    alpha: boolean;
-  };
-}
-
-export const kindDefinitions: IKindDefinitions = {
-  [ImageKind.GREY]: {
-    channels: 1,
-    alpha: false
-  },
-  [ImageKind.GREYA]: {
-    channels: 2,
-    alpha: true
-  },
-  [ImageKind.RGB]: {
-    channels: 3,
-    alpha: false
-  },
-  [ImageKind.RGBA]: {
-    channels: 4,
-    alpha: true
-  }
-};

package/src/utils/validators.ts

@@ -1,23 +0,0 @@
-import { Image } from '../Image';
-
-export function validateChannel(channel: number, image: Image): void {
-  if (!Number.isInteger(channel) || channel >= image.channels || channel < 0) {
-    throw new RangeError(
-      `invalid channel: ${channel}. It must be a positive integer smaller than ${
-        image.channels
-      }`
-    );
-  }
-}
-
-/**
- * Validates that a value passed by the user is smaller than the image's maxValue.
- */
-export function validateValue(value: number, image: Image): void {
-  if (!Number.isInteger(value) || value > image.maxValue || value < 0) {
-    throw new RangeError(
-      `invalid value: ${value}. It must be a positive integer smaller than ${image.maxValue +
-        1}`
-    );
-  }
-}