feat: add option to specify the number of slots for the histogram (#448)

feat: add option to specify the number of slots for the histogram
refactor!: group optional arguments in computeThreshold

Author: moonayyur

src/operations/__tests__/threshold.test.ts

@@ -26,13 +26,13 @@ test('computeThreshold with OTSU', () => {
   const testImage = testUtils.load('opencv/test.png');
 
   const grey = testImage.convertColor('GREY');
-  const thresholdValue = computeThreshold(grey, 'otsu');
+  const thresholdValue = computeThreshold(grey, { algorithm: 'otsu' });
   expect(thresholdValue).toBe(127);
 });
 
 test('computeThreshold with OTSU (2)', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  const thresholdValue = computeThreshold(img, 'otsu');
+  const thresholdValue = computeThreshold(img, { algorithm: 'otsu' });
   expect(thresholdValue).toBe(135);
 });
 
@@ -116,3 +116,27 @@ test('16 bits image', () => {
 
   expect(threshold).toMatchImageSnapshot();
 });
+
+test('16 bits image simple with default number of slots 2**16', () => {
+  const image = new Image(2, 2, {
+    colorModel: ImageColorModel.GREY,
+    bitDepth: 16,
+    data: new Uint16Array([0, 100, 20000, 30000]),
+  });
+  const threshold = image.threshold({ slots: 2 ** image.bitDepth });
+  const defaultThreshold = image.threshold();
+
+  expect(threshold).toEqual(defaultThreshold);
+});
+
+test('16 bits image simple with custom number of slots 2**8', () => {
+  const image = new Image(2, 2, {
+    colorModel: ImageColorModel.GREY,
+    bitDepth: 16,
+    data: new Uint16Array([0, 100, 20000, 30000]),
+  });
+  const threshold = image.threshold({ slots: 2 ** 8 });
+  const defaultThreshold = image.threshold();
+
+  expect(threshold).not.toEqual(defaultThreshold);
+});

src/operations/threshold.ts

@@ -40,6 +40,10 @@ export type ThresholdAlgorithm =
   (typeof ThresholdAlgorithm)[keyof typeof ThresholdAlgorithm];
 
 interface ThresholdOptionsBase {
+  /**
+   * Number of slots that histogram can have. Slots must be a power of 2.
+   */
+  slots?: number;
   /**
    * Image to use as the output.
    */
@@ -69,19 +73,20 @@ export type ThresholdOptions =
 /**
  * Compute threshold value for an image using the specified algorithm.
  * @param image - The grey image.
- * @param algorithm - Algorithm that defines the threshold.
+ * @param options - Threshold options.
  * @returns The threshold value for the image.
  */
 export function computeThreshold(
   image: Image,
-  algorithm: ThresholdAlgorithm = 'otsu',
+  options: ThresholdOptionsAlgorithm = {},
 ): number {
+  const { algorithm = 'otsu', slots } = options;
   if (image.channels !== 1) {
     throw new TypeError(
       'threshold can only be computed on images with one channel',
     );
   }
-  const histogram = image.histogram();
+  const histogram = image.histogram({ slots });
 
   switch (algorithm) {
     case 'huang':
@@ -136,7 +141,7 @@ export function threshold(image: Image, options: ThresholdOptions = {}): Mask {
     }
     thresholdValue = threshold * image.maxValue;
   } else {
-    thresholdValue = computeThreshold(image, options.algorithm);
+    thresholdValue = computeThreshold(image, options);
   }
   const result = imageToOutputMask(image, options);
   for (let i = 0; i < image.size; i++) {

src/operations/thresholds/__tests__/thresholdAlgorithms.test.ts

@@ -2,75 +2,75 @@ import { computeThreshold } from '../../threshold';
 
 test('Huang should work similarily to ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'huang')).toBe(132);
+  expect(computeThreshold(img, { algorithm: 'huang' })).toBe(132);
 });
 
 test('Intermodes should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'intermodes')).toBe(166);
+  expect(computeThreshold(img, { algorithm: 'intermodes' })).toBe(166);
 });
 
 test('Isodata should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'isodata')).toBe(135);
+  expect(computeThreshold(img, { algorithm: 'isodata' })).toBe(135);
 });
 
 test('Percentile should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'percentile')).toBe(90);
+  expect(computeThreshold(img, { algorithm: 'percentile' })).toBe(90);
 });
 
 test('Li should work similarily to ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'li')).toBe(117);
+  expect(computeThreshold(img, { algorithm: 'li' })).toBe(117);
 });
 
 test('MaxEntropy should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'maxEntropy')).toBe(126);
+  expect(computeThreshold(img, { algorithm: 'maxEntropy' })).toBe(126);
 });
 
 test('Mean should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'mean')).toBe(106);
+  expect(computeThreshold(img, { algorithm: 'mean' })).toBe(106);
 });
 
 test('MinError should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'minError')).toBe(101);
+  expect(computeThreshold(img, { algorithm: 'minError' })).toBe(101);
 });
 
 test('Minimum should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'minimum')).toBe(234);
+  expect(computeThreshold(img, { algorithm: 'minimum' })).toBe(234);
 });
 
 test('Moments should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'moments')).toBe(127);
+  expect(computeThreshold(img, { algorithm: 'moments' })).toBe(127);
 });
 
 test('Otsu should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'otsu')).toBe(135);
+  expect(computeThreshold(img, { algorithm: 'otsu' })).toBe(135);
 });
 
 test('RenyiEntropy should work similarily to ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'renyiEntropy')).toBe(116);
+  expect(computeThreshold(img, { algorithm: 'renyiEntropy' })).toBe(116);
 });
 
 test('Shanbhag should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'shanbhag')).toBe(116);
+  expect(computeThreshold(img, { algorithm: 'shanbhag' })).toBe(116);
 });
 
 test('Triangle should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'triangle')).toBe(87);
+  expect(computeThreshold(img, { algorithm: 'triangle' })).toBe(87);
 });
 
 test('Yen should work like ImageJ', () => {
   const img = testUtils.load('various/grayscale_by_zimmyrose.png');
-  expect(computeThreshold(img, 'yen')).toBe(108);
+  expect(computeThreshold(img, { algorithm: 'yen' })).toBe(108);
 });

src/roi/__tests__/waterShed.test.ts

@@ -114,7 +114,7 @@ describe('Test WaterShed Roi generation', () => {
       [4, 4, 4, 4, 3, 2, 2, 2, 2, 3],
       [4, 4, 4, 4, 3, 3, 3, 3, 2, 3],
     ]);
-    const threshold = computeThreshold(image, 'otsu');
+    const threshold = computeThreshold(image, { algorithm: 'otsu' });
 
     const roiMapManager = waterShed(image, {
       threshold: threshold / image.maxValue,