image-js 0.0.0-next-e30968a2d8

package/src/morphology/close.ts

@@ -0,0 +1,61 @@
+import { ColorDepth, IJS, Mask } from '..';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface CloseOptions {
+  /**
+   * 3x3 matrix. The kernel can only have ones and zeros.
+   * Accessing a value: kernel[row][column]
+   *
+   * @default [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+   */
+  kernel?: number[][];
+  /**
+   * Number of iterations of the algorithm.
+   *
+   * @default 1
+   */
+  iterations?: number;
+}
+
+export function close(image: IJS, options?: CloseOptions): IJS;
+export function close(image: Mask, options?: CloseOptions): Mask;
+/**
+ * In mathematical morphology, the closing of a set A by a structuring element B is the erosion of the dilation of that set (Wikipedia).
+ * In image processing, closing is, together with opening, the basic workhorse of morphological noise removal.
+ * Opening removes small objects, while closing removes small holes.
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.html
+ *
+ * @param image - Image to process.
+ * @param options - Close options.
+ * @returns Closed image.
+ */
+export function close(
+  image: IJS | Mask,
+  options: CloseOptions = {},
+): IJS | Mask {
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'close', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+
+  checkKernel(kernel, 'close');
+
+  let newImage = image;
+  for (let i = 0; i < iterations; i++) {
+    newImage = newImage.dilate({ kernel }).erode({ kernel });
+  }
+  return newImage;
+}

package/src/morphology/dilate.ts

