nmr-processing 9.5.0 → 9.5.1-pre.1684857934

package/src/filters/filter1d/apodization.ts

@@ -0,0 +1,90 @@
+import { apodization } from '../../apodization/apodization';
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'apodization';
+export const name = 'Apodization';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: false,
+};
+
+export interface ApodizationOptions {
+  lineBroadening: number;
+  gaussBroadening: number;
+  lineBroadeningCenter: number;
+}
+
+export const defaultApodizationOptions: ApodizationOptions = {
+  lineBroadening: 1,
+  gaussBroadening: 0,
+  lineBroadeningCenter: 0,
+};
+
+export function apply(datum1D: Entry1D, options: ApodizationOptions) {
+  const newData = apodizationFilter(datum1D, options);
+
+  datum1D.data = {
+    ...datum1D.data,
+    re: newData.re as Float64Array,
+    im: newData.im as Float64Array,
+  };
+}
+export function isApplicable(datum1D: Entry1D) {
+  if (datum1D.info.isComplex && datum1D.info.isFid) return true;
+  return false;
+}
+
+export function reduce(previousValue: any, newValue: any) {
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}
+
+export function apodizationFilter(
+  datum1D: Entry1D,
+  options: ApodizationOptions,
+) {
+  const { lineBroadening, gaussBroadening, lineBroadeningCenter } = options;
+  let grpdly = datum1D.info?.digitalFilter || 0;
+  let pointsToShift;
+  if (grpdly > 0) {
+    pointsToShift = Math.floor(grpdly);
+  } else {
+    pointsToShift = 0;
+  }
+
+  const re = datum1D.data.re;
+  const im = datum1D.data.im;
+  const t = datum1D.data.x;
+
+  const length = re.length;
+  const dw = (t[length - 1] - t[0]) / (length - 1); //REPLACE CONSTANT with calculated value... : for this we need AQ or DW to set it right...
+
+  return apodization(
+    { re, im },
+    {
+      pointsToShift,
+      compose: {
+        length,
+        shapes: [
+          {
+            start: 0,
+            shape: {
+              kind: 'lorentzToGauss',
+              options: {
+                length,
+                dw,
+                exponentialHz:
+                  gaussBroadening > 0 ? lineBroadening : -lineBroadening,
+                gaussianHz: gaussBroadening,
+                center: lineBroadeningCenter,
+              },
+            },
+          },
+        ],
+      },
+    },
+  );
+}

package/src/filters/filter1d/baselineCorrection.ts

@@ -0,0 +1,83 @@
+import airPLS from 'ml-airpls';
+import baselineRegression from 'ml-baseline-correction-regression';
+import { xyEquallySpaced } from 'ml-spectra-processing';
+
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'baselineCorrection';
+export const name = 'Baseline correction';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: false,
+  updateYDomain: true,
+};
+
+export type BaselineAlgorithms = 'airpls' | 'polynomial';
+
+export interface PolynomialOptions {
+  zones: Array<{ from: number; to: number; id: string }>;
+  algorithm: 'polynomial';
+  degree: number;
+}
+
+export interface AirplsOptions {
+  zones: Array<{ from: number; to: number; id: string }>;
+  algorithm: 'airpls';
+  maxIterations: number;
+  tolerance: number;
+}
+
+export type BaselineCorrectionOptions = PolynomialOptions | AirplsOptions;
+
+export function apply(datum1D: Entry1D, options: BaselineCorrectionOptions) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('baselineCorrection not applicable on this data');
+  }
+  const { algorithm } = options;
+  let { x, re } = datum1D.data;
+
+  let corrected;
+  switch (algorithm) {
+    case 'airpls':
+      corrected = airPLS(x, re, options).corrected;
+      break;
+    case 'polynomial':
+      {
+        const { degree, zones } = options;
+        let reduced = xyEquallySpaced(
+          { x, y: re },
+          { numberOfPoints: 4096, zones },
+        );
+        let result = baselineRegression(reduced.x, reduced.y, {
+          regressionOptions: degree,
+        });
+        let { regression } = result;
+        corrected = new Float64Array(x.length);
+        for (let i = 0; i < re.length; i++) {
+          corrected[i] = re[i] - regression.predict(x[i]);
+        }
+      }
+
+      break;
+    default:
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+      throw new Error(`baselineCorrection: algorithm unknown: ${algorithm}`);
+  }
+
+  Object.assign(datum1D.data, { re: corrected });
+}
+
+export function isApplicable(datum1D: Entry1D) {
+  if (!datum1D.info.isFid) return true;
+  return false;
+}
+
+export function reduce(
+  previousValue: BaselineCorrectionOptions,
+  newValue: BaselineCorrectionOptions,
+) {
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}

