From 3e7d8ccf8f20354a3f0b2f379769c907c8222a9f Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 10 Nov 2026 23:10:35 -0500 Subject: [PATCH 1/8] fix(ranges): detect range signals against the spectrum baseline --- .../ranges/__tests__/detectSignal.test.ts | 134 ++++++++++++++++ .../__tests__/detectSignalsFallback.test.ts | 84 ++++++++++ .../data1d/Spectrum1D/ranges/detectSignals.ts | 143 ++++++++++++++---- .../detectSignalsByMultipletAnalysis.ts | 8 +- 4 files changed, 335 insertions(+), 34 deletions(-) create mode 100644 src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts index 4c2d15219a..c933f8d6bd 100644 --- a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts @@ -1,3 +1,4 @@ +import type { DataXY } from 'cheminfo-types'; import { rangesToXY } from 'nmr-processing'; import { describe, expect, it } from 'vitest'; @@ -33,3 +34,136 @@ describe('lineBroadening', () => { expect(result?.js[0].coupling).toBeCloseTo(7.2, 2); }); }); + +const FREQUENCY = 400; +const FROM = -0.5; +const TO = 10.5; +const NB_POINTS = 64 * 1024; +const NOISE = 1; + +interface Peak { + x: number; + /** + * Peak height. + */ + y: number; + /** + * Full width at half maximum, in ppm. + */ + width: number; +} + +/** + * Full width at half maximum to gaussian sigma. + */ +const FWHM_TO_SIGMA = 2 * Math.sqrt(2 * Math.LN2); + +/** + * Synthetic spectrum with a deterministic noise floor, so that the fixtures + * have a baseline like real data does (`median(|y|) > 0`). + */ +function buildSpectrum(peaks: Peak[]): DataXY { + const dx = (TO - FROM) / (NB_POINTS - 1); + const x = new Float64Array(NB_POINTS); + const y = new Float64Array(NB_POINTS); + for (let i = 0; i < NB_POINTS; i++) { + x[i] = FROM + i * dx; + } + for (const peak of peaks) { + const sigma = peak.width / FWHM_TO_SIGMA; + for (let i = 0; i < NB_POINTS; i++) { + const z = (x[i] - peak.x) / sigma; + y[i] += peak.y * Math.exp(-0.5 * z * z); + } + } + + let seed = 123_456_789; + for (let i = 0; i < NB_POINTS; i++) { + seed = (seed * 1_103_515_245 + 12_345) % 2_147_483_648; + y[i] += ((seed / 2_147_483_648) * 2 - 1) * NOISE; + } + + return { x, y }; +} + +function getSignals(spectrum: DataXY, from: number, to: number) { + return detectSignals(spectrum, { + from, + to, + frequency: FREQUENCY, + nucleus: '1H', + }) as Array<{ delta: number; multiplicity?: string; peaks?: unknown[] }>; +} + +describe('signal detection inside a range (issue #4435)', () => { + it('detects a signal in a narrow range', () => { + const spectrum = buildSpectrum([ + { x: 8.265, y: 1000, width: 0.002 }, + { x: 3.32, y: 200, width: 0.003 }, + ]); + const signals = getSignals(spectrum, 8.2625, 8.2675); + expect(signals.length).toBeGreaterThanOrEqual(1); + expect(signals[0].delta).toBeCloseTo(8.265, 2); + }); + + it('detects weak lines when they are the tallest point of their own range', () => { + const spectrum = buildSpectrum([ + { x: 7.968, y: 50, width: 0.002 }, + { x: 7.972, y: 50, width: 0.002 }, + ]); + const signals = getSignals(spectrum, 7.964, 7.975); + expect(signals.length).toBeGreaterThanOrEqual(1); + }); + + it('detects the signals when the strongest point of the range is at its edge', () => { + const spectrum = buildSpectrum([ + { x: 7.9595, y: 1000, width: 0.003 }, + { x: 7.968, y: 50, width: 0.002 }, + { x: 7.972, y: 50, width: 0.002 }, + ]); + const signals = getSignals(spectrum, 7.962, 7.975); + expect(signals.length).toBeGreaterThanOrEqual(1); + }); + + it.each([0.0005, 0.001, 0.002, 0.003, 0.005, 0.008, 0.01, 0.02])( + 'never leaves a range without signals when it contains a peak (width %f ppm)', + (width) => { + const spectrum = buildSpectrum([{ x: 8.265, y: 1000, width: 0.002 }]); + const signals = getSignals( + spectrum, + 8.265 - width / 2, + 8.265 + width / 2, + ); + expect(signals.length).toBeGreaterThanOrEqual(1); + }, + ); + + it('keeps the multiplet analysis of a well resolved range', () => { + const spectrum = buildSpectrum([ + { x: 8.256, y: 1000, width: 0.0015 }, + { x: 8.262, y: 2000, width: 0.0015 }, + { x: 8.268, y: 1000, width: 0.0015 }, + ]); + const signals = getSignals(spectrum, 8.25, 8.27); + expect(signals).toHaveLength(1); + expect(signals[0].multiplicity).toBe('t'); + expect(signals[0].delta).toBeCloseTo(8.262, 2); + }); + + it('keeps a signal when the range only contains the flank of a broad peak', () => { + // No local maximum inside the range: the detection must still report + // something (peak picking, multiplet analysis or the fallback). + const spectrum = buildSpectrum([{ x: 7.962, y: 1000, width: 0.02 }]); + const signals = getSignals(spectrum, 7.964, 7.978); + expect(signals.length).toBeGreaterThanOrEqual(1); + }); + + it('returns no signal for a range that only contains noise', () => { + const spectrum = buildSpectrum([ + { x: 8.265, y: 1000, width: 0.002 }, + { x: 3.32, y: 200, width: 0.003 }, + ]); + const signals = getSignals(spectrum, 5.1, 5.12); + expect(signals).toHaveLength(0); + }); +}); diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts new file mode 100644 index 0000000000..b0ed97c2cb --- /dev/null +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts @@ -0,0 +1,84 @@ +import type { DataXY, Logger } from 'cheminfo-types'; +import { describe, expect, it, vi } from 'vitest'; + +import detectSignals from '../detectSignals.js'; + +// The multiplet analysis is forced to return nothing so that the fallback of +// `detectSignals` is exercised on its own, without depending on the ability of +// the peak picking to find a local maximum in the range. +vi.mock('../detectSignalsByMultipletAnalysis.js', () => ({ + detectSignalsByMultipletAnalysis: vi.fn(() => []), +})); + +const FREQUENCY = 400; +const FROM = -0.5; +const TO = 10.5; +const NB_POINTS = 64 * 1024; +const NOISE = 1; +const FWHM_TO_SIGMA = 2 * Math.sqrt(2 * Math.LN2); + +function buildSpectrum(peaks: Array<{ x: number; y: number; width: number }>) { + const dx = (TO - FROM) / (NB_POINTS - 1); + const x = new Float64Array(NB_POINTS); + const y = new Float64Array(NB_POINTS); + for (let i = 0; i < NB_POINTS; i++) { + x[i] = FROM + i * dx; + } + for (const peak of peaks) { + const sigma = peak.width / FWHM_TO_SIGMA; + for (let i = 0; i < NB_POINTS; i++) { + const z = (x[i] - peak.x) / sigma; + y[i] += peak.y * Math.exp(-0.5 * z * z); + } + } + + let seed = 123_456_789; + for (let i = 0; i < NB_POINTS; i++) { + seed = (seed * 1_103_515_245 + 12_345) % 2_147_483_648; + y[i] += ((seed / 2_147_483_648) * 2 - 1) * NOISE; + } + + return { x, y } as DataXY; +} + +describe('detectSignals fallback', () => { + it('reports the point of maximum intensity when nothing can be detected', () => { + const spectrum = buildSpectrum([{ x: 8.265, y: 1000, width: 0.002 }]); + const warn = vi.fn(); + const signals = detectSignals(spectrum, { + from: 8.26, + to: 8.27, + frequency: FREQUENCY, + nucleus: '1H', + logger: { warn } as unknown as Logger, + }) as Array<{ + delta: number; + multiplicity?: string; + kind?: string; + peaks?: unknown[]; + }>; + + expect(signals).toHaveLength(1); + expect(signals[0].delta).toBeCloseTo(8.265, 2); + expect(signals[0].multiplicity).toBe(''); + expect(signals[0].kind).toBe('signal'); + expect(signals[0].peaks).toHaveLength(0); + // the user is informed that the multiplicity could not be determined + expect(warn).toHaveBeenCalledOnce(); + }); + + it('stays empty when the range only contains noise', () => { + const spectrum = buildSpectrum([{ x: 8.265, y: 1000, width: 0.002 }]); + const warn = vi.fn(); + const signals = detectSignals(spectrum, { + from: 5.1, + to: 5.12, + frequency: FREQUENCY, + nucleus: '1H', + logger: { warn } as unknown as Logger, + }); + + expect(signals).toHaveLength(0); + expect(warn).not.toHaveBeenCalled(); + }); +}); diff --git a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts index f4bf987e3c..308e37440a 100644 --- a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts +++ b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts @@ -1,11 +1,33 @@ import type { DataXY, Logger } from 'cheminfo-types'; -import { xGetFromToIndex } from 'ml-spectra-processing'; +import median from 'ml-array-median'; +import { xGetFromToIndex, xyMaxYPoint } from 'ml-spectra-processing'; import { xyAutoRangesPicking } from 'nmr-processing'; import { detectSignalsByMultipletAnalysis } from './detectSignalsByMultipletAnalysis.js'; const MAX_LENGTH = 4092; +/** + * Factor applied to the baseline noise of the whole spectrum to build the + * peak picking threshold used inside a range. + * + * The threshold must not be derived from the range itself: in a narrow range + * most of the points belong to the peaks, so a "noise" estimated from them is + * close to (or bigger than) the peak height and nothing is detected. + */ +const RANGE_PEAK_NOISE_FACTOR = 8; + +/** + * Baseline noise of the spectrum: absolute median of the intensity, as in + * `autoPeakPicking`. It is robust to the presence of intense peaks and it does + * not depend on the range being analysed. + */ +export function getBaselineNoise(y: Float64Array) { + return ( + median(Array.from(y, (value) => Math.abs(value))) * RANGE_PEAK_NOISE_FACTOR + ); +} + interface DetectSignalsOptions { from: number; to: number; @@ -21,40 +43,95 @@ export default function detectSignals( const { from, to, frequency, nucleus, logger } = options; const { fromIndex, toIndex } = xGetFromToIndex(data.x, { from, to }); + const noiseLevel = getBaselineNoise(data.y); const size = toIndex - fromIndex; - if (size <= 16 || size >= MAX_LENGTH) { - const frequencyCluster = (to - from) * frequency; - const ranges = xyAutoRangesPicking(data, { - logger, - peakPicking: { - sgOptions: { - windowSize: 7, - polynomial: 3, - }, - to, - from, - frequency, - broadRatio: 0.0025, - smoothY: true, + + const signals = + size <= 16 || size >= MAX_LENGTH + ? detectSignalsByAutoRangesPicking(data, { + from, + to, + frequency, + nucleus, + noiseLevel, + logger, + }) + : detectSignalsByMultipletAnalysis(data, { + fromIndex, + toIndex, + frequency, + noiseLevel, + }); + + if (signals.length > 0) { + return signals; + } + + // The range may be too narrow (or its signals too weak) for the multiplet + // analysis. When there is something above the baseline inside it, the point + // of maximum intensity is reported as a signal of unknown multiplicity, so + // that the range is never left without a signal. A range that only contains + // noise stays empty. + const maxPoint = xyMaxYPoint(data, { fromIndex, toIndex }); + if (maxPoint.y > noiseLevel) { + logger?.warn( + 'No signal could be detected inside the range: it may be too narrow or its signals too weak for the multiplet analysis. The point of maximum intensity is used as signal.', + ); + return [ + { + delta: maxPoint.x, + multiplicity: '', + kind: 'signal' as const, + js: [], + diaIDs: [], + peaks: [], }, - ranges: { - symRatio: 2.5, - frequency, - nucleus, - compile: true, - frequencyCluster, - keepPeaks: true, - clean: 0.5, + ]; + } + + return signals; +} + +interface DetectSignalsByAutoRangesPickingOptions { + from: number; + to: number; + frequency: number; + nucleus: string; + noiseLevel: number; + logger?: Logger; +} + +function detectSignalsByAutoRangesPicking( + data: DataXY, + options: DetectSignalsByAutoRangesPickingOptions, +) { + const { from, to, frequency, nucleus, noiseLevel, logger } = options; + const frequencyCluster = (to - from) * frequency; + const ranges = xyAutoRangesPicking(data, { + logger, + peakPicking: { + sgOptions: { + windowSize: 7, + polynomial: 3, }, - }); - return ranges - .flatMap((r) => r.signals || []) - .map((s) => ({ multiplicity: '', js: [], ...s })); - } else { - return detectSignalsByMultipletAnalysis(data, { - fromIndex, - toIndex, + to, + from, frequency, - }); - } + noiseLevel, + broadRatio: 0.0025, + smoothY: true, + }, + ranges: { + symRatio: 2.5, + frequency, + nucleus, + compile: true, + frequencyCluster, + keepPeaks: true, + clean: 0.5, + }, + }); + return ranges + .flatMap((r) => r.signals || []) + .map((s) => ({ multiplicity: '', js: [], ...s })); } diff --git a/src/data/data1d/Spectrum1D/ranges/detectSignalsByMultipletAnalysis.ts b/src/data/data1d/Spectrum1D/ranges/detectSignalsByMultipletAnalysis.ts index 64c8e9f2b6..dba94eefd5 100644 --- a/src/data/data1d/Spectrum1D/ranges/detectSignalsByMultipletAnalysis.ts +++ b/src/data/data1d/Spectrum1D/ranges/detectSignalsByMultipletAnalysis.ts @@ -15,13 +15,18 @@ interface DetectSignalsByMultipletAnalysisOptions { fromIndex: number; toIndex: number; frequency: number; + /** + * Baseline noise of the whole spectrum. It replaces the cutoff that + * `xyAutoPeaksPicking` would otherwise derive from the analysed range. + */ + noiseLevel?: number; } export function detectSignalsByMultipletAnalysis( data: DataXY, options: DetectSignalsByMultipletAnalysisOptions, ) { - const { fromIndex, toIndex, frequency } = options; + const { fromIndex, toIndex, frequency, noiseLevel } = options; const dataRoi = { x: data.x.slice(fromIndex, toIndex), y: data.y.slice(fromIndex, toIndex), @@ -34,6 +39,7 @@ export function detectSignalsByMultipletAnalysis( from, to, frequency, + noiseLevel, minMaxRatio: 0.1, maxAbsoluteRatio: 0.1, broadWidth: 0.25, From 7b65cabe2deb681ffe4937b3e2746410e24f5564 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Wed, 11 Nov 2026 11:59:51 -0500 Subject: [PATCH 2/8] fix(ranges): remove the unused export reported by knip --- src/data/data1d/Spectrum1D/ranges/detectSignals.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts index 308e37440a..826f6dacc2 100644 --- a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts +++ b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts @@ -22,7 +22,7 @@ const RANGE_PEAK_NOISE_FACTOR = 8; * `autoPeakPicking`. It is robust to the presence of intense peaks and it does * not depend on the range being analysed. */ -export function getBaselineNoise(y: Float64Array) { +function getBaselineNoise(y: Float64Array) { return ( median(Array.from(y, (value) => Math.abs(value))) * RANGE_PEAK_NOISE_FACTOR ); From 224c16f2a79455dd4bbf76264b7a0d9c55040e24 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 17 Nov 2026 17:38:51 -0500 Subject: [PATCH 3/8] chore: uses spectrum-generator in test cases --- .../ranges/__tests__/detectSignal.test.ts | 54 ++++--------------- .../__tests__/detectSignalsFallback.test.ts | 34 ++++-------- 2 files changed, 18 insertions(+), 70 deletions(-) diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts index c933f8d6bd..97d60cde8f 100644 --- a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts @@ -1,5 +1,6 @@ import type { DataXY } from 'cheminfo-types'; import { rangesToXY } from 'nmr-processing'; +import { generateSpectrum } from 'spectrum-generator'; import { describe, expect, it } from 'vitest'; import detectSignals from '../detectSignals.js'; @@ -39,51 +40,14 @@ const FREQUENCY = 400; const FROM = -0.5; const TO = 10.5; const NB_POINTS = 64 * 1024; -const NOISE = 1; - -interface Peak { - x: number; - /** - * Peak height. - */ - y: number; - /** - * Full width at half maximum, in ppm. - */ - width: number; -} - -/** - * Full width at half maximum to gaussian sigma. - */ -const FWHM_TO_SIGMA = 2 * Math.sqrt(2 * Math.LN2); - -/** - * Synthetic spectrum with a deterministic noise floor, so that the fixtures - * have a baseline like real data does (`median(|y|) > 0`). - */ -function buildSpectrum(peaks: Peak[]): DataXY { - const dx = (TO - FROM) / (NB_POINTS - 1); - const x = new Float64Array(NB_POINTS); - const y = new Float64Array(NB_POINTS); - for (let i = 0; i < NB_POINTS; i++) { - x[i] = FROM + i * dx; - } - for (const peak of peaks) { - const sigma = peak.width / FWHM_TO_SIGMA; - for (let i = 0; i < NB_POINTS; i++) { - const z = (x[i] - peak.x) / sigma; - y[i] += peak.y * Math.exp(-0.5 * z * z); - } - } - - let seed = 123_456_789; - for (let i = 0; i < NB_POINTS; i++) { - seed = (seed * 1_103_515_245 + 12_345) % 2_147_483_648; - y[i] += ((seed / 2_147_483_648) * 2 - 1) * NOISE; - } - - return { x, y }; +function buildSpectrum(peaks: Array<{ x: number; y: number; width: number }>) { + return generateSpectrum( + peaks.map(({ x, y, width }) => [x, y, width] as [number, number, number]), + { + generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, + noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, + }, + ); } function getSignals(spectrum: DataXY, from: number, to: number) { diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts index b0ed97c2cb..de1c2f8402 100644 --- a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts @@ -1,4 +1,5 @@ -import type { DataXY, Logger } from 'cheminfo-types'; +import type { Logger } from 'cheminfo-types'; +import { generateSpectrum } from 'spectrum-generator'; import { describe, expect, it, vi } from 'vitest'; import detectSignals from '../detectSignals.js'; @@ -14,31 +15,14 @@ const FREQUENCY = 400; const FROM = -0.5; const TO = 10.5; const NB_POINTS = 64 * 1024; -const NOISE = 1; -const FWHM_TO_SIGMA = 2 * Math.sqrt(2 * Math.LN2); - function buildSpectrum(peaks: Array<{ x: number; y: number; width: number }>) { - const dx = (TO - FROM) / (NB_POINTS - 1); - const x = new Float64Array(NB_POINTS); - const y = new Float64Array(NB_POINTS); - for (let i = 0; i < NB_POINTS; i++) { - x[i] = FROM + i * dx; - } - for (const peak of peaks) { - const sigma = peak.width / FWHM_TO_SIGMA; - for (let i = 0; i < NB_POINTS; i++) { - const z = (x[i] - peak.x) / sigma; - y[i] += peak.y * Math.exp(-0.5 * z * z); - } - } - - let seed = 123_456_789; - for (let i = 0; i < NB_POINTS; i++) { - seed = (seed * 1_103_515_245 + 12_345) % 2_147_483_648; - y[i] += ((seed / 2_147_483_648) * 2 - 1) * NOISE; - } - - return { x, y } as DataXY; + return generateSpectrum( + peaks.map(({ x, y, width }) => [x, y, width] as [number, number, number]), + { + generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, + noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, + }, + ); } describe('detectSignals fallback', () => { From f05fc1ecb274192ef15dcb1de14449b96cc25aa1 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 17 Nov 2026 17:49:58 -0500 Subject: [PATCH 4/8] chore: use xAbsoluteMedian --- src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts b/src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts index 05bc64342f..7488541598 100644 --- a/src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts +++ b/src/data/data1d/Spectrum1D/peaks/autoPeakPicking.ts @@ -1,6 +1,6 @@ import type { Peak1D } from '@zakodium/nmr-types'; import type { Spectrum1D } from '@zakodium/nmrium-core'; -import median from 'ml-array-median'; +import { xAbsoluteMedian } from 'ml-spectra-processing'; import type { OptionsXYAutoPeaksPicking } from 'nmr-processing'; import { mapPeaks, xyAutoPeaksPicking } from 'nmr-processing'; @@ -30,7 +30,7 @@ export function autoPeakPicking( defaultPeakShape = DEFAULT_PEAK_SHAPE, } = options; // we calculate the noise but this could be improved - const noise = median(spectrum.data.re.map((y) => Math.abs(y))); + const noise = xAbsoluteMedian(spectrum.data.re); let { re, x } = spectrum.data; const { originFrequency: frequency } = spectrum.info; From 2790081a3e081ee28b6cffb6ed46eb775c825697 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 17 Nov 2026 17:50:30 -0500 Subject: [PATCH 5/8] chore: uses xAbsoluteMedian to calculate noiseLevel --- .../data1d/Spectrum1D/ranges/detectSignals.ts | 20 ++++++------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts index 826f6dacc2..200218b441 100644 --- a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts +++ b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts @@ -1,6 +1,9 @@ import type { DataXY, Logger } from 'cheminfo-types'; -import median from 'ml-array-median'; -import { xGetFromToIndex, xyMaxYPoint } from 'ml-spectra-processing'; +import { + xAbsoluteMedian, + xGetFromToIndex, + xyMaxYPoint, +} from 'ml-spectra-processing'; import { xyAutoRangesPicking } from 'nmr-processing'; import { detectSignalsByMultipletAnalysis } from './detectSignalsByMultipletAnalysis.js'; @@ -17,17 +20,6 @@ const MAX_LENGTH = 4092; */ const RANGE_PEAK_NOISE_FACTOR = 8; -/** - * Baseline noise of the spectrum: absolute median of the intensity, as in - * `autoPeakPicking`. It is robust to the presence of intense peaks and it does - * not depend on the range being analysed. - */ -function getBaselineNoise(y: Float64Array) { - return ( - median(Array.from(y, (value) => Math.abs(value))) * RANGE_PEAK_NOISE_FACTOR - ); -} - interface DetectSignalsOptions { from: number; to: number; @@ -43,7 +35,7 @@ export default function detectSignals( const { from, to, frequency, nucleus, logger } = options; const { fromIndex, toIndex } = xGetFromToIndex(data.x, { from, to }); - const noiseLevel = getBaselineNoise(data.y); + const noiseLevel = xAbsoluteMedian(data.y) * RANGE_PEAK_NOISE_FACTOR; const size = toIndex - fromIndex; const signals = From b002c8b76847ff2e839cd65dba843aae75359f40 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 17 Nov 2026 17:51:12 -0500 Subject: [PATCH 6/8] chore: add dev-dep spectrum-generator --- package-lock.json | 1 + package.json | 1 + 2 files changed, 2 insertions(+) diff --git a/package-lock.json b/package-lock.json index 9937576844..5543f38bef 100644 --- a/package-lock.json +++ b/package-lock.json @@ -105,6 +105,7 @@ "react-router-dom": "^7.18.4", "rimraf": "^6.1.3", "serve": "^14.2.6", + "spectrum-generator": "^8.2.1", "stylelint": "^17.16.0", "stylelint-config-standard": "^40.0.0", "typescript": "~6.0.3", diff --git a/package.json b/package.json index a58b3ac905..2232cdd7d1 100644 --- a/package.json +++ b/package.json @@ -156,6 +156,7 @@ "react-router-dom": "^7.18.4", "rimraf": "^6.1.3", "serve": "^14.2.6", + "spectrum-generator": "^8.2.1", "stylelint": "^17.16.0", "stylelint-config-standard": "^40.0.0", "typescript": "~6.0.3", From 5cb57148bbced97b92e61b48f93d44f851dcb3d9 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Tue, 17 Nov 2026 22:33:11 -0500 Subject: [PATCH 7/8] fix: replace hardcoded threshold factor with RANGE_PEAK_NOISE_FACTOR constant --- src/component/reducer/actions/RangesActions.ts | 5 +++-- .../Spectrum1D/ranges/__tests__/detectSignal.test.ts | 11 ++++------- .../ranges/__tests__/detectSignalsFallback.test.ts | 11 ++++------- src/data/data1d/Spectrum1D/ranges/constants.ts | 4 ++++ src/data/data1d/Spectrum1D/ranges/detectSignals.ts | 11 +---------- 5 files changed, 16 insertions(+), 26 deletions(-) create mode 100644 src/data/data1d/Spectrum1D/ranges/constants.ts diff --git a/src/component/reducer/actions/RangesActions.ts b/src/component/reducer/actions/RangesActions.ts index 6025156cde..c7b118ac04 100644 --- a/src/component/reducer/actions/RangesActions.ts +++ b/src/component/reducer/actions/RangesActions.ts @@ -24,6 +24,7 @@ import { updateRangesRelativeValues, } from '../../../data/data1d/Spectrum1D/index.js'; import type { ChangeRangeRelativeValueProps } from '../../../data/data1d/Spectrum1D/ranges/changeRangeRelativeValue.js'; +import { RANGE_PEAK_NOISE_FACTOR } from '../../../data/data1d/Spectrum1D/ranges/constants.js'; import type { DetectRangesOptions } from '../../../data/data1d/Spectrum1D/ranges/detectRanges.js'; import { unlink } from '../../../data/utilities/RangeUtilities.js'; import { isProton } from '../../../data/utilities/isProton.js'; @@ -252,7 +253,7 @@ function handleAutoRangesDetection( smoothY: false, sensitivity: 100, broadWidth: 0.05, - thresholdFactor: 8, + thresholdFactor: RANGE_PEAK_NOISE_FACTOR, minMaxRatio, maxAbsoluteRatio: minMaxRatio, direction: lookNegative ? 'both' : 'positive', @@ -273,7 +274,7 @@ function handleAutoRangesDetection( function handleAutoSpectraRangesDetection(draft: Draft) { const peakPicking: DetectRangesOptions['peakPicking'] = { sensitivity: 100, - thresholdFactor: 8, + thresholdFactor: RANGE_PEAK_NOISE_FACTOR, minMaxRatio: 0.05, }; const { data, molecules } = draft; diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts index 97d60cde8f..e19ff75106 100644 --- a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignal.test.ts @@ -41,13 +41,10 @@ const FROM = -0.5; const TO = 10.5; const NB_POINTS = 64 * 1024; function buildSpectrum(peaks: Array<{ x: number; y: number; width: number }>) { - return generateSpectrum( - peaks.map(({ x, y, width }) => [x, y, width] as [number, number, number]), - { - generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, - noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, - }, - ); + return generateSpectrum(peaks, { + generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, + noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, + }); } function getSignals(spectrum: DataXY, from: number, to: number) { diff --git a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts index de1c2f8402..2673cacff7 100644 --- a/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts +++ b/src/data/data1d/Spectrum1D/ranges/__tests__/detectSignalsFallback.test.ts @@ -16,13 +16,10 @@ const FROM = -0.5; const TO = 10.5; const NB_POINTS = 64 * 1024; function buildSpectrum(peaks: Array<{ x: number; y: number; width: number }>) { - return generateSpectrum( - peaks.map(({ x, y, width }) => [x, y, width] as [number, number, number]), - { - generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, - noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, - }, - ); + return generateSpectrum(peaks, { + generator: { from: FROM, to: TO, nbPoints: NB_POINTS }, + noise: { distribution: 'uniform', percent: 0.2, seed: 123_456_789 }, + }); } describe('detectSignals fallback', () => { diff --git a/src/data/data1d/Spectrum1D/ranges/constants.ts b/src/data/data1d/Spectrum1D/ranges/constants.ts new file mode 100644 index 0000000000..0d278df035 --- /dev/null +++ b/src/data/data1d/Spectrum1D/ranges/constants.ts @@ -0,0 +1,4 @@ +/** + * Shared noise threshold factor for range signal and range peak picking. + */ +export const RANGE_PEAK_NOISE_FACTOR = 8; diff --git a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts index 200218b441..40e8e6f141 100644 --- a/src/data/data1d/Spectrum1D/ranges/detectSignals.ts +++ b/src/data/data1d/Spectrum1D/ranges/detectSignals.ts @@ -6,20 +6,11 @@ import { } from 'ml-spectra-processing'; import { xyAutoRangesPicking } from 'nmr-processing'; +import { RANGE_PEAK_NOISE_FACTOR } from './constants.js'; import { detectSignalsByMultipletAnalysis } from './detectSignalsByMultipletAnalysis.js'; const MAX_LENGTH = 4092; -/** - * Factor applied to the baseline noise of the whole spectrum to build the - * peak picking threshold used inside a range. - * - * The threshold must not be derived from the range itself: in a narrow range - * most of the points belong to the peaks, so a "noise" estimated from them is - * close to (or bigger than) the peak height and nothing is detected. - */ -const RANGE_PEAK_NOISE_FACTOR = 8; - interface DetectSignalsOptions { from: number; to: number; From b9d27fbea4bc879408c5be68ec729d55373d5169 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Wed, 18 Nov 2026 00:04:08 -0500 Subject: [PATCH 8/8] chore: remove useless dep --- package-lock.json | 2 +- package.json | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/package-lock.json b/package-lock.json index 8f90f1159a..1cebe9fd96 100644 --- a/package-lock.json +++ b/package-lock.json @@ -39,7 +39,6 @@ "lodash": "^4.18.1", "mf-parser": "^3.9.3", "ml-array-mean": "^2.0.0", - "ml-array-median": "^2.0.0", "ml-conrec": "^6.0.0", "ml-gsd": "^14.3.0", "ml-peak-shape-generator": "^5.6.0", @@ -105,6 +104,7 @@ "react-router-dom": "^7.18.5", "rimraf": "^6.1.4", "serve": "^14.2.7", + "spectrum-generator": "^8.2.1", "stylelint": "^18.0.0", "stylelint-config-standard": "^41.0.0", "typescript": "~6.0.3", diff --git a/package.json b/package.json index 43e227387c..9a24ba2460 100644 --- a/package.json +++ b/package.json @@ -90,7 +90,6 @@ "lodash": "^4.18.1", "mf-parser": "^3.9.3", "ml-array-mean": "^2.0.0", - "ml-array-median": "^2.0.0", "ml-conrec": "^6.0.0", "ml-gsd": "^14.3.0", "ml-peak-shape-generator": "^5.6.0",