nmr-processing 9.5.0 → 9.5.1-pre.1685396168

package/src/apodization/apodization.ts

@@ -10,23 +10,27 @@ export interface DataReIm {
   im: DoubleArray;
 }
 
-interface ApodizationOptions {
+export interface ApodizationFilterOptions {
   /**
    * number of points at the end of the shape to apply the window function inverted
    * @default 0
    */
   pointsToShift?: number;
-  compose: ShapeOptions;
+  compose?: ShapeOptions;
 }
-export function apodization(data: DataReIm, options: ApodizationOptions) {
+export function apodization(data: DataReIm, options: ApodizationFilterOptions = {}) {
   const { compose: composeOptions, pointsToShift } = options;
+
+  if (!composeOptions) {
+    return { ...data, windowData: new Float64Array(data.re.length).fill(1) };
+  }
+
   const windowData = compose(composeOptions);
 
   const applyWindowOptions = {
     windowData,
     pointsToShift,
   };
-
   const re = applyWindow(data.re, applyWindowOptions);
   const im = applyWindow(data.im, applyWindowOptions);
 

package/src/apodization/applyWindow.ts

@@ -42,7 +42,6 @@ export function applyWindow(data: DoubleArray, options: ApplyWindowOptions) {
   for (let i = start, j = 0; i < firstEndPoint; i++) {
     output[i] *= windowData[j++];
   }
-
   for (let i = dataLength - 1, j = 0; i > dataLength - pointsToShift - 1; i--) {
     output[i] *= windowData[j++];
   }

package/src/apodization/compose.ts

@@ -36,6 +36,7 @@ export function compose(shapeOptions: ShapeOptions) {
       'length' in shapeOptions ? shapeOptions.length : dataLength - start;
 
     const windowData = getData(getFunction(shape), length);
+
     applyWindow(data, {
       windowData,
       length,

package/src/apodization/getFunction.ts

@@ -1,6 +1,7 @@
 import type { WindowFunctions } from './shapes/WindowFunctions';
 import { exponential } from './shapes/exponential';
 import { lorentzToGauss } from './shapes/lorentzToGauss';
+import { sineBell } from './shapes/sineBell';
 
 export function getFunction(shape: WindowFunctions) {
   const { kind, options } = shape;
@@ -9,6 +10,8 @@ export function getFunction(shape: WindowFunctions) {
       return exponential(options);
     case 'lorentzToGauss':
       return lorentzToGauss(options);
+    case 'sineBell':
+      return sineBell(options);
     default:
       throw Error(`Unknown distribution ${kind as string}`);
   }

package/src/apodization/shapes/WindowFunctions.ts

@@ -1,5 +1,6 @@
 import type { ExponentialOptions } from './exponential';
 import type { LorentzToGaussOptions } from './lorentzToGauss';
+import { SineBellOptions } from './sineBell';
 
 interface Exponential {
   kind: 'exponential';
@@ -11,4 +12,9 @@ interface LorentToGauss {
   options: LorentzToGaussOptions;
 }
 
-export type WindowFunctions = Exponential | LorentToGauss;
+interface SineBell {
+  kind: 'sineBell';
+  options: SineBellOptions;
+}
+
+export type WindowFunctions = Exponential | LorentToGauss | SineBell;

package/src/apodization/shapes/sineBell.ts

@@ -0,0 +1,41 @@
+export interface SineBellOptions {
+  /**
+   * Specifies the exponent of the sine-bell; Non-integer values are allowed.
+   * Common values are 1.0 (for ordinary sine-bell) and 2.0 (for squared-bell functions).
+   * @default 1
+   */
+  exponent?: number;
+  /**
+   * Specifies the starting point of the sine-bell in units of pi radians.
+   * Common values are 0.0 (for a sine window which starts height at 0.0) and
+   * 0.5 (for a cosine window, which starts at height 1.0).
+   * @default 0
+   */
+  offset?: number;
+  /**
+   * Specifies the ending point of the sine-bell in units of pi radians.
+   * Common values are 1.0 (for a window which goes to 0.0 height at the last point) and
+   * 0.95 (for a window which doesn't go all the way to 0.0).
+   * @default 1
+   */
+  end?: number;
+  /**
+   * Specifies the number of points in the window function.
+   */
+  length: number;
+}
+
+export function sineBell(options: SineBellOptions) {
+  const { exponent = 1, offset = 0, end = 1, length } = options;
+
+  if (length === undefined) {
+    throw new Error('length options should exists for sineBell shape');
+  }
+
+  if (end < 0 || end > 1) {
+    throw new Error(`the end parameter should be [0-1]`);
+  }
+  const c1 = Math.PI * offset;
+  const c2 = (Math.PI * (end - offset)) / (length - 1);
+  return (i: number) => Math.pow(Math.sin(c1 + c2 * i), exponent);
+}

package/src/apodization/utils/getData.ts

@@ -9,7 +9,6 @@ export function getData(func: (i: number) => number, length: number) {
     data[i] = value;
     if (value > max) max = value;
   }
-
   for (let i = 0; i < length; i++) data[i] /= max;
   return data;
 }

package/src/constants/SignalsKinds.ts

@@ -0,0 +1,37 @@
+export const SignalKinds: { label: string; value: string }[] = [
+  {
+    label: 'Signal',
+    value: 'signal',
+  },
+  {
+    label: 'Reference',
+    value: 'reference',
+  },
+  {
+    label: 'Solvent',
+    value: 'solvent',
+  },
+  {
+    label: 'Impurity',
+    value: 'impurity',
+  },
+  {
+    label: 'Standard',
+    value: 'standard',
+  },
+  {
+    label: 'P1',
+    value: 'p1',
+  },
+  {
+    label: 'P2',
+    value: 'p2',
+  },
+  {
+    label: 'P3',
+    value: 'p3',
+  },
+];
+
+export const SignalKindsToInclude = ['signal'];
+export const DatumKind = { signal: 'signal', mixed: 'mixed' };

package/src/datum/Entry1D.ts

@@ -0,0 +1,11 @@
+import { Data1D } from '../types/Data1D';
+import { Filter } from '../types/Filter';
+
+export interface Entry1D {
+  id?: string;
+  info: Record<string, any>;
+  originalInfo?: Record<string, any>;
+  data: Data1D;
+  originalData?: Data1D;
+  filters: Array<Filter>;
+}

package/src/datum/ExclusionZone.ts

@@ -0,0 +1,5 @@
+export interface ExclusionZone {
+  id: string;
+  from: number;
+  to: number;
+}

package/src/datum/Filters.ts

@@ -0,0 +1,44 @@
+import { FilterDomainUpdateRules } from './FiltersManager';
+import * as apodization from './data1d/filter1d/apodization';
+import * as baselineCorrection from './data1d/filter1d/baselineCorrection';
+import * as digitalFilter from './data1d/filter1d/digitalFilter';
+import * as fft from './data1d/filter1d/fft';
+import * as phaseCorrection from './data1d/filter1d/phaseCorrection';
+import * as shiftX from './data1d/filter1d/shiftX';
+import * as signalProcessing from './data1d/filter1d/signalProcessing';
+import * as zeroFilling from './data1d/filter1d/zeroFilling';
+import * as shift2DX from './data2d/filter2d/shiftX';
+import * as shift2DY from './data2d/filter2d/shiftY';
+
+export type { ApodizationOptions } from './data1d/filter1d/apodization';
+export type {
+  BaselineAlgorithms,
+  PolynomialOptions,
+  AirplsOptions,
+  BaselineCorrectionOptions,
+} from './data1d/filter1d/baselineCorrection';
+export type { PhaseCorrectionParameters, AutoPhaseCorrectionOptions } from './data1d/filter1d/phaseCorrection';
+export type { ZeroFillingOptions } from './data1d/filter1d/zeroFilling';
+
+export const Filters: Record<
+  string,
+  {
+    apply: any;
+    reduce: any;
+    isApplicable: any;
+    name: string;
+    id: string;
+    DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+  }
+> = {
+  apodization,
+  signalProcessing,
+  baselineCorrection,
+  digitalFilter,
+  fft,
+  phaseCorrection,
+  shiftX,
+  zeroFilling,
+  shift2DX,
+  shift2DY,
+};

package/src/datum/FiltersManager.ts

@@ -0,0 +1,238 @@
+import { v4 } from '@lukeed/uuid';
+import { Data2D } from 'cheminfo-types';
+
+import { Data1D } from '../types/Data1D';
+import { BaseFilter, Filter } from '../types/Filter';
+import { Spectrum1D } from '../types/Spectrum/Spectrum1D';
+import { Spectrum2D } from '../types/Spectrum/Spectrum2D';
+import { cloneData1D } from '../utilities/cloneData1D';
+import { cloneData2D } from '../utilities/cloneData2D';
+
+import { Filters } from './Filters';
+import { updateIntegrals } from './data1d/utils/updateIntegrals';
+import { updatePeaks } from './data1d/utils/updatePeaks';
+import { updateRanges } from './data1d/utils/updateRanges';
+import { updateZones } from './data2d/utils/updateZones';
+
+export interface FilterDomainUpdateRules {
+  updateYDomain: boolean;
+  updateXDomain: boolean;
+}
+
+function resetDataToOrigin(datum: Spectrum1D | Spectrum2D) {
+  datum.data =
+    datum.info.dimension === 1
+      ? cloneData1D(datum.originalData as Data1D)
+      : cloneData2D(datum.originalData as Data2D);
+
+  const { originalInfo } = datum;
+  if (originalInfo) {
+    datum.info = { ...originalInfo };
+  }
+}
+// update the the part of the data that affected by applying the filters
+function updateData(datum: Spectrum1D | Spectrum2D) {
+  if (datum.info.dimension === 1) {
+    updatePeaks(datum as Spectrum1D);
+    updateRanges(datum as Spectrum1D);
+    updateIntegrals(datum as Spectrum1D);
+  } else if (datum.info.dimension === 2) {
+    updateZones(datum as Spectrum2D);
+  }
+}
+
+interface ApplyFilterOptions {
+  forceReapply?: boolean;
+  filterIndex?: number | -1;
+}
+
+interface FilterOption {
+  name: string;
+  label: string;
+  value: any;
+}
+
+/***
+ * @param {object} Filters [{name:'',options:{}},{...}]
+ */
+export function applyFilter(
+  datum: Spectrum1D | Spectrum2D,
+  filters: BaseFilter[] = [],
+  options: ApplyFilterOptions = {},
+) {
+  const { forceReapply = false, filterIndex } = options;
+  let isReduced = false;
+  for (let filter of filters) {
+    const filterOption = {
+      name: filter.name,
+      label: Filters[filter.name].name,
+      value: filter.value,
+    };
+    const previousFilter = lookupForFilter(datum, filter.name);
+    const isDeleteAllow =
+      'isDeleteAllow' in filter ? filter.isDeleteAllow : true;
+    if (previousFilter) {
+      const reduceResult = Filters[filter.name].reduce(
+        previousFilter.value,
+        filterOption.value,
+      );
+      if (reduceResult.once) {
+        if (!isReduced) {
+          isReduced = true;
+        }
+        if (reduceResult.reduce != null && reduceResult.reduce !== undefined) {
+          replaceFilter(datum, previousFilter.id, reduceResult.reduce);
+        }
+      } else {
+        addFilter(datum, filterOption, { isDeleteAllow, filterIndex });
+      }
+    } else {
+      addFilter(datum, filterOption, { isDeleteAllow, filterIndex });
+    }
+  }
+  if (forceReapply) {
+    reapplyFilters(datum);
+  } else if (isReduced) {
+    if (filters.length === 1 && isLastFilter(datum, filters[0].name)) {
+      Filters[filters[0].name].apply(datum, filters[0].value);
+    } else {
+      reapplyFilters(datum);
+    }
+  } else {
+    for (let filter of filters) {
+      Filters[filter.name].apply(datum, filter.value);
+    }
+  }
+  updateData(datum);
+}
+
+function isLastFilter(datum: Spectrum1D | Spectrum2D, id: string) {
+  const index = datum.filters.findIndex((f) => f.name === id);
+  if (datum.filters.length === index + 1) {
+    return true;
+  }
+  return false;
+}
+
+export function lookupForFilter(
+  datum: Spectrum1D | Spectrum2D,
+  filterName: string,
+) {
+  return datum.filters.find((f) => f.name === filterName);
+}
+
+export function reapplyFilters(
+  datum: Spectrum1D | Spectrum2D,
+  filters?: Filter[],
+) {
+  const _filters = filters || datum.filters;
+  enableFilter(datum, null, null, _filters);
+}
+
+// id filter id
+export function enableFilter(
+  datum: Spectrum1D | Spectrum2D,
+  id: string | null,
+  checked: boolean | null,
+  filters?: Filter[],
+) {
+  datum.filters = datum.filters.slice(0);
+  if (id) {
+    datum.filters = datum.filters.map((filter) => {
+      return { ...filter, flag: filter.id === id ? checked : filter.flag };
+    });
+  }
+
+  resetDataToOrigin(datum);
+
+  const _filters = filters || datum.filters;
+
+  for (let filterIndex = 0; filterIndex < _filters.length; filterIndex++) {
+    const filter = datum.filters[filterIndex];
+    datum.filters[filterIndex] = {
+      ...datum.filters[filterIndex],
+    };
+
+    if (filter.flag) {
+      try {
+        Filters[filter.name].apply(datum, filter.value);
+      } catch (error: any) {
+        datum.filters[filterIndex] = {
+          ...datum.filters[filterIndex],
+          error: error.message,
+        };
+      }
+    }
+  }
+}
+
+export function deleteFilter(datum: Spectrum1D | Spectrum2D, id?: string) {
+  // delete the specified filter otherwise delete all filters where isDeleteAllow is true
+  datum.filters = datum.filters
+    .slice(0)
+    .filter((filter) => (id ? filter.id !== id : !filter.isDeleteAllow));
+
+  resetDataToOrigin(datum);
+
+  for (let i = 0; i < datum.filters.length; i++) {
+    datum.filters[i] = {
+      ...datum.filters[i],
+    };
+
+    if (datum.filters[i].flag) {
+      const { name, value } = datum.filters[i];
+      try {
+        Filters[name].apply(datum, value);
+      } catch (error: any) {
+        datum.filters[i] = {
+          ...datum.filters[i],
+          error: error.message,
+        };
+      }
+    }
+  }
+  updateData(datum);
+}
+interface AddFilterOptions {
+  filterIndex?: number;
+  isDeleteAllow?: boolean;
+}
+
+export function addFilter(
+  datum: Spectrum1D | Spectrum2D,
+  filterOptions: FilterOption,
+  options: AddFilterOptions = {},
+) {
+  const { filterIndex, isDeleteAllow = true } = options;
+  const id = v4();
+
+  const filter = {
+    ...filterOptions,
+    id,
+    flag: true,
+    isDeleteAllow,
+  };
+
+  if (typeof filterIndex === 'number' && filterIndex !== -1) {
+    datum.filters = [
+      ...datum.filters.slice(0, filterIndex + 1),
+      filter,
+      ...datum.filters.slice(filterIndex + 1),
+    ];
+  } else {
+    datum.filters.push(filter);
+  }
+}
+
+function replaceFilter(
+  datum: Spectrum1D | Spectrum2D,
+  filterID: string,
+  value: any,
+) {
+  // datum.filters = datum.filters.slice(0);
+  const index = datum.filters.findIndex((f) => f.id === filterID);
+  datum.filters[index] = {
+    ...datum.filters[index],
+    value,
+  };
+}

package/src/datum/MatrixFilter.ts

@@ -0,0 +1,58 @@
+import type { FilterXYType } from 'ml-signal-processing';
+
+interface BaseField {
+  key: string;
+  level: number;
+  name: string;
+  description: string;
+}
+
+interface Field<T> extends BaseField {
+  default: T;
+}
+
+interface LabelField extends BaseField {
+  type: 'label';
+}
+
+interface SelectField extends Field<any> {
+  type: 'select';
+  choices: any[];
+}
+interface StringField extends Field<string> {
+  type: 'string';
+}
+interface NumberField extends Field<number> {
+  type: 'number';
+}
+interface BooleanField extends Field<boolean> {
+  type: 'boolean';
+}
+
+type CommonField =
+  | SelectField
+  | StringField
+  | NumberField
+  | BooleanField
+  | LabelField;
+
+interface ListField extends Field<string[]> {
+  type: 'list';
+  properties: Record<string, CommonField>;
+}
+
+type Properties =
+  | ListField
+  | SelectField
+  | StringField
+  | NumberField
+  | BooleanField
+  | LabelField;
+
+export type MatrixProperties = Record<string /*filed name*/, Properties>;
+
+export interface MatrixFilter {
+  name: FilterXYType['name'] /*filter name*/;
+  properties: MatrixProperties;
+  options: any;
+}

package/src/datum/MatrixOptions.ts

@@ -0,0 +1,25 @@
+import { ExclusionZone } from './ExclusionZone';
+import { MatrixFilter } from './MatrixFilter';
+
+export interface MatrixOptions {
+  /**
+   * Matrix generation filters
+   * @default []
+   *
+   */
+  filters: (MatrixFilter & { options: object })[];
+  /**
+   * Exclusion zones
+   * @default []
+   */
+  exclusionsZones: ExclusionZone[];
+  /**
+   * range
+   */
+  range: { from: number; to: number };
+
+  /**
+   * number of points
+   */
+  numberOfPoints: number;
+}

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

@@ -0,0 +1,90 @@
+import { apodization } from '../../../apodization/apodization';
+import { Data1D } from '../../../types/Data1D';
+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 function apply(datum1D: Entry1D, options: ApodizationOptions) {
+  if (!isApplicable(datum1D)) {
+    throw new Error('apodization not applicable on this data');
+  }
+  const newData = apodizationFilter(datum1D, options);
+
+  datum1D.data = {
+    ...datum1D.data,
+    re: newData.re as Float64Array,
+    im: newData.im as Float64Array,
+  };
+}
+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: any, newValue: any) {
+  return {
+    once: true,
+    reduce: newValue,
+  };
+}
+
+export function apodizationFilter(
+  datum1D: Entry1D & { data: Required<Data1D> },
+  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,
+              },
+            },
+          },
+        ],
+      },
+    },
+  );
+}