nmr-processing 5.0.0 → 6.0.3

package/src/signals/signalsToXY.ts

@@ -2,10 +2,10 @@ import rescale from 'ml-array-rescale';
 import arraySequentialFill from 'ml-array-sequential-fill';
 import type { Shape1D } from 'ml-peak-shape-generator';
 
-import type { MakeMandatory } from '../types/MakeMandatory';
-import type { NMRSignal1D } from '../types/NMRSignal1D';
-import type { Jcoupling } from '../types/jcoupling';
+import type { MakeMandatory } from '../utilities/MakeMandatory';
 
+import type { NMRSignal1D } from './NMRSignal1D';
+import type { Jcoupling } from './jcoupling';
 import { signalsToSpinSystem } from './simulation/signalsToSpinSystem';
 import simulate1D from './simulation/simulate1D';
 import { splitSpinSystem } from './simulation/splitSpinSystem';
@@ -48,7 +48,7 @@ export interface OptionsSignalsToXY {
   maxClusterSize?: number;
 }
 
-type JcouplingFromPrediction = MakeMandatory<Jcoupling, 'distance'>;
+type JcouplingFromPrediction = MakeMandatory<Jcoupling, 'pathLength'>;
 type Signal1DWidthAtomsIDsAndDiaID = MakeMandatory<NMRSignal1D, 'atoms'>;
 type Signal1DWidthJsAndDiaID = Omit<Signal1DWidthAtomsIDsAndDiaID, 'js'> & {
   js: JcouplingFromPrediction[];

package/src/signals/simulation/signalsToSpinSystem.ts

@@ -1,10 +1,10 @@
 import { Matrix } from 'ml-matrix';
 import simpleClustering from 'ml-simple-clustering';
 
-import type { MakeMandatory } from '../../types/MakeMandatory';
-import type { NMRSignal1D } from '../../types/NMRSignal1D';
-import type { Jcoupling } from '../../types/jcoupling';
-import type { SpinSystem } from '../../types/spinSystem';
+import type { MakeMandatory } from '../../utilities/MakeMandatory';
+import type { NMRSignal1D } from '../NMRSignal1D';
+import type { Jcoupling } from '../jcoupling';
+import type { SpinSystem } from '../spinSystem';
 
 interface Ids {
   [index: number]: number;

package/src/signals/simulation/simulate1D.ts

@@ -6,7 +6,7 @@ import type { Shape1D } from 'ml-peak-shape-generator';
 import { SparseMatrix } from 'ml-sparse-matrix';
 import { SpectrumGenerator } from 'spectrum-generator';
 
-import type { SpinSystem } from '../../types/spinSystem';
+import type { SpinSystem } from '../spinSystem';
 
 import getPauliMatrix from './getPauliMatrix';
 
@@ -133,7 +133,8 @@ export default function simulate1D(
         clusterFake,
       );
       const hamSize = hamiltonian.rows;
-      //@ts-expect-error
+      // TODO: add support for sparse matrix in matrix types.
+      // @ts-expect-error sparse matrix not supported
       const evd = new EVD(hamiltonian);
       const V = evd.eigenvectorMatrix;
       const diagB = evd.realEigenvalues;

package/src/signals/simulation/splitSpinSystem.ts

@@ -2,7 +2,7 @@ import { agnes } from 'ml-hclust';
 import type { Cluster } from 'ml-hclust';
 import { Matrix } from 'ml-matrix';
 
-import type { SpinSystem } from '../../types/spinSystem';
+import type { SpinSystem } from '../spinSystem';
 
 export interface SplitSpinSystemOptions {
   /**
@@ -53,7 +53,11 @@ interface SplitClusterOptions {
   connectivity: Matrix;
 }
 
-function splitCluster(cluster: Cluster, clusterList: Array<Int16Array>, options: SplitClusterOptions) {
+function splitCluster(
+  cluster: Cluster,
+  clusterList: Array<Int16Array>,
+  options: SplitClusterOptions,
+) {
   let { maxClusterSize, force, nSpins, connectivity } = options;
   if (!force && cluster.size <= maxClusterSize) {
     clusterList.push(getMembers(cluster.indices(), nSpins));
@@ -102,7 +106,11 @@ function splitCluster(cluster: Cluster, clusterList: Array<Int16Array>, options:
   }
 }
 
-function calculateBetas(chemicalShifts: number[], couplingConstants: Matrix, frequency: number) {
+function calculateBetas(
+  chemicalShifts: number[],
+  couplingConstants: Matrix,
+  frequency: number,
+) {
   let nRows = couplingConstants.rows;
   let nColumns = couplingConstants.columns;
   let betas = Matrix.zeros(nRows, nRows);

package/src/utilities/joinPatterns.ts

@@ -1,7 +1,6 @@
 import { couplingPatterns } from '../constants/couplingPatterns';
 import { couplingValues } from '../constants/couplingValues';
 
-
 export function joinPatterns(patterns: string[]) {
   const sum = patterns.reduce((sum, pattern) => {
     if (isNaN(couplingValues[pattern])) {

package/src/utilities/rangeFromSignal.ts

@@ -1,5 +1,5 @@
 import { couplingValues } from '../constants/couplingValues';
-import type { NMRSignal1D } from '../types/NMRSignal1D';
+import type { NMRSignal1D } from '../signals/NMRSignal1D';
 
 export interface RangeFromSignalOptions {
   /**

package/src/utilities/resurrect.ts

@@ -1,4 +1,4 @@
-import type { NMRRange } from '../types/NMRRange';
+import type { NMRRange } from '../xy/NMRRange';
 
 import { resurrectRange } from './resurrectRange';
 import { splitParenthesis } from './splitParenthesis';

package/src/utilities/resurrectRange.ts

@@ -1,5 +1,5 @@
-import type { NMRRange } from '../types/NMRRange';
-import type { NMRSignal1D } from '../types/NMRSignal1D';
+import type { NMRSignal1D } from '../signals/NMRSignal1D';
+import type { NMRRange } from '../xy/NMRRange';
 
 import { rangeFromSignal } from './rangeFromSignal';
 import { splitParenthesis } from './splitParenthesis';

package/src/{types → xy}/NMRRange.ts

@@ -1,4 +1,4 @@
-import type { NMRSignal1D } from './NMRSignal1D';
+import type { NMRSignal1D } from '../signals/NMRSignal1D';
 
 export interface NMRRange {
   from: number;

package/src/xy/xyAutoPeaksPicking.ts

@@ -2,9 +2,9 @@ import { DataXY } from 'cheminfo-types';
 import { gsd, joinBroadPeaks, optimizePeaks } from 'ml-gsd';
 import type {
   Peak1D,
-  IGSDOptions,
-  IOptimizePeaksOptions,
-  IJoinBroadPeaksOptions,
+  GSDOptions,
+  OptimizePeaksOptions,
+  JoinBroadPeaksOptions,
 } from 'ml-gsd';
 import {
   xyExtract,
@@ -26,9 +26,9 @@ interface OptionsGetCutOff {
 }
 
 export interface IGetPeakListOptions
-  extends IGSDOptions,
-    IOptimizePeaksOptions,
-    IJoinBroadPeaksOptions {
+  extends GSDOptions,
+    OptimizePeaksOptions,
+    JoinBroadPeaksOptions {
   /**
    * If it is true, the peaks parameters will be optimized.
    * @default false

package/src/xy/xyAutoRangesPicking.ts

@@ -1,7 +1,8 @@
+import type { DataXY } from 'cheminfo-types';
+
 import { peaksFilterImpurities } from '../peaks/peaksFilterImpurities';
 import type { OptionsPeaksFilterImpurities } from '../peaks/peaksFilterImpurities';
 import { OptionsPeaksToRanges, peaksToRanges } from '../peaks/peaksToRanges';
-import type { XYNumberArray } from '../types/XYNumberArray';
 
 import { xyAutoPeaksPicking } from './xyAutoPeaksPicking';
 import type { OptionsXYAutoPeaksPicking } from './xyAutoPeaksPicking';
@@ -16,7 +17,7 @@ interface OptionsXYAutoRangesPicking {
  * Detect peaks, optimize parameters and compile multiplicity if required.
  */
 export function xyAutoRangesPicking(
-  data: XYNumberArray,
+  data: DataXY,
   options: OptionsXYAutoRangesPicking = {},
 ) {
   let peaks = xyAutoPeaksPicking(data, options.peakPicking);

package/src/{types → xyz}/NMRSignal2D.ts

@@ -1,4 +1,5 @@
-import type { MPFPeak } from './MPFPeak';
+import type { FromTo } from 'cheminfo-types';
+import type { Peak2D } from 'ml-matrix-peaks-finder';
 
 export interface Signal2DAxisData {
   nucleus?: string;
@@ -6,15 +7,14 @@ export interface Signal2DAxisData {
   resolution?: number;
   atoms?: number[];
   diaIDs?: string[];
-  from: number;
-  to: number;
 }
 export interface NMRSignal2D {
   x: Signal2DAxisData;
   y: Signal2DAxisData;
+  j?: {
+    pathLength?: number | FromTo;
+  };
   id?: string;
-  peaks?: MPFPeak[];
+  peaks?: Peak2D[];
   kind?: string;
-  //eslint-disable-next-line
-  _highlight?: (number | string)[];
 }

package/src/xyz/NMRZone.ts

@@ -0,0 +1,10 @@
+import type { FromTo } from 'cheminfo-types';
+
+import type { NMRSignal2D } from './NMRSignal2D';
+
+export interface NMRZone {
+  x: FromTo;
+  y: FromTo;
+  id?: string;
+  signals: NMRSignal2D[];
+}

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,25 +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.from = minMax1[0];
-      signal.y.from = minMax2[0];
-      signal.x.to = minMax1[1];
-      signal.y.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));