nmr-processing 9.5.1 → 9.5.2-pre.1685982544

package/src/datum/data1d/filter1d/phaseCorrection.ts

@@ -0,0 +1,127 @@
+import {
+  reimAbsolute,
+  reimAutoPhaseCorrection,
+  reimPhaseCorrection,
+  xEnsureFloat64,
+} from 'ml-spectra-processing';
+
+import { Data1D } from '../../../types/Data1D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+
+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 & { data: Required<Data1D> },
+  phaseValues: { ph0: number; ph1: number },
+) {
+  let { ph0, ph1 } = phaseValues;
+  const { re, im } = spectrum.data;
+  const phased = reimPhaseCorrection(
+    { re, im },
+    (ph0 * Math.PI) / 180,
+    (ph1 * Math.PI) / 180,
+    { reverse: true },
+  );
+  spectrum.data = {
+    ...spectrum.data,
+    ...{
+      re: xEnsureFloat64(phased.re),
+      im: xEnsureFloat64(phased.im),
+    },
+  };
+}
+
+export 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/datum/data1d/filter1d/shiftX.ts

@@ -0,0 +1,37 @@
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+
+/**
+ *
+ * @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,
+};
+
+interface ShiftXOptions {
+  shift?: number;
+}
+export function apply(spectrum: Entry1D, options: ShiftXOptions = {}) {
+  const { shift = 0 } = options;
+  spectrum.data.x = spectrum.data.x.map((val) => val + shift);
+}
+
+export function isApplicable() {
+  return true;
+}
+
+export function reduce(previous: ShiftXOptions, next: ShiftXOptions) {
+  const { shift: previousValue = 0 } = previous;
+  const { shift: nextShift = 0 } = next;
+  return {
+    once: true,
+    reduce: { shift: previousValue + nextShift },
+  };
+}

package/src/datum/data1d/filter1d/signalProcessing.ts

@@ -0,0 +1,79 @@
+import * as Filters from 'ml-signal-processing';
+
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { MatrixOptions } from '../../MatrixOptions';
+import { Entry1D } from '../Entry1D';
+
+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 };
+}

package/src/datum/data1d/filter1d/utils/padDataToNextPowerOfTwo.ts

@@ -0,0 +1,49 @@
+import { xSequentialFill } from 'ml-spectra-processing';
+
+import { Data1D } from '../../../../types/Data1D';
+import { Info1D } from '../../../../types/Info/Info1D';
+import { Entry1D } from '../../Entry1D';
+
+export function padDataToNextPowerOfTwo(
+  datum1D: Partial<Omit<Entry1D, 'info'>> & {
+    data: Required<Data1D>;
+    info: Partial<Info1D>;
+  },
+  digitalFilterApplied: boolean,
+) {
+  const { x, re, im } = datum1D.data;
+  const size = nextPowerOfTwo(x.length);
+
+  let newRE = new Float64Array(size);
+  let newIM = new Float64Array(size);
+
+  const grpdly = datum1D.info?.digitalFilter || 0;
+  const pointsToShift = grpdly > 0 ? Math.floor(grpdly) : 0;
+
+  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 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/datum/data1d/filter1d/zeroFilling.ts

@@ -0,0 +1,93 @@
+import { Data1D } from '../../../types/Data1D';
+import { Info1D } from '../../../types/Info/Info1D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+
+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;
+}
+
+type Entry1DZeroFilling = Partial<Omit<Entry1D, 'info'>> &
+  Required<Pick<Entry1D, 'data' | 'filters'>> & { info: Partial<Info1D> };
+
+export function apply(
+  datum1D: Entry1DZeroFilling,
+  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,
+  );
+
+  const grpdly = datum1D.info?.digitalFilter || 0;
+  const pointsToShift =
+    digitalFilterApplied && grpdly > 0 ? Math.floor(grpdly) : 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: Entry1DZeroFilling,
+): datum1D is Entry1DZeroFilling & { 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/datum/data1d/utils/RangeUtilities.ts

@@ -0,0 +1,102 @@
+import { v4 as generateID } from '@lukeed/uuid';
+import omit from 'lodash/omit';
+
+import { DatumKind } from '../../../constants/SignalsKinds';
+import { Range } from '../../../types/Ranges/Ranges';
+import { Signal1D } from '../../../types/Signals/Signal1D';
+
+export function getDiaIDs(range: Range): string[] {
+  return ([] as string[]).concat(
+    range.diaIDs || [],
+    range.signals
+      ? range.signals.flatMap((_signal) => _signal.diaIDs || [])
+      : [],
+  );
+}
+
+export function getNbAtoms(range: Range, signalIndex?: number): number {
+  if (signalIndex === undefined) {
+    let sum = 0;
+    if (range.signals) {
+      for (const signal of range.signals) {
+        sum += signal.nbAtoms || 0;
+      }
+    }
+    return sum;
+  }
+
+  return range.signals[signalIndex].nbAtoms || 0;
+}
+
+export function setNbAtoms(range: Range, signalIndex?: number): void {
+  range.nbAtoms = getNbAtoms(range, signalIndex);
+  if (range.nbAtoms === 0) {
+    delete range.nbAtoms;
+  }
+}
+
+export function resetDiaIDs(range: Range): void {
+  const deletedKeys = ['diaIDs', 'nbAtoms'];
+  range = omit(range, deletedKeys) as Range;
+  range.signals = range.signals.map((signal) => {
+    return omit(signal, deletedKeys) as Signal1D;
+  });
+}
+
+/**
+ *
+ * @param {object} range
+ * @param {String('both' | 'range' | 'signal')} unlinkType
+ * @param {object} options
+ * @param {number} [options.signalIndex]
+ * @returns {object}
+ */
+
+interface UnlinkOptions {
+  unlinkType?: 'both' | 'range' | 'signal';
+  signalIndex?: number;
+}
+export function unlink(range: Range, options: UnlinkOptions = {}): Range {
+  const { unlinkType = 'both', signalIndex = -1 } = options;
+  const keys = ['diaIDs', 'nbAtoms'];
+
+  switch (unlinkType) {
+    case 'both':
+      resetDiaIDs(range);
+      break;
+    case 'range':
+      range = omit(range, keys) as Range;
+      break;
+    case 'signal':
+      if (signalIndex !== -1) {
+        range.signals[signalIndex] = omit(
+          range.signals[signalIndex],
+          keys,
+        ) as Signal1D;
+      }
+      break;
+    default:
+      break;
+  }
+  return range;
+}
+
+export function addDefaultSignal(range: Range) {
+  range.signals.push({
+    id: generateID(),
+    multiplicity: 'm',
+    kind: 'signal',
+    js: [],
+    delta: (range.to + range.from) / 2,
+  });
+}
+
+export function checkRangeKind(range: Range) {
+  return range.kind === DatumKind.signal;
+}
+
+export function checkSignalKinds(range: Range, kinds: string[]) {
+  return !range.signals.some(
+    (_signal) => _signal.kind === undefined || !kinds.includes(_signal.kind),
+  );
+}

