nmr-processing 9.5.0 → 9.5.1-pre.1684857934

package/src/filters/filter1d/utils/padDataToNextPowerOfTwo.ts

@@ -0,0 +1,48 @@
+import { xSequentialFill } from 'ml-spectra-processing';
+
+import { Entry1D } from '../../Entry1D';
+
+export function padDataToNextPowerOfTwo(
+  datum1D: Entry1D,
+  digitalFilterApplied: boolean,
+) {
+  const { x, re, im } = datum1D.data;
+  const size = nextPowerOfTwo(x.length);
+
+  let newRE = new Float64Array(size);
+  let newIM = new Float64Array(size);
+
+  const pointsToShift = getPointsToShift(datum1D);
+
+  newRE.set(re.slice(0, size - pointsToShift));
+  newIM.set(im.slice(0, size - pointsToShift));
+
+  if (pointsToShift > 0 && digitalFilterApplied) {
+    newRE.set(re.slice(re.length - pointsToShift), size - pointsToShift);
+    newIM.set(im.slice(re.length - pointsToShift), size - pointsToShift);
+  }
+
+  const newX = xSequentialFill({
+    from: x[0],
+    size,
+    step: x[1] - x[0],
+  }) as Float64Array;
+
+  datum1D.data = { ...datum1D.data, re: newRE, im: newIM, x: newX };
+}
+
+function getPointsToShift(datum1D: Entry1D) {
+  let grpdly = datum1D.info?.digitalFilter || 0;
+  return grpdly > 0 ? Math.floor(grpdly) : 0;
+}
+
+function nextPowerOfTwo(n: number) {
+  if (n === 0) return 1;
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  return n + 1;
+}

package/src/filters/filter1d/zeroFilling.ts

