test: add and improve test cases for transform functions (#441)

Author: EscapedGibbon

src/compute/__tests__/histogram.test.ts

@@ -98,7 +98,7 @@ test('throw if slots is not a power of 2', () => {
     [0, 255, 255, 255, 0],
     [0, 0, 0, 0, 0],
   ]);
-  expect(() => image.histogram({ slots: 7 })).toThrowError(
+  expect(() => image.histogram({ slots: 7 })).toThrow(
     'slots must be a power of 2, for example: 64, 256, 1024',
   );
 });

src/filters/__tests__/convolution.test.ts

@@ -16,7 +16,7 @@ describe('convolution functions', () => {
       },
     );
 
-    const expected = testUtils.load('opencv/testConv.png');
+    const expected = testUtils.load('opencv/testConvolution.png');
 
     expect(convoluted).toMatchImage(expected);
   });
@@ -32,7 +32,7 @@ describe('convolution functions', () => {
       borderType: 'reflect',
     });
 
-    const expected = testUtils.load('opencv/testConv.png');
+    const expected = testUtils.load('opencv/testConvolution.png');
     expect(convoluted).toMatchImage(expected);
   });
 

src/filters/__tests__/gaussianBlur.test.ts

@@ -1,4 +1,8 @@
-import { GaussianBlurOptions, gaussianBlur } from '../gaussianBlur';
+import {
+  GaussianBlurOptions,
+  gaussianBlur,
+  GaussianBlurSigmaOptions,
+} from '../gaussianBlur';
 
 test('symmetrical kernel, should return the kernel itself', () => {
   const image = testUtils.createGreyImage([
@@ -102,26 +106,20 @@ test('x and y kernels', () => {
 
   expect(() => {
     return image.gaussianBlur(options);
-  }).toThrowError(
+  }).toThrow(
     'you must either define sigma or sigmaX and sigmaY in the options argument',
   );
 });
 
-test.skip('gaussian blur should have same result as opencv', () => {
+test('gaussian blur should have same result as opencv', () => {
   const img = testUtils.load('opencv/test.png');
-  const options: GaussianBlurOptions = {
+  const options: GaussianBlurSigmaOptions = {
     borderType: 'reflect',
     size: 3,
-    sigmaX: 1,
-    sigmaY: 1,
+    sigma: 1,
   };
   const blurred = gaussianBlur(img, options);
 
-  // const grey = convertColor(img, ImageKind.GREY);
-  // const greyBlurred = gaussianBlur(grey, options);
-  // console.log(greyBlurred.data);
-
   const expected = testUtils.load('opencv/testGaussianBlur.png');
-  // write('gaussian.png', blurred);
-  expect(expected).toMatchImage(blurred);
+  expect(blurred).toMatchImage(expected);
 });

src/geometry/__tests__/transform.test.ts

@@ -1,4 +1,6 @@
-test('compare result of translation with opencv', () => {
+//To look at the equivalent opencv code go to generate.py in test/img/opencv
+//folder.
+test('compare result of translation with opencv with default parameters', () => {
   const img = testUtils.load('opencv/test.png');
   const translation = [
     [1, 0, 2],
@@ -9,23 +11,106 @@ test('compare result of translation with opencv', () => {
     height: 20,
   });
 
-  expect(transformed).toMatchImage('opencv/testTranslation.png');
+  expect(transformed).toMatchImage('opencv/testTranslate.png');
 });
 
-// is this the expected result for the fullImage option??
-test.skip('fullImage = true', () => {
+test('compare result of clockwise rotation with opencv', () => {
   const img = testUtils.load('opencv/test.png');
-  const translation = [
-    [1, 0, 2],
-    [0, 1, 10],
-  ];
-  const transformed = img.transform(translation, {
-    width: 16,
-    height: 15,
-    fullImage: true,
-  });
+  const transformed = img.transform(
+    [
+      [0, -1, img.width + 1],
+      [1, 0, 0],
+    ],
+    {
+      inverse: false,
+      fullImage: false,
+      width: 10,
+      height: 8,
+      borderType: 'constant',
+      borderValue: 0,
+      interpolationType: 'bilinear',
+    },
+  );
+  expect(transformed).toMatchImage('opencv/testClockwiseRot90.png');
+});
 
-  expect(transformed).toMatchImage('opencv/testTranslation.png');
+test('compare result of anti-clockwise rotation with opencv', () => {
+  const img = testUtils.load('opencv/test.png');
+  const transformed = img.transform(
+    [
+      [0, 1, 0],
+      [-1, 0, img.width - 1],
+    ],
+    {
+      inverse: false,
+      fullImage: false,
+      width: 10,
+      height: 8,
+      borderType: 'constant',
+      borderValue: 0,
+      interpolationType: 'bilinear',
+    },
+  );
+  expect(transformed).toMatchImage('opencv/testAntiClockwiseRot90.png');
+});
+
+test('get a vertical reflection of an image', () => {
+  const img = testUtils.load('opencv/test.png');
+  const transformed = img.transform(
+    [
+      [1, 0, 0],
+      [0, -1, img.height - 1],
+    ],
+    {
+      inverse: false,
+      fullImage: false,
+      borderType: 'constant',
+      borderValue: 0,
+      interpolationType: 'bilinear',
+    },
+  );
+  expect(transformed).toMatchImage('opencv/testReflect.png');
+});
+//problematic test1
+//Scaling with test image works only if the image is scaled by 2 or by 4.
+test('get a scale of an image to 32*40', () => {
+  const img = testUtils.load('opencv/test.png');
+  const transformed = img.transform(
+    [
+      [4, 0, 0],
+      [0, 4, 0],
+    ],
+    {
+      inverse: false,
+      fullImage: false,
+      width: img.width * 4,
+      height: img.height * 4,
+      borderType: 'constant',
+      borderValue: 0,
+      interpolationType: 'bilinear',
+    },
+  );
+  expect(transformed).toMatchImage('opencv/testScale.png');
+});
+
+test('affineTransformation', () => {
+  const img = testUtils.load('opencv/test.png');
+  const transformed = img.transform(
+    [
+      [2, 1, 2],
+      [-1, 1, 2],
+    ],
+    {
+      inverse: false,
+      fullImage: false,
+      interpolationType: 'bilinear',
+      borderType: 'constant',
+    },
+  );
+  // OpenCV bilinear interpolation is less precise for speed.
+  expect(transformed).toMatchImage('opencv/testAffineTransform.png', {
+    error: 3,
+  });
 });
 
 test('should throw if matrix has wrong size', () => {

src/geometry/__tests__/transformRotate.test.ts

@@ -10,7 +10,7 @@ test('rotate + scale compared to opencv (nearest)', () => {
     center: { column: 2, row: 4 },
   });
 
-  expect(rotated).toMatchImage('opencv/testRotate.png');
+  expect(rotated).toMatchImage('opencv/testInterpolate.png');
 });
 
 test('rotate + scale compared to opencv (bilinear)', () => {
@@ -22,6 +22,7 @@ test('rotate + scale compared to opencv (bilinear)', () => {
     interpolationType: 'bilinear',
     center: { column: 2, row: 4 },
   });
+  // OpenCV bilinear interpolation is less precise for speed.
   expect(rotated).toMatchImage('opencv/testRotateBilinear.png', { error: 5 });
 });
 
@@ -35,6 +36,7 @@ test('rotate + scale compared to opencv (bicubic)', () => {
     center: { column: 2, row: 4 },
   });
 
+  // OpenCV bilinear interpolation is less precise for speed.
   expect(rotated).toMatchImage('opencv/testRotateBicubic.png', { error: 13 });
 });
 

src/utils/geometry/__tests__/removeClosePoints.test.ts

@@ -98,7 +98,7 @@ test('test error handling', () => {
       distance: 0,
     });
     return result;
-  }).toThrowError(
+  }).toThrow(
     'image channel must be specified or image must have only one channel',
   );
 });

test/TestImagePath.ts

@@ -27,14 +27,19 @@ export type TestImagePath =
   | 'formats/tif/rgba8-multi.tif'
   | 'formats/tif/palette.tif'
   | 'opencv/test.png'
+  | 'opencv/testAffineTransform.png'
   | 'opencv/testBlur.png'
-  | 'opencv/testConv.png'
+  | 'opencv/testConvolution.png'
   | 'opencv/testGaussianBlur.png'
-  | 'opencv/testRotate.png'
+  | 'opencv/testInterpolate.png'
   | 'opencv/testRotateBicubic.png'
   | 'opencv/testRotateBilinear.png'
-  | 'opencv/testTranslation.png'
+  | 'opencv/testTranslate.png'
   | 'opencv/testResizeBilinear.png'
+  | 'opencv/testAntiClockwiseRot90.png'
+  | 'opencv/testClockwiseRot90.png'
+  | 'opencv/testScale.png'
+  | 'opencv/testReflect.png'
   | 'various/grayscale_by_zimmyrose.png'
   | 'various/alphabet.jpg'
   | 'various/without-metadata.jpg'

test/img/opencv/generate.py

@@ -0,0 +1,74 @@
+import numpy as np
+import cv2 as cv
+
+img = cv.imread('./test.png')
+assert img is not None, "file could not be read, check with os.path.exists()"
+rows, cols = img.shape[0], img.shape[1]
+
+# Image scaling by 10.
+scale = 4
+M = np.float32([[scale, 0, 0], [0, scale, 0]])
+dst = cv.warpAffine(img, M, dsize=(cols * scale, rows * scale), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT,
+                    borderValue=0)
+cv.imwrite('testScale.png', dst)
+
+# Image resizing by 10.
+dst = cv.resize(img, (80, 100), interpolation=cv.INTER_LINEAR)
+cv.imwrite('testResizeBilinear.png', dst)
+
+# Image rotate counter-clockwise by 90 degrees
+M = np.float32([[0, 1, 0], [-1, 0, cols - 1]])
+dst = cv.warpAffine(img, M, (rows, cols), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT)
+cv.imwrite('testAntiClockwiseRot90.png', dst)
+
+# Image rotate clockwise by 90 degrees
+M = np.float32([[0, -1, cols + 1], [1, 0, 0]])
+dst = cv.warpAffine(img, M, (rows, cols), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT)
+cv.imwrite('testClockwiseRot90.png', dst)
+
+# Image interpolation
+matrix = cv.getRotationMatrix2D((2, 4), angle=30, scale=0.8)
+dst = cv.warpAffine(img, matrix, dsize=(cols, rows), flags=cv.INTER_NEAREST, borderMode=cv.BORDER_REFLECT)
+cv.imwrite('testInterpolate.png', dst)
+
+# Image bilinear interpolation
+matrix = cv.getRotationMatrix2D((2, 4), angle=30, scale=1.4)
+dst = cv.warpAffine(img, matrix, dsize=(cols, rows), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_REFLECT)
+cv.imwrite('testRotateBilinear.png', dst)
+
+# Image bicubic interpolation
+matrix = cv.getRotationMatrix2D((2, 4), angle=30, scale=1.4)
+dst = cv.warpAffine(img, matrix, dsize=(cols, rows), flags=cv.INTER_CUBIC, borderMode=cv.BORDER_REFLECT)
+cv.imwrite('testRotateBicubic.png', dst)
+
+# Image reflection
+M = np.float32([[1, 0, 0], [0, -1, rows - 1]])
+dst = cv.warpAffine(img, M, (cols, rows), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT)
+cv.imwrite('testReflect.png', dst)
+
+# Image translation
+M = np.float32([[1, 0, 2], [0, 1, 4]])
+dst = cv.warpAffine(img, M, (16, 20))
+cv.imwrite('testTranslate.png', dst)
+
+# Image affine transformation
+M = np.float32([[2, 1, 2], [-1, 1, 2]])
+dst = cv.warpAffine(img, M, (cols, rows), flags=cv.INTER_LINEAR, borderMode=cv.BORDER_CONSTANT)
+cv.imwrite('testAffineTransform.png', dst)
+
+# Image blur
+dst = cv.blur(img, (3, 5), borderType=cv.BORDER_REFLECT)
+cv.imwrite('testBlur.png', dst)
+
+# Image gaussian blur
+kernel = cv.getGaussianKernel(3, 1)
+dst = cv.sepFilter2D(img, -1, kernel, kernel, borderType=cv.BORDER_REFLECT)
+cv.imwrite('testGaussianBlur.png', dst)
+
+# Image convolution
+kernelX = np.float32([[0.1, 0.2, 0.3]])
+
+kernelY = np.float32([[0.4, 0.5, 0.6, -0.3, -0.4]])
+
+dst = cv.sepFilter2D(img, ddepth=-1, kernelX=kernelX, kernelY=kernelY, borderType=cv.BORDER_REFLECT)
+cv.imwrite('testConvolution.png', dst)