image-js 0.0.0-next-e30968a2d8

package/src/filters/hypotenuse.ts

@@ -0,0 +1,74 @@
+import { IJS } from '..';
+import checkProcessable from '../utils/checkProcessable';
+import { validateChannels } from '../utils/validators';
+
+export interface HypotenuseOptions {
+  /**
+   * Depth of the resulting image.
+   *
+   * @default image.depth
+   */
+  depth?: number;
+  /**
+   * To which channels to apply the filter. By default all but alpha.
+   */
+  channels?: number[];
+}
+
+/**
+ * Calculate a new image that is the hypotenuse between the current image and the otherImage.
+ *
+ * @param image - First image to process.
+ * @param otherImage - Second image.
+ * @param options - Hypotenuse options.
+ * @returns Hypotenuse of the two images.
+ */
+export function hypotenuse(
+  image: IJS,
+  otherImage: IJS,
+  options: HypotenuseOptions = {},
+): IJS {
+  let { depth = image.depth, channels = [] } = options;
+
+  for (let i = 0; i < image.components; i++) {
+    channels.push(i);
+  }
+
+  checkProcessable(image, 'hypotenuse', {
+    bitDepth: [8, 16, 32],
+  });
+
+  if (image.width !== otherImage.width || image.height !== otherImage.height) {
+    throw new Error('hypotenuse: both images must have the same size');
+  }
+  if (image.alpha !== otherImage.alpha || image.depth !== otherImage.depth) {
+    throw new Error(
+      'hypotenuse: both images must have the same alpha and bitDepth',
+    );
+  }
+  if (image.channels !== otherImage.channels) {
+    throw new Error(
+      'hypotenuse: both images must have the same number of channels',
+    );
+  }
+
+  validateChannels(channels, image);
+
+  let newImage = IJS.createFrom(image, { depth });
+
+  for (const channel of channels) {
+    for (let i = 0; i < image.size; i++) {
+      let value = Math.hypot(
+        image.getValueByIndex(i, channel),
+        otherImage.getValueByIndex(i, channel),
+      );
+      newImage.setValueByIndex(
+        i,
+        channel,
+        value > newImage.maxValue ? newImage.maxValue : value,
+      );
+    }
+  }
+
+  return newImage;
+}

package/src/filters/index.ts

@@ -0,0 +1,10 @@
+export * from './and';
+export * from './blur';
+export * from './convolution';
+export * from './derivativeFilter';
+export * from './gaussianBlur';
+export * from './gradientFilter';
+export * from './hypotenuse';
+export * from './invert';
+export * from './or';
+export * from './subtractImage';

package/src/filters/invert.ts

@@ -0,0 +1,47 @@
+import { copyAlpha, Mask } from '..';
+import { IJS } from '../IJS';
+import { getOutputImage, maskToOutputMask } from '../utils/getOutputImage';
+
+export interface InvertOptions {
+  /**
+   * Image to which the inverted image has to be put.
+   */
+  out?: IJS | Mask;
+}
+
+export function invert(image: IJS, options?: InvertOptions): IJS;
+export function invert(image: Mask, options?: InvertOptions): Mask;
+/**
+ * Invert the components of an image.
+ *
+ * @param image - The image to invert.
+ * @param options - Invert options.
+ * @returns The inverted image.
+ */
+export function invert(image: IJS | Mask, options?: InvertOptions): IJS | Mask {
+  if (image instanceof IJS) {
+    const newImage = getOutputImage(image, options);
+    if (image.alpha) {
+      copyAlpha(image, newImage);
+    }
+
+    const { maxValue } = newImage;
+    for (let i = 0; i < newImage.size; i++) {
+      for (let component = 0; component < image.components; component++) {
+        newImage.setValueByIndex(
+          i,
+          component,
+          maxValue - image.getValueByIndex(i, component),
+        );
+      }
+    }
+    return newImage;
+  } else {
+    const newImage = maskToOutputMask(image, options);
+
+    for (let i = 0; i < newImage.size; i++) {
+      newImage.setBitByIndex(i, !image.getBitByIndex(i));
+    }
+    return newImage;
+  }
+}

package/src/filters/or.ts

