test: add more simple matching tests

Author: opatiny

src/featureMatching/descriptors/__tests__/getBriefDescriptors.test.ts

@@ -113,16 +113,51 @@ test('verify descriptor is correct (descriptorLength = 10)', () => {
   );
 });
 
-test.only('compare scalene triangle keypoints', () => {
+test.each([
+  {
+    message: 'windowSize = 7',
+    windowSize: 7,
+    expected: [
+      { srcIndex: 0, dstIndex: 0, distance: 15 },
+      { srcIndex: 0, dstIndex: 1, distance: 73 },
+      { srcIndex: 1, dstIndex: 0, distance: 77 },
+      { srcIndex: 1, dstIndex: 1, distance: 11 },
+    ],
+  },
+  {
+    message: 'windowSize = 15',
+    windowSize: 15,
+    expected: [
+      { srcIndex: 0, dstIndex: 0, distance: 13 },
+      { srcIndex: 0, dstIndex: 1, distance: 11 },
+      { srcIndex: 1, dstIndex: 0, distance: 23 },
+      { srcIndex: 1, dstIndex: 1, distance: 7 },
+    ],
+  },
+  {
+    message: 'windowSize = 31',
+    windowSize: 31,
+    expected: [
+      { srcIndex: 0, dstIndex: 0, distance: 11 },
+      { srcIndex: 0, dstIndex: 1, distance: 14 },
+      { srcIndex: 1, dstIndex: 0, distance: 20 },
+      { srcIndex: 1, dstIndex: 1, distance: 9 },
+    ],
+  },
+])('check distance for each keypoint pair ($message)', (data) => {
   const source = testUtils
     .load('featureMatching/polygons/scaleneTriangle.png')
     .convertColor(ImageColorModel.GREY);
-  const sourceKeypoints = getOrientedFastKeypoints(source);
+  const sourceKeypoints = getOrientedFastKeypoints(source, {
+    windowSize: data.windowSize,
+  });
   const sourceBrief = getBriefDescriptors(source, sourceKeypoints);
   const destination = testUtils
     .load('featureMatching/polygons/scaleneTriangle10.png')
     .convertColor(ImageColorModel.GREY);
-  const destinationKeypoints = getOrientedFastKeypoints(destination);
+  const destinationKeypoints = getOrientedFastKeypoints(destination, {
+    windowSize: data.windowSize,
+  });
   const destinationBrief = getBriefDescriptors(
     destination,
     destinationKeypoints,
@@ -147,11 +182,6 @@ test.only('compare scalene triangle keypoints', () => {
     }
   }
 
-  // 0-0 and 1-1 are the correct matches, so this looks good
-  expect(result).toStrictEqual([
-    { srcIndex: 0, dstIndex: 0, distance: 15 },
-    { srcIndex: 0, dstIndex: 1, distance: 73 },
-    { srcIndex: 1, dstIndex: 0, distance: 77 },
-    { srcIndex: 1, dstIndex: 1, distance: 11 },
-  ]);
+  // 0-0 and 1-1 are the correct matches
+  expect(result).toStrictEqual(data.expected);
 });

src/featureMatching/descriptors/utils/__tests__/__image_snapshots__/get-keypoint-patch-test-ts-window-size-15-scalene-triangle-1-snap.png

@@ -58,3 +58,24 @@ test('patch had black pixels on border', () => {
 
   expect(result).toMatchImageSnapshot();
 });
+
+test.each([
+  {
+    message: 'scalene triangle',
+    image: 'scaleneTriangle',
+  },
+  {
+    message: 'scalene triangle rotated 10°',
+    image: 'scaleneTriangle10',
+  },
+])('windowSize = 15 ($message)', (data) => {
+  const image = testUtils
+    .load(`featureMatching/polygons/${data.image}.png` as TestImagePath)
+    .convertColor(ImageColorModel.GREY);
+
+  const keypoints = getOrientedFastKeypoints(image, { windowSize: 15 });
+
+  for (let keypoint of keypoints) {
+    expect(getKeypointPatch(image, keypoint)).toMatchImageSnapshot();
+  }
+});

src/featureMatching/descriptors/utils/__tests__/__image_snapshots__/get-keypoint-patch-test-ts-window-size-15-scalene-triangle-2-snap.png

@@ -96,3 +96,55 @@ test('angle should never be NaN', () => {
     expect(isNaN(keypoint.angle)).toBe(false);
   }
 });
+
+test('check angle for different windowSize', () => {
+  const image = testUtils
+    .load('featureMatching/polygons/scaleneTriangle10.png')
+    .convertColor(ImageColorModel.GREY);
+
+  const keypoints7 = getOrientedFastKeypoints(image);
+  const keypoints15 = getOrientedFastKeypoints(image, { windowSize: 15 });
+  const keypoints31 = getOrientedFastKeypoints(image, { windowSize: 31 });
+
+  expect([keypoints7, keypoints15, keypoints31]).toBeDeepCloseTo(
+    [
+      [
+        {
+          origin: { row: 607, column: 132 },
+          score: 2680,
+          angle: 145.3,
+        },
+        {
+          origin: { row: 50, column: 292 },
+          score: 2662,
+          angle: -112.2,
+        },
+      ],
+      [
+        {
+          origin: { row: 607, column: 132 },
+          score: 2680,
+          angle: 123.7,
+        },
+        {
+          origin: { row: 50, column: 292 },
+          score: 2662,
+          angle: -95.4,
+        },
+      ],
+      [
+        {
+          origin: { row: 607, column: 132 },
+          score: 2680,
+          angle: 120,
+        },
+        {
+          origin: { row: 50, column: 292 },
+          score: 2662,
+          angle: -92.1,
+        },
+      ],
+    ],
+    1,
+  );
+});

src/featureMatching/descriptors/utils/__tests__/__image_snapshots__/get-keypoint-patch-test-ts-window-size-15-scalene-triangle-rotated-10-1-snap.png

@@ -46,12 +46,12 @@ export function getOrientedFastKeypoints(
 
   const fastKeypoints = getFastKeypoints(image, options);
 
-  const borderDistance = getRadius(windowSize);
+  const radius = getRadius(windowSize);
 
   // handle edge cases: remove keypoints too close to border
   let keypoints: FastKeypoint[] = [];
   for (let keypoint of fastKeypoints) {
-    if (checkBorderDistance(image, keypoint.origin, borderDistance)) {
+    if (checkBorderDistance(image, keypoint.origin, radius)) {
       keypoints.push(keypoint);
     }
   }
@@ -60,7 +60,7 @@ export function getOrientedFastKeypoints(
   for (let keypoint of keypoints) {
     const centroid = getPatchIntensityCentroid(image, {
       origin: keypoint.origin,
-      radius: borderDistance,
+      radius,
     })[0];
     const angle = toDegrees(getAngle({ column: 0, row: 0 }, centroid));
     orientedFastKeypoints.push({ ...keypoint, angle });