feat: add getExtrema and removeClosePoints geometry utils (#412)

chore: fix eslint issues
chore: improve watershed tests

Author: EscapedGibbon

package.json

@@ -78,7 +78,7 @@
     "autoprefixer": "^10.4.16",
     "clsx": "^2.0.0",
     "cross-env": "^7.0.3",
-    "eslint": "^8.53.0",
+    "eslint": "^8.55.0",
     "eslint-config-cheminfo-react": "^10.0.0",
     "eslint-config-cheminfo-typescript": "^12.0.4",
     "eslint-plugin-import": "^2.29.0",

src/compare/computeRmse.ts

@@ -26,7 +26,7 @@ export function computeMse(image: Image, otherImage: Image): number {
   for (let i = 0; i < image.size; i++) {
     for (let channel = 0; channel < image.channels; channel++) {
       const value = difference.getValueByIndex(i, channel);
-      sum += Math.pow(value, 2);
+      sum += value ** 2;
     }
   }
   return sum / (image.size * image.channels);

src/compute/__tests__/getExtrema.test.ts

@@ -1,4 +1,4 @@
-import getExtrema from '../getExtrema';
+import { getExtrema } from '../getExtrema';
 
 test('minimum of grey image from legacy code', () => {
   const image = testUtils.createGreyImage([

src/compute/getExtrema.ts

@@ -2,7 +2,7 @@ import { Image, Mask, Point } from '..';
 import { assertUnreachable } from '../utils/validators/assert';
 import checkProcessable from '../utils/validators/checkProcessable';
 
-interface ExtremaOptions {
+export interface ExtremaOptions {
   /**
    * Chooses what kind of extremum to compute.
    * @default `'maximum'`
@@ -30,10 +30,7 @@ interface ExtremaOptions {
  * @param options - ExtremaOptions
  * @returns Array of Points.
  */
-export default function getExtrema(
-  image: Image,
-  options: ExtremaOptions,
-): Point[] {
+export function getExtrema(image: Image, options: ExtremaOptions): Point[] {
   const { kind = 'maximum', mask, algorithm = 'star', maxEquals = 2 } = options;
   checkProcessable(image, {
     bitDepth: [8, 16],

src/compute/index.ts

@@ -1,3 +1,4 @@
 export * from './mean';
 export * from './histogram';
 export * from './median';
+export * from './getExtrema';

src/compute/variance.ts

@@ -12,10 +12,7 @@ export function variance(image: Image): number[] {
   const sum = new Array(image.channels).fill(0);
   for (let i = 0; i < image.size; i++) {
     for (let channel = 0; channel < image.channels; channel++) {
-      sum[channel] += Math.pow(
-        image.getValueByIndex(i, channel) - mean[channel],
-        2,
-      );
+      sum[channel] += (image.getValueByIndex(i, channel) - mean[channel]) ** 2;
     }
   }
 

src/featureMatching/keypoints/getHarrisScore.ts

@@ -68,6 +68,6 @@ export function getHarrisScore(
 
   return (
     eigenValues[0] * eigenValues[1] -
-    harrisConstant * Math.pow(eigenValues[0] + eigenValues[1], 2)
+    harrisConstant * (eigenValues[0] + eigenValues[1]) ** 2
   );
 }

src/featureMatching/visualize/__tests__/Montage.test.ts

@@ -13,13 +13,13 @@ describe('constructor', () => {
   });
   it('should error when scale is not an integer', () => {
     expect(() => {
-      new Montage(source, source, { scale: 1.5 });
+      return new Montage(source, source, { scale: 1.5 });
     }).toThrow('scale must be an integer');
   });
   it('invalid disposition type', () => {
     expect(() => {
       // @ts-expect-error: invalid disposition type
-      new Montage(source, source, { disposition: 'test' });
+      return new Montage(source, source, { disposition: 'test' });
     }).toThrow('invalid disposition type: test');
   });
 });

src/index.ts

@@ -6,6 +6,7 @@ export * from './draw';
 export * from './featureMatching';
 export * from './filters';
 export * from './geometry';
+export * from './utils/geometry';
 export * from './Image';
 export * from './load';
 export * from './Mask';

src/roi/__tests__/computeRois.test.ts

@@ -1,4 +1,5 @@
-import { fromMask } from '..';
+import { RoiMapManager, fromMask, waterShed } from '..';
+import { createGreyImage, getInt32Array } from '../../../test/testUtils';
 import { computeRois } from '../computeRois';
 
 test('3x3 mask', () => {
@@ -15,3 +16,50 @@ test('3x3 mask', () => {
   expect(roiMapManager.whiteRois).toMatchSnapshot();
   expect(roiMapManager.blackRois).toMatchSnapshot();
 });
+
+test('test 2, waterShed for a grey image', () => {
+  const image = createGreyImage([
+    [3, 3, 3, 3, 3, 3, 3, 3, 4, 4],
+    [3, 3, 2, 2, 2, 3, 3, 3, 4, 4],
+    [4, 3, 2, 1, 2, 2, 3, 3, 4, 4],
+    [4, 3, 2, 2, 2, 2, 3, 3, 3, 4],
+    [4, 4, 4, 3, 2, 3, 2, 3, 3, 4],
+    [4, 4, 4, 3, 3, 3, 3, 1, 3, 3],
+    [4, 3, 3, 3, 3, 3, 2, 2, 2, 3],
+    [4, 4, 3, 3, 3, 3, 2, 2, 2, 2],
+    [4, 4, 4, 4, 3, 2, 2, 2, 2, 3],
+    [4, 4, 4, 4, 3, 3, 3, 3, 2, 3],
+  ]);
+
+  const roiMapManager = waterShed(image, { threshold: 2 / 255 });
+
+  const result = new RoiMapManager({
+    data: getInt32Array(`
+           0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+           0,  0, -1, -1, -1,  0,  0,  0,  0,  0,
+           0,  0, -1, -1, -1, -1,  0,  0,  0,  0,
+           0,  0, -1, -1, -1, -1,  0,  0,  0,  0,
+           0,  0,  0,  0, -1,  0,  0,  0,  0,  0,
+           0,  0,  0,  0,  0,  0,  0, -2,  0,  0,
+           0,  0,  0,  0,  0,  0, -2, -2, -2,  0,
+           0,  0,  0,  0,  0,  0, -2, -2, -2, -2,
+           0,  0,  0,  0,  0, -2, -2, -2, -2,  0,
+           0,  0,  0,  0,  0,  0,  0,  0, -2,  0
+        `),
+    nbPositive: 0,
+    nbNegative: 2,
+    width: 10,
+    height: 10,
+  });
+  expect(roiMapManager).toStrictEqual(result);
+  computeRois(roiMapManager);
+
+  expect(roiMapManager.blackRois[0].origin).toStrictEqual({
+    column: 2,
+    row: 1,
+  });
+  expect(roiMapManager.blackRois[1].origin).toStrictEqual({
+    column: 5,
+    row: 5,
+  });
+});