image-js 0.0.0-next-e30968a2d8

package/src/roi/utils/colorMaps/getRainbowMap.ts

@@ -0,0 +1,65 @@
+import { RoiKind } from '../../RoiManager';
+import { maxNumberRois, colorMapCenter } from '../constants';
+import { hsvToRgb } from '../hsvToRgb';
+import { rgbToNumber } from '../rgbToNumber';
+
+export interface GetRainbowMapOptions {
+  /**
+   * Number of black ROIs
+   */
+  nbNegative: number;
+  /**
+   * Number of white ID ROIs
+   */
+  nbPositive: number;
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  roiKind?: RoiKind;
+}
+
+/**
+ * Return a map where ROIs are all different hues.
+ *
+ * @param options - Get temperature map options
+ * @returns The colored map.
+ */
+export function getRainbowMap(options: GetRainbowMapOptions): Uint32Array {
+  const { nbNegative, nbPositive, roiKind = RoiKind.BW } = options;
+
+  let colorMap = new Uint32Array(maxNumberRois);
+
+  const hueRange = 360;
+
+  let step: number;
+  if (roiKind === RoiKind.BW) {
+    step = hueRange / (nbNegative + nbPositive);
+  } else if (roiKind === RoiKind.BLACK) {
+    step = hueRange / nbNegative;
+  } else if (roiKind === RoiKind.WHITE) {
+    step = hueRange / nbPositive;
+  } else {
+    throw new Error('getRainbowMap: unrecognised ROI kind');
+  }
+
+  // negative values
+  let hue = 0;
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.BLACK) {
+    for (let i = colorMapCenter - nbNegative; i < colorMapCenter; i++) {
+      const hsv = [hue, 255, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+      hue += step;
+    }
+  }
+  // positive values
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.WHITE) {
+    for (let i = colorMapCenter + 1; i < colorMapCenter + 1 + nbPositive; i++) {
+      const hsv = [hue, 255, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+      hue += step;
+    }
+  }
+  return colorMap;
+}

package/src/roi/utils/colorMaps/getSaturationMap.ts

@@ -0,0 +1,80 @@
+import { RoiKind } from '../../RoiManager';
+import { maxNumberRois, colorMapCenter } from '../constants';
+import { hsvToRgb } from '../hsvToRgb';
+import { rgbToNumber } from '../rgbToNumber';
+
+export interface GetSaturationMapOptions {
+  /**
+   * Number of black ROIs
+   */
+  nbNegative: number;
+  /**
+   * Number of white ID ROIs
+   */
+  nbPositive: number;
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  roiKind?: RoiKind;
+  /**
+   * Hue of white ROIs
+   *
+   * @default 0
+   */
+  whiteHue?: number;
+  /**
+   * Hue of black ROIs
+   *
+   * @default 240
+   */
+  blackHue?: number;
+}
+
+/**
+ * Return a map where ROIs are different shades of red (positive) or blue (negative) depending on the ROI index. It it the saturation of the HSV color model that is varied.
+ *
+ * @param options - Get temperature map options
+ * @returns The colored map.
+ */
+export function getSaturationMap(
+  options: GetSaturationMapOptions,
+): Uint32Array {
+  const {
+    nbNegative,
+    nbPositive,
+    roiKind = RoiKind.BW,
+    whiteHue = 0,
+    blackHue = 240,
+  } = options;
+
+  let colorMap = new Uint32Array(maxNumberRois);
+
+  const range = 255 - 63;
+  const negativeStep = range / nbNegative;
+  const positiveStep = range / nbPositive;
+
+  // negative values
+  let counter = 0;
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.BLACK) {
+    for (let i = colorMapCenter - nbNegative; i < colorMapCenter; i++) {
+      const hsv = [blackHue, 255 - counter++ * negativeStep, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+    }
+  }
+  // positive values
+  counter = 0;
+  if (roiKind === RoiKind.BW || roiKind === RoiKind.WHITE) {
+    for (let i = colorMapCenter + 1; i < colorMapCenter + 1 + nbPositive; i++) {
+      const hsv = [whiteHue, 255 - counter++ * positiveStep, 255];
+      colorMap[i] = rgbToNumber(hsvToRgb(hsv));
+    }
+  }
+  return colorMap;
+}

package/src/roi/utils/constants.ts

@@ -0,0 +1,3 @@
+export const maxNumberRois = 2 ** 16;
+export const maxRoiId = maxNumberRois / 2;
+export const colorMapCenter = maxNumberRois / 2;

package/src/roi/utils/getColorMap.ts

