react-cheminfo 0.69.0 → 0.71.0

package/src/ir/core/irPeaks.ts

@@ -0,0 +1,79 @@
+/**
+ * The bands of an infrared spectrum as a notebook writes them, and back: the
+ * peaks of the host protocol's `spectra.ir.jdx` and `spectra.ir.peaks`.
+ *
+ * The two differ in two ways only: a notebook's transmittance is a fraction
+ * where the viewer holds a percentage, and it calls a band's strength `kind`.
+ */
+
+import { xFindClosestIndex } from 'ml-spectra-processing';
+
+import type { IrPeakValue } from '../../host/core/irKinds.ts';
+
+import { bandAtIndex } from './handPicking.ts';
+import type { IrBand, IrBandStrength } from './irBand.ts';
+import type { IrSpectrum } from './irSpectrum.ts';
+import { orderedBands } from './spectrumBands.ts';
+
+/**
+ * The bands a notebook handed over with a spectrum.
+ *
+ * Each stays where the notebook put it, with the values it gave; a value it
+ * left out is read off the spectrum at the nearest sample, and a strength
+ * letter that is not one of `w`, `m` and `S` is worked out again.
+ * @param spectrum - The spectrum they were picked on.
+ * @param peaks - The peaks, in any order.
+ * @returns The bands, ascending, one per wavenumber.
+ */
+export function bandsFromPeaks(
+  spectrum: IrSpectrum,
+  peaks: readonly IrPeakValue[],
+): IrBand[] {
+  const bands: IrBand[] = [];
+  for (const peak of peaks) {
+    const { wavenumber, absorbance, transmittance, kind } = peak;
+    if (!Number.isFinite(wavenumber)) continue;
+    const read = bandAtIndex(
+      spectrum,
+      xFindClosestIndex(spectrum.wavenumber, wavenumber),
+    );
+    if (read === null) continue;
+    bands.push({
+      ...read,
+      wavenumber,
+      ...(absorbance === undefined ? {} : { absorbance }),
+      ...(transmittance === undefined
+        ? {}
+        : { transmittance: transmittance * 100 }),
+      strength: isStrength(kind) ? kind : read.strength,
+    });
+  }
+  return orderedBands(spectrum.id, bands);
+}
+
+/**
+ * Bands as a notebook keeps them.
+ * @param bands - The bands, as the viewer holds them.
+ * @returns The peaks, in the same order.
+ */
+export function peaksFromBands(bands: readonly IrBand[]): IrPeakValue[] {
+  const peaks: IrPeakValue[] = [];
+  for (const band of bands) {
+    const { wavenumber, absorbance, transmittance, strength } = band;
+    peaks.push({
+      wavenumber,
+      ...(absorbance === undefined ? {} : { absorbance }),
+      ...(transmittance === undefined
+        ? {}
+        : { transmittance: transmittance / 100 }),
+      kind: strength,
+    });
+  }
+  return peaks;
+}
+
+function isStrength(kind: string | undefined): kind is IrBandStrength {
+  return kind !== undefined && STRENGTHS.includes(kind);
+}
+
+const STRENGTHS: readonly string[] = ['w', 'm', 'S'] satisfies IrBandStrength[];

package/src/ir/core/irReducer.ts

@@ -13,10 +13,19 @@
  * closed.
  */
 
+import type { IrBand } from './irBand.ts';
+import {
+  arriving,
+  changeSettings,
+  mapSpectrum,
+  resetSpectrumBands,
+  restoreState,
+  setSpectrumBands,
+} from './irBandState.ts';
 import type { IrPanelId } from './irSidePanels.ts';
 import type { IrDomain, IrSpectrum } from './irSpectrum.ts';
 import type { IrSettings, IrState, IrTool, PartialIrState } from './irState.ts';
-import { isIrWindow, mergeIrSettings } from './irState.ts';
+import { isIrWindow } from './irState.ts';
 
 /** Everything that can be asked of the viewer. */
 export type IrAction =
@@ -26,6 +35,8 @@ export type IrAction =
   | { type: 'renameSpectrum'; id: string; name: string }
   | { type: 'setSpectrumColor'; id: string; color: string }
   | { type: 'setSpectrumVisible'; id: string; visible: boolean }
+  | { type: 'setBands'; id: string; bands: IrBand[] }
+  | { type: 'resetBands'; id: string }
   | { type: 'selectSpectrum'; id: string | null }
   | { type: 'setDomain'; domain: IrDomain }
   | { type: 'resetDomain' }
