image-js 1.0.0-alpha.2 → 1.0.0

package/src/stack/compute/sum.ts

@@ -0,0 +1,37 @@
+import { Image } from '../../Image.js';
+import type { Stack } from '../../Stack.js';
+import { checkProcessable } from '../utils/checkProcessable.js';
+
+/**
+ *  Returns a new 16 bits depth image with the sum of each pixel of the images of the stack.
+ * @param stack - Stack to process.
+ * @returns The sum image.
+ */
+export function sum(stack: Stack): Image {
+  checkProcessable(stack, { sameDimensions: true, bitDepth: 8 });
+  // Because 255*257 = 2**16 - 1
+  if (stack.size > 257) {
+    throw new Error('Maximal valid stack size is 257');
+  }
+  const image = stack.getImage(0);
+  const dataSize = image.size * stack.channels;
+  const sum = new Uint16Array(dataSize).fill(0);
+
+  for (let i = 0; i < stack.size; i++) {
+    for (let j = 0; j < image.size; j++) {
+      for (let channel = 0; channel < stack.channels; channel++) {
+        sum[j * stack.channels + channel] += stack.getValueByIndex(
+          i,
+          j,
+          channel,
+        );
+      }
+    }
+  }
+
+  return new Image(image.width, image.height, {
+    data: sum,
+    colorModel: stack.colorModel,
+    bitDepth: 16,
+  });
+}

package/src/stack/index.ts

@@ -0,0 +1,7 @@
+export * from './compute/histogram.js';
+export * from './compute/maxImage.js';
+export * from './compute/meanImage.js';
+export * from './compute/medianImage.js';
+export * from './load/decodeStack.js';
+export * from './compute/minImage.js';
+export * from './compute/sum.js';

package/src/stack/load/decodeStack.ts

@@ -0,0 +1,26 @@
+import imageType from 'image-type';
+import { match } from 'ts-pattern';
+
+import type { Stack } from '../../Stack.js';
+
+import { decodeStackFromTiff } from './decodeTiff.js';
+
+/**
+ * Decode input data and create stack. Data format is automatically detected.
+ * Possible formats: tiff.
+ * @param data - Data to decode.
+ * @returns The decoded image.
+ */
+export function decodeStack(data: ArrayBufferView): Stack {
+  const typedArray = new Uint8Array(
+    data.buffer,
+    data.byteOffset,
+    data.byteLength,
+  );
+  const type = imageType(typedArray);
+  return match(type)
+    .with({ mime: 'image/tiff' }, () => decodeStackFromTiff(typedArray))
+    .otherwise(() => {
+      throw new RangeError(`invalid data format: ${type?.mime}`);
+    });
+}

package/src/stack/load/decodeTiff.ts

@@ -0,0 +1,19 @@
+import { decode } from 'tiff';
+
+import { Stack } from '../../Stack.js';
+import { getImageFromIFD } from '../../load/decodeTiff.js';
+
+/**
+ * Decode a TIFF and create a stack of images.
+ * @param buffer - The data to decode.
+ * @returns The stack of images.
+ */
+export function decodeStackFromTiff(buffer: Uint8Array): Stack {
+  const decoded = decode(buffer);
+  const images = [];
+  for (const IFD of decoded) {
+    images.push(getImageFromIFD(IFD));
+  }
+
+  return new Stack(images);
+}

package/src/stack/utils/checkImagesValid.ts

