DynExp
Highly flexible laboratory automation for dynamically changing experiments.
Loading...
Searching...
No Matches
WidefieldMicroscopeWidget.cpp
Go to the documentation of this file.
1// This file is part of DynExp.
2
3#include "stdafx.h"
4#include "WidefieldMicroscope.h"
5#include "moc_WidefieldMicroscopeWidget.cpp"
6#include "WidefieldMicroscopeWidget.h"
7
8namespace DynExpModule::Widefield
9{
10 WidefieldMicroscopeWidget::StatusBarType::StatusBarType(WidefieldMicroscopeWidget* Owner)
11 : CurrentState(nullptr), CurrentContext(nullptr),
12 StateLabel(new QLabel(Owner)),
13 CellIDLabel(new QLabel(Owner)), CellIDContextMenu(new QMenu(Owner)),
14 HomePosLabel(new QLabel(Owner)),
15 PumpPowerLabel(new QLabel(Owner)),
16 ImageCoordinatesGroup(new QWidget(Owner)), ImageCoordinatesLayout(new QHBoxLayout),
17 XCoordLabel(new QLabel(Owner)), YCoordLabel(new QLabel(Owner))
18 {
19 CellIDLabel->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
20 PumpPowerLabel->setMinimumWidth(140);
21 XCoordLabel->setAlignment(Qt::AlignmentFlag::AlignRight);
22 YCoordLabel->setAlignment(Qt::AlignmentFlag::AlignRight);
23 ImageCoordinatesLayout->addWidget(XCoordLabel);
24 ImageCoordinatesLayout->addWidget(YCoordLabel);
25 ImageCoordinatesGroup->setLayout(ImageCoordinatesLayout);
26 }
27
28 void WidefieldMicroscopeWidget::StatusBarType::Update()
29 {
30 if (CurrentContext && !std::string(CurrentContext->GetDescription()).empty())
31 StateLabel->setText(QString(" ") + CurrentContext->GetDescription());
32 else
33 StateLabel->setText(CurrentState ? (QString(" ") + CurrentState->GetDescription()) : "< Unknown >");
34
35 if (CurrentState && CurrentState->GetState() != StateType::Ready)
36 StateLabel->setStyleSheet(DynExpUI::StatusBarBusyStyleSheet);
37 else
38 StateLabel->setStyleSheet("");
39 }
40
41 WidefieldMicroscopeWidget::WidefieldMicroscopeWidget(WidefieldMicroscope& Owner, QModuleWidget* parent)
42 : QModuleWidget(Owner, parent), StatusBar(this),
43 WidefieldConfocalModeActionGroup(new QActionGroup(this)), MainGraphicsView(nullptr),
44 MainGraphicsScene(new QGraphicsScene(this)), CurrentConfocalSpotPosition(0, 0),
45 EmitterListContextMenu(new QMenu(this)),
46 ConfocalMapContextMenu(new QMenu(this)), ConfocalGraph(nullptr), ConfocalGraphContainer(nullptr),
47 ConfocalSurfaceDataProxy(new QSurfaceDataProxy(this)), ConfocalSurfaceDataArray(nullptr),
48 ConfocalSurface3DSeries(new QSurface3DSeries(ConfocalSurfaceDataProxy)),
49 NumItemsInArray(0),
50 ConfocalSurfaceMinCounts(std::numeric_limits<decltype(ConfocalSurfaceMinCounts)>::max()), ConfocalSurfaceMaxCounts(0),
51 HBTDataSeries(nullptr), HBTDataChart(nullptr), HBTXAxis(new QValueAxis(this)), HBTYAxis(new QValueAxis(this))
52 {
53 ui.setupUi(this);
54
55 // For shortcuts
56 this->addAction(ui.action_Stop_current_action);
57 this->addAction(ui.action_Optimize_positions);
58 this->addAction(ui.action_Save_Image);
59 this->addAction(ui.action_Save_Image);
60 this->addAction(ui.action_Zoom_in);
61 this->addAction(ui.action_Zoom_out);
62 this->addAction(ui.action_Zoom_reset);
63 this->addAction(ui.action_Zoom_fit);
64 this->addAction(ui.action_EmitterList_Edit_name);
65 this->addAction(ui.action_EmitterList_Remove_entry);
66
67 ui.action_Zoom_fit->setChecked(true);
68
69 // Status bar
70 ui.MainStatusBar->addWidget(StatusBar.StateLabel, 4);
71 ui.MainStatusBar->addWidget(StatusBar.CellIDLabel, 1);
72 ui.MainStatusBar->addWidget(StatusBar.HomePosLabel, 2);
73 ui.MainStatusBar->addWidget(StatusBar.PumpPowerLabel, 1);
74 ui.MainStatusBar->addPermanentWidget(StatusBar.ImageCoordinatesGroup, 2);
75
76 StatusBar.CellIDContextMenu->addAction(ui.action_Reset_CellID);
77 connect(StatusBar.CellIDLabel, &QWidget::customContextMenuRequested, this, &WidefieldMicroscopeWidget::OnCellIDContextMenuRequested);
78
79 // Tool bar
80 WidefieldConfocalModeActionGroup->addAction(ui.action_Widefield_mode);
81 WidefieldConfocalModeActionGroup->addAction(ui.action_Widefield_mode);
82 WidefieldConfocalModeActionGroup->addAction(ui.action_Confocal_mode);
83
84 // Main image
85 MainGraphicsView = new Util::MarkerGraphicsView(ui.MainHSplitter);
86 MainGraphicsView->setObjectName(QString::fromUtf8("MainGraphicsView"));
87 MainGraphicsView->setMinimumSize(QSize(300, 200));
88 ui.MainHSplitter->addWidget(MainGraphicsView);
89
90 MainGraphicsPixmapItem = MainGraphicsScene->addPixmap(MainGraphicsPixmap);
91 MainGraphicsView->setScene(MainGraphicsScene);
92 MainGraphicsView->setAlignment(Qt::AlignLeft | Qt::AlignTop);
93 MainGraphicsView->viewport()->installEventFilter(this);
94 MainGraphicsView->viewport()->setMouseTracking(true);
95
96 MainGraphicsView->contextMenu()->addSeparator();
97 MainGraphicsView->contextMenu()->addAction(ui.action_Zoom_in);
98 MainGraphicsView->contextMenu()->addAction(ui.action_Zoom_out);
99 MainGraphicsView->contextMenu()->addAction(ui.action_Zoom_reset);
100 MainGraphicsView->contextMenu()->addAction(ui.action_Zoom_fit);
101 MainGraphicsView->contextMenu()->addSeparator();
102 MainGraphicsView->contextMenu()->addAction(ui.action_Save_Image);
103
104 // Emitter list
105 EmitterListContextMenu->addAction(ui.action_EmitterList_Edit_name);
106 EmitterListContextMenu->addAction(ui.action_EmitterList_Remove_entry);
107 EmitterListContextMenu->addSeparator();
108 EmitterListContextMenu->addAction(ui.action_EmitterList_Go_to_sample_position);
109 EmitterListContextMenu->addAction(ui.action_EmitterList_Bring_marker_to_confocal_spot);
110 EmitterListContextMenu->addSeparator();
111 EmitterListContextMenu->addAction(ui.action_EmitterList_Run_characterization_from_ID);
112
113 // Graph to display confocal scans
114 ConfocalMapContextMenu->addAction(ui.action_confocal_map_save_raw_data);
115 ConfocalMapContextMenu->addAction(ui.action_confocal_map_reset);
116 ui.BConfocalGraphTools->setMenu(ConfocalMapContextMenu);
117 ConfocalGraph = new Q3DSurface(); // Ownership transferred to ConfocalGraphContainer below.
118 ConfocalGraphContainer = QWidget::createWindowContainer(ConfocalGraph, ui.WidgetConfocalGraphContainer);
119 ConfocalGraphContainer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
120 ui.WidgetConfocalGraphContainer->layout()->addWidget(ConfocalGraphContainer);
121 ConfocalGraph->activeTheme()->setType(DynExpUI::DefaultQ3DTheme);
122 ConfocalGraph->activeTheme()->setLabelBorderEnabled(false);
123 ConfocalGraph->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPreset::CameraPresetDirectlyAbove);
124 ConfocalGraph->setShadowQuality(QAbstract3DGraph::ShadowQuality::ShadowQualityNone);
125 ConfocalGraph->setOrthoProjection(true);
126 ConfocalGraph->setSelectionMode(QAbstract3DGraph::SelectionFlag::SelectionItem);
127
128 ConfocalGraph->axisX()->setLabelFormat("%.0f");
129 ConfocalGraph->axisX()->setAutoAdjustRange(true);
130 ConfocalGraph->axisX()->setLabelAutoRotation(90);
131 ConfocalGraph->axisX()->setTitle("X in nm");
132 ConfocalGraph->axisX()->setTitleVisible(true);
133 ConfocalGraph->axisY()->setLabelFormat("%.0f");
134 ConfocalGraph->axisY()->setAutoAdjustRange(false);
135 ConfocalGraph->axisY()->setTitle("Count rate in Hz");
136 ConfocalGraph->axisY()->setTitleVisible(true);
137 ConfocalGraph->axisZ()->setLabelFormat("%.0f");
138 ConfocalGraph->axisZ()->setAutoAdjustRange(true);
139 ConfocalGraph->axisZ()->setTitle("Y in nm");
140 ConfocalGraph->axisZ()->setTitleVisible(true);
141
142 ConfocalSurface3DSeries->setDrawMode(QSurface3DSeries::DrawSurface);
143 ConfocalSurface3DSeries->setFlatShadingEnabled(true);
144 ConfocalSurface3DSeries->setBaseGradient(DynExpUI::GetDefaultLinearGradient());
145 ConfocalSurface3DSeries->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
146 ConfocalSurface3DSeries->setItemLabelFormat("(@xLabel nm, @zLabel nm): @yLabel Hz");
147 ConfocalGraph->addSeries(ConfocalSurface3DSeries);
148
149 // Graph to display HBT result
150 HBTDataChart = new QChart();
151 ui.HBTChart->setChart(HBTDataChart); // Takes ownership of HBTDataChart.
152 ui.HBTChart->setRenderHint(QPainter::Antialiasing);
153 HBTDataChart->setTheme(DynExpUI::DefaultQChartTheme);
154 HBTDataChart->legend()->setVisible(false);
155 HBTXAxis->setTitleText("time in ps");
156 HBTYAxis->setTitleText("g(2)");
157
158 // Chart takes ownership of axes.
159 HBTDataChart->addAxis(HBTXAxis, Qt::AlignBottom);
160 HBTDataChart->addAxis(HBTYAxis, Qt::AlignLeft);
161 }
162
163 const WidefieldMicroscope& WidefieldMicroscopeWidget::GetCastOwner() const noexcept
164 {
165 return static_cast<const WidefieldMicroscope&>(GetOwner());
166 }
167
168 void WidefieldMicroscopeWidget::InitializeUI(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
169 {
170 if (!GetUIInitialized())
171 {
172 ui.action_Toogle_LED_light_source->setEnabled(ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::LEDLightToggle));
173 ui.action_Toogle_pump_light_source->setEnabled(ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::PumpLightToggle));
174 ui.GBGeneralLaserPowers->setEnabled(ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::SetPumpPower));
175
176 auto WidefieldTabIndex = ui.TabWidget->indexOf(ui.TabWidefield);
177 auto ConfocalTabIndex = ui.TabWidget->indexOf(ui.TabConfocal);
178 auto HBTTabIndex = ui.TabWidget->indexOf(ui.TabHBT);
179 ui.TabWidget->setTabVisible(WidefieldTabIndex, ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield));
180 ui.TabWidget->setTabVisible(ConfocalTabIndex, ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Confocal));
181 ui.TabWidget->setTabVisible(HBTTabIndex, ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::HBT));
182
183 ui.SBGeneralWidefieldPower->setMinimum(ModuleData->GetMinPumpPower());
184 ui.SBGeneralWidefieldPower->setMaximum(ModuleData->GetMaxPumpPower());
185 ui.SBGeneralWidefieldPower->setSingleStep(std::abs(ModuleData->GetMaxPumpPower() - ModuleData->GetMinPumpPower()) / 100.0);
186 ui.SBGeneralConfocalPower->setMinimum(ModuleData->GetMinPumpPower());
187 ui.SBGeneralConfocalPower->setMaximum(ModuleData->GetMaxPumpPower());
188 ui.SBGeneralConfocalPower->setSingleStep(std::abs(ModuleData->GetMaxPumpPower() - ModuleData->GetMinPumpPower()) / 100.0);
189 if (ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::FocusAdjustment))
190 {
191 ui.SBGeneralFocusCurrentVoltage->setMinimum(ModuleData->GetMinFocusVoltage());
192 ui.SBGeneralFocusCurrentVoltage->setMaximum(ModuleData->GetMaxFocusVoltage());
193 ui.SBGeneralFocusCurrentVoltage->setSingleStep(std::abs(ModuleData->GetMaxFocusVoltage() - ModuleData->GetMinFocusVoltage()) / 100.0);
194 ui.SBGeneralFocusZeroVoltage->setMinimum(ModuleData->GetMinFocusVoltage());
195 ui.SBGeneralFocusZeroVoltage->setMaximum(ModuleData->GetMaxFocusVoltage());
196 ui.SBGeneralFocusZeroVoltage->setSingleStep(std::abs(ModuleData->GetMaxFocusVoltage() - ModuleData->GetMinFocusVoltage()) / 100.0);
197 ui.SBGeneralFocusConfocalOffsetVoltage->setMinimum(-std::abs(ModuleData->GetMinFocusVoltage()) - std::abs(ModuleData->GetMaxFocusVoltage()));
198 ui.SBGeneralFocusConfocalOffsetVoltage->setMaximum(std::abs(ModuleData->GetMinFocusVoltage()) + std::abs(ModuleData->GetMaxFocusVoltage()));
199 ui.SBGeneralFocusConfocalOffsetVoltage->setSingleStep(std::abs(ModuleData->GetMaxFocusVoltage() - ModuleData->GetMinFocusVoltage()) / 100.0);
200 }
201 else
202 ui.GBGeneralFocus->setVisible(false);
203 if (!ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldConfocalSwitch))
204 {
205 ui.LGeneralWidefieldPower->setText("Power in any mode");
206 ui.LGeneralConfocalPower->setVisible(false);
207 ui.SBGeneralConfocalPower->setVisible(false);
208 ui.LGeneralFocusConfocalOffsetVoltage->setVisible(false);
209 ui.SBGeneralFocusConfocalOffsetVoltage->setVisible(false);
210 }
211
212 ui.SBWidefieldLEDExposureTime->setMinimum(ModuleData->GetMinCameraExposureTime().count());
213 ui.SBWidefieldLEDExposureTime->setMaximum(ModuleData->GetMaxCameraExposureTime().count());
214 ui.SBWidefieldPumpExposureTime->setMinimum(ModuleData->GetMinCameraExposureTime().count());
215 ui.SBWidefieldPumpExposureTime->setMaximum(ModuleData->GetMaxCameraExposureTime().count());
216
217 ui.TWEmitterList->setColumnWidth(EmitterListColumnType::EmitterName, 96);
218 ui.TWEmitterList->setColumnWidth(EmitterListColumnType::Sample_x, 134);
219 ui.TWEmitterList->setColumnWidth(EmitterListColumnType::Sample_y, 134);
220 ui.TWEmitterList->setColumnWidth(EmitterListColumnType::EmitterState, 134);
221
222 UIInitialized = true;
223 }
224 }
225
226 void WidefieldMicroscopeWidget::SetUIState(const StateMachineStateType* State, const Util::StateMachineContext<StateMachineStateType>* Context,
227 Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
228 {
229 bool IsReady = State->GetState() == StateType::Ready;
230 StatusBar.CurrentState = State;
231 StatusBar.CurrentContext = Context;
232
233 StatusBar.CellIDLabel->setText(ModuleData->HasCellID() ? QString::fromStdString(ModuleData->GetCellID().IDString) : "< Unknown cell ID. >");
234 StatusBar.CellIDLabel->setToolTip(ModuleData->HasCellID() ?
235 ("(" + QString::number(ModuleData->GetCellID().X_id) + ", " + QString::number(ModuleData->GetCellID().Y_id) + ")") : "n/a");
236
237 QString HomePosString = "home: (" + QString::number(ModuleData->GetSampleHomePosition().x) + " nm, " + QString::number(ModuleData->GetSampleHomePosition().y) + " nm)";
238 StatusBar.HomePosLabel->setText(ModuleData->GetSampleHomePosition().IsEmpty() ? "< No home position set. >" : HomePosString);
239
240 StatusBar.PumpPowerLabel->setText(ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::MeasurePumpPower) ?
241 (" Pump power: " + QString::number(ModuleData->GetMeasuredPumpPower(), 'f', 2) + " V") : "");
242 if (ModuleData->GetPumpLightTurnedOn())
243 StatusBar.PumpPowerLabel->setStyleSheet(DynExpUI::StatusBarRunningStyleSheet);
244 else
245 StatusBar.PumpPowerLabel->setStyleSheet("");
246
247 MainGraphicsView->EnableActions(IsReady);
248 ui.action_Save_Image->setEnabled(IsReady);
249 ui.action_Stop_current_action->setEnabled(!IsReady);
250 ui.action_Set_home_position->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Confocal));
251 ui.action_Go_home_position->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Confocal));
252 ui.action_Widefield_mode->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldConfocalSwitch));
253 ui.action_Confocal_mode->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldConfocalSwitch));
254 ui.action_Autofocus->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::FocusAdjustment));
255 ui.action_Optimize_positions->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::ConfocalOptimization)
256 && ModuleData->GetSetupMode() == WidefieldMicroscopeData::SetupModeType::Confocal);
257 ui.action_Toggle_HBT_mirror->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::HBTSwitch));
258 ui.action_Reset_CellID->setEnabled(IsReady);
259 ui.GBGeneralLaserPowers->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::SetPumpPower));
260 ui.GBGeneralFocus->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::FocusAdjustment));
261 ui.SBWidefieldLEDExposureTime->setEnabled(IsReady &&
262 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield) && ModuleData->GetWidefieldCamera()->CanSetExposureTime());
263 ui.BWidefieldApplyLEDExposureTime->setEnabled(IsReady &&
264 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield) && ModuleData->GetWidefieldCamera()->CanSetExposureTime());
265 ui.SBWidefieldPumpExposureTime->setEnabled(IsReady &&
266 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield) && ModuleData->GetWidefieldCamera()->CanSetExposureTime());
267 ui.BWidefieldApplyPumpExposureTime->setEnabled(IsReady &&
268 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield) && ModuleData->GetWidefieldCamera()->CanSetExposureTime());
269 ui.BWidefieldFindConfocalSpot->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldConfocalSwitch));
270 ui.BWidefieldLEDCapture->setEnabled(IsReady);
271 ui.BWidefieldCapture->setEnabled(IsReady);
272 ui.BReadCellID->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldLocalization));
273 ui.BAnalyzeImageDistortion->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldLocalization));
274 ui.BLocalizeEmitters->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldLocalization));
275 ui.action_EmitterList_Edit_name->setEnabled(IsReady);
276 ui.action_EmitterList_Remove_entry->setEnabled(IsReady);
277 ui.action_EmitterList_Go_to_sample_position->setEnabled(IsReady);
278 ui.action_EmitterList_Bring_marker_to_confocal_spot->setEnabled(IsReady);
279 ui.action_EmitterList_Run_characterization_from_ID->setEnabled(IsReady);
280 ui.SBConfocalWidth->setEnabled(IsReady);
281 ui.SBConfocalHeight->setEnabled(IsReady);
282 ui.SBConfocalDistPerPixel->setEnabled(IsReady);
283 ui.SBConfocalSPDExposureTime->setEnabled(IsReady);
284 ui.SBConfocalOptimizationInitXYStepSize->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::ConfocalOptimization));
285 ui.SBConfocalOptimizationInitZStepSize->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::ConfocalOptimization));
286 ui.SBConfocalOptimizationTolerance->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::ConfocalOptimization));
287 ui.BConfocalScan->setEnabled(IsReady);
288 ui.action_confocal_map_save_raw_data->setEnabled(IsReady);
289 ui.SBHBTBinWidth->setEnabled(IsReady);
290 ui.SBHBTBinCount->setEnabled(IsReady);
291 ui.BHBTSaveData->setEnabled(IsReady);
292 ui.BHBT->setEnabled(IsReady);
293 ui.GBAutoMeasureGeneralSettings->setEnabled(IsReady);
294 ui.GBAutoMeasureLocalizationSettings->setEnabled(IsReady);
295 ui.GBAutoMeasureCharacterizationSettings->setEnabled(IsReady);
296 ui.GBAutoMeasureCellSettings->setEnabled(IsReady);
297 ui.BAutoMeasureRunLocalization->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield));
298 ui.BAutoMeasureRunCharacterization->setEnabled(IsReady);
299 ui.BAutoMeasureRunSampleCharacterization->setEnabled(IsReady && ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Widefield) &&
300 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::Confocal) &&
301 ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::WidefieldLocalization));
302 }
303
304 void WidefieldMicroscopeWidget::UpdateUIData(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
305 {
306 // Toolbar
307 ui.action_Toogle_LED_light_source->setChecked(ModuleData->GetLEDLightTurnedOn());
308 ui.action_Toogle_pump_light_source->setChecked(ModuleData->GetPumpLightTurnedOn());
309 ui.action_Widefield_mode->setChecked(ModuleData->GetSetupMode() == WidefieldMicroscopeData::SetupModeType::Widefield);
310 ui.action_Confocal_mode->setChecked(ModuleData->GetSetupMode() == WidefieldMicroscopeData::SetupModeType::Confocal);
311
312 // General
313 // QDoubleSpinBox::setValue() emits QDoubleSpinBox::valueChanged().
314 if (!ui.SBGeneralWidefieldPower->hasFocus())
315 ui.SBGeneralWidefieldPower->setValue(ModuleData->GetWidefieldPumpPower());
316 if (!ui.SBGeneralConfocalPower->hasFocus())
317 ui.SBGeneralConfocalPower->setValue(ModuleData->GetConfocalPumpPower());
318 if (!ui.SBGeneralFocusCurrentVoltage->hasFocus())
319 ui.SBGeneralFocusCurrentVoltage->setValue(ModuleData->GetFocusCurrentVoltage());
320 if (!ui.SBGeneralFocusZeroVoltage->hasFocus())
321 ui.SBGeneralFocusZeroVoltage->setValue(ModuleData->GetFocusZeroVoltage());
322 if (!ui.SBGeneralFocusConfocalOffsetVoltage->hasFocus())
323 ui.SBGeneralFocusConfocalOffsetVoltage->setValue(ModuleData->GetFocusConfocalOffsetVoltage());
324
325 // MainGraphicsView
326 if (ModuleData->TestFeature(WidefieldMicroscopeData::FeatureType::SampleXYPositioning))
327 {
328 auto SamplePosition = ModuleData->GetSamplePosition();
329 MainGraphicsView->SetCurrentImagePos({ static_cast<qreal>(SamplePosition.x), static_cast<qreal>(SamplePosition.y) });
330 }
331 else
332 MainGraphicsView->SetCurrentImagePos({ });
333 }
334
335 void WidefieldMicroscopeWidget::UpdateWidefieldUIData(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
336 {
337 if (!ui.SBWidefieldLEDExposureTime->hasFocus())
338 ui.SBWidefieldLEDExposureTime->setValue(ModuleData->GetLEDCameraExposureTime().count());
339
340 if (!ui.SBWidefieldPumpExposureTime->hasFocus())
341 ui.SBWidefieldPumpExposureTime->setValue(ModuleData->GetWidefieldCameraExposureTime().count());
342
343 if (ModuleData->IsCurrentImageAvlbl())
344 {
345 // SetMainGraphicsImage creates a deep copy of the current image.
346 SetMainGraphicsImage(ModuleData->GetCurrentImage());
347 ModuleData->ResetCurrentImageAvlbl();
348 }
349
350 if (!SaveWidefieldImageFilename.isEmpty())
351 {
352 ModuleData->EnqueueEvent(DynExp::MakeEvent(&GetCastOwner(), &WidefieldMicroscope::OnSaveCurrentImage, SaveWidefieldImageFilename));
353
354 SaveWidefieldImageFilename.clear();
355 }
356
357 if (ModuleData->HaveLocalizedPositionsChanged())
358 {
359 MainGraphicsView->RemoveMarkers(true);
360 for (const auto& Position : ModuleData->GetLocalizedPositions())
361 MainGraphicsView->AddMarker(Position.second.Position, QColorConstants::DarkYellow, true, Position.first, "Emitter " + Util::ToStr(Position.first));
362
363 ModuleData->ResetLocalizedPositionsChanged();
364 }
365
366 if (CurrentConfocalSpotPosition != ModuleData->GetConfocalSpotImagePosition())
367 {
368 MainGraphicsView->RemoveMarker(CurrentConfocalSpotPosition);
369 MainGraphicsView->AddMarker(ModuleData->GetConfocalSpotImagePosition(), QColorConstants::Red, false, -1, "Confocal spot");
370
371 CurrentConfocalSpotPosition = ModuleData->GetConfocalSpotImagePosition();
372 }
373
374 if (MainGraphicsView->HaveMarkersChanged())
375 {
376 // Copy intended.
377 const auto LocalizedPositions = ModuleData->GetLocalizedPositions();
378 ModuleData->ClearLocalizedPositions();
379
380 bool SortingEnabled = ui.TWEmitterList->isSortingEnabled();
381 ui.TWEmitterList->setSortingEnabled(false);
382
383 ui.TWEmitterList->clearContents();
384 ui.TWEmitterList->setRowCount(0);
385
386 auto& Markers = MainGraphicsView->GetMarkers();
387 for (const auto& Marker : Markers)
388 {
389 const auto Row = ui.TWEmitterList->rowCount();
390 ui.TWEmitterList->insertRow(Row);
391
392 QTableWidgetItem* IDItem = new QTableWidgetItem;
393 WidefieldMicroscopeData::LocalizedEmitterStateType LocalizedEmitterState = WidefieldMicroscopeData::LocalizedEmitterStateType::NotSet;
394 if (Marker.GetID() >= 0)
395 {
396 IDItem->setData(Qt::EditRole, Marker.GetID());
397 IDItem->setData(Qt::UserRole, Marker.GetID());
398
399 auto OldLocalizedPosition = LocalizedPositions.find(Marker.GetID());
400 if (OldLocalizedPosition != LocalizedPositions.cend())
401 LocalizedEmitterState = OldLocalizedPosition->second.State;
402 ModuleData->AppendLocalizedPosition({ Marker.GetID(), { Marker.GetMarkerPos(), LocalizedEmitterState } });
403 }
404 else
405 {
406 IDItem->setData(Qt::UserRole, Util::MarkerGraphicsView::MarkerType::IDType(-1));
407 IDItem->setText("n/a");
408 }
409
410 ui.TWEmitterList->setItem(Row, EmitterListColumnType::EmitterID, IDItem);
411 ui.TWEmitterList->setItem(Row, EmitterListColumnType::EmitterName, new QTableWidgetItem(Marker.GetName().data()));
412 ui.TWEmitterList->setItem(Row, EmitterListColumnType::Image_x, new QTableWidgetItem(QString::number(Marker.GetMarkerPos().x())));
413 ui.TWEmitterList->item(Row, EmitterListColumnType::Image_x)->setData(Qt::ItemDataRole::UserRole, Marker.GetMarkerPos().x());
414 ui.TWEmitterList->setItem(Row, EmitterListColumnType::Image_y, new QTableWidgetItem(QString::number(Marker.GetMarkerPos().y())));
415 ui.TWEmitterList->item(Row, EmitterListColumnType::Image_y)->setData(Qt::ItemDataRole::UserRole, Marker.GetMarkerPos().y());
416 ui.TWEmitterList->setItem(Row, EmitterListColumnType::Sample_x, new QTableWidgetItem(Marker.GetImagePos().isNull() ? "n/a" : QString::number(Marker.GetImagePos().x(), 'f', 0)));
417 ui.TWEmitterList->item(Row, EmitterListColumnType::Sample_x)->setData(Qt::ItemDataRole::UserRole, Marker.GetImagePos().x());
418 ui.TWEmitterList->setItem(Row, EmitterListColumnType::Sample_y, new QTableWidgetItem(Marker.GetImagePos().isNull() ? "n/a" : QString::number(Marker.GetImagePos().y(), 'f', 0)));
419 ui.TWEmitterList->item(Row, EmitterListColumnType::Sample_y)->setData(Qt::ItemDataRole::UserRole, Marker.GetImagePos().y());
420 ui.TWEmitterList->setItem(Row, EmitterListColumnType::EmitterState, new QTableWidgetItem(WidefieldMicroscopeData::GetLocalizedEmitterStateString(LocalizedEmitterState)));
421 ui.TWEmitterList->item(Row, EmitterListColumnType::EmitterState)->setForeground(WidefieldMicroscopeData::GetLocalizedEmitterColor(LocalizedEmitterState));
422 }
423
424 ui.TWEmitterList->setSortingEnabled(SortingEnabled);
425
426 ModuleData->ResetLocalizedPositionsChanged();
427 ModuleData->ResetAutoMeasureCurrentEmitter();
428 }
429
430 if (ModuleData->HaveLocalizedPositionsStateChanged())
431 {
432 for (int i = 0; i < ui.TWEmitterList->rowCount(); ++i)
433 {
434 auto ID = ui.TWEmitterList->item(i, EmitterListColumnType::EmitterID)->data(Qt::ItemDataRole::UserRole).value<Util::MarkerGraphicsView::MarkerType::IDType>();
435 auto Emitter = ModuleData->GetLocalizedPositions().find(ID);
436 if (Emitter == ModuleData->GetLocalizedPositions().cend())
437 continue;
438
439 ui.TWEmitterList->item(i, EmitterListColumnType::EmitterState)->setText(WidefieldMicroscopeData::GetLocalizedEmitterStateString(Emitter->second.State));
440 ui.TWEmitterList->item(i, EmitterListColumnType::EmitterState)->setForeground(WidefieldMicroscopeData::GetLocalizedEmitterColor(Emitter->second.State));
441 }
442
443 ModuleData->ClearLocalizedPositionsStateChanged();
444 }
445
446 switch (EmitterListTask)
447 {
448 case EmitterListTaskType::GoToSamplePos:
449 ModuleData->EnqueueEvent(DynExp::MakeEvent(&GetCastOwner(), &WidefieldMicroscope::OnGoToSamplePos, SamplePos));
450 EmitterListTask = EmitterListTaskType::None;
451 break;
452 case EmitterListTaskType::MarkerToConfocalSpot:
453 ModuleData->EnqueueEvent(DynExp::MakeEvent(&GetCastOwner(), &WidefieldMicroscope::OnBringMarkerToConfocalSpot, MarkerPos, SamplePos));
454 EmitterListTask = EmitterListTaskType::None;
455 break;
456 case EmitterListTaskType::RunCharacterization:
457 ModuleData->EnqueueEvent(DynExp::MakeEvent(&GetCastOwner(), &WidefieldMicroscope::OnRunCharacterizationFromID, MarkerID));
458 EmitterListTask = EmitterListTaskType::None;
459 break;
460 default: break;
461 }
462 }
463
464 void WidefieldMicroscopeWidget::UpdateConfocalUIData(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
465 {
466 if (!ui.SBConfocalWidth->hasFocus())
467 ui.SBConfocalWidth->setValue(ModuleData->GetConfocalScanWidth());
468 if (!ui.SBConfocalHeight->hasFocus())
469 ui.SBConfocalHeight->setValue(ModuleData->GetConfocalScanHeight());
470 if (!ui.SBConfocalDistPerPixel->hasFocus())
471 ui.SBConfocalDistPerPixel->setValue(ModuleData->GetConfocalScanDistPerPixel());
472 if (!ui.SBConfocalOptimizationInitXYStepSize->hasFocus())
473 ui.SBConfocalOptimizationInitXYStepSize->setValue(ModuleData->GetConfocalOptimizationInitXYStepSize());
474 if (!ui.SBConfocalOptimizationInitZStepSize->hasFocus())
475 ui.SBConfocalOptimizationInitZStepSize->setValue(ModuleData->GetConfocalOptimizationInitZStepSize());
476 if (!ui.SBConfocalOptimizationTolerance->hasFocus())
477 ui.SBConfocalOptimizationTolerance->setValue(ModuleData->GetConfocalOptimizationTolerance());
478
479 if (ModuleData->HasConfocalScanSurfacePlotRows())
480 {
481 auto Rows = ModuleData->GetConfocalScanSurfacePlotRows();
482 NumItemsInArray = 0;
483 ConfocalSurfaceMinCounts = std::numeric_limits<decltype(ConfocalSurfaceMinCounts)>::max();
484 ConfocalSurfaceMaxCounts = 0;
485
486 // Deletes old array.
487 ConfocalSurfaceDataProxy->resetArray(nullptr);
488 // Ownership transferred to ConfocalSurfaceDataProxy below with resetArray().
489 ConfocalSurfaceDataArray = new QSurfaceDataArray;
490 ConfocalSurfaceDataArray->reserve(Util::NumToT<int>(Rows.size()));
491
492 for (auto& Row : Rows)
493 *ConfocalSurfaceDataArray << Row.release();
494
495 ConfocalSurfaceDataProxy->resetArray(ConfocalSurfaceDataArray);
496 }
497
498 if (ModuleData->GetConfocalScanResults().size() > NumItemsInArray)
499 {
500 for (auto i = NumItemsInArray; i < ModuleData->GetConfocalScanResults().size(); ++i)
501 {
502 const auto& ResultItem = ModuleData->GetConfocalScanResults()[i];
503 if (ResultItem.first.RowIndex < 0 || ResultItem.first.ColumnIndex < 0)
504 continue;
505
506 auto& SurfaceItem = ConfocalSurfaceDataArray->operator[](ResultItem.first.RowIndex)->operator[](ResultItem.first.ColumnIndex);
507
508 SurfaceItem.setY(ResultItem.second);
509 ConfocalSurfaceDataProxy->setItem(ResultItem.first.RowIndex, ResultItem.first.ColumnIndex, SurfaceItem);
510
511 ConfocalSurfaceMinCounts = std::min(ConfocalSurfaceMinCounts, ResultItem.second);
512 ConfocalSurfaceMaxCounts = std::max(ConfocalSurfaceMaxCounts, ResultItem.second);
513
514 ++NumItemsInArray;
515 }
516
517 if (ConfocalSurfaceMinCounts < std::numeric_limits<decltype(ConfocalSurfaceMinCounts)>::max() && ConfocalSurfaceMaxCounts > 0)
518 ConfocalGraph->axisY()->setRange(ConfocalSurfaceMinCounts, ConfocalSurfaceMaxCounts);
519 }
520 }
521
522 void WidefieldMicroscopeWidget::UpdateHBTUIData(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData)
523 {
524 if (!ui.SBHBTBinWidth->hasFocus())
525 ui.SBHBTBinWidth->setValue(ModuleData->GetHBTBinWidth().count());
526 if (!ui.SBHBTBinCount->hasFocus())
527 ui.SBHBTBinCount->setValue(Util::NumToT<int>(ModuleData->GetHBTBinCount()));
528 if (!ui.SBHBTAcquisitionTime->hasFocus())
529 ui.SBHBTAcquisitionTime->setValue(static_cast<double>(ModuleData->GetHBTMaxIntegrationTime().count()) / std::chrono::microseconds::period::den);
530 ui.LEHBTTotalIntegrationTime->setText(QString::number(ModuleData->GetHBTTotalIntegrationTime().count() / std::chrono::microseconds::period::den) + " s");
531
532 if (ui.HBTChart->isVisible())
533 {
534 HBTDataChart->removeAllSeries();
535 HBTDataSeries = new QLineSeries(this);
536 HBTDataSeries->append(ModuleData->GetHBTDataPoints());
537 HBTDataSeries->setPointsVisible(false);
538
539 HBTXAxis->setRange(ModuleData->GetHBTDataPointsMinValues().x(), ModuleData->GetHBTDataPointsMaxValues().x());
540 HBTYAxis->setRange(ModuleData->GetHBTDataPointsMinValues().y(), ModuleData->GetHBTDataPointsMaxValues().y());
541 ui.LEHBTMinValue->setText(QString::number(ModuleData->GetHBTDataPointsMinValues().y()));
542
543 HBTDataChart->addSeries(HBTDataSeries);
544 HBTDataSeries->attachAxis(HBTDataChart->axes()[0]);
545 HBTDataSeries->attachAxis(HBTDataChart->axes()[1]);
546 }
547 }
548
549 void WidefieldMicroscopeWidget::UpdateAutoMeasureUIData(Util::SynchronizedPointer<WidefieldMicroscopeData>& ModuleData, bool IsCharacterizingSample)
550 {
551 {
552 const QSignalBlocker Blocker(ui.LEAutoMeasureSavePath);
553 ui.LEAutoMeasureSavePath->setText(QString::fromUtf16(ModuleData->GetAutoMeasureSavePath().u16string().c_str()));
554 } // Blocker unlocked here.
555
556 if (!ui.SBAutoMeasureNumberImageSets->hasFocus())
557 ui.SBAutoMeasureNumberImageSets->setValue(ModuleData->GetAutoMeasureNumberImageSets());
558 if (!ui.SBAutoMeasureInitialImageSetWaitTime->hasFocus())
559 ui.SBAutoMeasureInitialImageSetWaitTime->setValue(ModuleData->GetAutoMeasureInitialImageSetWaitTime().count());
560 if (!ui.SBAutoMeasureImagePositionScatterRadius->hasFocus())
561 ui.SBAutoMeasureImagePositionScatterRadius->setValue(ModuleData->GetAutoMeasureImagePositionScatterRadius());
562 if (!ui.CBAutoMeasureLocalize->hasFocus())
563 ui.CBAutoMeasureLocalize->setCurrentIndex(ModuleData->GetAutoMeasureLocalizationType());
564 if (!ui.CBAutoMeasureOptimize->hasFocus())
565 ui.CBAutoMeasureOptimize->setChecked(ModuleData->GetAutoMeasureOptimizeEnabled());
566 if (!ui.CBAutoMeasureEnableSpectrum->hasFocus())
567 ui.CBAutoMeasureEnableSpectrum->setChecked(ModuleData->GetAutoMeasureSpectrumEnabled());
568 if (!ui.CBAutoMeasureEnableHBT->hasFocus())
569 ui.CBAutoMeasureEnableHBT->setChecked(ModuleData->GetAutoMeasureHBTEnabled());
570 if (!ui.SBAutoMeasureOptimizationAttempts->hasFocus())
571 ui.SBAutoMeasureOptimizationAttempts->setValue(ModuleData->GetAutoMeasureNumOptimizationAttempts());
572 if (!ui.SBAutoMeasureOptimizationReruns->hasFocus())
573 ui.SBAutoMeasureOptimizationReruns->setValue(ModuleData->GetAutoMeasureMaxOptimizationReruns());
574 if (!ui.SBAutoMeasureOptimizationMaxDistance->hasFocus())
575 ui.SBAutoMeasureOptimizationMaxDistance->setValue(ModuleData->GetAutoMeasureOptimizationMaxDistance());
576 if (!ui.SBAutoMeasureCountRateThreshold->hasFocus())
577 ui.SBAutoMeasureCountRateThreshold->setValue(ModuleData->GetAutoMeasureCountRateThreshold());
578 if (!ui.SBAutoMeasureCellRangeFromX->hasFocus())
579 ui.SBAutoMeasureCellRangeFromX->setValue(ModuleData->GetAutoMeasureCellRangeFrom().x());
580 if (!ui.SBAutoMeasureCellRangeFromY->hasFocus())
581 ui.SBAutoMeasureCellRangeFromY->setValue(ModuleData->GetAutoMeasureCellRangeFrom().y());
582 if (!ui.SBAutoMeasureCellRangeToX->hasFocus())
583 ui.SBAutoMeasureCellRangeToX->setValue(ModuleData->GetAutoMeasureCellRangeTo().x());
584 if (!ui.SBAutoMeasureCellRangeToY->hasFocus())
585 ui.SBAutoMeasureCellRangeToY->setValue(ModuleData->GetAutoMeasureCellRangeTo().y());
586 if (!ui.SBAutoMeasureCellSkipX->hasFocus())
587 ui.SBAutoMeasureCellSkipX->setValue(ModuleData->GetAutoMeasureCellSkip().x());
588 if (!ui.SBAutoMeasureCellSkipY->hasFocus())
589 ui.SBAutoMeasureCellSkipY->setValue(ModuleData->GetAutoMeasureCellSkip().y());
590
591 if (ModuleData->GetAutoMeasureCurrentImageSet() >= 0 && ModuleData->GetAutoMeasureCurrentImageSet() < ModuleData->GetAutoMeasureNumberImageSets())
592 {
593 ui.LAutoMeasureCellProgress->setText("Recording image set " + QString::number(ModuleData->GetAutoMeasureCurrentImageSet() + 1) +
594 " / " + QString::number(ModuleData->GetAutoMeasureNumberImageSets()));
595 ui.PBAutoMeasureCellProgress->setValue(static_cast<int>(100.0 * ModuleData->GetAutoMeasureCurrentImageSet() / ModuleData->GetAutoMeasureNumberImageSets()));
596 ui.PBAutoMeasureCellProgress->setVisible(true);
597 }
598 else if (ModuleData->IsAutoMeasureRunning())
599 {
600 const auto EmitterCount = std::distance(ModuleData->GetAutoMeasureFirstEmitter(), ModuleData->GetLocalizedPositions().end());
601 const auto CurrentEmitter = EmitterCount - std::distance(ModuleData->GetAutoMeasureCurrentEmitter(), ModuleData->GetLocalizedPositions().end());
602
603 ui.LAutoMeasureCellProgress->setText("Emitter " + QString::number(CurrentEmitter + 1) +
604 " / " + QString::number(EmitterCount) + ", " +
605 QString::number(ModuleData->GetNumFinishedLocalizedPositions()) + " successful, " +
606 QString::number(ModuleData->GetNumFailedLocalizedPositions()) + " failed");
607 ui.PBAutoMeasureCellProgress->setValue(static_cast<int>(100.0 * CurrentEmitter / EmitterCount));
608 ui.PBAutoMeasureCellProgress->setVisible(true);
609 }
610 else
611 {
612 ui.LAutoMeasureCellProgress->setText("Ready");
613 ui.PBAutoMeasureCellProgress->setVisible(false);
614 }
615
616 ui.GBAutoMeasureSampleProgress->setVisible(IsCharacterizingSample && ModuleData->HasCellID());
617 if (IsCharacterizingSample && ModuleData->HasCellID())
618 {
619 const auto CurrentCell = ModuleData->GetAutoMeasureCurrentCellIndex();
620 const auto CellCount = ModuleData->GetAutoMeasureCellCount();
621
622 ui.LAutoMeasureSampleProgress->setText("Cell " + QString::number(CurrentCell + 1) +
623 " / " + QString::number(CellCount));
624 ui.PBAutoMeasureSampleProgress->setValue(static_cast<int>(100.0 * CurrentCell / CellCount));
625 }
626 }
627
628 void WidefieldMicroscopeWidget::SetMainGraphicsImage(const QImage& Image) noexcept
629 {
630 MainGraphicsPixmap = QPixmap::fromImage(Image); // deep copy
631 MainGraphicsPixmap.detach(); // just to be sure...
632 }
633
634 void WidefieldMicroscopeWidget::UpdateScene()
635 {
636 if (MainGraphicsView->isVisible() && !MainGraphicsView->visibleRegion().isEmpty())
637 {
638 MainGraphicsPixmapItem->setPixmap(MainGraphicsPixmap);
639 MainGraphicsScene->update();
640
641 OnZoomFitClicked(ui.action_Zoom_fit->isChecked());
642 }
643
644 StatusBar.Update();
645 }
646
647 bool WidefieldMicroscopeWidget::eventFilter(QObject* obj, QEvent* event)
648 {
649 if (MainGraphicsView->viewport())
650 if (event->type() == QEvent::MouseMove)
651 {
652 OnImageMouseMove(static_cast<QMouseEvent*>(event));
653
654 return true;
655 }
656
657 return QObject::eventFilter(obj, event);
658 }
659
660 void WidefieldMicroscopeWidget::resizeEvent(QResizeEvent* event)
661 {
662 OnZoomFitClicked(ui.action_Zoom_fit->isChecked());
663 }
664
665 bool WidefieldMicroscopeWidget::StoreTWEmitterListSelection()
666 {
667 if (ui.TWEmitterList->selectedItems().empty())
668 return false;
669
670 const auto Row = ui.TWEmitterList->selectedItems()[0]->row();
671
672 MarkerPos = { ui.TWEmitterList->item(Row, EmitterListColumnType::Image_x)->data(Qt::ItemDataRole::UserRole).toInt(),
673 ui.TWEmitterList->item(Row, EmitterListColumnType::Image_y)->data(Qt::ItemDataRole::UserRole).toInt() };
674 SamplePos = { ui.TWEmitterList->item(Row, EmitterListColumnType::Sample_x)->data(Qt::ItemDataRole::UserRole).toReal(),
675 ui.TWEmitterList->item(Row, EmitterListColumnType::Sample_y)->data(Qt::ItemDataRole::UserRole).toReal() };
676 MarkerID = ui.TWEmitterList->item(Row, EmitterListColumnType::EmitterID)->data(Qt::ItemDataRole::UserRole).value<decltype(MarkerID)>();
677
678 return true;
679 }
680
681 void WidefieldMicroscopeWidget::OnSaveImageClicked()
682 {
683 auto Filename = Util::PromptSaveFilePathModule(this, "Save image", ".png", "Portable Network Graphics image (*.png)");
684 if (Filename.isEmpty())
685 return;
686
687 SaveWidefieldImageFilename = Filename;
688 }
689
690 void WidefieldMicroscopeWidget::OnZoomResetClicked()
691 {
692 ui.action_Zoom_fit->setChecked(false);
693 MainGraphicsView->ZoomReset();
694 }
695
696 void WidefieldMicroscopeWidget::OnZoomInClicked()
697 {
698 ui.action_Zoom_fit->setChecked(false);
699 MainGraphicsView->ZoomIn();
700 }
701
702 void WidefieldMicroscopeWidget::OnZoomOutClicked()
703 {
704 ui.action_Zoom_fit->setChecked(false);
705 MainGraphicsView->ZoomOut();
706 }
707
708 void WidefieldMicroscopeWidget::OnZoomFitClicked(bool Checked)
709 {
710 if (Checked)
711 MainGraphicsView->fitInView(MainGraphicsPixmapItem, Qt::AspectRatioMode::KeepAspectRatio);
712 }
713
714 void WidefieldMicroscopeWidget::OnImageMouseMove(QMouseEvent* Event)
715 {
716 auto LocalPoint = MainGraphicsView->mapFromGlobal(Event->globalPos());
717
718 if (!MainGraphicsView->items(LocalPoint).empty())
719 {
720 auto Point = MainGraphicsView->mapToScene(LocalPoint).toPoint();
721
722 StatusBar.XCoordLabel->setText("X:" + QString::number(Point.x()));
723 StatusBar.YCoordLabel->setText("Y:" + QString::number(Point.y()));
724 }
725 }
726
727 void WidefieldMicroscopeWidget::OnCellIDContextMenuRequested(const QPoint& Position)
728 {
729 StatusBar.CellIDContextMenu->exec(StatusBar.CellIDLabel->mapToGlobal(Position));
730 }
731
739
745
746 void WidefieldMicroscopeWidget::OnEmitterListContextMenuRequested(const QPoint& Position)
747 {
748 EmitterListContextMenu->exec(ui.TWEmitterList->mapToGlobal(Position));
749 }
750
751 void WidefieldMicroscopeWidget::OnEmitterListDeleteEntryClicked()
752 {
753 for (int i = 0; i < ui.TWEmitterList->selectedItems().size(); ++i)
754 {
755 const auto Row = ui.TWEmitterList->selectedItems()[i]->row();
756 const QPoint Pos = { ui.TWEmitterList->item(Row, EmitterListColumnType::Image_x)->data(Qt::ItemDataRole::UserRole).toInt(),
757 ui.TWEmitterList->item(Row, EmitterListColumnType::Image_y)->data(Qt::ItemDataRole::UserRole).toInt() };
758
759 MainGraphicsView->RemoveMarker(Pos, true);
760 }
761 }
762
763 void WidefieldMicroscopeWidget::OnEmitterListEditEntryClicked()
764 {
765 if (ui.TWEmitterList->selectedItems().empty() || !StoreTWEmitterListSelection())
766 return;
767
768 const auto Row = ui.TWEmitterList->selectedItems()[0]->row();
769 const auto OldName = ui.TWEmitterList->item(Row, EmitterListColumnType::EmitterName)->text();
770
771 bool OKClicked = false;
772 QString NewName = QInputDialog::getText(this, "Edit name",
773 QString("Enter new name for marker \"") + OldName + "\":", QLineEdit::Normal, OldName, &OKClicked);
774
775 if (OKClicked)
776 MainGraphicsView->RenameMarker(MarkerPos, NewName.toStdString());
777 }
778
784
790
796
797 void WidefieldMicroscopeWidget::OnConfocalMapResetClicked()
798 {
799 ConfocalGraph->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPreset::CameraPresetDirectlyAbove);
800 }
801
802 void WidefieldMicroscopeWidget::OnConfocalMapSaveRawDataClicked()
803 {
804 if (!ConfocalSurfaceDataArray)
805 return;
806
807 auto Filename = Util::PromptSaveFilePathModule(this, "Save data", ".csv", " Comma-separated values file (*.csv)");
808 if (Filename.isEmpty())
809 return;
810
811 std::stringstream CSVData;
812 {
813 auto ModuleData = DynExp::dynamic_ModuleData_cast<WidefieldMicroscope>(GetOwner().GetModuleData());
814
815 CSVData = ModuleData->AssembleCSVHeader(true, false, false);
816 ModuleData->WriteConfocalScanResults(CSVData);
817 } // ModuleData unlocked here.
818
819 if (!Util::SaveToFile(Filename, CSVData.str()))
820 QMessageBox::warning(this, "DynExp - Error", "Error writing data to file.");
821 }
822
823 void WidefieldMicroscopeWidget::OnHBTSaveRawDataClicked()
824 {
825 auto Filename = Util::PromptSaveFilePathModule(this, "Save data", ".csv", " Comma-separated values file (*.csv)");
826 if (Filename.isEmpty())
827 return;
828
829 std::stringstream CSVData;
830 {
831 auto ModuleData = DynExp::dynamic_ModuleData_cast<WidefieldMicroscope>(GetOwner().GetModuleData());
832
833 CSVData = ModuleData->AssembleCSVHeader(false, true, false);
834 ModuleData->WriteHBTResults(CSVData);
835 } // ModuleData unlocked here.
836
837 if (!Util::SaveToFile(Filename, CSVData.str()))
838 QMessageBox::warning(this, "DynExp - Error", "Error writing data to file.");
839 }
840
841 void WidefieldMicroscopeWidget::OnAutoMeasureSavePathBrowseClicked()
842 {
843 auto Filename = Util::PromptSaveFilePathModule(this, "Select directory and filename prefix for saving data in auto-measure mode",
844 ".csv", " Comma-separated values file (*.csv)");
845 if (Filename.isEmpty())
846 return;
847
848 // Emits signal to update module data accordingly.
849 ui.LEAutoMeasureSavePath->setText(Filename);
850 }
851}
WidefieldMicroscopeWidget.h
User interface belonging to the DynExpModule::Widefield::WidefieldMicroscope module.
WidefieldMicroscope.h
Implementation of a module to control a combined widefield and confocal microscope.
DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedEmitterColor
static QColor GetLocalizedEmitterColor(LocalizedEmitterStateType State)
Definition WidefieldMicroscope.cpp:76
DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedEmitterStateString
static const char * GetLocalizedEmitterStateString(LocalizedEmitterStateType State)
Definition WidefieldMicroscope.cpp:65
DynExpModule::Widefield::WidefieldMicroscopeWidget::eventFilter
bool eventFilter(QObject *obj, QEvent *event) override
Definition WidefieldMicroscopeWidget.cpp:647
DynExpModule::Widefield::WidefieldMicroscopeWidget::UpdateHBTUIData
void UpdateHBTUIData(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:522
DynExpModule::Widefield::WidefieldMicroscopeWidget::WidefieldMicroscopeWidget
WidefieldMicroscopeWidget(WidefieldMicroscope &Owner, QModuleWidget *parent=nullptr)
Definition WidefieldMicroscopeWidget.cpp:41
DynExpModule::Widefield::WidefieldMicroscopeWidget::MarkerID
Util::MarkerGraphicsView::MarkerType::IDType MarkerID
Definition WidefieldMicroscopeWidget.h:189
DynExpModule::Widefield::WidefieldMicroscopeWidget::UpdateConfocalUIData
void UpdateConfocalUIData(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:464
DynExpModule::Widefield::WidefieldMicroscopeWidget::SetUIState
void SetUIState(const StateMachineStateType *State, const Util::StateMachineContext< StateMachineStateType > *Context, Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:226
DynExpModule::Widefield::WidefieldMicroscopeWidget::UpdateUIData
void UpdateUIData(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:304
DynExpModule::Widefield::WidefieldMicroscopeWidget::StoreTWEmitterListSelection
bool StoreTWEmitterListSelection()
Stores the values of the respective cells of ui.TWEmitterList's currently selected row in MarkerPos a...
Definition WidefieldMicroscopeWidget.cpp:665
DynExpModule::Widefield::WidefieldMicroscopeWidget::resizeEvent
virtual void resizeEvent(QResizeEvent *event) override
Definition WidefieldMicroscopeWidget.cpp:660
DynExpModule::Widefield::WidefieldMicroscopeWidget::InitializeUI
void InitializeUI(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:168
DynExpModule::Widefield::WidefieldMicroscopeWidget::UpdateAutoMeasureUIData
void UpdateAutoMeasureUIData(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData, bool IsCharacterizingSample)
Definition WidefieldMicroscopeWidget.cpp:549
DynExpModule::Widefield::WidefieldMicroscopeWidget::UpdateWidefieldUIData
void UpdateWidefieldUIData(Util::SynchronizedPointer< WidefieldMicroscopeData > &ModuleData)
Definition WidefieldMicroscopeWidget.cpp:335
DynExpModule::Widefield::WidefieldMicroscopeWidget::GetCastOwner
const WidefieldMicroscope & GetCastOwner() const noexcept
Definition WidefieldMicroscopeWidget.cpp:163
DynExpModule::Widefield::WidefieldMicroscope::OnRunCharacterizationFromID
void OnRunCharacterizationFromID(DynExp::ModuleInstance *Instance, Util::MarkerGraphicsView::MarkerType::IDType ID) const
Definition WidefieldMicroscope.cpp:635
DynExpModule::Widefield::WidefieldMicroscope::OnGoToSamplePos
void OnGoToSamplePos(DynExp::ModuleInstance *Instance, QPointF SamplePos) const
Definition WidefieldMicroscope.cpp:611
DynExpModule::Widefield::WidefieldMicroscope::OnSaveCurrentImage
void OnSaveCurrentImage(DynExp::ModuleInstance *Instance, QString Filename) const
Definition WidefieldMicroscope.cpp:589
DynExpModule::Widefield::WidefieldMicroscope::OnBringMarkerToConfocalSpot
void OnBringMarkerToConfocalSpot(DynExp::ModuleInstance *Instance, QPoint MarkerPos, QPointF SamplePos) const
Definition WidefieldMicroscope.cpp:624
DynExp::QModuleWidget::Owner
QModuleBase & Owner
Module owning this user interface window (reference, because it should never change nor be nullptr).
Definition Module.h:1162
DynExp::QModuleWidget::QModuleWidget
QModuleWidget(QModuleBase &Owner, QWidget *Parent=nullptr)
Constructs a QModuleWidget instance.
Definition Module.cpp:417
DynExp::QModuleWidget::GetOwner
const auto & GetOwner() const noexcept
Getter for the owning module.
Definition Module.h:1111
Util::MarkerGraphicsView
Implements a QGraphicsView the user can interact with to insert graphical markers....
Definition QtUtil.h:379
Util::MarkerGraphicsView::ZoomReset
void ZoomReset()
Resets the zoom.
Definition QtUtil.cpp:522
Util::MarkerGraphicsView::DeselectMarkers
void DeselectMarkers()
Deselects all selected markers.
Definition QtUtil.cpp:506
Util::MarkerGraphicsView::EnableActions
void EnableActions(bool Enable)
Definition QtUtil.cpp:527
Util::MarkerGraphicsView::GetMarkers
const std::vector< MarkerType > & GetMarkers() const noexcept
Definition QtUtil.h:448
Util::MarkerGraphicsView::contextMenu
auto contextMenu() const noexcept
Definition QtUtil.h:446
Util::MarkerGraphicsView::RenameMarker
void RenameMarker(const QPoint &MarkerPos, std::string_view NewName)
Assigns a name to the marker at position MarkerPos. Affects MarkersChanged.
Definition QtUtil.cpp:489
Util::MarkerGraphicsView::SelectMarker
void SelectMarker(const QPoint &MarkerPos)
Selects the marker at position MarkerPos.
Definition QtUtil.cpp:500
Util::MarkerGraphicsView::HaveMarkersChanged
bool HaveMarkersChanged() noexcept
Returns whether a marker operation has changed the stored markers. Resets the flag.
Definition QtUtil.cpp:390
Util::MarkerGraphicsView::RemoveMarker
void RemoveMarker(size_t Index, bool OnlyUserDeletableMarkers=false)
Removes the n-th marker specified by Index. Affects MarkersChanged.
Definition QtUtil.cpp:413
Util::MarkerGraphicsView::AddMarker
void AddMarker(const QPoint &MarkerPos, const QColor &Color, bool IsUserDeletable=true, MarkerType::IDType ID=-1, std::string Name={})
Adds a marker to the graphics view at position MarkerPos assigning the properties passed as arguments...
Definition QtUtil.cpp:398
Util::MarkerGraphicsView::ZoomIn
void ZoomIn()
Zooms in one step.
Definition QtUtil.cpp:512
Util::MarkerGraphicsView::ZoomOut
void ZoomOut()
Zooms out one step.
Definition QtUtil.cpp:517
Util::MarkerGraphicsView::SetCurrentImagePos
void SetCurrentImagePos(const QPointF &Pos)
Definition QtUtil.h:455
Util::MarkerGraphicsView::RemoveMarkers
void RemoveMarkers(bool OnlyUserDeletableMarkers)
Removes all markers from the graphics view. Affects MarkersChanged.
Definition QtUtil.cpp:464
Util::StateMachineContext
State machine context as used by class StateMachine. A state machine context holds a map with keys an...
Definition Util.h:1362
Util::StateMachineState
State machine state as used by class StateMachine. A state mainly wraps a state function of the membe...
Definition Util.h:1305
Util::StateMachineState::GetState
constexpr StateEnumType GetState() const noexcept
Returns the state's unique identifier.
Definition Util.h:1321
Util::SynchronizedPointer
Pointer to lock a class derived from ISynchronizedPointerLockable for synchronizing between threads....
Definition Util.h:170
DynExpUI::DefaultQChartTheme
constexpr auto DefaultQChartTheme
Definition DynExpDefinitions.h.in:113
DynExpUI::StatusBarRunningStyleSheet
constexpr auto StatusBarRunningStyleSheet
Definition DynExpDefinitions.h.in:119
DynExpUI::DefaultQ3DTheme
constexpr auto DefaultQ3DTheme
Definition DynExpDefinitions.h.in:114
DynExpUI::GetDefaultLinearGradient
QLinearGradient GetDefaultLinearGradient()
Definition DynExpDefinitions.cpp:33
DynExpUI::StatusBarBusyStyleSheet
constexpr auto StatusBarBusyStyleSheet
Definition DynExpDefinitions.h.in:122
DynExp::MakeEvent
auto MakeEvent(ReceiverType *Receiver, typename DefaultEvent< ReceiverType, std::tuple< std::remove_reference_t< ArgsTs >... > >::EventFuncPtrType EventFuncPtr, ArgsTs &&...Args)
Creates an event of type DefaultEvent.
Definition Module.h:763
Util::ToStr
std::string ToStr(const T &Value, int Precision=-1)
Converts a (numeric) value of type T to a std::string using operator<< of std::stringstream.
Definition Util.h:625
Util::SaveToFile
bool SaveToFile(const QString &Filename, std::string_view Text)
Saves a std::string_view to a file (using QFile). Creates a new file or truncates an existing file's ...
Definition QtUtil.cpp:236
Util::PromptSaveFilePathModule
QString PromptSaveFilePathModule(DynExp::QModuleWidget *Parent, const QString &Title, const QString &DefaultSuffix, const QString &NameFilter)
Works as PromptOpenFilePath() but asks the user to select a single file which does not need to exist....
Definition QtUtil.cpp:143
stdafx.h
Accumulates include statements to provide a precompiled header.
DynExpModule::Widefield::WidefieldMicroscopeWidget::StatusBarType::CurrentContext
const Util::StateMachineContext< StateMachineStateType > * CurrentContext
Definition WidefieldMicroscopeWidget.h:101