nmr-processing 9.5.1 → 9.5.2-pre.1685982544

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 { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+import { Entry1D } from '../Entry1D';
+
+import { getShiftX } from './getShiftX';
+import { getSpectrumErrorValue } from './getSpectrumErrorValue';
+
+function checkRange(range: Range, spectrum: Entry1D, 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: Entry1D,
+  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/mapValues.ts

@@ -0,0 +1,18 @@
+import { Integral } from '../../../types/Integral';
+import { Range } from '../../../types/Ranges/Ranges';
+
+export function mapValues<T extends Integral[] | Range[]>(
+  values: T,
+  key: string,
+  factor: number,
+  check: (value: any) => boolean,
+) {
+  return values.map((value) => {
+    return {
+      ...value,
+      ...(check(value) && {
+        [key]: value.absolute * factor,
+      }),
+    };
+  });
+}

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

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

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

@@ -0,0 +1,36 @@
+import { Integral } from '../../../types/Integral';
+import { getSum } from '../../../utilities/getSum';
+import { Entry1D } from '../Entry1D';
+
+import { checkIntegralKind } from './checkIntegralKind';
+import { mapValues } from './mapValues';
+
+export function updateIntegralsRelativeValues(
+  spectrum: Entry1D,
+  forceCalculateIntegral = false,
+) {
+  const { values, options } = spectrum.integrals;
+
+  const currentSum = getSum(values, 'absolute', checkIntegralKind);
+
+  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];
+      factor = (item.integral || options.sum) / item.absolute;
+    }
+  }
+
+  spectrum.integrals.values = mapValues(
+    values,
+    'integral',
+    factor,
+    checkIntegralKind,
+  ) as Integral[];
+
+  if (!options.isSumConstant && !forceCalculateIntegral) {
+    options.sum = getSum(values, 'integral', checkIntegralKind);
+  }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { Entry1D } from '../Entry1D';
+
+import { mapRanges } from './mapRanges';
+import { updateRangesRelativeValues } from './updateRangesRelativeValues';
+
+export function updateRanges(spectrum: Entry1D) {
+  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,36 @@
+import { Range } from '../../../types/Ranges/Ranges';
+import { getSum } from '../../../utilities/getSum';
+import { Entry1D } from '../Entry1D';
+
+import { checkRangeKind } from './checkRangeKind';
+import { mapValues } from './mapValues';
+
+export function updateRangesRelativeValues(
+  spectrum: Entry1D,
+  forceCalculateIntegral = false,
+) {
+  const { values, options } = spectrum.ranges;
+
+  const currentSum = getSum(values, 'absolute', checkRangeKind);
+
+  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];
+      factor = (item.integration || options.sum) / item.absolute;
+    }
+  }
+
+  spectrum.ranges.values = mapValues(
+    values,
+    'integration',
+    factor,
+    checkRangeKind,
+  ) as Range[];
+
+  if (!options.isSumConstant && !forceCalculateIntegral) {
+    options.sum = getSum(values, 'integration', checkRangeKind);
+  }
+}

package/src/datum/data2d/Entry2D.ts

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

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

@@ -0,0 +1,37 @@
+import { MinMaxContent } from 'cheminfo-types';
+
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+
+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 { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry2D } from '../Entry2D';
+
+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 { Entry2D } from '../Entry2D';
+
+export interface Zone2DError {
+  x: number;
+  y: number;
+}
+
+export function get2DSpectrumErrorValue(spectrum: Entry2D): 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 };
+}

package/src/datum/data2d/utils/getShift.ts

@@ -0,0 +1,23 @@
+import { Filters } from '../../Filters';
+import { Entry2D } from '../Entry2D';
+
+export interface Shift2D {
+  x: number;
+  y: number;
+}
+
+export function getShift(spectrum: Entry2D): Shift2D {
+  let shift = { x: 0, y: 0 };
+  if (spectrum?.filters) {
+    for (const filter of spectrum.filters) {
+      if (filter.name === Filters.shift2DX.id) {
+        shift.x = filter?.flag ? filter.value.shift : 0;
+      }
+      if (filter.name === Filters.shift2DY.id) {
+        shift.y = filter?.flag ? filter.value.shift : 0;
+      }
+    }
+  }
+
+  return shift;
+}

package/src/datum/data2d/utils/isZoneExists.ts

