nmr-processing 9.3.8-pre.1681135907 → 9.4.0

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

@@ -1,123 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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 };
-}

package/src/xyz/xyzBidimensionalFFT.ts

@@ -1,123 +0,0 @@
-import { DoubleArray } from 'cheminfo-types';
-import Matrix from 'ml-matrix';
-
-import { ApodizationOptions } from '../apodization/apodization';
-import { Data2D, Data2DFid } from './Data2D';
-
-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],
-  };
-}