@@ -0,0 +1,90 @@
+import { Data1D } from '../Data1D';
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'zeroFilling';
+export const name = 'Zero Filling';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: false,
+};
+
+export interface ZeroFillingOptions {
+  nbPoints?: number;
+  factor?: number;
+}
+
+export function apply(datum1D: Entry1D, options: ZeroFillingOptions) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('zeroFilling not applicable on this data');
+  }
+
+  let { nbPoints, factor = 2 } = options;
+
+  if (!nbPoints) {
+    nbPoints = 2 ** Math.round(Math.log2(datum1D.data.x.length * factor));
+    const filter = datum1D.filters.find((filter) => filter.name === id);
+    if (filter) {
+      filter.value = { nbPoints };
+    }
+  }
+
+  let digitalFilterApplied = datum1D.filters.some(
+    (e) => e.name === 'digitalFilter' && e.flag,
+  );
+
+  let grpdly = datum1D.info?.digitalFilter || 0;
+  let pointsToShift;
+  if (grpdly > 0 && digitalFilterApplied) {
+    pointsToShift = Math.floor(grpdly);
+  } else {
+    pointsToShift = 0;
+  }
+
+  const { re, im, x } = datum1D.data;
+
+  let newRE = new Float64Array(nbPoints);
+  let newIM = new Float64Array(nbPoints);
+  let newX = new Float64Array(nbPoints);
+
+  const length = Math.min(nbPoints, re.length);
+
+  newRE.set(re.slice(0, length - pointsToShift));
+  newIM.set(im.slice(0, length - pointsToShift));
+  newX.set(x.slice(0, length - pointsToShift));
+
+  let diff = x[1] - x[0];
+  let currentX = x[length - pointsToShift - 1];
+  for (let i = length - pointsToShift; i < nbPoints; i++) {
+    currentX += diff;
+    newX[i] = currentX;
+  }
+
+  if (pointsToShift > 0 && pointsToShift < nbPoints) {
+    newRE.set(re.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+    newIM.set(im.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+  }
+
+  datum1D.data = { ...datum1D.data, re: newRE, im: newIM, x: newX };
+}
+
+export function isApplicable(
+  datum1D: Entry1D,
+): datum1D is Entry1D & { data: Required<Data1D> } {
+  if (datum1D.info.isComplex && datum1D.info.isFid) {
+    return true;
+  }
+  return false;
+}
+
+export function reduce(
+  _previousValue: ZeroFillingOptions,
+  newValue: ZeroFillingOptions,
+) {
+  delete newValue.factor;
+
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}

package/src/filters/filter2d/shiftX.ts

@@ -0,0 +1,31 @@
+import { MinMaxContent } from 'cheminfo-types';
+
+import { Entry2D } from '../../xyz/Entry2D';
+
+export const id = 'shift2DX';
+export const name = 'Shift 2D X';
+
+/**
+ *
+ * @param {Object} datum2d
+ * @param {number} [shiftValue=0]
+ */
+
+export function apply(datum2D: Entry2D, shiftValue = 0) {
+  const data: Record<string, MinMaxContent> = { ...datum2D.data };
+  for (const key in data) {
+    data[key].minX += shiftValue;
+    data[key].maxX += shiftValue;
+  }
+}
+
+export function isApplicable() {
+  return true;
+}
+
+export function reduce(previousValue: number, newValue: number) {
+  return {
+    once: true,
+    reduce: previousValue + newValue,
+  };
+}

package/src/filters/filter2d/shiftY.ts

@@ -0,0 +1,29 @@
+import { MinMaxContent } from 'cheminfo-types';
+
+import { Entry2D } from '../../xyz/Entry2D';
+
+export const id = 'shift2DY';
+export const name = 'Shift 2D Y';
+/**
+ *
+ * @param {Object} datum2d
+ * @param {number} [shiftValue=0]
+ */
+export function apply(datum2D: Entry2D, shiftValue = 0) {
+  const data: Record<string, MinMaxContent> = { ...datum2D.data };
+  for (const key in data) {
+    data[key].minY += shiftValue;
+    data[key].maxY += shiftValue;
+  }
+}
+
+export function isApplicable() {
+  return true;
+}
+
+export function reduce(previousValue: number, newValue: number) {
+  return {
+    once: true,
+    reduce: previousValue + newValue,
+  };
+}

package/src/index.ts

@@ -40,6 +40,7 @@ export * from './xy/xyPeaksOptimization';
 export * from './xyz/xyzAutoZonesPicking';
 export * from './xyz/xyzAutoSignalsPicking';
 export * from './xyz/xyzJResAnalyzer';
+export * from './xyz/xyzBidimensionalFFT';
 
 export * from './databases/getDatabase';
 export * from './databases/carbonImpurities';
@@ -58,6 +59,8 @@ export * from './multiplicity/checkMultiplet';
 export * from './multiplicity/checkMultiplicity';
 export * from './multiplicity/translateMultiplet';
 
+export * from './filters/FiltersManager';
+
 export type { NMRSignal1D } from './signals/NMRSignal1D';
 export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
 export type { NMRRange } from './xy/NMRRange';

package/src/utilities/checkData2DFid.ts

@@ -0,0 +1,10 @@
+import { Data2D, Data2DFid } from 'cheminfo-types';
+
+export type Data2DFidComplete = Required<Data2DFid>;
+export function checkData2DFid(
+  data: Data2D,
+): asserts data is Data2DFidComplete {
+  if (!('re' in data && 'im' in data)) {
+    throw new Error('imaginary (im) data should exists');
+  }
+}

package/src/utilities/cloneData1D.ts

@@ -0,0 +1,6 @@
+import { Data1D } from '../filters/Data1D';
+
+export function cloneData1D(datum: Data1D) {
+  const { x, re, im } = datum || { x: [], re: [], im: [] };
+  return { x: x.slice(), re: re.slice(), im: im?.slice() || null };
+}

package/src/utilities/cloneData2D.ts

@@ -0,0 +1,27 @@
+import { Data2D, Data2DFid, Data2DFt, MinMaxContent } from 'cheminfo-types';
+
+export function cloneData2D(data: Data2D) {
+  const newData: any = {};
+
+  if (isData2DFt(data)) {
+    for (const key in data) {
+      addCloneData(newData, key, data[key as keyof Data2DFt]);
+    }
+  } else {
+    for (const key in data) {
+      addCloneData(newData, key, data[key as keyof Data2DFid]);
+    }
+  }
+  return newData;
+}
+
+function isData2DFt(data: Data2D): data is Data2DFt {
+  return 're' in data;
+}
+
+function addCloneData(newData: any, key: string, data?: MinMaxContent) {
+  if (data) {
+    const { z, ...other } = data;
+    newData[key] = { z: z.slice(), ...other };
+  }
+}

package/src/xyz/Entry2D.ts

@@ -0,0 +1,12 @@
+import { Data2D } from 'cheminfo-types';
+
+import { Filter } from '../filters/FiltersManager';
+
+export interface Entry2D {
+  id?: string;
+  info: Record<string, any>;
+  originalInfo?: Record<string, any>;
+  data: Data2D;
+  originalData?: Data2D;
+  filters: Array<Filter>;
+}

package/src/xyz/quadrature.ts

@@ -0,0 +1,68 @@
+import { Data2D, DoubleArray } from 'cheminfo-types';
+import { xAdd, xMultiply, xSubtract } from 'ml-spectra-processing';
+
+import { checkData2DFid, Data2DFidComplete } from '../utilities/checkData2DFid';
+
+export function quadrature(data: Data2D, options: { fnMode: string }) {
+  checkData2DFid(data);
+
+  const { fnMode } = options;
+
+  switch (fnMode) {
+    case 'ttpi':
+      return ttpiQuadrature(data);
+    case 'states':
+      return shrQuadrature(data);
+    case 'echo':
+      return echoQuadrature(data);
+    default:
+      return {
+        re: data.re.z,
+        im: data.im.z,
+      };
+  }
+}
+
+function echoQuadrature(data: Data2DFidComplete) {
+  const {
+    re: { z: reMatrix },
+    im: { z: imMatrix },
+  } = data;
+
+  const newRe: DoubleArray[] = [];
+  const newIm: DoubleArray[] = [];
+  for (let i = 0; i < reMatrix.length; i += 2) {
+    let reCosine = reMatrix[i];
+    let imCosine = imMatrix[i];
+    let reSine = reMatrix[i + 1];
+    let imSine = imMatrix[i + 1];
+
+    newRe.push(xSubtract(xMultiply(imSine, -1), imCosine));
+    newRe.push(xSubtract(reSine, reCosine));
+    newIm.push(xAdd(reSine, reCosine));
+    newIm.push(xSubtract(imSine, imCosine));
+  }
+
+  return { re: newRe, im: newIm };
+}
+
+function shrQuadrature(data: Data2DFidComplete) {
+  const { re, im } = data;
+  return { re: re.z, im: im.z };
+}
+
+function ttpiQuadrature(data: Data2DFidComplete) {
+  const newRe: DoubleArray[] = [];
+  const newIm: DoubleArray[] = [];
+
+  const {
+    re: { z: reMatrix },
+    im: { z: imMatrix },
+  } = data;
+  for (let i = 0; i < reMatrix.length; i++) {
+    newRe.push(i % 2 ? reMatrix[i].slice() : xMultiply(reMatrix[i], -1));
+    newIm.push(i % 2 ? imMatrix[i].slice() : xMultiply(imMatrix[i], -1));
+  }
+
+  return { re: newRe, im: newIm };
+}

package/src/xyz/util/fft2d/digitalFilter.ts

@@ -0,0 +1,24 @@
+import { DataReIm } from 'ml-spectra-processing';
+
+export function digitalFilter(
+  data: DataReIm,
+  options: { digitalFilterValue: number },
+) {
+  let { digitalFilterValue = 0 } = options;
+  let re = new Float64Array(data.re);
+  let im = new Float64Array(data.im);
+
+  let pointsToShift = Math.floor(digitalFilterValue);
+
+  const skip = 0;
+  pointsToShift += 0;
+
+  const newRe = new Float64Array(re.length);
+  const newIm = new Float64Array(im.length);
+  newRe.set(re.slice(pointsToShift));
+  newRe.set(re.slice(skip, pointsToShift), re.length - pointsToShift);
+  newIm.set(im.slice(pointsToShift));
+  newIm.set(im.slice(skip, pointsToShift), im.length - pointsToShift);
+
+  return { re: newRe, im: newIm };
+}

package/src/xyz/util/fft2d/fftDirectDimension.ts

@@ -0,0 +1,111 @@
+import { DoubleArray } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+import {
+  reimAutoPhaseCorrection,
+  reimFFT,
+  reimPhaseCorrection,
+} from 'ml-spectra-processing';
+
+import {
+  apodization,
+  ApodizationOptions,
+} from '../../../apodization/apodization';
+
+import { digitalFilter } from './digitalFilter';
+import { removeDCOffset } from './removeDCOffset';
+import { zeroFilling, ZeroFillingOptions } from './zeroFilling';
+
+interface PhaseCorrection {
+  mode?: string;
+  ph0?: number;
+  ph1?: number;
+}
+
+export interface DirectDimensionOptions {
+  fnMode?: string;
+  digitalFilterValue?: number;
+  zeroFilling?: ZeroFillingOptions;
+  apodization?: ApodizationOptions;
+  phaseCorrection?: PhaseCorrection;
+}
+
+export function fftDirectDimension(
+  data: { re: DoubleArray[]; im: DoubleArray[] },
+  options: DirectDimensionOptions,
+) {
+  const { re: reData, im: imData } = data;
+  const nbRows = reData.length;
+  const nbColumns = reData[0].length;
+
+  const { zeroFilling: zeroFillingF2, digitalFilterValue = 0 } = options;
+
+  const { factor: f2Factor = 2 } = zeroFillingF2 || {};
+  const nbPointsF2 =
+    zeroFillingF2?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * f2Factor));
+
+  const reFFT = new Matrix(nbRows, nbPointsF2);
+  const imFFT = new Matrix(nbRows, nbPointsF2);
+
+  const { apodization: apodizationF2 } = options;
+  let {
+    ph0: ph0F2,
+    ph1: ph1F2,
+    mode: pcModeF2 = 'no',
+  } = options?.phaseCorrection || {};
+
+  for (let i = 0; i < nbRows; i++) {
+    const newData = digitalFilter(
+      { re: reData[i], im: imData[i] },
+      { digitalFilterValue },
+    );
+
+    Object.assign(newData, removeDCOffset(newData, { digitalFilterValue }));
+
+    if (apodizationF2) {
+      const { re: aRe, im: aIm } = apodization(newData, apodizationF2);
+      Object.assign(newData, { re: aRe, im: aIm });
+    }
+
+    Object.assign(
+      newData,
+      zeroFilling(newData, { digitalFilterValue, nbPoints: nbPointsF2 }),
+    );
+
+    Object.assign(newData, reimFFT(newData, { applyZeroShift: true }));
+
+    const dfResidual =
+      (digitalFilterValue - Math.round(digitalFilterValue)) * Math.PI * 2;
+    if (dfResidual > 0) {
+      Object.assign(newData, reimPhaseCorrection(newData, 0, -dfResidual));
+    }
+
+    if (
+      i === 0 &&
+      pcModeF2 === 'pk' &&
+      ph0F2 === undefined &&
+      ph1F2 === undefined
+    ) {
+      const phased = reimAutoPhaseCorrection(newData, { magnitudeMode: false });
+      ph0F2 = phased.ph0;
+      ph1F2 = phased.ph1;
+    }
+    if (pcModeF2 === 'pk' && ph0F2 !== undefined && ph1F2 !== undefined) {
+      Object.assign(
+        newData,
+        reimPhaseCorrection(
+          newData,
+          (ph0F2 * Math.PI) / 180,
+          (ph1F2 * Math.PI) / 180,
+        ),
+      );
+    }
+
+    reFFT.setRow(i, newData.re);
+    imFFT.setRow(i, newData.im);
+  }
+
+  return {
+    re: reFFT,
+    im: imFFT,
+  };
+}

