nmr-processing 9.5.0 → 9.5.1-pre.1685396168

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

@@ -0,0 +1,90 @@
+import { Data1D } from '../../../types/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/datum/data1d/updateRelatives.ts

@@ -0,0 +1,50 @@
+import { Integral } from '../../types/Integral';
+import { Integrals } from '../../types/Integrals';
+import { Range, Ranges } from '../../types/Ranges/Ranges';
+import { getSum } from '../../utilities/getSum';
+
+export function updateRelatives<Data extends Integral | Range>(
+  data: Data extends Integral ? Integrals : Ranges,
+  key: keyof Extract<Data, string>,
+  check: (value: any) => boolean,
+  forceCalculateIntegral = false,
+): void {
+  const { values, options } = data;
+
+  const currentSum = getSum(values, 'absolute', check);
+
+  let factor = 0;
+  if (options?.sum) {
+    if (options.isSumConstant || forceCalculateIntegral) {
+      factor = currentSum > 0 ? options.sum / currentSum : 0;
+    } else if (values?.[0]) {
+      const item = values[0];
+      //@ts-expect-error should works well
+      factor = (item[key as string] || options.sum) / item.absolute;
+    }
+  }
+
+  data.values = mapValues(values, factor, check) as Data extends Integral
+    ? Integral[]
+    : Range[];
+
+  if (!options.isSumConstant && !forceCalculateIntegral) {
+    options.sum = getSum(values, key as string, check);
+  }
+}
+
+function mapValues<T extends Integral[] | Range[]>(
+  values: T,
+  factor: number,
+  check: (value: any) => boolean,
+) {
+  return values.map((value) => {
+    return {
+      ...value,
+      ...(check(value) && {
+        //@ts-expect-error should works well
+        [key as string]: value.absolute * factor,
+      }),
+    };
+  });
+}

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 { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { Filters } from '../../Filters';
+
+export function getShiftX(spectrum: Spectrum1D): 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 { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+
+export function getSpectrumErrorValue(spectrum: Spectrum1D) {
+  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 { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { ShiftTarget } from '../../../types/common/MapOptions';
+
+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: Spectrum1D,
+  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 { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+
+import { getShiftX } from './getShiftX';
+import { getSpectrumErrorValue } from './getSpectrumErrorValue';
+
+function isExists(peak: Peak1D, spectrum: Spectrum1D, 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: Spectrum1D,
+  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;
+}

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

@@ -0,0 +1,107 @@
+import { v4 } from '@lukeed/uuid';
+import { xyIntegration } from 'ml-spectra-processing';
+
+import { DatumKind } from '../../../constants/SignalsKinds';
+import { Range } from '../../../types/Ranges/Ranges';
+import { Signal1D } from '../../../types/Signals/Signal1D';
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+
+import { getShiftX } from './getShiftX';
+import { getSpectrumErrorValue } from './getSpectrumErrorValue';
+
+function checkRange(range: Range, spectrum: Spectrum1D, error: number) {
+  // check if the range is already exists
+  for (const { from, to } of spectrum.ranges?.values || []) {
+    if (
+      Math.abs(range.from - from) < error &&
+      Math.abs(range.to - to) < error
+    ) {
+      return true;
+    }
+  }
+}
+
+function getRange(
+  range: Range,
+  shiftTarget: 'origin' | 'current',
+  shift: number,
+) {
+  const { originFrom, originTo, from, to } = range;
+  if (shiftTarget === 'origin') {
+    return {
+      originFrom: from - shift,
+      originTo: to - shift,
+      from,
+      to,
+    };
+  } else {
+    return {
+      originFrom,
+      originTo,
+      from: (originFrom || 0) + shift,
+      to: (originTo || 0) + shift,
+    };
+  }
+}
+function getSignalDelta(
+  signal: Signal1D,
+  shiftTarget: ShiftTarget,
+  shift: number,
+) {
+  const { delta, originDelta } = signal;
+  if (shiftTarget === 'origin') {
+    return {
+      originDelta: delta - shift,
+      delta,
+    };
+  } else {
+    return {
+      originDelta,
+      delta: (originDelta || 0) + shift,
+    };
+  }
+}
+
+export function mapRanges(
+  ranges: Range[],
+  spectrum: Spectrum1D,
+  options: MapOptions = {},
+) {
+  const { checkIsExisting = true, shiftTarget = 'origin' } = options;
+  const { x, re } = spectrum.data;
+  const shiftX = getShiftX(spectrum);
+  const error = getSpectrumErrorValue(spectrum);
+
+  if (checkIsExisting) {
+    ranges = ranges.filter(
+      (r) =>
+        (checkIsExisting && !checkRange(r, spectrum, error)) || r.id === 'new',
+    );
+  }
+  return ranges.map((range) => {
+    const rangeBoundary = getRange(range, shiftTarget, shiftX);
+
+    const absolute = xyIntegration(
+      { x, y: re },
+      { from: rangeBoundary.from, to: rangeBoundary.to, reverse: true },
+    );
+    const signals = range.signals.map((signal) => {
+      const { kind = null, id, ...resSignal } = signal;
+      return {
+        kind: kind || 'signal',
+        id: id || v4(),
+        ...resSignal,
+        ...getSignalDelta(signal, shiftTarget, shiftX),
+      };
+    });
+    return {
+      ...range,
+      id: range.id || v4(),
+      kind: signals?.[0].kind || DatumKind.signal,
+      ...rangeBoundary,
+      absolute,
+      signals,
+    };
+  });
+}

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

@@ -0,0 +1,13 @@
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+
+import { mapIntegrals } from './mapIntegrals';
+import { updateIntegralsRelativeValues } from './updateIntegralsRelativeValues';
+
+export function updateIntegrals(spectrum: Spectrum1D) {
+  spectrum.integrals.values = mapIntegrals(
+    spectrum.integrals.values,
+    spectrum,
+    'current',
+  );
+  updateIntegralsRelativeValues(spectrum, true);
+}

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

@@ -0,0 +1,17 @@
+import { Integral } from '../../../types/Integral';
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { updateRelatives } from '../updateRelatives';
+
+import { checkIntegralKind } from './checkIntegralKind';
+
+export function updateIntegralsRelativeValues(
+  spectrum: Spectrum1D,
+  forceCalculateIntegral = false,
+) {
+  updateRelatives<Integral>(
+    spectrum.integrals,
+    'integral',
+    checkIntegralKind,
+    forceCalculateIntegral,
+  );
+}

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

@@ -0,0 +1,10 @@
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+
+import { mapPeaks } from './mapPeaks';
+
+export function updatePeaks(spectrum: Spectrum1D) {
+  spectrum.peaks.values = mapPeaks(spectrum.peaks.values, spectrum, {
+    checkIsExisting: false,
+    shiftTarget: 'current',
+  });
+}

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

@@ -0,0 +1,12 @@
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+
+import { mapRanges } from './mapRanges';
+import { updateRangesRelativeValues } from './updateRangesRelativeValues';
+
+export function updateRanges(spectrum: Spectrum1D) {
+  spectrum.ranges.values = mapRanges(spectrum.ranges.values, spectrum, {
+    checkIsExisting: false,
+    shiftTarget: 'current',
+  });
+  updateRangesRelativeValues(spectrum, true);
+}

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

@@ -0,0 +1,16 @@
+import { Spectrum1D } from '../../../types/Spectrum/Spectrum1D';
+import { updateRelatives } from '../updateRelatives';
+
+import { checkRangeKind } from './checkRangeKind';
+
+export function updateRangesRelativeValues(
+  spectrum: Spectrum1D,
+  forceCalculateIntegral = false,
+) {
+  updateRelatives(
+    spectrum.ranges,
+    'integration',
+    checkRangeKind,
+    forceCalculateIntegral,
+  );
+}

package/src/datum/data2d/filter2d/shiftX.ts

@@ -0,0 +1,37 @@
+import { MinMaxContent } from 'cheminfo-types';
+
+import { Entry2D } from '../../../xyz/Entry2D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+
+export const id = 'shift2DX';
+export const name = 'Shift 2D X';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: true,
+  updateYDomain: false,
+};
+
+/**
+ *
+ * @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/datum/data2d/filter2d/shiftY.ts

@@ -0,0 +1,36 @@
+import { MinMaxContent } from 'cheminfo-types';
+
+import { Entry2D } from '../../../xyz/Entry2D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+
+export const id = 'shift2DY';
+export const name = 'Shift 2D Y';
+
+export const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules> = {
+  updateXDomain: false,
+  updateYDomain: true,
+};
+
+/**
+ *
+ * @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/datum/data2d/utils/get2DSpectrumErrorValue.ts

@@ -0,0 +1,18 @@
+import { Data2DFid, Data2DFt } from 'cheminfo-types';
+
+import { Spectrum2D } from '../../../types/Spectrum/Spectrum2D';
+
+export interface Zone2DError {
+  x: number;
+  y: number;
+}
+
+export function get2DSpectrumErrorValue(spectrum: Spectrum2D): Zone2DError {
+  const { data, info } = spectrum;
+  const { minX, maxX, minY, maxY } = info.isFid
+    ? (data as Data2DFid).re
+    : (data as Data2DFt).rr;
+  const x = Math.abs(maxX - minX) / 10000;
+  const y = Math.abs(maxY - minY) / 10000;
+  return { x, y };
+}