@@ -0,0 +1,34 @@
+import { Mask } from '..';
+import { maskToOutputMask } from '../utils/getOutputImage';
+
+export interface OrOptions {
+  /**
+   * Image to which the inverted image has to be put.
+   */
+  out?: Mask;
+}
+
+/**
+ * Perform an OR operation on two masks.
+ *
+ * @param mask - First mask.
+ * @param otherMask - Second mask.
+ * @param options - Or options.
+ * @returns OR of the two masks.
+ */
+export function or(mask: Mask, otherMask: Mask, options?: OrOptions): Mask {
+  const newMask = maskToOutputMask(mask, options);
+
+  if (mask.width !== otherMask.width || mask.height !== otherMask.height) {
+    throw new Error('or: both masks must have the same size');
+  }
+
+  for (let i = 0; i < newMask.size; i++) {
+    if (mask.getBitByIndex(i) || otherMask.getBitByIndex(i)) {
+      newMask.setBitByIndex(i, 1);
+    } else {
+      newMask.setBitByIndex(i, 0);
+    }
+  }
+  return newMask;
+}

package/src/filters/subtractImage.ts

@@ -0,0 +1,91 @@
+import { ColorDepth, IJS, Mask } from '..';
+import checkProcessable from '../utils/checkProcessable';
+
+export interface SubtractImageOptions {
+  /**
+   * Return the absolute difference for each pixel.
+   *
+   * @default false
+   */
+  absolute?: boolean;
+}
+
+export function subtractImage(
+  image: IJS,
+  otherImage: IJS,
+  options?: SubtractImageOptions,
+): IJS;
+export function subtractImage(
+  image: Mask,
+  otherImage: Mask,
+  options?: SubtractImageOptions,
+): Mask;
+export function subtractImage(
+  image: IJS | Mask,
+  otherImage: IJS | Mask,
+  options: SubtractImageOptions,
+): IJS | Mask;
+/**
+ * Calculate a new image that is the subtraction between the current image and the otherImage.
+ *
+ * @param image - Image from which to subtract
+ * @param otherImage - Image to subtract
+ * @param options - Subtract options.
+ * @returns The subtracted image
+ */
+export function subtractImage(
+  image: IJS | Mask,
+  otherImage: IJS | Mask,
+  options: SubtractImageOptions = {},
+): IJS | Mask {
+  let { absolute = false } = options;
+
+  if (image instanceof IJS) {
+    checkProcessable(image, 'subtractImage', {
+      bitDepth: [ColorDepth.UINT1, ColorDepth.UINT8, ColorDepth.UINT16],
+      components: [1, 3],
+      alpha: false,
+    });
+  }
+
+  if (image.width !== otherImage.width || image.height !== otherImage.height) {
+    throw new Error('subtractImage: both images must have the same size');
+  }
+  if (image.alpha !== otherImage.alpha || image.depth !== otherImage.depth) {
+    throw new Error(
+      'subtractImage: both images must have the same alpha and depth',
+    );
+  }
+  if (image.channels !== otherImage.channels) {
+    throw new Error(
+      'subtractImage: both images must have the same number of channels',
+    );
+  }
+
+  let newImage = image.clone();
+  if (newImage instanceof IJS) {
+    for (let index = 0; index < image.size; index++) {
+      for (let channel = 0; channel < image.channels; channel++) {
+        let value =
+          image.getValueByIndex(index, channel) -
+          otherImage.getValueByIndex(index, channel);
+        if (absolute) {
+          newImage.setValueByIndex(index, channel, Math.abs(value));
+        } else {
+          newImage.setValueByIndex(index, channel, Math.max(value, 0));
+        }
+      }
+    }
+  } else if (image instanceof Mask && otherImage instanceof Mask) {
+    for (let index = 0; index < image.size; index++) {
+      let value = image.getBitByIndex(index) - otherImage.getBitByIndex(index);
+      if (absolute) {
+        newImage.setBitByIndex(index, Math.abs(value) ? 1 : 0);
+      } else {
+        newImage.setBitByIndex(index, Math.max(value, 0) ? 1 : 0);
+      }
+    }
+  }
+
+  return newImage;
+}

package/src/geometry/index.ts

@@ -0,0 +1,3 @@
+export * from './transform';
+export * from './resize';
+export * from './rotate';

package/src/geometry/resize.ts

