image-js 0.0.0-next-e30968a2d8

package/src/utils/interpolatePixel.ts

@@ -0,0 +1,170 @@
+import { IJS } from '../IJS';
+
+import { ClampFunction } from './clamp';
+import { BorderInterpolationFunction } from './interpolateBorder';
+import { round } from './round';
+
+export enum InterpolationType {
+  NEAREST = 'NEAREST',
+  BILINEAR = 'BILINEAR',
+  BICUBIC = 'BICUBIC',
+}
+
+type InterpolationFunction = (
+  image: IJS,
+  column: number,
+  row: number,
+  channel: number,
+  intepolateBorder: BorderInterpolationFunction,
+  clamp: ClampFunction,
+) => number;
+
+/**
+ * Get the interpolation function based on its name.
+ *
+ * @param interpolationType - Specified interpolation type.
+ * @returns The interpolation function.
+ */
+export function getInterpolationFunction(
+  interpolationType: InterpolationType,
+): InterpolationFunction {
+  switch (interpolationType) {
+    case InterpolationType.NEAREST: {
+      return interpolateNearest;
+    }
+    case InterpolationType.BILINEAR: {
+      return interpolateBilinear;
+    }
+    case InterpolationType.BICUBIC: {
+      return interpolateBicubic;
+    }
+    default: {
+      throw new Error(`interpolation ${interpolationType} not implemented`);
+    }
+  }
+}
+
+/**
+ * @param image - The image to interpolate.
+ * @param column - Column index.
+ * @param row - Row index.
+ * @param channel - Channel index.
+ * @param interpolateBorder
+ */
+function interpolateNearest(
+  image: IJS,
+  column: number,
+  row: number,
+  channel: number,
+  interpolateBorder: BorderInterpolationFunction,
+): number {
+  column = Math.round(column);
+  row = Math.round(row);
+
+  return interpolateBorder(column, row, channel, image);
+}
+
+/**
+ * @param image
+ * @param column - Column index.
+ * @param row - Row index.
+ * @param channel - Channel index.
+ * @param interpolateBorder
+ */
+function interpolateBilinear(
+  image: IJS,
+  column: number,
+  row: number,
+  channel: number,
+  interpolateBorder: BorderInterpolationFunction,
+): number {
+  const px0 = Math.floor(column);
+  const py0 = Math.floor(row);
+
+  if (px0 === column && py0 === row) {
+    return interpolateBorder(px0, py0, channel, image);
+  }
+
+  const px1 = px0 + 1;
+  const py1 = py0 + 1;
+
+  const vx0y0 = interpolateBorder(px0, py0, channel, image);
+  const vx1y0 = interpolateBorder(px1, py0, channel, image);
+  const vx0y1 = interpolateBorder(px0, py1, channel, image);
+  const vx1y1 = interpolateBorder(px1, py1, channel, image);
+
+  const r1 = (px1 - column) * vx0y0 + (column - px0) * vx1y0;
+  const r2 = (px1 - column) * vx0y1 + (column - px0) * vx1y1;
+  return round((py1 - row) * r1 + (row - py0) * r2);
+}
+
+/**
+ * @param image
+ * @param column - Column index.
+ * @param row - Row index.
+ * @param channel - Channel index.
+ * @param interpolateBorder
+ * @param clamp
+ */
+function interpolateBicubic(
+  image: IJS,
+  column: number,
+  row: number,
+  channel: number,
+  interpolateBorder: BorderInterpolationFunction,
+  clamp: ClampFunction,
+): number {
+  const px1 = Math.floor(column);
+  const py1 = Math.floor(row);
+
+  if (px1 === column && py1 === row) {
+    return interpolateBorder(px1, py1, channel, image);
+  }
+
+  const xNorm = column - px1;
+  const yNorm = row - py1;
+
+  const vx0y0 = interpolateBorder(px1 - 1, py1 - 1, channel, image);
+  const vx1y0 = interpolateBorder(px1, py1 - 1, channel, image);
+  const vx2y0 = interpolateBorder(px1 + 1, py1 - 1, channel, image);
+  const vx3y0 = interpolateBorder(px1 + 2, py1 - 1, channel, image);
+  const v0 = cubic(vx0y0, vx1y0, vx2y0, vx3y0, xNorm);
+
+  const vx0y1 = interpolateBorder(px1 - 1, py1, channel, image);
+  const vx1y1 = interpolateBorder(px1, py1, channel, image);
+  const vx2y1 = interpolateBorder(px1 + 1, py1, channel, image);
+  const vx3y1 = interpolateBorder(px1 + 2, py1, channel, image);
+  const v1 = cubic(vx0y1, vx1y1, vx2y1, vx3y1, xNorm);
+
+  const vx0y2 = interpolateBorder(px1 - 1, py1 + 1, channel, image);
+  const vx1y2 = interpolateBorder(px1, py1 + 1, channel, image);
+  const vx2y2 = interpolateBorder(px1 + 1, py1 + 1, channel, image);
+  const vx3y2 = interpolateBorder(px1 + 2, py1 + 1, channel, image);
+  const v2 = cubic(vx0y2, vx1y2, vx2y2, vx3y2, xNorm);
+
+  const vx0y3 = interpolateBorder(px1 - 1, py1 + 2, channel, image);
+  const vx1y3 = interpolateBorder(px1, py1 + 2, channel, image);
+  const vx2y3 = interpolateBorder(px1 + 1, py1 + 2, channel, image);
+  const vx3y3 = interpolateBorder(px1 + 2, py1 + 2, channel, image);
+  const v3 = cubic(vx0y3, vx1y3, vx2y3, vx3y3, xNorm);
+
+  return round(clamp(cubic(v0, v1, v2, v3, yNorm)));
+}
+
+/**
+ * @param a
+ * @param b
+ * @param c
+ * @param d
+ * @param x
+ */
+function cubic(a: number, b: number, c: number, d: number, x: number): number {
+  return (
+    b +
+    0.5 *
+      x *
+      (c -
+        a +
+        x * (2.0 * a - 5.0 * b + 4.0 * c - d + x * (3.0 * (b - c) + d - a)))
+  );
+}