package/src/filters/filter1d/digitalFilter.ts

@@ -0,0 +1,51 @@
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'digitalFilter';
+export const name = 'Digital Filter';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+/**
+ * Move points from the beginning to the end of FID and performs a first order phase correction
+ * @param {Datum1d} datum1d
+ */
+
+export function apply(datum1D: Entry1D, options: any = {}) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('Digital Filter is not applicable on this data');
+  }
+
+  let { digitalFilterValue = 0 } = options;
+  let re = new Float64Array(datum1D.data.re);
+  let im = new Float64Array(datum1D.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);
+
+  datum1D.data.re = newRe;
+  datum1D.data.im = newIm;
+}
+
+export function isApplicable(datum1D: Entry1D) {
+  if (datum1D.info.isComplex && datum1D.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}

package/src/filters/filter1d/equallySpaced.ts

@@ -0,0 +1,61 @@
+import { xyEquallySpaced } from 'ml-spectra-processing';
+
+import { Entry1D } from '../Entry1D';
+
+export const id = 'equallySpaced';
+export const name = 'Equally spaced';
+
+/**
+ * Equally Spaced
+ * **
+ * Function that returns a Number array of equally spaced numberOfPoints
+ * containing a representation of intensities of the spectra arguments x
+ * and y.
+ *
+ * The options parameter contains an object in the following form:
+ * from: starting point
+ * to: last point
+ * numberOfPoints: number of points between from and to
+ * variant: "slot" or "smooth" - smooth is the default option
+ *
+ * The slot variant consist that each point in the new array is calculated
+ * averaging the existing points between the slot that belongs to the current
+ * value. The smooth variant is the same but takes the integral of the range
+ * of the slot and divide by the step size between two points in the new array.
+ *
+ * @param {Array<{from:number;to:number}>} options.exclusions
+ */
+
+export function apply(spectrum: Entry1D, options: any = {}) {
+  if (!isApplicable(spectrum)) {
+    throw new Error('Equally Spaced is not applicable on this data');
+  }
+  const { from, to, numberOfPoints, exclusions } = options;
+  const { x, re, im } = spectrum.data;
+  const XREdata = xyEquallySpaced(
+    { x, y: re },
+    { from, to, numberOfPoints, exclusions },
+  );
+
+  spectrum.data.x = XREdata.x;
+  spectrum.data.re = XREdata.y;
+  if (im) {
+    const XIMdata = xyEquallySpaced(
+      { x, y: re },
+      { from, to, numberOfPoints, exclusions },
+    );
+    spectrum.data.im = XIMdata.y;
+  }
+}
+
+export function isApplicable(spectrum: Entry1D) {
+  if (spectrum.info.isComplex && !spectrum.info.isFid) return true;
+  return false;
+}
+
+export function reduce() {
+  return {
+    once: false,
+    reduce: null,
+  };
+}

package/src/filters/filter1d/exclusionZones.ts

@@ -0,0 +1,34 @@
+import { xySetYValue, zonesNormalize } from 'ml-spectra-processing';
+
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'exclusionZones';
+export const name = 'Exclusion zones';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: false,
+  updateYDomain: false,
+};
+
+export function apply(spectrum: Entry1D, zones = []) {
+  if (!isApplicable(spectrum)) {
+    throw new Error('Exclusion Zones filter not applicable on this data');
+  }
+  const { x, re, im } = spectrum.data;
+  spectrum.data.re = Float64Array.from(xySetYValue({ x, y: re }, { zones }).y);
+  spectrum.data.im = im
+    ? Float64Array.from(xySetYValue({ x, y: re }, { zones }).y)
+    : im;
+}
+
+export function isApplicable(spectrum: Entry1D) {
+  if (spectrum.info.isFt) return true;
+  return false;
+}
+
+export function reduce(previousValue: any, newValue: any) {
+  return {
+    once: true,
+    reduce: zonesNormalize(previousValue.concat(newValue)),
+  };
+}

package/src/filters/filter1d/fft.ts

