chore: calculate only missing contour levels

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

@@ -9,6 +9,7 @@ import {
   LevelSign,
 } from '../../../data/data2d/Spectrum2D/contours';
 import { useChartData } from '../../context/ChartContext';
+import { useContourCache } from '../../context/ContourCacheContext';
 import { usePreferences } from '../../context/PreferencesContext';
 import { useToaster } from '../../context/ToasterContext';
 import { useActiveSpectrum } from '../../hooks/useActiveSpectrum';
@@ -76,20 +77,25 @@ function ContoursPaths({
   const activeSpectrum = useActiveSpectrum();
   const preferences = usePreferences();
   const level = useContoursLevel(spectrum, sign);
+  const [cache, setCache] = useContourCache();
 
   const contours = useMemo(() => {
     const { contours, timeout } = drawContours(
       level,
       spectrum,
+      cache,
       sign === 'negative',
     );
     if (timeout) {
       onTimeout();
     }
-    return contours;
-  }, [spectrum, level, onTimeout, sign]);
+    setCache(cache);
+    return { contours, cache };
+  }, [spectrum, level, onTimeout, sign, cache, setCache]);
 
-  const path = usePath(spectrum, contours);
+  // useEffect(() => {}, [setCache, contours]);
+
+  const path = usePath(spectrum, contours.contours);
 
   const opacity =
     activeSpectrum === null || spectrumID === activeSpectrum.id

src/component/context/ContourCacheContext.tsx

@@ -0,0 +1,9 @@
+import React, { createContext, useState } from 'react';
+
+const initialContourCache: Record<string, any> = {};
+const ContourCacheContext = createContext(null);
+export const ContourCacheProvider = ContourCacheContext.Provider;
+export function useContourCache() {
+  React.useContext(ContourCacheContext);
+  return useState(initialContourCache);
+}

src/data/data2d/Spectrum2D/contours.ts

@@ -177,45 +177,67 @@
 function drawContours(
   level: ContourItem,
   spectrum: Spectrum2D,
+  contourCache: Record<string, any>,
   negative = false,
   quadrant = 'rr',
 ) {
   const { contourLevels, numberOfLayers } = level;
+  const key = negative ? 'negative' : 'positive';
 
-  return getContours({
+  const nbLevels = Math.min(
+    numberOfLayers,
+    contourLevels[1] - contourLevels[0],
+  );
+
+  const { id, data } = spectrum;
+  if (!contourCache[id]) {
+    contourCache[id] = {};
+  }
+
+  if (!(key in contourCache[id])) {
+    contourCache[id][key] = { contours: [], timeout: false };
+  }
+
+  const oneSenseContours = contourCache[id][key].contours;
+  const selectedLevels = getRange(
+    Math.max(0, contourLevels[0]),
+    contourLevels[1],
+    nbLevels,
+  ).map((e) => Math.round(e));
+
+  const levels = selectedLevels.filter((level) => !oneSenseContours[level]);
+  const { contours, timeout } = getContours({
+    levels,
     negative,
-    boundary: contourLevels,
-    nbLevels: numberOfLayers,
-    data: spectrum.data[quadrant],
+    data: data[quadrant],
   });
+
+  for (const [i, level] of contours.entries()) {
+    oneSenseContours[levels[i]] = level;
+  }
+  contourCache[id][key] = { contours: oneSenseContours, timeout };
+
+  return {
+    contours: selectedLevels.map((level) => oneSenseContours[level]),
+    timeout,
+  };
 }
 
 interface ContoursCalcOptions {
-  boundary: [number, number];
+  levels: number[];
   negative?: boolean;
   timeout?: number;
-  nbLevels: number;
   data: NmrData2DFt['rr'];
 }
 
 function getContours(options: ContoursCalcOptions) {
-  const {
-    boundary,
-    negative = false,
-    timeout = 2000,
-    nbLevels,
-    data,
-  } = options;
+  const { levels, negative = false, timeout = 2000, data } = options;
   const xs = getRange(data.minX, data.maxX, data.z[0].length);
   const ys = getRange(data.minY, data.maxY, data.z.length);
   const conrec = new Conrec(data.z, { xs, ys, swapAxes: false });
   const max = Math.max(Math.abs(data.minZ), Math.abs(data.maxZ));
-  const minLevel = calculateValueOfLevel(boundary[0], max);
-  const maxLevel = calculateValueOfLevel(boundary[1], max);
-
-  const diffRange = boundary[1] - boundary[0];
 
-  let _range = getRange(minLevel, maxLevel, Math.min(nbLevels, diffRange), 2);
+  let _range = levels.map((level) => calculateValueOfLevel(level, max));
   if (negative) {
     _range = _range.map((value) => -value);
   }