diff --git a/.eslintrc.cjs b/.eslintrc.cjs index cbae52b..409a16f 100644 --- a/.eslintrc.cjs +++ b/.eslintrc.cjs @@ -26,7 +26,7 @@ module.exports = { rules: { 'react/react-in-jsx-scope': 'off', }, - ignorePatterns: ['dist/', 'node_modules/', '.storybook/'], + ignorePatterns: ['dist/', 'node_modules/', '.storybook/', 'storybook-static/'], }; diff --git a/docs/ECGChart.md b/docs/ECGChart.md new file mode 100644 index 0000000..3b08694 --- /dev/null +++ b/docs/ECGChart.md @@ -0,0 +1,378 @@ +# ECGChart Component + +A real-time electrocardiogram (ECG/EKG) visualization component with medical-standard grid display, heart rate calculation, and full color customization. + +## Medical Context + +An **ECG (Electrocardiogram)** records the electrical activity of the heart over time. Each heartbeat produces a characteristic waveform pattern: + +- **P wave**: Atrial depolarization (atria contract) +- **QRS complex**: Ventricular depolarization (ventricles contract) - the sharp spike +- **T wave**: Ventricular repolarization (ventricles relax) + +ECG is used to detect heart rhythm abnormalities, heart attacks, and other cardiac conditions. + +## Installation + +```bash +npm install scadable +``` + +## Import + +```typescript +import { ECGChart } from 'scadable/health'; +``` + +## Basic Usage + +### Real-time Mode + +```tsx +import { ECGChart } from 'scadable/health'; + +function MyComponent() { + return ( + console.log('Heart rate:', bpm)} + /> + ); +} +``` + +### With Pre-configured Device + +```tsx +import { ECGChart, Facility, Device } from 'scadable/health'; + +const facility = new Facility('your-api-key'); +const device = new Device(facility, 'ecg-device-001'); + +function MyComponent() { + return ( + + ); +} +``` + +### Historical Mode + +```tsx +import { ECGChart } from 'scadable/health'; + +const historicalECGData = [0.1, 0.15, 0.8, 0.3, 0.05, -0.1, 0.25, ...]; // ECG values in mV + +function MyComponent() { + return ( + + ); +} +``` + +## Props Reference + +### Connection Props + +| Prop | Type | Required | Description | +|------|------|----------|-------------| +| `apiKey` | `string` | Conditional* | API key for authentication | +| `deviceId` | `string` | Conditional* | Device ID to connect to | +| `device` | `Device` | Conditional* | Pre-configured Device instance | + +*Either provide `device` OR both `apiKey` and `deviceId` (for realtime mode only) + +### Data Props + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `dataPath` | `string` | Required | JSON path to extract ECG value (e.g., ".data.ecg") | +| `mode` | `'realtime' \| 'historical'` | `'realtime'` | Display mode | +| `historicalData` | `number[]` | - | Pre-recorded ECG values (mV) for historical mode | + +### Display Props + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `title` | `string` | `'ECG Monitor'` | Chart title | +| `width` | `number` | `800` | Chart width in pixels | +| `height` | `number` | `400` | Chart height in pixels | + +### Medical Settings + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `sweepSpeed` | `25 \| 50` | `25` | Sweep speed in mm/s (standard: 25 or 50) | +| `gain` | `5 \| 10 \| 20` | `10` | Gain in mm/mV (standard: 5, 10, or 20) | +| `samplingRate` | `number` | `250` | Sampling rate in Hz (typical: 250-1000) | +| `showGrid` | `boolean` | `true` | Show medical-standard ECG grid | +| `showCalibration` | `boolean` | `true` | Show 1mV calibration pulse | +| `bufferDuration` | `number` | `10` | Buffer duration in seconds | + +### Heart Rate Features + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `showHeartRate` | `boolean` | `true` | Show heart rate display and calculation | +| `onHeartRateChange` | `(bpm: number) => void` | - | Callback when heart rate changes | + +### Color Customization + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `waveformColor` | `string` | `'#dc2626'` | ECG waveform color | +| `gridColor` | `string` | `'#f4c2c2'` | Grid line color | +| `backgroundColor` | `string` | `'#ffffff'` | Background color | + +## ECG Grid Explanation + +The ECG grid follows medical standards: +- **Small squares**: 1mm × 1mm + - Horizontal: 0.04 seconds (at 25mm/s) + - Vertical: 0.1mV (at 10mm/mV gain) +- **Large squares**: 5mm × 5mm (5 small squares) + - Horizontal: 0.2 seconds + - Vertical: 0.5mV + +## Sweep Speed and Gain + +### Sweep Speed +- **25 mm/s** (standard): Good for overall rhythm assessment +- **50 mm/s**: Better for detailed waveform analysis + +### Gain +- **5 mm/mV**: For large amplitude signals +- **10 mm/mV** (standard): Most common setting +- **20 mm/mV**: For small amplitude signals + +## Expected Data Format + +The component expects WebSocket data in this format: + +```json +{ + "broker_id": "service-mqtt-...", + "device_id": "ecg-device-001", + "timestamp": "2025-11-06T19:54:50.802Z", + "data": { + "ecg": 0.85 + } +} +``` + +Where `ecg` is the voltage value in **millivolts (mV)**. + +Use `dataPath` to extract the value. For the above example: `dataPath=".data.ecg"` + +## Heart Rate Calculation + +When `showHeartRate={true}`, the component: +1. Detects R-peaks in the QRS complex using the Pan-Tompkins algorithm +2. Calculates R-R intervals (time between peaks) +3. Computes BPM: `60000 / average_RR_interval_ms` +4. Updates every 500ms +5. Colors the heart rate: + - **Green**: 60-100 BPM (normal) + - **Red**: <60 or >100 BPM (abnormal) + +## Color Customization Examples + +### Classic Medical (Default) +```tsx + +``` + +### Blue Theme +```tsx + +``` + +### Dark Mode +```tsx + +``` + +### High Contrast +```tsx + +``` + +## Performance + +- Supports up to **1000 Hz** sampling rate +- Renders at **60 FPS** using hardware-accelerated Canvas +- Memory efficient with circular buffer (default 10-second buffer) +- Optimized for mobile devices (30+ FPS) + +## Best Practices + +### 1. Choose Appropriate Settings +```tsx +// For rhythm analysis + + +// For detailed waveform analysis + +``` + +### 2. Handle Heart Rate Updates +```tsx +const [currentBPM, setCurrentBPM] = useState(0); + + { + setCurrentBPM(bpm); + if (bpm > 120) { + alert('High heart rate detected!'); + } + }} +/> +``` + +### 3. Responsive Sizing +```tsx +
+ 800 ? 800 : 600} + height={window.innerWidth > 800 ? 400 : 300} + /> +
+``` + +### 4. Error Handling +The component displays connection errors automatically. No additional error handling needed. + +## Medical Disclaimer + +⚠️ **IMPORTANT**: This component is for **visualization purposes only** and is **NOT intended for medical diagnosis or treatment**. + +- Do not use for clinical decision-making +- Do not use as a replacement for medical-grade equipment +- Always consult qualified healthcare professionals +- This is educational/demo software, not medical device software + +## Browser Compatibility + +- Chrome/Edge: ✅ Full support +- Firefox: ✅ Full support +- Safari: ✅ Full support +- Mobile browsers: ✅ Full support (with reduced FPS on older devices) + +Requires: +- HTML5 Canvas support +- ES6+ JavaScript +- WebSocket support (for realtime mode) + +## Troubleshooting + +### No waveform displayed +- Check that `dataPath` matches your data structure +- Verify WebSocket connection is active (check connection indicator) +- Ensure ECG values are in millivolts (mV), typically -2 to +2 range + +### Heart rate shows "--" +- Need at least 2 heartbeats for calculation +- Check that R-peaks are detectable (gain may be too low) +- Ensure sampling rate is configured correctly + +### Poor performance +- Reduce `samplingRate` if not using medical-grade precision +- Reduce `bufferDuration` to use less memory +- Disable `showHeartRate` if not needed (saves CPU) + +## Examples + +### Multiple Patients Dashboard +```tsx +import { ECGChart, Facility, Device } from 'scadable/health'; + +function ICUDashboard() { + const facility = new Facility('your-api-key'); + + return ( +
+ + +
+ ); +} +``` + +### With Alert System +```tsx +function ECGWithAlerts() { + const handleHeartRateChange = (bpm: number) => { + if (bpm > 120) { + console.error('Tachycardia detected!'); + // Trigger alert system + } else if (bpm < 50) { + console.error('Bradycardia detected!'); + // Trigger alert system + } + }; + + return ( + + ); +} +``` + +## Related Components + +- [EEGChart](./EEGChart.md) - Multi-channel brain wave visualization +- [LiveTelemetryLineChart](./LiveTelemetryLineChart.md) - General-purpose line chart + +## Support + +For issues or questions: +- GitHub Issues: https://github.com/scadable/library-react/issues +- Documentation: https://github.com/scadable/library-react diff --git a/docs/EEGChart.md b/docs/EEGChart.md new file mode 100644 index 0000000..1b70eb0 --- /dev/null +++ b/docs/EEGChart.md @@ -0,0 +1,522 @@ +# EEGChart Component + +A real-time electroencephalogram (EEG) visualization component for multi-channel brain wave monitoring with optional spectral analysis and customizable display modes. + +## Medical Context + +An **EEG (Electroencephalogram)** records electrical activity in the brain using multiple electrodes placed on the scalp. EEG is used to: + +- Diagnose epilepsy and seizure disorders +- Study sleep patterns and disorders +- Monitor brain activity during surgery +- Research cognitive processes and brain states +- Detect brain injuries and abnormalities + +### Frequency Bands + +Brain waves are categorized into five main frequency bands: + +| Band | Frequency | Mental State | +|------|-----------|--------------| +| **Delta (δ)** | 0.5-4 Hz | Deep sleep, unconscious | +| **Theta (θ)** | 4-8 Hz | Drowsiness, meditation, creativity | +| **Alpha (α)** | 8-13 Hz | Relaxed, calm, awake | +| **Beta (β)** | 13-30 Hz | Active thinking, concentration, alertness | +| **Gamma (γ)** | 30-100 Hz | High-level information processing | + +## Installation + +```bash +npm install scadable +``` + +## Import + +```typescript +import { EEGChart, EEGChannelConfig } from 'scadable/health'; +``` + +## Basic Usage + +### Real-time 4-Channel EEG + +```tsx +import { EEGChart, EEGChannelConfig } from 'scadable/health'; + +function MyComponent() { + const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, + { name: 'C3', dataPath: '.data.channels.C3', color: '#f59e0b' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#ef4444' }, + ]; + + return ( + + ); +} +``` + +### With Spectral Analysis + +```tsx +import { EEGChart, EEGChannelConfig } from 'scadable/health'; + +function MyComponent() { + const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, + ]; + + return ( + + ); +} +``` + +### Historical Mode + +```tsx +import { EEGChart, EEGChannelConfig } from 'scadable/health'; + +const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, +]; + +const historicalData = new Map([ + ['Fp1', [12.5, 15.3, 18.2, ...]], + ['Fp2', [10.1, 13.8, 16.5, ...]], +]); + +function MyComponent() { + return ( + + ); +} +``` + +## Props Reference + +### Connection Props + +| Prop | Type | Required | Description | +|------|------|----------|-------------| +| `apiKey` | `string` | Conditional* | API key for authentication | +| `deviceId` | `string` | Conditional* | Device ID to connect to | +| `device` | `Device` | Conditional* | Pre-configured Device instance | + +*Either provide `device` OR both `apiKey` and `deviceId` (for realtime mode only) + +### Data Props + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `channels` | `EEGChannelConfig[]` | Required | Channel configurations (see below) | +| `mode` | `'realtime' \| 'historical'` | `'realtime'` | Display mode | +| `historicalData` | `Map` | - | Pre-recorded channel data for historical mode | + +### Display Props + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `title` | `string` | `'EEG Monitor'` | Chart title | +| `width` | `number` | `1000` | Chart width in pixels | +| `height` | `number` | `600` | Chart height in pixels | +| `layout` | `'stacked' \| 'overlay'` | `'stacked'` | Channel display layout | +| `showLabels` | `boolean` | `true` | Show channel labels | + +### Medical Settings + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `sensitivity` | `number` | `70` | Sensitivity in µV/mm (standard: 5-100) | +| `timeWindow` | `number` | `10` | Time window in seconds | +| `samplingRate` | `number` | `256` | Sampling rate in Hz (typical: 256-512) | + +### Spectral Analysis + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `showSpectralAnalysis` | `boolean` | `false` | Show spectral analysis panel | +| `frequencyBands` | `Array<'delta' \| 'theta' \| 'alpha' \| 'beta' \| 'gamma'>` | All bands | Which frequency bands to analyze | + +### Color Customization + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `backgroundColor` | `string` | `'#ffffff'` | Background color | +| `gridColor` | `string` | `'#e5e7eb'` | Grid line color | +| `textColor` | `string` | `'#1f2937'` | Text color | + +## EEGChannelConfig + +```typescript +interface EEGChannelConfig { + name: string; // Channel name (e.g., "Fp1", "C3") + dataPath: string; // JSON path to extract value + color: string; // Channel display color +} +``` + +## Channel Naming (10-20 System) + +The international 10-20 system standardizes electrode placement: + +- **Fp**: Frontal pole (Fp1, Fp2) +- **F**: Frontal (F3, F4, F7, F8, Fz) +- **C**: Central (C3, C4, Cz) +- **T**: Temporal (T3, T4, T5, T6) +- **P**: Parietal (P3, P4, Pz) +- **O**: Occipital (O1, O2) + +Odd numbers = left hemisphere, Even numbers = right hemisphere, z = midline + +## Expected Data Format + +The component expects WebSocket data in this format: + +```json +{ + "broker_id": "service-mqtt-...", + "device_id": "eeg-device-001", + "timestamp": "2025-11-06T19:54:50.802Z", + "data": { + "channels": { + "Fp1": 45.2, + "Fp2": 42.8, + "C3": 38.5, + "C4": 40.1 + } + } +} +``` + +Where channel values are in **microvolts (µV)**. + +## Layout Modes + +### Stacked Layout +- Each channel has its own horizontal baseline +- Easy to identify individual channels +- Best for monitoring multiple channels +- Default and most common mode + +```tsx + +``` + +### Overlay Layout +- All channels share the same baseline +- Easy to compare waveform synchronization +- Useful for correlation analysis +- Better for fewer channels (2-4) + +```tsx + +``` + +## Spectral Analysis + +When `showSpectralAnalysis={true}`, the component: +1. Performs FFT (Fast Fourier Transform) on each channel +2. Calculates power in each frequency band +3. Identifies the dominant frequency band +4. Updates analysis every second +5. Displays results in a side panel + +### Interpreting Results + +```tsx + +``` + +Example output: +- **High Alpha**: Relaxed, meditative state +- **High Beta**: Active thinking, concentration +- **High Theta**: Drowsy, creative state +- **High Delta**: Deep sleep + +## Sensitivity Settings + +Sensitivity controls the vertical scale (µV per mm): + +| Sensitivity | Use Case | +|-------------|----------| +| **30 µV/mm** | High amplification, small signals | +| **50 µV/mm** | Standard clinical setting | +| **70 µV/mm** | Default, balanced view | +| **100 µV/mm** | Lower amplification, large signals | + +```tsx +// High sensitivity for small signals + + +// Low sensitivity for large signals + +``` + +## Color Customization Examples + +### Standard Medical +```tsx + +``` + +### Dark Mode +```tsx + +``` + +### High Contrast +```tsx + +``` + +### Per-Channel Colors +```tsx +const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#FF0000' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#00FF00' }, + { name: 'C3', dataPath: '.data.channels.C3', color: '#0000FF' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#FFFF00' }, +]; +``` + +## Performance + +- Supports up to **1024 Hz** sampling rate +- Renders at **60 FPS** using hardware-accelerated Canvas +- Efficiently handles 8+ channels simultaneously +- Memory efficient with per-channel circular buffers +- Spectral analysis runs in background without blocking rendering + +## Best Practices + +### 1. Choose Appropriate Layout +```tsx +// For 4+ channels, use stacked + + +// For 2-3 channels comparison, use overlay + +``` + +### 2. Configure Sensitivity Based on Signal +```tsx +// For adult scalp EEG (typical 50-100 µV) + + +// For pediatric EEG (higher amplitude) + +``` + +### 3. Use Descriptive Channel Names +```tsx +const channels: EEGChannelConfig[] = [ + { name: 'Left Frontal', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Right Frontal', dataPath: '.data.channels.Fp2', color: '#10b981' }, +]; +``` + +### 4. Responsive Design +```tsx + +``` + +## Common Montages + +### Bipolar Montage (Double Banana) +```tsx +const channels: EEGChannelConfig[] = [ + { name: 'Fp1-F3', dataPath: '.data.bipolar.Fp1_F3', color: '#3b82f6' }, + { name: 'F3-C3', dataPath: '.data.bipolar.F3_C3', color: '#10b981' }, + { name: 'C3-P3', dataPath: '.data.bipolar.C3_P3', color: '#f59e0b' }, + { name: 'P3-O1', dataPath: '.data.bipolar.P3_O1', color: '#ef4444' }, +]; +``` + +### Referential Montage +```tsx +const channels: EEGChannelConfig[] = [ + { name: 'Fp1-A1', dataPath: '.data.referential.Fp1', color: '#3b82f6' }, + { name: 'Fp2-A2', dataPath: '.data.referential.Fp2', color: '#10b981' }, + { name: 'C3-A1', dataPath: '.data.referential.C3', color: '#f59e0b' }, + { name: 'C4-A2', dataPath: '.data.referential.C4', color: '#ef4444' }, +]; +``` + +## Medical Disclaimer + +⚠️ **IMPORTANT**: This component is for **visualization purposes only** and is **NOT intended for medical diagnosis or treatment**. + +- Do not use for clinical decision-making +- Do not use as a replacement for medical-grade EEG equipment +- Always consult qualified healthcare professionals +- This is educational/demo software, not medical device software +- Not approved by FDA or other regulatory agencies + +## Browser Compatibility + +- Chrome/Edge: ✅ Full support +- Firefox: ✅ Full support +- Safari: ✅ Full support +- Mobile browsers: ✅ Full support (may have reduced performance with 8+ channels) + +Requires: +- HTML5 Canvas support +- ES6+ JavaScript +- WebSocket support (for realtime mode) + +## Troubleshooting + +### Channels not displaying +- Verify `dataPath` matches your data structure +- Check WebSocket connection (connection indicator) +- Ensure channel values are in microvolts (µV), typically 0-100 range + +### Waveforms too small/large +- Adjust `sensitivity` prop (lower = larger waveform) +- Check that values are in µV, not mV or V + +### Spectral analysis not updating +- Ensure enough data is collected (need at least 1 second of data) +- Check `samplingRate` matches your actual data rate +- Verify `showSpectralAnalysis={true}` is set + +### Poor performance with many channels +- Reduce `samplingRate` if medical precision not required +- Reduce `timeWindow` to use less memory +- Disable `showSpectralAnalysis` if not needed +- Use fewer channels (8 or less recommended) + +## Examples + +### Sleep Study Monitor +```tsx +import { EEGChart, EEGChannelConfig } from 'scadable/health'; + +function SleepStudy() { + const channels: EEGChannelConfig[] = [ + { name: 'C3', dataPath: '.data.channels.C3', color: '#3b82f6' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#10b981' }, + ]; + + return ( + + ); +} +``` + +### Full Clinical Montage +```tsx +function ClinicalEEG() { + const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, + { name: 'F3', dataPath: '.data.channels.F3', color: '#f59e0b' }, + { name: 'F4', dataPath: '.data.channels.F4', color: '#ef4444' }, + { name: 'C3', dataPath: '.data.channels.C3', color: '#8b5cf6' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#ec4899' }, + { name: 'P3', dataPath: '.data.channels.P3', color: '#06b6d4' }, + { name: 'P4', dataPath: '.data.channels.P4', color: '#84cc16' }, + { name: 'O1', dataPath: '.data.channels.O1', color: '#f97316' }, + { name: 'O2', dataPath: '.data.channels.O2', color: '#14b8a6' }, + ]; + + return ( + + ); +} +``` + +### Meditation Monitor +```tsx +function MeditationMonitor() { + const channels: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + ]; + + return ( +
+

Meditation Session

+ +

High Alpha = Deep relaxation, High Theta = Meditative state

+
+ ); +} +``` + +## Related Components + +- [ECGChart](./ECGChart.md) - Heart electrical activity visualization +- [LiveTelemetryLineChart](./LiveTelemetryLineChart.md) - General-purpose line chart + +## Support + +For issues or questions: +- GitHub Issues: https://github.com/scadable/library-react/issues +- Documentation: https://github.com/scadable/library-react diff --git a/docs/LiveTelemetryGage.md b/docs/LiveTelemetryGage.md new file mode 100644 index 0000000..4334c4a --- /dev/null +++ b/docs/LiveTelemetryGage.md @@ -0,0 +1,393 @@ +# LiveTelemetryGage + +A modern, animated circular gauge component for displaying real-time telemetry data from WebSocket connections. Perfect for SCADA systems, IoT dashboards, and monitoring applications that need at-a-glance status indicators. + +## Features + +- 🎯 **Real-time gauge visualization** - Displays live streaming data on a circular gauge +- 🌈 **Dynamic color transitions** - Smooth color changes from green (low) to yellow (mid) to red (high) +- ✨ **Modern design** - Sleek, minimalist SVG-based gauge with smooth animations +- 📊 **Customizable ranges** - Set min/max values to match your sensor specifications +- 🎨 **Custom color schemes** - Configure colors for different value ranges +- 🔢 **Flexible formatting** - Control decimal places and unit labels +- 🟢 **Live status indicator** - Visual connection status badge +- 🔌 **WebSocket powered** - Real-time data through WebSocket connections + +## Installation + +```bash +npm install scadable +``` + +## Basic Usage + +### Simple Example + +```tsx +import { LiveTelemetryGage } from 'scadable'; + +function TemperatureGauge() { + return ( + + ); +} +``` + +### Using a Device Instance + +For more control, you can pass a pre-configured `Device` instance: + +```tsx +import { Facility, Device, LiveTelemetryGage } from 'scadable'; + +function PressureGauge() { + const facility = new Facility('your-api-key'); + const device = new Device(facility, 'your-device-id'); + + return ( + + ); +} +``` + +## Understanding JSON Paths + +The gauge uses **JSON path notation** to extract data from the WebSocket payload. Given this example payload: + +```json +{ + "broker_id": "service-mqtt-6446d94bf6-pn8x7", + "device_id": "mifKUN32sahJNOvo", + "payload": "Mw==", + "qos": 0, + "timestamp": "2025-11-06T19:54:50.802707085Z", + "topic": "sensors/temperature", + "data": { + "temperature": 72.5, + "pressure": 145.3, + "rpm": 3500 + } +} +``` + +You would configure: + +- **dataPath**: `".data.temperature"` - Extracts the temperature from the nested data object + +### Path Examples + +| Path | Extracts | Value | +|------|----------|-------| +| `".data.temperature"` | Nested temperature | `72.5` | +| `".data.pressure"` | Nested pressure | `145.3` | +| `".data.rpm"` | Nested RPM | `3500` | +| `".qos"` | Quality of service | `0` | + +## Props Reference + +### Required Props + +| Prop | Type | Description | +|------|------|-------------| +| `title` | `string` | Gauge title displayed at the top | +| `dataPath` | `string` | JSON path to extract value (e.g., `".data.temperature"`) | +| `min` | `number` | Minimum range value (gauge starts here) | +| `max` | `number` | Maximum range value (gauge ends here) | + +### Connection Props (Choose One) + +Either provide a Device instance OR apiKey + deviceId: + +| Prop | Type | Description | +|------|------|-------------| +| `device` | `Device` | Pre-configured Device instance | +| `apiKey` | `string` | API key for authentication | +| `deviceId` | `string` | Device ID to connect to | + +### Optional Props + +| Prop | Type | Default | Description | +|------|------|---------|-------------| +| `unit` | `string` | `""` | Unit label (e.g., "°C", "PSI", "RPM") | +| `decimals` | `number` | `1` | Number of decimal places to display | +| `size` | `number` | `300` | Gauge width and height in pixels | +| `colorLow` | `string` | `"#22c55e"` | Color for low values (green) | +| `colorMid` | `string` | `"#eab308"` | Color for medium values (yellow) | +| `colorHigh` | `string` | `"#ef4444"` | Color for high values (red) | + +## Advanced Examples + +### Temperature Gauge with Custom Range + +```tsx + +``` + +### Pressure Gauge with Custom Colors + +```tsx + +``` + +### RPM Gauge (No Decimals) + +```tsx + +``` + +### Multiple Gauges Dashboard + +```tsx +import { LiveTelemetryGage } from 'scadable'; + +function Dashboard() { + return ( +
+ + + + + +
+ ); +} +``` + +### Compact Gauges for Space-Constrained UIs + +```tsx + +``` + +## Best Practices + +### Setting Min/Max Range + +Choose `min` and `max` based on your sensor specifications: + +- ✅ **Good**: `min={0}`, `max={100}` for 0-100°C temperature sensor +- ✅ **Good**: `min={0}`, `max={200}` for 0-200 PSI pressure sensor +- ✅ **Good**: `min={0}`, `max={10000}` for 0-10k RPM motor +- ❌ **Bad**: `min={0}`, `max={1000}` for data that only goes 0-50 (gauge mostly empty) + +### Decimal Places + +Balance between precision and readability: + +- **0 decimals**: Good for RPM, counts, large numbers (e.g., `3500 RPM`) +- **1 decimal**: Good for temperature, pressure (e.g., `72.5 °C`) +- **2 decimals**: Good for precise measurements (e.g., `3.14 V`) + +### Gauge Size + +Choose size based on your layout: + +- **180-200px**: Compact, for multi-gauge dashboards +- **250-300px**: Standard, good for most use cases (default: 300) +- **320-400px**: Large, for primary/critical metrics + +### Color Schemes + +#### Standard (Traffic Light) +```tsx +colorLow="#22c55e" // Green (good) +colorMid="#eab308" // Yellow (warning) +colorHigh="#ef4444" // Red (danger) +``` + +#### Cool (Blue to Pink) +```tsx +colorLow="#3b82f6" // Blue +colorMid="#8b5cf6" // Purple +colorHigh="#ec4899" // Pink +``` + +#### Monochrome (Single Color Intensity) +```tsx +colorLow="#cbd5e1" // Light gray +colorMid="#64748b" // Medium gray +colorHigh="#1e293b" // Dark gray +``` + +## Color Transition Logic + +The gauge automatically changes color based on the current value percentage: + +- **0-33%** of range: Uses `colorLow` +- **34-66%** of range: Uses `colorMid` +- **67-100%** of range: Uses `colorHigh` + +For example, with `min={0}` and `max={100}`: +- Value 25: Green (`colorLow`) +- Value 50: Yellow (`colorMid`) +- Value 85: Red (`colorHigh`) + +## Visual Design + +The gauge includes: + +- **Circular arc** (270° sweep from bottom-left to bottom-right) +- **Large centered value** with dynamic color +- **Unit label** below the value +- **Min/Max labels** at arc endpoints +- **Range display** below the gauge +- **Live status badge** (top-right corner with pulsing indicator) +- **Smooth transitions** (0.5s ease-out animations) +- **Drop shadow** on the active arc for depth + +## Troubleshooting + +### Gauge not displaying data + +1. Verify your API key and device ID are correct +2. Check that the WebSocket connection shows "Live" status +3. Verify JSON path matches your payload structure +4. Check browser console for errors +5. Ensure the extracted value is a number + +### Gauge shows "--" + +- No data received yet (connection establishing) +- JSON path doesn't match payload structure +- Value at path is not a valid number + +### Range issues + +- Ensure `min < max` +- Set range to match sensor specifications +- Value outside range will be clamped to 0% or 100% + +### Colors not changing + +- Verify `colorLow`, `colorMid`, `colorHigh` are valid CSS colors +- Colors transition at 33% and 67% boundaries +- Check that values are in expected range + +## Accessibility + +The gauge component: + +- Uses semantic HTML and ARIA-compliant SVG +- Includes text labels for screen readers +- Displays numerical value prominently +- Shows connection status visually and textually + +## Performance + +- Lightweight SVG-based rendering +- Smooth CSS transitions (no JavaScript animation loops) +- Efficient WebSocket data handling +- Minimal re-renders with React hooks + +## TypeScript Support + +The component is fully typed. Import types: + +```tsx +import type { LiveTelemetryGageProps } from 'scadable'; + +const gaugeProps: LiveTelemetryGageProps = { + device: myDevice, + title: "My Gauge", + dataPath: ".data.value", + min: 0, + max: 100, + unit: "V", + decimals: 2, + size: 300, +}; +``` + +## See Also + +- [Facility Class](./Facility.md) +- [Device Class](./Device.md) +- [useLiveTelemetry Hook](./useLiveTelemetry.md) +- [LiveTelemetryLineChart Component](./LiveTelemetryLineChart.md) diff --git a/package.json b/package.json index a854d09..854dad6 100644 --- a/package.json +++ b/package.json @@ -10,6 +10,11 @@ "types": "./dist/index.d.ts", "import": "./dist/index.mjs", "require": "./dist/index.js" + }, + "./health": { + "types": "./dist/health.d.ts", + "import": "./dist/health.mjs", + "require": "./dist/health.js" } }, "scripts": { diff --git a/src/components/ECGChart.stories.tsx b/src/components/ECGChart.stories.tsx new file mode 100644 index 0000000..4edf1db --- /dev/null +++ b/src/components/ECGChart.stories.tsx @@ -0,0 +1,284 @@ +import React from 'react'; +import type { Meta, StoryObj } from '@storybook/react'; +import { ECGChart } from './ECGChart'; +import { Device } from '../core/Device'; +import { Facility } from '../core/Facility'; + +// Mock ECG Device that generates realistic ECG waveform with P-QRS-T pattern +class MockECGDevice extends Device { + private mockInterval: ReturnType | null = null; + private sampleIndex: number = 0; + private heartRate: number = 75; // BPM + + constructor(facility: Facility, deviceId: string, heartRate: number = 75) { + super(facility, deviceId); + this.heartRate = heartRate; + } + + // Generate realistic ECG waveform (P-QRS-T pattern) + private generateECGValue(): number { + const samplesPerBeat = (60 / this.heartRate) * 250; // 250 Hz sampling + const position = (this.sampleIndex % samplesPerBeat) / samplesPerBeat; + + let value = 0; + + // P wave (atrial depolarization) - small bump at ~0.15 + if (position >= 0.12 && position <= 0.18) { + const pPosition = (position - 0.12) / 0.06; + value += 0.15 * Math.sin(pPosition * Math.PI); + } + + // QRS complex (ventricular depolarization) - sharp spike at ~0.35 + if (position >= 0.32 && position <= 0.42) { + const qrsPosition = (position - 0.32) / 0.1; + if (qrsPosition < 0.2) { + // Q wave (small dip) + value += -0.1 * Math.sin(qrsPosition * 5 * Math.PI); + } else if (qrsPosition < 0.6) { + // R wave (tall spike) + value += 1.2 * Math.sin((qrsPosition - 0.2) * 2.5 * Math.PI); + } else { + // S wave (small dip) + value += -0.15 * Math.sin((qrsPosition - 0.6) * 2.5 * Math.PI); + } + } + + // T wave (ventricular repolarization) - rounded bump at ~0.6 + if (position >= 0.52 && position <= 0.68) { + const tPosition = (position - 0.52) / 0.16; + value += 0.25 * Math.sin(tPosition * Math.PI); + } + + // Add small baseline noise + value += (Math.random() - 0.5) * 0.02; + + this.sampleIndex++; + return value; + } + + connect(): void { + setTimeout(() => { + (this as any).updateConnectionStatus('connected'); + + // Send ECG data at 250 Hz (4ms intervals) + this.mockInterval = setInterval(() => { + const ecgValue = this.generateECGValue(); + const mockPayload = { + broker_id: "service-mqtt-mock-ecg", + device_id: this.deviceId, + payload: "ecg", + qos: 0, + timestamp: new Date().toISOString(), + topic: "health/ecg", + data: { + ecg: parseFloat(ecgValue.toFixed(3)), + }, + }; + (this as any).handleMessage(JSON.stringify(mockPayload)); + }, 4); // 4ms = 250 Hz + }, 500); + } + + disconnect(): void { + if (this.mockInterval) { + clearInterval(this.mockInterval); + } + (this as any).updateConnectionStatus('disconnected'); + } +} + +const meta: Meta = { + title: 'Health/ECGChart', + component: ECGChart, + tags: ['autodocs'], + parameters: { + docs: { + description: { + component: 'Real-time ECG (electrocardiogram) visualization component with medical-standard grid and heart rate calculation. Displays P-QRS-T waveform pattern with customizable colors and settings.', + }, + }, + }, +}; + +export default meta; + +type Story = StoryObj; + +const mockFacility = new Facility('storybook-api-key'); +const mockDevice1 = new MockECGDevice(mockFacility, 'ecg-device-1', 75); +const mockDevice2 = new MockECGDevice(mockFacility, 'ecg-device-2', 90); +const mockDevice3 = new MockECGDevice(mockFacility, 'ecg-device-3', 60); + +export const StandardECG: Story = { + args: { + device: mockDevice1, + title: 'ECG Monitor - Standard Settings', + dataPath: '.data.ecg', + mode: 'realtime', + sweepSpeed: 25, + gain: 10, + samplingRate: 250, + showGrid: true, + showCalibration: true, + showHeartRate: true, + width: 800, + height: 400, + }, + render: (args) => ( +
+

+ Standard ECG display with 25mm/s sweep speed and 10mm/mV gain. Watch the realistic P-QRS-T waveform pattern and live heart rate calculation. +

+ +
+

ECG Waveform Components:

+
    +
  • P wave: Atrial depolarization (small bump before main spike)
    • +
  • QRS complex: Ventricular depolarization (sharp tall spike)
    • +
  • T wave: Ventricular repolarization (rounded bump after spike)
    • +
+
+
+ ), +}; + +export const HighSpeedECG: Story = { + args: { + device: mockDevice2, + title: 'ECG Monitor - High Speed', + dataPath: '.data.ecg', + mode: 'realtime', + sweepSpeed: 50, + gain: 10, + samplingRate: 250, + showGrid: true, + showCalibration: true, + showHeartRate: true, + width: 800, + height: 400, + }, + render: (args) => ( +
+

+ High-speed ECG display with 50mm/s sweep for detailed waveform analysis. Heart rate: ~90 BPM. +

+ +
+ ), +}; + +export const CustomColors: Story = { + args: { + device: mockDevice3, + title: 'ECG Monitor - Custom Theme', + dataPath: '.data.ecg', + mode: 'realtime', + sweepSpeed: 25, + gain: 10, + samplingRate: 250, + showGrid: true, + showCalibration: true, + showHeartRate: true, + waveformColor: '#3b82f6', + gridColor: '#93c5fd', + backgroundColor: '#eff6ff', + width: 800, + height: 400, + }, + render: (args) => ( +
+

+ Custom blue color scheme demonstrating full color customization. Heart rate: ~60 BPM (normal resting). +

+ +
+ ), +}; + +export const DarkModeECG: Story = { + args: { + device: new MockECGDevice(mockFacility, 'ecg-device-dark', 75), + title: 'ECG Monitor - Dark Mode', + dataPath: '.data.ecg', + mode: 'realtime', + sweepSpeed: 25, + gain: 10, + samplingRate: 250, + showGrid: true, + showCalibration: true, + showHeartRate: true, + waveformColor: '#22c55e', + gridColor: '#374151', + backgroundColor: '#1f2937', + width: 800, + height: 400, + }, + render: (args) => ( +
+

+ Dark mode ECG display with green waveform - perfect for low-light environments. +

+ +
+ ), +}; + +export const HighGainECG: Story = { + args: { + device: new MockECGDevice(mockFacility, 'ecg-device-highgain', 75), + title: 'ECG Monitor - High Gain', + dataPath: '.data.ecg', + mode: 'realtime', + sweepSpeed: 25, + gain: 20, + samplingRate: 250, + showGrid: true, + showCalibration: true, + showHeartRate: true, + width: 800, + height: 400, + }, + render: (args) => ( +
+

+ High gain (20mm/mV) for amplifying small signals. Notice the larger waveform amplitude and calibration pulse. +

+ +
+ ), +}; + +export const MultipleECGMonitors: Story = { + render: () => { + const device1 = new MockECGDevice(mockFacility, 'ecg-multi-1', 75); + const device2 = new MockECGDevice(mockFacility, 'ecg-multi-2', 85); + + return ( +
+

+ Multiple ECG monitors displaying different patients simultaneously. +

+
+ + +
+
+ ); + }, +}; diff --git a/src/components/ECGChart.tsx b/src/components/ECGChart.tsx new file mode 100644 index 0000000..02379a4 --- /dev/null +++ b/src/components/ECGChart.tsx @@ -0,0 +1,274 @@ +/* eslint-disable no-undef */ +import React, { useState, useEffect, useRef } from 'react'; +import { Facility } from '../core/Facility'; +import { Device } from '../core/Device'; +import { useLiveTelemetry } from '../hooks/useLiveTelemetry'; +import { getValueByPath } from '../utils/jsonPath'; +import { ECGRenderer, ECGRendererConfig } from '../utils/ecgRenderer'; +import { useECGAnalysis } from '../hooks/useECGAnalysis'; +import { ECG } from '../utils/medicalConstants'; + +export interface ECGChartProps { + /** API key for authentication (required if device not provided) */ + apiKey?: string; + /** Device ID to connect to (required if device not provided) */ + deviceId?: string; + /** Pre-configured Device instance (alternative to apiKey/deviceId) */ + device?: Device; + /** Chart title */ + title?: string; + /** JSON path to extract ECG value (e.g., ".data.ecg") */ + dataPath: string; + /** Display mode: realtime or historical */ + mode?: 'realtime' | 'historical'; + /** Historical data array (only used in historical mode) */ + historicalData?: number[]; + /** Sweep speed in mm/s (default: 25) */ + sweepSpeed?: 25 | 50; + /** Gain in mm/mV (default: 10) */ + gain?: 5 | 10 | 20; + /** Sampling rate in Hz (default: 250) */ + samplingRate?: number; + /** Show ECG grid (default: true) */ + showGrid?: boolean; + /** Show calibration pulse (default: true) */ + showCalibration?: boolean; + /** Show heart rate display (default: true) */ + showHeartRate?: boolean; + /** Callback when heart rate changes */ + onHeartRateChange?: (_bpm: number) => void; + /** Waveform color (default: ECG.COLORS.WAVEFORM) */ + waveformColor?: string; + /** Grid color (default: ECG.COLORS.GRID_MAJOR) */ + gridColor?: string; + /** Background color (default: ECG.COLORS.BACKGROUND) */ + backgroundColor?: string; + /** Chart width (default: 800) */ + width?: number; + /** Chart height (default: 400) */ + height?: number; + /** Buffer duration in seconds (default: 10) */ + bufferDuration?: number; +} + +export const ECGChart: React.FC = ({ + apiKey, + deviceId, + device: providedDevice, + title = 'ECG Monitor', + dataPath, + mode = 'realtime', + historicalData, + sweepSpeed = ECG.DEFAULT_SWEEP_SPEED, + gain = ECG.DEFAULT_GAIN, + samplingRate = ECG.DEFAULT_SAMPLING_RATE, + showGrid = true, + showCalibration = true, + showHeartRate = true, + onHeartRateChange, + waveformColor = ECG.COLORS.WAVEFORM, + gridColor = ECG.COLORS.GRID_MAJOR, + backgroundColor = ECG.COLORS.BACKGROUND, + width = 800, + height = 400, + bufferDuration = 10, +}) => { + const canvasRef = useRef(null); + const rendererRef = useRef(null); + const dataBufferRef = useRef(null); + + // Use provided device or create one from apiKey/deviceId (only for realtime mode) + const device = useState(() => { + if (mode === 'historical') { + return null; + } + if (providedDevice) { + return providedDevice; + } + if (!apiKey || !deviceId) { + throw new Error('Either provide a device instance or both apiKey and deviceId for realtime mode'); + } + const facility = new Facility(apiKey); + return new Device(facility, deviceId); + })[0]; + + const { telemetry, isConnected, error } = useLiveTelemetry(device || undefined); + + // ECG analysis for heart rate + const { heartRate } = useECGAnalysis(dataBufferRef.current, { + samplingRate, + enabled: showHeartRate && mode === 'realtime', + }); + + // Initialize renderer + useEffect(() => { + if (!canvasRef.current) return; + + const config: ECGRendererConfig = { + width, + height, + sweepSpeed, + gain, + samplingRate, + showGrid, + showCalibration, + backgroundColor, + waveformColor, + gridColor, + bufferDuration, + }; + + rendererRef.current = new ECGRenderer(canvasRef.current, config); + dataBufferRef.current = new Float32Array(Math.ceil(bufferDuration * samplingRate)); + + // Start animation loop + rendererRef.current.startAnimation(); + + // Cleanup + return () => { + if (rendererRef.current) { + rendererRef.current.destroy(); + rendererRef.current = null; + } + }; + }, [width, height, sweepSpeed, gain, samplingRate, showGrid, showCalibration, backgroundColor, waveformColor, gridColor, bufferDuration]); + + // Handle realtime telemetry data + useEffect(() => { + if (mode !== 'realtime' || !telemetry || typeof telemetry !== 'object') return; + if (!rendererRef.current) return; + + const value = getValueByPath(telemetry, dataPath); + if (value !== undefined) { + const numericValue = parseFloat(value); + if (!isNaN(numericValue)) { + rendererRef.current.addDataPoint(numericValue); + } + } + }, [telemetry, dataPath, mode]); + + // Handle historical data + useEffect(() => { + if (mode !== 'historical' || !historicalData || !rendererRef.current) return; + + rendererRef.current.clearBuffer(); + rendererRef.current.addDataPoints(historicalData); + }, [historicalData, mode]); + + // Handle heart rate changes + useEffect(() => { + if (onHeartRateChange && heartRate > 0) { + onHeartRateChange(heartRate); + } + }, [heartRate, onHeartRateChange]); + + // Determine heart rate color based on range + const getHeartRateColor = (heartRateBpm: number): string => { + if (heartRateBpm === 0) return ECG.COLORS.TEXT; + if (heartRateBpm < ECG.HEART_RATE.NORMAL_MIN || heartRateBpm > ECG.HEART_RATE.NORMAL_MAX) { + return '#ef4444'; // Red for abnormal + } + return '#22c55e'; // Green for normal + }; + + return ( +
+ {/* Title and Heart Rate */} +
+

{title}

+ {showHeartRate && mode === 'realtime' && ( +
+ Heart Rate: + + {heartRate > 0 ? `${heartRate} BPM` : '--'} + +
+ )} +
+ + {/* Error Display */} + {error && ( +
+ Error: {error} +
+ )} + + {/* Canvas Container with Status */} +
+ {/* Connection Status - Only show in realtime mode */} + {mode === 'realtime' && ( +
+
+ + {isConnected ? 'Live' : 'Disconnected'} + +
+ )} + + {/* Canvas */} + +
+ + {/* Chart Info */} +
+ Sweep: {sweepSpeed} mm/s + Gain: {gain} mm/mV + Rate: {samplingRate} Hz +
+ + +
+ ); +}; diff --git a/src/components/EEGChart.stories.tsx b/src/components/EEGChart.stories.tsx new file mode 100644 index 0000000..042d1be --- /dev/null +++ b/src/components/EEGChart.stories.tsx @@ -0,0 +1,322 @@ +import React from 'react'; +import type { Meta, StoryObj } from '@storybook/react'; +import { EEGChart, EEGChannelConfig } from './EEGChart'; +import { Device } from '../core/Device'; +import { Facility } from '../core/Facility'; + +// Mock EEG Device that generates realistic multi-channel brain wave patterns +class MockEEGDevice extends Device { + private mockInterval: ReturnType | null = null; + private sampleIndex: number = 0; + private channels: string[]; + + constructor(facility: Facility, deviceId: string, channels: string[]) { + super(facility, deviceId); + this.channels = channels; + } + + // Generate realistic EEG waveform with different frequency bands + private generateEEGValue(channelIndex: number, dominantBand: 'alpha' | 'beta' | 'theta' | 'delta' = 'alpha'): number { + const time = this.sampleIndex / 256; // 256 Hz sampling + let value = 0; + + // Mix different frequency bands based on dominant band + switch (dominantBand) { + case 'alpha': // 8-13 Hz (relaxed, awake) + value += 30 * Math.sin(2 * Math.PI * 10 * time); + value += 10 * Math.sin(2 * Math.PI * 5 * time); // Some theta + break; + case 'beta': // 13-30 Hz (active thinking) + value += 20 * Math.sin(2 * Math.PI * 20 * time); + value += 15 * Math.sin(2 * Math.PI * 25 * time); + value += 10 * Math.sin(2 * Math.PI * 10 * time); // Some alpha + break; + case 'theta': // 4-8 Hz (drowsy, meditative) + value += 35 * Math.sin(2 * Math.PI * 6 * time); + value += 15 * Math.sin(2 * Math.PI * 3 * time); // Some delta + break; + case 'delta': // 0.5-4 Hz (deep sleep) + value += 40 * Math.sin(2 * Math.PI * 2 * time); + value += 20 * Math.sin(2 * Math.PI * 1 * time); + break; + } + + // Add channel-specific phase offset + value += 5 * Math.sin(2 * Math.PI * 15 * time + channelIndex); + + // Add small noise + value += (Math.random() - 0.5) * 3; + + return value; + } + + connect(): void { + setTimeout(() => { + (this as any).updateConnectionStatus('connected'); + + // Send EEG data at 256 Hz (~4ms intervals) + this.mockInterval = setInterval(() => { + const channelData: any = {}; + + this.channels.forEach((channel, index) => { + // Different channels have different dominant frequencies + let dominantBand: 'alpha' | 'beta' | 'theta' | 'delta' = 'alpha'; + if (index % 4 === 0) dominantBand = 'alpha'; + else if (index % 4 === 1) dominantBand = 'beta'; + else if (index % 4 === 2) dominantBand = 'theta'; + else dominantBand = 'alpha'; + + channelData[channel] = parseFloat(this.generateEEGValue(index, dominantBand).toFixed(2)); + }); + + const mockPayload = { + broker_id: "service-mqtt-mock-eeg", + device_id: this.deviceId, + payload: "eeg", + qos: 0, + timestamp: new Date().toISOString(), + topic: "health/eeg", + data: { + channels: channelData, + }, + }; + + (this as any).handleMessage(JSON.stringify(mockPayload)); + this.sampleIndex++; + }, 4); // ~256 Hz + }, 500); + } + + disconnect(): void { + if (this.mockInterval) { + clearInterval(this.mockInterval); + } + (this as any).updateConnectionStatus('disconnected'); + } +} + +const meta: Meta = { + title: 'Health/EEGChart', + component: EEGChart, + tags: ['autodocs'], + parameters: { + docs: { + description: { + component: 'Real-time EEG (electroencephalogram) visualization component for multi-channel brain wave monitoring. Supports stacked and overlay layouts with optional spectral analysis.', + }, + }, + }, +}; + +export default meta; + +type Story = StoryObj; + +const mockFacility = new Facility('storybook-api-key'); + +// 4-channel configuration +const channels4: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, + { name: 'C3', dataPath: '.data.channels.C3', color: '#f59e0b' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#ef4444' }, +]; + +const mockDevice4 = new MockEEGDevice(mockFacility, 'eeg-device-4ch', ['Fp1', 'Fp2', 'C3', 'C4']); + +export const StandardEEG: Story = { + args: { + device: mockDevice4, + title: 'EEG Monitor - 4 Channels', + channels: channels4, + mode: 'realtime', + sensitivity: 70, + timeWindow: 10, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + width: 1000, + height: 600, + }, + render: (args) => ( +
+

