fix: update PSG n spectra-fitting (#70)

* fix: add prefix I to interfaces

rename options of joinBroadPeaks width -> broadWidth, mask -> broadMask

* chore: adapt test case

* fix: eslint

* chore: update dependencies

spectrum-generator, ml-spectra-fitting n PSG

Author: jobo322

package.json

@@ -72,16 +72,16 @@
     "nodemon": "^2.0.14",
     "prettier": "^2.4.1",
     "rimraf": "^3.0.2",
-    "spectrum-generator": "^6.0.0",
+    "spectrum-generator": "^6.0.1",
     "ts-jest": "^27.0.7",
     "typescript": "^4.4.4",
     "xy-parser": "^3.2.0"
   },
   "dependencies": {
     "cheminfo-types": "^0.8.0",
-    "ml-peak-shape-generator": "^3.0.2",
+    "ml-peak-shape-generator": "^3.0.3",
     "ml-savitzky-golay-generalized": "2.0.3",
-    "ml-spectra-fitting": "^3.0.0",
+    "ml-spectra-fitting": "^3.0.1",
     "ml-spectra-processing": "^6.8.0"
   }
 }

src/__tests__/broadNMR.test.ts

@@ -25,7 +25,7 @@ describe('Global spectra deconvolution NMR spectra', () => {
       { x: spectrum[0], y: spectrum[1] },
       result,
       {
-        width: 0.25,
+        broadWidth: 0.25,
         broadRatio: 0.0025,
         shape: { kind: 'lorentzian' },
         sgOptions: {

src/__tests__/massPeakPicking.test.ts

@@ -42,10 +42,11 @@ describe('Check the peak picking of a simulated mass spectrum', () => {
         kind: 'gaussian',
       },
     });
+    const gaussian = new Gaussian();
     expect(result[0].x).toBeCloseTo(69.938, 1);
     expect(result[0].y).toBeCloseTo(max, 2);
     expect(result[0].fwhm).toBeCloseTo(0.01, 4);
-    expect(result[0].width).toBeCloseTo(Gaussian.fwhmToWidth(0.01), 4);
+    expect(result[0].width).toBeCloseTo(gaussian.fwhmToWidth(0.01), 4);
 
     expect(result[1].x).toBeCloseTo(71.935, 2);
     expect(result[1].y).toBeCloseTo((63.99155 * max) / 100, 3);

src/gsd.ts

@@ -26,19 +26,19 @@ import SG from 'ml-savitzky-golay-generalized';
  */
 
 export interface Peak1D {
-  index?: number;
   x: number;
   y: number;
   width: number;
   fwhm?: number;
   shape?: Shape1D;
 }
-export interface LastType {
+
+interface LastType {
   x: number;
   index: number;
 }
 
-export interface GSDOptions {
+export interface IGSDOptions {
   noiseLevel?: number;
   sgOptions?: {
     windowSize: number;
@@ -54,7 +54,7 @@ export interface GSDOptions {
   factor?: number;
 }
 
-export function gsd(data: DataXY, options: GSDOptions = {}): Peak1D[] {
+export function gsd(data: DataXY, options: IGSDOptions = {}): Peak1D[] {
   let {
     noiseLevel,
     sgOptions = {
@@ -195,16 +195,17 @@ export function gsd(data: DataXY, options: GSDOptions = {}): Peak1D[] {
     }
   }
 
-  let widthProcessor = getShape1D(shape).widthToFWHM;
+  let widthToFWHM = getShape1D(shape).widthToFWHM;
 
-  let signals: Peak1D[] = [];
   let lastK = -1;
-  let possible: number,
-    frequency: number,
-    distanceJ: number,
-    minDistance: number,
-    gettingCloser: boolean;
+  let possible: number;
+  let frequency: number;
+  let distanceJ: number;
+  let minDistance: number;
+  let gettingCloser: boolean;
 
+  const peaks: Peak1D[] = [];
+  const indexes: number[] = [];
   for (const minddYIndex of minddY) {
     frequency = xData[minddYIndex];
     possible = -1;
@@ -231,29 +232,29 @@ export function gsd(data: DataXY, options: GSDOptions = {}): Peak1D[] {
     if (possible !== -1) {
       if (Math.abs(yData[minddYIndex]) > minMaxRatio * maxY) {
         let width = Math.abs(intervalR[possible].x - intervalL[possible].x);
-        signals.push({
-          index: minddYIndex,
+        indexes.push(minddYIndex);
+        peaks.push({
           x: frequency,
           y: maxCriteria
             ? yData[minddYIndex] + noiseLevel
             : -yData[minddYIndex] - noiseLevel,
           width: width,
-          fwhm: widthProcessor(width),
+          fwhm: widthToFWHM(width),
           shape,
         });
       }
     }
   }
 
   if (realTopDetection) {
-    determineRealTop(signals, xData, yData);
+    determineRealTop({ peaks, x: xData, y: yData, indexes });
   }
 
-  signals.sort((a, b) => {
+  peaks.sort((a, b) => {
     return a.x - b.x;
   });
 
-  return signals;
+  return peaks;
 }
 
 const isEqualSpaced = (x: DoubleArray): boolean => {
@@ -297,18 +298,20 @@ const getNoiseLevel = (y: DoubleArray): number => {
 
   return stddev;
 };
-const determineRealTop = (
-  peakList: Peak1D[],
-  x: DoubleArray,
-  y: DoubleArray,
-): void => {
-  let alpha: number,
-    beta: number,
-    gamma: number,
-    p: number,
-    currentPoint: number;
-  for (const peak of peakList) {
-    currentPoint = peak.index as number; // peakList[j][2];
+const determineRealTop = (options: {
+  peaks: Peak1D[];
+  x: DoubleArray;
+  y: DoubleArray;
+  indexes: number[];
+}): void => {
+  const { peaks, x, y, indexes } = options;
+  let alpha: number;
+  let beta: number;
+  let gamma: number;
+  let p: number;
+  for (let i = 0; i < peaks.length; i++) {
+    const peak = peaks[i];
+    let currentPoint = indexes[i];
     // The detected peak could be moved 1 or 2 units to left or right.
     if (
       y[currentPoint - 1] >= y[currentPoint - 2] &&
@@ -350,8 +353,6 @@ const determineRealTop = (
       beta = 20 * Math.log10(y[currentPoint]);
       gamma = 20 * Math.log10(y[currentPoint + 1]);
       p = (0.5 * (alpha - gamma)) / (alpha - 2 * beta + gamma);
-      // console.log(alpha, beta, gamma, `p: ${p}`);
-      // console.log(x[currentPoint]+" "+tmp+" "+currentPoint);
       peak.x = x[currentPoint] + (x[currentPoint] - x[currentPoint - 1]) * p;
       peak.y =
         y[currentPoint] -

src/post/broadenPeaks.ts

@@ -5,7 +5,7 @@ import type { Peak1D } from '../gsd';
  * Because peaks may not be symmetric after we add 2 properties, from and to.
  * @return {Array} peakList
  */
-interface BroadenPeaksOptions {
+export interface IBroadenPeaksOptions {
   /**
    * @default 2
    */
@@ -23,7 +23,7 @@ interface InternPeak1D extends Peak1D {
 }
 export function broadenPeaks(
   peakList: Peak1D[],
-  options: BroadenPeaksOptions = {},
+  options: IBroadenPeaksOptions = {},
 ): Peak1D[] {
   const { factor = 2, overlap = false } = options;
 

src/post/joinBroadPeaks.ts

@@ -2,70 +2,77 @@ import type { DataXY } from 'cheminfo-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
 import SG from 'ml-savitzky-golay-generalized';
 import { optimize } from 'ml-spectra-fitting';
+import type { IOptimizationOptions } from 'ml-spectra-fitting';
 import { xFindClosestIndex } from 'ml-spectra-processing';
 
 import type { Peak1D } from '../gsd';
 
 /**
  * This function try to join the peaks that seems to belong to a broad signal in a single broad peak.
- * @param {Array} peaks - A list of initial parameters to be optimized. e.g. coming from a peak picking [{x, y, width}].
- * @param {object} [options = {}] - options
- * @param {number} [options.width=0.25] - width limit to join peaks.
- * @param {object} [options.shape={}] - it's specify the kind of shape used to fitting.
- * @param {string} [options.shape.kind = 'gaussian'] - kind of shape; lorentzian, gaussian and pseudovoigt are supported.
- * @param {object} [options.optimization = {}] - it's specify the kind and options of the algorithm use to optimize parameters.
- * @param {string} [options.optimization.kind = 'lm'] - kind of algorithm. By default it's levenberg-marquardt.
- * @param {number} [options.optimization.options.timeout = 10] - maximum time running before break in seconds.
- * @param {object} [options.optimization.options = {}] - options for the specific kind of algorithm.
+ * @param peaks - A list of initial parameters to be optimized. e.g. coming from a peak picking [{x, y, width}].
  */
 
 interface GetSoftMaskOptions {
   sgOptions: {
     windowSize: number;
     polynomial: number;
   };
+  /**
+   * broadRatio
+   * @default 0.0025
+   */
   broadRatio: number;
 }
 
-interface OptionsType extends Partial<GetSoftMaskOptions> {
-  width?: number;
+export interface IJoinBroadPeaksOptions extends Partial<GetSoftMaskOptions> {
+  /**
+   * width limit to join peaks.
+   * @default 0.25
+   */
+  broadWidth?: number;
+  /**
+   * it's specify the kind of shape used to fitting.
+   */
   shape?: Shape1D;
-  optimization?: { kind: string; timeout: number };
-  mask?: boolean[];
+  /**
+   * it's specify the kind and options of the algorithm use to optimize parameters.
+   */
+  optimization?: IOptimizationOptions;
+  broadMask?: boolean[];
 }
 
 export function joinBroadPeaks(
   data: DataXY,
   peakList: Peak1D[],
-  options: OptionsType = {},
+  options: IJoinBroadPeaksOptions = {},
 ): Peak1D[] {
   let {
-    mask,
+    broadMask,
     shape = { kind: 'gaussian' },
-    optimization = { kind: 'lm', timeout: 10 },
+    optimization = { kind: 'lm', options: { timeout: 10 } },
     sgOptions = {
       windowSize: 9,
       polynomial: 3,
     },
     broadRatio = 0.0025,
+    broadWidth = 0.25,
   } = options;
-  let { width = 0.25 } = options;
 
   let max = 0;
   let maxI = 0;
   let count = 1;
   const broadLines: Peak1D[] = [];
   const peaks: Peak1D[] = JSON.parse(JSON.stringify(peakList));
-  const broadMask = !mask
+  const mask = !broadMask
     ? getSoftMask(data, peaks, { sgOptions, broadRatio })
-    : mask;
+    : broadMask;
 
-  if (broadMask.length !== peaks.length) {
+  if (mask.length !== peaks.length) {
     throw new Error('mask length does not match the length of peaksList');
   }
 
   for (let i: number = peaks.length - 1; i >= 0; i--) {
-    if (broadMask[i]) {
+    if (mask[i]) {
       broadLines.push(peaks.splice(i, 1)[0]);
     }
   }
@@ -79,7 +86,7 @@ export function joinBroadPeaks(
   };
   let indexes: number[] = [0];
   for (let i = 1; i < broadLines.length; i++) {
-    if (Math.abs(broadLines[i - 1].x - broadLines[i].x) < width) {
+    if (Math.abs(broadLines[i - 1].x - broadLines[i].x) < broadWidth) {
       candidates.x.push(broadLines[i].x);
       candidates.y.push(broadLines[i].y);
       if (broadLines[i].y > max) {

src/post/optimizePeaks.ts

@@ -2,6 +2,7 @@ import type { DataXY } from 'cheminfo-types';
 import type { Shape1D } from 'ml-peak-shape-generator';
 import { getShape1D } from 'ml-peak-shape-generator';
 import { optimize } from 'ml-spectra-fitting';
+import type { IOptimizationOptions } from 'ml-spectra-fitting';
 import { xGetFromToIndex } from 'ml-spectra-processing';
 
 import type { Peak1D } from '../gsd';
@@ -14,7 +15,7 @@ import { groupPeaks } from './groupPeaks';
  * @param data - An object containing the x and y data to be fitted.
  * @param peakList - A list of initial parameters to be optimized. e.g. coming from a peak picking [{x, y, width}].
  */
-interface OptimizePeaksOptions {
+export interface IOptimizePeaksOptions {
   /**
    * times of width to group peaks.
    * @default 1
@@ -32,29 +33,13 @@ interface OptimizePeaksOptions {
   /**
    * it's specify the kind and options of the algorithm use to optimize parameters.
    */
-  optimization?: {
-    /**
-     * kind of algorithm. By default it's levenberg-marquardt.
-     * @default 'lm'
-     */
-    kind: string;
-    /**
-     * options for the specific kind of algorithm.
-     */
-    options: {
-      /**
-       * maximum time running before break in seconds.
-       * @default 10
-       */
-      timeout: number;
-    };
-  };
+  optimization?: IOptimizationOptions;
 }
 
 export function optimizePeaks(
   data: DataXY,
   peakList: Peak1D[],
-  options: OptimizePeaksOptions = {},
+  options: IOptimizePeaksOptions = {},
 ): Peak1D[] {
   const {
     factorWidth = 1,
@@ -68,7 +53,7 @@ export function optimizePeaks(
         timeout: 10,
       },
     },
-  }: OptimizePeaksOptions = options;
+  }: IOptimizePeaksOptions = options;
 
   if (data.x[0] > data.x[1]) {
     data.x.reverse();
@@ -108,14 +93,10 @@ export function optimizePeaks(
       y: data.y.slice(fromIndex, toIndex),
     };
     if (currentRange.x.length > 5) {
-      let { peaks: optimizedPeaks }: { peaks: Peak1D[] } = optimize(
-        currentRange,
-        peaks,
-        {
-          shape,
-          optimization,
-        },
-      );
+      let { peaks: optimizedPeaks } = optimize(currentRange, peaks, {
+        shape,
+        optimization,
+      });
       results = results.concat(optimizedPeaks);
       // eslint-disable-next-line curly
     } else results = results.concat(peaks);