feat: reduce oversized spectra to 1024 points

Author: hamed-musallam

src/component/2d/ft/Contours.tsx

@@ -4,9 +4,12 @@ import { memo, useMemo, useRef } from 'react';
 
 import type { LevelSign } from '../../../data/data2d/Spectrum2D/contours.js';
 import { drawContours } from '../../../data/data2d/Spectrum2D/contours.js';
+import { isFt2DSpectrum } from '../../../data/data2d/Spectrum2D/isSpectrum2D.ts';
 import { useChartData } from '../../context/ChartContext.js';
 import { usePreferences } from '../../context/PreferencesContext.js';
 import { useToaster } from '../../context/ToasterContext.js';
+import type { SpectrumData } from '../../hooks/use2DReducer.tsx';
+import { use2DReducer } from '../../hooks/use2DReducer.tsx';
 import { useActiveSpectrum } from '../../hooks/useActiveSpectrum.js';
 import { PathBuilder } from '../../utility/PathBuilder.js';
 import { getSpectraByNucleus } from '../../utility/getSpectraByNucleus.js';
@@ -16,18 +19,15 @@ interface ContoursPathsProps {
   id: string;
   color: string;
   sign: LevelSign;
-  spectrum: Spectrum2D;
+  spectrum: SpectrumData;
   onTimeout: () => void;
 }
 
 interface ContoursInnerProps {
   spectra: Spectrum2D[];
 }
 