@@ -0,0 +1,51 @@
+import { RoiKind } from '../RoiManager';
+import { RoisColorMode } from '../colorRois';
+
+import { getBinaryMap } from './colorMaps/getBinaryMap';
+import { getRainbowMap } from './colorMaps/getRainbowMap';
+import { getSaturationMap } from './colorMaps/getSaturationMap';
+
+export interface GetColorMapOptions {
+  /**
+   * Number of black ROIs
+   */
+  nbNegative: number;
+  /**
+   * Number of white ID ROIs
+   */
+  nbPositive: number;
+  /**
+   * Specify the mode: what colors to use in the color map
+   *
+   * @default ColorMode.BINARY
+   */
+  mode?: RoisColorMode;
+
+  /**
+   * Specify which ROIs to colour.
+   *
+   * @default RoiKind.BW
+   */
+  roiKind?: RoiKind;
+}
+
+/**
+ * Return a map of 32 bits integers corresponding to the colors of each ROI.
+ *
+ * @param options - Get color map options.
+ * @returns The color map.
+ */
+export function getColorMap(options: GetColorMapOptions): Uint32Array {
+  const { mode = RoisColorMode.BINARY } = options;
+
+  switch (mode) {
+    case RoisColorMode.BINARY:
+      return getBinaryMap(options);
+    case RoisColorMode.SATURATION:
+      return getSaturationMap(options);
+    case RoisColorMode.RAINBOW:
+      return getRainbowMap(options);
+    default:
+      throw new Error('getColorMap: unknown color mode');
+  }
+}

package/src/roi/utils/hsvToRgb.ts

@@ -0,0 +1,62 @@
+export interface HsvColor {
+  h: number;
+  s: number;
+  v: number;
+}
+export interface RgbColor {
+  r: number;
+  g: number;
+  b: number;
+}
+
+/**
+ * Convert HSV (hue, saturation, value) color code to RGB.
+ * - Hue: angle in the color wheel (from red to purple), in range 0->359
+ * - Saturation: how strong the color is (from white to bright color), in range 0-255
+ * - Value: basically the brightness (from black to intense color), in range 0-255
+ *
+ * @param hsv - The HSV color.
+ * @returns The RGB color.
+ */
+export function hsvToRgb(hsv: number[]): Uint8Array {
+  const h = hsv[0];
+  const s = hsv[1] / 255;
+  const v = hsv[2] / 255;
+  const C = s * v;
+  const X = C * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = v - C;
+
+  let r, g, b;
+
+  if (h >= 0 && h < 60) {
+    r = C;
+    g = X;
+    b = 0;
+  } else if (h >= 60 && h < 120) {
+    r = X;
+    g = C;
+    b = 0;
+  } else if (h >= 120 && h < 180) {
+    r = 0;
+    g = C;
+    b = X;
+  } else if (h >= 180 && h < 240) {
+    r = 0;
+    g = X;
+    b = C;
+  } else if (h >= 240 && h < 300) {
+    r = X;
+    g = 0;
+    b = C;
+  } else {
+    r = C;
+    g = 0;
+    b = X;
+  }
+
+  let rgb = new Uint8Array(3);
+  rgb[0] = (r + m) * 255;
+  rgb[1] = (g + m) * 255;
+  rgb[2] = (b + m) * 255;
+  return rgb;
+}

package/src/roi/utils/rgbToNumber.ts

@@ -0,0 +1,9 @@
+/**
+ * Convert RGB array to 32 bits number where alpha is set to 255.
+ *
+ * @param rgb - The RGB color array
+ * @returns 32 bits number encoding RGBA color
+ */
+export function rgbToNumber(rgb: Uint8Array): number {
+  return 0xff000000 + (rgb[2] << 16) + (rgb[1] << 8) + rgb[0];
+}

package/src/save/encode.ts

