image-js 0.0.0-next-e30968a2d8

package/src/morphology/open.ts

@@ -0,0 +1,61 @@
+import { ColorDepth, IJS, Mask } from '..';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface OpenOptions {
+  /**
+   * 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 open(image: IJS, options?: OpenOptions): IJS;
+export function open(image: Mask, options?: OpenOptions): Mask;
+/**
+ * In mathematical morphology, opening is the dilation of the erosion of a set A by a structuring element B.
+ * Together with closing, the opening serves in computer vision and image processing as a basic workhorse of morphological noise removal.
+ * Opening removes small objects from the foreground (usually taken as the bright pixels) of an image,
+ * placing them in the background, while closing removes small holes in the foreground, changing small islands of background into foreground. (Wikipedia)
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.html
+ *
+ * @param image - Image to process.
+ * @param options - Open options
+ * @returns The opened image
+ */
+export function open(image: IJS | Mask, options: OpenOptions = {}): IJS | Mask {
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'open', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+
+  checkKernel(kernel, 'open');
+
+  let newImage = image;
+  for (let i = 0; i < iterations; i++) {
+    newImage = newImage.erode({ kernel });
+    newImage = newImage.dilate({ kernel });
+  }
+
+  return newImage;
+}

package/src/morphology/topHat.ts

@@ -0,0 +1,64 @@
+import { ColorDepth, IJS, Mask } from '..';
+import { subtractImage } from '../filters';
+import { checkKernel } from '../utils/checkKernel';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface TopHatOptions {
+  /**
+   * 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 topHat(image: IJS, options?: TopHatOptions): IJS;
+export function topHat(image: Mask, options?: TopHatOptions): Mask;
+/**
+ * This function is the white top hat (also called top hat). In mathematical morphology and digital image processing,
+ * top-hat transform is an operation that extracts small elements and details from given images.
+ * The white top-hat transform is defined as the difference between the input image and its opening by some structuring element.
+ * Top-hat transforms are used for various image processing tasks, such as feature extraction, background equalization, image enhancement, and others. (Wikipedia)
+ * http://docs.opencv.org/2.4/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.html
+ *
+ * @param image - Image to process
+ * @param options - Top hat options
+ * @returns The top-hatted image
+ */
+export function topHat(
+  image: IJS | Mask,
+  options: TopHatOptions = {},
+): IJS | Mask {
+  let {
+    kernel = [
+      [1, 1, 1],
+      [1, 1, 1],
+      [1, 1, 1],
+    ],
+    iterations = 1,
+  } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'topHat', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: 1,
+      alpha: false,
+    });
+  }
+
+  checkKernel(kernel, 'topHat');
+
+  let newImage = image;
+  for (let i = 0; i < iterations; i++) {
+    let openImage = newImage.open({ kernel });
+    newImage = subtractImage(openImage, newImage, { absolute: true });
+  }
+  return newImage;
+}

package/src/operations/convertColor.ts

