-
Standard: ${standardName.toUpperCase()}
-
Preset: ${preset?.filename || 'Unknown'}
+ Object.entries(individualPlots).forEach(([name, plot]) => {
+ if (plot.error) {
+ const err = document.createElement('div');
+ err.className = 'chart-card';
+ err.innerHTML = `
+
+
`;
+ container.appendChild(err);
+ return;
+ }
- // Setup event handlers
- this.setupCalibrationChartEvents(card, standardName);
+ const card = this._createCalibrationChartCard(name, plot, preset);
+ container.appendChild(card);
+ });
- // Render the plot
- const plotContainer = card.querySelector('.chart-card__plot');
- this.renderCalibrationChart(plotContainer, plotConfig, standardTitle);
+ if (typeof lucide !== 'undefined') {
+ lucide.createIcons({ attrs: { 'stroke-width': 1.5 } });
+ }
+ }
- return card;
+ _createCalibrationChartCard(standardName, plotConfig, preset) {
+ const card = document.createElement('div');
+ card.className = 'chart-card';
+ card.dataset.standard = standardName;
+
+ const title = `${standardName.toUpperCase()} Standard`;
+
+ card.innerHTML = `
+
+
+
+ `;
+
+ // Actions
+ card.addEventListener('click', (e) => {
+ const action = e.target.closest?.('[data-action]')?.dataset.action;
+ if (!action) return;
+ e.stopPropagation();
+
+ const plotEl = card.querySelector('.chart-card__plot');
+ if (action === 'fullscreen') this._toggleFullscreen(card);
+ if (action === 'download') this.downloadCalibrationStandard(standardName, plotEl);
+ });
+
+ // Plot
+ const plotEl = card.querySelector('.chart-card__plot');
+ this._renderPlotly(plotEl, plotConfig, title);
+
+ return card;
+ }
+
+ _renderPlotly(container, plotConfig, title) {
+ if (!container || !plotConfig || plotConfig.error) {
+ container.innerHTML = `
Failed to load plot: ${plotConfig?.error || 'Unknown error'}
`;
+ return;
}
- setupCalibrationChartEvents(card, standardName) {
- card.addEventListener('click', (e) => {
- const action = e.target.closest('[data-action]')?.dataset.action;
- if (!action) return;
- e.stopPropagation();
+ const layout = {
+ ...plotConfig.layout,
+ title: { text: title, font: { size: 16, color: '#f1f5f9' } },
+ plot_bgcolor: 'transparent',
+ paper_bgcolor: 'transparent',
+ font: { family: 'Inter, -apple-system, BlinkMacSystemFont, sans-serif', size: 12, color: '#f1f5f9' },
+ autosize: true,
+ width: null,
+ height: null,
+ margin: { l: 60, r: 50, t: 50, b: 60 },
+ showlegend: true,
+ legend: {
+ orientation: 'v',
+ x: 1.02,
+ y: 1,
+ xanchor: 'left',
+ yanchor: 'top',
+ bgcolor: 'rgba(30, 41, 59, 0.9)',
+ bordercolor: '#475569',
+ borderwidth: 1,
+ font: { size: 10, color: '#f1f5f9' }
+ },
+ xaxis: {
+ ...plotConfig.layout.xaxis,
+ gridcolor: '#334155',
+ zerolinecolor: '#475569',
+ color: '#cbd5e1',
+ fixedrange: false
+ },
+ yaxis: {
+ ...plotConfig.layout.yaxis,
+ gridcolor: '#334155',
+ zerolinecolor: '#475569',
+ color: '#cbd5e1',
+ fixedrange: false
+ }
+ };
- const plotContainer = card.querySelector('.chart-card__plot');
+ const config = {
+ displayModeBar: true,
+ modeBarButtonsToRemove: ['select2d', 'lasso2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'toggleSpikelines'],
+ displaylogo: false,
+ responsive: false,
+ doubleClick: 'reset',
+ toImageButtonOptions: {
+ format: 'png',
+ filename: `calibration-plot-${Date.now()}`,
+ height: 600,
+ width: 800,
+ scale: 1
+ }
+ };
- switch (action) {
- case 'fullscreen':
- this.toggleCalibrationFullscreen(card);
- break;
- case 'download':
- this.downloadCalibrationStandard(standardName, plotContainer);
- break;
- }
+ Plotly.newPlot(container, plotConfig.data, layout, config);
+
+ // Resize observer
+ if (window.ResizeObserver) {
+ const ro = new ResizeObserver(() => {
+ if (container && container.clientWidth > 0) {
+ Plotly.Plots.resize(container);
+ }
+ });
+ ro.observe(container);
+ container._resizeObserver = ro;
+ }
+ }
+
+ _toggleFullscreen(card) {
+ if (!document.fullscreenElement) {
+ card.requestFullscreen?.().then(() => {
+ setTimeout(() => {
+ const plot = card.querySelector('.chart-card__plot');
+ if (plot && typeof Plotly !== 'undefined') {
+ const rect = plot.getBoundingClientRect();
+ Plotly.relayout(plot, { width: rect.width, height: rect.height });
+ Plotly.Plots.resize(plot);
+ }
+ }, 200);
+ }).catch(console.error);
+ } else {
+ document.exitFullscreen?.().then(() => {
+ setTimeout(() => {
+ const plot = card.querySelector('.chart-card__plot');
+ if (plot && typeof Plotly !== 'undefined') {
+ Plotly.Plots.resize(plot);
+ }
+ }, 100);
+ });
+ }
+ }
+
+ closePlotsModal() {
+ const modal = this.elements.plotsModal;
+ if (!modal) return;
+
+ modal.classList.remove('modal--active');
+ document.body.style.overflow = '';
+
+ // Clean plots
+ if (typeof Plotly !== 'undefined') {
+ const containers = modal.querySelectorAll('[id^="calibration-plot-"]');
+ containers.forEach(c => {
+ if (c._resizeObserver) { c._resizeObserver.disconnect(); c._resizeObserver = null; }
+ if (c._fullData) Plotly.purge(c);
+ });
+ }
+
+ this.currentPlotsData = null;
+ }
+
+ /* ----------------------------- Downloads ----------------------------- */
+
+ async downloadCalibrationStandard(standardName, plotContainer) {
+ try {
+ const ts = new Date().toISOString().replace(/[:.]/g, '-');
+ const calibrationName = this.currentPlotsData?.calibration_name || 'unknown';
+ const base = `${calibrationName}_${standardName}_${ts}`;
+
+ if (plotContainer && typeof Plotly !== 'undefined') {
+ await Plotly.downloadImage(plotContainer, {
+ format: 'png', width: 1200, height: 800, filename: `${base}_plot`
});
- }
+ }
- renderCalibrationChart(container, plotConfig, title) {
- if (!container || !plotConfig || plotConfig.error) {
- container.innerHTML = `
Failed to load plot: ${plotConfig?.error || 'Unknown error'}
`;
- return;
+ const data = this._prepareCalibrationDownloadData(standardName);
+ this._downloadJSON(data, `${base}_data.json`);
+
+ this._notify('success', 'Download Complete', `Downloaded ${standardName.toUpperCase()} standard plot and data`);
+ } catch (e) {
+ console.error('Download standard failed:', e);
+ this._notify('error', 'Download Failed', 'Failed to download calibration data');
+ }
+ }
+
+ async downloadAllCalibrationData() {
+ if (!this.currentPlotsData) return;
+
+ try {
+ const ts = new Date().toISOString().replace(/[:.]/g, '-');
+ const calibrationName = this.currentPlotsData.calibration_name || 'unknown';
+ const base = `${calibrationName}_complete_${ts}`;
+
+ const btn = this.elements.downloadAllBtn;
+ if (btn) ButtonState.set(btn, { state: 'loading', icon: 'loader', text: 'Downloading...' });
+
+ const complete = this._prepareCompleteCalibrationData();
+ this._downloadJSON(complete, `${base}.json`);
+
+ await this._downloadAllPlotImages(base);
+
+ this._notify('success', 'Complete Download', `Downloaded complete calibration data and plots for ${calibrationName}`);
+ } catch (e) {
+ console.error('Download all failed:', e);
+ this._notify('error', 'Download Failed', 'Failed to download complete calibration data');
+ } finally {
+ const btn = this.elements.downloadAllBtn;
+ if (btn) ButtonState.set(btn, { state: 'normal', icon: 'download-cloud', text: 'Download All' });
+ }
+ }
+
+ _prepareCalibrationDownloadData(standardName) {
+ if (!this.currentPlotsData) return null;
+ const plot = this.currentPlotsData.individual_plots[standardName];
+ return {
+ calibration_info: {
+ calibration_name: this.currentPlotsData.calibration_name,
+ preset: this.currentPlotsData.preset,
+ standard_name: standardName,
+ download_timestamp: new Date().toISOString()
+ },
+ plot_data: plot ? { data: plot.data, layout: plot.layout, error: plot.error } : null,
+ raw_sweep_data: this._extractRawSweepData(standardName),
+ metadata: {
+ description: `VNA calibration standard data export - ${standardName.toUpperCase()}`,
+ format_version: '1.0',
+ exported_by: 'VNA System Dashboard',
+ contains: ['Calibration information', 'Plot configuration', 'Raw sweep measurements', 'Frequency & magnitude data']
+ }
+ };
+ }
+
+ _extractRawSweepData(standardName) {
+ const plot = this.currentPlotsData?.individual_plots?.[standardName];
+ if (!plot || !plot.raw_sweep_data) return null;
+
+ const raw = plot.raw_sweep_data;
+ const freqInfo = plot.frequency_info;
+
+ const points = [];
+ if (raw.points?.length) {
+ for (let i = 0; i < raw.points.length; i++) {
+ const [re, im] = raw.points[i];
+ const magLin = Math.sqrt(re * re + im * im);
+ const magDb = magLin > 0 ? 20 * Math.log10(magLin) : -120;
+ const phaseRad = Math.atan2(im, re);
+ const phaseDeg = phaseRad * (180 / Math.PI);
+
+ let fHz = 0;
+ if (freqInfo?.start_freq && freqInfo?.stop_freq) {
+ fHz = freqInfo.start_freq + (freqInfo.stop_freq - freqInfo.start_freq) * i / (raw.points.length - 1);
}
- const layout = {
- ...plotConfig.layout,
- title: { text: title, font: { size: 16, color: '#f1f5f9' } },
- plot_bgcolor: 'transparent',
- paper_bgcolor: 'transparent',
- font: { family: 'Inter, -apple-system, BlinkMacSystemFont, sans-serif', size: 12, color: '#f1f5f9' },
- autosize: true,
- width: null,
- height: null,
- margin: { l: 60, r: 50, t: 50, b: 60 },
- showlegend: true,
- legend: {
- orientation: 'v',
- x: 1.02,
- y: 1,
- xanchor: 'left',
- yanchor: 'top',
- bgcolor: 'rgba(30, 41, 59, 0.9)',
- bordercolor: '#475569',
- borderwidth: 1,
- font: { size: 10, color: '#f1f5f9' }
- },
- xaxis: {
- ...plotConfig.layout.xaxis,
- gridcolor: '#334155',
- zerolinecolor: '#475569',
- color: '#cbd5e1',
- fixedrange: false
- },
- yaxis: {
- ...plotConfig.layout.yaxis,
- gridcolor: '#334155',
- zerolinecolor: '#475569',
- color: '#cbd5e1',
- fixedrange: false
- }
- };
-
- const config = {
- displayModeBar: true,
- modeBarButtonsToRemove: ['select2d','lasso2d','hoverClosestCartesian','hoverCompareCartesian','toggleSpikelines'],
- displaylogo: false,
- responsive: false,
- doubleClick: 'reset',
- toImageButtonOptions: {
- format: 'png',
- filename: `calibration-plot-${Date.now()}`,
- height: 600,
- width: 800,
- scale: 1
- }
- };
-
- Plotly.newPlot(container, plotConfig.data, layout, config);
-
- // Setup resize observer
- if (window.ResizeObserver) {
- const ro = new ResizeObserver(() => {
- if (container && container.clientWidth > 0) {
- Plotly.Plots.resize(container);
- }
- });
- ro.observe(container);
- container._resizeObserver = ro;
- }
- }
-
- toggleCalibrationFullscreen(card) {
- if (!document.fullscreenElement) {
- card.requestFullscreen()?.then(() => {
- setTimeout(() => {
- const plotContainer = card.querySelector('.chart-card__plot');
- if (plotContainer && typeof Plotly !== 'undefined') {
- const rect = plotContainer.getBoundingClientRect();
- Plotly.relayout(plotContainer, { width: rect.width, height: rect.height });
- Plotly.Plots.resize(plotContainer);
- }
- }, 200);
- }).catch(console.error);
- } else {
- document.exitFullscreen()?.then(() => {
- setTimeout(() => {
- const plotContainer = card.querySelector('.chart-card__plot');
- if (plotContainer && typeof Plotly !== 'undefined') {
- Plotly.Plots.resize(plotContainer);
- }
- }, 100);
- });
- }
- }
-
- async downloadCalibrationStandard(standardName, plotContainer) {
- try {
- const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
- const calibrationName = this.currentPlotsData?.calibration_name || 'unknown';
- const presetName = this.currentPlotsData?.preset?.filename || 'unknown';
- const baseFilename = `${calibrationName}_${standardName}_${timestamp}`;
-
- // Download image
- if (plotContainer && typeof Plotly !== 'undefined') {
- await Plotly.downloadImage(plotContainer, {
- format: 'png',
- width: 1200,
- height: 800,
- filename: `${baseFilename}_plot`
- });
- }
-
- // Prepare calibration data for download
- const calibrationData = this.prepareCalibrationDownloadData(standardName);
-
- // Download data as JSON
- this.downloadJSON(calibrationData, `${baseFilename}_data.json`);
-
- // Show success notification
- this.notifications.show({
- type: 'success',
- title: 'Download Complete',
- message: `Downloaded ${standardName.toUpperCase()} standard plot and data`
- });
-
- } catch (error) {
- console.error('Failed to download calibration standard:', error);
- this.notifications.show({
- type: 'error',
- title: 'Download Failed',
- message: 'Failed to download calibration data'
- });
- }
- }
-
- prepareCalibrationDownloadData(standardName) {
- if (!this.currentPlotsData) return null;
-
- const standardPlot = this.currentPlotsData.individual_plots[standardName];
-
- return {
- calibration_info: {
- calibration_name: this.currentPlotsData.calibration_name,
- preset: this.currentPlotsData.preset,
- standard_name: standardName,
- download_timestamp: new Date().toISOString()
- },
- plot_data: standardPlot ? {
- data: standardPlot.data,
- layout: standardPlot.layout,
- error: standardPlot.error
- } : null,
- raw_sweep_data: this.extractRawSweepData(standardName),
- metadata: {
- description: `VNA calibration standard data export - ${standardName.toUpperCase()}`,
- format_version: "1.0",
- exported_by: "VNA System Dashboard",
- contains: [
- "Calibration information",
- "Plot configuration (Plotly format)",
- "Raw sweep measurements",
- "Frequency and magnitude data"
- ]
- }
- };
- }
-
- extractRawSweepData(standardName) {
- const standardPlot = this.currentPlotsData?.individual_plots?.[standardName];
- if (!standardPlot || !standardPlot.raw_sweep_data) {
- return null;
- }
-
- const rawData = standardPlot.raw_sweep_data;
- const frequencyInfo = standardPlot.frequency_info;
-
- // Process raw complex data points into detailed format
- const processedPoints = [];
- if (rawData.points && rawData.points.length > 0) {
- for (let i = 0; i < rawData.points.length; i++) {
- const [real, imag] = rawData.points[i];
- const magnitude_linear = Math.sqrt(real * real + imag * imag);
- const magnitude_db = magnitude_linear > 0 ? 20 * Math.log10(magnitude_linear) : -120;
- const phase_radians = Math.atan2(imag, real);
- const phase_degrees = phase_radians * (180 / Math.PI);
-
- // Calculate frequency
- let frequency_hz = 0;
- if (frequencyInfo && frequencyInfo.start_freq && frequencyInfo.stop_freq) {
- frequency_hz = frequencyInfo.start_freq +
- (frequencyInfo.stop_freq - frequencyInfo.start_freq) * i / (rawData.points.length - 1);
- }
-
- processedPoints.push({
- point_index: i,
- frequency_hz: frequency_hz,
- frequency_ghz: frequency_hz / 1e9,
- complex_data: {
- real: real,
- imaginary: imag
- },
- magnitude: {
- linear: magnitude_linear,
- db: magnitude_db
- },
- phase: {
- radians: phase_radians,
- degrees: phase_degrees
- }
- });
- }
- }
-
- return {
- standard_name: standardName,
- sweep_info: {
- sweep_number: rawData.sweep_number,
- timestamp: rawData.timestamp,
- total_points: rawData.total_points,
- file_path: rawData.file_path
- },
- frequency_info: frequencyInfo,
- measurement_points: processedPoints,
- statistics: {
- total_points: processedPoints.length,
- frequency_range: {
- start_hz: processedPoints[0]?.frequency_hz || 0,
- stop_hz: processedPoints[processedPoints.length - 1]?.frequency_hz || 0
- },
- magnitude_range_db: {
- min: Math.min(...processedPoints.map(p => p.magnitude.db)),
- max: Math.max(...processedPoints.map(p => p.magnitude.db))
- }
- }
- };
- }
-
- async downloadAllCalibrationData() {
- if (!this.currentPlotsData) return;
-
- try {
- const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
- const calibrationName = this.currentPlotsData.calibration_name || 'unknown';
- const baseFilename = `${calibrationName}_complete_${timestamp}`;
-
- // Show loading state
- const downloadAllBtn = this.elements.downloadAllBtn;
- if (downloadAllBtn) {
- downloadAllBtn.disabled = true;
- downloadAllBtn.innerHTML = '
Downloading...';
- if (typeof lucide !== 'undefined') lucide.createIcons();
- }
-
- // Prepare complete calibration export
- const completeData = this.prepareCompleteCalibrationData();
-
- // Download complete data as JSON
- this.downloadJSON(completeData, `${baseFilename}.json`);
-
- // Also download individual plots as images
- await this.downloadAllPlotImages(baseFilename);
-
- // Show success notification
- this.notifications.show({
- type: 'success',
- title: 'Complete Download',
- message: `Downloaded complete calibration data and all plots for ${calibrationName}`
- });
-
- } catch (error) {
- console.error('Failed to download complete calibration data:', error);
- this.notifications.show({
- type: 'error',
- title: 'Download Failed',
- message: 'Failed to download complete calibration data'
- });
- } finally {
- // Restore button state
- const downloadAllBtn = this.elements.downloadAllBtn;
- if (downloadAllBtn) {
- downloadAllBtn.disabled = false;
- downloadAllBtn.innerHTML = '
Download All';
- if (typeof lucide !== 'undefined') lucide.createIcons();
- }
- }
- }
-
- prepareCompleteCalibrationData() {
- if (!this.currentPlotsData) return null;
-
- const allStandardsData = {};
- Object.keys(this.currentPlotsData.individual_plots).forEach(standardName => {
- allStandardsData[standardName] = this.prepareCalibrationDownloadData(standardName);
+ points.push({
+ point_index: i,
+ frequency_hz: fHz,
+ frequency_ghz: fHz / 1e9,
+ complex_data: { real: re, imaginary: im },
+ magnitude: { linear: magLin, db: magDb },
+ phase: { radians: phaseRad, degrees: phaseDeg }
});
-
- return {
- export_info: {
- export_timestamp: new Date().toISOString(),
- export_type: "complete_calibration",
- calibration_name: this.currentPlotsData.calibration_name,
- preset: this.currentPlotsData.preset,
- standards_included: Object.keys(allStandardsData),
- format_version: "1.0"
- },
- calibration_summary: {
- name: this.currentPlotsData.calibration_name,
- preset: this.currentPlotsData.preset,
- total_standards: Object.keys(allStandardsData).length,
- standards: Object.keys(allStandardsData).map(name => ({
- name: name,
- has_data: allStandardsData[name] !== null,
- has_error: allStandardsData[name]?.plot_data?.error ? true : false
- }))
- },
- standards_data: allStandardsData,
- metadata: {
- description: "Complete VNA calibration data export including all standards",
- exported_by: "VNA System Dashboard",
- contains: [
- "Complete calibration information",
- "All calibration standards data",
- "Raw sweep measurements for each standard",
- "Plot configurations (Plotly format)",
- "Frequency and magnitude data",
- "Complex impedance measurements"
- ],
- usage_notes: [
- "This file contains all data for the calibration set",
- "Individual standard data is available in the 'standards_data' section",
- "Raw complex measurements are in [real, imaginary] format",
- "Frequencies are provided in both Hz and GHz",
- "Magnitudes are provided in both linear and dB scales"
- ]
- }
- };
+ }
}
- async downloadAllPlotImages(baseFilename) {
- const plotContainers = this.elements.plotsModal.querySelectorAll('[id^="calibration-plot-"]');
- const downloadPromises = [];
-
- plotContainers.forEach(container => {
- if (container && typeof Plotly !== 'undefined' && container._fullData) {
- const standardName = container.id.replace('calibration-plot-', '');
- const promise = Plotly.downloadImage(container, {
- format: 'png',
- width: 1200,
- height: 800,
- filename: `${baseFilename}_${standardName}_plot`
- });
- downloadPromises.push(promise);
- }
- });
-
- // Wait for all image downloads to complete
- await Promise.all(downloadPromises);
- }
-
- downloadJSON(data, filename) {
- const jsonString = JSON.stringify(data, null, 2);
- const blob = new Blob([jsonString], { type: 'application/json' });
- const url = URL.createObjectURL(blob);
-
- const link = document.createElement('a');
- link.href = url;
- link.download = filename;
- document.body.appendChild(link);
- link.click();
- document.body.removeChild(link);
-
- // Clean up the URL object
- URL.revokeObjectURL(url);
- }
-
- closePlotsModal() {
- const modal = this.elements.plotsModal;
- if (!modal) return;
-
- modal.classList.remove('modal--active');
- document.body.style.overflow = '';
-
- // Clean up plots and resize observers
- if (typeof Plotly !== 'undefined') {
- const plotContainers = modal.querySelectorAll('[id^="calibration-plot-"]');
- plotContainers.forEach(container => {
- if (container._resizeObserver) {
- container._resizeObserver.disconnect();
- container._resizeObserver = null;
- }
- if (container._fullData) {
- Plotly.purge(container);
- }
- });
+ return {
+ standard_name: standardName,
+ sweep_info: {
+ sweep_number: raw.sweep_number,
+ timestamp: raw.timestamp,
+ total_points: raw.total_points,
+ file_path: raw.file_path
+ },
+ frequency_info: freqInfo,
+ measurement_points: points,
+ statistics: {
+ total_points: points.length,
+ frequency_range: {
+ start_hz: points[0]?.frequency_hz || 0,
+ stop_hz: points[points.length - 1]?.frequency_hz || 0
+ },
+ magnitude_range_db: {
+ min: Math.min(...points.map(p => p.magnitude.db)),
+ max: Math.max(...points.map(p => p.magnitude.db))
}
+ }
+ };
+ }
- // Clear plots data
- this.currentPlotsData = null;
+ _prepareCompleteCalibrationData() {
+ if (!this.currentPlotsData) return null;
+ const all = {};
+ Object.keys(this.currentPlotsData.individual_plots).forEach(name => {
+ all[name] = this._prepareCalibrationDownloadData(name);
+ });
+
+ return {
+ export_info: {
+ export_timestamp: new Date().toISOString(),
+ export_type: 'complete_calibration',
+ calibration_name: this.currentPlotsData.calibration_name,
+ preset: this.currentPlotsData.preset,
+ standards_included: Object.keys(all),
+ format_version: '1.0'
+ },
+ calibration_summary: {
+ name: this.currentPlotsData.calibration_name,
+ preset: this.currentPlotsData.preset,
+ total_standards: Object.keys(all).length,
+ standards: Object.keys(all).map(n => ({
+ name: n,
+ has_data: all[n] !== null,
+ has_error: !!all[n]?.plot_data?.error
+ }))
+ },
+ standards_data: all,
+ metadata: {
+ description: 'Complete VNA calibration data export including all standards',
+ exported_by: 'VNA System Dashboard',
+ contains: [
+ 'Complete calibration information',
+ 'All calibration standards data',
+ 'Raw sweep measurements',
+ 'Plot configurations (Plotly format)',
+ 'Frequency and magnitude data',
+ 'Complex impedance measurements'
+ ],
+ usage_notes: [
+ 'File contains all data for the calibration set',
+ "Individual standard data is in 'standards_data'",
+ 'Raw complex measurements are in [real, imaginary]',
+ 'Frequencies in Hz and GHz, magnitudes in linear and dB'
+ ]
+ }
+ };
+ }
+
+ async _downloadAllPlotImages(base) {
+ const containers = this.elements.plotsModal.querySelectorAll('[id^="calibration-plot-"]');
+ const jobs = [];
+ containers.forEach(c => {
+ if (c && typeof Plotly !== 'undefined' && c._fullData) {
+ const name = c.id.replace('calibration-plot-', '');
+ jobs.push(Plotly.downloadImage(c, { format: 'png', width: 1200, height: 800, filename: `${base}_${name}_plot` }));
+ }
+ });
+ await Promise.all(jobs);
+ }
+
+ _downloadJSON(data, filename) {
+ const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+ const url = URL.createObjectURL(blob);
+ const a = Object.assign(document.createElement('a'), { href: url, download: filename });
+ document.body.appendChild(a);
+ a.click();
+ a.remove();
+ URL.revokeObjectURL(url);
+ }
+
+ /* ----------------------------- Helpers ----------------------------- */
+
+ _notify(type, title, message) {
+ this.notifications?.show?.({ type, title, message });
+ }
+
+ _resetCalibrationCaptureState(standard = null) {
+ // публичная версия для внешних вызовов
+ this._resetCalibrationCaptureStateInternal(standard);
+ }
+
+ _resetCalibrationCaptureStateInternal(standard = null) {
+ if (standard) this.disabledStandards.delete(standard);
+ else this.disabledStandards.clear();
+
+ if (!standard || standard === this.pendingStandard) {
+ this.waitingForSweep = false;
+ this.pendingStandard = null;
+ this.websocket?.off?.('processor_result', this._boundHandleSweepForCalibration);
+ this._clearCalibrationTimeout();
}
- // Public methods for external use
- async refresh() {
- if (!this.isInitialized) return;
-
- await this.loadInitialData();
- }
-
- async handleSweepForCalibration(payload) {
- // Only process if we're waiting for a sweep and this is sweep data
- if (!this.waitingForSweep || !this.pendingStandard) return;
-
- try {
- console.log(`📡 New sweep received, capturing ${this.pendingStandard} standard...`);
-
- // Remove listener to avoid duplicate calls
- if (this.websocket) {
- this.websocket.off('processor_result', this.handleSweepForCalibration.bind(this));
- }
-
- const button = document.querySelector(`[data-standard="${this.pendingStandard}"]`);
- if (button) {
- button.innerHTML = '
Capturing...';
- if (typeof lucide !== 'undefined') lucide.createIcons();
- }
-
- const response = await fetch('/api/v1/settings/calibration/add-standard', {
- method: 'POST',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ standard: this.pendingStandard })
- });
-
- if (!response.ok) throw new Error(`HTTP ${response.status}`);
-
- const result = await response.json();
-
- this.notifications.show({
- type: 'success',
- title: 'Standard Captured',
- message: result.message
- });
-
- // Reset state
- this.resetStandardCaptureState();
-
- // Reload working calibration
- await this.loadWorkingCalibration();
-
- } catch (error) {
- console.error('Failed to capture standard:', error);
- this.notifications.show({
- type: 'error',
- title: 'Calibration Error',
- message: 'Failed to capture calibration standard'
- });
-
- this.resetStandardCaptureState();
- }
- }
-
- resetStandardCaptureState(standard = null) {
- // Reset specific standard or all
- if (standard) {
- this.disabledStandards.delete(standard);
- } else {
- this.disabledStandards.clear();
- }
-
- // If this was the pending standard, reset waiting state
- if (!standard || standard === this.pendingStandard) {
- this.waitingForSweep = false;
- this.pendingStandard = null;
-
- // Remove WebSocket listener if still attached
- if (this.websocket) {
- this.websocket.off('processor_result', this.handleSweepForCalibration.bind(this));
- }
- }
-
- // Restore button states
- if (this.workingCalibration) {
- this.generateStandardButtons(this.workingCalibration);
- }
- }
-
- destroy() {
- // Clean up calibration capture state
- this.resetStandardCaptureState();
-
- // Remove event listeners
- this.elements.presetDropdown?.removeEventListener('change', this.handlePresetChange);
- this.elements.setPresetBtn?.removeEventListener('click', this.handleSetPreset);
- this.elements.startCalibrationBtn?.removeEventListener('click', this.handleStartCalibration);
- this.elements.saveCalibrationBtn?.removeEventListener('click', this.handleSaveCalibration);
- this.elements.calibrationDropdown?.removeEventListener('change', this.handleCalibrationChange);
- this.elements.setCalibrationBtn?.removeEventListener('click', this.handleSetCalibration);
-
- this.isInitialized = false;
- console.log('🧹 Settings Manager destroyed');
- }
-}
\ No newline at end of file
+ if (this.workingCalibration) this._renderStandardButtons(this.workingCalibration);
+ }
+}