package/src/datum/data1d/utils/checkIntegralKind.ts

@@ -0,0 +1,11 @@
+import { SignalKindsToInclude } from '../../../constants/SignalsKinds';
+import { Integral } from '../../../types/Integral';
+
+/**
+ * check whether integral based on its kind can be included in another operation or not
+ * @param integral  integral
+ * @returns {boolean}
+ */
+export function checkIntegralKind(integral: Integral): boolean {
+  return SignalKindsToInclude.includes(integral.kind);
+}

package/src/datum/data1d/utils/checkRangeKind.ts

@@ -0,0 +1,8 @@
+import { SignalKindsToInclude } from '../../../constants/SignalsKinds';
+import { Range } from '../../../types/Ranges/Ranges';
+
+import { checkSignalKinds } from './RangeUtilities';
+
+export function checkRangeKind(range: Range): boolean {
+  return range.signals && checkSignalKinds(range, SignalKindsToInclude);
+}

package/src/datum/data1d/utils/getShiftX.ts

@@ -0,0 +1,10 @@
+import { Filters } from '../../Filters';
+import { Entry1D } from '../Entry1D';
+
+export function getShiftX(spectrum: Entry1D): number {
+  const filter =
+    spectrum?.filters &&
+    spectrum?.filters.find((filter) => filter.name === Filters.shiftX.id);
+
+  return filter?.flag ? filter.value.shift : 0;
+}

