image-js 0.0.0-next-e30968a2d8

package/src/operations/thresholds/li.ts

@@ -0,0 +1,81 @@
+/*
+ * 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
+ * This implementation is based on the iterative version (Ref. 2nd reference below) of the algorithm.
+ *  1) Li, CH & Lee, CK (1993), "Minimum Cross Entropy Thresholding", Pattern Recognition 26(4): 61 625
+ *  2) Li, CH & Tam, PKS (1998), "An Iterative Algorithm for Minimum Cross Entropy Thresholding",
+ *     Pattern Recognition Letters 18(8): 771-776
+ *  3) Sezgin, M & Sankur, B (2004), "Survey over Image Thresholding Techniques and Quantitative Performance
+ *     Evaluation",Journal of Electronic Imaging 13(1): 146-165
+ * @param histogram - the histogram of the image
+ * @param total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram using Li algorithm.
+ *
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function li(histogram: Uint32Array, total: number): number {
+  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 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 */
+  const tolerance = 0.5; /* threshold tolerance */
+  let temp;
+
+  /* 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 */
+
+    /* 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 */
+    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 {
+      newThresh = (temp + 0.5) | 0;
+    }
+    /*  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/src/operations/thresholds/maxEntropy.ts

@@ -0,0 +1,89 @@
+/*
+ * 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:
+ * Kapur, JN; Sahoo, PK & Wong, ACK (1985), "A New Method for Gray-Level Picture Thresholding Using the Entropy of the Histogram",
+ * Graphical Models and Image Processing 29(3): 273-285
+ * @param histogram - the histogram of the image
+ *        total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram using maximal enthropy algorithm.
+ *
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function maxEntropy(
+  histogram: Uint32Array,
+  total: number,
+): number {
+  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 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 */
+    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 */
+    totEnt = entBack + entObj;
+
+    if (maxEnt < totEnt) {
+      maxEnt = totEnt;
+      threshold = it;
+    }
+  }
+  return threshold;
+}

package/src/operations/thresholds/mean.ts

@@ -0,0 +1,23 @@
+/*
+ * 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",
+ * CVGIP: Graphical Models and Image Processing 55: 532-537
+ * @param histogram - the histogram of the image
+ * @param total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram by making its average.
+ *
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function mean(histogram: Uint32Array, total: number): number {
+  let sum = 0;
+  for (let i = 0; i < histogram.length; i++) {
+    sum += i * histogram[i];
+  }
+  return Math.floor(sum / total);
+}

package/src/operations/thresholds/minError.ts

@@ -0,0 +1,102 @@
+/*
+ * 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
+ */
+
+/**
+ * Return a threshold for a histogram using Li algorithm.
+ *
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function minError(
+  histogram: Uint32Array,
+  total: number,
+): number {
+  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: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += y[i];
+  }
+  return x;
+}
+
+function sumB(y: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += i * y[i];
+  }
+  return x;
+}
+
+function sumC(y: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += i * i * y[i];
+  }
+  return x;
+}

package/src/operations/thresholds/minimum.ts

@@ -0,0 +1,78 @@
+// 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
+
+/**
+ * Return a threshold for a histogram.
+ *
+ * @param histogram - Image histogram.
+ * @returns The threshold.
+ */
+export default function minimum(histogram: Uint32Array): number {
+  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;
+    }
+  }
+  for (let i = 1; i < max; i++) {
+    if (
+      histogramCopy[i - 1] > histogramCopy[i] &&
+      histogramCopy[i + 1] >= histogramCopy[i]
+    ) {
+      threshold = i;
+      break;
+    }
+  }
+  return threshold;
+}
+function smoothed(histogram: number[]): number[] {
+  // 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 bimodalTest(histogram: number[]): boolean {
+  // 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.ts

@@ -0,0 +1,60 @@
+// 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
+
+/**
+ * Return a threshold for a histogram.
+ *
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function moments(histogram: Uint32Array, total: number): number {
+  // 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/otsu.ts

@@ -0,0 +1,42 @@
+/*
+ * 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
+ */
+
+/**
+ * Return a threshold for a histogram using Otsu algorithm.
+ *
+ * @param histogramCounts - The image histogram.
+ * @param total - Total number of pixels of the image.
+ * @returns The threshold.
+ */
+export function otsu(histogramCounts: Uint32Array, total: number): number {
+  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/src/operations/thresholds/percentile.ts

@@ -0,0 +1,40 @@
+// 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.
+
+/**
+ * Return a threshold for a histogram using percentiles.
+ *
+ * @param histogram - Image histogram.
+ * @returns The threshold.
+ */
+export default function percentile(histogram: Uint32Array): number {
+  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: Uint32Array, endIndex: number): number {
+  let x = 0;
+  for (let i = 0; i <= endIndex; i++) {
+    x += histogram[i];
+  }
+  return x;
+}

package/src/operations/thresholds/renyiEntropy.ts

@@ -0,0 +1,148 @@
+// 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
+
+/**
+ * Return a threshold for a histogram using its entropy.
+ *
+ * @param histogram - The image histogram.
+ * @param total - Total number of pixels of the image.
+ * @returns The threshold.
+ */
+export default function renyiEntropy(histogram: Uint32Array, total: number) {
+  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); // accumulative normalized histogram
+  const P2 = new Array(histogram.length); // accumulative 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 = new Uint32Array([threshold1, threshold2, threshold3]);
+  tStars.sort();
+
+  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;
+}