DynExp
Highly flexible laboratory automation for dynamically changing experiments.
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 
8 namespace 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 
732  void WidefieldMicroscopeWidget::OnEmitterListCellClicked(int Row, int Column)
733  {
734  if (!StoreTWEmitterListSelection())
735  MainGraphicsView->DeselectMarkers();
736  else
737  MainGraphicsView->SelectMarker(MarkerPos);
738  }
739 
740  void WidefieldMicroscopeWidget::OnEmitterListCellDoubleClicked(int Row, int Column)
741  {
742  if (StoreTWEmitterListSelection())
743  EmitterListTask = EmitterListTaskType::MarkerToConfocalSpot;
744  }
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 
779  void WidefieldMicroscopeWidget::OnEmitterListGoToSamplePositionClicked()
780  {
781  if (StoreTWEmitterListSelection())
782  EmitterListTask = EmitterListTaskType::GoToSamplePos;
783  }
784 
785  void WidefieldMicroscopeWidget::OnEmitterListBringMarkerToConfocalSpotClicked()
786  {
787  if (StoreTWEmitterListSelection())
788  EmitterListTask = EmitterListTaskType::MarkerToConfocalSpot;
789  }
790 
791  void WidefieldMicroscopeWidget::OnEmitterListRunCharacterizationFromID()
792  {
793  if (StoreTWEmitterListSelection())
794  EmitterListTask = EmitterListTaskType::RunCharacterization;
795  }
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::GetMarkers
const std::vector< MarkerType > & GetMarkers() const noexcept
Definition: QtUtil.h:448
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::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