nmr-processing 9.5.1 → 9.5.2-pre.1685982544

package/lib/datum/MatrixFilter.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MatrixFilter.js.map

package/lib/datum/MatrixFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatrixFilter.js","sourceRoot":"","sources":["../../src/datum/MatrixFilter.ts"],"names":[],"mappings":""}

package/lib/datum/MatrixOptions.d.ts

@@ -0,0 +1,28 @@
+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/lib/datum/MatrixOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MatrixOptions.js.map

package/lib/datum/MatrixOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MatrixOptions.js","sourceRoot":"","sources":["../../src/datum/MatrixOptions.ts"],"names":[],"mappings":""}

package/lib/datum/data1d/Entry1D.d.ts

@@ -0,0 +1,17 @@
+import { Data1D } from '../../types/Data1D';
+import { Filter } from '../../types/Filter';
+import { Info1D } from '../../types/Info/Info1D';
+import { Integrals } from '../../types/Integrals';
+import { Peaks } from '../../types/Peaks/Peaks';
+import { Ranges } from '../../types/Ranges/Ranges';
+export interface Entry1D {
+    id?: string;
+    data: Data1D;
+    originalData?: Data1D;
+    peaks: Peaks;
+    integrals: Integrals;
+    ranges: Ranges;
+    info: Info1D;
+    originalInfo?: Info1D;
+    filters: Array<Filter>;
+}

package/lib/datum/data1d/Entry1D.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Entry1D.js.map

package/lib/datum/data1d/Entry1D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Entry1D.js","sourceRoot":"","sources":["../../../src/datum/data1d/Entry1D.ts"],"names":[],"mappings":""}

package/lib/datum/data1d/filter1d/apodization/apodization.d.ts

@@ -0,0 +1,25 @@
+import { Data1D } from '../../../../types/Data1D';
+import { Info1D } from '../../../../types/Info/Info1D';
+import { FilterDomainUpdateRules } from '../../../FiltersManager';
+import { Entry1D } from '../../Entry1D';
+export declare const id = "apodization";
+export declare const name = "Apodization";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+export interface ApodizationOptions {
+    lineBroadening: number;
+    gaussBroadening: number;
+    lineBroadeningCenter: number;
+}
+type Entry1DApodizationFilter = Partial<Omit<Entry1D, 'info'>> & {
+    info: Partial<Info1D>;
+    data: Data1D;
+};
+export declare function apply(datum1D: Entry1DApodizationFilter, options: ApodizationOptions): void;
+export declare function isApplicable(datum1D: Entry1DApodizationFilter): datum1D is Entry1DApodizationFilter & {
+    data: Required<Data1D>;
+};
+export declare function reduce(previousValue: any, newValue: any): {
+    once: boolean;
+    reduce: any;
+};
+export {};