@@ -0,0 +1,185 @@
+import { IJS, ImageColorModel } from '../IJS';
+import { Mask } from '../Mask';
+import { getOutputImage, maskToOutputImage } from '../utils/getOutputImage';
+
+export interface ConvertColorOptions {
+  /**
+   * Image to which to output.
+   */
+  out?: IJS;
+}
+
+/**
+ * Convert image to a different color model.
+ *
+ * @param image - Image to convert.
+ * @param colorModel - New color model.
+ * @param options - Convert color options.
+ * @returns The converted image.
+ */
+export function convertColor(
+  image: IJS | Mask,
+  colorModel: ImageColorModel,
+  options: ConvertColorOptions = {},
+): IJS {
+  const canConvert = new Map([
+    [
+      ImageColorModel.GREY,
+      [ImageColorModel.GREYA, ImageColorModel.RGB, ImageColorModel.RGBA],
+    ],
+    [
+      ImageColorModel.GREYA,
+      [ImageColorModel.GREY, ImageColorModel.RGB, ImageColorModel.RGBA],
+    ],
+    [
+      ImageColorModel.RGB,
+      [ImageColorModel.GREYA, ImageColorModel.GREY, ImageColorModel.RGBA],
+    ],
+    [
+      ImageColorModel.RGBA,
+      [ImageColorModel.GREYA, ImageColorModel.GREY, ImageColorModel.RGB],
+    ],
+    [ImageColorModel.BINARY, [ImageColorModel.GREY]],
+  ]);
+
+  if (image.colorModel === colorModel) {
+    throw new Error(`Cannot convert color, image is already ${colorModel}`);
+  }
+
+  const canConvertTo = canConvert.get(image.colorModel);
+  if (!canConvertTo || !canConvertTo.includes(colorModel)) {
+    throw new Error(
+      `conversion from ${image.colorModel} to ${colorModel} not implemented`,
+    );
+  }
+
+  if (image instanceof IJS) {
+    const output = getOutputImage(image, options, {
+      newParameters: { colorModel: colorModel },
+    });
+
+    if (
+      image.colorModel === ImageColorModel.GREY ||
+      image.colorModel === ImageColorModel.GREYA
+    ) {
+      convertGreyToAny(image, output);
+    }
+
+    if (
+      image.colorModel === ImageColorModel.RGB ||
+      image.colorModel === ImageColorModel.RGBA
+    ) {
+      if (
+        colorModel === ImageColorModel.RGB ||
+        colorModel === ImageColorModel.RGBA
+      ) {
+        convertRgbToRgb(image, output);
+      } else {
+        // GREYA or GREY
+        convertRgbToGrey(image, output);
+      }
+    }
+
+    if (!image.alpha && output.alpha) {
+      output.fillAlpha(output.maxValue);
+    }
+
+    if (image.alpha && output.alpha) {
+      copyAlpha(image, output);
+    }
+    return output;
+  } else {
+    const output = maskToOutputImage(image, options);
+    convertBinaryToGrey(image, output);
+    return output;
+  }
+}
+
+/**
+ * Copy alpha channel of source to dest.
+ *
+ * @param source - Source image.
+ * @param dest - Destination image.
+ */
+export function copyAlpha(source: IJS, dest: IJS): void {
+  if (source.size !== dest.size) {
+    throw new Error('source and destination have different sizes');
+  }
+  if (!source.alpha) {
+    throw new Error('source image does not have alpha');
+  }
+  if (!dest.alpha) {
+    throw new Error('destination does not have alpha');
+  }
+
+  for (let i = 0; i < dest.size; i++) {
+    dest.setValueByIndex(
+      i,
+      dest.channels - 1,
+      source.getValueByIndex(i, source.channels - 1),
+    );
+  }
+}
+
+/**
+ * Convert grey image to other color model.
+ *
+ * @param image - Image to convert.
+ * @param newImage - Converted image.
+ */
+function convertGreyToAny(image: IJS, newImage: IJS): void {
+  for (let i = 0; i < image.size; i++) {
+    for (let j = 0; j < newImage.components; j++) {
+      newImage.setValueByIndex(i, j, image.getValueByIndex(i, 0));
+    }
+  }
+}
+
+/**
+ * Convert RGB image to RGB. Allows to use convert with an RGB target whatever the image color model is.
+ *
+ * @param image - Image to convert.
+ * @param newImage - Converted image.
+ */
+function convertRgbToRgb(image: IJS, newImage: IJS): void {
+  for (let i = 0; i < image.size; i++) {
+    for (let j = 0; j < 3; j++) {
+      newImage.setValueByIndex(i, j, image.getValueByIndex(i, j));
+    }
+  }
+}
+
+/**
+ * Convert RGB image to GREY.
+ *
+ * @param image - Image to convert.
+ * @param newImage - Converted image.
+ */
+function convertRgbToGrey(image: IJS, newImage: IJS): void {
+  for (let i = 0; i < image.size; i++) {
+    const r = image.getValueByIndex(i, 0);
+    const g = image.getValueByIndex(i, 1);
+    const b = image.getValueByIndex(i, 2);
+    newImage.setValueByIndex(
+      i,
+      0,
+      Math.round(0.299 * r + 0.587 * g + 0.114 * b),
+    );
+  }
+}
+
+/**
+ * Convert Mask to GREY.
+ *
+ * @param mask - Mask to convert.
+ * @param newImage - Converted image.
+ */
+export function convertBinaryToGrey(mask: Mask, newImage: IJS): void {
+  for (let i = 0; i < mask.size; i++) {
+    newImage.setValueByIndex(
+      i,
+      0,
+      mask.getBitByIndex(i) ? newImage.maxValue : 0,
+    );
+  }
+}

package/src/operations/convertDepth.ts