+ Standard 4-channel EEG display in stacked layout. Each channel shows different brain wave patterns. +

+ +
+

EEG Frequency Bands:

+
    +
  • Delta (δ): 0.5-4 Hz - Deep sleep
    • +
  • Theta (θ): 4-8 Hz - Drowsiness, meditation
    • +
  • Alpha (α): 8-13 Hz - Relaxed, awake
    • +
  • Beta (β): 13-30 Hz - Active thinking, concentration
    • +
  • Gamma (γ): 30-100 Hz - High-level information processing
    • +
+
+
+ ), +}; + +export const WithSpectralAnalysis: Story = { + args: { + device: new MockEEGDevice(mockFacility, 'eeg-device-spectral', ['Fp1', 'Fp2', 'C3', 'C4']), + title: 'EEG Monitor - With Spectral Analysis', + channels: channels4, + mode: 'realtime', + sensitivity: 70, + timeWindow: 10, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + showSpectralAnalysis: true, + frequencyBands: ['delta', 'theta', 'alpha', 'beta', 'gamma'], + width: 1000, + height: 600, + }, + render: (args) => ( +
+

+ EEG display with real-time spectral analysis showing power in each frequency band. The dominant band is highlighted for each channel. +

+ +
+ ), +}; + +// 8-channel configuration +const channels8: EEGChannelConfig[] = [ + { name: 'Fp1', dataPath: '.data.channels.Fp1', color: '#3b82f6' }, + { name: 'Fp2', dataPath: '.data.channels.Fp2', color: '#10b981' }, + { name: 'F3', dataPath: '.data.channels.F3', color: '#f59e0b' }, + { name: 'F4', dataPath: '.data.channels.F4', color: '#ef4444' }, + { name: 'C3', dataPath: '.data.channels.C3', color: '#8b5cf6' }, + { name: 'C4', dataPath: '.data.channels.C4', color: '#ec4899' }, + { name: 'P3', dataPath: '.data.channels.P3', color: '#06b6d4' }, + { name: 'P4', dataPath: '.data.channels.P4', color: '#84cc16' }, +]; + +const mockDevice8 = new MockEEGDevice(mockFacility, 'eeg-device-8ch', ['Fp1', 'Fp2', 'F3', 'F4', 'C3', 'C4', 'P3', 'P4']); + +export const FullMontage: Story = { + args: { + device: mockDevice8, + title: 'EEG Monitor - 8 Channel Montage', + channels: channels8, + mode: 'realtime', + sensitivity: 70, + timeWindow: 10, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + width: 1000, + height: 800, + }, + render: (args) => ( +
+

