image-js 1.2.0 → 1.4.0

package/src/featureMatching/keypoints/getFastKeypoints.ts

@@ -13,6 +13,8 @@ import type { GetHarrisScoreOptions } from '../featureMatching.types.js';
 
 import { getFastScore } from './getFastScore.js';
 import { getHarrisScore } from './getHarrisScore.js';
+import type { GetShiTomasiScoreOptions } from './getShiTomasiScore.ts';
+import { getShiTomasiScore } from './getShiTomasiScore.ts';
 import type { IsFastKeypointOptions } from './isFastKeypoint.js';
 import { isFastKeypoint } from './isFastKeypoint.js';
 
@@ -38,11 +40,11 @@ export interface GetFastKeypointsOptions extends IsFastKeypointOptions {
    * Algorithm to use to compute corners score.
    * @default `'FAST'`
    */
-  scoreAlgorithm?: 'HARRIS' | 'FAST';
+  scoreAlgorithm?: 'HARRIS' | 'FAST' | 'TOMASI';
   /**
    * Options for the Harris score computation.
    */
-  harrisScoreOptions?: GetHarrisScoreOptions;
+  scoreOptions?: GetHarrisScoreOptions | GetShiTomasiScoreOptions;
 }
 
 export interface FastKeypoint {
@@ -69,11 +71,7 @@ export function getFastKeypoints(
   image: Image,
   options: GetFastKeypointsOptions = {},
 ): FastKeypoint[] {
-  const {
-    fastRadius = 3,
-    scoreAlgorithm = 'FAST',
-    harrisScoreOptions,
-  } = options;
+  const { fastRadius = 3, scoreAlgorithm = 'FAST', scoreOptions } = options;
 
   const circlePoints = getCirclePoints(fastRadius);
   const compassPoints = getCompassPoints(fastRadius);
@@ -90,15 +88,24 @@ export function getFastKeypoints(
     alpha: false,
   });
 
+  function harrisScore(image: Image, corner: Point) {
+    return getHarrisScore(image, corner, scoreOptions as GetHarrisScoreOptions);
+  }
+  function fastScore(image: Image, corner: Point) {
+    return getFastScore(image, corner, threshold, circlePoints);
+  }
+  function tomasiScore(image: Image, corner: Point) {
+    return getShiTomasiScore(
+      image,
+      corner,
+      scoreOptions as GetShiTomasiScoreOptions,
+    );
+  }
+
   const getScore = match(scoreAlgorithm)
-    .with('HARRIS', () => {
-      return (image: Image, corner: Point) =>
-        getHarrisScore(image, corner, harrisScoreOptions);
-    })
-    .with('FAST', () => {
-      return (image: Image, corner: Point) =>
-        getFastScore(image, corner, threshold, circlePoints);
-    })
+    .with('HARRIS', () => harrisScore)
+    .with('FAST', () => fastScore)
+    .with('TOMASI', () => tomasiScore)
     .exhaustive();
 
   const allKeypoints: FastKeypoint[] = [];

package/src/featureMatching/keypoints/getHarrisScore.ts

@@ -1,18 +1,17 @@
-import { EigenvalueDecomposition, Matrix, WrapperMatrix1D } from 'ml-matrix';
-
 import type { Image } from '../../Image.js';
 import type { Point } from '../../geometry/index.js';
-import { SOBEL_X, SOBEL_Y } from '../../utils/constants/kernels.js';
 import type { GetHarrisScoreOptions } from '../featureMatching.types.js';
 
+import { getEigenvaluesForScore } from './getEigenvaluesForScore.js';
+
 /**
  * Get the Harris score of a corner. The idea behind the algorithm is that a
- * slight shift of a window around a corner along x and y shoud result in
+ * slight shift of a window around a corner along x and y should result in
  * a very different image.
  *
  * We distinguish 3 cases:
  * - the score is highly negative: you have an edge
- * - the abolute value of the score is small: the region is flat
+ * - the absolute value of the score is small: the region is flat
  * - the score is highly positive: you have a corner.
  * @see {@link https://en.wikipedia.org/wiki/Harris_corner_detector}
  * @param image - Image to which the corner belongs. It must be a greyscale image with only one channel.
@@ -25,46 +24,8 @@ export function getHarrisScore(
   origin: Point,
   options: GetHarrisScoreOptions = {},
 ): number {
-  const { windowSize = 7, harrisConstant = 0.04 } = options;
-
-  if (!(windowSize % 2)) {
-    throw new TypeError('windowSize must be an odd integer');
-  }
-
-  const cropOrigin = {
-    row: origin.row - (windowSize - 1) / 2,
-    column: origin.column - (windowSize - 1) / 2,
-  };
-  const window = image.crop({
-    origin: cropOrigin,
-    width: windowSize,
-    height: windowSize,
-  });
-  const xDerivative = window.gradientFilter({ kernelX: SOBEL_X });
-  const yDerivative = window.gradientFilter({ kernelY: SOBEL_Y });
-
-  const xMatrix = new WrapperMatrix1D(xDerivative.getRawImage().data, {
-    rows: xDerivative.height,
-  });
-  const yMatrix = new WrapperMatrix1D(yDerivative.getRawImage().data, {
-    rows: yDerivative.height,
-  });
-
-  const xx = xMatrix.mmul(xMatrix);
-  const xy = yMatrix.mmul(xMatrix);
-  const yy = yMatrix.mmul(yMatrix);
-
-  const xxSum = xx.sum();
-  const xySum = xy.sum();
-  const yySum = yy.sum();
-
-  const structureTensor = new Matrix([
-    [xxSum, xySum],
-    [xySum, yySum],
-  ]);
-
-  const eigenValues = new EigenvalueDecomposition(structureTensor)
-    .realEigenvalues;
+  const { harrisConstant = 0.04, windowSize } = options;
+  const eigenValues = getEigenvaluesForScore(image, origin, windowSize);
 
   return (
     eigenValues[0] * eigenValues[1] -

package/src/featureMatching/keypoints/getOrientedFastKeypoints.ts

@@ -11,10 +11,9 @@ import type {
 import { getFastKeypoints } from './getFastKeypoints.js';
 import { getPatchIntensityCentroid } from './getPatchIntensityCentroid.js';
 
-export interface GetOrientedFastKeypointsOptions
-  extends GetFastKeypointsOptions {
+export interface GetOrientedFastKeypointsOptions extends GetFastKeypointsOptions {
   /**
-   * Diameter of the circle used for compotuation of the intensity centroid.
+   * Diameter of the circle used for computation of the intensity centroid.
    * @default `7`
    */
   centroidPatchDiameter?: number;

package/src/featureMatching/keypoints/getShiTomasiScore.ts

@@ -0,0 +1,36 @@
+import type { Image } from '../../Image.ts';
+import type { Point } from '../../index_full.ts';
+
+import { getEigenvaluesForScore } from './getEigenvaluesForScore.js';
+
+export interface GetShiTomasiScoreOptions {
+  qualityLevel?: number;
+  /**
+   * Size of the window to compute the Harris score.
+   * Should be an odd number so that the window can be centered on the corner.
+   * @default `7`
+   */
+  windowSize?: number;
+}
+
+/**
+ * Get the Shi-Tomasi score of a corner. The idea is similar to Harris score, but it removes constant to calculate the score and just takes the minimum from two eigenvalues.
+ * We distinguish 3 cases:
+ * - the score is highly negative: you have an edge
+ * - the absolute value of the score is small: the region is flat
+ * - the score is highly positive: you have a corner.
+ * @param image - Image to which the corner belongs. It must be a greyscale image with only one channel.
+ * @param origin - Center of the window, where the corner should be.
+ * @param options  - Get Shi-Tomasi score options.
+ * @returns The Shi-Tomasi score.
+ */
+export function getShiTomasiScore(
+  image: Image,
+  origin: Point,
+  options: GetShiTomasiScoreOptions = {},
+): number {
+  const { windowSize = 7 } = options;
+
+  const eigenValues = getEigenvaluesForScore(image, origin, windowSize);
+  return Math.min(eigenValues[0], eigenValues[1]);
+}

package/src/featureMatching/visualize/Montage.ts

@@ -13,7 +13,6 @@ export const MontageDisposition = {
   HORIZONTAL: 'horizontal',
   VERTICAL: 'vertical',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type MontageDisposition =
   (typeof MontageDisposition)[keyof typeof MontageDisposition];
 

package/src/filters/convolution.ts

@@ -6,6 +6,7 @@ import {
 import { Image } from '../Image.js';
 import { extendBorders } from '../operations/extendBorders.js';
 import { getClamp } from '../utils/clamp.js';
+import { getDefaultColor } from '../utils/getDefaultColor.ts';
 import { getIndex } from '../utils/getIndex.js';
 import { getOutputImage } from '../utils/getOutputImage.js';
 import type { BorderType } from '../utils/interpolateBorder.js';
@@ -15,6 +16,7 @@ import type {
   BorderInterpolationFunction,
   ClampFunction,
 } from '../utils/utils.types.js';
+import { validateColor } from '../utils/validators/validators.ts';
 
 export interface ConvolutionOptions {
   /**
@@ -26,7 +28,7 @@ export interface ConvolutionOptions {
    * Value of the border if BorderType is 'constant'.
    * @default `0`
    */
-  borderValue?: number;
+  borderValue?: number | number[];
   /**
    * Whether the kernel should be normalized.
    * @default `false`
@@ -83,7 +85,11 @@ export function rawDirectConvolution(
   kernel: number[][],
   options: ConvolutionOptions = {},
 ): Float64Array {
-  const { borderType = 'reflect101', borderValue = 0 } = options;
+  const { borderType = 'reflect101', borderValue = getDefaultColor(image) } =
+    options;
+  if (Array.isArray(borderValue)) {
+    validateColor(borderValue, image);
+  }
   const interpolateBorder = getBorderInterpolation(borderType, borderValue);
 
   const result = new Float64Array(image.size * image.channels);

package/src/filters/derivativeFilter.ts

@@ -19,7 +19,6 @@ export const DerivativeFilter = {
   // for 2x2 matrices, the current pixel corresponds to the top-left
   //  ROBERTS = 'roberts',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type DerivativeFilter =
   (typeof DerivativeFilter)[keyof typeof DerivativeFilter];
 

package/src/filters/medianFilter.ts

@@ -1,6 +1,7 @@
 import { xMedian } from 'ml-spectra-processing';
 
 import { Image } from '../Image.js';
+import { getDefaultColor } from '../utils/getDefaultColor.ts';
 import type { BorderType } from '../utils/interpolateBorder.js';
 import { getBorderInterpolation } from '../utils/interpolateBorder.js';
 import checkProcessable from '../utils/validators/checkProcessable.js';
@@ -10,16 +11,16 @@ export interface MedianFilterOptions {
    * Type of border algorithm to interpolate from.
    * @default `'reflect101'`
    */
-  borderType: BorderType;
+  borderType?: BorderType;
   /**
    * Value of border.
    */
-  borderValue?: number;
+  borderValue?: number | number[];
   /**
    * The radius of the cell to extract median value from. Must be odd.
-   *  @default `1`
+   *  @default `3`
    */
-  cellSize: number;
+  cellSize?: number;
 }
 /**
  * Calculate a new image that replaces all pixel values by the median of neighbouring pixels.
@@ -27,8 +28,12 @@ export interface MedianFilterOptions {
  * @param options - MedianFilterOptions
  * @returns Image after median filter.
  */
-export function medianFilter(image: Image, options: MedianFilterOptions) {
-  const { cellSize = 3, borderType = 'reflect101', borderValue } = options;
+export function medianFilter(image: Image, options: MedianFilterOptions = {}) {
+  const {
+    cellSize = 3,
+    borderType = 'reflect101',
+    borderValue = getDefaultColor(image),
+  } = options;
 
   checkProcessable(image, {
     bitDepth: [8, 16],
@@ -46,10 +51,7 @@ export function medianFilter(image: Image, options: MedianFilterOptions) {
     );
   }
 
-  const interpolateBorder = getBorderInterpolation(
-    borderType,
-    borderValue as number,
-  );
+  const interpolateBorder = getBorderInterpolation(borderType, borderValue);
 
   const newImage = Image.createFrom(image);
   const size = cellSize ** 2;

package/src/geometry/resize.ts

@@ -41,7 +41,7 @@ export interface ResizeOptions {
    * Value of the border if BorderType is 'constant'.
    * @default `0`
    */
-  borderValue?: number;
+  borderValue?: number | number[];
 }
 
 /**

package/src/geometry/transform.ts

@@ -2,10 +2,12 @@ import { Matrix, inverse } from 'ml-matrix';
 
 import { Image } from '../Image.js';
 import { getClamp } from '../utils/clamp.js';
+import { getDefaultColor } from '../utils/getDefaultColor.ts';
 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';
+import { validateColor } from '../utils/validators/validators.ts';
 
 export interface TransformOptions {
   /**
@@ -31,7 +33,7 @@ export interface TransformOptions {
    * Value of the border if BorderType is 'constant'.
    *  @default `0`
    */
-  borderValue?: number;
+  borderValue?: number | number[];
   /**
    * Whether the transform matrix should be inverted.
    */
@@ -56,13 +58,17 @@ export function transform(
   options: TransformOptions = {},
 ): Image {
   const {
+    borderValue = getDefaultColor(image),
     borderType = 'constant',
-    borderValue = 0,
     interpolationType = 'bilinear',
     fullImage,
   } = options;
   let { width = image.width, height = image.height } = options;
 
+  if (Array.isArray(borderValue)) {
+    validateColor(borderValue, image);
+  }
+
   if (!isValidMatrix(transformMatrix)) {
     throw new TypeError(
       `transformation matrix must be 2x3 or 3x3. Received ${transformMatrix.length}x${transformMatrix[1].length}`,

package/src/load/decodePng.ts

@@ -6,6 +6,8 @@ import { Image } from '../Image.js';
 import type { ImageColorModel } from '../utils/constants/colorModels.js';
 import { assert } from '../utils/validators/assert.js';
 
+import type { Resolution } from './load.types.ts';
+
 /**
  * Decode a PNG. See the fast-png npm module.
  * @param buffer - The data to decode.
@@ -41,11 +43,27 @@ export function decodePng(buffer: Uint8Array): Image {
     default:
       throw new RangeError(`invalid number of channels: ${png.channels}`);
   }
+  let resolution: Resolution | undefined;
+  if (png.resolution) {
+    resolution =
+      png.resolution.unit === 1
+        ? /*If the resolution unit is meters*/ {
+            x: png.resolution.x,
+            y: png.resolution.y,
+            unit: 'meter' as const,
+          }
+        : /*If resolution unit is unknown */ {
+            x: png.resolution.x,
+            y: png.resolution.y,
+            unit: 'unknown' as const,
+          };
+  }
 
   return new Image(png.width, png.height, {
     colorModel,
     bitDepth,
     data: png.data,
+    resolution,
   });
 }
 

package/src/load/decodeTiff.ts

@@ -4,6 +4,7 @@ import type { BitDepth } from '../Image.js';
 import { Image } from '../Image.js';
 
 import { getMetadata } from './getMetadata.js';
+import type { Resolution } from './load.types.ts';
 
 type TiffIfd = ReturnType<typeof decode>[number];
 
@@ -26,7 +27,7 @@ export function getImageFromIFD(ifd: TiffIfd): Image {
   if (ifd.data instanceof Float32Array || ifd.data instanceof Float64Array) {
     throw new Error('Float TIFF data is not supported.');
   }
-
+  const resolution = getTiffResolution(ifd);
   if (ifd.type === 3) {
     const hasAlpha = ifd.samplesPerPixel === 2;
     const pixelLength = hasAlpha ? 4 : 3;
@@ -66,6 +67,7 @@ export function getImageFromIFD(ifd: TiffIfd): Image {
       colorModel: hasAlpha ? 'RGBA' : 'RGB',
       bitDepth: 16,
       meta: getMetadata(ifd),
+      resolution,
     });
   } else if (ifd.type === 1 || ifd.type === 0) {
     if (ifd.bitsPerSample !== 1) {
@@ -74,6 +76,7 @@ export function getImageFromIFD(ifd: TiffIfd): Image {
         bitDepth: ifd.bitsPerSample as BitDepth,
         colorModel: ifd.alpha ? 'GREYA' : 'GREY',
         meta: getMetadata(ifd),
+        resolution,
       });
     } else {
       return new Image(ifd.width, ifd.height, {
@@ -81,6 +84,7 @@ export function getImageFromIFD(ifd: TiffIfd): Image {
         bitDepth: 8 as BitDepth,
         colorModel: 'GREY',
         meta: getMetadata(ifd),
+        resolution,
       });
     }
   } else {
@@ -89,6 +93,39 @@ export function getImageFromIFD(ifd: TiffIfd): Image {
       bitDepth: ifd.bitsPerSample as BitDepth,
       colorModel: ifd.alpha ? 'RGBA' : 'RGB',
       meta: getMetadata(ifd),
+      resolution,
     });
   }
 }
+
+/**
+ * Gets image resolution from its metadata and converts it into Pixels per meter, when it's possible. Also keeps original resolution values and units.
+ * @param ifd - Tiff metadata.
+ * @returns Resolution object.
+ */
+function getTiffResolution(ifd: TiffIfd): Resolution | undefined {
+  if (!ifd.xResolution || !ifd.yResolution) {
+    return undefined;
+  }
+
+  switch (ifd.resolutionUnit) {
+    case 1:
+      return {
+        x: ifd.xResolution,
+        y: ifd.yResolution,
+        unit: 'unknown',
+      };
+    case 3:
+      return {
+        x: ifd.xResolution,
+        y: ifd.yResolution,
+        unit: 'centimeter',
+      };
+    default:
+      return {
+        x: ifd.xResolution,
+        y: ifd.yResolution,
+        unit: 'inch',
+      };
+  }
+}

package/src/load/load.types.ts

@@ -5,3 +5,11 @@ export interface ImageMetadata {
   };
   exif: Record<string, unknown>;
 }
+
+export interface Resolution {
+  x: number;
+  y: number;
+  unit: ResolutionUnit;
+}
+
+export type ResolutionUnit = 'inch' | 'centimeter' | 'meter' | 'unknown';

package/src/operations/extendBorders.ts

@@ -1,6 +1,8 @@
 import { Image } from '../Image.js';
+import { getDefaultColor } from '../utils/getDefaultColor.ts';
 import type { BorderType } from '../utils/interpolateBorder.js';
 import { getBorderInterpolation } from '../utils/interpolateBorder.js';
+import { validateColor } from '../utils/validators/validators.ts';
 
 export interface ExtendBordersOptions {
   /**
@@ -20,7 +22,7 @@ export interface ExtendBordersOptions {
    * Value of the border if BorderType is 'constant'.
    * @default `0`
    */
-  borderValue?: number;
+  borderValue?: number | number[];
 }
 
 /**
@@ -37,9 +39,12 @@ export function extendBorders(
     horizontal,
     vertical,
     borderType = 'reflect101',
-    borderValue = 0,
+    borderValue = getDefaultColor(image),
   } = options;
 
+  if (Array.isArray(borderValue)) {
+    validateColor(borderValue, image);
+  }
   const interpolateBorder = getBorderInterpolation(borderType, borderValue);
 
   const newImage = Image.createFrom(image, {

package/src/operations/grey.ts

@@ -25,7 +25,6 @@ export const GreyAlgorithm = {
   SATURATION: 'saturation',
   LIGHTNESS: 'lightness',
 } as const satisfies Record<string, keyof typeof greyAlgorithms>;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type GreyAlgorithm = (typeof GreyAlgorithm)[keyof typeof GreyAlgorithm];
 
 {

package/src/operations/threshold.ts

@@ -37,7 +37,6 @@ export const ThresholdAlgorithm = {
   TRIANGLE: 'triangle',
   YEN: 'yen',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type ThresholdAlgorithm =
   (typeof ThresholdAlgorithm)[keyof typeof ThresholdAlgorithm];
 

package/src/roi/colorRois.ts

@@ -18,7 +18,6 @@ export const RoisColorMode = {
    */
   RAINBOW: 'rainbow',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type RoisColorMode = (typeof RoisColorMode)[keyof typeof RoisColorMode];
 
 export interface ColorRoisOptions {

package/src/roi/getRois.ts

@@ -9,7 +9,6 @@ export const RoiKind = {
   WHITE: 'white',
   BW: 'bw',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type RoiKind = (typeof RoiKind)[keyof typeof RoiKind];
 
 export interface GetRoisOptions {

package/src/save/encode.ts

@@ -15,7 +15,6 @@ export const ImageFormat = {
   JPEG: 'jpeg',
   BMP: 'bmp',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type ImageFormat = (typeof ImageFormat)[keyof typeof ImageFormat];
 
 export interface EncodeOptionsPng {

package/src/utils/constants/colorModels.ts

@@ -5,7 +5,6 @@ export const ImageColorModel = {
   RGBA: 'RGBA',
   BINARY: 'BINARY',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type ImageColorModel =
   (typeof ImageColorModel)[keyof typeof ImageColorModel];
 

package/src/utils/interpolateBorder.ts

@@ -11,7 +11,6 @@ export const BorderType = {
   WRAP: 'wrap',
   REFLECT_101: 'reflect101',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type BorderType = (typeof BorderType)[keyof typeof BorderType];
 
 /**
@@ -24,8 +23,11 @@ export type BorderType = (typeof BorderType)[keyof typeof BorderType];
  */
 export function getBorderInterpolation(
   type: BorderType,
-  value: number,
+  value: number | number[],
 ): BorderInterpolationFunction {
+  if (typeof value === 'number') {
+    value = new Array(4).fill(value);
+  }
   return match(type)
     .with('constant', () => getInterpolateConstant(value))
     .with('replicate', () => interpolateReplicate)
@@ -41,7 +43,7 @@ function checkRange(point: number, length: number): void {
   }
 }
 
-function getInterpolateConstant(value: number): BorderInterpolationFunction {
+function getInterpolateConstant(value: number[]): BorderInterpolationFunction {
   return function interpolateConstant(
     column: number,
     row: number,
@@ -51,7 +53,7 @@ function getInterpolateConstant(value: number): BorderInterpolationFunction {
     const newColumn = interpolateConstantPoint(column, image.width);
     const newRow = interpolateConstantPoint(row, image.height);
     if (newColumn === -1 || newRow === -1) {
-      return value;
+      return value[channel];
     }
     return image.getValue(newColumn, newRow, channel);
   };

package/src/utils/interpolatePixel.ts

@@ -13,7 +13,6 @@ export const InterpolationType = {
   BILINEAR: 'bilinear',
   BICUBIC: 'bicubic',
 } as const;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type InterpolationType =
   (typeof InterpolationType)[keyof typeof InterpolationType];
 
@@ -22,7 +21,7 @@ type InterpolationFunction = (
   column: number,
   row: number,
   channel: number,
-  intepolateBorder: BorderInterpolationFunction,
+  interpolateBorder: BorderInterpolationFunction,
   clamp: ClampFunction,
 ) => number;