@@ -0,0 +1,135 @@
+import {
+  DataReIm,
+  reimFFT,
+  reimPhaseCorrection,
+  xMean,
+} from 'ml-spectra-processing';
+
+import { Data1D } from '../Data1D';
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+import { padDataToNextPowerOfTwo } from './utils/padDataToNextPowerOfTwo';
+
+export const id = 'fft';
+export const name = 'FFT';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(datum1D: Entry1D) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('fft not applicable on this data');
+  }
+
+  checkSameLength(datum1D);
+
+  let digitalFilterApplied = datum1D.filters.some(
+    (e) => e.name === 'digitalFilter' && e.flag,
+  );
+
+  const {
+    info: { aqMod },
+  } = datum1D;
+
+  if (aqMod === 1) {
+    removeDCOffset(datum1D, digitalFilterApplied);
+  }
+
+  if (!isPowerOfTwo(datum1D.data.x.length)) {
+    padDataToNextPowerOfTwo(datum1D, digitalFilterApplied);
+  }
+
+  const { data, info } = datum1D;
+  Object.assign(
+    data,
+    reimFFT(
+      {
+        re: data.re,
+        im: data.im,
+      },
+      { applyZeroShift: true },
+    ),
+  );
+
+  if (digitalFilterApplied) {
+    let { digitalFilter = 0 } = info;
+    let ph1 = (digitalFilter - Math.floor(digitalFilter)) * Math.PI * 2;
+    Object.assign(
+      data,
+      reimPhaseCorrection(data as DataReIm, 0, -ph1, { reverse: true }),
+    );
+  }
+
+  datum1D.data.x = generateXAxis(datum1D);
+  datum1D.info = { ...datum1D.info, isFid: false, isFt: true };
+}
+
+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() {
+  return {
+    once: true,
+    reduce: undefined,
+  };
+}
+
+function generateXAxis(datum1D: Entry1D) {
+  const info = datum1D.info;
+  const baseFrequency = Number.parseFloat(info.baseFrequency);
+  const frequencyOffset = Number.parseFloat(info.frequencyOffset);
+  const spectralWidth = Number.parseFloat(info.spectralWidth);
+  const offset = frequencyOffset / baseFrequency;
+  let spectralHalfWidth = 0.5 * spectralWidth;
+  let nbPoints = datum1D.data.x.length;
+  let firstPoint = offset - spectralHalfWidth;
+  let dx = spectralWidth / (nbPoints - 1);
+  const xAxis = new Float64Array(nbPoints);
+  for (let i = 0; i < nbPoints; i++) {
+    xAxis[i] = firstPoint;
+    firstPoint += dx;
+  }
+  return xAxis;
+}
+
+function isPowerOfTwo(n: number) {
+  return n !== 0 && (n & (n - 1)) === 0;
+}
+
+function removeDCOffset(spectrum: Entry1D, digitalFilterApplied: boolean) {
+  let { digitalFilter = 0 } = digitalFilterApplied ? spectrum.info : {};
+  const data = spectrum.data;
+  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 - digitalFilter),
+  );
+  const averageIm = xMean(
+    data.im.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilter),
+  );
+  for (
+    let i = digitalFilterApplied ? 0 : digitalFilter;
+    i < nbPoints - digitalFilter;
+    i++
+  ) {
+    newRe[i] -= averageRe;
+    newIm[i] -= averageIm;
+  }
+
+  Object.assign(spectrum.data, { re: newRe, im: newIm });
+  return spectrum;
+}
+
+function checkSameLength(spectrum: Entry1D) {
+  const { data } = spectrum;
+  if (data.x.length !== data.re.length || data.x.length !== data.im?.length) {
+    throw new Error('The length of data should be equal');
+  }
+}

package/src/filters/filter1d/phaseCorrection.ts