@@ -0,0 +1,27 @@
+import { Zone } from '../../../types/Zones/Zone';
+import { Entry2D } from '../Entry2D';
+
+import { Zone2DError } from './get2DSpectrumErrorValue';
+
+export function isZoneExists(
+  zone: Zone,
+  spectrum: Entry2D,
+  error: Zone2DError,
+) {
+  const newXRange = zone.x || { from: 0, to: 0 };
+  const newYRange = zone.y || { from: 0, to: 0 };
+
+  if (!spectrum.zones?.values) return false;
+
+  for (const { x, y } of spectrum.zones.values) {
+    if (
+      Math.abs(newXRange.from - x.from) < error.x &&
+      Math.abs(newXRange.to - x.to) < error.x &&
+      Math.abs(newYRange.from - y.from) < error.y &&
+      Math.abs(newYRange.to - y.to) < error.y
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/datum/data2d/utils/mapZones.ts

@@ -0,0 +1,80 @@
+import { v4 } from '@lukeed/uuid';
+
+import { DatumKind } from '../../../constants/SignalsKinds';
+import { Signal2D } from '../../../types/Signals/Signal2D';
+import { Zone } from '../../../types/Zones/Zone';
+import { MapOptions, ShiftTarget } from '../../../types/common/MapOptions';
+import { Entry2D } from '../Entry2D';
+
+import { get2DSpectrumErrorValue } from './get2DSpectrumErrorValue';
+import { getShift, Shift2D } from './getShift';
+import { isZoneExists } from './isZoneExists';
+
+function getSignal(signal: Signal2D, shiftTarget: ShiftTarget, shift: Shift2D) {
+  const { x, y } = signal;
+
+  if (shiftTarget === 'origin') {
+    return {
+      ...signal,
+      x: {
+        ...x,
+        originDelta: x.delta - shift.x,
+      },
+      y: {
+        ...y,
+        originDelta: y.delta - shift.y,
+      },
+    };
+  } else {
+    return {
+      ...signal,
+      x: {
+        ...x,
+        delta: x.originDelta + shift.x,
+      },
+      y: {
+        ...y,
+        delta: y.originDelta + shift.y,
+      },
+    };
+  }
+}
+
+export function mapZones(
+  zones: Zone[],
+  datum: Entry2D,
+  options: MapOptions = {},
+) {
+  const { checkIsExisting = true, shiftTarget = 'origin' } = options;
+  const shift = getShift(datum);
+  const error = get2DSpectrumErrorValue(datum);
+
+  let _zones: Zone[] = zones;
+
+  if (checkIsExisting) {
+    _zones = zones.filter((zone) => !isZoneExists(zone, datum, error));
+  }
+
+  return _zones.map((zone: Zone) => {
+    const x = zone.x || { from: 0, to: 0 };
+    const y = zone.y || { from: 0, to: 0 };
+
+    const signals = zone.signals.map((signal) => {
+      const { id, kind } = signal;
+      return {
+        ...getSignal(signal, shiftTarget, shift),
+        id: id || v4(),
+        kind: kind || 'signal',
+      };
+    });
+
+    return {
+      ...zone,
+      id: zone.id || v4(),
+      x: { from: x.from, to: x.to },
+      y: { from: y.from, to: y.to },
+      signals,
+      kind: zone.kind || DatumKind.signal,
+    };
+  });
+}

package/src/datum/data2d/utils/updateZones.ts

@@ -0,0 +1,10 @@
+import { Entry2D } from '../Entry2D';
+
+import { mapZones } from './mapZones';
+
+export function updateZones(spectrum: Entry2D) {
+  spectrum.zones.values = mapZones(spectrum.zones.values, spectrum, {
+    checkIsExisting: false,
+    shiftTarget: 'current',
+  });
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from 'gyromagnetic-ratio';
 export * from './constants/impurities';
+export * from './constants/SignalsKinds';
 export * from './constants/couplingPatterns';
 
 export * from './peaks/peaksFilterImpurities';
@@ -40,6 +41,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,8 +60,38 @@ export * from './multiplicity/checkMultiplet';
 export * from './multiplicity/checkMultiplicity';
 export * from './multiplicity/translateMultiplet';
 
+export * from './datum/Filters';
+export * as FiltersManager from './datum/FiltersManager';
+export * from './datum/data1d/utils/getShiftX';
+export * from './datum/data1d/utils/getSpectrumErrorValue';
+export * from './datum/data1d/utils/mapPeaks';
+export * from './datum/data1d/utils/mapRanges';
+export * from './datum/data1d/utils/updateRanges';
+export * from './datum/data1d/utils/checkIntegralKind';
+export * from './datum/data1d/utils/updateRangesRelativeValues';
+export * from './datum/data1d/utils/updateIntegralsRelativeValues';
+export * as RangeUtilities from './datum/data1d/utils/RangeUtilities';
+
+export type { BaseFilter, Filter } from './types/Filter';
+
 export type { NMRSignal1D } from './signals/NMRSignal1D';
 export type { NMRSignal2D, Signal2DProjection } from './xyz/NMRSignal2D';
+export type { Peaks } from './types/Peaks/Peaks';
+export type { Peak1D } from './types/Peaks/Peak1D';
+export type { Peak2D } from './types/Peaks/Peak2D';
+export type { Signal1D } from './types/Signals/Signal1D';
+export type { Signal2D } from './types/Signals/Signal2D';
+export type { Range, Ranges } from './types/Ranges/Ranges';
+export type { Zone } from './types/Zones/Zone';
+export type { Zones } from './types/Zones/Zones';
+export type { Data1D } from './types/Data1D';
+export type { Data2D } from './types/Data2D';
+export type { Info1D } from './types/Info/Info1D';
+export type { Info2D } from './types/Info/Info2D';
+export type { Integral } from './types/Integral';
+export type { Integrals } from './types/Integrals';
+export type { SumOptions } from './types/Options/SumOptions';
+
 export type { NMRRange } from './xy/NMRRange';
 export type { NMRZone } from './xyz/NMRZone';
 export type { NMRPeak1D } from './peaks/NMRPeak1D';

package/src/signal/signalJoinCouplings.ts

@@ -1,4 +1,4 @@
-import sum from 'ml-array-sum';
+import { xSum } from 'ml-spectra-processing';
 
 import { joinPatterns } from '../multiplicity/joinPatterns';
 import type { Jcoupling } from '../signals/Jcoupling';
@@ -94,7 +94,7 @@ function groupJCouplings(
 
   signal.js = [];
   for (let group of groups) {
-    let coupling = sum(group.map((group) => group.coupling)) / group.length;
+    let coupling = xSum(group.map((group) => group.coupling)) / group.length;
     let atoms = distinctValues(
       group
         .filter((group) => group.atoms)

package/src/signals/signalsJoin.ts

@@ -1,6 +1,5 @@
 import { v4 as generateID } from '@lukeed/uuid';
-import mean from 'ml-array-mean';
-import sum from 'ml-array-sum';
+import { xSum, xMean } from 'ml-spectra-processing';
 
 import { signalJoinCouplings } from '../signal/signalJoinCouplings';
 import type { SignalJoinCouplingsOptions } from '../signal/signalJoinCouplings';
@@ -90,13 +89,13 @@ export function signalsJoin(
         diaIDs: coupling.diaIDs,
         pathLength: coupling.pathLength,
         multiplicity: coupling.multiplicity,
-        coupling: mean(group.map((item) => item.js[i].coupling)),
+        coupling: xMean(group.map((item) => item.js[i].coupling)),
       });
     }
     let signal: Signal1DWidthJsAndDiaID = {
       id: generateID(),
-      nbAtoms: sum(group.map((item) => item.nbAtoms || 0)),
-      delta: mean(group.map((item) => item.delta)),
+      nbAtoms: xSum(group.map((item) => item.nbAtoms || 0)),
+      delta: xMean(group.map((item) => item.delta)),
       diaIDs: group[0].diaIDs,
       atoms: group.map((item) => item.atoms || []).flat(),
       js,

package/src/signals/signalsToRanges.ts

@@ -56,7 +56,7 @@ export function signalsToRanges(
 
   wrapped = wrapped.sort((signal1, signal2) => signal1.from - signal2.from);
 
-  let ranges = [];
+  let ranges: RangeFullfiled[] = [];
   let range = {} as RangeFullfiled;
   for (let signal of wrapped) {
     if (range.from === undefined || signal.from > range.to) {

package/src/signals/signalsToXY.ts

@@ -1,6 +1,5 @@
-import rescale from 'ml-array-rescale';
 import type { Shape1D } from 'ml-peak-shape-generator';
-import { xSequentialFill } from 'ml-spectra-processing';
+import { xSequentialFill, xRescale } from 'ml-spectra-processing';
 
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
@@ -113,7 +112,7 @@ export function signalsToXY(
   });
 
   if (maxValue) {
-    spectrum.y = rescale(spectrum.y, { max: maxValue });
+    spectrum.y = xRescale(spectrum.y, { max: maxValue });
   }
 
   return spectrum;

package/src/signals/simulation/simulateXYPeaks.ts

@@ -68,7 +68,7 @@ export function simulateXYPeaks(
 
   const multiplicity = spinSystem.multiplicity;
 
-  const xyPeaks = [];
+  const xyPeaks: Array<{ x: number; y: number }> = [];
   for (const cluster of spinSystem.clusters) {
     let clusterFake = cluster.map((cluster) =>
       cluster < 0 ? -cluster - 1 : cluster,