test(getPatchIntensityCentroid): tests are passing

Author: opatiny

src/Image.ts

@@ -333,7 +333,6 @@ export class Image {
     const start = (row * this.width + column) * this.channels;
     for (let i = 0; i < this.channels; i++) {
       this.data[start + i] = value[i];
-      console.log(this.data[start + i], value[i]);
     }
   }
 
@@ -346,7 +345,6 @@ export class Image {
    */
   public setVisiblePixel(column: number, row: number, value: number[]): void {
     if (column >= 0 && column < this.width && row >= 0 && row < this.height) {
-      console.log(value);
       this.setPixel(column, row, value);
     }
   }

src/featureMatching/keypoints/__tests__/__image_snapshots__/get-patch-intensity-centroid-test-ts-patch-default-options-1-snap.png

@@ -8,25 +8,68 @@ test('3x3 empty image', () => {
   expect(result).toStrictEqual([{ column: 0, row: 0 }]);
 });
 
-test.only('patch, default options', () => {
+test('3x3 image', () => {
+  const image = testUtils.createGreyImage([
+    [0, 0, 0],
+    [1, 0, 0],
+    [0, 0, 0],
+  ]);
+  const result = getPatchIntensityCentroid(image, { radius: 1 });
+  expect(result).toStrictEqual([{ column: -1, row: 0 }]);
+});
+
+test('5x5 image', () => {
+  const image = testUtils.createGreyImage([
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 9],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+  ]);
+  const result = getPatchIntensityCentroid(image, { radius: 2 });
+  expect(result).toStrictEqual([{ column: 1.9, row: 0 }]);
+});
+
+test('5x5 image, diagonal line', () => {
+  const image = testUtils.createGreyImage([
+    [0, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0],
+    [0, 0, 1, 0, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+  ]);
+  const result = getPatchIntensityCentroid(image, { radius: 2 });
+  expect(result).toStrictEqual([{ column: -0.5, row: -0.5 }]);
+});
+
+test('check window is circular', () => {
+  const image = testUtils.createGreyImage([
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 0],
+    [0, 0, 0, 1, 0],
+    [0, 0, 0, 1, 0],
+    [0, 0, 0, 0, 100],
+  ]);
+  const result = getPatchIntensityCentroid(image, { radius: 2 });
+  expect(result).toStrictEqual([{ column: 1, row: 0 }]);
+});
+
+test('patch, default options', () => {
   const image = testUtils.load('featureMatching/patch.png');
-  console.log(image.colorModel);
+  image.invert({ out: image });
 
-  const centroid = round(getPatchIntensityCentroid(image)[0]);
-  console.log(centroid);
+  const radius = 3;
+
+  const centroid = getPatchIntensityCentroid(image)[0];
 
   const center = image.getCoordinates(ImageCoordinates.CENTER);
 
-  const point = sum(center, centroid);
-  console.log(point);
+  const point = round(sum(center, centroid));
 
   const result = image.convertColor(ImageColorModel.RGB);
-  for (let i = 14; i < 15; i++) {
-    result.drawPoints([{ row: i, column: i }], {
-      color: [0, 255, 0],
-      out: result,
-    });
-  }
+  result.drawCircle(center, radius + 1, { color: [255, 0, 0], out: result });
+
+  result.drawPoints([point], { color: [0, 255, 0], out: result });
 
   expect(result).toMatchImageSnapshot();
 });

src/featureMatching/keypoints/__tests__/getPatchIntensityCentroid.test.ts

@@ -24,6 +24,18 @@ test('5x5 image, 01, radius = 2', () => {
   expect(result).toStrictEqual([-3]);
 });
 
+test('5x5 image, 10, radius = 2', () => {
+  const image = testUtils.createGreyImage([
+    [0, 0, 1, 0, 42],
+    [0, 0, 1, 0, 0],
+    [0, 0, 0, 4, 0],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0],
+  ]);
+  const result = getPatchIntensityMoment(image, 1, 0, { radius: 2 });
+  expect(result).toStrictEqual([4]);
+});
+
 test('too close to border error', () => {
   const image = testUtils.createGreyImage([
     [0, 0, 1, 0, 42],

src/featureMatching/keypoints/__tests__/getPatchIntensityMoment.test.ts

@@ -59,7 +59,7 @@ export function getOrientedFastKeypoints(
   let orientedFastKeypoints: OrientedFastKeypoint[] = [];
   for (let keypoint of keypoints) {
     const centroid = getPatchIntensityCentroid(image, {
-      origin: keypoint.origin,
+      center: keypoint.origin,
       radius,
     })[0];
     const angle = toDegrees(getAngle({ column: 0, row: 0 }, centroid));

src/featureMatching/keypoints/getOrientedFastKeypoints.ts

@@ -1,5 +1,6 @@
 import { Image, ImageCoordinates } from '../../Image';
 import { Point } from '../../geometry';
+import { getFilledCirclePoints } from '../../utils/geometry/getCirclePoints';
 import { checkBorderDistance } from '../utils/checkBorderDistance';
 
 export interface GetPatchIntensityMomentOptions {
@@ -8,7 +9,7 @@ export interface GetPatchIntensityMomentOptions {
    *
    * @default The center of the image.
    */
-  origin?: Point;
+  center?: Point;
   /**
    * Radius of the circular window.
    *
@@ -27,37 +28,33 @@ export interface GetPatchIntensityMomentOptions {
  * @param p - Order along x.
  * @param q - Order along y.
  * @param options - Get intensity moment options.
- * @returns The intensity moment of order pq or the circular window.
+ * @returns The intensity moment of order pq of the circular window relative to the center.
  */
 export function getPatchIntensityMoment(
   image: Image,
   p: number,
   q: number,
   options: GetPatchIntensityMomentOptions = {},
 ): number[] {
-  const { origin = image.getCoordinates(ImageCoordinates.CENTER), radius = 3 } =
-    options;
+  const {
+    center: origin = image.getCoordinates(ImageCoordinates.CENTER),
+    radius = 3,
+  } = options;
 
   if (!checkBorderDistance(image, origin, radius)) {
     throw new Error(`desired patch is too close to image border`);
   }
-
   let moment = new Array(image.channels).fill(0);
-  for (let row = origin.row - radius; row < origin.row + radius; row++) {
-    for (
-      let column = origin.column - radius;
-      column < origin.column + radius;
-      column++
-    ) {
-      const xDistance = column - origin.column;
-      const yDistance = row - origin.row;
 
-      if (xDistance ** 2 + yDistance ** 2 <= radius ** 2) {
-        for (let channel = 0; channel < image.channels; channel++) {
-          const intensity = image.getValue(column, row, channel);
-          moment[channel] += xDistance ** p * yDistance ** q * intensity;
-        }
-      }
+  let relativeCirclePoints = getFilledCirclePoints(radius);
+  for (let point of relativeCirclePoints) {
+    for (let channel = 0; channel < image.channels; channel++) {
+      const intensity = image.getValue(
+        point.column + origin.column,
+        point.row + origin.row,
+        channel,
+      );
+      moment[channel] += point.column ** p * point.row ** q * intensity;
     }
   }
   return moment;