nmr-processing 9.5.0 → 9.5.1-pre.1684857934

package/src/xyz/util/padData.ts

@@ -1,8 +1,9 @@
-import Matrix from 'ml-matrix';
+import { MinMaxContent } from 'cheminfo-types';
 
-import { Data2D } from '../Data2D';
-
-export function padData(spectraData: Data2D, options: { width: number }) {
+export function padData(
+  spectraData: MinMaxContent,
+  options: { width: number },
+) {
   let { minX, maxX, minY, maxY } = spectraData;
 
   const width = options.width;
@@ -20,15 +21,20 @@ export function padData(spectraData: Data2D, options: { width: number }) {
 
   let xOffset = xDiff / 2;
   let yOffset = yDiff / 2;
-  let newMatrix = Matrix.zeros(nbSubSpectra + yDiff, nbPoints + xDiff);
+
+  const newMatrix: Float64Array[] = [];
+  for (let i = 0; i < nbSubSpectra + yDiff; i++) {
+    newMatrix.push(new Float64Array(nbPoints + xDiff));
+  }
   for (let i = 0; i < nbSubSpectra; i++) {
     for (let j = 0; j < nbPoints; j++) {
-      newMatrix.set(i + yOffset, j + xOffset, spectraData.z[i][j]);
+      newMatrix[i + yOffset].set(spectraData.z[i], xOffset);
     }
   }
 
   return {
-    z: newMatrix.to2DArray(),
+    ...spectraData,
+    z: newMatrix,
     minX: minX - xOffset * xInterval,
     maxX: maxX + xOffset * xInterval,
     minY: minY - yOffset * yInterval,

package/src/xyz/xyzAutoSignalsPicking.ts

@@ -1,4 +1,5 @@
 import { v4 as generateID } from '@lukeed/uuid';
+import { MinMaxContent } from 'cheminfo-types';
 import * as convolution from 'ml-matrix-convolution';
 import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
@@ -11,7 +12,6 @@ import type { GetKernelOptions } from '../peaks/util/getKernel';
 import * as PeakOptimizer from '../peaks/util/peakOptimizer';
 import { MakeMandatory } from '../utilities/MakeMandatory';
 
-import { Data2D } from './Data2D';
 import type { NMRSignal2D } from './NMRSignal2D';
 import { padData } from './util/padData';
 
@@ -89,7 +89,7 @@ export type NMRSignal2DWithID<T extends Peak2D = Peak2D> = MakeMandatory<
 >;
 
 export function xyzAutoSignalsPicking(
-  spectraData: Data2D,
+  spectraData: MinMaxContent,
   options: XYZAutoSignalsPickingOptions,
 ) {
   let {

package/src/xyz/xyzAutoZonesPicking.ts

@@ -1,3 +1,5 @@
+import { MinMaxContent } from 'cheminfo-types';
+
 import { xyzAutoSignalsPicking } from '..';
 import type { GetKernelOptions } from '../peaks/util/getKernel';
 import { MakeMandatory } from '../utilities/MakeMandatory';
@@ -5,14 +7,6 @@ import { MakeMandatory } from '../utilities/MakeMandatory';
 import { NMRZone } from './NMRZone';
 import { formatZones } from './util/formatZone';
 
-export interface Data2D {
-  z: number[][] | Float64Array[];
-  minX: number;
-  maxX: number;
-  minY: number;
-  maxY: number;
-}
-
 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.
@@ -71,7 +65,7 @@ export interface XYZAutoZonesPickingOptions {
 export type NMRZoneWithID = MakeMandatory<NMRZone, 'id'>;
 
 export function xyzAutoZonesPicking(
-  spectraData: Data2D,
+  spectraData: MinMaxContent,
   options: XYZAutoZonesPickingOptions,
 ): NMRZoneWithID[] {
   const signals = xyzAutoSignalsPicking(spectraData, options);

package/src/xyz/xyzBidimensionalFFT.ts

@@ -0,0 +1,122 @@
+import { Data2D, DoubleArray, Data2DFid } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+
+import { ApodizationOptions } from '../apodization/apodization';
+
+import { quadrature } from './quadrature';
+import {
+  DirectDimensionOptions,
+  fftDirectDimension,
+} from './util/fft2d/fftDirectDimension';
+import {
+  fftIndirectDimension,
+  IndirectDimensionOptions,
+} from './util/fft2d/fftIndirectDimension';
+import { ZeroFillingOptions } from './util/fft2d/zeroFilling';
+
+type Info2D = any;
+
+interface BidimensionalFFTOptions {
+  fnMode: string;
+  info: Info2D;
+  zeroFilling?: ZeroFillingOptions;
+  phaseCorrection?: { ph0: number; ph1: number };
+  digitalFilterValue?: number;
+  apodization?: ApodizationOptions;
+  indirect?: IndirectDimensionOptions;
+  direct?: DirectDimensionOptions;
+}
+
+export function xyzBidimensionalFFT(
+  data: Data2D,
+  options: BidimensionalFFTOptions,
+) {
+  ensureData2DFid(data);
+
+  const {
+    info,
+    fnMode,
+    digitalFilterValue = 0,
+    zeroFilling: zeroFillingGeneral,
+  } = options;
+
+  const orderedData = quadrature(data, { fnMode });
+
+  const { re: reData } = orderedData;
+  const nbRows = reData.length;
+  const nbColumns = reData[0].length;
+  const { direct = {}, indirect = {} } = options;
+
+  const { zeroFilling: zeroFillingF2 = zeroFillingGeneral } = direct;
+
+  const { factor: f2Factor = 2 } = zeroFillingF2 || {};
+  const nbPointsF2 =
+    zeroFillingF2?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * f2Factor));
+
+  const transformed = fftDirectDimension(orderedData, {
+    ...direct,
+    fnMode,
+    digitalFilterValue,
+    zeroFilling: { nbPoints: nbPointsF2 },
+  });
+
+  const { zeroFilling: zeroFillingF1 } = options;
+  const { factor: f1Factor = 2 } = zeroFillingF1 || {};
+  const nbPointsF1 =
+    zeroFillingF1?.nbPoints || 2 ** Math.round(Math.log2(nbRows * f1Factor));
+  const { re: reResult, im: imResult } = fftIndirectDimension(transformed, {
+    ...indirect,
+    fnMode,
+    zeroFilling: { nbPoints: nbPointsF1 },
+  });
+
+  const minMaxXY = getMinMaxXY(info);
+  return {
+    re: {
+      z: convertToDoubleArray(reResult),
+      maxZ: reResult.max(),
+      minZ: reResult.min(),
+      ...minMaxXY,
+    },
+    im: {
+      z: convertToDoubleArray(imResult),
+      maxZ: imResult.max(),
+      minZ: imResult.min(),
+      ...minMaxXY,
+    },
+  };
+}
+
+function ensureData2DFid(data: Data2D): asserts data is Data2DFid {
+  if (!('re' in data)) {
+    throw new Error('bidimensional FFT only can be applied to raw data');
+  }
+}
+
+function convertToDoubleArray(data: Matrix) {
+  const result: DoubleArray[] = new Array(data.rows);
+  for (let i = 0; i < data.rows; i++) {
+    result[i] = new Float64Array(data.getRow(i));
+  }
+  return result;
+}
+
+function getMinMaxXY(info: Info2D) {
+  const min: number[] = [];
+  const max: number[] = [];
+  for (let i = 0; i < info.baseFrequency.length; i++) {
+    const baseFrequency = Number.parseFloat(info.baseFrequency[i]);
+    const frequencyOffset = Number.parseFloat(info.frequencyOffset[i]);
+    const spectralWidth = Number.parseFloat(info.spectralWidth[i]);
+    const offset = frequencyOffset / baseFrequency;
+    min.push(offset - spectralWidth * 0.5);
+    max.push(offset + spectralWidth * 0.5);
+  }
+
+  return {
+    minX: min[0],
+    maxX: max[0],
+    minY: min[1],
+    maxY: max[1],
+  };
+}

package/lib/xyz/Data2D.d.ts

@@ -1,7 +0,0 @@
-export interface Data2D {
-    z: number[][] | Float64Array[];
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: number;
-}

package/lib/xyz/Data2D.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Data2D.js","sourceRoot":"","sources":["../../src/xyz/Data2D.ts"],"names":[],"mappings":""}

package/lib-esm/xyz/Data2D.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Data2D.js.map

package/lib-esm/xyz/Data2D.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Data2D.js","sourceRoot":"","sources":["../../src/xyz/Data2D.ts"],"names":[],"mappings":""}

package/src/xyz/Data2D.ts

@@ -1,7 +0,0 @@
-export interface Data2D {
-  z: number[][] | Float64Array[];
-  minX: number;
-  maxX: number;
-  minY: number;
-  maxY: number;
-}