image-js 0.0.0-next-e30968a2d8

package/src/utils/checkProcessable.ts

@@ -0,0 +1,98 @@
+import { ColorDepth, IJS, ImageColorModel } from '..';
+
+// @ts-expect-error Intl types don't exist yet
+const formatter = new Intl.ListFormat('en', { type: 'disjunction' });
+
+interface CheckOptions {
+  bitDepth?: ColorDepth[] | ColorDepth;
+  alpha?: boolean[] | boolean;
+  colorModel?: ImageColorModel[] | ImageColorModel;
+  components?: number[] | number;
+  channels?: number[] | number;
+}
+
+/**
+ * This method checks if a process can be applied on the current image
+ *
+ * @param image - Image for which compatibility has to be checked
+ * @param processName - Name of the process to apply
+ * @param options - Check processable options
+ */
+export default function checkProcessable(
+  image: IJS,
+  processName: string,
+  options: CheckOptions = {},
+) {
+  let { bitDepth, alpha, colorModel, components, channels } = options;
+  if (bitDepth) {
+    if (!Array.isArray(bitDepth)) {
+      bitDepth = [bitDepth];
+    }
+    if (!bitDepth.includes(image.depth)) {
+      throw new TypeError(
+        `The process "${processName}" can only be applied if bit depth is ${format(
+          bitDepth,
+        )}`,
+      );
+    }
+  }
+  if (alpha) {
+    if (!Array.isArray(alpha)) {
+      alpha = [alpha];
+    }
+    if (!alpha.includes(image.alpha)) {
+      throw new TypeError(
+        `The process "${processName}" can only be applied if alpha is ${format(
+          alpha,
+        )}`,
+      );
+    }
+  }
+  if (colorModel) {
+    if (!Array.isArray(colorModel)) {
+      colorModel = [colorModel];
+    }
+    if (!colorModel.includes(image.colorModel)) {
+      throw new TypeError(
+        `The process "${processName}" can only be applied if color model is ${format(
+          colorModel,
+        )}`,
+      );
+    }
+  }
+  if (components) {
+    if (!Array.isArray(components)) {
+      components = [components];
+    }
+    if (!components.includes(image.components)) {
+      let errorMessage = `The process "${processName}" can only be applied if the number of components is ${format(
+        components,
+      )}`;
+      if (components.length === 1 && components[0] === 1) {
+        throw new TypeError(
+          `${errorMessage}.\rYou should transform your image using "image.grey()" before applying the algorithm.`,
+        );
+      } else {
+        throw new TypeError(errorMessage);
+      }
+    }
+  }
+  if (channels) {
+    if (!Array.isArray(channels)) {
+      channels = [channels];
+    }
+    if (!channels.includes(image.channels)) {
+      throw new TypeError(
+        `The process "${processName}" can only be applied if the number of channels is ${format(
+          channels,
+        )}`,
+      );
+    }
+  }
+}
+
+type ArrayType = number[] | ImageColorModel[] | ColorDepth[] | boolean[];
+
+function format(array: ArrayType) {
+  return formatter.format(array.map((element) => String(element)));
+}

package/src/utils/clamp.ts