@@ -0,0 +1,65 @@
+import { IJS } from '../IJS';
+
+import { encodeJpeg, EncodeJpegOptions } from './encodeJpeg';
+import { encodePng, EncodePngOptions } from './encodePng';
+
+export enum ImageFormat {
+  png = 'png',
+  jpg = 'jpg',
+  jpeg = 'jpeg',
+}
+
+export interface EncodeOptionsPng {
+  format: ImageFormat.png;
+  encoderOptions?: EncodePngOptions;
+}
+export interface EncodeOptionsJpeg {
+  format: ImageFormat.jpg | ImageFormat.jpeg;
+  encoderOptions?: EncodeJpegOptions;
+}
+
+const defaultPng: EncodeOptionsPng = { format: ImageFormat.png };
+
+/**
+ * Encodes the image to an output format.
+ * Defaults to PNG.
+ *
+ * @param image - Image to encode.
+ */
+export function encode(image: IJS): Uint8Array;
+/**
+ * Encodes the image to PNG.
+ *
+ * @param image - Image to encode.
+ * @param options - Format and options passed to the PNG encoder.
+ */
+export function encode(image: IJS, options: EncodeOptionsPng): Uint8Array;
+/**
+ * Encodes the image to JPEG.
+ *
+ * @param image - Image to encode.
+ * @param options - Format and options passed to the JPEG encoder.
+ */
+export function encode(image: IJS, options: EncodeOptionsJpeg): Uint8Array;
+/**
+ * Encode an image in JPEG or PNG format.
+ *
+ * @param image - Image to encode.
+ * @param options - Encoding options.
+ * @returns The encoded image.
+ */
+export function encode(
+  image: IJS,
+  options: EncodeOptionsPng | EncodeOptionsJpeg = defaultPng,
+): Uint8Array {
+  if (options.format === ImageFormat.png) {
+    return encodePng(image, options.encoderOptions);
+  } else if (
+    options.format === ImageFormat.jpg ||
+    options.format === ImageFormat.jpeg
+  ) {
+    return encodeJpeg(image, options.encoderOptions);
+  } else {
+    throw new RangeError(`unknown format: ${options.format}`);
+  }
+}

package/src/save/encodeJpeg.ts

@@ -0,0 +1,37 @@
+import { encode } from 'jpeg-js';
+
+import { IJS, ImageColorModel, ColorDepth } from '../IJS';
+
+export interface EncodeJpegOptions {
+  /**
+   * Defines jpeg quality. Integer value between 1 and 100%, 100% being the best quality.
+   *
+   * @default 50
+   */
+  quality?: number;
+}
+
+/**
+ * Creates a JPEG buffer from an image.
+ *
+ * @param image - The image instance.
+ * @param options - JPEG encoding options.
+ * @returns The buffer.
+ */
+export function encodeJpeg(
+  image: IJS,
+  options: EncodeJpegOptions = {},
+): Uint8Array {
+  const { quality = 50 } = options;
+
+  if (image.colorModel !== ImageColorModel.RGBA) {
+    image = image.convertColor(ImageColorModel.RGBA);
+  }
+  if (image.depth !== ColorDepth.UINT8) {
+    image = image.convertDepth(ColorDepth.UINT8);
+  }
+
+  // Image data after depth conversion will always be UInt8Array
+  const buffer = encode(image.getRawImage(), quality).data;
+  return new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+}

package/src/save/encodePng.ts

@@ -0,0 +1,16 @@
+import { encode, PngEncoderOptions } from 'fast-png';
+
+import { IJS } from '../IJS';
+
+export type EncodePngOptions = PngEncoderOptions;
+
+/**
+ * Creates a PNG buffer from an image.
+ *
+ * @param image - The image instance.
+ * @param options - PNG encoding options.
+ * @returns The buffer.
+ */
+export function encodePng(image: IJS, options?: EncodePngOptions): Uint8Array {
+  return encode(image.getRawImage(), options);
+}

package/src/save/index.ts

@@ -0,0 +1,5 @@
+export * from './encode';
+export * from './encodePng';
+export * from './encodeJpeg';
+export * from './write';
+export * from './writeCanvas';