-function usePath(
-  spectrum: Spectrum2D,
-  contours: ReturnType<typeof drawContours>['contours'],
-) {
+function usePath(contours: ReturnType<typeof drawContours>['contours']) {
   const scaleX = useScale2DX();
   const scaleY = useScale2DY();
 
@@ -49,7 +49,7 @@ function usePath(
   return pathBuilder.toString();
 }
 
-const useContoursLevel = (spectrum: Spectrum2D, sign: LevelSign) => {
+const useContoursLevel = (spectrum: SpectrumData, sign: LevelSign) => {
   const {
     display: { contourOptions },
   } = spectrum;
@@ -79,7 +79,7 @@ function ContoursPaths({
     return contours;
   }, [spectrum, level, onTimeout, sign]);
 
-  const path = usePath(spectrum, contours);
+  const path = usePath(contours);
 
   const opacity =
     activeSpectrum === null || spectrumID === activeSpectrum.id
@@ -113,10 +113,11 @@ function ContoursInner({ spectra }: ContoursInnerProps) {
   function timeoutHandler() {
     debounceAlert.current();
   }
+  const spectraData = use2DReducer(spectra);
 
   return (
     <g className="contours">
-      {spectra?.map((spectrum) => {
+      {spectraData?.map((spectrum) => {
         return (
           <g key={spectrum.id}>
             {spectrum.display.isPositiveVisible && (
@@ -155,8 +156,8 @@ export default function Contours() {
     },
   } = useChartData();
   const spectra2d = useMemo<Spectrum2D[]>(() => {
-    return getSpectraByNucleus(activeTab, spectra).filter(
-      (datum) => datum.info.isFt,
+    return getSpectraByNucleus(activeTab, spectra).filter((datum) =>
+      isFt2DSpectrum(datum),
     ) as Spectrum2D[];
   }, [activeTab, spectra]);
 

src/component/hooks/use2DReducer.tsx

@@ -0,0 +1,163 @@
+import type { Spectrum2D } from '@zakodium/nmrium-core';
+import type { NmrData2DContent, NmrData2DFt } from 'cheminfo-types';
+import { xyEquallySpaced } from 'ml-spectra-processing';
+
+import { useChartData } from '../context/ChartContext.tsx';
+
+export interface SpectrumData extends Pick<Spectrum2D, 'display' | 'id'> {
+  data: NmrData2DContent;
+}
+export function use2DReducer(spectra: Spectrum2D[]) {
+  const { xDomain, yDomain } = useChartData();
+  const [fromX, toX] = xDomain;
+  const [fromY, toY] = yDomain;
+  const outputSpectra: SpectrumData[] = [];
+  for (const spectrum of spectra) {
+    const { id, display, data } = spectrum;
+    const { rr } = data as NmrData2DFt;
+    const reducedData = reduce2DSpectrum(rr, {
+      fromX,
+      toX,
+      fromY,
+      toY,
+    });
+    outputSpectra.push({
+      data: reducedData,
+      id,
+      display,
+    });
+  }
+  return outputSpectra;
+}
+
+interface Reduce2DSpectrumOptions {
+  numberOfPoints?: number;
+  fromX?: number;
+  toX?: number;
+  fromY?: number;
+  toY?: number;
+}
+
+export function reduce2DSpectrum(
+  data: NmrData2DContent,
+  options: Reduce2DSpectrumOptions,
+) {
+  const {
+    minY: originalMinY,
+    minX: originalMinX,
+    maxY: originalMaxY,
+    maxX: originalMaxX,
+    z,
+  } = data;
+  const { numberOfPoints = 1024, fromX, fromY, toX, toY } = options;
+  const nbPointsY = z.length;
+  const nbPointsX = z[0]?.length || 0;
+
+  if (nbPointsX <= numberOfPoints && nbPointsY <= numberOfPoints) {
+    return data;
+  }
+
+  const minX = fromX ?? originalMinX;
+  const maxX = toX ?? originalMaxX;
+  const minY = fromY ?? originalMinY;
+  const maxY = toY ?? originalMaxY;
+
+  const shouldReduceX = nbPointsX > numberOfPoints;
+  const shouldReduceY = nbPointsY > numberOfPoints;
+
+  const targetPointX = shouldReduceX ? numberOfPoints : nbPointsX;
+  const targetPointY = shouldReduceY ? numberOfPoints : nbPointsY;
+
+  let reducedX: Float64Array[] = [];
+  // Reduce over x dimension
+  if (shouldReduceX) {
+    const xAXis = generate1DArray({
+      min: originalMinX,
+      max: originalMaxX,
+      numberOfPoints: nbPointsX,
+    });
+    for (let row = 0; row < nbPointsY; row++) {
+      const output = xyEquallySpaced(
+        { x: xAXis, y: z[row] },
+        {
+          numberOfPoints: targetPointX,
+          from: minX,
+          to: maxX,
+        },
+      );
+      reducedX[row] = Float64Array.from(output.y);
+    }
+  } else {
+    reducedX = structuredClone(z);
+  }
+
+  if (!shouldReduceY) {
+    return {
+      ...data,
+      minX,
+      maxX,
+      minY,
+      maxY,
+      z: reducedX,
+    };
+  }
+  const yAXis = generate1DArray({
+    min: originalMinY,
+    max: originalMaxY,
+    numberOfPoints: nbPointsY,
+  });
+
+  const reducedMatrix: Float64Array[] = [];
+
+  for (let i = 0; i < targetPointY; i++) {
+    reducedMatrix[i] = new Float64Array(targetPointX);
+  }
+
+  const colBuffer = new Float64Array(nbPointsY);
+
+  //Reduce over y dimension
+  for (let col = 0; col < targetPointX; col++) {
+    for (let row = 0; row < nbPointsY; row++) {
+      colBuffer[row] = reducedX[row][col];
+    }
+    const output = xyEquallySpaced(
+      { x: yAXis, y: colBuffer },
+      {
+        numberOfPoints: targetPointY,
+        from: minY,
+        to: maxY,
+      },
+    );
+
+    //resample column into the matrix
+    for (let row = 0; row < targetPointY; row++) {
+      reducedMatrix[row][col] = output.y[row];
+    }
+  }
+
+  return {
+    ...data,
+    minX,
+    maxX,
+    minY,
+    maxY,
+    z: reducedMatrix,
+  };
+}
+
+interface Generate1DArray {
+  min: number;
+  max: number;
+  numberOfPoints: number;
+}
+
+function generate1DArray(options: Generate1DArray) {
+  const { min, max, numberOfPoints } = options;
+  const array = new Float64Array(numberOfPoints);
+  const step = (max - min) / (numberOfPoints - 1);
+  for (let i = 0; i < numberOfPoints; i++) {
+    array[i] = min + i * step;
+  }
+
+  return array;
+}

src/data/data2d/Spectrum2D/contours.ts

@@ -3,6 +3,7 @@ import type { NmrData2DFt } from 'cheminfo-types';
 import { Conrec } from 'ml-conrec';
 import { xMaxAbsoluteValue } from 'ml-spectra-processing';
 
+import type { SpectrumData } from '../../../component/hooks/use2DReducer.tsx';
 import { calculateSanPlot } from '../../utilities/calculateSanPlot.js';
 
 interface Level {
@@ -184,18 +185,16 @@ function range(from: number, to: number, step: number) {
 
 function drawContours(
   level: ContourItem,
-  spectrum: Spectrum2D,
+  spectrum: SpectrumData,
   negative = false,
-  quadrant = 'rr',
 ) {
   const { contourLevels, numberOfLayers } = level;
 
   return getContours({
     negative,
     boundary: contourLevels,
     nbLevels: numberOfLayers,
-    // @ts-expect-error type of NmrData2D should have a discriminator field to separate fid and ft
-    data: spectrum.data[quadrant],
+    data: spectrum.data,
   });
 }