@@ -0,0 +1,39 @@
+import { IJS } from '../IJS';
+
+export type ClampFunction = (value: number) => number;
+
+/**
+ * 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: IJS): ClampFunction {
+  if (image.maxValue === 255) {
+    return clamp255;
+  }
+  if (image.maxValue === 65535) {
+    return clamp65535;
+  }
+  throw new Error(`unknown maxValue: ${image.maxValue}`);
+}
+
+/**
+ * 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);
+}

package/src/utils/colorModels.ts

@@ -0,0 +1,41 @@
+export enum ImageColorModel {
+  GREY = 'GREY',
+  GREYA = 'GREYA',
+  RGB = 'RGB',
+  RGBA = 'RGBA',
+  BINARY = 'BINARY',
+}
+
+export const colorModels: {
+  [key in ImageColorModel]: {
+    components: number;
+    alpha: boolean;
+    channels: number;
+  };
+} = {
+  [ImageColorModel.GREY]: {
+    components: 1,
+    alpha: false,
+    channels: 1,
+  },
+  [ImageColorModel.GREYA]: {
+    components: 1,
+    alpha: true,
+    channels: 2,
+  },
+  [ImageColorModel.RGB]: {
+    components: 3,
+    alpha: false,
+    channels: 3,
+  },
+  [ImageColorModel.RGBA]: {
+    components: 3,
+    alpha: true,
+    channels: 4,
+  },
+  [ImageColorModel.BINARY]: {
+    components: 1,
+    alpha: false,
+    channels: 1,
+  },
+};

package/src/utils/copyData.ts

@@ -0,0 +1,23 @@
+import { IJS, Mask } from '..';
+
+export function copyData(source: IJS, target: IJS): 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: IJS | Mask, target: IJS | Mask): void {
+  if (
+    target.width !== source.width ||
+    target.height !== source.height ||
+    target.colorModel !== source.colorModel
+  ) {
+    throw new Error(
+      'copyData: images width, height or color model is different',
+    );
+  }
+  // @ts-expect-error Accessing data, which is private
+  target.data = source.data.slice();
+}

package/src/utils/getIndex.ts

@@ -0,0 +1,19 @@
+import { IJS, Mask } from '..';
+
+/**
+ * Compute the current data index based on the value coordinates.
+ *
+ * @param row - Row of the value.
+ * @param column - Column of the value.
+ * @param channel - Value channel.
+ * @param image - The image that is being processed.
+ * @returns The value index.
+ */
+export function getIndex(
+  row: number,
+  column: number,
+  channel: number,
+  image: IJS | Mask,
+): number {
+  return (row * image.width + column) * image.channels + channel;
+}

package/src/utils/getOutputImage.ts