@@ -0,0 +1,264 @@
+import { Mask } from '..';
+import { ColorDepth, IJS } from '../IJS';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface DilateOptions {
+  /**
+   * Matrix with odd dimensions (e.g. 1 by 3). The kernel can only have ones and zeros.
+   * Accessing a value: kernel[row][column]
+   *
+   * @default [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+   */
+  kernel?: number[][];
+  /**
+   * Number of iterations of the algorithm.
+   *
+   * @default 1
+   */
+  iterations?: number;
+}
+
+export function dilate(image: IJS, options?: DilateOptions): IJS;
+export function dilate(image: Mask, options?: DilateOptions): Mask;
+/**
+ * Dilatation is one of two fundamental operations (with erosion) in morphological
+ * image processing from which all other morphological operations are based (from Wikipedia).
+ * Replaces each value with it's local maximum among the pixels with a kernel value of 1.
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.html
+ * https://en.wikipedia.org/wiki/Dilation_(morphology)
+ *
+ * @param image - Image to dilate.
+ * @param options - Dilate options.
+ * @returns Dilated image.
+ */
+export function dilate(
+  image: IJS | Mask,
+  options: DilateOptions = {},
+): Mask | IJS {
+  let defaultKernel = false;
+  if (options.kernel === undefined) {
+    defaultKernel = true;
+  }
+
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'dilate', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+
+  checkKernel(kernel, 'dilate');
+
+  let onlyOnes = true;
+  if (!defaultKernel) {
+    outer: for (const row of kernel) {
+      for (const value of row) {
+        if (value !== 1) {
+          onlyOnes = false;
+          break outer;
+        }
+      }
+    }
+  }
+
+  let result = image;
+  for (let i = 0; i < iterations; i++) {
+    if (result instanceof Mask) {
+      if (onlyOnes) {
+        const newMask = result.clone();
+        result = dilatMaskOnlyOnes(
+          result,
+          newMask,
+          kernel[0].length,
+          kernel.length,
+        );
+      } else {
+        const newMask = Mask.createFrom(result);
+        result = dilateMask(result, newMask, kernel);
+      }
+    } else if (onlyOnes) {
+      const newImage = IJS.createFrom(result);
+      result = dilateGreyOnlyOnes(
+        result,
+        newImage,
+        kernel[0].length,
+        kernel.length,
+      );
+    } else {
+      const newImage = IJS.createFrom(result);
+      result = dilateGrey(result, newImage, kernel);
+    }
+  }
+  return result;
+}
+
+function dilateGrey(image: IJS, newImage: IJS, kernel: number[][]): IJS {
+  const kernelWidth = kernel[0].length;
+  const kernelHeight = kernel.length;
+  let radiusX = (kernelWidth - 1) / 2;
+  let radiusY = (kernelHeight - 1) / 2;
+  for (let row = 0; row < image.height; row++) {
+    for (let column = 0; column < image.width; column++) {
+      let max = 0;
+      for (let kernelRow = 0; kernelRow < kernelHeight; kernelRow++) {
+        for (let kernelColumn = 0; kernelColumn < kernelWidth; kernelColumn++) {
+          if (kernel[kernelRow][kernelColumn] !== 1) continue;
+          let currentColumn = kernelColumn - radiusX + column;
+          let currentRow = kernelRow - radiusY + row;
+          if (
+            currentColumn < 0 ||
+            currentRow < 0 ||
+            currentColumn >= image.width ||
+            currentRow >= image.height
+          ) {
+            continue;
+          }
+          const value = image.getValue(currentRow, currentColumn, 0);
+          if (value > max) max = value;
+        }
+      }
+      newImage.setValue(row, column, 0, max);
+    }
+  }
+  return newImage;
+}
+
+function dilateGreyOnlyOnes(
+  image: IJS,
+  newImage: IJS,
+  kernelWidth: number,
+  kernelHeight: number,
+): IJS {
+  const radiusX = (kernelWidth - 1) / 2;
+  const radiusY = (kernelHeight - 1) / 2;
+
+  const maxList = [];
+  for (let column = 0; column < image.width; column++) {
+    maxList.push(0);
+  }
+
+  for (let row = 0; row < image.height; row++) {
+    for (let column = 0; column < image.width; column++) {
+      let max = 0;
+      for (
+        let h = Math.max(0, row - radiusY);
+        h < Math.min(image.height, row + radiusY + 1);
+        h++
+      ) {
+        const value = image.getValue(h, column, 0);
+        if (value > max) {
+          max = value;
+        }
+      }
+      maxList[column] = max;
+    }
+
+    for (let column = 0; column < image.width; column++) {
+      let max = 0;
+      for (
+        let i = Math.max(0, column - radiusX);
+        i < Math.min(image.width, column + radiusX + 1);
+        i++
+      ) {
+        if (maxList[i] > max) {
+          max = maxList[i];
+        }
+      }
+      newImage.setValue(row, column, 0, max);
+    }
+  }
+  return newImage;
+}
+
+function dilateMask(mask: Mask, newMask: Mask, kernel: number[][]): Mask {
+  const kernelWidth = kernel[0].length;
+  const kernelHeight = kernel.length;
+  let radiusX = (kernelWidth - 1) / 2;
+  let radiusY = (kernelHeight - 1) / 2;
+  for (let row = 0; row < mask.height; row++) {
+    for (let column = 0; column < mask.width; column++) {
+      let max = 0;
+      for (let kernelRow = 0; kernelRow < kernelHeight; kernelRow++) {
+        for (let kernelColumn = 0; kernelColumn < kernelWidth; kernelColumn++) {
+          if (kernel[kernelRow][kernelColumn] !== 1) continue;
+          let currentColumn = kernelColumn - radiusX + column;
+          let currentRow = kernelRow - radiusY + row;
+          if (
+            currentRow < 0 ||
+            currentColumn < 0 ||
+            currentColumn >= mask.width ||
+            currentRow >= mask.height
+          ) {
+            continue;
+          }
+          const value = mask.getBit(currentRow, currentColumn);
+          if (value === 1) {
+            max = 1;
+            break;
+          }
+        }
+      }
+      if (max === 1) {
+        newMask.setBit(row, column, 1);
+      }
+    }
+  }
+  return newMask;
+}
+
+function dilatMaskOnlyOnes(
+  mask: Mask,
+  newMask: Mask,
+  kernelWidth: number,
+  kernelHeight: number,
+): Mask {
+  const radiusX = (kernelWidth - 1) / 2;
+  const radiusY = (kernelHeight - 1) / 2;
+
+  const maxList = [];
+  for (let column = 0; column < mask.width; column++) {
+    maxList.push(1);
+  }
+
+  for (let row = 0; row < mask.height; row++) {
+    for (let column = 0; column < mask.width; column++) {
+      maxList[column] = 0;
+      for (
+        let h = Math.max(0, row - radiusY);
+        h < Math.min(mask.height, row + radiusY + 1);
+        h++
+      ) {
+        if (mask.getBit(h, column) === 1) {
+          maxList[column] = 1;
+          break;
+        }
+      }
+    }
+
+    for (let column = 0; column < mask.width; column++) {
+      if (newMask.getBit(row, column) === 1) continue;
+      for (
+        let i = Math.max(0, column - radiusX);
+        i < Math.min(mask.width, column + radiusX + 1);
+        i++
+      ) {
+        if (maxList[i] === 1) {
+          newMask.setBit(row, column, 1);
+          break;
+        }
+      }
+    }
+  }
+  return newMask;
+}

