nmr-processing 3.4.0 → 6.0.0

package/src/signals/simulation/simulate1D.ts

@@ -1,9 +1,10 @@
 import binarySearch from 'binary-search';
+import { DataXY } from 'cheminfo-types';
 import { Matrix, EVD } from 'ml-matrix';
 import type { Matrix as MatrixClassType } from 'ml-matrix';
+import type { Shape1D } from 'ml-peak-shape-generator';
 import { SparseMatrix } from 'ml-sparse-matrix';
 import { SpectrumGenerator } from 'spectrum-generator';
-import type { Shape1DOptions } from 'spectrum-generator';
 
 import type { SpinSystem } from '../../types/spinSystem';
 
@@ -46,7 +47,7 @@ interface Simulate1DOptions {
    * Shape options
    * @default {kind:'gaussian'}
    */
-  shape?: Shape1DOptions;
+  shape?: Shape1D;
 }
 
 /**
@@ -59,7 +60,7 @@ export default function simulate1D(
    */
   spinSystem: SpinSystem,
   options: Simulate1DOptions = {},
-) {
+): DataXY {
   let {
     lineWidth = 1,
     maxClusterSize = 8,

package/src/signals/simulation/splitSpinSystem.ts

@@ -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/types/NMRPeak1D.ts

@@ -1,11 +1,5 @@
-export interface NMRPeak1D {
+import type { Peak1D } from 'ml-gsd';
+
+export interface NMRPeak1D extends Peak1D {
   kind?: string;
-  x: number;
-  y: number;
-  shape: {
-    width: number;
-    noiseLevel?: number;
-    soft?: boolean;
-    kind?: string;
-  };
 }

package/src/types/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,17 +7,16 @@ export interface Signal2DAxisData {
   resolution?: number;
   atoms?: number[];
   diaIDs?: string[];
-  fromTo?: {
-    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/types/NMRZone.ts

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

package/src/types/dataStructure.ts

@@ -2,4 +2,4 @@ export interface DataBaseLevelStructure {
   [key: string]: number[] | undefined;
 }
 
-export type DataBaseStructure = DataBaseLevelStructure[];
+export type DataBaseStructure = DataBaseLevelStructure[];

package/src/types/jcoupling.ts

@@ -4,5 +4,5 @@ export interface Jcoupling {
   assignment?: string | string[];
   diaIDs?: string[];
   multiplicity?: string;
-  distance?: number;
+  pathLength?: number;
 }

package/src/types/ml-matrix-peaks-finder/index.d.ts

@@ -8,7 +8,7 @@ declare module 'ml-matrix-peaks-finder' {
     cols: number;
     labelling?: 'drain' | 'floodfill';
   }
-  interface MPFPeak {
+  interface Peak2D {
     x: number;
     y: number;
     z: number;
@@ -20,5 +20,5 @@ declare module 'ml-matrix-peaks-finder' {
   function findPeaks2DRegion(
     absoluteData: number[] | Float64Array,
     options?: FindPeaks2DRegionOptions,
-  ): MPFPeak[];
+  ): Peak2D[];
 }

package/src/types/ml-simple-clustering/index.d.ts

@@ -9,4 +9,4 @@ declare module 'ml-simple-clustering' {
 interface OptionsSimpleClustering {
   threshold?: number;
   out?: 'assignment' | 'indexes' | 'values';
-}
+}

package/src/types/ml-spectra-processing/index.d.ts

@@ -45,7 +45,13 @@ declare module 'ml-spectra-processing' {
 
   interface XYIntegrationOptions extends XGetFromToIndexOptions {}
 
-  function xyIntegration(data: XYNumberArray, options?: XYIntegrationOptions): number;
+  function xyIntegration(
+    data: XYNumberArray,
+    options?: XYIntegrationOptions,
+  ): number;
 
-  function xGetFromToIndex(x: number[] | Float64Array, options?: XGetFromToIndexOptions): number;
+  function xGetFromToIndex(
+    x: number[] | Float64Array,
+    options?: XGetFromToIndexOptions,
+  ): number;
 }

package/src/types/modules/nmr-parser.ts

@@ -0,0 +1,17 @@
+declare module 'nmr-parser' {
+  interface FromBrukerOptions {
+    base64?: boolean;
+    shiftX?: number;
+    info?: any;
+    name?: string;
+  }
+
+  function fromBruker(
+    zipFile: ArrayBuffer | string,
+    options?: Partial<FromBrukerOptions>,
+  ): Promise<Array<any>>;
+
+  function fromJCAMP(buffer: string | ArrayBuffer, options?: any): Array<any>;
+
+  function fromJEOL(buffer: ArrayBuffer): any;
+}

package/src/types/openchemlib-utils/index..d.ts

@@ -48,7 +48,10 @@ declare module 'openchemlib-utils' {
   export interface PathInfo extends AtomInfo {
     paths: HoseCodesForPath[];
   }
-  function getPathsInfo(molecule: Molecule, options?: GetPathsInfoOptions): PathInfo[];
+  function getPathsInfo(
+    molecule: Molecule,
+    options?: GetPathsInfoOptions,
+  ): PathInfo[];
 
   export interface AtomInfo {
     oclID: string;
@@ -102,20 +105,25 @@ declare module 'openchemlib-utils' {
   export interface HoseCodesForPath {
     atoms: number[];
     from: number;
-    to: number,
-    torsion?: number,
+    to: number;
+    torsion?: number;
     hoses: Hoses;
     length: number;
   }
 
-  function getHoseCodesForPath(molecule: Molecule, from: string, to: string, maxLength: number): HoseCodesForPath;
+  function getHoseCodesForPath(
+    molecule: Molecule,
+    from: string,
+    to: string,
+    maxLength: number,
+  ): HoseCodesForPath;
 
   export interface GetConnectivityMatrixOptions {
     /**
      * get the path length between atoms
      * @default false
      */
-    pathLength?: boolean
+    pathLength?: boolean;
     /**
      * set the nominal mass of the atoms on diagonal
      * @default false
@@ -142,7 +150,10 @@ declare module 'openchemlib-utils' {
      */
     stda?: boolean | number;
   }
-  function getConnectivityMatrix(molecule: Molecule, options?: GetConnectivityMatrixOptions): number[][] | Float64Array[];
+  function getConnectivityMatrix(
+    molecule: Molecule,
+    options?: GetConnectivityMatrixOptions,
+  ): number[][] | Float64Array[];
 
   function getDiastereotopicAtomIDs(molecule: Molecule): string[];
 }

package/src/types/prediction1D.ts

@@ -1,7 +1,7 @@
 import type { Molecule } from 'openchemlib';
 
-import type { NMRRange } from "./NMRRange";
-import type { NMRSignal1D } from "./NMRSignal1D";
+import type { NMRRange } from './NMRRange';
+import type { NMRSignal1D } from './NMRSignal1D';
 
 export interface Prediction1D {
   molfile: string;

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/xy/xyAutoPeaksPicking.ts

@@ -1,12 +1,17 @@
 import { DataXY } from 'cheminfo-types';
 import { gsd, joinBroadPeaks, optimizePeaks } from 'ml-gsd';
+import type {
+  Peak1D,
+  GSDOptions,
+  OptimizePeaksOptions,
+  JoinBroadPeaksOptions,
+} from 'ml-gsd';
 import {
   xyExtract,
   xNoiseSanPlot,
   xAbsoluteMedian,
 } from 'ml-spectra-processing';
 
-import type { NMRPeak1D } from '../types/NMRPeak1D';
 /**
  * Implementation of the peak picking method described by Cobas in:
  * A new approach to improving automated analysis of proton NMR spectra
@@ -20,63 +25,19 @@ interface OptionsGetCutOff {
   thresholdFactor: number;
 }
 
-interface OptionsGetPeakList {
-  /**
-   * Noise threshold in spectrum y units. Default is three/thresholdFactor times the absolute median of data.y.
-   * @default `median(data.y) * (options.thresholdFactor || 3)`
-   */
-  noiseLevel?: number;
-  /**
-   * Threshold to determine if a given peak should be considered as a noise, bases on its relative height compared to the highest peak.
-   * @default 0.01
-   */
-  minMaxRatio: number;
-  /**
-   * If broadRatio is higher than 0, then all the peaks which second derivative smaller than broadRatio * maxAbsSecondDerivative will be marked with the soft mask equal to true.
-   * @default 0.00025
-   */
-  broadRatio: number;
-  /**
-   * Select the peak intensities from a smoothed version of the independent variables.
-   * @default true
-   */
-  smoothY: boolean;
+export interface IGetPeakListOptions
+  extends GSDOptions,
+    OptimizePeaksOptions,
+    JoinBroadPeaksOptions {
   /**
    * If it is true, the peaks parameters will be optimized.
    * @default false
    */
   optimize: boolean;
-  /**
-   * factor to determine the width at the moment to group the peaks in signals in 'GSD.optimizePeaks' function.
-   * @default 4
-   */
-  factorWidth: number;
-  /**
-   * if it is true, it optimizes the x and intensity by extrapolation.
-   */
-  realTopDetection: boolean;
-  /**
-   * options to shape used to adapt the FWHM
-   * @default {kind:'gaussian'}
-   */
-  shape: { kind: string };
-  /**
-   * options for optimization step, kind represent the algorithm
-   * @default {kind:'lm'}
-   */
-  optimization: { kind: string };
-  /**
-   * Threshold to determine if some peak is candidate to clustering into range.
-   * @default 0.25
-   */
-  broadWidth: number;
-  /**
-   * Options for savitz Golay
-   */
-  sgOptions: { windowSize: number; polynomial: number };
 }
 
-export interface OptionsXYAutoPeaksPicking extends Partial<OptionsGetPeakList> {
+export interface OptionsXYAutoPeaksPicking
+  extends Partial<IGetPeakListOptions> {
   /**
    * Low limit value in the x axis to extract a sub set of points from the input data.
    */
@@ -105,7 +66,7 @@ export interface OptionsXYAutoPeaksPicking extends Partial<OptionsGetPeakList> {
 export function xyAutoPeaksPicking(
   data: DataXY,
   options: OptionsXYAutoPeaksPicking = {},
-): NMRPeak1D[] {
+): Peak1D[] {
   const {
     from,
     to,
@@ -131,7 +92,7 @@ export function xyAutoPeaksPicking(
 
   const cutOff = getCutOff(data.y, { noiseLevel, useSanPlot, thresholdFactor });
 
-  let getPeakOptions = {
+  let getPeakOptions: IGetPeakListOptions = {
     shape,
     broadWidth,
     optimize,
@@ -154,7 +115,7 @@ export function xyAutoPeaksPicking(
   return peaks;
 }
 
-function getPeakList(data: DataXY, options: OptionsGetPeakList) {
+function getPeakList(data: DataXY, options: IGetPeakListOptions) {
   const {
     shape,
     broadWidth,
@@ -173,15 +134,15 @@ function getPeakList(data: DataXY, options: OptionsGetPeakList) {
     shape,
     sgOptions,
     minMaxRatio,
-    broadRatio,
     noiseLevel,
     smoothY,
     realTopDetection,
   });
 
   if (broadWidth) {
-    peakList = joinBroadPeaks(peakList, {
-      width: broadWidth,
+    peakList = joinBroadPeaks(data, peakList, {
+      broadRatio,
+      broadWidth,
       shape,
       optimization,
     });
@@ -198,7 +159,7 @@ function getPeakList(data: DataXY, options: OptionsGetPeakList) {
   return peakList;
 }
 
-function getNegativePeaks(data: DataXY, options: OptionsGetPeakList) {
+function getNegativePeaks(data: DataXY, options: IGetPeakListOptions) {
   let { x, y } = data;
   let negativeDataY = new Float64Array(data.y.length);
   for (let i = 0; i < negativeDataY.length; i++) {

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

@@ -1,13 +1,14 @@
 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';
 
 const smallFilter = [
@@ -86,7 +87,7 @@ export interface XYZAutoPeaksPickingOptions {
   kernel?: GetKernelOptions;
 }
 
-export function xyzAutoPeaksPicking(
+export function xyzAutoZonesPicking(
   spectraData: Data2D,
   options: XYZAutoPeaksPickingOptions,
 ) {
@@ -178,7 +179,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 +236,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 +281,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 +315,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 +324,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,8 +1,8 @@
+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';
 
@@ -96,7 +96,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 +137,7 @@ function compilePattern(
   return signals;
 }
 
-interface Peak2DHack extends MPFPeak {
+interface Peak2DHack extends Peak2D {
   width?: number;
 }
 type Signal2DHack = Omit<NMRSignal2D, 'peaks'> & {
@@ -149,7 +149,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));