package/src/xyz/util/fft2d/fftIndirectDimension.ts

@@ -0,0 +1,123 @@
+import { DoubleArray } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+import {
+  reimAbsolute,
+  reimAutoPhaseCorrection,
+  reimFFT,
+  reimPhaseCorrection,
+} from 'ml-spectra-processing';
+
+import {
+  apodization,
+  ApodizationOptions,
+} from '../../../apodization/apodization';
+
+import { zeroFilling, ZeroFillingOptions } from './zeroFilling';
+
+interface PhaseCorrection {
+  mode?: string;
+  ph0?: number;
+  ph1?: number;
+}
+
+export interface IndirectDimensionOptions {
+  fnMode?: string;
+  zeroFilling?: ZeroFillingOptions;
+  apodization?: ApodizationOptions;
+  phaseCorrection?: PhaseCorrection;
+}
+
+export function fftIndirectDimension(
+  data: { re: DoubleArray[] | Matrix; im: DoubleArray[] | Matrix },
+  options: IndirectDimensionOptions,
+) {
+  const reData = Matrix.checkMatrix(data.re);
+  const imData = Matrix.checkMatrix(data.im);
+
+  const nbRows = reData.rows;
+  const nbColumns = reData.columns;
+
+  const { zeroFilling: zeroFillingF1 } = options;
+  const { factor: f1Factor = 2 } = zeroFillingF1 || {};
+  const nbPointsF1 =
+    zeroFillingF1?.nbPoints || 2 ** Math.round(Math.log2(nbRows * f1Factor));
+  const { apodization: apodizationF1 } = options;
+  let {
+    ph0: ph0F1,
+    ph1: ph1F1,
+    mode: pcModeF1,
+  } = options.phaseCorrection || {};
+
+  const reResult = new Matrix(nbPointsF1, nbColumns);
+  const imResult = new Matrix(nbPointsF1, nbColumns);
+  for (let i = 0; i < nbColumns; i++) {
+    const { re: aRe, im: aIm } = apodization(
+      {
+        re: reData.getColumn(i),
+        im: imData.getColumn(i),
+      },
+      apodizationF1,
+    );
+
+    const newRe = [];
+    const newIm = [];
+    if (options.fnMode === 'echo') {
+      for (let j = 0; j < aRe.length; j += 2) {
+        newRe.push(aRe[j]);
+        newIm.push(aRe[j + 1]);
+      }
+    } else {
+      for (let j = 0; j < aRe.length; j++) {
+        newRe.push(aRe[j]);
+        newIm.push(-aIm[j]);
+      }
+    }
+
+    let transformed = reimFFT(
+      zeroFilling(
+        {
+          re: newRe,
+          im: newIm,
+        },
+        { digitalFilterValue: 0, nbPoints: nbPointsF1 },
+      ),
+      { applyZeroShift: true },
+    );
+    let { re, im } = transformed;
+
+    if (options.phaseCorrection?.mode === 'mc') {
+      re = reimAbsolute({ re, im });
+      im = new Float64Array(im.length);
+    }
+
+    if (pcModeF1 === 'pk') {
+      if (i === 0 && ph0F1 === undefined && ph1F1 === undefined) {
+        //here we can improve it by checking if the experiment is phase sensitive.
+        const phased = reimAutoPhaseCorrection(
+          { re, im },
+          { magnitudeMode: false },
+        );
+        ph0F1 = phased.ph0;
+        ph1F1 = phased.ph1;
+      }
+      if (ph0F1 !== undefined && ph1F1 !== undefined) {
+        Object.assign(
+          transformed,
+          reimPhaseCorrection(
+            transformed,
+            (ph0F1 * Math.PI) / 180,
+            (ph1F1 * Math.PI) / 180,
+          ),
+        );
+      }
+    }
+
+    reResult.setColumn(i, re);
+    imResult.setColumn(i, im);
+  }
+
+  return {
+    re: reResult,
+    im: imResult,
+  };
+}