package/src/morphology/erode.ts

@@ -0,0 +1,264 @@
+import { ColorDepth, Mask } from '..';
+import { IJS } from '../IJS';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface ErodeOptions {
+  /**
+   * Matrix with odd dimensions (e.g. 1 by 3). The kernel can only have ones and zeros.
+   * Accessing a value: kernel[row][column]
+   *
+   * @default [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+   */
+  kernel?: number[][];
+  /**
+   * Number of iterations of the algorithm.
+   *
+   * @default 1
+   */
+  iterations?: number;
+}
+
+export function erode(image: IJS, options?: ErodeOptions): IJS;
+export function erode(image: Mask, options?: ErodeOptions): Mask;
+/**
+ * Erosion is one of two fundamental operations (with dilatation) in morphological
+ * IJS processing from which all other morphological operations are based (from Wikipedia).
+ * Replaces each value with it's local minimum among the pixels with a kernel value of 1.
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.html
+ * https://en.wikipedia.org/wiki/Erosion_(morphology)
+ *
+ * @param image - The image to erode.
+ * @param options - Erode options.
+ * @returns - The eroded image.
+ */
+export function erode(
+  image: IJS | Mask,
+  options: ErodeOptions = {},
+): IJS | Mask {
+  let defaultKernel = false;
+  if (options.kernel === undefined) {
+    defaultKernel = true;
+  }
+
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'erode', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+
+  checkKernel(kernel, 'erode');
+
+  let onlyOnes = true;
+  if (!defaultKernel) {
+    outer: for (const row of kernel) {
+      for (const bit of row) {
+        if (bit !== 1) {
+          onlyOnes = false;
+          break outer;
+        }
+      }
+    }
+  }
+
+  let result = image;
+  for (let i = 0; i < iterations; i++) {
+    if (result instanceof Mask) {
+      if (onlyOnes) {
+        const newImage = result.clone();
+        result = erodeMaskOnlyOnes(
+          result,
+          newImage,
+          kernel[0].length,
+          kernel.length,
+        );
+      } else {
+        const newImage = Mask.createFrom(image);
+        result = erodeMask(result, newImage, kernel);
+      }
+    } else if (onlyOnes) {
+      const newImage = IJS.createFrom(image);
+      result = erodeGreyOnlyOnes(
+        result,
+        newImage,
+        kernel[0].length,
+        kernel.length,
+      );
+    } else {
+      const newImage = IJS.createFrom(image);
+      result = erodeGrey(result, newImage, kernel);
+    }
+  }
+  return result;
+}
+
+function erodeGrey(img: IJS, newImage: IJS, kernel: number[][]): IJS {
+  const kernelWidth = kernel[0].length;
+  const kernelHeight = kernel.length;
+  let radiusX = (kernelWidth - 1) / 2;
+  let radiusY = (kernelHeight - 1) / 2;
+  for (let row = 0; row < img.height; row++) {
+    for (let column = 0; column < img.width; column++) {
+      let min = img.maxValue;
+      for (let kernelRow = 0; kernelRow < kernelHeight; kernelRow++) {
+        for (let kernelColumn = 0; kernelColumn < kernelWidth; kernelColumn++) {
+          if (kernel[kernelRow][kernelColumn] !== 1) continue;
+          let currentColumn = kernelColumn - radiusX + column;
+          let currentRow = kernelRow - radiusY + row;
+          if (
+            currentColumn < 0 ||
+            currentRow < 0 ||
+            currentColumn >= img.width ||
+            currentRow >= img.height
+          ) {
+            continue;
+          }
+          const value = img.getValue(currentRow, currentColumn, 0);
+          if (value < min) min = value;
+        }
+      }
+      newImage.setValue(row, column, 0, min);
+    }
+  }
+  return newImage;
+}
+
+function erodeGreyOnlyOnes(
+  image: IJS,
+  newImage: IJS,
+  kernelWidth: number,
+  kernelHeight: number,
+): IJS {
+  const radiusX = (kernelWidth - 1) / 2;
+  const radiusY = (kernelHeight - 1) / 2;
+
+  const minList = [];
+  for (let column = 0; column < image.width; column++) {
+    minList.push(0);
+  }
+
+  for (let row = 0; row < image.height; row++) {
+    for (let column = 0; column < image.width; column++) {
+      let min = image.maxValue;
+      for (
+        let h = Math.max(0, row - radiusY);
+        h < Math.min(image.height, row + radiusY + 1);
+        h++
+      ) {
+        const value = image.getValue(h, column, 0);
+        if (value < min) {
+          min = value;
+        }
+      }
+      minList[column] = min;
+    }
+
+    for (let column = 0; column < image.width; column++) {
+      let min = image.maxValue;
+      for (
+        let i = Math.max(0, column - radiusX);
+        i < Math.min(image.width, column + radiusX + 1);
+        i++
+      ) {
+        if (minList[i] < min) {
+          min = minList[i];
+        }
+      }
+      newImage.setValue(row, column, 0, min);
+    }
+  }
+  return newImage;
+}
+
+function erodeMask(mask: Mask, newMask: Mask, kernel: number[][]): Mask {
+  const kernelWidth = kernel[0].length;
+  const kernelHeight = kernel.length;
+  let radiusX = (kernelWidth - 1) / 2;
+  let radiusY = (kernelHeight - 1) / 2;
+  for (let row = 0; row < mask.height; row++) {
+    for (let column = 0; column < mask.width; column++) {
+      let min = 1;
+      for (let kernelRow = 0; kernelRow < kernelHeight; kernelRow++) {
+        for (let kernelColumn = 0; kernelColumn < kernelWidth; kernelColumn++) {
+          if (kernel[kernelRow][kernelColumn] !== 1) continue;
+          let currentColumn = kernelColumn - radiusX + column;
+          let currentRow = kernelRow - radiusY + row;
+          if (
+            currentRow < 0 ||
+            currentColumn < 0 ||
+            currentColumn >= mask.width ||
+            currentRow >= mask.height
+          ) {
+            continue;
+          }
+          const value = mask.getBit(currentRow, currentColumn);
+          if (value === 0) {
+            min = 0;
+            break;
+          }
+        }
+      }
+      if (min === 1) {
+        newMask.setBit(row, column, 1);
+      }
+    }
+  }
+  return newMask;
+}
+
+function erodeMaskOnlyOnes(
+  mask: Mask,
+  newMask: Mask,
+  kernelWidth: number,
+  kernelHeight: number,
+): Mask {
+  const radiusX = (kernelWidth - 1) / 2;
+  const radiusY = (kernelHeight - 1) / 2;
+
+  const minList = [];
+  for (let column = 0; column < mask.width; column++) {
+    minList.push(0);
+  }
+
+  for (let row = 0; row < mask.height; row++) {
+    for (let column = 0; column < mask.width; column++) {
+      minList[column] = 1;
+      for (
+        let h = Math.max(0, row - radiusY);
+        h < Math.min(mask.height, row + radiusY + 1);
+        h++
+      ) {
+        if (mask.getBit(h, column) === 0) {
+          minList[column] = 0;
+          break;
+        }
+      }
+    }
+
+    for (let column = 0; column < mask.width; column++) {
+      if (newMask.getBit(row, column) === 0) continue;
+      for (
+        let i = Math.max(0, column - radiusX);
+        i < Math.min(mask.width, column + radiusX + 1);
+        i++
+      ) {
+        if (minList[i] === 0) {
+          newMask.setBit(row, column, 0);
+          break;
+        }
+      }
+    }
+  }
+  return newMask;
+}

