image-js 0.0.0-next-e30968a2d8

package/src/operations/thresholds/shanbhag.ts

@@ -0,0 +1,82 @@
+// 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
+
+/**
+ * Return a threshold for a histogram using Shanbhag algorithm.
+ *
+ * @param histogram - The image histogram.
+ * @param histogrami
+ * @param total - Total number of pixels of the image.
+ * @returns The threshold.
+ */
+export default function shanbhag(histogram: Uint32Array, total: 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 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/triangle.ts

@@ -0,0 +1,115 @@
+// 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,
+// Journal of Histochemistry and Cytochemistry 25 (7), pp. 741-753
+//
+//  modified from Johannes Schindelin plugin
+
+/**
+ * Return a threshold for a histogram using Triangle algorithm.
+ *
+ * @param histogram - The image histogram.
+ * @returns The threshold.
+ */
+export function triangle(histogram: Uint32Array): number {
+  // find min and max
+  let min = 0;
+  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.
+  // 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
+  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
+      const temp = histogram[left];
+      histogram[left] = histogram[right];
+      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
+  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
+  let split = min;
+  let splitDistance = 0;
+  for (let i = min + 1; i <= max; i++) {
+    const 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) {
+      const temp = histogram[left];
+      histogram[left] = histogram[right];
+      histogram[right] = temp;
+      left++;
+      right--;
+    }
+    return histogram.length - 1 - split;
+  } else {
+    return split;
+  }
+}

package/src/operations/thresholds/yen.ts

