image-js 1.0.0-alpha.3 → 1.1.0

package/src/geometry/rotate.ts

@@ -1,51 +1,63 @@
-import { Image, ImageCoordinates } from '../Image';
-import { InterpolationType, BorderType } from '../types';
+import { Image } from '../Image.js';
 
-import { transform } from './transform';
+export type RotateAngle = 90 | 180 | 270 | -90 | -180 | -270;
 
-export interface IRotateOptions {
-  center?: ImageCoordinates | [number, number];
-  scale?: number;
-  width?: number;
-  height?: number;
-  /*
-    Bypasses width, height, and center options to include
-    every pixel of the original image inside the rotated image
-  */
-  fullImage?: boolean;
-  interpolationType?: InterpolationType;
-  borderType?: BorderType;
-  borderValue?: number;
-}
-
-export function rotate(
-  image: Image,
-  angle: number,
-  options: IRotateOptions = {}
-): Image {
-  const { center = ImageCoordinates.CENTER, scale = 1 } = options;
+/**
+ * Rotates an image in multiples of 90 degrees.
+ * @param image - The image to rotate.
+ * @param angle - The angle to rotate the image by. Positive values rotate clockwise, negative values rotate counter-clockwise.
+ * @returns - The rotated image.
+ */
+export function rotate(image: Image, angle: RotateAngle): Image {
+  const newWidth = angle % 180 === 0 ? image.width : image.height;
+  const newHeight = angle % 180 === 0 ? image.height : image.width;
+  const newImage = Image.createFrom(image, {
+    width: newWidth,
+    height: newHeight,
+  });
 
-  let centerCoordinates;
-  if (typeof center === 'string') {
-    centerCoordinates = image.getCoordinates(center);
+  if (angle === 90 || angle === -270) {
+    for (let column = 0; column < image.width; column++) {
+      for (let row = 0; row < image.height; row++) {
+        for (let channel = 0; channel < image.channels; channel++) {
+          newImage.setValue(
+            newImage.width - row - 1,
+            column,
+            channel,
+            image.getValue(column, row, channel),
+          );
+        }
+      }
+    }
+  } else if (angle === 180 || angle === -180) {
+    for (let column = 0; column < image.width; column++) {
+      for (let row = 0; row < image.height; row++) {
+        for (let channel = 0; channel < image.channels; channel++) {
+          newImage.setValue(
+            newImage.width - column - 1,
+            newImage.height - row - 1,
+            channel,
+            image.getValue(column, row, channel),
+          );
+        }
+      }
+    }
+  } else if (angle === 270 || angle === -90) {
+    for (let column = 0; column < image.width; column++) {
+      for (let row = 0; row < image.height; row++) {
+        for (let channel = 0; channel < image.channels; channel++) {
+          newImage.setValue(
+            row,
+            newImage.height - column - 1,
+            channel,
+            image.getValue(column, row, channel),
+          );
+        }
+      }
+    }
   } else {
-    centerCoordinates = center;
+    throw new RangeError(`invalid angle: ${angle}`);
   }
-  const transformMatrix = getRotationMatrix(angle, centerCoordinates, scale);
-
-  return transform(image, transformMatrix, options);
-}
 
-function getRotationMatrix(
-  angle: number,
-  center: [number, number],
-  scale: number
-): number[][] {
-  const angleRadians = (angle * Math.PI) / 180;
-  const alpha = scale * Math.cos(angleRadians);
-  const beta = scale * Math.sin(angleRadians);
-  return [
-    [alpha, beta, (1 - alpha) * center[0] - beta * center[1]],
-    [-beta, alpha, beta * center[0] + (1 - alpha) * center[1]]
-  ];
+  return newImage;
 }

package/src/geometry/transform.ts

@@ -1,53 +1,107 @@
-import { inverse, Matrix } from 'ml-matrix';
+import { Matrix, inverse } from 'ml-matrix';
 
-import { Image, ImageCoordinates } from '../Image';
-import { getInterpolationFunction } from '../utils/interpolatePixel';
-import { InterpolationType, BorderType } from '../types';
-import { getBorderInterpolation } from '../utils/interpolateBorder';
-import { getClamp } from '../utils/clamp';
+import { Image } from '../Image.js';
+import { getClamp } from '../utils/clamp.js';
+import type { BorderType } from '../utils/interpolateBorder.js';
+import { getBorderInterpolation } from '../utils/interpolateBorder.js';
+import type { InterpolationType } from '../utils/interpolatePixel.js';
+import { getInterpolationFunction } from '../utils/interpolatePixel.js';
 
-export interface ITransformOptions {
+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 `'bilinear'`
+   */
+
   interpolationType?: InterpolationType;
+  /**
+   * Specify how the borders should be handled.
+   * @default `'constant'`
+   */
   borderType?: BorderType;
-  inverse?: boolean;
+  /**
+   * Value of the border if BorderType is 'constant'.
+   *  @default `0`
+   */
   borderValue?: number;
+  /**
+   * Whether the transform matrix should be inverted.
+   */
+  inverse?: boolean;
+  /**
+   * Bypasses width and height 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: Image,
   transformMatrix: number[][],
-  options: ITransformOptions = {}
+  options: TransformOptions = {},
 ): Image {
   const {
-    borderType = BorderType.CONSTANT,
+    borderType = 'constant',
     borderValue = 0,
-    interpolationType = InterpolationType.BILINEAR
+    interpolationType = 'bilinear',
+    fullImage,
   } = options;
   let { width = image.width, height = image.height } = options;
 
-  if (options.fullImage) {
+  if (!isValidMatrix(transformMatrix)) {
+    throw new TypeError(
+      `transformation matrix must be 2x3 or 3x3. Received ${transformMatrix.length}x${transformMatrix[1].length}`,
+    );
+  }
+  if (transformMatrix.length === 2) {
+    transformMatrix.push([0, 0, 1]);
+  }
+
+  if (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)
+      image.getCoordinates('top-left'),
+      image.getCoordinates('top-right'),
+      image.getCoordinates('bottom-right'),
+      image.getCoordinates('bottom-left'),
     ];
 
-    corners[1][0] += 1;
-    corners[2][0] += 1;
-    corners[2][1] += 1;
-    corners[3][1] += 1;
+    corners[1].column += 1;
+    corners[2].column += 1;
+    corners[2].row += 1;
+    corners[3].row += 1;
 
     const transformedCorners = corners.map((corner) => {
       return [
-        transformPoint(transformMatrix[0], corner[0], corner[1]),
-        transformPoint(transformMatrix[1], corner[0], corner[1])
+        transformPoint(
+          transformMatrix[0],
+          transformMatrix[2],
+          corner.column,
+          corner.row,
+        ),
+        transformPoint(
+          transformMatrix[1],
+          transformMatrix[2],
+          corner.column,
+          corner.row,
+        ),
       ];
     });
 
@@ -62,8 +116,18 @@ export function transform(
     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 centerX = transformPoint(
+      transformMatrix[0],
+      transformMatrix[2],
+      center[0],
+      center[1],
+    );
+    const centerY = transformPoint(
+      transformMatrix[1],
+      transformMatrix[2],
+      center[0],
+      center[1],
+    );
     const a = (width - 1) / 2 - centerX;
     const b = (height - 1) / 2 - centerY;
     transformMatrix[0][2] = a;
@@ -72,48 +136,42 @@ export function transform(
     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 = Image.createFrom(image, {
     width,
-    height
+    height,
   });
 
   const interpolateBorder = getBorderInterpolation(borderType, borderValue);
   const clamp = getClamp(newImage);
 
   const interpolate = getInterpolationFunction(interpolationType);
-  const hFactor = newImage.width * newImage.channels;
-  for (let y = 0; y < newImage.height; y++) {
-    const hOffset = hFactor * y;
-    for (let x = 0; x < newImage.width; x++) {
-      const wOffset = hOffset + x * image.channels;
-      const nx = transformPoint(transformMatrix[0], x, y);
-      const ny = transformPoint(transformMatrix[1], x, y);
-      for (let c = 0; c < newImage.channels; c++) {
+  for (let row = 0; row < newImage.height; row++) {
+    for (let column = 0; column < newImage.width; column++) {
+      const nx = transformPoint(
+        transformMatrix[0],
+        transformMatrix[2],
+        column,
+        row,
+      );
+      const ny = transformPoint(
+        transformMatrix[1],
+        transformMatrix[2],
+        column,
+        row,
+      );
+      for (let channel = 0; channel < newImage.channels; channel++) {
         const newValue = interpolate(
           image,
           nx,
           ny,
-          c,
+          channel,
           interpolateBorder,
-          clamp
+          clamp,
         );
-        newImage.data[wOffset + c] = newValue;
+        newImage.setValue(column, row, channel, newValue);
       }
     }
   }
@@ -121,6 +179,34 @@ export function transform(
   return newImage;
 }
 
-function transformPoint(transform: number[], x: number, y: number): number {
-  return transform[0] * x + transform[1] * y + transform[2];
+/**
+ * Apply a transformation to a point.
+ * @param transform - Transformation matrix.
+ * @param perspective - Perspective matrix.
+ * @param column - Column of the point.
+ * @param row - Row of the point.
+ * @returns New value.
+ */
+function transformPoint(
+  transform: number[],
+  perspective: number[],
+  column: number,
+  row: number,
+): number {
+  return (
+    (transform[0] * column + transform[1] * row + transform[2]) /
+    (perspective[0] * column + perspective[1] * row + perspective[2])
+  );
+}
+
+function isValidMatrix(transformationMatrix: number[][]) {
+  return (
+    (transformationMatrix.length === 3 &&
+      transformationMatrix[0].length === 3 &&
+      transformationMatrix[1].length === 3 &&
+      transformationMatrix[2].length === 3) ||
+    (transformationMatrix.length === 2 &&
+      transformationMatrix[0].length === 3 &&
+      transformationMatrix[1].length === 3)
+  );
 }

package/src/geometry/transformRotate.ts

@@ -0,0 +1,65 @@
+import type { Image, ImageCoordinates } from '../Image.js';
+import type { Point } from '../utils/geometry/points.js';
+
+import type { TransformOptions } from './transform.js';
+import { transform } from './transform.js';
+
+export interface TransformRotateOptions extends TransformOptions {
+  /**
+   * Specify the rotation center point as a predefined string or a Point.
+   * @default `'center'`.
+   */
+  center?: ImageCoordinates | Point;
+  /**
+   * Scaling factor for the rotated image.
+   *  @default `1`
+   */
+  scale?: number;
+}
+
+/**
+ * Rotate an image anti-clockwise of a given angle.
+ * @param image - Original image.
+ * @param angle - Angle in degrees.
+ * @param options - Rotate options.
+ * @returns A new rotated image.
+ */
+export function transformRotate(
+  image: Image,
+  angle: number,
+  options: TransformRotateOptions = {},
+): Image {
+  const { center = 'center', scale = 1, ...otherOptions } = options;
+
+  let centerCoordinates;
+  if (typeof center === 'string') {
+    centerCoordinates = image.getCoordinates(center);
+  } else {
+    centerCoordinates = center;
+  }
+  const transformMatrix = getRotationMatrix(angle, centerCoordinates, scale);
+
+  return transform(image, transformMatrix, otherOptions);
+}
+
+/**
+ * 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 3 x 3 rotation matrix.
+ */
+function getRotationMatrix(
+  angle: number,
+  center: Point,
+  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.column - sin * center.row],
+    [-sin, cos, sin * center.column + (1 - cos) * center.row],
+    [0, 0, 1],
+  ];
+}

package/src/index.ts

@@ -1,8 +1,24 @@
-export * from './Image';
-export * from './compute';
-export * from './filters';
-export * from './load';
-export * from './operations';
-export * from './geometry';
-export * from './save';
-export * from './types';
+export * from './align/index.js';
+export * from './compare/index.js';
+export * from './compute/index.js';
+export * from './correctColor/index.js';
+export * from './draw/index.js';
+export * from './featureMatching/index.js';
+export * from './filters/index.js';
+export * from './geometry/index.js';
+export * from './utils/geometry/index.js';
+export * from './Image.js';
+export * from './load/index.js';
+export * from './Mask.js';
+export * from './maskAnalysis/index.js';
+export * from './morphology/index.js';
+export * from './operations/index.js';
+export * from './roi/index.js';
+export * from './save/index.js';
+export * from './Stack.js';
+export { decodeStack } from './stack/load/decodeStack.js';
+export * from './utils/utils.types.js';
+export * from './utils/constants/channelLabels.js';
+export * from './utils/constants/colorModels.js';
+export { BorderType } from './utils/interpolateBorder.js';
+export { InterpolationType } from './utils/interpolatePixel.js';

package/src/load/decode.ts

@@ -1,28 +1,31 @@
-import { Image } from '../Image';
+import imageType from 'image-type';
+import { match } from 'ts-pattern';
 
-import checkHeader from './checkHeader';
-import { decodePng } from './decodePng';
-import { decodeJpeg } from './decodeJpeg';
-
-const pngHeader = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
-const jpegHeader = [0xff, 0xd8, 0xff];
+import type { Image } from '../Image.js';
 
+import { decodeBmp } from './decodeBmp.ts';
+import { decodeJpeg } from './decodeJpeg.js';
+import { decodePng } from './decodePng.js';
+import { decodeTiff } from './decodeTiff.js';
 /**
  * Decode input data. Data format is automatically detected.
- * Possible formats: png and jpeg.
- * @param data - data to decode
+ * Possible formats: png, jpeg and tiff.
+ * @param data - Data to decode.
+ * @returns The decoded image.
  */
 export function decode(data: ArrayBufferView): Image {
   const typedArray = new Uint8Array(
     data.buffer,
     data.byteOffset,
-    data.byteLength
+    data.byteLength,
   );
-  if (checkHeader(typedArray, pngHeader)) {
-    return decodePng(typedArray);
-  } else if (checkHeader(typedArray, jpegHeader)) {
-    return decodeJpeg(typedArray);
-  } else {
-    throw new Error('unrecognized data format');
-  }
+  const type = imageType(typedArray);
+  return match(type)
+    .with({ mime: 'image/png' }, () => decodePng(typedArray))
+    .with({ mime: 'image/jpeg' }, () => decodeJpeg(typedArray))
+    .with({ mime: 'image/tiff' }, () => decodeTiff(typedArray))
+    .with({ mime: 'image/bmp' }, () => decodeBmp(typedArray))
+    .otherwise(() => {
+      throw new RangeError(`invalid data format: ${type?.mime}`);
+    });
 }

package/src/load/decodeBmp.ts

@@ -0,0 +1,37 @@
+import { decode } from 'fast-bmp';
+
+import { Image } from '../Image.ts';
+import { Mask } from '../Mask.ts';
+import type { ImageColorModel } from '../utils/constants/colorModels.ts';
+
+/**
+ * Decode a BMP. See the fast-bmp npm module.
+ * @param data - The data to decode.
+ * @returns The decoded image or mask.
+ */
+export function decodeBmp(data: Uint8Array): Image {
+  const decodedData = decode(data);
+  if (decodedData.bitsPerPixel === 1) {
+    const mask = new Mask(decodedData.width, decodedData.height, {
+      data: decodedData.data as Uint8Array,
+    });
+    return mask.convertColor('GREY');
+  } else {
+    let colorModel: ImageColorModel;
+    switch (decodedData.channels) {
+      case 1:
+        colorModel = 'GREY';
+        break;
+      case 3:
+        colorModel = 'RGB';
+        break;
+      default:
+        colorModel = 'RGBA';
+        break;
+    }
+    return new Image(decodedData.width, decodedData.height, {
+      colorModel,
+      data: decodedData.data as Uint8Array,
+    });
+  }
+}

package/src/load/decodeJpeg.ts

@@ -1,15 +1,31 @@
+import { decode as decodeExif } from 'fast-jpeg';
 import { decode } from 'jpeg-js';
 
-import { Image, ImageKind } from '../Image';
+import { Image } from '../Image.js';
+
+import { getMetadata } from './getMetadata.js';
 
 /**
  * Decode a jpeg. See the jpeg-js npm module.
- * @param buffer The data to decode
+ * @param buffer - The data to decode.
+ * @returns The decoded image.
  */
 export function decodeJpeg(buffer: Uint8Array): Image {
-  const jpeg = decode(buffer, true);
+  const jpeg = decode(buffer, {
+    useTArray: true,
+    maxMemoryUsageInMB: Number.POSITIVE_INFINITY,
+    maxResolutionInMP: Number.POSITIVE_INFINITY,
+  });
+
+  const decodedExif = decodeExif(buffer);
+  // TODO : handle stacks (many IFDs?)
+  const meta = decodedExif.exif?.[0]
+    ? getMetadata(decodedExif.exif[0])
+    : undefined;
+
   return new Image(jpeg.width, jpeg.height, {
     data: jpeg.data,
-    kind: ImageKind.RGBA
+    colorModel: 'RGBA',
+    meta,
   });
 }