package/src/morphology/floodFill.ts

@@ -0,0 +1,31 @@
+import { Mask } from '..';
+import { maskToOutputMask } from '../utils/getOutputImage';
+
+export interface FloodFillOptions {
+  /**
+   * Consider pixels connected by corners?
+   *
+   * @default false
+   */
+  allowCorners?: boolean;
+  /**
+   * Image to which the inverted image has to be put.
+   */
+  out?: Mask;
+}
+
+/**
+ * Fill holes in regions of interest.
+ *
+ * @param mask - Mask to process.
+ * @param options - Flood fill options.
+ * @returns The filled mask.
+ */
+export function floodFill(mask: Mask, options: FloodFillOptions = {}): Mask {
+  let { allowCorners = false } = options;
+
+  let newImage = maskToOutputMask(mask, options, { clone: true });
+  let inverted = mask.invert();
+  let cleared = inverted.clearBorder({ allowCorners });
+  return newImage.or(cleared, { out: newImage });
+}

package/src/morphology/index.ts

@@ -0,0 +1,10 @@
+export * from './erode';
+export * from './dilate';
+export * from './open';
+export * from './close';
+export * from './topHat';
+export * from './bottomHat';
+export * from './morphologicalGradient';
+export * from './clearBorder';
+export * from './cannyEdgeDetector';
+export * from './floodFill';