@@ -0,0 +1,118 @@
+import {
+  reimAbsolute,
+  reimAutoPhaseCorrection,
+  reimPhaseCorrection,
+} from 'ml-spectra-processing';
+
+import { Data1D } from '../Data1D';
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'phaseCorrection';
+export const name = 'Phase correction';
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: false,
+  updateYDomain: false,
+};
+export interface PhaseCorrectionParameters {
+  ph0: number;
+  ph1: number;
+  absolute: boolean;
+}
+
+/**
+ *
+ * @param {Datum1d} datum1d
+ * @param {Object} [options={}]
+ * @param {number} [options.ph0=0]
+ * @param {number} [options.ph1=0]
+ */
+
+export function apply(datum1D: Entry1D, options: any = {}) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('phaseCorrection not applicable on this data');
+  }
+
+  const { absolute = false } = options;
+  const filter = datum1D.filters?.find((filter) => filter.name === id);
+
+  if (absolute) {
+    const { re, im } = datum1D.data;
+    datum1D.data.re = reimAbsolute({ re, im });
+    datum1D.data.im = new Float64Array(0);
+    if (filter) {
+      filter.value = { ...filter.value, ph0: 0, ph1: 0, absolute };
+    }
+  } else if ('ph0' in options && 'ph1' in options) {
+    let { ph0, ph1 } = options;
+    phaseCorrection(datum1D, { ph0, ph1 });
+    if (filter) {
+      filter.value = { ...filter.value, absolute };
+    }
+  } else {
+    let { ph0, ph1 } = autoPhaseCorrection(datum1D);
+    phaseCorrection(datum1D, { ph0, ph1 });
+    if (filter) {
+      filter.value = { ...filter.value, absolute, ph0, ph1 };
+    }
+  }
+}
+
+function phaseCorrection(
+  spectrum: Entry1D,
+  phaseValues: { ph0: number; ph1: number },
+) {
+  let { ph0, ph1 } = phaseValues;
+  ph0 *= Math.PI / 180;
+  ph1 *= Math.PI / 180;
+  spectrum.data = {
+    ...spectrum.data,
+    ...reimPhaseCorrection(spectrum.data, ph0, ph1, { reverse: true }),
+  };
+}
+
+interface AutoPhaseCorrectionOptions {
+  minRegSize?: number;
+  maxDistanceToJoin?: number;
+  magnitudeMode?: boolean;
+  factorNoise?: number;
+  reverse?: boolean;
+}
+
+function autoPhaseCorrection(
+  spectrum: Entry1D,
+  options: AutoPhaseCorrectionOptions = {},
+) {
+  const {
+    minRegSize = 5,
+    maxDistanceToJoin = 128,
+    magnitudeMode = true,
+    factorNoise = 5,
+    reverse = true,
+  } = options;
+
+  return reimAutoPhaseCorrection(spectrum.data as any, {
+    minRegSize,
+    maxDistanceToJoin,
+    magnitudeMode,
+    factorNoise,
+    reverse,
+  });
+}
+
+export function isApplicable(
+  spectrum: Entry1D,
+): spectrum is Entry1D & { data: Required<Data1D> } {
+  if (spectrum.info.isComplex && !spectrum.info.isFid) return true;
+  return false;
+}
+
+export function reduce(
+  previousValue: PhaseCorrectionParameters,
+  newValue: PhaseCorrectionParameters,
+) {
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}

package/src/filters/filter1d/shiftX.ts

@@ -0,0 +1,31 @@
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+/**
+ *
+ * @param {Object} datum1d
+ * @param {number} [shiftValue=0]
+ */
+
+export const id = 'shiftX';
+export const name = 'Shift X';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: false,
+};
+
+export function apply(datum1D: Entry1D, shiftValue = 0) {
+  datum1D.data.x = datum1D.data.x.map((val) => val + shiftValue);
+}
+
+export function isApplicable() {
+  return true;
+}
+
+export function reduce(previousValue: number, newValue: number) {
+  return {
+    once: true,
+    reduce: previousValue + newValue,
+  };
+}

package/src/filters/filter1d/signalProcessing.ts

@@ -0,0 +1,79 @@
+import * as Filters from 'ml-signal-processing';
+
+import { MatrixOptions } from '../MatrixOptions';
+import { Entry1D } from '../Entry1D';
+import { FilterDomainUpdateRules } from '../FiltersManager';
+
+export const id = 'signalProcessing';
+export const name = 'Signal processing';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: true,
+};
+
+export function apply(spectrum: Entry1D, options: MatrixOptions) {
+  if (!isApplicable(spectrum)) {
+    throw new Error('Signal Processing is not applicable on this data');
+  }
+
+  spectrum.data = filterXY(spectrum, options);
+}
+export function isApplicable(spectrum: Entry1D) {
+  if (spectrum.info.isFt) return true;
+  return false;
+}
+
+export function reduce(previousValue: any, newValue: any) {
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}
+
+export function filterXY(spectrum: Entry1D, options: MatrixOptions) {
+  let x = spectrum.data.x.slice(0);
+  let cloneX = spectrum.data.x.slice(0);
+  let re = spectrum.data.re.slice(0);
+  let im = spectrum.data.im?.slice(0);
+
+  const filters = options.filters.slice();
+
+  const {
+    range: { from, to },
+    numberOfPoints,
+    exclusionsZones: exclusions,
+  } = options;
+
+  filters.push({
+    name: 'equallySpaced',
+    options: { from, to, numberOfPoints, exclusions },
+    properties: {},
+  });
+
+  for (const filter of filters) {
+    // eslint-disable-next-line import/namespace
+    const filterFunction = Filters[filter.name];
+    if (!filterFunction) {
+      throw new Error(`Unknown filter: ${filter.name}`);
+    }
+
+    const filterOptions = filter?.options || {};
+
+    // @ts-expect-error some method have options and some other ones don't have any options
+    const realResult = filterFunction({ x, y: re }, filterOptions);
+    x = realResult.data.x as Float64Array;
+    re = realResult.data.y as Float64Array;
+
+    if (im) {
+      const imaginaryResult = filterFunction(
+        { x: cloneX, y: im },
+        // @ts-expect-error some method have options and some other ones don't have any options
+        filterOptions,
+      );
+      im = imaginaryResult.data.y as Float64Array;
+    }
+  }
+
+  return { x, re, im };
+}