+ Full 8-channel EEG montage showing frontal (Fp), frontocentral (F), central (C), and parietal (P) electrode positions. +

+ +
+ ), +}; + +export const OverlayMode: Story = { + args: { + device: new MockEEGDevice(mockFacility, 'eeg-device-overlay', ['Fp1', 'Fp2', 'C3', 'C4']), + title: 'EEG Monitor - Overlay Mode', + channels: channels4, + mode: 'realtime', + sensitivity: 70, + timeWindow: 10, + samplingRate: 256, + layout: 'overlay', + showLabels: false, + width: 1000, + height: 500, + }, + render: (args) => ( +
+

+ Overlay mode displays all channels on the same baseline for easy comparison of waveform synchronization. +

+ +
+ ), +}; + +export const DarkModeEEG: Story = { + args: { + device: new MockEEGDevice(mockFacility, 'eeg-device-dark', ['Fp1', 'Fp2', 'C3', 'C4']), + title: 'EEG Monitor - Dark Mode', + channels: channels4, + mode: 'realtime', + sensitivity: 70, + timeWindow: 10, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + backgroundColor: '#1f2937', + gridColor: '#374151', + textColor: '#f9fafb', + width: 1000, + height: 600, + }, + render: (args) => ( +
+

+ Dark mode EEG display with custom color scheme for low-light environments. +

+ +
+ ), +}; + +export const HighSensitivity: Story = { + args: { + device: new MockEEGDevice(mockFacility, 'eeg-device-highsens', ['Fp1', 'Fp2', 'C3', 'C4']), + title: 'EEG Monitor - High Sensitivity', + channels: channels4, + mode: 'realtime', + sensitivity: 30, + timeWindow: 10, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + width: 1000, + height: 600, + }, + render: (args) => ( +
+

+ High sensitivity (30 µV/mm) amplifies the signal for detecting small variations in brain activity. +

+ +
+ ), +}; + +export const LongTimeWindow: Story = { + args: { + device: new MockEEGDevice(mockFacility, 'eeg-device-longtime', ['Fp1', 'Fp2', 'C3', 'C4']), + title: 'EEG Monitor - Extended View', + channels: channels4, + mode: 'realtime', + sensitivity: 70, + timeWindow: 20, + samplingRate: 256, + layout: 'stacked', + showLabels: true, + width: 1200, + height: 600, + }, + render: (args) => ( +
+

+ Extended 20-second time window for observing longer-term brain wave patterns and trends. +

+ +
+ ), +}; diff --git a/src/components/EEGChart.tsx b/src/components/EEGChart.tsx new file mode 100644 index 0000000..e9e731f --- /dev/null +++ b/src/components/EEGChart.tsx @@ -0,0 +1,323 @@ +/* eslint-disable no-undef */ +import React, { useState, useEffect, useRef } from 'react'; +import { Facility } from '../core/Facility'; +import { Device } from '../core/Device'; +import { useLiveTelemetry } from '../hooks/useLiveTelemetry'; +import { getValueByPath } from '../utils/jsonPath'; +import { EEGRenderer, EEGRendererConfig } from '../utils/eegRenderer'; +import { useEEGSpectralAnalysis } from '../hooks/useEEGSpectralAnalysis'; +import { EEG } from '../utils/medicalConstants'; + +export interface EEGChannelConfig { + /** Channel name (e.g., "Fp1", "Fp2") */ + name: string; + /** JSON path to extract channel value (e.g., ".data.channels.Fp1") */ + dataPath: string; + /** Channel color */ + color: string; +} + +export interface EEGChartProps { + /** API key for authentication (required if device not provided) */ + apiKey?: string; + /** Device ID to connect to (required if device not provided) */ + deviceId?: string; + /** Pre-configured Device instance (alternative to apiKey/deviceId) */ + device?: Device; + /** Chart title */ + title?: string; + /** Channel configurations */ + channels: EEGChannelConfig[]; + /** Display mode: realtime or historical */ + mode?: 'realtime' | 'historical'; + /** Historical data map (channelName -> values array) */ + historicalData?: Map; + /** Sensitivity in µV/mm (default: 70) */ + sensitivity?: number; + /** Time window in seconds (default: 10) */ + timeWindow?: number; + /** Sampling rate in Hz (default: 256) */ + samplingRate?: number; + /** Layout mode: stacked or overlay (default: stacked) */ + layout?: 'stacked' | 'overlay'; + /** Show channel labels (default: true) */ + showLabels?: boolean; + /** Show spectral analysis panel (default: false) */ + showSpectralAnalysis?: boolean; + /** Frequency bands to analyze (default: all) */ + frequencyBands?: Array<'delta' | 'theta' | 'alpha' | 'beta' | 'gamma'>; + /** Background color */ + backgroundColor?: string; + /** Grid color */ + gridColor?: string; + /** Text color */ + textColor?: string; + /** Chart width (default: 1000) */ + width?: number; + /** Chart height (default: 600) */ + height?: number; +} + +export const EEGChart: React.FC = ({ + apiKey, + deviceId, + device: providedDevice, + title = 'EEG Monitor', + channels, + mode = 'realtime', + historicalData, + sensitivity = EEG.DEFAULT_SENSITIVITY, + timeWindow = EEG.DEFAULT_TIME_WINDOW, + samplingRate = EEG.DEFAULT_SAMPLING_RATE, + layout = 'stacked', + showLabels = true, + showSpectralAnalysis = false, + frequencyBands = ['delta', 'theta', 'alpha', 'beta', 'gamma'], + backgroundColor = EEG.COLORS.BACKGROUND, + gridColor = EEG.COLORS.GRID, + textColor = EEG.COLORS.TEXT, + width = 1000, + height = 600, +}) => { + const canvasRef = useRef(null); + const rendererRef = useRef(null); + const channelBuffersRef = useRef>(new Map()); + + // Use provided device or create one from apiKey/deviceId (only for realtime mode) + const device = useState(() => { + if (mode === 'historical') { + return null; + } + if (providedDevice) { + return providedDevice; + } + if (!apiKey || !deviceId) { + throw new Error('Either provide a device instance or both apiKey and deviceId for realtime mode'); + } + const facility = new Facility(apiKey); + return new Device(facility, deviceId); + })[0]; + + const { telemetry, isConnected, error } = useLiveTelemetry(device || undefined); + + // Spectral analysis + const spectralData = useEEGSpectralAnalysis( + showSpectralAnalysis ? channelBuffersRef.current : null, + { + samplingRate, + enabled: showSpectralAnalysis && mode === 'realtime', + } + ); + + // Initialize renderer and buffers + useEffect(() => { + if (!canvasRef.current) return; + + const config: EEGRendererConfig = { + width, + height, + sensitivity, + timeWindow, + samplingRate, + layout, + showLabels, + backgroundColor, + gridColor, + textColor, + }; + + rendererRef.current = new EEGRenderer(canvasRef.current, config); + + // Initialize channels + channels.forEach(channel => { + rendererRef.current?.addChannel(channel.name, channel.color); + + // Create buffer for this channel + const bufferSize = Math.ceil(timeWindow * samplingRate); + channelBuffersRef.current.set(channel.name, new Float32Array(bufferSize)); + }); + + // Start animation loop + rendererRef.current.startAnimation(); + + // Cleanup + return () => { + if (rendererRef.current) { + rendererRef.current.destroy(); + rendererRef.current = null; + } + }; + }, [channels, width, height, sensitivity, timeWindow, samplingRate, layout, showLabels, backgroundColor, gridColor, textColor]); + + // Handle realtime telemetry data + useEffect(() => { + if (mode !== 'realtime' || !telemetry || typeof telemetry !== 'object') return; + if (!rendererRef.current) return; + + channels.forEach(channel => { + const value = getValueByPath(telemetry, channel.dataPath); + if (value !== undefined) { + const numericValue = parseFloat(value); + if (!isNaN(numericValue)) { + rendererRef.current?.addDataPoint(channel.name, numericValue); + + // Also update our buffer for spectral analysis + const buffer = channelBuffersRef.current.get(channel.name); + if (buffer) { + // Shift buffer and add new value + for (let i = 0; i < buffer.length - 1; i++) { + buffer[i] = buffer[i + 1]; + } + buffer[buffer.length - 1] = numericValue; + } + } + } + }); + }, [telemetry, channels, mode]); + + // Handle historical data + useEffect(() => { + if (mode !== 'historical' || !historicalData || !rendererRef.current) return; + + rendererRef.current.clearBuffers(); + historicalData.forEach((values, channelName) => { + rendererRef.current?.addDataPoints(channelName, values); + }); + }, [historicalData, mode]); + + return ( +
+ {/* Title */} +
+

{title}

+
+ {channels.length} channel{channels.length !== 1 ? 's' : ''} +
+
+ + {/* Error Display */} + {error && ( +
+ Error: {error} +
+ )} + +
+ {/* Canvas Container */} +
+
+ {/* Connection Status - Only show in realtime mode */} + {mode === 'realtime' && ( +
+
+ + {isConnected ? 'Live' : 'Disconnected'} + +
+ )} + + {/* Canvas */} + +
+ + {/* Chart Info */} +
+ Sensitivity: {sensitivity} µV/mm + Window: {timeWindow}s + Rate: {samplingRate} Hz + Layout: {layout} +
+
+ + {/* Spectral Analysis Panel */} + {showSpectralAnalysis && ( +
+

Spectral Analysis

+ {spectralData.size > 0 ? ( + Array.from(spectralData.entries()).map(([channelName, data]) => { + const channel = channels.find(c => c.name === channelName); + return ( +
+
+ {channelName} +
+
+ {frequencyBands.includes('delta') && ( +
δ Delta: {data.bands.delta.toFixed(2)}
+ )} + {frequencyBands.includes('theta') && ( +
θ Theta: {data.bands.theta.toFixed(2)}
+ )} + {frequencyBands.includes('alpha') && ( +
α Alpha: {data.bands.alpha.toFixed(2)}
+ )} + {frequencyBands.includes('beta') && ( +
β Beta: {data.bands.beta.toFixed(2)}
+ )} + {frequencyBands.includes('gamma') && ( +
γ Gamma: {data.bands.gamma.toFixed(2)}
+ )} +
+ Dominant: {data.dominantBand} +
+
+
+ ); + }) + ) : ( +
Analyzing...
+ )} +
+ )} +
+ + +
+ ); +}; diff --git a/src/components/LiveTelemetryGage.stories.tsx b/src/components/LiveTelemetryGage.stories.tsx new file mode 100644 index 0000000..bbb9d81 --- /dev/null +++ b/src/components/LiveTelemetryGage.stories.tsx @@ -0,0 +1,259 @@ +import React from 'react'; +import type { Meta, StoryObj } from '@storybook/react'; +import { LiveTelemetryGage } from './LiveTelemetryGage'; +import { Device } from '../core/Device'; +import { Facility } from '../core/Facility'; + +// Mock Device for Storybook +class MockDevice extends Device { + private mockInterval: ReturnType | null = null; + private dataGenerator: () => number; + + constructor(facility: Facility, deviceId: string, dataGenerator: () => number) { + super(facility, deviceId); + this.dataGenerator = dataGenerator; + } + + // Override connect to simulate a connection and data stream + connect(): void { + setTimeout(() => { + (this as any).updateConnectionStatus('connected'); + + let value = this.dataGenerator(); + this.mockInterval = setInterval(() => { + value = this.dataGenerator(); + const mockPayload = { + broker_id: "service-mqtt-mock-12345", + device_id: "storybook-device-id", + payload: "Mw==", + qos: 0, + timestamp: new Date().toISOString(), + topic: "sensors/data", + data: { + temperature: parseFloat(value.toFixed(2)), + pressure: parseFloat((value * 2.5).toFixed(1)), + rpm: Math.floor(value * 100), + }, + }; + (this as any).handleMessage(JSON.stringify(mockPayload)); + }, 1500); + }, 1000); + } + + // Override disconnect to clear the interval + disconnect(): void { + if (this.mockInterval) { + clearInterval(this.mockInterval); + } + (this as any).updateConnectionStatus('disconnected'); + } +} + +const meta: Meta = { + title: 'Basic/LiveTelemetryGage', + component: LiveTelemetryGage, + tags: ['autodocs'], + parameters: { + docs: { + description: { + component: 'A modern, animated gauge component that displays real-time telemetry data from a WebSocket connection. Configure JSON paths to extract values and set min/max ranges for the gauge scale.', + }, + }, + }, +}; + +export default meta; + +type Story = StoryObj; + +const mockFacility = new Facility('storybook-api-key'); + +// Temperature generator (15-35°C) +const mockDeviceTemp = new MockDevice( + mockFacility, + 'storybook-temp-device', + () => 15 + Math.random() * 20 +); + +// Pressure generator (0-150 PSI) +const mockDevicePressure = new MockDevice( + mockFacility, + 'storybook-pressure-device', + () => Math.random() * 150 +); + +// RPM generator (0-8000) +const mockDeviceRPM = new MockDevice( + mockFacility, + 'storybook-rpm-device', + () => 1000 + Math.random() * 7000 +); + +// High value generator (danger zone) +const mockDeviceHigh = new MockDevice( + mockFacility, + 'storybook-high-device', + () => 70 + Math.random() * 25 +); + +export const TemperatureGauge: Story = { + args: { + device: mockDeviceTemp, + title: 'Engine Temperature', + dataPath: '.data.temperature', + min: 0, + max: 50, + unit: '°C', + decimals: 1, + size: 300, + }, + render: (args) => ( +
+