package/src/morphology/morphologicalGradient.ts

@@ -0,0 +1,69 @@
+import { ColorDepth, IJS, Mask } from '..';
+import { subtractImage } from '../filters';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface MorphologicalGradientOptions {
+  /**
+   * 3x3 matrix. The kernel can only have ones and zeros.
+   * Accessing a value: kernel[row][column]
+   *
+   * @default [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
+   */
+  kernel?: number[][];
+  /**
+   * Number of iterations of the algorithm.
+   *
+   * @default 1
+   */
+  iterations?: number;
+}
+
+export function morphologicalGradient(
+  image: IJS,
+  options?: MorphologicalGradientOptions,
+): IJS;
+export function morphologicalGradient(
+  image: Mask,
+  options?: MorphologicalGradientOptions,
+): Mask;
+/**
+ * In mathematical morphology and digital image processing, a morphological gradient is the difference between the dilation and the erosion of a given image. It is an image where each pixel value (typically non-negative) indicates the contrast intensity in the close neighborhood of that pixel. It is useful for edge detection and segmentation applications.
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.html
+ *
+ *
+ * @param image - Image to process
+ * @param options - Morphological gradient hat options
+ * @returns The processed image
+ */
+export function morphologicalGradient(
+  image: IJS | Mask,
+  options: MorphologicalGradientOptions = {},
+) {
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'bottomHat', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+  checkKernel(kernel, 'morphologicalGradient');
+
+  let newImage = image;
+  for (let i = 0; i < iterations; i++) {
+    let dilatedImage = newImage.dilate({ kernel });
+    let erodedImage = newImage.erode({ kernel });
+    newImage = subtractImage(dilatedImage, erodedImage, { absolute: true });
+  }
+
+  return newImage;
+}