package/lib/datum/data1d/filter1d/apodization/apodization.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+const apodizationFilter_1 = require("./apodizationFilter");
+exports.id = 'apodization';
+exports.name = 'Apodization';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: true,
+    updateYDomain: false,
+};
+function apply(datum1D, options) {
+    if (!isApplicable(datum1D)) {
+        throw new Error('apodization not applicable on this data');
+    }
+    const newData = (0, apodizationFilter_1.apodizationFilter)(datum1D, options);
+    datum1D.data = {
+        ...datum1D.data,
+        re: newData.re,
+        im: newData.im,
+    };
+}
+exports.apply = apply;
+function isApplicable(datum1D) {
+    if (datum1D.info.isComplex && datum1D.info.isFid)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce(previousValue, newValue) {
+    return {
+        once: true,
+        reduce: newValue,
+    };
+}
+exports.reduce = reduce;
+//# sourceMappingURL=apodization.js.map

package/lib/datum/data1d/filter1d/apodization/apodization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apodization.js","sourceRoot":"","sources":["../../../../../src/datum/data1d/filter1d/apodization/apodization.ts"],"names":[],"mappings":";;;AAKA,2DAAwD;AAE3C,QAAA,EAAE,GAAG,aAAa,CAAC;AACnB,QAAA,IAAI,GAAG,aAAa,CAAC;AACrB,QAAA,mBAAmB,GAAsC;IACpE,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,KAAK;CACrB,CAAC;AAaF,SAAgB,KAAK,CACnB,OAAiC,EACjC,OAA2B;IAE3B,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;KAC5D;IACD,MAAM,OAAO,GAAG,IAAA,qCAAiB,EAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEpD,OAAO,CAAC,IAAI,GAAG;QACb,GAAG,OAAO,CAAC,IAAI;QACf,EAAE,EAAE,OAAO,CAAC,EAAkB;QAC9B,EAAE,EAAE,OAAO,CAAC,EAAkB;KAC/B,CAAC;AACJ,CAAC;AAdD,sBAcC;AACD,SAAgB,YAAY,CAC1B,OAAiC;IAEjC,IAAI,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IAC9D,OAAO,KAAK,CAAC;AACf,CAAC;AALD,oCAKC;AAED,SAAgB,MAAM,CAAC,aAAkB,EAAE,QAAa;IACtD,OAAO;QACL,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,QAAQ;KACjB,CAAC;AACJ,CAAC;AALD,wBAKC"}

package/lib/datum/data1d/filter1d/apodization/apodizationFilter.d.ts

@@ -0,0 +1,14 @@
+import { Data1D } from '../../../../types/Data1D';
+import { Info1D } from '../../../../types/Info/Info1D';
+import { Entry1D } from '../../Entry1D';
+import { ApodizationOptions } from './apodization';
+type Entry1DApodizationFilter = Partial<Omit<Entry1D, 'info'>> & {
+    info: Partial<Info1D>;
+    data: Required<Data1D>;
+};
+export declare function apodizationFilter(datum1D: Entry1DApodizationFilter, options: ApodizationOptions): {
+    windowData: Float64Array;
+    re: import("cheminfo-types").DoubleArray;
+    im: import("cheminfo-types").DoubleArray;
+};
+export {};

package/lib/datum/data1d/filter1d/apodization/apodizationFilter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apodizationFilter = void 0;
+const apodization_1 = require("../../../../apodization/apodization");
+function apodizationFilter(datum1D, options) {
+    const { lineBroadening, gaussBroadening, lineBroadeningCenter } = options;
+    const grpdly = datum1D.info?.digitalFilter || 0;
+    const pointsToShift = grpdly > 0 ? Math.floor(grpdly) : 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 (0, apodization_1.apodization)({ re, im }, {
+        pointsToShift,
+        compose: {
+            length,
+            shapes: [
+                {
+                    start: 0,
+                    shape: {
+                        kind: 'lorentzToGauss',
+                        options: {
+                            length,
+                            dw,
+                            exponentialHz: gaussBroadening > 0 ? lineBroadening : -lineBroadening,
+                            gaussianHz: gaussBroadening,
+                            center: lineBroadeningCenter,
+                        },
+                    },
+                },
+            ],
+        },
+    });
+}
+exports.apodizationFilter = apodizationFilter;
+//# sourceMappingURL=apodizationFilter.js.map

package/lib/datum/data1d/filter1d/apodization/apodizationFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apodizationFilter.js","sourceRoot":"","sources":["../../../../../src/datum/data1d/filter1d/apodization/apodizationFilter.ts"],"names":[],"mappings":";;;AAAA,qEAAkE;AAYlE,SAAgB,iBAAiB,CAC/B,OAAiC,EACjC,OAA2B;IAE3B,MAAM,EAAE,cAAc,EAAE,eAAe,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC;IAE1E,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,aAAa,IAAI,CAAC,CAAC;IAChD,MAAM,aAAa,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1D,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;IAC3B,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAEzB,MAAM,MAAM,GAAG,EAAE,CAAC,MAAM,CAAC;IACzB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,0FAA0F;IAE5I,OAAO,IAAA,yBAAW,EAChB,EAAE,EAAE,EAAE,EAAE,EAAE,EACV;QACE,aAAa;QACb,OAAO,EAAE;YACP,MAAM;YACN,MAAM,EAAE;gBACN;oBACE,KAAK,EAAE,CAAC;oBACR,KAAK,EAAE;wBACL,IAAI,EAAE,gBAAgB;wBACtB,OAAO,EAAE;4BACP,MAAM;4BACN,EAAE;4BACF,aAAa,EACX,eAAe,GAAG,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc;4BACxD,UAAU,EAAE,eAAe;4BAC3B,MAAM,EAAE,oBAAoB;yBAC7B;qBACF;iBACF;aACF;SACF;KACF,CACF,CAAC;AACJ,CAAC;AAzCD,8CAyCC"}

package/lib/datum/data1d/filter1d/baselineCorrection.d.ts

@@ -0,0 +1,32 @@
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+export declare const id = "baselineCorrection";
+export declare const name = "Baseline correction";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+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 declare function apply(datum1D: Entry1D, options: BaselineCorrectionOptions): void;
+export declare function isApplicable(datum1D: Entry1D): boolean;
+export declare function reduce(previousValue: BaselineCorrectionOptions, newValue: BaselineCorrectionOptions): {
+    once: boolean;
+    reduce: BaselineCorrectionOptions;
+};

package/lib/datum/data1d/filter1d/baselineCorrection.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+const ml_airpls_1 = __importDefault(require("ml-airpls"));
+const ml_baseline_correction_regression_1 = __importDefault(require("ml-baseline-correction-regression"));
+const ml_spectra_processing_1 = require("ml-spectra-processing");
+exports.id = 'baselineCorrection';
+exports.name = 'Baseline correction';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: false,
+    updateYDomain: true,
+};
+function apply(datum1D, options) {
+    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 = (0, ml_airpls_1.default)(x, re, options).corrected;
+            break;
+        case 'polynomial':
+            {
+                const { degree, zones } = options;
+                let reduced = (0, ml_spectra_processing_1.xyEquallySpaced)({ x, y: re }, { numberOfPoints: 4096, zones });
+                let result = (0, ml_baseline_correction_regression_1.default)(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 });
+}
+exports.apply = apply;
+function isApplicable(datum1D) {
+    if (!datum1D.info.isFid)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce(previousValue, newValue) {
+    return {
+        once: true,
+        reduce: newValue,
+    };
+}
+exports.reduce = reduce;
+//# sourceMappingURL=baselineCorrection.js.map

package/lib/datum/data1d/filter1d/baselineCorrection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baselineCorrection.js","sourceRoot":"","sources":["../../../../src/datum/data1d/filter1d/baselineCorrection.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA+B;AAC/B,0GAAmE;AACnE,iEAAwD;AAK3C,QAAA,EAAE,GAAG,oBAAoB,CAAC;AAC1B,QAAA,IAAI,GAAG,qBAAqB,CAAC;AAC7B,QAAA,mBAAmB,GAAsC;IACpE,aAAa,EAAE,KAAK;IACpB,aAAa,EAAE,IAAI;CACpB,CAAC;AAmBF,SAAgB,KAAK,CAAC,OAAgB,EAAE,OAAkC;IACxE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;KACnE;IACD,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAC9B,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAE7B,IAAI,SAAS,CAAC;IACd,QAAQ,SAAS,EAAE;QACjB,KAAK,QAAQ;YACX,SAAS,GAAG,IAAA,mBAAM,EAAC,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC;YAC7C,MAAM;QACR,KAAK,YAAY;YACf;gBACE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;gBAClC,IAAI,OAAO,GAAG,IAAA,uCAAe,EAC3B,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EACZ,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,EAAE,CAChC,CAAC;gBACF,IAAI,MAAM,GAAG,IAAA,2CAAkB,EAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE;oBACpD,iBAAiB,EAAE,MAAM;iBAC1B,CAAC,CAAC;gBACH,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;gBAC5B,SAAS,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;gBACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBAClC,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;iBACjD;aACF;YAED,MAAM;QACR;YACE,4EAA4E;YAC5E,MAAM,IAAI,KAAK,CAAC,0CAA0C,SAAS,EAAE,CAAC,CAAC;KAC1E;IAED,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;AACjD,CAAC;AApCD,sBAoCC;AAED,SAAgB,YAAY,CAAC,OAAgB;IAC3C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACrC,OAAO,KAAK,CAAC;AACf,CAAC;AAHD,oCAGC;AAED,SAAgB,MAAM,CACpB,aAAwC,EACxC,QAAmC;IAEnC,OAAO;QACL,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,QAAQ;KACjB,CAAC;AACJ,CAAC;AARD,wBAQC"}

package/lib/datum/data1d/filter1d/digitalFilter.d.ts

@@ -0,0 +1,23 @@
+import { Data1D } from '../../../types/Data1D';
+import { Info1D } from '../../../types/Info/Info1D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+export declare const id = "digitalFilter";
+export declare const name = "Digital Filter";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+type Entry1DDigitalFilter = Partial<Omit<Entry1D, 'info'>> & Required<Pick<Entry1D, 'data' | 'filters'>> & {
+    info: Partial<Info1D>;
+};
+/**
+ * Move points from the beginning to the end of FID and performs a first order phase correction
+ * @param {Datum1d} datum1d
+ */
+export declare function apply(spectrum: Entry1DDigitalFilter, options?: any): void;
+export declare function isApplicable(datum1D: Entry1DDigitalFilter): datum1D is Entry1DDigitalFilter & {
+    data: Required<Data1D>;
+};
+export declare function reduce(): {
+    once: boolean;
+    reduce: undefined;
+};
+export {};

package/lib/datum/data1d/filter1d/digitalFilter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+exports.id = 'digitalFilter';
+exports.name = 'Digital Filter';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: true,
+    updateYDomain: true,
+};
+/**
+ * Move points from the beginning to the end of FID and performs a first order phase correction
+ * @param {Datum1d} datum1d
+ */
+function apply(spectrum, options = {}) {
+    if (!isApplicable(spectrum)) {
+        throw new Error('Digital Filter is not applicable on this data');
+    }
+    let { digitalFilterValue } = options;
+    if (!digitalFilterValue) {
+        digitalFilterValue = spectrum.info.digitalFilter || 0;
+        const filter = spectrum.filters.find((filter) => filter.name === exports.id);
+        if (filter) {
+            filter.value = { digitalFilterValue };
+        }
+    }
+    let re = new Float64Array(spectrum.data.re);
+    let im = new Float64Array(spectrum.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);
+    spectrum.data.re = newRe;
+    spectrum.data.im = newIm;
+}
+exports.apply = apply;
+function isApplicable(datum1D) {
+    if (datum1D.info.isComplex && datum1D.info.isFid)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce() {
+    return {
+        once: true,
+        reduce: undefined,
+    };
+}
+exports.reduce = reduce;
+//# sourceMappingURL=digitalFilter.js.map

package/lib/datum/data1d/filter1d/digitalFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"digitalFilter.js","sourceRoot":"","sources":["../../../../src/datum/data1d/filter1d/digitalFilter.ts"],"names":[],"mappings":";;;AAKa,QAAA,EAAE,GAAG,eAAe,CAAC;AACrB,QAAA,IAAI,GAAG,gBAAgB,CAAC;AACxB,QAAA,mBAAmB,GAAsC;IACpE,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;CACpB,CAAC;AAKF;;;GAGG;AAEH,SAAgB,KAAK,CAAC,QAA8B,EAAE,UAAe,EAAE;IACrE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IACD,IAAI,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC;IAErC,IAAI,CAAC,kBAAkB,EAAE;QACvB,kBAAkB,GAAG,QAAQ,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,UAAE,CAAC,CAAC;QACrE,IAAI,MAAM,EAAE;YACV,MAAM,CAAC,KAAK,GAAG,EAAE,kBAAkB,EAAE,CAAC;SACvC;KACF;IAED,IAAI,EAAE,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5C,IAAI,EAAE,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAE5C,IAAI,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAEnD,MAAM,IAAI,GAAG,CAAC,CAAC;IACf,aAAa,IAAI,CAAC,CAAC;IAEnB,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;IACnC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC;IACpE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;IACnC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC;IAEpE,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC;AAC3B,CAAC;AA/BD,sBA+BC;AAED,SAAgB,YAAY,CAC1B,OAA6B;IAE7B,IAAI,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IAC9D,OAAO,KAAK,CAAC;AACf,CAAC;AALD,oCAKC;AAED,SAAgB,MAAM;IACpB,OAAO;QACL,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,SAAS;KAClB,CAAC;AACJ,CAAC;AALD,wBAKC"}