+ A circular gauge showing temperature with smooth color transitions from green (cool) to yellow (warm) to red (hot). +

+ +
+ ), +}; + +export const PressureGauge: Story = { + args: { + device: mockDevicePressure, + title: 'System Pressure', + dataPath: '.data.pressure', + min: 0, + max: 200, + unit: 'PSI', + decimals: 0, + size: 320, + colorLow: '#3b82f6', // Blue for low pressure + colorMid: '#8b5cf6', // Purple for medium + colorHigh: '#ec4899', // Pink for high + }, + render: (args) => ( +
+

+ Pressure gauge with custom color scheme (blue → purple → pink) and PSI units. +

+ +
+ ), +}; + +export const RPMGauge: Story = { + args: { + device: mockDeviceRPM, + title: 'Engine RPM', + dataPath: '.data.rpm', + min: 0, + max: 10000, + unit: 'RPM', + decimals: 0, + size: 350, + colorLow: '#10b981', // Emerald + colorMid: '#f59e0b', // Amber + colorHigh: '#dc2626', // Red + }, + render: (args) => ( +
+

+ RPM gauge with integer values (no decimals) and larger size. Ideal for monitoring engine or motor speed. +

+ +
+ ), +}; + +export const DangerZone: Story = { + args: { + device: mockDeviceHigh, + title: 'Critical Temperature', + dataPath: '.data.temperature', + min: 0, + max: 100, + unit: '°C', + decimals: 1, + size: 280, + }, + render: (args) => ( +
+

+ This gauge shows values in the high range (danger zone) with red coloring to indicate critical levels. +

+ +
+ ), +}; + +export const MultipleGauges: Story = { + render: () => { + const facility = new Facility('storybook-api-key'); + const tempDevice = new MockDevice(facility, 'temp', () => 15 + Math.random() * 20); + const pressureDevice = new MockDevice(facility, 'pressure', () => Math.random() * 150); + const rpmDevice = new MockDevice(facility, 'rpm', () => 1000 + Math.random() * 7000); + + return ( +
+

+ Multiple gauges can be displayed side by side for comprehensive monitoring dashboards. +

+
+ + + +
+
+ ); + }, +}; + +export const CompactGauge: Story = { + args: { + device: mockDeviceTemp, + title: 'Temp', + dataPath: '.data.temperature', + min: 0, + max: 50, + unit: '°C', + decimals: 1, + size: 200, + }, + render: (args) => ( +
+

+ Compact version (200px) perfect for dashboards with space constraints. +

+ +
+ ), +}; diff --git a/src/components/LiveTelemetryGage.tsx b/src/components/LiveTelemetryGage.tsx new file mode 100644 index 0000000..8d1c230 --- /dev/null +++ b/src/components/LiveTelemetryGage.tsx @@ -0,0 +1,349 @@ +import React, { useState, useEffect } from 'react'; +import { Facility } from '../core/Facility'; +import { Device } from '../core/Device'; +import { useLiveTelemetry } from '../hooks/useLiveTelemetry'; +import { getValueByPath } from '../utils/jsonPath'; + +export interface LiveTelemetryGageProps { + /** API key for authentication (required if device not provided) */ + apiKey?: string; + /** Device ID to connect to (required if device not provided) */ + deviceId?: string; + /** Pre-configured Device instance (alternative to apiKey/deviceId) */ + device?: Device; + /** Gage title */ + title: string; + /** JSON path to extract value (e.g., ".data.temperature") */ + dataPath: string; + /** Minimum range value */ + min: number; + /** Maximum range value */ + max: number; + /** Unit label (e.g., "°C", "PSI", "RPM") */ + unit?: string; + /** Number of decimal places to display (default: 1) */ + decimals?: number; + /** Gage width and height (default: 300) */ + size?: number; + /** Primary color for high values (default: "#ef4444") */ + colorHigh?: string; + /** Middle color for medium values (default: "#eab308") */ + colorMid?: string; + /** Low color for low values (default: "#22c55e") */ + colorLow?: string; +} + +export const LiveTelemetryGage: React.FC = ({ + apiKey, + deviceId, + device: providedDevice, + title, + dataPath, + min, + max, + unit = '', + decimals = 1, + size = 300, + colorHigh = '#ef4444', + colorMid = '#eab308', + colorLow = '#22c55e', +}) => { + const [currentValue, setCurrentValue] = useState(null); + + // Use provided device or create one from apiKey/deviceId + const device = useState(() => { + if (providedDevice) { + return providedDevice; + } + if (!apiKey || !deviceId) { + throw new Error('Either provide a device instance or both apiKey and deviceId'); + } + const facility = new Facility(apiKey); + return new Device(facility, deviceId); + })[0]; + + const { telemetry, isConnected, error } = useLiveTelemetry(device); + + useEffect(() => { + if (telemetry && typeof telemetry === 'object') { + const value = getValueByPath(telemetry, dataPath); + if (value !== undefined) { + const numericValue = parseFloat(value); + if (!isNaN(numericValue)) { + setCurrentValue(numericValue); + } + } + } + }, [telemetry, dataPath]); + + // Calculate percentage and angle for the gauge arc + const percentage = currentValue !== null + ? Math.min(Math.max((currentValue - min) / (max - min), 0), 1) + : 0; + + const startAngle = -135; // Start at bottom-left + const endAngle = 135; // End at bottom-right + const angleRange = endAngle - startAngle; + const currentAngle = startAngle + (angleRange * percentage); + + // Determine color based on percentage + const getColor = () => { + if (percentage < 0.33) return colorLow; + if (percentage < 0.67) return colorMid; + return colorHigh; + }; + + // SVG arc path calculation + const svgHeight = size * 0.85; + const radius = (size * 0.3); + const centerX = size / 2; + const centerY = size / 2; + const strokeWidth = size * 0.08; + + const polarToCartesian = (angle: number) => { + const angleInRadians = (angle * Math.PI) / 180; + return { + x: centerX + radius * Math.cos(angleInRadians), + y: centerY + radius * Math.sin(angleInRadians), + }; + }; + + const createArc = (start: number, end: number) => { + const startPoint = polarToCartesian(start); + const endPoint = polarToCartesian(end); + const largeArcFlag = end - start <= 180 ? 0 : 1; + + return `M ${startPoint.x} ${startPoint.y} A ${radius} ${radius} 0 ${largeArcFlag} 1 ${endPoint.x} ${endPoint.y}`; + }; + + const backgroundPath = createArc(startAngle, endAngle); + const foregroundPath = createArc(startAngle, currentAngle); + + // Format value display + const displayValue = currentValue !== null + ? currentValue.toFixed(decimals) + : '--'; + + return ( +
+

+ {title} +

+ + {/* Error Display */} + {error && ( +
+ Error: {error} +
+ )} + + {/* Gage Container */} +
+ {/* Connection Status - Top Right */} +
+
+ + {isConnected ? 'Live' : 'Disconnected'} + +
+ + {/* SVG Gage */} + + + {/* Clip path to ensure nothing goes outside */} + + + + + {/* Gradient for the arc */} + + + + + + + {/* Drop shadow */} + + + + + + + + + + + + + + + + {/* Background arc */} + + + {/* Foreground arc (value) */} + + + {/* Min label */} + + {min} + + + {/* Max label */} + + {max} + + + {/* Center value display */} + + {displayValue} + + + {/* Unit label */} + {unit && ( + + {unit} + + )} + + + + {/* Range label */} +
+ Range: {min} - {max} {unit} +
+
+ + +
+ ); +}; diff --git a/src/components/LiveTelemetryLineChart.stories.tsx b/src/components/LiveTelemetryLineChart.stories.tsx index 74c4419..4e7f148 100644 --- a/src/components/LiveTelemetryLineChart.stories.tsx +++ b/src/components/LiveTelemetryLineChart.stories.tsx @@ -46,7 +46,7 @@ class MockDevice extends Device { } const meta: Meta = { - title: 'Library/LiveTelemetryLineChart', + title: 'Basic/LiveTelemetryLineChart', component: LiveTelemetryLineChart, tags: ['autodocs'], parameters: { @@ -113,10 +113,10 @@ export const CustomPaths: Story = { Customize the JSON paths to extract different data from the payload:

    -
  • xDataPath: ".timestamp" - Extracts timestamp from root
    • -
  • yDataPath: ".data.tempreture" - Extracts temperature from nested data
    • +
  • xDataPath: ".timestamp" - Extracts timestamp from root
    • +
  • yDataPath: ".data.tempreture" - Extracts temperature from nested data
  • yMin/yMax: 0/50 - Fixed Y-axis range
    • -
  • lineColor: "#ff7300" - Custom orange line color
    • +
  • lineColor: "#ff7300" - Custom orange line color
diff --git a/src/components/TelemetryDisplay.stories.tsx b/src/components/TelemetryDisplay.stories.tsx index be58693..f93ad99 100644 --- a/src/components/TelemetryDisplay.stories.tsx +++ b/src/components/TelemetryDisplay.stories.tsx @@ -47,7 +47,7 @@ class MockDevice extends Device { } const meta: Meta = { - title: 'Library/TelemetryDisplay', + title: 'Basic/TelemetryDisplay', component: TelemetryDisplay, tags: ['autodocs'], }; diff --git a/src/health.ts b/src/health.ts new file mode 100644 index 0000000..889e35e --- /dev/null +++ b/src/health.ts @@ -0,0 +1,33 @@ +/** + * Scadable Health - Medical telemetry visualization components + * + * ECG and EEG chart components for real-time health data visualization + * Import via: import { ECGChart, EEGChart } from 'scadable/health' + */ + +// Re-export core dependencies +export { Facility } from './core/Facility'; +export { Device } from './core/Device'; +export { useLiveTelemetry } from './hooks/useLiveTelemetry'; + +// Health components (will be added as they're created) +export { ECGChart } from './components/ECGChart'; +export type { ECGChartProps } from './components/ECGChart'; + +export { EEGChart } from './components/EEGChart'; +export type { EEGChartProps, EEGChannelConfig } from './components/EEGChart'; + +// Health-specific hooks (will be added as they're created) +export { useECGAnalysis } from './hooks/useECGAnalysis'; +export { useEEGSpectralAnalysis } from './hooks/useEEGSpectralAnalysis'; + +// Re-export core types +export type { + TelemetryData, + ScadablePayload, + WebSocketMessage, + WebSocketConfig, + TelemetryHookResult, +} from './core/types'; +export { ConnectionStatus } from './core/types'; +export type { ConnectionStatusValue } from './core/types'; diff --git a/src/hooks/useECGAnalysis.ts b/src/hooks/useECGAnalysis.ts new file mode 100644 index 0000000..5bb46c0 --- /dev/null +++ b/src/hooks/useECGAnalysis.ts @@ -0,0 +1,93 @@ +/** + * Hook for ECG signal analysis + * Detects R-peaks and calculates heart rate using Pan-Tompkins algorithm + */ + +import { useEffect, useState, useRef } from 'react'; +import { findPeaks, calculateRRIntervals, calculateHeartRate } from '../utils/signalProcessing'; + +export interface ECGAnalysisResult { + heartRate: number; // BPM + rrIntervals: number[]; // milliseconds + peaks: number[]; // indices of R-peaks + lastPeakTime: number | null; // timestamp of last detected peak +} + +export interface UseECGAnalysisOptions { + samplingRate: number; // Hz + threshold?: number; // mV - threshold for peak detection + minRRInterval?: number; // milliseconds - minimum time between peaks + enabled?: boolean; // enable/disable analysis +} + +/** + * Hook for real-time ECG analysis + * Analyzes ECG data buffer to detect R-peaks and calculate heart rate + */ +export function useECGAnalysis( + dataBuffer: Float32Array | null, + options: UseECGAnalysisOptions +): ECGAnalysisResult { + const { + samplingRate, + threshold = 0.5, + minRRInterval = 300, + enabled = true, + } = options; + + const [heartRate, setHeartRate] = useState(0); + const [rrIntervals, setRRIntervals] = useState([]); + const [peaks, setPeaks] = useState([]); + const [lastPeakTime, setLastPeakTime] = useState(null); + + const analysisIntervalRef = useRef(null); + + useEffect(() => { + if (!enabled || !dataBuffer || dataBuffer.length === 0) { + return; + } + + // Run analysis periodically (every 500ms) + const runAnalysis = () => { + // Convert Float32Array to regular array for processing + const data = Array.from(dataBuffer); + + // Find R-peaks + const minDistance = Math.floor((minRRInterval / 1000) * samplingRate); + const detectedPeaks = findPeaks(data, threshold, minDistance); + + if (detectedPeaks.length > 0) { + setPeaks(detectedPeaks); + setLastPeakTime(Date.now()); + + // Calculate R-R intervals + const intervals = calculateRRIntervals(detectedPeaks, samplingRate); + setRRIntervals(intervals); + + // Calculate heart rate + if (intervals.length > 0) { + const bpm = calculateHeartRate(intervals); + setHeartRate(bpm); + } + } + }; + + // Start periodic analysis + analysisIntervalRef.current = window.setInterval(runAnalysis, 500); + + // Cleanup + return () => { + if (analysisIntervalRef.current !== null) { + clearInterval(analysisIntervalRef.current); + analysisIntervalRef.current = null; + } + }; + }, [dataBuffer, samplingRate, threshold, minRRInterval, enabled]); + + return { + heartRate, + rrIntervals, + peaks, + lastPeakTime, + }; +} diff --git a/src/hooks/useEEGSpectralAnalysis.ts b/src/hooks/useEEGSpectralAnalysis.ts new file mode 100644 index 0000000..f7ef195 --- /dev/null +++ b/src/hooks/useEEGSpectralAnalysis.ts @@ -0,0 +1,119 @@ +/** + * Hook for EEG spectral analysis + * Calculates power in different frequency bands (delta, theta, alpha, beta, gamma) + */ + +import { useEffect, useState, useRef } from 'react'; +import { calculateSpectralPower } from '../utils/signalProcessing'; +import { EEG } from '../utils/medicalConstants'; + +export interface FrequencyBandPower { + delta: number; // 0.5-4 Hz + theta: number; // 4-8 Hz + alpha: number; // 8-13 Hz + beta: number; // 13-30 Hz + gamma: number; // 30-100 Hz +} + +export interface ChannelSpectralData { + channelName: string; + bands: FrequencyBandPower; + dominantBand: keyof FrequencyBandPower; + totalPower: number; +} + +export interface UseEEGSpectralAnalysisOptions { + samplingRate: number; + enabled?: boolean; + updateInterval?: number; // milliseconds +} + +/** + * Hook for real-time EEG spectral analysis + * Analyzes EEG data to extract power in different frequency bands + */ +export function useEEGSpectralAnalysis( + channelBuffers: Map | null, + options: UseEEGSpectralAnalysisOptions +): Map { + const { samplingRate, enabled = true, updateInterval = 1000 } = options; + + const [spectralData, setSpectralData] = useState>( + new Map() + ); + + const analysisIntervalRef = useRef(null); + + useEffect(() => { + if (!enabled || !channelBuffers || channelBuffers.size === 0) { + return; + } + + // Run spectral analysis periodically + const runAnalysis = () => { + const newSpectralData = new Map(); + + channelBuffers.forEach((buffer, channelName) => { + if (buffer.length === 0) return; + + // Convert Float32Array to regular array + const data = Array.from(buffer); + + // Define frequency bands + const bands = [ + EEG.FREQUENCY_BANDS.DELTA, + EEG.FREQUENCY_BANDS.THETA, + EEG.FREQUENCY_BANDS.ALPHA, + EEG.FREQUENCY_BANDS.BETA, + EEG.FREQUENCY_BANDS.GAMMA, + ]; + + // Calculate power in each band + const powers = calculateSpectralPower(data, samplingRate, bands); + + const bandPower: FrequencyBandPower = { + delta: powers[0] || 0, + theta: powers[1] || 0, + alpha: powers[2] || 0, + beta: powers[3] || 0, + gamma: powers[4] || 0, + }; + + // Calculate total power + const totalPower = Object.values(bandPower).reduce((sum, p) => sum + p, 0); + + // Find dominant band + let dominantBand: keyof FrequencyBandPower = 'alpha'; + let maxPower = 0; + (Object.keys(bandPower) as Array).forEach(band => { + if (bandPower[band] > maxPower) { + maxPower = bandPower[band]; + dominantBand = band; + } + }); + + newSpectralData.set(channelName, { + channelName, + bands: bandPower, + dominantBand, + totalPower, + }); + }); + + setSpectralData(newSpectralData); + }; + + // Start periodic analysis + analysisIntervalRef.current = window.setInterval(runAnalysis, updateInterval); + + // Cleanup + return () => { + if (analysisIntervalRef.current !== null) { + clearInterval(analysisIntervalRef.current); + analysisIntervalRef.current = null; + } + }; + }, [channelBuffers, samplingRate, enabled, updateInterval]); + + return spectralData; +} diff --git a/src/utils/ecgRenderer.ts b/src/utils/ecgRenderer.ts new file mode 100644 index 0000000..081772a --- /dev/null +++ b/src/utils/ecgRenderer.ts @@ -0,0 +1,267 @@ +/** + * Canvas-based ECG renderer + * Renders ECG waveform with medical-standard grid and calibration pulse + */ + +/* eslint-disable no-undef */ +import { ECG, CANVAS } from './medicalConstants'; + +export interface ECGRendererConfig { + width: number; + height: number; + sweepSpeed: number; // mm/s + gain: number; // mm/mV + samplingRate: number; // Hz + showGrid: boolean; + showCalibration: boolean; + backgroundColor: string; + waveformColor: string; + gridColor: string; + bufferDuration: number; // seconds +} + +export class ECGRenderer { + private canvas: HTMLCanvasElement; + private ctx: CanvasRenderingContext2D; + private config: ECGRendererConfig; + private dataBuffer: Float32Array; + private bufferIndex: number = 0; + private bufferSize: number; + private pixelsPerMM: number; + private lastRenderTime: number = 0; + private animationFrameId: number | null = null; + + constructor(canvas: HTMLCanvasElement, config: ECGRendererConfig) { + this.canvas = canvas; + const ctx = canvas.getContext('2d', { alpha: false }); + if (!ctx) { + throw new Error('Unable to get 2D context from canvas'); + } + this.ctx = ctx; + this.config = config; + + // Calculate buffer size based on duration and sampling rate + this.bufferSize = Math.ceil(config.bufferDuration * config.samplingRate); + this.dataBuffer = new Float32Array(this.bufferSize); + + // Calculate pixels per millimeter based on canvas size + // Assume canvas width represents a specific time duration + const durationSeconds = config.bufferDuration; + const durationMM = (durationSeconds * config.sweepSpeed * 1000) / 1000; // sweep speed is mm/s + this.pixelsPerMM = config.width / durationMM; + + this.setupCanvas(); + } + + private setupCanvas(): void { + const dpr = CANVAS.DPI_SCALE; + + // Set display size + this.canvas.style.width = `${this.config.width}px`; + this.canvas.style.height = `${this.config.height}px`; + + // Set actual size in memory (scaled for high DPI) + this.canvas.width = this.config.width * dpr; + this.canvas.height = this.config.height * dpr; + + // Scale context to match DPI + this.ctx.scale(dpr, dpr); + + // Enable anti-aliasing + this.ctx.imageSmoothingEnabled = CANVAS.ANTI_ALIAS; + } + + /** + * Add new data point to the buffer + */ + public addDataPoint(value: number): void { + this.dataBuffer[this.bufferIndex] = value; + this.bufferIndex = (this.bufferIndex + 1) % this.bufferSize; + } + + /** + * Add multiple data points + */ + public addDataPoints(values: number[]): void { + values.forEach(value => this.addDataPoint(value)); + } + + /** + * Clear the data buffer + */ + public clearBuffer(): void { + this.dataBuffer.fill(0); + this.bufferIndex = 0; + } + + /** + * Update configuration + */ + public updateConfig(config: Partial): void { + this.config = { ...this.config, ...config }; + this.setupCanvas(); + } + + /** + * Draw the ECG grid (medical standard 1mm and 5mm squares) + */ + private drawGrid(): void { + if (!this.config.showGrid) return; + + const { width, height } = this.config; + const smallSquare = this.pixelsPerMM * ECG.GRID.SMALL_SQUARE_MM; + const largeSquare = this.pixelsPerMM * ECG.GRID.LARGE_SQUARE_MM; + + // Draw small squares (1mm - light grid) + this.ctx.strokeStyle = this.config.gridColor + '40'; // 25% opacity + this.ctx.lineWidth = 0.5; + this.ctx.beginPath(); + + // Vertical lines + for (let x = 0; x <= width; x += smallSquare) { + this.ctx.moveTo(x, 0); + this.ctx.lineTo(x, height); + } + + // Horizontal lines + for (let y = 0; y <= height; y += smallSquare) { + this.ctx.moveTo(0, y); + this.ctx.lineTo(width, y); + } + + this.ctx.stroke(); + + // Draw large squares (5mm - darker grid) + this.ctx.strokeStyle = this.config.gridColor; + this.ctx.lineWidth = 1; + this.ctx.beginPath(); + + // Vertical lines + for (let x = 0; x <= width; x += largeSquare) { + this.ctx.moveTo(x, 0); + this.ctx.lineTo(x, height); + } + + // Horizontal lines + for (let y = 0; y <= height; y += largeSquare) { + this.ctx.moveTo(0, y); + this.ctx.lineTo(width, y); + } + + this.ctx.stroke(); + } + + /** + * Draw calibration pulse (1mV square wave) + */ + private drawCalibration(): void { + if (!this.config.showCalibration) return; + + const { height } = this.config; + const centerY = height / 2; + const calHeight = this.pixelsPerMM * this.config.gain * ECG.CALIBRATION.AMPLITUDE_MV; + const calWidth = (ECG.CALIBRATION.DURATION_MS / 1000) * this.config.sweepSpeed * this.pixelsPerMM; + const startX = 20; + + this.ctx.strokeStyle = this.config.waveformColor; + this.ctx.lineWidth = 2; + this.ctx.beginPath(); + this.ctx.moveTo(startX, centerY); + this.ctx.lineTo(startX, centerY - calHeight); + this.ctx.lineTo(startX + calWidth, centerY - calHeight); + this.ctx.lineTo(startX + calWidth, centerY); + this.ctx.stroke(); + } + + /** + * Draw the ECG waveform + */ + private drawWaveform(): void { + const { width, height } = this.config; + const centerY = height / 2; + + // Calculate how many pixels per sample + const pixelsPerSample = (this.config.sweepSpeed * this.pixelsPerMM) / this.config.samplingRate; + + this.ctx.strokeStyle = this.config.waveformColor; + this.ctx.lineWidth = 2; + this.ctx.lineCap = 'round'; + this.ctx.lineJoin = 'round'; + this.ctx.beginPath(); + + let started = false; + for (let i = 0; i < this.bufferSize; i++) { + const bufferIdx = (this.bufferIndex + i) % this.bufferSize; + const value = this.dataBuffer[bufferIdx]; + + const x = i * pixelsPerSample; + if (x > width) break; + + // Convert mV to pixels using gain + const y = centerY - (value * this.config.gain * this.pixelsPerMM); + + if (!started) { + this.ctx.moveTo(x, y); + started = true; + } else { + this.ctx.lineTo(x, y); + } + } + + this.ctx.stroke(); + } + + /** + * Render a single frame + */ + public render(): void { + const { width, height } = this.config; + + // Clear canvas + this.ctx.fillStyle = this.config.backgroundColor; + this.ctx.fillRect(0, 0, width, height); + + // Draw layers + this.drawGrid(); + this.drawCalibration(); + this.drawWaveform(); + } + + /** + * Start animation loop + */ + public startAnimation(): void { + const animate = (timestamp: number) => { + // Throttle to target FPS + const elapsed = timestamp - this.lastRenderTime; + const targetFrameTime = 1000 / 60; // 60 FPS + + if (elapsed >= targetFrameTime) { + this.render(); + this.lastRenderTime = timestamp; + } + + this.animationFrameId = requestAnimationFrame(animate); + }; + + this.animationFrameId = requestAnimationFrame(animate); + } + + /** + * Stop animation loop + */ + public stopAnimation(): void { + if (this.animationFrameId !== null) { + cancelAnimationFrame(this.animationFrameId); + this.animationFrameId = null; + } + } + + /** + * Cleanup resources + */ + public destroy(): void { + this.stopAnimation(); + this.clearBuffer(); + } +} diff --git a/src/utils/eegRenderer.ts b/src/utils/eegRenderer.ts new file mode 100644 index 0000000..5deb10a --- /dev/null +++ b/src/utils/eegRenderer.ts @@ -0,0 +1,306 @@ +/** + * Canvas-based EEG renderer + * Renders multi-channel EEG waveforms with stacked or overlay layout + */ + +/* eslint-disable no-undef */ +import { CANVAS } from './medicalConstants'; + +export interface EEGChannelData { + name: string; + color: string; + data: Float32Array; + bufferIndex: number; +} + +export interface EEGRendererConfig { + width: number; + height: number; + sensitivity: number; // µV/mm + timeWindow: number; // seconds + samplingRate: number; // Hz + layout: 'stacked' | 'overlay'; + showLabels: boolean; + backgroundColor: string; + gridColor: string; + textColor: string; +} + +export class EEGRenderer { + private canvas: HTMLCanvasElement; + private ctx: CanvasRenderingContext2D; + private config: EEGRendererConfig; + private channels: Map = new Map(); + private bufferSize: number; + private pixelsPerMM: number; + private channelHeight: number; + private lastRenderTime: number = 0; + private animationFrameId: number | null = null; + + constructor(canvas: HTMLCanvasElement, config: EEGRendererConfig) { + this.canvas = canvas; + const ctx = canvas.getContext('2d', { alpha: false }); + if (!ctx) { + throw new Error('Unable to get 2D context from canvas'); + } + this.ctx = ctx; + this.config = config; + + // Calculate buffer size + this.bufferSize = Math.ceil(config.timeWindow * config.samplingRate); + + // Calculate pixels per millimeter + this.pixelsPerMM = config.width / (config.timeWindow * 25); // 25mm/s standard + + // Calculate channel height for stacked layout + this.channelHeight = config.height; + + this.setupCanvas(); + } + + private setupCanvas(): void { + const dpr = CANVAS.DPI_SCALE; + + // Set display size + this.canvas.style.width = `${this.config.width}px`; + this.canvas.style.height = `${this.config.height}px`; + + // Set actual size in memory + this.canvas.width = this.config.width * dpr; + this.canvas.height = this.config.height * dpr; + + // Scale context + this.ctx.scale(dpr, dpr); + + // Enable anti-aliasing + this.ctx.imageSmoothingEnabled = CANVAS.ANTI_ALIAS; + } + + /** + * Add or update a channel + */ + public addChannel(name: string, color: string): void { + if (!this.channels.has(name)) { + this.channels.set(name, { + name, + color, + data: new Float32Array(this.bufferSize), + bufferIndex: 0, + }); + + // Recalculate channel height for stacked layout + if (this.config.layout === 'stacked') { + this.channelHeight = this.config.height / this.channels.size; + } + } + } + + /** + * Remove a channel + */ + public removeChannel(name: string): void { + this.channels.delete(name); + + // Recalculate channel height + if (this.config.layout === 'stacked' && this.channels.size > 0) { + this.channelHeight = this.config.height / this.channels.size; + } + } + + /** + * Add data point to a channel + */ + public addDataPoint(channelName: string, value: number): void { + const channel = this.channels.get(channelName); + if (!channel) return; + + channel.data[channel.bufferIndex] = value; + channel.bufferIndex = (channel.bufferIndex + 1) % this.bufferSize; + } + + /** + * Add multiple data points to a channel + */ + public addDataPoints(channelName: string, values: number[]): void { + values.forEach(value => this.addDataPoint(channelName, value)); + } + + /** + * Clear all channel buffers + */ + public clearBuffers(): void { + this.channels.forEach(channel => { + channel.data.fill(0); + channel.bufferIndex = 0; + }); + } + + /** + * Update configuration + */ + public updateConfig(config: Partial): void { + this.config = { ...this.config, ...config }; + this.setupCanvas(); + + // Recalculate channel height if needed + if (this.config.layout === 'stacked' && this.channels.size > 0) { + this.channelHeight = this.config.height / this.channels.size; + } + } + + /** + * Draw background grid + */ + private drawGrid(): void { + const { width, height } = this.config; + + this.ctx.strokeStyle = this.config.gridColor; + this.ctx.lineWidth = 0.5; + this.ctx.beginPath(); + + // Vertical time markers (every second) + const pixelsPerSecond = width / this.config.timeWindow; + for (let t = 0; t <= this.config.timeWindow; t++) { + const x = t * pixelsPerSecond; + this.ctx.moveTo(x, 0); + this.ctx.lineTo(x, height); + } + + // Horizontal lines for stacked layout + if (this.config.layout === 'stacked') { + for (let i = 0; i <= this.channels.size; i++) { + const y = i * this.channelHeight; + this.ctx.moveTo(0, y); + this.ctx.lineTo(width, y); + } + } + + this.ctx.stroke(); + } + + /** + * Draw channel labels + */ + private drawLabels(): void { + if (!this.config.showLabels || this.config.layout !== 'stacked') return; + + this.ctx.font = '12px sans-serif'; + this.ctx.fillStyle = this.config.textColor; + this.ctx.textAlign = 'left'; + this.ctx.textBaseline = 'middle'; + + let channelIndex = 0; + this.channels.forEach(channel => { + const y = channelIndex * this.channelHeight + this.channelHeight / 2; + this.ctx.fillStyle = channel.color; + this.ctx.fillText(channel.name, 10, y); + channelIndex++; + }); + } + + /** + * Draw a single channel waveform + */ + private drawChannel(channel: EEGChannelData, channelIndex: number): void { + const { width } = this.config; + const pixelsPerSample = width / this.bufferSize; + + // Calculate center Y based on layout + let centerY: number; + if (this.config.layout === 'stacked') { + centerY = channelIndex * this.channelHeight + this.channelHeight / 2; + } else { + centerY = this.config.height / 2; + } + + this.ctx.strokeStyle = channel.color; + this.ctx.lineWidth = 1.5; + this.ctx.lineCap = 'round'; + this.ctx.lineJoin = 'round'; + this.ctx.beginPath(); + + let started = false; + for (let i = 0; i < this.bufferSize; i++) { + const bufferIdx = (channel.bufferIndex + i) % this.bufferSize; + const value = channel.data[bufferIdx]; + + const x = i * pixelsPerSample; + if (x > width) break; + + // Convert µV to pixels using sensitivity + const y = centerY - (value * this.pixelsPerMM) / this.config.sensitivity; + + if (!started) { + this.ctx.moveTo(x, y); + started = true; + } else { + this.ctx.lineTo(x, y); + } + } + + this.ctx.stroke(); + } + + /** + * Render a single frame + */ + public render(): void { + const { width, height } = this.config; + + // Clear canvas + this.ctx.fillStyle = this.config.backgroundColor; + this.ctx.fillRect(0, 0, width, height); + + // Draw grid + this.drawGrid(); + + // Draw channels + let channelIndex = 0; + this.channels.forEach(channel => { + this.drawChannel(channel, channelIndex); + channelIndex++; + }); + + // Draw labels last (on top) + this.drawLabels(); + } + + /** + * Start animation loop + */ + public startAnimation(): void { + const animate = (timestamp: number) => { + // Throttle to target FPS + const elapsed = timestamp - this.lastRenderTime; + const targetFrameTime = 1000 / 60; // 60 FPS + + if (elapsed >= targetFrameTime) { + this.render(); + this.lastRenderTime = timestamp; + } + + this.animationFrameId = requestAnimationFrame(animate); + }; + + this.animationFrameId = requestAnimationFrame(animate); + } + + /** + * Stop animation loop + */ + public stopAnimation(): void { + if (this.animationFrameId !== null) { + cancelAnimationFrame(this.animationFrameId); + this.animationFrameId = null; + } + } + + /** + * Cleanup resources + */ + public destroy(): void { + this.stopAnimation(); + this.clearBuffers(); + this.channels.clear(); + } +} diff --git a/src/utils/medicalConstants.ts b/src/utils/medicalConstants.ts new file mode 100644 index 0000000..f79eb83 --- /dev/null +++ b/src/utils/medicalConstants.ts @@ -0,0 +1,120 @@ +/** + * Medical visualization constants and standards + * Following international medical device standards for ECG and EEG displays + */ + +// ECG Standards +export const ECG = { + // Standard sweep speeds (mm/s) + SWEEP_SPEEDS: [25, 50] as const, + DEFAULT_SWEEP_SPEED: 25, + + // Standard gain values (mm/mV) + GAINS: [5, 10, 20] as const, + DEFAULT_GAIN: 10, + + // Standard sampling rates (Hz) + SAMPLING_RATES: [250, 500, 1000] as const, + DEFAULT_SAMPLING_RATE: 250, + + // Grid specifications (medical standard ECG paper) + GRID: { + SMALL_SQUARE_MM: 1, // 1mm small squares + LARGE_SQUARE_MM: 5, // 5mm large squares (5 small squares) + SMALL_SQUARE_TIME_MS: 40, // 0.04s at 25mm/s + LARGE_SQUARE_TIME_MS: 200, // 0.2s at 25mm/s + }, + + // Calibration pulse + CALIBRATION: { + AMPLITUDE_MV: 1.0, // 1mV standard calibration + DURATION_MS: 200, // 200ms pulse width + }, + + // Normal heart rate ranges + HEART_RATE: { + MIN: 40, + MAX: 200, + NORMAL_MIN: 60, + NORMAL_MAX: 100, + }, + + // Default colors (medical standard - pink grid, red waveform) + COLORS: { + BACKGROUND: '#ffffff', + GRID_MAJOR: '#f4c2c2', + GRID_MINOR: '#fce7e7', + WAVEFORM: '#dc2626', + CALIBRATION: '#dc2626', + TEXT: '#1f2937', + }, +} as const; + +// EEG Standards +export const EEG = { + // Standard sensitivities (µV/mm) + SENSITIVITIES: [5, 7, 10, 15, 20, 30, 50, 70, 100] as const, + DEFAULT_SENSITIVITY: 70, + + // Standard time windows (seconds) + TIME_WINDOWS: [5, 10, 15, 20, 30, 60] as const, + DEFAULT_TIME_WINDOW: 10, + + // Standard sampling rate (Hz) + SAMPLING_RATES: [128, 256, 512, 1024] as const, + DEFAULT_SAMPLING_RATE: 256, + + // Frequency bands (Hz) + FREQUENCY_BANDS: { + DELTA: { min: 0.5, max: 4, label: 'δ (Delta)' }, + THETA: { min: 4, max: 8, label: 'θ (Theta)' }, + ALPHA: { min: 8, max: 13, label: 'α (Alpha)' }, + BETA: { min: 13, max: 30, label: 'β (Beta)' }, + GAMMA: { min: 30, max: 100, label: 'γ (Gamma)' }, + } as const, + + // Standard 10-20 electrode positions + ELECTRODE_POSITIONS: [ + 'Fp1', 'Fp2', 'F7', 'F3', 'Fz', 'F4', 'F8', + 'T3', 'C3', 'Cz', 'C4', 'T4', + 'T5', 'P3', 'Pz', 'P4', 'T6', + 'O1', 'O2', + ] as const, + + // Default colors for channels + COLORS: { + BACKGROUND: '#ffffff', + GRID: '#e5e7eb', + TEXT: '#1f2937', + CHANNELS: [ + '#3b82f6', // blue + '#10b981', // green + '#f59e0b', // amber + '#ef4444', // red + '#8b5cf6', // violet + '#ec4899', // pink + '#06b6d4', // cyan + '#84cc16', // lime + ], + }, + + // Impedance thresholds (kΩ) + IMPEDANCE: { + GOOD: 5, + ACCEPTABLE: 10, + POOR: 20, + }, +} as const; + +// Common performance targets +export const PERFORMANCE = { + TARGET_FPS: 60, + MIN_FPS: 30, + BUFFER_DURATION_S: 10, // Keep 10 seconds of data in memory +} as const; + +// Canvas rendering constants +export const CANVAS = { + DPI_SCALE: typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1, + ANTI_ALIAS: true, +} as const; diff --git a/src/utils/signalProcessing.ts b/src/utils/signalProcessing.ts new file mode 100644 index 0000000..70ef266 --- /dev/null +++ b/src/utils/signalProcessing.ts @@ -0,0 +1,187 @@ +/** + * Signal processing utilities for medical telemetry + * Includes filtering, peak detection, and frequency analysis + */ + +/** + * Simple moving average filter + * Smooths signal by averaging over a window + */ +export function movingAverage(data: number[], windowSize: number): number[] { + if (windowSize <= 1) return data; + + const result: number[] = []; + for (let i = 0; i < data.length; i++) { + const start = Math.max(0, i - Math.floor(windowSize / 2)); + const end = Math.min(data.length, i + Math.ceil(windowSize / 2)); + const window = data.slice(start, end); + const avg = window.reduce((sum, val) => sum + val, 0) / window.length; + result.push(avg); + } + return result; +} + +/** + * Simple high-pass filter to remove DC offset + * Uses difference equation: y[n] = x[n] - x[n-1] + alpha * y[n-1] + */ +export function highPassFilter(data: number[], alpha: number = 0.95): number[] { + if (data.length === 0) return []; + + const result: number[] = [data[0]]; + for (let i = 1; i < data.length; i++) { + result.push(data[i] - data[i - 1] + alpha * result[i - 1]); + } + return result; +} + +/** + * Simple low-pass filter to remove high-frequency noise + * Uses exponential moving average + */ +export function lowPassFilter(data: number[], alpha: number = 0.1): number[] { + if (data.length === 0) return []; + + const result: number[] = [data[0]]; + for (let i = 1; i < data.length; i++) { + result.push(alpha * data[i] + (1 - alpha) * result[i - 1]); + } + return result; +} + +/** + * Notch filter for removing power line interference (50/60 Hz) + * Simple implementation using moving average at the notch frequency + */ +export function notchFilter(data: number[], samplingRate: number, notchFreq: number = 60): number[] { + const period = Math.round(samplingRate / notchFreq); + if (period <= 1 || data.length < period) return data; + + const result: number[] = []; + for (let i = 0; i < data.length; i++) { + if (i < period) { + result.push(data[i]); + } else { + // Remove the frequency component by subtracting delayed signal + result.push(data[i] - data[i - period]); + } + } + return result; +} + +/** + * Find peaks in a signal using simple threshold and derivative + * Returns indices of detected peaks + */ +export function findPeaks(data: number[], threshold: number, minDistance: number = 0): number[] { + if (data.length < 3) return []; + + const peaks: number[] = []; + for (let i = 1; i < data.length - 1; i++) { + // Peak if higher than neighbors and above threshold + if (data[i] > data[i - 1] && data[i] > data[i + 1] && data[i] > threshold) { + // Check minimum distance from last peak + if (minDistance === 0 || peaks.length === 0 || i - peaks[peaks.length - 1] >= minDistance) { + peaks.push(i); + } + } + } + return peaks; +} + +/** + * Calculate R-R intervals from R-peak positions + * Returns intervals in milliseconds + */ +export function calculateRRIntervals(peakIndices: number[], samplingRate: number): number[] { + const intervals: number[] = []; + for (let i = 1; i < peakIndices.length; i++) { + const interval = ((peakIndices[i] - peakIndices[i - 1]) / samplingRate) * 1000; + intervals.push(interval); + } + return intervals; +} + +/** + * Calculate heart rate from R-R intervals + * Returns BPM (beats per minute) + */ +export function calculateHeartRate(rrIntervals: number[]): number { + if (rrIntervals.length === 0) return 0; + + // Average R-R interval in milliseconds + const avgRR = rrIntervals.reduce((sum, interval) => sum + interval, 0) / rrIntervals.length; + + // Convert to BPM + const bpm = 60000 / avgRR; + + // Clamp to reasonable range + return Math.max(30, Math.min(250, Math.round(bpm))); +} + +/** + * Simple FFT-based spectral analysis + * Returns power in specified frequency bands + * Note: This is a simplified version. For production, consider using a library like fft.js + */ +export function calculateSpectralPower( + data: number[], + samplingRate: number, + frequencyBands: { min: number; max: number }[] +): number[] { + // For simplicity, we'll use a basic DFT for small windows + // In production, use FFT library for better performance + const n = data.length; + const powers: number[] = []; + + for (const band of frequencyBands) { + let power = 0; + const freqStep = samplingRate / n; + + // Calculate power in this frequency band + for (let k = 0; k < n / 2; k++) { + const freq = k * freqStep; + if (freq >= band.min && freq <= band.max) { + // DFT coefficient + let real = 0; + let imag = 0; + for (let t = 0; t < n; t++) { + const angle = (-2 * Math.PI * k * t) / n; + real += data[t] * Math.cos(angle); + imag += data[t] * Math.sin(angle); + } + power += (real * real + imag * imag) / (n * n); + } + } + powers.push(power); + } + + return powers; +} + +/** + * Normalize data to range [0, 1] + */ +export function normalize(data: number[]): number[] { + if (data.length === 0) return []; + + const min = Math.min(...data); + const max = Math.max(...data); + const range = max - min; + + if (range === 0) return data.map(() => 0.5); + + return data.map(val => (val - min) / range); +} + +/** + * Calculate standard deviation + */ +export function standardDeviation(data: number[]): number { + if (data.length === 0) return 0; + + const mean = data.reduce((sum, val) => sum + val, 0) / data.length; + const variance = data.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / data.length; + + return Math.sqrt(variance); +} diff --git a/vite.config.ts b/vite.config.ts index b77f0c0..e82fb87 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -15,10 +15,13 @@ export default defineConfig({ ], build: { lib: { - entry: resolve(fileURLToPath(new URL('.', import.meta.url)), 'src/index.ts'), + entry: { + index: resolve(fileURLToPath(new URL('.', import.meta.url)), 'src/index.ts'), + health: resolve(fileURLToPath(new URL('.', import.meta.url)), 'src/health.ts') + }, name: 'Scadable', formats: ['es', 'cjs'], - fileName: (format) => `index.${format === 'es' ? 'mjs' : 'js'}` + fileName: (format, entryName) => `${entryName}.${format === 'es' ? 'mjs' : 'js'}` }, rollupOptions: { external: ['react', 'react-dom'],