@@ -0,0 +1,59 @@
+import { IJS, ColorDepth } from '../IJS';
+
+/**
+ * Convert the color depth of an image.
+ *
+ * @param image - Image to convert.
+ * @param newDepth - Depth to convert to.
+ * @returns Converted image.
+ */
+export function convertDepth(image: IJS, newDepth: ColorDepth): IJS {
+  if (image.depth === newDepth) {
+    throw new Error('cannot convert image to same depth');
+  }
+
+  if (newDepth === ColorDepth.UINT16) {
+    return convertToUint16(image);
+  } else {
+    return convertToUint8(image);
+  }
+}
+
+/**
+ * Convert image depth to 16 bits.
+ *
+ * @param image - Image to convert.
+ * @returns Converted image.
+ */
+function convertToUint16(image: IJS): IJS {
+  const newImage = new IJS(image.width, image.height, {
+    depth: ColorDepth.UINT16,
+    colorModel: image.colorModel,
+  });
+
+  for (let i = 0; i < image.size; i++) {
+    for (let j = 0; j < newImage.channels; j++) {
+      newImage.setValueByIndex(i, j, image.getValueByIndex(i, j) << 8);
+    }
+  }
+  return newImage;
+}
+
+/**
+ * Convert image depth to 8 bits.
+ *
+ * @param image - Image to convert.
+ * @returns Converted image.
+ */
+function convertToUint8(image: IJS): IJS {
+  const newImage = new IJS(image.width, image.height, {
+    depth: ColorDepth.UINT8,
+    colorModel: image.colorModel,
+  });
+  for (let i = 0; i < image.size; i++) {
+    for (let j = 0; j < newImage.channels; j++) {
+      newImage.setValueByIndex(i, j, image.getValueByIndex(i, j) >> 8);
+    }
+  }
+  return newImage;
+}

package/src/operations/copyTo.ts

@@ -0,0 +1,107 @@
+import { IJS } from '..';
+import { getOutputImage } from '../utils/getOutputImage';
+
+export interface CopyToOptions {
+  /**
+   * X offset for the copy, the top left corner of the target image is the reference.
+   *
+   * @default 0
+   */
+  columnOffset?: number;
+  /**
+   * Y offset for the copy, the top left corner of the target image is the reference.
+   *
+   * @default 0
+   */
+  rowOffset?: number;
+  /**
+   * Image to which to output.
+   */
+  out?: IJS;
+}
+
+/**
+ * Copy the image to another one by specifying the location in the target image.
+ *
+ * @param source - The source image.
+ * @param target - The target image.
+ * @param options - copyTo options.
+ * @returns The target with the source copied to it.
+ */
+export default function copyTo(
+  source: IJS,
+  target: IJS,
+  options: CopyToOptions = {},
+): IJS {
+  const { columnOffset = 0, rowOffset = 0 } = options;
+
+  if (source.colorModel !== target.colorModel) {
+    throw new Error('Source and target should have the same color model.');
+  }
+
+  const result = getOutputImage(target, options, { clone: true });
+  if (source.alpha) {
+    for (
+      let row = Math.max(rowOffset, 0);
+      row < Math.min(source.height + rowOffset, target.height);
+      row++
+    ) {
+      for (
+        let column = Math.max(columnOffset, 0);
+        column < Math.min(source.width + columnOffset, target.width);
+        column++
+      ) {
+        let sourceAlpha = source.getValue(
+          row - rowOffset,
+          column - columnOffset,
+          source.channels - 1,
+        );
+        let targetAlpha = target.getValue(row, column, source.channels - 1);
+
+        let newAlpha =
+          sourceAlpha + targetAlpha * (1 - sourceAlpha / source.maxValue);
+
+        result.setValue(row, column, target.channels - 1, newAlpha);
+        for (let component = 0; component < source.components; component++) {
+          let sourceComponent = source.getValue(
+            row - rowOffset,
+            column - columnOffset,
+            component,
+          );
+          let targetComponent = target.getValue(row, column, component);
+
+          let newComponent =
+            (sourceComponent * sourceAlpha +
+              targetComponent *
+                targetAlpha *
+                (1 - sourceAlpha / source.maxValue)) /
+            newAlpha;
+
+          result.setValue(row, column, component, newComponent);
+        }
+      }
+    }
+  } else {
+    for (
+      let row = Math.max(rowOffset, 0);
+      row < Math.min(source.height + rowOffset, target.height);
+      row++
+    ) {
+      for (
+        let column = Math.max(columnOffset, 0);
+        column < Math.min(source.width + columnOffset, target.width);
+        column++
+      ) {
+        for (let component = 0; component < target.components; component++) {
+          let sourceComponent = source.getValue(
+            row - rowOffset,
+            column - columnOffset,
+            component,
+          );
+          result.setValue(row, column, component, sourceComponent);
+        }
+      }
+    }
+  }
+  return result;
+}