@@ -0,0 +1,182 @@
+import { ColorDepth } from '..';
+import { CreateFromOptions, IJS, ImageColorModel } from '../IJS';
+import { Mask } from '../Mask';
+
+import { copyData } from './copyData';
+
+export interface OutOptions {
+  /**
+   * Image to use as the output.
+   * The image must have compatible properties or the method will throw.
+   */
+  out?: IJS | Mask;
+}
+
+type NewImageParameters = Omit<CreateFromOptions, 'data'>;
+
+interface OutInternalOptions {
+  /**
+   * Parameters that will be combined with the ones from
+   * `thisImage`.
+   */
+  newParameters?: NewImageParameters;
+  /**
+   * Specify if the values of the original image should be cloned.
+   */
+  clone?: boolean;
+}
+
+/**
+ * Use this function to support getting the output image of an algorithm from
+ * user-supplied options.
+ *
+ * @param thisImage - Current image on which the algorithm is applied.
+ * @param options - Options object received by the algorithm.
+ * @param internalOptions - Some additional private options.
+ * @returns The output image.
+ */
+export function getOutputImage(
+  thisImage: IJS,
+  options: OutOptions = {},
+  internalOptions: OutInternalOptions = {},
+): IJS {
+  const { out } = options;
+  const { newParameters, clone } = internalOptions;
+  if (out === undefined) {
+    if (clone) {
+      return thisImage.clone();
+    } else {
+      return IJS.createFrom(thisImage, newParameters);
+    }
+  } else {
+    if (!(out instanceof IJS)) {
+      throw new TypeError('out must be an IJS object');
+    }
+    const requirements: NewImageParameters = Object.assign(
+      {
+        width: thisImage.width,
+        height: thisImage.height,
+        depth: thisImage.depth,
+        colorModel: thisImage.colorModel,
+      },
+      newParameters,
+    );
+    checkRequirements(requirements, out);
+    if (clone) {
+      copyData(thisImage, out);
+    }
+    return out;
+  }
+}
+
+/**
+ * Use this function to support getting the output image of an algorithm from
+ * user-supplied options when the input is a mask.
+ *
+ * @param mask - Current mask on which the algorithm is applied.
+ * @param options - Options object received by the algorithm.
+ * @returns The output image.
+ */
+export function maskToOutputImage(mask: Mask, options: OutOptions = {}): IJS {
+  const { out } = options;
+
+  if (out === undefined) {
+    return IJS.createFrom(mask, {
+      colorModel: ImageColorModel.GREY,
+    });
+  } else {
+    if (!(out instanceof IJS)) {
+      throw new TypeError('out must be an IJS object');
+    }
+    const requirements: NewImageParameters = {
+      width: mask.width,
+      height: mask.height,
+      depth: ColorDepth.UINT8,
+      colorModel: ImageColorModel.GREY,
+    };
+    checkRequirements(requirements, out);
+    return out;
+  }
+}
+
+/**
+ * Use this function to support getting the output mask of an algorithm from
+ * user-supplied options when the input is an image.
+ *
+ * @param image - Current image on which the algorithm is applied.
+ * @param options - Options object received by the algorithm.
+ * @returns The output mask.
+ */
+export function imageToOutputMask(image: IJS, options: OutOptions = {}): Mask {
+  const { out } = options;
+  if (out === undefined) {
+    return Mask.createFrom(image);
+  } else {
+    if (!(out instanceof Mask)) {
+      throw new TypeError('out must be a Mask object');
+    }
+    const requirements: NewImageParameters = {
+      width: image.width,
+      height: image.height,
+      depth: ColorDepth.UINT1,
+      colorModel: ImageColorModel.BINARY,
+    };
+    checkRequirements(requirements, out);
+    return out;
+  }
+}
+
+function checkRequirements<ReqType extends object, OutType extends ReqType>(
+  requirements: ReqType,
+  out: OutType,
+): void {
+  type Keys = keyof ReqType;
+  for (const property in requirements) {
+    const prop = property as Keys;
+    if (out[prop] !== requirements[prop]) {
+      throw new RangeError(
+        `cannot use out. Its ${property} property must be ${requirements[prop]}. Found ${out[prop]}`,
+      );
+    }
+  }
+}
+
+/**
+ * Use this function to support getting the output mask of an algorithm from
+ * user-supplied options when the input is an mask.
+ *
+ * @param mask - Current mask on which the algorithm is applied.
+ * @param options - Options object received by the algorithm.
+ * @param internalOptions - Additional private options.
+ * @returns The output mask.
+ */
+export function maskToOutputMask(
+  mask: Mask,
+  options: OutOptions = {},
+  internalOptions: OutInternalOptions = {},
+): Mask {
+  const { out } = options;
+  const { newParameters, clone } = internalOptions;
+  if (out === undefined) {
+    if (clone) {
+      return mask.clone();
+    } else {
+      return Mask.createFrom(mask, newParameters);
+    }
+  } else {
+    if (!(out instanceof Mask)) {
+      throw new TypeError('out must be a Mask object');
+    }
+    const requirements: NewImageParameters = {
+      width: mask.width,
+      height: mask.height,
+      depth: ColorDepth.UINT1,
+      colorModel: ImageColorModel.BINARY,
+    };
+    checkRequirements(requirements, out);
+    if (clone) {
+      copyData(mask, out);
+    }
+    return out;
+  }
+}

package/src/utils/interpolateBorder.ts