package/src/xyz/util/fft2d/removeDCOffset.ts

@@ -0,0 +1,19 @@
+import { DataReIm, xMean } from 'ml-spectra-processing';
+
+export function removeDCOffset(data: DataReIm, options: any) {
+  let { digitalFilterValue = 0 } = options;
+  const nbPoints = data.re.length;
+  const newRe = new Float64Array(data.re);
+  const newIm = new Float64Array(data.im);
+  const averageRe = xMean(
+    data.re.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilterValue),
+  );
+  const averageIm = xMean(
+    data.im.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilterValue),
+  );
+  for (let i = digitalFilterValue; i < nbPoints - digitalFilterValue; i++) {
+    newRe[i] -= averageRe;
+    newIm[i] -= averageIm;
+  }
+  return { re: newRe, im: newIm };
+}

package/src/xyz/util/fft2d/zeroFilling.ts

@@ -0,0 +1,39 @@
+import { DataReIm } from 'ml-spectra-processing';
+
+export interface ZeroFillingOptions {
+  nbPoints?: number;
+  factor?: number;
+  digitalFilterValue?: number;
+}
+
+export function zeroFilling(data: DataReIm, options: ZeroFillingOptions) {
+  let { nbPoints, factor = 2, digitalFilterValue: grpdly = 0 } = options;
+
+  if (!nbPoints) {
+    nbPoints = 2 ** Math.round(Math.log2(data.re.length * factor));
+  }
+
+  let pointsToShift;
+  if (grpdly > 0) {
+    pointsToShift = Math.floor(grpdly);
+  } else {
+    pointsToShift = 0;
+  }
+
+  const { re, im } = data;
+
+  let newRE = new Float64Array(nbPoints);
+  let newIM = new Float64Array(nbPoints);
+
+  const length = Math.min(nbPoints, re.length);
+
+  newRE.set(re.slice(0, length - pointsToShift));
+  newIM.set(im.slice(0, length - pointsToShift));
+
+  if (pointsToShift > 0 && pointsToShift < nbPoints) {
+    newRE.set(re.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+    newIM.set(im.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+  }
+
+  return { re: newRE, im: newIM };
+}