@@ -0,0 +1,182 @@
+import { IJS } from '../IJS';
+import { getClamp } from '../utils/clamp';
+import { getBorderInterpolation, BorderType } from '../utils/interpolateBorder';
+import {
+  getInterpolationFunction,
+  InterpolationType,
+} from '../utils/interpolatePixel';
+
+export interface ResizeOptions {
+  /**
+   * Width of the output image.
+   */
+  width?: number;
+  /**
+   * Height of the output image.
+   */
+  height?: number;
+  /**
+   * Factor by which to scale the width.
+   */
+  xFactor?: number;
+  /**
+   * Factor by which to scale the width.
+   */
+  yFactor?: number;
+  /**
+   * Should the aspect ratio of the image be preserved?
+   */
+  preserveAspectRatio?: boolean;
+  /**
+   * Method to use to interpolate the new pixels
+   *
+   * @default InterpolationType.BILINEAR
+   */
+  interpolationType?: InterpolationType;
+  /**
+   * Specify how the borders should be handled.
+   *
+   * @default BorderType.CONSTANT
+   */
+  borderType?: BorderType;
+  /**
+   * Value of the border if BorderType is CONSTANT.
+   *
+   * @default 0
+   */
+  borderValue?: number;
+}
+
+/**
+ * Returns a resized copy of an image.
+ *
+ * @param image - Original image.
+ * @param options - Resize options.
+ * @returns The new image.
+ */
+export function resize(image: IJS, options: ResizeOptions): IJS {
+  const {
+    interpolationType = InterpolationType.BILINEAR,
+    borderType = BorderType.CONSTANT,
+    borderValue = 0,
+  } = options;
+  const { width, height } = checkOptions(image, options);
+  const newImage = IJS.createFrom(image, { width, height });
+  const interpolate = getInterpolationFunction(interpolationType);
+  const interpolateBorder = getBorderInterpolation(borderType, borderValue);
+  const clamp = getClamp(newImage);
+  const intervalX = (image.width - 1) / (width - 1);
+  const intervalY = (image.height - 1) / (height - 1);
+  for (let row = 0; row < newImage.height; row++) {
+    for (let column = 0; column < newImage.width; column++) {
+      const nx = column * intervalX;
+      const ny = row * intervalY;
+      for (let channel = 0; channel < newImage.channels; channel++) {
+        const newValue = interpolate(
+          image,
+          nx,
+          ny,
+          channel,
+          interpolateBorder,
+          clamp,
+        );
+        newImage.setValue(row, column, channel, newValue);
+      }
+    }
+  }
+  return newImage;
+}
+
+/**
+ * @param image
+ * @param options
+ */
+function checkOptions(
+  image: IJS,
+  options: ResizeOptions,
+): { width: number; height: number; xFactor: number; yFactor: number } {
+  const {
+    width,
+    height,
+    xFactor,
+    yFactor,
+    preserveAspectRatio = true,
+  } = options;
+
+  if (
+    width === undefined &&
+    height === undefined &&
+    xFactor === undefined &&
+    yFactor === undefined
+  ) {
+    throw new Error(
+      'At least one of the width, height, xFactor or yFactor options must be passed',
+    );
+  }
+
+  let newWidth: number;
+  let newHeight: number;
+
+  const maybeWidth = getSize(width, xFactor, image.width, preserveAspectRatio);
+  const maybeHeight = getSize(
+    height,
+    yFactor,
+    image.height,
+    preserveAspectRatio,
+  );
+
+  if (maybeWidth === undefined) {
+    if (maybeHeight !== undefined) {
+      newWidth = Math.round(maybeHeight * (image.width / image.height));
+    } else {
+      throw new Error('UNREACHABLE');
+    }
+  } else {
+    newWidth = maybeWidth;
+  }
+
+  if (maybeHeight === undefined) {
+    if (maybeWidth !== undefined) {
+      newHeight = Math.round(maybeWidth * (image.height / image.width));
+    } else {
+      throw new Error('UNREACHABLE');
+    }
+  } else {
+    newHeight = maybeHeight;
+  }
+
+  return {
+    width: newWidth,
+    height: newHeight,
+    xFactor: xFactor ? xFactor : newWidth / image.width,
+    yFactor: yFactor ? yFactor : newHeight / image.height,
+  };
+}
+
+/**
+ * @param sizeOpt
+ * @param factor
+ * @param sizeImg- -
+ * Should the aspect ratio of the image be preserved?
+ * @param sizeImg
+ * @param preserveAspectRatio
+ */
+function getSize(
+  sizeOpt: number | undefined,
+  factor: number | undefined,
+  sizeImg: number,
+  preserveAspectRatio: boolean,
+): number | undefined {
+  if (sizeOpt === undefined) {
+    if (factor !== undefined) {
+      return Math.round(sizeImg * factor);
+    } else if (!preserveAspectRatio) {
+      return sizeImg;
+    }
+  } else if (factor !== undefined) {
+    throw new Error('factor must not be passed with size');
+  } else {
+    return sizeOpt;
+  }
+  return undefined;
+}

