nmr-processing 3.4.1 → 6.0.1

package/src/xyz/{xyzAutoPeaksPicking.ts → xyzAutoZonesPicking.ts}

@@ -1,14 +1,16 @@
 import { Matrix } from 'ml-matrix';
 import * as convolution from 'ml-matrix-convolution';
 import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
+import type { Peak2D } from 'ml-matrix-peaks-finder';
 import simpleClustering from 'ml-simple-clustering';
 
+import { NMRZone } from '..';
 import { determineRealTop } from '../peaks/util/determineRealTop';
 import { getKernel } from '../peaks/util/getKernel';
 import type { GetKernelOptions } from '../peaks/util/getKernel';
 import * as PeakOptimizer from '../peaks/util/peakOptimizer';
-import type { MPFPeak } from '../types/MPFPeak';
-import type { NMRSignal2D } from '../types/NMRSignal2D';
+
+import type { NMRSignal2D } from './NMRSignal2D';
 
 const smallFilter = [
   [0, 0, 1, 2, 2, 2, 1, 0, 0],
@@ -30,7 +32,7 @@ export interface Data2D {
   maxY: number;
 }
 
-export interface XYZAutoPeaksPickingOptions {
+export interface XYZAutoZonesPickingOptions {
   /**
    * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
    * @default 14
@@ -86,9 +88,9 @@ export interface XYZAutoPeaksPickingOptions {
   kernel?: GetKernelOptions;
 }
 
-export function xyzAutoPeaksPicking(
+export function xyzAutoZonesPicking(
   spectraData: Data2D,
-  options: XYZAutoPeaksPickingOptions,
+  options: XYZAutoZonesPickingOptions,
 ) {
   let {
     sizeToPad = 14,
@@ -178,7 +180,41 @@ export function xyzAutoPeaksPicking(
     signals = PeakOptimizer.enhanceSymmetry(signals);
   }
 
-  return signals;
+  return formatZones(signals);
+}
+
+function formatZones(signals: NMRSignal2D[]) {
+  let zones: NMRZone[] = [];
+  for (const signal of signals) {
+    let minMax1 = [Number.MAX_VALUE, 0];
+    let minMax2 = [Number.MAX_VALUE, 0];
+    for (const peak of signal.peaks || []) {
+      if (peak.minX < minMax1[0]) {
+        minMax1[0] = peak.minX;
+      }
+      if (peak.maxX > minMax1[1]) {
+        minMax1[1] = peak.maxX;
+      }
+      if (peak.minY < minMax2[0]) {
+        minMax2[0] = peak.minY;
+      }
+      if (peak.maxY > minMax2[1]) {
+        minMax2[1] = peak.maxY;
+      }
+    }
+    zones.push({
+      x: {
+        from: minMax1[0],
+        to: minMax1[1],
+      },
+      y: {
+        from: minMax2[0],
+        to: minMax2[1],
+      },
+      signals: [signal],
+    });
+  }
+  return zones;
 }
 
 /**
@@ -201,7 +237,7 @@ export interface CreateSignals2DOptions {
   minX: number;
   maxX: number;
 }
-const createSignals2D = (peaks: MPFPeak[], options: CreateSignals2DOptions) => {
+const createSignals2D = (peaks: Peak2D[], options: CreateSignals2DOptions) => {
   let {
     nCols,
     nRows,
@@ -246,9 +282,6 @@ const createSignals2D = (peaks: MPFPeak[], options: CreateSignals2DOptions) => {
     peaks[i].maxY = minY + dy * peaks[i].maxY;
 
     // Still having problems to correctly detect peaks on those areas. So I'm removing everything there.
-    if (peaks[i].y < -1 || peaks[i].y >= 210) {
-      peaks.splice(i, 1);
-    }
   }
   // The connectivity matrix is an square and symmetric matrix, so we'll only store the upper diagonal in an
   // array like form
@@ -283,9 +316,7 @@ const createSignals2D = (peaks: MPFPeak[], options: CreateSignals2DOptions) => {
           resolution: dy,
         },
       };
-      let peaks2D = [];
-      let minMax1 = [Number.MAX_VALUE, 0];
-      let minMax2 = [Number.MAX_VALUE, 0];
+      let peaks2D: Peak2D[] = [];
       let sumZ = 0;
 
       for (let jPeak = 0; jPeak < cluster.length; jPeak++) {
@@ -294,23 +325,9 @@ const createSignals2D = (peaks: MPFPeak[], options: CreateSignals2DOptions) => {
           signal.x.delta += peaks[jPeak].x * peaks[jPeak].z;
           signal.y.delta += peaks[jPeak].y * peaks[jPeak].z;
           sumZ += peaks[jPeak].z;
-          if (peaks[jPeak].minX < minMax1[0]) {
-            minMax1[0] = peaks[jPeak].minX;
-          }
-          if (peaks[jPeak].maxX > minMax1[1]) {
-            minMax1[1] = peaks[jPeak].maxX;
-          }
-          if (peaks[jPeak].minY < minMax2[0]) {
-            minMax2[0] = peaks[jPeak].minY;
-          }
-          if (peaks[jPeak].maxY > minMax2[1]) {
-            minMax2[1] = peaks[jPeak].maxY;
-          }
         }
       }
 
-      signal.x.fromTo = { from: minMax1[0], to: minMax1[1] };
-      signal.y.fromTo = { from: minMax2[0], to: minMax2[1] };
       signal.x.delta /= sumZ;
       signal.y.delta /= sumZ;
       signal.peaks = peaks2D;

package/src/xyz/xyzJResAnalyzer.ts

@@ -1,10 +1,11 @@
+import type { Peak2D } from 'ml-matrix-peaks-finder';
 import simpleClustering from 'ml-simple-clustering';
 
 import type { JAxisKeys } from '../peaks/util/jAnalyzer';
 import jAnalyzer from '../peaks/util/jAnalyzer';
-import type { MPFPeak } from '../types/MPFPeak';
-import type { MakeMandatory } from '../types/MakeMandatory';
-import type { NMRSignal2D } from '../types/NMRSignal2D';
+import type { MakeMandatory } from '../utilities/MakeMandatory';
+
+import type { NMRSignal2D } from './NMRSignal2D';
 
 interface CompilePatternOptions {
   observedFrequencies?: number[] | Float64Array;
@@ -96,7 +97,7 @@ function compilePattern(
     for (const peak of peaks) {
       if (!peak.width) peak.width = 0.02;
     }
-    peaks.sort((a: MPFPeak, b: MPFPeak) => a.y - b.y);
+    peaks.sort((a: Peak2D, b: Peak2D) => a.y - b.y);
   }
 
   for (let i = 0; i < signals.length; i++) {
@@ -137,7 +138,7 @@ function compilePattern(
   return signals;
 }
 
-interface Peak2DHack extends MPFPeak {
+interface Peak2DHack extends Peak2D {
   width?: number;
 }
 type Signal2DHack = Omit<NMRSignal2D, 'peaks'> & {
@@ -149,7 +150,7 @@ type Signal2DHack = Omit<NMRSignal2D, 'peaks'> & {
   observe: number;
 };
 
-function createSignals2D(peaksInput: MPFPeak[], options: any) {
+function createSignals2D(peaksInput: Peak2D[], options: any) {
   let { observedFrequencies, tolerances, nuclei, dx, dy } = options;
 
   const peaks: Peak2DHack[] = JSON.parse(JSON.stringify(peaksInput));