@@ -46,7 +57,10 @@ export function irReducer(state: IrState, action: IrAction): IrState {
   switch (action.type) {
     case 'addSpectra': {
       if (action.spectra.length === 0) return state;
-      const spectra = [...state.data.spectra, ...action.spectra];
+      const spectra = [
+        ...state.data.spectra,
+        ...arriving(state, action.spectra),
+      ];
       return {
         ...state,
         data: { spectra },
@@ -65,7 +79,7 @@ export function irReducer(state: IrState, action: IrAction): IrState {
     case 'setSpectra': {
       return {
         ...state,
-        data: { spectra: [...action.spectra] },
+        data: { spectra: arriving(state, action.spectra) },
         view: {
           ...state.view,
           selectedId: action.spectra[0]?.id ?? null,
@@ -122,6 +136,14 @@ export function irReducer(state: IrState, action: IrAction): IrState {
       );
     }
 
+    case 'setBands': {
+      return setSpectrumBands(state, action.id, action.bands);
+    }
+
+    case 'resetBands': {
+      return resetSpectrumBands(state, action.id);
+    }
+
     case 'selectSpectrum': {
       if (state.view.selectedId === action.id) return state;
       return { ...state, view: { ...state.view, selectedId: action.id } };
@@ -162,17 +184,11 @@ export function irReducer(state: IrState, action: IrAction): IrState {
     }
 
     case 'setSettings': {
-      const settings = mergeIrSettings(state.settings, action.settings);
-      return { ...state, settings };
+      return changeSettings(state, action.settings);
     }
 
     case 'loadState': {
-      const { data, view, settings } = action.state;
-      return {
-        data: data === undefined ? state.data : { spectra: [...data.spectra] },
-        view: { ...state.view, ...view },
-        settings: mergeIrSettings(state.settings, settings),
-      };
+      return restoreState(state, action.state);
     }
 
     case 'clear': {
@@ -191,29 +207,6 @@ export function irReducer(state: IrState, action: IrAction): IrState {
   }
 }
 
-/**
- * Change one spectrum, leaving the state alone when it did not change.
- * @param state - The state in force.
- * @param id - Which spectrum.
- * @param change - What to make of it; return it unchanged for no change.
- * @returns The new state, or the old one.
- */
-function mapSpectrum(
-  state: IrState,
-  id: string,
-  change: (spectrum: IrSpectrum) => IrSpectrum,
-): IrState {
-  let changed = false;
-  const spectra = state.data.spectra.map((spectrum) => {
-    if (spectrum.id !== id) return spectrum;
-    const next = change(spectrum);
-    if (next !== spectrum) changed = true;
-    return next;
-  });
-  if (!changed) return state;
-  return { ...state, data: { spectra }, view: { ...state.view, error: null } };
-}
-
 /**
  * Refuse an action, saying why.
  * @param state - The state in force.

package/src/ir/core/irSpectrum.ts

@@ -25,6 +25,8 @@ import type { DataXY } from 'cheminfo-types';
 
 import type { ChartDomain } from '../../chart/core/chartDomain.ts';
 
+import type { IrBand } from './irBand.ts';
+
 /**
  * One trace of a measurement: wavenumber against whichever value axis is drawn.
  *
@@ -150,6 +152,20 @@ export interface IrSpectrum {
    * @default false
    */
   excludeFromDomain?: boolean;
+  /**
+   * The bands picked on it, ascending by wavenumber. The viewer picks them
+   * when a spectrum arrives without any; a host may hand them over with it, as
+   * a notebook that keeps them does.
+   * @default undefined
+   */
+  bands?: IrBand[];
+  /**
+   * Whether `bands` were picked by hand — edited in the viewer, or handed over
+   * — rather than found with the picking settings, which re-pick only a list
+   * that was not.
+   * @default false
+   */
+  bandsByHand?: boolean;
 }
 
 /**

package/src/ir/core/irState.ts

@@ -7,10 +7,10 @@
  * `settings` is the workspace, which is how every spectrum is drawn whichever
  * ones happen to be open.
  *
- * The bands are **not** in here. They are derived from the spectra and the
- * picking settings, so holding them would mean holding an answer that has to be
- * kept in step with its own inputs — `useIrEditor` recomputes them instead, and
- * a stale band is then impossible rather than merely unlikely.
+ * The bands are in `data`, each spectrum carrying its own: picked when it
+ * arrives, picked again by the reducer when the settings change while they were
+ * found automatically, and left alone once picked by hand. That is what lets a
+ * band be added or taken away, and a list be handed to a host and back.
  */
 
 import type { IrPanelId, IrSidePanelId } from './irSidePanels.ts';
@@ -18,6 +18,7 @@ import type { IrDomain, IrMode, IrSpectrum } from './irSpectrum.ts';
 import type { IrTechnique } from './irTechnique.ts';
 import { defaultIrMode, irModeFor, offersIrMode } from './irTechnique.ts';
 import type { PickBandsOptions } from './pickBands.ts';
+import { withBands } from './spectrumBands.ts';
 
 /** The document: what a file holds. */
 export interface IrData {
@@ -25,8 +26,11 @@ export interface IrData {
   spectra: IrSpectrum[];
 }
 
-/** What a drag across the chart is for while it is chosen. */
-export type IrTool = 'read' | 'box';
+/**
+ * What a drag across the chart is for while it is chosen, and for `pick`, what
+ * a click is: a band added where it lands, or taken away.
+ */
+export type IrTool = 'read' | 'box' | 'pick';
 
 /** Where you are in the viewer. */
 export interface IrView {
@@ -165,8 +169,11 @@ export function createIrState(options: CreateIrStateOptions = {}): IrState {
     technique,
     mode: defaultIrMode(technique),
   };
+  const merged = mergeIrSettings(opened, settings);
   return {
-    data: { spectra: [...spectra] },
+    data: {
+      spectra: spectra.map((spectrum) => withBands(spectrum, merged.picking)),
+    },
     view: {
       selectedId: spectra[0]?.id ?? null,
       domain: null,
@@ -174,7 +181,7 @@ export function createIrState(options: CreateIrStateOptions = {}): IrState {
       openPanelIds: [...(panelIds ?? DEFAULT_SIDE_PANELS)],
       error: null,
     },
-    settings: mergeIrSettings(opened, settings),
+    settings: merged,
   };
 }
 

package/src/ir/core/pickBands.ts

@@ -21,6 +21,13 @@ import type { IrSpectrum } from './irSpectrum.ts';
 import type { PeakPickingOptions } from './ramanBands.ts';
 import { ramanBands } from './ramanBands.ts';
 
+/**
+ * How many points the picker smooths over before it looks for a band. `ml-gsd`
+ * refuses a trace shorter than that — a few points typed in by hand — rather
+ * than finding no band in it.
+ */
+const SMOOTHING_WINDOW = 9;
+
 /** How the bands are picked. */
 export interface PickBandsOptions {
   /**
@@ -88,7 +95,7 @@ export function pickBands(
     minPeakWidth = 4,
     limit,
   } = options;
-  if (spectrum.wavenumber.length < 2) return [];
+  if (spectrum.wavenumber.length < SMOOTHING_WINDOW) return [];
 
   const picking: PeakPickingOptions = {
     minMaxRatio: minRelativeHeight,
@@ -109,43 +116,6 @@ export function pickBands(
   return kept.toSorted(byAscendingWavenumber);
 }
 
-/**
- * The bands of an infrared spectrum, picked on its absorbance.
- * @param spectrum - The spectrum to pick from.
- * @param picking - Where to pick, and how finely.
- * @returns The bands, in the order they were found; none when the spectrum
- * carries only one of its two axes, since the strength is read off the other.
- */
-function infraredBands(
-  spectrum: IrSpectrum,
-  picking: PeakPickingOptions,
-): IrBand[] {
-  const { id, wavenumber, absorbance, transmittance } = spectrum;
-  if (absorbance === undefined || transmittance === undefined) return [];
-
-  const picked = autoPeakPicking(
-    measurementOf(wavenumber, absorbance, transmittance),
-    // Absorbance, because a band is a maximum there and a minimum in the other.
-    { yVariable: 'a', ...picking },
-  );
-
-  const bands: IrBand[] = [];
-  for (const peak of picked) {
-    if (!Number.isFinite(peak.wavenumber)) continue;
-    bands.push({
-      spectrumId: id,
-      wavenumber: peak.wavenumber,
-      absorbance: peak.absorbance,
-      // `ConvertedPeak.transmittance` is a fraction where the spectrum's own
-      // transmittance is a percentage; brought onto the one scale here so that
-      // nothing downstream has to remember which of the two it is holding.
-      transmittance: peak.transmittance * 100,
-      strength: peak.kind as IrBandStrength,
-    });
-  }
-  return bands;
-}
-
 /**
  * The spectrum as `ir-spectrum` wants it.
  *
@@ -158,7 +128,7 @@ function infraredBands(
  * @param transmittance - Percent transmittance at each.
  * @returns A measurement carrying all three variables.
  */
-function measurementOf(
+export function infraredMeasurement(
   wavenumber: Float64Array,
   absorbance: Float64Array,
   transmittance: Float64Array,
@@ -195,6 +165,43 @@ function measurementOf(
   };
 }
 
+/**
+ * The bands of an infrared spectrum, picked on its absorbance.
+ * @param spectrum - The spectrum to pick from.
+ * @param picking - Where to pick, and how finely.
+ * @returns The bands, in the order they were found; none when the spectrum
+ * carries only one of its two axes, since the strength is read off the other.
+ */
+function infraredBands(
+  spectrum: IrSpectrum,
+  picking: PeakPickingOptions,
+): IrBand[] {
+  const { id, wavenumber, absorbance, transmittance } = spectrum;
+  if (absorbance === undefined || transmittance === undefined) return [];
+
+  const picked = autoPeakPicking(
+    infraredMeasurement(wavenumber, absorbance, transmittance),
+    // Absorbance, because a band is a maximum there and a minimum in the other.
+    { yVariable: 'a', ...picking },
+  );
+
+  const bands: IrBand[] = [];
+  for (const peak of picked) {
+    if (!Number.isFinite(peak.wavenumber)) continue;
+    bands.push({
+      spectrumId: id,
+      wavenumber: peak.wavenumber,
+      absorbance: peak.absorbance,
+      // `ConvertedPeak.transmittance` is a fraction where the spectrum's own
+      // transmittance is a percentage; brought onto the one scale here so that
+      // nothing downstream has to remember which of the two it is holding.
+      transmittance: peak.transmittance * 100,
+      strength: peak.kind as IrBandStrength,
+    });
+  }
+  return bands;
+}
+
 /**
  * Order two bands by height, tallest first.
  * @param first - One band.

package/src/ir/core/ramanBands.ts

@@ -56,7 +56,7 @@ export function ramanBands(
       spectrumId: id,
       wavenumber: peak.wavenumber,
       intensity: value,
-      strength: strengthOf(value, min, max),
+      strength: intensityStrength(value, min, max),
     });
   }
   return bands;
@@ -69,7 +69,7 @@ export function ramanBands(
  * @param highest - Its highest.
  * @returns The letter a correlation table would use.
  */
-function strengthOf(
+export function intensityStrength(
   value: number,
   lowest: number,
   highest: number,

package/src/ir/core/spectrumBands.ts

@@ -0,0 +1,113 @@
+/**
+ * The bands a spectrum carries.
+ *
+ * A spectrum arriving without bands is picked once, with the picking settings
+ * in force, and from then on its bands are part of it: they travel to a host
+ * with it, and a host's own reach the chart. Bands found automatically follow
+ * the settings — moving the threshold picks them again — while bands picked by
+ * hand, or handed over, are left as they are.
+ */
+
+import type { IrBand } from './irBand.ts';
+import type { IrSpectrum } from './irSpectrum.ts';
+import type { PickBandsOptions } from './pickBands.ts';
+import { pickBands } from './pickBands.ts';
+
+/**
+ * A spectrum carrying its bands: picked now when it has none, its own kept and
+ * put in order otherwise.
+ * @param spectrum - The spectrum, as it arrived.
+ * @param picking - How to pick it, if it has to be.
+ * @returns The spectrum with its bands; the same object when it had them, in
+ * order.
+ */
+export function withBands(
+  spectrum: IrSpectrum,
+  picking: PickBandsOptions,
+): IrSpectrum {
+  const { id, bands } = spectrum;
+  if (bands === undefined) {
+    return {
+      ...spectrum,
+      bands: pickBands(spectrum, picking),
+      bandsByHand: false,
+    };
+  }
+  const ordered = orderedBands(id, bands);
+  return ordered === bands ? spectrum : { ...spectrum, bands: ordered };
+}
+
+/**
+ * A spectrum's bands picked again with other settings, unless they were picked
+ * by hand.
+ * @param spectrum - The spectrum.
+ * @param picking - The settings now in force.
+ * @returns The spectrum re-picked, or the same object when its bands are its
+ * own.
+ */
+export function repickBands(
+  spectrum: IrSpectrum,
+  picking: PickBandsOptions,
+): IrSpectrum {
+  if (spectrum.bandsByHand) return spectrum;
+  return {
+    ...spectrum,
+    bands: pickBands(spectrum, picking),
+    bandsByHand: false,
+  };
+}
+
+/**
+ * Bands as a spectrum holds them: ascending, one per wavenumber, each naming
+ * the spectrum, and none at a wavenumber that is not a number.
+ * @param spectrumId - The spectrum they belong to.
+ * @param bands - The bands, in any order.
+ * @returns The bands in order; the same array when they already were.
+ */
+export function orderedBands(spectrumId: string, bands: IrBand[]): IrBand[] {
+  if (isOrdered(spectrumId, bands)) return bands;
+  const kept: IrBand[] = [];
+  for (const band of bands.toSorted(byWavenumber)) {
+    if (!Number.isFinite(band.wavenumber)) continue;
+    if (kept.at(-1)?.wavenumber === band.wavenumber) continue;
+    kept.push(band.spectrumId === spectrumId ? band : { ...band, spectrumId });
+  }
+  return kept;
+}
+
+/**
+ * Whether two picking settings pick the same bands.
+ * @param first - One.
+ * @param second - The other.
+ * @returns Whether every option agrees.
+ */
+export function samePicking(
+  first: PickBandsOptions,
+  second: PickBandsOptions,
+): boolean {
+  return (
+    first === second ||
+    (first.from === second.from &&
+      first.to === second.to &&
+      first.minRelativeHeight === second.minRelativeHeight &&
+      first.minPeakWidth === second.minPeakWidth &&
+      first.limit === second.limit)
+  );
+}
+
+function isOrdered(spectrumId: string, bands: readonly IrBand[]): boolean {
+  let previous = Number.NEGATIVE_INFINITY;
+  for (const band of bands) {
+    const { wavenumber } = band;
+    if (band.spectrumId !== spectrumId || !Number.isFinite(wavenumber)) {
+      return false;
+    }
+    if (wavenumber <= previous) return false;
+    previous = wavenumber;
+  }
+  return true;
+}
+
+function byWavenumber(first: IrBand, second: IrBand): number {
+  return first.wavenumber - second.wavenumber;
+}

package/src/ir/ui/BandRow.tsx

@@ -1,4 +1,4 @@
-import { Icon } from '@blueprintjs/core';
+import { Button, Icon } from '@blueprintjs/core';
 
 import {
   panelCellStyle,
@@ -24,6 +24,11 @@ export interface BandRowProps {
    * @default undefined
    */
   onHighlight?: (band: IrBand | null) => void;
+  /**
+   * Takes the band away; the row ends with the button that calls it.
+   * @default undefined — no button
+   */
+  onRemove?: (band: IrBand) => void;
 }
 
 /**
@@ -37,7 +42,7 @@ export interface BandRowProps {
  * @returns The row.
  */
 export function BandRow(props: BandRowProps) {
-  const { entry, mode, assignments, lit, onHighlight } = props;
+  const { entry, mode, assignments, lit, onHighlight, onRemove } = props;
   const { band } = entry;
 
   return (
@@ -54,6 +59,17 @@ export function BandRow(props: BandRowProps) {
         {formatIrValue(bandValue(band, mode) ?? Number.NaN, mode)}
       </td>
       {assignments ? <CandidatesCell entry={entry} /> : null}
+      {onRemove === undefined ? null : (
+        <td style={removeCellStyle}>
+          <Button
+            variant="minimal"
+            size="small"
+            icon="small-cross"
+            aria-label={`Take away the band at ${formatWavenumber(band.wavenumber)} cm⁻¹`}
+            onClick={() => onRemove(band)}
+          />
+        </td>
+      )}
     </tr>
   );
 }
@@ -105,3 +121,5 @@ const STRENGTH_TITLES = {
 } as const;
 
 const litRowStyle = { background: '#fff3e0' } as const;
+
+const removeCellStyle = { ...panelCellStyle, padding: 0, width: 1 } as const;