feat(level): parameters can now be arrays

Closes: #307

Author: opatiny

src/filters/__tests__/level.test.ts

@@ -77,21 +77,42 @@ test('3x1 rgba image, custom channels', () => {
     [30, 40, 50, 50],
     [60, 70, 80, 50],
   ]);
-  expect(
-    image.level({
-      inputMin: 10,
-      inputMax: 60,
-      outputMin: 0,
-      outputMax: 100,
-      channels: [1],
-    }),
-  ).toMatchImageData([
+
+  const result = image.level({
+    inputMin: 10,
+    inputMax: 60,
+    outputMin: 0,
+    outputMax: 100,
+    channels: [1],
+  });
+  expect(result).toMatchImageData([
     [0, 0, 20, 50],
     [30, 60, 50, 50],
     [60, 100, 80, 50],
   ]);
 });
 
+test('3x1 rgba image, other custom channels', () => {
+  const image = testUtils.createRgbaImage([
+    [0, 10, 20, 50],
+    [30, 40, 50, 50],
+    [60, 70, 80, 50],
+  ]);
+
+  const result = image.level({
+    inputMin: 10,
+    inputMax: 60,
+    outputMin: 0,
+    outputMax: 100,
+    channels: [0, 3],
+  });
+  expect(result).toMatchImageData([
+    [0, 10, 20, 80],
+    [40, 40, 50, 80],
+    [100, 70, 80, 80],
+  ]);
+});
+
 test('3x1 rgba image, modify alpha', () => {
   const image = testUtils.createRgbaImage([
     [0, 10, 20, 50],
@@ -112,3 +133,24 @@ test('3x1 rgba image, modify alpha', () => {
     [100, 100, 100, 80],
   ]);
 });
+
+test('3x1 rgba image, arrays as input', () => {
+  const image = testUtils.createRgbaImage([
+    [0, 10, 20, 50],
+    [30, 40, 50, 50],
+    [60, 70, 80, 50],
+  ]);
+
+  const result = image.level({
+    inputMin: [0, 0, 0, 0],
+    inputMax: [50, 50, 100, 100],
+    outputMin: 0,
+    outputMax: 100,
+  });
+
+  expect(result).toMatchImageData([
+    [0, 20, 20, 50],
+    [60, 80, 50, 50],
+    [100, 100, 80, 50],
+  ]);
+});

src/filters/level.ts

@@ -17,31 +17,31 @@ export interface LevelOptions {
    *
    * @default 0
    */
-  inputMin?: number;
+  inputMin?: number | number[];
   /**
    * Maximal input value.
    *
    * @default image.maxValue
    */
-  inputMax?: number;
+  inputMax?: number | number[];
   /**
    * Minimal output value.
    *
    * @default 0
    */
-  outputMin?: number;
+  outputMin?: number | number[];
   /**
    * Maximal output value.
    *
    * @default image.maxValue
    */
-  outputMax?: number;
+  outputMax?: number | number[];
   /**
    * Specifies the shape of the curve connecting the two points.
    *
    * @default 1
    */
-  gamma?: number;
+  gamma?: number | number[];
   /**
    * Image to which to output.
    */
@@ -75,17 +75,31 @@ export function level(image: Image, options: LevelOptions = {}) {
 
   const clamp = getClamp(image);
 
+  inputMin = getValueArray(inputMin, image.channels);
+  inputMax = getValueArray(inputMax, image.channels);
+  outputMin = getValueArray(outputMin, image.channels);
+  outputMax = getValueArray(outputMax, image.channels);
+  gamma = getValueArray(gamma, image.channels);
+
   for (let row = 0; row < image.height; row++) {
     for (let column = 0; column < image.width; column++) {
       for (let channel of channels) {
         let currentValue = image.getValue(column, row, channel);
 
-        let clamped = Math.max(Math.min(currentValue, inputMax), inputMin);
+        let clamped = Math.max(
+          Math.min(currentValue, inputMax[channel]),
+          inputMin[channel],
+        );
 
-        const ratio = clamp((clamped - inputMin) / (inputMax - inputMin));
+        const ratio = clamp(
+          (clamped - inputMin[channel]) /
+            (inputMax[channel] - inputMin[channel]),
+        );
 
         const result = clamp(
-          ratio ** (1 / gamma) * (outputMax - outputMin) + outputMin,
+          ratio ** (1 / gamma[channel]) *
+            (outputMax[channel] - outputMin[channel]) +
+            outputMin[channel],
         );
 
         newImage.setValue(column, row, channel, result);
@@ -94,3 +108,25 @@ export function level(image: Image, options: LevelOptions = {}) {
   }
   return newImage;
 }
+
+/**
+ * Get an array with correct values for each channel to process.
+ *
+ * @param value - Number or array to transform to the final array.
+ * @param imageChannels - Number of channels processed in the level function.
+ * @returns Array of values for each channel.
+ */
+function getValueArray(
+  value: number | number[],
+  imageChannels: number,
+): number[] {
+  if (Array.isArray(value)) {
+    if (value.length === imageChannels) {
+      return value;
+    } else {
+      throw new Error('array length is not compatible with channel option');
+    }
+  } else {
+    return new Array(imageChannels).fill(value);
+  }
+}