package/src/save/write.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+
+import { Mask, IJS, ImageColorModel } from '..';
+
+import {
+  encode,
+  ImageFormat,
+  EncodeOptionsPng,
+  EncodeOptionsJpeg,
+} from './encode';
+
+/**
+ * Write an image to the disk.
+ * The file format is determined automatically from the file's extension.
+ * If the extension is not supported, an error will be thrown.
+ */
+export async function write(path: string, image: IJS | Mask): Promise<void>;
+/**
+ * Write an image to the disk as PNG.
+ * When the `png` format is specified, the file's extension doesn't matter.
+ */
+export async function write(
+  path: string,
+  image: IJS | Mask,
+  options: EncodeOptionsPng,
+): Promise<void>;
+/**
+ * Write an image to the disk as JPEG.
+ * When the `jpeg` format is specified, the file's extension doesn't matter.
+ */
+export async function write(
+  path: string,
+  image: IJS | Mask,
+  options: EncodeOptionsJpeg,
+): Promise<void>;
+/**
+ * Asynchronously write an image to the disk.
+ *
+ * @param path - Path where the image should be written.
+ * @param image - Image to save.
+ * @param options - Encode options.
+ */
+export async function write(
+  path: string,
+  image: IJS | Mask,
+  options?: EncodeOptionsPng | EncodeOptionsJpeg,
+): Promise<void> {
+  if (image instanceof Mask) {
+    image = image.convertColor(ImageColorModel.GREY);
+  }
+  const toWrite = getDataToWrite(path, image, options);
+  await fs.promises.writeFile(path, toWrite);
+}
+
+/**
+ * Synchronous version of @see {@link write}.
+ *
+ * @param path - Path where the image should be written.
+ * @param image - Image to save.
+ * @param options - Encode options.
+ */
+export function writeSync(
+  path: string,
+  image: IJS | Mask,
+  options?: EncodeOptionsPng | EncodeOptionsJpeg,
+): void {
+  if (image instanceof Mask) {
+    image = image.convertColor(ImageColorModel.GREY);
+  }
+  const toWrite = getDataToWrite(path, image, options);
+  fs.writeFileSync(path, toWrite);
+}
+
+/**
+ * @param destinationPath
+ * @param image - Image to save.
+ * @param options - Encode options.
+ */
+function getDataToWrite(
+  destinationPath: string,
+  image: IJS,
+  options?: EncodeOptionsPng | EncodeOptionsJpeg,
+): Uint8Array {
+  let format: ImageFormat;
+  if (options === undefined) {
+    const extension = path.extname(destinationPath).slice(1).toLowerCase();
+    if (extension === 'png') {
+      format = ImageFormat.png;
+      return encode(image, { format });
+    } else if (extension === 'jpg' || extension === 'jpeg') {
+      format = ImageFormat.jpg;
+      return encode(image, { format });
+    } else {
+      throw new Error(
+        'image format could not be determined from file extension. Please use a supported extension or specify the format option',
+      );
+    }
+  } else if (options.format === ImageFormat.png) {
+    return encode(image, options);
+  } else if (
+    options.format === ImageFormat.jpg ||
+    options.format === ImageFormat.jpeg
+  ) {
+    return encode(image, options);
+  } else {
+    throw new RangeError(`unknown format: ${options.format}`);
+  }
+}

package/src/save/writeCanvas.ts

@@ -0,0 +1,82 @@
+import { IJS, ImageColorModel } from '../IJS';
+
+export interface WriteCanvasOptions {
+  /**
+   * If set to `true`, the canvas element will be resized to fit the image.
+   *
+   * @default true
+   */
+  resizeCanvas?: boolean;
+  /**
+   * @default 0
+   */
+  dx?: number;
+  /**
+   * @default 0
+   */
+  dy?: number;
+  /**
+   * @default 0
+   */
+  dirtyX?: number;
+  /**
+   * @default 0
+   */
+  dirtyY?: number;
+  /**
+   * @default image.width
+   */
+  dirtyWidth?: number;
+  /**
+   * @default image.height
+   */
+  dirtyHeight?: number;
+}
+
+/**
+ * Draw the image in an HTML canvas.
+ *
+ * @param image - The image to draw.
+ * @param canvas - The HTML canvas.
+ * @param options - Write canvas options.
+ */
+export function writeCanvas(
+  image: IJS,
+  canvas: HTMLCanvasElement,
+  options: WriteCanvasOptions = {},
+): void {
+  if (image.colorModel !== ImageColorModel.RGBA) {
+    image = image.convertColor(ImageColorModel.RGBA);
+  }
+  const {
+    resizeCanvas = true,
+    dx = 0,
+    dy = 0,
+    dirtyX = 0,
+    dirtyY = 0,
+    dirtyWidth = image.width,
+    dirtyHeight = image.height,
+  } = options;
+  if (resizeCanvas) {
+    canvas.width = image.width;
+    canvas.height = image.height;
+  }
+  const ctx = canvas.getContext('2d');
+  if (ctx === null) {
+    throw new Error('could not get context from canvas element');
+  }
+  const data = image.getRawImage().data;
+  ctx.putImageData(
+    new ImageData(
+      new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength),
+      image.width,
+      image.height,
+    ),
+    dx,
+    dy,
+    dirtyX,
+    dirtyY,
+    dirtyWidth,
+    dirtyHeight,
+  );
+}

package/src/utils/boolToNumber.ts

@@ -0,0 +1,18 @@
+import { BitValue } from '../Mask';
+
+/**
+ * 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 { Mask, IJS } from '..';
+
+/**
+ * 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: IJS | 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/checkKernel.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks the that the dimensions of the kernel are odd.
+ *
+ * @param kernel - Kernel passed to a morphology function.
+ * @param functionName - Name of the function.
+ */
+export function checkKernel(kernel: number[][], functionName: string) {
+  if (kernel.length % 2 === 0 || kernel[0].length % 2 === 0) {
+    throw new TypeError(
+      `${functionName}: The number of rows and columns of the kernel must be odd`,
+    );
+  }
+}