@@ -0,0 +1,206 @@
+import { IJS } from '../IJS';
+
+export enum BorderType {
+  CONSTANT = 'CONSTANT',
+  REPLICATE = 'REPLICATE',
+  REFLECT = 'REFLECT',
+  WRAP = 'WRAP',
+  REFLECT_101 = 'REFLECT_101',
+}
+
+export type BorderInterpolationFunction = (
+  column: number,
+  row: number,
+  channel: number,
+  image: IJS,
+) => number;
+
+/**
+ * Pick the border interpolation algorithm.
+ * The different algorithms are illustrated here:
+ * https://vovkos.github.io/doxyrest-showcase/opencv/sphinx_rtd_theme/enum_cv_BorderTypes.html
+ *
+ * @param type
+ * @param value
+ */
+export function getBorderInterpolation(
+  type: BorderType,
+  value: number,
+): BorderInterpolationFunction {
+  switch (type) {
+    case BorderType.CONSTANT:
+      return getInterpolateConstant(value);
+    case BorderType.REPLICATE:
+      return interpolateReplicate;
+    case BorderType.REFLECT:
+      return interpolateReflect;
+    case BorderType.REFLECT_101:
+      return interpolateReflect101;
+    case BorderType.WRAP:
+      return interpolateWrap;
+    default:
+      throw new Error(
+        `interpolateBorder cannot be used with border type ${type}`,
+      );
+  }
+}
+
+function checkRange(point: number, length: number): void {
+  if (point <= 0 - length || point >= length + length - 1) {
+    throw new RangeError(
+      'interpolateBorder only supports borders smaller than the original image',
+    );
+  }
+}
+
+function getInterpolateConstant(value: number): BorderInterpolationFunction {
+  return function interpolateConstant(
+    column: number,
+    row: number,
+    channel: number,
+    image: IJS,
+  ): number {
+    const newX = interpolateConstantPoint(column, image.width);
+    const newY = interpolateConstantPoint(row, image.height);
+    if (newX === -1 || newY === -1) {
+      return value;
+    }
+    return image.getValue(newY, newX, channel);
+  };
+}
+
+/**
+ * @param point
+ * @param length
+ */
+export function interpolateConstantPoint(
+  point: number,
+  length: number,
+): number {
+  if (point >= 0 && point < length) {
+    return point;
+  }
+  return -1;
+}
+
+function interpolateReplicate(
+  column: number,
+  row: number,
+  channel: number,
+  image: IJS,
+): number {
+  return image.getValue(
+    interpolateReplicatePoint(row, image.height),
+    interpolateReplicatePoint(column, image.width),
+    channel,
+  );
+}
+
+/**
+ * @param point
+ * @param length
+ */
+export function interpolateReplicatePoint(
+  point: number,
+  length: number,
+): number {
+  if (point >= 0 && point < length) {
+    return point;
+  }
+  checkRange(point, length);
+  if (point < 0) {
+    return 0;
+  } else {
+    return length - 1;
+  }
+}
+
+function interpolateReflect(
+  column: number,
+  row: number,
+  channel: number,
+  image: IJS,
+): number {
+  return image.getValue(
+    interpolateReflectPoint(row, image.height),
+    interpolateReflectPoint(column, image.width),
+    channel,
+  );
+}
+
+/**
+ * @param point
+ * @param length
+ */
+export function interpolateReflectPoint(point: number, length: number): number {
+  if (point >= 0 && point < length) {
+    return point;
+  }
+  checkRange(point, length);
+  if (point < 0) {
+    return -1 - point;
+  } else {
+    return length + length - 1 - point;
+  }
+}
+
+function interpolateWrap(
+  column: number,
+  row: number,
+  channel: number,
+  image: IJS,
+): number {
+  return image.getValue(
+    interpolateWrapPoint(row, image.height),
+    interpolateWrapPoint(column, image.width),
+    channel,
+  );
+}
+
+/**
+ * @param point
+ * @param length
+ */
+export function interpolateWrapPoint(point: number, length: number): number {
+  if (point >= 0 && point < length) {
+    return point;
+  }
+  checkRange(point, length);
+  if (point < 0) {
+    return length + point;
+  } else {
+    return point - length;
+  }
+}
+
+function interpolateReflect101(
+  column: number,
+  row: number,
+  channel: number,
+  image: IJS,
+): number {
+  return image.getValue(
+    interpolateReflect101Point(row, image.height),
+    interpolateReflect101Point(column, image.width),
+    channel,
+  );
+}
+
+/**
+ * @param point
+ * @param length
+ */
+export function interpolateReflect101Point(
+  point: number,
+  length: number,
+): number {
+  if (point >= 0 && point < length) {
+    return point;
+  }
+  checkRange(point, length);
+  if (point < 0) {
+    return 0 - point;
+  } else {
+    return length + length - 2 - point;
+  }
+}