package/src/datum/data1d/utils/getSpectrumErrorValue.ts

@@ -0,0 +1,6 @@
+import { Entry1D } from '../Entry1D';
+
+export function getSpectrumErrorValue(spectrum: Entry1D) {
+  const { x } = spectrum.data;
+  return (x[x.length - 1] - x[0]) / 10000;
+}

package/src/datum/data1d/utils/mapIntegrals.ts

@@ -0,0 +1,52 @@
+import { v4 } from '@lukeed/uuid';
+import { xyIntegration } from 'ml-spectra-processing';
+
+import { Integral } from '../../../types/Integral';
+import { ShiftTarget } from '../../../types/common/MapOptions';
+import { Entry1D } from '../Entry1D';
+
+import { getShiftX } from './getShiftX';
+
+function getRange(integral: Integral, shiftTarget: ShiftTarget, shift: number) {
+  const { originFrom, originTo, from, to } = integral;
+  if (shiftTarget === 'origin') {
+    return {
+      originFrom: from - shift,
+      originTo: to - shift,
+      from,
+      to,
+    };
+  } else {
+    return {
+      originFrom,
+      originTo,
+      from: originFrom + shift,
+      to: originTo + shift,
+    };
+  }
+}
+
+export function mapIntegrals(
+  integrals: Integral[],
+  spectrum: Entry1D,
+  shiftTarget: ShiftTarget = 'origin',
+) {
+  const { x, re } = spectrum.data;
+  const shiftX = getShiftX(spectrum);
+
+  return integrals.map((integral) => {
+    const integralBoundary = getRange(integral, shiftTarget, shiftX);
+
+    const absolute = xyIntegration(
+      { x, y: re },
+      { from: integralBoundary.from, to: integralBoundary.to, reverse: true },
+    );
+
+    return {
+      ...integral,
+      id: integral.id || v4(),
+      ...integralBoundary,
+      absolute,
+    };
+  });
+}

package/src/datum/data1d/utils/mapPeaks.ts

@@ -0,0 +1,62 @@
+import { v4 } from '@lukeed/uuid';
+
+import { Peak1D } from '../../../types/Peaks/Peak1D';
+import { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+import { Entry1D } from '../Entry1D';
+
+import { getShiftX } from './getShiftX';
+import { getSpectrumErrorValue } from './getSpectrumErrorValue';
+
+function isExists(peak: Peak1D, spectrum: Entry1D, error: number) {
+  // check if the Peak is already exists
+  for (const { x } of spectrum.peaks?.values || []) {
+    if (Math.abs(peak.x - x) < error) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function getPeakDelta(peak: Peak1D, shiftTarget: ShiftTarget, shift: number) {
+  const { originalX = 0, x } = peak;
+  if (shiftTarget === 'origin') {
+    return {
+      originalX: x - shift,
+      x,
+    };
+  } else {
+    return {
+      originalX,
+      x: originalX + shift,
+    };
+  }
+}
+
+export function mapPeaks(
+  peaks: Peak1D[],
+  spectrum: Entry1D,
+  options: MapOptions = {},
+) {
+  const { checkIsExisting = true, shiftTarget = 'origin' } = options;
+  const shiftX = getShiftX(spectrum);
+  const error = getSpectrumErrorValue(spectrum);
+
+  let newPeaks: Peak1D[] = [];
+
+  for (const peak of peaks) {
+    const peakDelta = getPeakDelta(peak, shiftTarget, shiftX);
+
+    if (
+      !checkIsExisting ||
+      (checkIsExisting && !isExists(peak, spectrum, error))
+    ) {
+      newPeaks.push({
+        ...peak,
+        id: peak?.id || v4(),
+        ...peakDelta,
+      });
+    }
+  }
+
+  return newPeaks;
+}