package/src/geometry/rotate.ts

@@ -0,0 +1,99 @@
+import { IJS, ImageCoordinates } from '../IJS';
+import { BorderType } from '../utils/interpolateBorder';
+import { InterpolationType } from '../utils/interpolatePixel';
+
+import { transform } from './transform';
+
+export interface RotateOptions {
+  /**
+   * Specify the rotation center point
+   *
+   * @default The center of the image.
+   */
+  center?: ImageCoordinates | [number, number];
+  /**
+   * Scaling factor for the rotated image.
+   *
+   * @default 1
+   */
+  scale?: number;
+  /**
+   * Width of the final image.
+   */
+  width?: number;
+  /**
+   * Height of the final image.
+   */
+  height?: number;
+  /*
+    Bypasses width, height, and center options to include
+    every pixel of the original image inside the rotated image
+  */
+  fullImage?: boolean;
+  /**
+   * Method to use to interpolate the new pixels
+   *
+   * @default InterpolationType.BILINEAR
+   */
+  interpolationType?: InterpolationType;
+  /**
+   * Specify how the borders should be handled.
+   *
+   * @default BorderType.CONSTANT
+   */
+  borderType?: BorderType;
+  /**
+   * Value of the border if BorderType is CONSTANT.
+   *
+   * @default 0
+   */
+  borderValue?: number;
+}
+
+/**
+ * Rotate an image of a given angle.
+ *
+ * @param image - Original image.
+ * @param angle - Angle in degrees.
+ * @param options - Rotate options.
+ * @returns A new rotated image.
+ */
+export function rotate(
+  image: IJS,
+  angle: number,
+  options: RotateOptions = {},
+): IJS {
+  const { center = ImageCoordinates.CENTER, scale = 1 } = options;
+
+  let centerCoordinates;
+  if (typeof center === 'string') {
+    centerCoordinates = image.getCoordinates(center);
+  } else {
+    centerCoordinates = center;
+  }
+  const transformMatrix = getRotationMatrix(angle, centerCoordinates, scale);
+
+  return transform(image, transformMatrix, options);
+}
+
+/**
+ * Generates a rotation matrix for the given angle.
+ *
+ * @param angle - Angle in degrees.
+ * @param center - Center point of the image.
+ * @param scale - Scaling factor.
+ * @returns 2 x 3 rotation matrix.
+ */
+function getRotationMatrix(
+  angle: number,
+  center: [number, number],
+  scale: number,
+): number[][] {
+  const angleRadians = (angle * Math.PI) / 180;
+  const cos = scale * Math.cos(angleRadians);
+  const sin = scale * Math.sin(angleRadians);
+  return [
+    [cos, sin, (1 - cos) * center[0] - sin * center[1]],
+    [-sin, cos, sin * center[0] + (1 - cos) * center[1]],
+  ];
+}

package/src/geometry/transform.ts