@@ -0,0 +1,63 @@
+// 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
+
+/**
+ * Return a threshold for a histogram using Yen algorithm.
+ *
+ * @param histogram - The image histogram.
+ * @param total - Total number of pixels of the image.
+ * @returns The threshold.
+ */
+export default function yen(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
+  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/roi/RoiManager.ts

@@ -0,0 +1,34 @@
+export enum RoiKind {
+  BLACK = 'BLACK',
+  WHITE = 'WHITE',
+  BW = 'BW',
+}
+
+export interface GetRoisOptions {
+  /**
+   * Minimal surface of the ROIs to keep
+   *
+   * @default 0
+   */
+  minSurface?: number;
+  /**
+   * Maximal surface of the ROIs to keep
+   *
+   * @default Number.POSITIVE_INFINITY
+   */
+  maxSurface?: number;
+  /**
+   * Kind of ROIs to keep
+   *
+   * @default 'BW'
+   */
+  kind?: RoiKind;
+}
+
+export interface Roi {
+  getSurface(): number;
+}
+
+export interface RoiManager {
+  getRois(options: GetRoisOptions): Roi[];
+}

package/src/roi/RoiMapManager.ts

@@ -0,0 +1,48 @@
+import { Matrix } from 'ml-matrix';
+
+import { Roi, RoiManager } from './RoiManager';
+
+export interface RoiMap {
+  /**
+   * Width of the map.
+   */
+  width: number;
+  /**
+   * Height of the map.
+   */
+  height: number;
+  /**
+   * Data of the ROIs. Each ROI is associated with a negative or a positive value,
+   * depending if it derives from a zone made of zeros or ones in the original mask.
+   */
+  data: Int16Array;
+  /**
+   * Number of distinct positive values in the ROI map
+   *
+   */
+  nbPositive: number;
+  /**
+   * Number of distinct negative values in the ROI map
+   *
+   */
+  nbNegative: number;
+}
+export class RoiMapManager implements RoiManager {
+  public map: RoiMap;
+
+  public constructor(map: RoiMap) {
+    this.map = map;
+  }
+
+  public getRois(): Roi[] {
+    return [];
+  }
+
+  public getMapMatrix(): number[][] {
+    return Matrix.from1DArray(
+      this.map.height,
+      this.map.width,
+      this.map.data,
+    ).to2DArray();
+  }
+}

package/src/roi/colorRois.ts

@@ -0,0 +1,69 @@
+import { IJS, ImageColorModel } from '..';
+
+import { colorMapCenter } from './utils/constants';
+import { getColorMap } from './utils/getColorMap';
+
+import { RoiKind, RoiMapManager } from '.';
+
+export enum RoisColorMode {
+  /**
+   * Only two acceptable values: red or green
+   */
+  BINARY = 'BINARY',
+  /**
+   * Palette of reds and blues.
+   */
+  SATURATION = 'SATURATION',
+  /**
+   * All possible hues (gradient of colors).
+   */
+  RAINBOW = 'RAINBOW',
+}
+
+export interface ColorRoisOptions {
+  /**
+   * Define the color mode to use to color the ROIs.
+   *
+   * @default ColorMode.BINARY
+   */
+  mode?: RoisColorMode;
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  roiKind?: RoiKind;
+}
+
+/**
+ * Generate an image with all the ROIs of various colors.
+ *
+ * @param roiMapManager - The ROI map manager.
+ * @param options - Color ROIs options.
+ * @returns The colored image.
+ */
+export function colorRois(
+  roiMapManager: RoiMapManager,
+  options: ColorRoisOptions = {},
+): IJS {
+  const { roiKind = RoiKind.BW, mode = RoisColorMode.BINARY } = options;
+
+  let image = new IJS(roiMapManager.map.width, roiMapManager.map.height, {
+    colorModel: ImageColorModel.RGBA,
+  });
+
+  const colorMap = getColorMap({
+    roiKind,
+    mode,
+    nbNegative: roiMapManager.map.nbNegative,
+    nbPositive: roiMapManager.map.nbPositive,
+  });
+
+  let data32 = new Uint32Array(image.getRawImage().data.buffer);
+
+  for (let index = 0; index < image.size; index++) {
+    data32[index] = colorMap[roiMapManager.map.data[index] + colorMapCenter];
+  }
+
+  return image;
+}

package/src/roi/fromMask.ts

@@ -0,0 +1,184 @@
+import { Mask } from '..';
+
+import { RoiMapManager } from './RoiMapManager';
+import { maxNumberRois, maxRoiId } from './utils/constants';
+
+export interface FromMaskOptions {
+  /**
+   * Consider pixels connected by corners as same ROI?
+   *
+   * @default false
+   */
+  allowCorners?: boolean;
+}
+
+/**
+ * Extract the ROIs of an image.
+ *
+ * @param mask - Mask to extract the ROIs from
+ * @param options - fromMask options
+ * @returns The corresponding ROI manager.
+ */
+export function fromMask(
+  mask: Mask,
+  options: FromMaskOptions = {},
+): RoiMapManager {
+  const { allowCorners = false } = options;
+
+  const MAX_ARRAY = maxNumberRois - 1; // 65535 should be enough for most of the cases
+
+  const maxPositiveId = maxRoiId - 1;
+  const maxNegativeId = -maxRoiId;
+
+  // based on a binary image we will create plenty of small images
+  let data = new Int16Array(mask.size); // maxValue: maxPositiveId, minValue: maxNegativeId
+
+  // split will always return an array of images
+  let positiveId = 0;
+  let negativeId = 0;
+
+  let columnToProcess = new Uint16Array(maxNumberRois);
+  let rowToProcess = new Uint16Array(maxNumberRois);
+
+  for (let column = 0; column < mask.width; column++) {
+    for (let row = 0; row < mask.height; row++) {
+      if (data[row * mask.width + column] === 0) {
+        // need to process the whole surface
+        analyseSurface(column, row);
+      }
+    }
+  }
+  // x column
+  // y row
+  function analyseSurface(column: number, row: number) {
+    let from = 0;
+    let to = 0;
+    let targetState = mask.getBit(row, column);
+    let id = targetState ? ++positiveId : --negativeId;
+    if (positiveId > maxPositiveId || negativeId < maxNegativeId) {
+      throw new Error('Too many regions of interest');
+    }
+    columnToProcess[0] = column;
+    rowToProcess[0] = row;
+    while (from <= to) {
+      let currentColumn = columnToProcess[from & MAX_ARRAY];
+      let currentRow = rowToProcess[from & MAX_ARRAY];
+      data[currentRow * mask.width + currentColumn] = id;
+      // need to check all around mask pixel
+      if (
+        currentColumn > 0 &&
+        data[currentRow * mask.width + currentColumn - 1] === 0 &&
+        mask.getBit(currentRow, currentColumn - 1) === targetState
+      ) {
+        // LEFT
+        to++;
+        columnToProcess[to & MAX_ARRAY] = currentColumn - 1;
+        rowToProcess[to & MAX_ARRAY] = currentRow;
+        data[currentRow * mask.width + currentColumn - 1] = maxNegativeId;
+      }
+      if (
+        currentRow > 0 &&
+        data[(currentRow - 1) * mask.width + currentColumn] === 0 &&
+        mask.getBit(currentRow - 1, currentColumn) === targetState
+      ) {
+        // TOP
+        to++;
+        columnToProcess[to & MAX_ARRAY] = currentColumn;
+        rowToProcess[to & MAX_ARRAY] = currentRow - 1;
+        data[(currentRow - 1) * mask.width + currentColumn] = maxNegativeId;
+      }
+      if (
+        currentColumn < mask.width - 1 &&
+        data[currentRow * mask.width + currentColumn + 1] === 0 &&
+        mask.getBit(currentRow, currentColumn + 1) === targetState
+      ) {
+        // RIGHT
+        to++;
+        columnToProcess[to & MAX_ARRAY] = currentColumn + 1;
+        rowToProcess[to & MAX_ARRAY] = currentRow;
+        data[currentRow * mask.width + currentColumn + 1] = maxNegativeId;
+      }
+      if (
+        currentRow < mask.height - 1 &&
+        data[(currentRow + 1) * mask.width + currentColumn] === 0 &&
+        mask.getBit(currentRow + 1, currentColumn) === targetState
+      ) {
+        // BOTTOM
+        to++;
+        columnToProcess[to & MAX_ARRAY] = currentColumn;
+        rowToProcess[to & MAX_ARRAY] = currentRow + 1;
+        data[(currentRow + 1) * mask.width + currentColumn] = maxNegativeId;
+      }
+      if (allowCorners) {
+        if (
+          currentColumn > 0 &&
+          currentRow > 0 &&
+          data[(currentRow - 1) * mask.width + currentColumn - 1] === 0 &&
+          mask.getBit(currentRow - 1, currentColumn - 1) === targetState
+        ) {
+          // TOP LEFT
+          to++;
+          columnToProcess[to & MAX_ARRAY] = currentColumn - 1;
+          rowToProcess[to & MAX_ARRAY] = currentRow - 1;
+          data[(currentRow - 1) * mask.width + currentColumn - 1] =
+            maxNegativeId;
+        }
+        if (
+          currentColumn < mask.width - 1 &&
+          currentRow > 0 &&
+          data[(currentRow - 1) * mask.width + currentColumn + 1] === 0 &&
+          mask.getBit(currentRow - 1, currentColumn + 1) === targetState
+        ) {
+          // TOP RIGHT
+          to++;
+          columnToProcess[to & MAX_ARRAY] = currentColumn + 1;
+          rowToProcess[to & MAX_ARRAY] = currentRow - 1;
+          data[(currentRow - 1) * mask.width + currentColumn + 1] =
+            maxNegativeId;
+        }
+        if (
+          currentColumn > 0 &&
+          currentRow < mask.height - 1 &&
+          data[(currentRow + 1) * mask.width + currentColumn - 1] === 0 &&
+          mask.getBit(currentRow + 1, currentColumn - 1) === targetState
+        ) {
+          // BOTTOM LEFT
+          to++;
+          columnToProcess[to & MAX_ARRAY] = currentColumn - 1;
+          rowToProcess[to & MAX_ARRAY] = currentRow + 1;
+          data[(currentRow + 1) * mask.width + currentColumn - 1] =
+            maxNegativeId;
+        }
+        if (
+          currentColumn < mask.width - 1 &&
+          currentRow < mask.height - 1 &&
+          data[(currentRow + 1) * mask.width + currentColumn + 1] === 0 &&
+          mask.getBit(currentRow + 1, currentColumn + 1) === targetState
+        ) {
+          // BOTTOM RIGHT
+          to++;
+          columnToProcess[to & MAX_ARRAY] = currentColumn + 1;
+          rowToProcess[to & MAX_ARRAY] = currentRow + 1;
+          data[(currentRow + 1) * mask.width + currentColumn + 1] =
+            maxNegativeId;
+        }
+      }
+
+      from++;
+
+      if (to - from > MAX_ARRAY) {
+        throw new Error(
+          'analyseMask can not finish, the array to manage internal data is not big enough.' +
+            'You could improve mask by changing MAX_ARRAY',
+        );
+      }
+    }
+  }
+  return new RoiMapManager({
+    width: mask.width,
+    height: mask.height,
+    data,
+    nbNegative: Math.abs(negativeId),
+    nbPositive: positiveId,
+  });
+}

package/src/roi/index.ts

@@ -0,0 +1,4 @@
+export * from './fromMask';
+export * from './RoiManager';
+export * from './RoiMapManager';
+export * from './colorRois';

package/src/roi/utils/colorMaps/getBinaryMap.ts

@@ -0,0 +1,72 @@
+import { RoiKind } from '../../RoiManager';
+import { maxNumberRois, colorMapCenter } from '../constants';
+import { hsvToRgb } from '../hsvToRgb';
+import { rgbToNumber } from '../rgbToNumber';
+
+// warning: the values in a uint32 array are flipped!! e.g. [0,0,0,1] becomes 0x01000000
+// the bits values are therefore in the following order: ABGR
+// index 32768 corresponds to the middle of the array
+
+export interface GetBinaryMapOptions {
+  /**
+   * Number of black ROIs
+   */
+  nbNegative: number;
+  /**
+   * Number of white ID ROIs
+   */
+  nbPositive: number;
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  roiKind?: RoiKind;
+  /**
+   * Hue of white ROIs
+   *
+   * @default 120
+   */
+  whiteHue?: number;
+  /**
+   * Hue of black ROIs
+   *
+   * @default 0
+   */
+  blackHue?: number;
+}
+
+/**
+ * Return a map where ROIs are red (negative) or green (positive) depending on the ROI index.
+ *
+ * @param options - Color maps options.
+ * @returns The colored map.
+ */
+export function getBinaryMap(options: GetBinaryMapOptions): Uint32Array {
+  const {
+    nbNegative,
+    nbPositive,
+    whiteHue = 120,
+    blackHue = 0,
+    roiKind = RoiKind.BW,
+  } = options;
+
+  let colorMap = new Uint32Array(maxNumberRois);
+
+  // negative values
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.BLACK) {
+    for (let i = colorMapCenter - nbNegative; i < colorMapCenter; i++) {
+      const hsv = [blackHue, 255, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+    }
+  }
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.WHITE) {
+    // positive values
+    for (let i = colorMapCenter + 1; i < colorMapCenter + 1 + nbPositive; i++) {
+      const hsv = [whiteHue, 255, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+    }
+  }
+
+  return colorMap;
+}