@@ -0,0 +1,35 @@
+import type { Image } from '../../Image.js';
+
+/**
+ * Verify all images of array have the same bit depth and color model.
+ * @param images - Images to process
+ */
+export function checkImagesValid(images: Image[]) {
+  const colorModel = images[0].colorModel;
+  const bitDepth = images[0].bitDepth;
+
+  for (const image of images) {
+    if (image.colorModel !== colorModel || image.bitDepth !== bitDepth) {
+      throw new RangeError(
+        `images must all have the same bit depth and color model`,
+      );
+    }
+  }
+}
+
+/**
+ * Checks if all the images of an array are the same dimensions.
+ * @param images - Images array.
+ * @returns `true` if all images have the same dimensions.
+ */
+export function verifySameDimensions(images: Image[]): boolean {
+  const width = images[0].width;
+  const height = images[0].height;
+
+  for (const image of images) {
+    if (image.width !== width || image.height !== height) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/stack/utils/checkProcessable.ts

@@ -0,0 +1,61 @@
+import type { Stack } from '../../Stack.js';
+import { format } from '../../utils/validators/checkProcessable.js';
+
+interface CheckStackOptions {
+  /**
+   * All images should have the same dimensions.
+   * @default `false`
+   */
+  sameDimensions?: boolean;
+  /**
+   * Verify that the images have or don't have an alpha channel.
+   */
+  alpha?: boolean;
+  /**
+   *
+   */
+  bitDepth?: number | number[];
+}
+
+/**
+ * This method checks if a process can be applied on the stack.
+ * @param stack - Stack to verify.
+ * @param options - Check processable options.
+ */
+export function checkProcessable(
+  stack: Stack,
+  options: CheckStackOptions = {},
+) {
+  const { sameDimensions = false, alpha } = options;
+  let { bitDepth } = options;
+  if (sameDimensions) {
+    const width = stack.getImage(0).width;
+    const height = stack.getImage(0).height;
+
+    for (let i = 1; i < stack.size; i++) {
+      const currentImage = stack.getImage(i);
+      if (currentImage.width !== width || currentImage.height !== height) {
+        throw new RangeError(
+          `images must all have same dimensions to apply this algorithm`,
+        );
+      }
+    }
+  }
+  if (alpha !== undefined && alpha !== stack.alpha) {
+    throw new RangeError(
+      `stack images ${
+        alpha ? 'should' : 'should not'
+      } have an alpha channel to apply this algorithm`,
+    );
+  }
+  if (bitDepth) {
+    if (!Array.isArray(bitDepth)) {
+      bitDepth = [bitDepth];
+    }
+    if (!bitDepth.includes(stack.bitDepth)) {
+      throw new RangeError(
+        `image bitDepth must be ${format(bitDepth)} to apply this algorithm`,
+      );
+    }
+  }
+}

package/src/stack/utils/getStackFromFolder.ts

@@ -0,0 +1,17 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { Stack } from '../../Stack.js';
+import { readSync } from '../../load/index.js';
+
+/**
+ * Create a stack with all images at a given path.
+ * @param path - Path to the folder containing the images.
+ * @returns The stack.
+ */
+export function getStackFromFolder(path: string): Stack {
+  const files = readdirSync(path);
+  const imageNames = files.filter((file) => file.endsWith('.png'));
+  const images = imageNames.map((name) => readSync(join(path, name)));
+  return new Stack(images);
+}

package/src/types/bresenham-zingl.d.ts

@@ -0,0 +1,50 @@
+declare module 'bresenham-zingl' {
+  type SetPixel = (x: number, y: number) => void;
+  type SetPixelAlpha = (x: number, y: number, alpha: number) => void;
+
+  /**
+   * Line segment rasterisation.
+   * @param x0 - Starting point x coordinate.
+   * @param y0 - Starting point y coordinate.
+   * @param x1 - Ending point x coordinate.
+   * @param y1 - Ending point y coordinate.
+   * @param setPixel - Function to set a pixel.
+   */
+  export function line(
+    x0: number,
+    y0: number,
+    x1: number,
+    y1: number,
+    setPixel: SetPixel,
+  ): void;
+
+  /**
+   * Draw anti-aliased line.
+   * @param x0 - Starting point x coordinate.
+   * @param y0 - Starting point y coordinate.
+   * @param x1 - Ending point x coordinate.
+   * @param y1 - Ending point y coordinate.
+   * @param setPixel - Function to set a pixel with alpha.
+   */
+  export function lineAA(
+    x0: number,
+    y0: number,
+    x1: number,
+    y1: number,
+    setPixel: SetPixelAlpha,
+  ): void;
+
+  /**
+   * Circle rasterisation.
+   * @param xm - Circle center x.
+   * @param ym - Circle center y.
+   * @param r - Circle radius.
+   * @param setPixel - Set pixel function.
+   */
+  export function circle(
+    xm: number,
+    ym: number,
+    r: number,
+    setPixel: SetPixel,
+  ): void;
+}

package/src/utils/arrayPointsToObjects.ts

@@ -0,0 +1,15 @@
+import type { ArrayPoint, Point } from './geometry/points.js';
+
+/**
+ * Convert object points into array points.
+ * @param points - Array of points as objects.
+ * @returns Array of points as arrays.
+ */
+export function arrayPointsToObjects(points: Point[]): ArrayPoint[] {
+  const result: ArrayPoint[] = [];
+
+  for (const point of points) {
+    result.push([point.column, point.row]);
+  }
+  return result;
+}

package/src/utils/boolToNumber.ts

@@ -0,0 +1,17 @@
+import type { BitValue } from '../Mask.js';
+
+/**
+ * Converts a bit value to the corresponding number.
+ * @param value - The bit to convert.
+ * @returns The bit value as a number.
+ */
+export function boolToNumber(value: BitValue): number {
+  let result;
+  if (typeof value === 'boolean') {
+    result = value ? 1 : 0;
+  } else {
+    result = value;
+  }
+
+  return result;
+}

package/src/utils/borderIterator.ts

@@ -0,0 +1,22 @@
+import type { Image } from '../Image.js';
+import type { Mask } from '../Mask.js';
+
+/**
+ * Create function that allows to iterate on the pixels of the border of an image.
+ * @param image - Image for which to create the border iterator.
+ * @yields - Index of the border pixel.
+ */
+export function* borderIterator(image: Image | Mask) {
+  for (let col = 0; col < image.width; col++) {
+    yield col;
+  }
+  for (let row = 2; row < image.height; row++) {
+    yield row * image.width - 1;
+  }
+  for (let col = 0; col < image.width; col++) {
+    yield image.width * image.height - col - 1;
+  }
+  for (let row = image.height - 2; row >= 1; row--) {
+    yield row * image.width;
+  }
+}

package/src/utils/clamp.ts

@@ -1,5 +1,48 @@
-import { Image } from '../Image';
+import type { Image } from '../Image.js';
 
-export function clamp(value: number, image: Image): number {
-  return Math.min(Math.max(value, 0), image.maxValue);
+import type { ClampFunction } from './utils.types.js';
+import { assert } from './validators/assert.js';
+
+/**
+ * Get the clamp function for an image (depends on the image bit depth).
+ * @param image - The image for which the clamp function is needed.
+ * @returns The clamp function.
+ */
+export function getClamp(image: Image): ClampFunction {
+  if (image.maxValue === 255) {
+    return clamp255;
+  } else {
+    assert(image.maxValue === 65535);
+    return clamp65535;
+  }
+}
+
+/**
+ * Clamp value for 8-bit images.
+ * @param value - Value to clamp.
+ * @returns The clamped value.
+ */
+function clamp255(value: number): number {
+  return Math.min(Math.max(value, 0), 255);
+}
+
+/**
+ * Clamp value for 16-bit images.
+ * @param value - Value to clamp.
+ * @returns The clamped value.
+ */
+function clamp65535(value: number): number {
+  return Math.min(Math.max(value, 0), 65535);
+}
+
+/**
+ * Get a function that clamps a value to a given range.
+ * @param min - Lower threshold.
+ * @param max - Upper threshold.
+ * @returns The clamping function.
+ */
+export function getClampFromTo(min: number, max: number) {
+  return function clamp(value: number) {
+    return Math.max(Math.min(value, max), min);
+  };
 }

package/src/utils/constants/channelLabels.ts

@@ -0,0 +1,9 @@
+import type { ImageColorModel } from './colorModels.js';
+
+export const channelLabels = {
+  GREY: ['Grey'],
+  GREYA: ['Grey', 'Alpha'],
+  RGB: ['Red', 'Green', 'Blue'],
+  RGBA: ['Red', 'Green', 'Blue', 'Alpha'],
+  BINARY: ['Mask'],
+} as const satisfies Record<ImageColorModel, readonly string[]>;

package/src/utils/constants/colorModels.ts

@@ -0,0 +1,45 @@
+export const ImageColorModel = {
+  GREY: 'GREY',
+  GREYA: 'GREYA',
+  RGB: 'RGB',
+  RGBA: 'RGBA',
+  BINARY: 'BINARY',
+} as const;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type ImageColorModel =
+  (typeof ImageColorModel)[keyof typeof ImageColorModel];
+
+export const colorModels: Record<
+  ImageColorModel,
+  {
+    components: number;
+    alpha: boolean;
+    channels: number;
+  }
+> = {
+  GREY: {
+    components: 1,
+    alpha: false,
+    channels: 1,
+  },
+  GREYA: {
+    components: 1,
+    alpha: true,
+    channels: 2,
+  },
+  RGB: {
+    components: 3,
+    alpha: false,
+    channels: 3,
+  },
+  RGBA: {
+    components: 3,
+    alpha: true,
+    channels: 4,
+  },
+  BINARY: {
+    components: 1,
+    alpha: false,
+    channels: 1,
+  },
+};

package/src/utils/constants/kernels.ts

@@ -0,0 +1,73 @@
+export const DISCRETE_LAPLACE_4 = [
+  [0, 1, 0],
+  [1, -4, 1],
+  [0, 1, 0],
+];
+
+export const DISCRETE_LAPLACE_8 = [
+  [1, 1, 1],
+  [1, -8, 1],
+  [1, 1, 1],
+];
+
+export const SOBEL_X = [
+  [-1, 0, 1],
+  [-2, 0, 2],
+  [-1, 0, 1],
+];
+
+export const SOBEL_Y = [
+  [-1, -2, -1],
+  [0, 0, 0],
+  [1, 2, 1],
+];
+
+export const SCHARR_X = [
+  [3, 0, -3],
+  [10, 0, -10],
+  [3, 0, -3],
+];
+
+export const SCHARR_Y = [
+  [3, 10, 3],
+  [0, 0, 0],
+  [-3, -10, -3],
+];
+
+export const PREWITT_X = [
+  [1, 0, -1],
+  [1, 0, -1],
+  [1, 0, -1],
+];
+
+export const PREWITT_Y = [
+  [1, 1, 1],
+  [0, 0, 0],
+  [-1, -1, -1],
+];
+
+export const ROBERTS_X = [
+  [0, 1],
+  [-1, 0],
+];
+
+export const ROBERTS_Y = [
+  [1, 0],
+  [0, -1],
+];
+
+export const SECOND_DERIVATIVE = [
+  [-1, -2, 0, 2, 1],
+  [-2, -4, 0, 4, 2],
+  [0, 0, 0, 0, 0],
+  [1, 2, 0, -2, -1],
+  [2, 4, 0, -4, -2],
+];
+
+export const SECOND_DERIVATIVE_INV = [
+  [1, 2, 0, -2, -1],
+  [2, 4, 0, -4, -2],
+  [0, 0, 0, 0, 0],
+  [-2, -4, 0, 4, 2],
+  [-1, -2, 0, 2, 1],
+];

package/src/utils/constants/kinds.ts

@@ -0,0 +1,26 @@
+type ColorModelDefinitions = Record<
+  string,
+  {
+    channels: number;
+    alpha: boolean;
+  }
+>;
+
+export const colorModelDefinitions: ColorModelDefinitions = {
+  grey: {
+    channels: 1,
+    alpha: false,
+  },
+  greya: {
+    channels: 2,
+    alpha: true,
+  },
+  rgb: {
+    channels: 3,
+    alpha: false,
+  },
+  rgba: {
+    channels: 4,
+    alpha: true,
+  },
+};

package/src/utils/copyData.ts

@@ -0,0 +1,21 @@
+import type { Image } from '../Image.js';
+import type { Mask } from '../Mask.js';
+
+export function copyData(source: Image, target: Image): void;
+export function copyData(source: Mask, target: Mask): void;
+/**
+ * Copy the data of an source to the target image.
+ * @param source - Image which data is copied.
+ * @param target - Image to which the data must be copied.
+ */
+export function copyData(source: Image | Mask, target: Image | Mask): void {
+  if (
+    target.width !== source.width ||
+    target.height !== source.height ||
+    target.colorModel !== source.colorModel
+  ) {
+    throw new RangeError('images width, height or color model is different');
+  }
+  // @ts-expect-error Accessing data, which is private
+  target.data = source.data.slice();
+}

package/src/utils/cross_platform.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns builtin Node.js modules or throws an error saying that the method is only implemented in Node.js.
+ * @param methodName - Name of the method that calls this function
+ * @returns - The `fs`, `path` and `url` Node.js modules.
+ */
+export function getNodeApiOrThrow(methodName: string) {
+  if (
+    typeof process === 'undefined' ||
+    typeof process.getBuiltinModule !== 'function'
+  ) {
+    throw new Error(`${methodName} is only implemented for Node.js`);
+  }
+  return {
+    fs: process.getBuiltinModule('node:fs'),
+    path: process.getBuiltinModule('node:path'),
+    url: process.getBuiltinModule('node:url'),
+  };
+}

package/src/utils/geometry/angles.ts

@@ -0,0 +1,26 @@
+import type { Point } from './points.js';
+import { difference, dot, normalize } from './points.js';
+
+/**
+ * Convert radians to degrees.
+ * @param radians - Angle in radians.
+ * @returns  Angle in degrees.
+ */
+export function toDegrees(radians: number): number {
+  return (radians * 180) / Math.PI;
+}
+
+/**
+ * Returns the angle between 3 points. The first one is the point where the angle is.
+ * @param origin - Origin where the angle has to be measured.
+ * @param p1 - First point.
+ * @param p2 - Second point.
+ * @returns The angle in radians.
+ */
+export function angle(origin: Point, p1: Point, p2: Point): number {
+  const v1 = normalize(difference(p1, origin));
+  const v2 = normalize(difference(p2, origin));
+  const dotProduct = dot(v1, v2);
+  // TODO this code is not correct because it may return the opposite angle
+  return Math.acos(dotProduct);
+}