@@ -0,0 +1,169 @@
+import { inverse, Matrix } from 'ml-matrix';
+
+import { IJS, ImageCoordinates } from '../IJS';
+import { getClamp } from '../utils/clamp';
+import { getBorderInterpolation, BorderType } from '../utils/interpolateBorder';
+import {
+  getInterpolationFunction,
+  InterpolationType,
+} from '../utils/interpolatePixel';
+
+export interface TransformOptions {
+  /**
+   * Width of the output image.
+   */
+  width?: number;
+  /**
+   * Height of the output image.
+   */
+  height?: number;
+  /**
+   * Method to use to interpolate the new pixels
+   *
+   * @default InterpolationType.BILINEAR
+   */
+
+  interpolationType?: InterpolationType;
+  /**
+   * Specify how the borders should be handled.
+   *
+   * @default BorderType.CONSTANT
+   */
+  borderType?: BorderType;
+  /**
+   * Value of the border if BorderType is CONSTANT.
+   *
+   * @default 0
+   */
+  borderValue?: number;
+  /**
+   * Should the transform matrix be inverted?
+   */
+  inverse?: boolean;
+  /*
+    Bypasses width, height, and center options to include
+    every pixel of the original image inside the transformed image.
+  */
+  fullImage?: boolean;
+}
+
+/**
+ * Transforms an image using a matrix.
+ *
+ * @param image - Original image.
+ * @param transformMatrix - 2×3 transform matrix.
+ * @param options - Transform options.
+ * @returns The new image.
+ */
+export function transform(
+  image: IJS,
+  transformMatrix: number[][],
+  options: TransformOptions = {},
+): IJS {
+  const {
+    borderType = BorderType.CONSTANT,
+    borderValue = 0,
+    interpolationType = InterpolationType.BILINEAR,
+  } = options;
+  let { width = image.width, height = image.height } = options;
+
+  if (options.fullImage) {
+    transformMatrix = transformMatrix.map((row) => row.slice());
+    transformMatrix[0][2] = 0;
+    transformMatrix[1][2] = 0;
+    const corners = [
+      image.getCoordinates(ImageCoordinates.TOP_LEFT),
+      image.getCoordinates(ImageCoordinates.TOP_RIGHT),
+      image.getCoordinates(ImageCoordinates.BOTTOM_RIGHT),
+      image.getCoordinates(ImageCoordinates.BOTTOM_LEFT),
+    ];
+
+    corners[1][0] += 1;
+    corners[2][0] += 1;
+    corners[2][1] += 1;
+    corners[3][1] += 1;
+
+    const transformedCorners = corners.map((corner) => {
+      return [
+        transformPoint(transformMatrix[0], corner[0], corner[1]),
+        transformPoint(transformMatrix[1], corner[0], corner[1]),
+      ];
+    });
+
+    const xCoordinates = transformedCorners.map((c) => c[0]);
+    const yCoordinates = transformedCorners.map((c) => c[1]);
+    const maxX = Math.max(...xCoordinates);
+    const maxY = Math.max(...yCoordinates);
+    const minX = Math.min(...xCoordinates);
+    const minY = Math.min(...yCoordinates);
+    const center = [(image.width - 1) / 2, (image.height - 1) / 2];
+
+    width = maxX - minX;
+    height = maxY - minY;
+
+    const centerX = transformPoint(transformMatrix[0], center[0], center[1]);
+    const centerY = transformPoint(transformMatrix[1], center[0], center[1]);
+    const a = (width - 1) / 2 - centerX;
+    const b = (height - 1) / 2 - centerY;
+    transformMatrix[0][2] = a;
+    transformMatrix[1][2] = b;
+    width = Math.round(width);
+    height = Math.round(height);
+  }
+
+  if (
+    transformMatrix.length !== 2 ||
+    transformMatrix[0].length !== 3 ||
+    transformMatrix[1].length !== 3
+  ) {
+    throw new Error(
+      `transformation matrix must be 2x3, found ${transformMatrix.length}x${transformMatrix[1].length}`,
+    );
+  }
+
+  if (!options.inverse) {
+    transformMatrix = [transformMatrix[0], transformMatrix[1], [0, 0, 1]];
+    transformMatrix = inverse(new Matrix(transformMatrix)).to2DArray();
+  }
+  const newImage = IJS.createFrom(image, {
+    width,
+    height,
+  });
+
+  const interpolateBorder = getBorderInterpolation(borderType, borderValue);
+  const clamp = getClamp(newImage);
+
+  const interpolate = getInterpolationFunction(interpolationType);
+  for (let row = 0; row < newImage.height; row++) {
+    for (let column = 0; column < newImage.width; column++) {
+      const nx = transformPoint(transformMatrix[0], column, row);
+      const ny = transformPoint(transformMatrix[1], column, row);
+      for (let channel = 0; channel < newImage.channels; channel++) {
+        const newValue = interpolate(
+          image,
+          nx,
+          ny,
+          channel,
+          interpolateBorder,
+          clamp,
+        );
+        newImage.setValue(row, column, channel, newValue);
+      }
+    }
+  }
+
+  return newImage;
+}
+
+/**
+ * @param transform
+ * @param column
+ * @param row
+ */
+function transformPoint(
+  transform: number[],
+  column: number,
+  row: number,
+): number {
+  return transform[0] * column + transform[1] * row + transform[2];
+}