package/src/operations/grey.ts

@@ -0,0 +1,114 @@
+import { IJS, ImageColorModel } from '..';
+import { getClamp } from '../utils/clamp';
+import { getOutputImage } from '../utils/getOutputImage';
+
+import * as greyAlgorithms from './greyAlgorithms';
+
+export type GreyAlgorithms = keyof typeof greyAlgorithms;
+
+/**
+ * Call back that converts the RGB channels to grey. It is clamped afterwards.
+ *
+ * @callback GreyAlgorithmCallback
+ * @param {number} red - value of the red channel
+ * @param {number} green - value of the green channel
+ * @param {number} blue - value of the blue channel
+ * @returns {number} value of the grey channel
+ */
+export type GreyAlgorithmCallback = (
+  red: number,
+  green: number,
+  blue: number,
+  image: IJS,
+) => number;
+
+export interface GreyOptions {
+  /**
+   * Specify the grey algorithm to use.
+   *
+   * @default 'luma709'
+   */
+  algorithm?: GreyAlgorithms | GreyAlgorithmCallback;
+  /**
+   * Specify wether to keep an alpha channel in the new image or not.
+   *
+   * @default false
+   */
+  keepAlpha?: boolean;
+  /**
+   * Specify wether to merge the alpha channel with the gray pixel or not.
+   *
+   * @default true
+   */
+  mergeAlpha?: boolean;
+  /**
+   * Image to which to output.
+   */
+  out?: IJS;
+}
+
+/**
+ * Convert the current image to grayscale.
+ * The source image has to be RGB or RGBA.
+ * If there is an alpha channel you have to specify what to do:
+ * - keepAlpha :  keep the alpha channel, you will get a GREYA image
+ * - mergeAlpha : multiply each pixel of the image by the alpha, you will get a GREY image
+ *
+ * @param image - Original color image to convert to grey.
+ * @param options - The grey conversion options.
+ * @returns The resulting grey image.
+ */
+export default function grey(image: IJS, options: GreyOptions = {}): IJS {
+  let { algorithm = 'luma709', keepAlpha = false, mergeAlpha = true } = options;
+
+  if (
+    image.colorModel !== ImageColorModel.RGB &&
+    image.colorModel !== ImageColorModel.RGBA
+  ) {
+    throw new Error('Image color model is not RGB or RGBA');
+  }
+
+  keepAlpha = keepAlpha && image.alpha;
+  mergeAlpha = mergeAlpha && image.alpha;
+  if (keepAlpha) {
+    mergeAlpha = false;
+  }
+
+  let newColorModel = keepAlpha ? ImageColorModel.GREYA : ImageColorModel.GREY;
+
+  let newImage = getOutputImage(image, options, {
+    newParameters: { colorModel: newColorModel },
+  });
+
+  let method: GreyAlgorithmCallback;
+  if (typeof algorithm === 'function') {
+    method = algorithm;
+  } else {
+    // eslint-disable-next-line import/namespace
+    method = greyAlgorithms[algorithm];
+  }
+
+  let clamp = getClamp(newImage);
+
+  for (let i = 0; i < image.size; i++) {
+    const red = image.getValueByIndex(i, 0);
+    const green = image.getValueByIndex(i, 1);
+    const blue = image.getValueByIndex(i, 2);
+    let newValue;
+    if (mergeAlpha) {
+      const alpha = image.getValueByIndex(i, 3);
+      newValue = clamp(
+        (method(red, green, blue, image) * alpha) / image.maxValue,
+      );
+    } else {
+      newValue = clamp(method(red, green, blue, image));
+      if (keepAlpha) {
+        const alpha = image.getValueByIndex(i, 3);
+        newImage.setValueByIndex(i, 1, alpha);
+      }
+    }
+    newImage.setValueByIndex(i, 0, newValue);
+  }
+
+  return newImage;
+}