fix: first derivative algorithm to detect peaks (#135)

* chore: extract cross zero points checking to unit test

* chore: add failling test case

* fix: check than back and next index is less and greater than zero

* chore: fix eslint

* fix: threshold would be the max between noiseLevel and minMaxRatio

* chore: add documentation to xGetCrossZeroPoints

Author: jobo322

src/__tests__/gaussian.test.ts

@@ -3,8 +3,8 @@ import { generateSpectrum } from 'spectrum-generator';
 import { describe, expect, it } from 'vitest';
 
 import type { GSDPeak } from '../GSDPeak.js';
-import { gsd } from '../gsd.ts';
 import type { GSDPeakID } from '../gsd.ts';
+import { gsd } from '../gsd.ts';
 
 describe('smooth:false option', () => {
   const peaks = [

src/__tests__/xGetCrossZeroPoints.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from 'vitest';
+
+import { xGetCrossZeroPoints } from '../algorithms/xGetCrossZeroPoints.ts';
+
+test('cross with exact zero', () => {
+  const y = [1, 1, 1];
+  const dY = [1e-10, 0, 1e-8];
+
+  const result = xGetCrossZeroPoints({
+    y,
+    dY,
+  });
+
+  expect(result).toHaveLength(0);
+});

src/algorithms/firstDerivative.ts

@@ -1,28 +1,13 @@
 import type { PeakData } from './PeakData.ts';
 import { getMinMaxIntervalsDy } from './getMinMaxIntervals.ts';
 import { getPeakFromIntervals } from './getPeaksFromIntervals.ts';
+import { xGetCrossZeroPoints } from './xGetCrossZeroPoints.ts';
 
 export function firstDerivative(input: PeakData) {
-  const { x, y, yData, dY, ddY, dX, yThreshold } = input;
-
-  const crossDy: number[] = [];
+  const { y, x, dY, dX, yData, yThreshold, ddY } = input;
+  const crossDy = xGetCrossZeroPoints(input);
   const { intervalL, intervalR } = getMinMaxIntervalsDy(y, x, dY, dX);
 
-  for (let i = 1; i < y.length - 1; ++i) {
-    if ((dY[i] < 0 && dY[i + 1] > 0) || (dY[i] > 0 && dY[i + 1] < 0)) {
-      // push the index of the element closer to zero
-      crossDy.push(Math.abs(dY[i]) < Math.abs(dY[i + 1]) ? i : i + 1);
-    }
-    // Handle exact zero
-    if (
-      dY[i] === 0 &&
-      dY[i] < Math.abs(dY[i + 1]) &&
-      dY[i] < Math.abs(dY[i - 1])
-    ) {
-      crossDy.push(i);
-    }
-  }
-
   return getPeakFromIntervals({
     minData: crossDy,
     intervalL,

src/algorithms/xGetCrossZeroPoints.ts

@@ -0,0 +1,35 @@
+import type { PeakData } from './PeakData.ts';
+
+export type XGetCrossZeroPointsInput = Pick<PeakData, 'y' | 'dY'>;
+
+/**
+ * Finds the indices where the first derivative crosses zero (sign change),
+ * which are potential peak positions. This function does not detect zero-crossings
+ * in regions with consecutive zero values in the derivative (flat regions).
+ *
+ * @param input - Object containing the y values and their first derivative (dY).
+ * @returns Array of indices where the first derivative crosses zero (excluding consecutive zeros).
+ */
+export function xGetCrossZeroPoints(input: XGetCrossZeroPointsInput) {
+  const { y, dY } = input;
+
+  const crossDy: number[] = [];
+
+  for (let i = 1; i < y.length - 1; ++i) {
+    if (isLessAndGreaterThanZero(dY[i], dY[i + 1])) {
+      // push the index of the element closer to zero
+      crossDy.push(Math.abs(dY[i]) < Math.abs(dY[i + 1]) ? i : i + 1);
+    } else if (
+      // Handle exact zero
+      dY[i] === 0 &&
+      isLessAndGreaterThanZero(dY[i - 1], dY[i + 1])
+    ) {
+      crossDy.push(i);
+    }
+  }
+  return crossDy;
+}
+
+function isLessAndGreaterThanZero(back: number, next: number) {
+  return (back < 0 && next > 0) || (back > 0 && next < 0);
+}

src/gsd.ts

@@ -145,7 +145,7 @@ export function gsd(data: DataXY, options: GSDOptions = {}): GSDPeakID[] {
     derivative: 2,
   });
 
-  const yThreshold = minY + (maxY - minY) * minMaxRatio;
+  const yThreshold = Math.max(noiseLevel, minY + (maxY - minY) * minMaxRatio);
 
   const dX = x[1] - x[0];
 

src/post/optimizePeaks.ts

@@ -2,8 +2,8 @@ import type { DataXY, FromTo } from 'cheminfo-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
 import type { OptimizationOptions } from 'ml-spectra-fitting';
 
-import { optimizePeaksWithLogs } from './optimizePeaksWithLogs.ts';
 import type { Peak } from './optimizePeaksWithLogs.ts';
+import { optimizePeaksWithLogs } from './optimizePeaksWithLogs.ts';
 
 export interface OptimizePeaksOptions {
   /**

src/utils/groupPeaks.ts

@@ -14,7 +14,7 @@ export function groupPeaks<T extends { x: number; width: number }>(
     factor?: number;
   } = {},
 ): T[][] {
-  if (peaks && peaks.length === 0) return [];
+  if (peaks?.length === 0) return [];
 
   const { factor = 1 } = options;