package/lib/datum/data1d/filter1d/equallySpaced.d.ts

@@ -0,0 +1,31 @@
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+export declare const id = "equallySpaced";
+export declare const name = "Equally spaced";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+/**
+ * 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 declare function apply(spectrum: Entry1D, options?: any): void;
+export declare function isApplicable(spectrum: Entry1D): boolean;
+export declare function reduce(): {
+    once: boolean;
+    reduce: null;
+};

package/lib/datum/data1d/filter1d/equallySpaced.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+const ml_spectra_processing_1 = require("ml-spectra-processing");
+exports.id = 'equallySpaced';
+exports.name = 'Equally spaced';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: false,
+    updateYDomain: false,
+};
+/**
+ * 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
+ */
+function apply(spectrum, options = {}) {
+    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 = (0, ml_spectra_processing_1.xyEquallySpaced)({ x, y: re }, { from, to, numberOfPoints, exclusions });
+    spectrum.data.x = (0, ml_spectra_processing_1.xEnsureFloat64)(XREdata.x);
+    spectrum.data.re = (0, ml_spectra_processing_1.xEnsureFloat64)(XREdata.y);
+    if (im) {
+        const XIMdata = (0, ml_spectra_processing_1.xyEquallySpaced)({ x, y: re }, { from, to, numberOfPoints, exclusions });
+        spectrum.data.im = (0, ml_spectra_processing_1.xEnsureFloat64)(XIMdata.y);
+    }
+}
+exports.apply = apply;
+function isApplicable(spectrum) {
+    if (spectrum.info.isComplex && !spectrum.info.isFid)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce() {
+    return {
+        once: false,
+        reduce: null,
+    };
+}
+exports.reduce = reduce;
+//# sourceMappingURL=equallySpaced.js.map

package/lib/datum/data1d/filter1d/equallySpaced.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equallySpaced.js","sourceRoot":"","sources":["../../../../src/datum/data1d/filter1d/equallySpaced.ts"],"names":[],"mappings":";;;AAAA,iEAAwE;AAK3D,QAAA,EAAE,GAAG,eAAe,CAAC;AACrB,QAAA,IAAI,GAAG,gBAAgB,CAAC;AACxB,QAAA,mBAAmB,GAAsC;IACpE,aAAa,EAAE,KAAK;IACpB,aAAa,EAAE,KAAK;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,SAAgB,KAAK,CAAC,QAAiB,EAAE,UAAe,EAAE;IACxD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;KAClE;IACD,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IACzD,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC;IACpC,MAAM,OAAO,GAAG,IAAA,uCAAe,EAC7B,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EACZ,EAAE,IAAI,EAAE,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,CACzC,CAAC;IAEF,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,IAAA,sCAAc,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5C,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,IAAA,sCAAc,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC7C,IAAI,EAAE,EAAE;QACN,MAAM,OAAO,GAAG,IAAA,uCAAe,EAC7B,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EACZ,EAAE,IAAI,EAAE,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,CACzC,CAAC;QACF,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,IAAA,sCAAc,EAAC,OAAO,CAAC,CAAC,CAAC,CAAC;KAC9C;AACH,CAAC;AApBD,sBAoBC;AAED,SAAgB,YAAY,CAAC,QAAiB;IAC5C,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACjE,OAAO,KAAK,CAAC;AACf,CAAC;AAHD,oCAGC;AAED,SAAgB,MAAM;IACpB,OAAO;QACL,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,IAAI;KACb,CAAC;AACJ,CAAC;AALD,wBAKC"}

package/lib/datum/data1d/filter1d/exclusionZones.d.ts

@@ -0,0 +1,11 @@
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+export declare const id = "exclusionZones";
+export declare const name = "Exclusion zones";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+export declare function apply(spectrum: Entry1D, zones?: never[]): void;
+export declare function isApplicable(spectrum: Entry1D): boolean;
+export declare function reduce(previousValue: any, newValue: any): {
+    once: boolean;
+    reduce: import("cheminfo-types").FromTo[];
+};

package/lib/datum/data1d/filter1d/exclusionZones.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+const ml_spectra_processing_1 = require("ml-spectra-processing");
+exports.id = 'exclusionZones';
+exports.name = 'Exclusion zones';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: false,
+    updateYDomain: false,
+};
+function apply(spectrum, 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((0, ml_spectra_processing_1.xySetYValue)({ x, y: re }, { zones }).y);
+    spectrum.data.im = im
+        ? Float64Array.from((0, ml_spectra_processing_1.xySetYValue)({ x, y: re }, { zones }).y)
+        : im;
+}
+exports.apply = apply;
+function isApplicable(spectrum) {
+    if (spectrum.info.isFt)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce(previousValue, newValue) {
+    return {
+        once: true,
+        reduce: (0, ml_spectra_processing_1.zonesNormalize)(previousValue.concat(newValue)),
+    };
+}
+exports.reduce = reduce;
+//# sourceMappingURL=exclusionZones.js.map

package/lib/datum/data1d/filter1d/exclusionZones.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exclusionZones.js","sourceRoot":"","sources":["../../../../src/datum/data1d/filter1d/exclusionZones.ts"],"names":[],"mappings":";;;AAAA,iEAAoE;AAKvD,QAAA,EAAE,GAAG,gBAAgB,CAAC;AACtB,QAAA,IAAI,GAAG,iBAAiB,CAAC;AACzB,QAAA,mBAAmB,GAAsC;IACpE,aAAa,EAAE,KAAK;IACpB,aAAa,EAAE,KAAK;CACrB,CAAC;AAEF,SAAgB,KAAK,CAAC,QAAiB,EAAE,KAAK,GAAG,EAAE;IACjD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;KACvE;IACD,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,IAAA,mCAAW,EAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE;QACnB,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAA,mCAAW,EAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,EAAE,CAAC;AACT,CAAC;AATD,sBASC;AAED,SAAgB,YAAY,CAAC,QAAiB;IAC5C,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACpC,OAAO,KAAK,CAAC;AACf,CAAC;AAHD,oCAGC;AAED,SAAgB,MAAM,CAAC,aAAkB,EAAE,QAAa;IACtD,OAAO;QACL,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,IAAA,sCAAc,EAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;KACvD,CAAC;AACJ,CAAC;AALD,wBAKC"}

package/lib/datum/data1d/filter1d/fft.d.ts

@@ -0,0 +1,19 @@
+import { Data1D } from '../../../types/Data1D';
+import { Info1D } from '../../../types/Info/Info1D';
+import { FilterDomainUpdateRules } from '../../FiltersManager';
+import { Entry1D } from '../Entry1D';
+export declare const id = "fft";
+export declare const name = "FFT";
+export declare const DOMAIN_UPDATE_RULES: Readonly<FilterDomainUpdateRules>;
+type Entry1DFt = Partial<Omit<Entry1D, 'info'>> & Required<Pick<Entry1D, 'data' | 'filters'>> & {
+    info: Partial<Info1D>;
+};
+export declare function apply(datum1D: Entry1DFt): void;
+export declare function isApplicable(datum1D: Entry1DFt): datum1D is Entry1DFt & {
+    data: Required<Data1D>;
+};
+export declare function reduce(): {
+    once: boolean;
+    reduce: undefined;
+};
+export {};

package/lib/datum/data1d/filter1d/fft.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduce = exports.isApplicable = exports.apply = exports.DOMAIN_UPDATE_RULES = exports.name = exports.id = void 0;
+const ml_spectra_processing_1 = require("ml-spectra-processing");
+const padDataToNextPowerOfTwo_1 = require("./utils/padDataToNextPowerOfTwo");
+exports.id = 'fft';
+exports.name = 'FFT';
+exports.DOMAIN_UPDATE_RULES = {
+    updateXDomain: true,
+    updateYDomain: true,
+};
+function apply(datum1D) {
+    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)) {
+        (0, padDataToNextPowerOfTwo_1.padDataToNextPowerOfTwo)(datum1D, digitalFilterApplied);
+    }
+    const { data, info } = datum1D;
+    Object.assign(data, (0, ml_spectra_processing_1.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, (0, ml_spectra_processing_1.reimPhaseCorrection)(data, 0, -ph1, { reverse: true }));
+    }
+    datum1D.data.x = generateXAxis(datum1D);
+    datum1D.info = { ...datum1D.info, isFid: false, isFt: true };
+}
+exports.apply = apply;
+function isApplicable(datum1D) {
+    if (datum1D.info.isComplex && datum1D.info.isFid)
+        return true;
+    return false;
+}
+exports.isApplicable = isApplicable;
+function reduce() {
+    return {
+        once: true,
+        reduce: undefined,
+    };
+}
+exports.reduce = reduce;
+function generateXAxis(datum1D) {
+    const info = datum1D.info;
+    const baseFrequency = Number(info.baseFrequency);
+    const frequencyOffset = Number(info.frequencyOffset);
+    const spectralWidth = Number(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) {
+    return n !== 0 && (n & (n - 1)) === 0;
+}
+function removeDCOffset(spectrum, digitalFilterApplied) {
+    let { digitalFilter = 0 } = digitalFilterApplied && spectrum.info ? 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 = (0, ml_spectra_processing_1.xMean)(data.re.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilter));
+    const averageIm = (0, ml_spectra_processing_1.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) {
+    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');
+    }
+}
+//# sourceMappingURL=fft.js.map