package/src/utils/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/kinds.ts

@@ -0,0 +1,27 @@
+import { ImageColorModel } from '../IJS';
+
+interface ColorModelDefinitions {
+  [key: string]: {
+    channels: number;
+    alpha: boolean;
+  };
+}
+
+export const colorModelDefinitions: ColorModelDefinitions = {
+  [ImageColorModel.GREY]: {
+    channels: 1,
+    alpha: false,
+  },
+  [ImageColorModel.GREYA]: {
+    channels: 2,
+    alpha: true,
+  },
+  [ImageColorModel.RGB]: {
+    channels: 3,
+    alpha: false,
+  },
+  [ImageColorModel.RGBA]: {
+    channels: 4,
+    alpha: true,
+  },
+};

package/src/utils/round.ts

@@ -0,0 +1,6 @@
+export function round(value: number): number {
+  if (value % 0.5 !== 0) {
+    return Math.round(value);
+  }
+  return Math.floor(value) % 2 === 0 ? Math.floor(value) : Math.ceil(value);
+}

package/src/utils/validators.ts

@@ -0,0 +1,43 @@
+import { IJS } from '../IJS';
+
+/**
+ * Validate an array of channels.
+ *
+ * @param channels - Array of channels.
+ * @param image - The image being processed
+ */
+export function validateChannels(channels: number[], image: IJS): void {
+  for (const channel of channels) {
+    validateChannel(channel, image);
+  }
+}
+
+/**
+ * Validates that a channel index passed by the user is within range and is an integer.
+ *
+ * @param channel - Channel index to validate.
+ * @param image - The image being processed.
+ */
+export function validateChannel(channel: number, image: IJS): void {
+  if (!Number.isInteger(channel) || channel >= image.channels || channel < 0) {
+    throw new RangeError(
+      `invalid channel: ${channel}. It must be a positive integer smaller than ${image.channels}`,
+    );
+  }
+}
+
+/**
+ * Validates that a value passed by the user is within range and is an integer.
+ *
+ * @param value - Value to validate.
+ * @param image - Image from which the value comes.
+ */
+export function validateValue(value: number, image: IJS): void {
+  if (!Number.isInteger(value) || value > image.maxValue || value < 0) {
+    throw new RangeError(
+      `invalid value: ${value}. It must be a positive integer smaller than ${
+        image.maxValue + 1
+      }`,
+    );
+  }
+}