dynexp/doc/WidefieldMicroscope_8h_source.html

 // This file is part of DynExp.


 #pragma once


 #include "stdafx.h"

 #include "DynExpCore.h"

 #include "../../MetaInstruments/Stage.h"

 #include "../../MetaInstruments/DigitalOut.h"

 #include "../../MetaInstruments/DigitalIn.h"

 #include "../../MetaInstruments/AnalogOut.h"

 #include "../../MetaInstruments/AnalogIn.h"

 #include "../../MetaInstruments/Camera.h"

 #include "../../MetaInstruments/TimeTagger.h"

 #include "../../Instruments/InterModuleCommunicator.h"

 #include "../../Instruments/WidefieldLocalization.h"

 #include "../../Modules/ImageViewer/ImageViewerEvents.h"

 #include "../../Modules/SpectrumViewer/SpectrumViewerEvents.h"


 #include "WidefieldMicroscopeWidget.h"


 namespace DynExpModule::Widefield

 {

     class WidefieldMicroscopeData : public DynExp::QModuleDataBase

     {

     public:

         enum class FeatureType { Widefield, WidefieldLocalization,

             SampleXYPositioning, SampleZPositioning, FocusAdjustment,

             Confocal, ConfocalOptimization, HBT,

             LEDLightToggle, PumpLightToggle, SetPumpPower, MeasurePumpPower,

             WidefieldConfocalSwitch, WidefieldConfocalIndicator, HBTSwitch,

             InterModuleCommunicator, NUM_ELEMENTS};

         enum class SetupModeType { Unknown, Widefield, Confocal };

         enum class LocalizedEmitterStateType { NotSet, Characterizing, Finished, Failed };


         struct LocalizedEmitterType

         {

             QPoint Position;

             LocalizedEmitterStateType State = LocalizedEmitterStateType::NotSet;

         };


         static const char* GetLocalizedEmitterStateString(LocalizedEmitterStateType State);

         static QColor GetLocalizedEmitterColor(LocalizedEmitterStateType State);


         using PositionType = DynExpInstr::PositionerStageData::PositionType;

         using CameraTimeType = DynExpInstr::CameraData::TimeType;

         using LocalizedPositionsMapType = std::map<Util::MarkerGraphicsView::MarkerType::IDType, LocalizedEmitterType>;

         using SPDTimeType = std::chrono::milliseconds;

         using QSurfaceDataRowsType = std::vector<std::unique_ptr<QSurfaceDataRow>>;


         struct PositionPoint

         {

             constexpr PositionPoint() noexcept

                 : x(0), y(0), z(0), MeasuredX(0), MeasuredY(0), MeasuredZ(0),

                 UsingX(false), UsingY(false), UsingZ(false), RowIndex(-1), ColumnIndex(-1) {}

             constexpr PositionPoint(PositionType x) noexcept

                 : x(x), y(0), z(0), MeasuredX(0), MeasuredY(0), MeasuredZ(0),

                 UsingX(true), UsingY(false), UsingZ(false), RowIndex(-1), ColumnIndex(-1) {}

             constexpr PositionPoint(PositionType x, PositionType y)

                 : x(x), y(y), z(0), MeasuredX(0), MeasuredY(0), MeasuredZ(0),

                 UsingX(true), UsingY(true), UsingZ(false), RowIndex(-1), ColumnIndex(-1) {}

             constexpr PositionPoint(PositionType x, PositionType y, PositionType z)

                 : x(x), y(y), z(z), MeasuredX(0), MeasuredY(0), MeasuredZ(0),

                 UsingX(true), UsingY(true), UsingZ(true), RowIndex(-1), ColumnIndex(-1) {}


             constexpr void Reset() noexcept;

             constexpr bool IsEmpty() const noexcept { return !UsingX && !UsingY && !UsingZ; }

             double DistTo(const PositionPoint& Other) const;


             std::string ToStr(std::string_view Prefix = "") const;


             PositionType x;

             PositionType y;

             PositionType z;


             PositionType MeasuredX;

             PositionType MeasuredY;

             PositionType MeasuredZ;


             bool UsingX;

             bool UsingY;

             bool UsingZ;


             int RowIndex;

             int ColumnIndex;

         };


         struct SPDStateType

         {

             constexpr SPDStateType(double Value = 0, bool Ready = false, size_t StreamSamplesWritten = 0) noexcept

                 : Value(Value), Ready(Ready), StreamSamplesWritten(StreamSamplesWritten) {}


             constexpr void Reset() noexcept

             {

                 Value = 0;

                 Ready = false;

                 StreamSamplesWritten = 0;

             }


             double Value;

             bool Ready;

             size_t StreamSamplesWritten;

         };


         WidefieldMicroscopeData() { Init(); }

         virtual ~WidefieldMicroscopeData() = default;


         auto& GetSampleStageX() noexcept { return SampleStageX; }

         auto& GetSampleStageX() const noexcept { return SampleStageX; }

         auto& GetSampleStageY() noexcept { return SampleStageY; }

         auto& GetSampleStageY() const noexcept { return SampleStageY; }

         auto& GetSampleStageZ() noexcept { return SampleStageZ; }

         auto& GetSampleStageZ() const noexcept { return SampleStageZ; }

         auto& GetSampleFocusPiezoZ() noexcept { return FocusPiezoZ; }

         auto& GetSampleFocusPiezoZ() const noexcept { return FocusPiezoZ; }

         auto& GetLEDSwitch() noexcept { return LEDSwitch; }

         auto& GetLEDSwitch() const noexcept { return LEDSwitch; }

         auto& GetPumpSwitch() noexcept { return PumpSwitch; }

         auto& GetPumpSwitch() const noexcept { return PumpSwitch; }

         auto& GetWidefieldConfocalSwitch() noexcept { return WidefieldConfocalSwitch; }

         auto& GetWidefieldConfocalSwitch() const noexcept { return WidefieldConfocalSwitch; }

         auto& GetWidefieldConfocalIndicator() noexcept { return WidefieldConfocalIndicator; }

         auto& GetWidefieldConfocalIndicator() const noexcept { return WidefieldConfocalIndicator; }

         auto& GetWidefieldHBTSwitch() noexcept { return WidefieldHBTSwitch; }

         auto& GetWidefieldHBTSwitch() const noexcept { return WidefieldHBTSwitch; }

         auto& GetPumpPower() noexcept { return PumpPower; }

         auto& GetPumpPower() const noexcept { return PumpPower; }

         auto& GetPumpPowerIndicator() noexcept { return PumpPowerIndicator; }

         auto& GetPumpPowerIndicator() const noexcept { return PumpPowerIndicator; }

         auto& GetWidefieldCamera() noexcept { return WidefieldCamera; }

         auto& GetWidefieldCamera() const noexcept { return WidefieldCamera; }

         auto& GetWidefieldLocalizer() noexcept { return WidefieldLocalizer; }

         auto& GetWidefieldLocalizer() const noexcept { return WidefieldLocalizer; }

         auto& GetSPD1() noexcept { return SPD1; }

         auto& GetSPD1() const noexcept { return SPD1; }

         auto& GetSPD2() noexcept { return SPD2; }

         auto& GetSPD2() const noexcept { return SPD2; }

         auto& GetAcqCommunicator() noexcept { return AcqCommunicator; }

         auto& GetAcqCommunicator() const noexcept { return AcqCommunicator; }


         template <size_t N>

         bool TestFeature(const std::array<FeatureType, N>& Flags) const { return Features.Test(Flags); }


         bool TestFeature(FeatureType Flag) const { return Features.Test(Flag); }

         void SetFeature(FeatureType Flag) { Features.Set(Flag); }


         std::string_view GetUIMessage() const noexcept { return UIMessage; }

         void SetUIMessage(const std::string& Message) { UIMessage = Message; }

         void ClearUIMessage() { UIMessage = ""; }


         PositionPoint GetSamplePosition() const;

         std::stringstream AssembleCSVHeader(bool IncludeConfocalScan, bool IncludeHBT, bool IncludeAutoMeasure) const;

         void WriteConfocalScanResults(std::stringstream& Stream) const;

         void WriteHBTResults(std::stringstream& Stream) const;


         SetupModeType GetSetupMode() const noexcept { return SetupMode; }

         void SetSetupMode(SetupModeType NewMode) noexcept { SetupMode = NewMode; }

         bool GetLEDLightTurnedOn() const noexcept { return LEDLightTurnedOn; }

         void SetLEDLightTurnedOn(bool State);

         bool GetPumpLightTurnedOn() const noexcept { return PumpLightTurnedOn; }

         void SetPumpLightTurnedOn(bool State);

         double GetMinPumpPower() const noexcept { return MinPumpPower; }

         void SetMinPumpPower(double MinPower) noexcept { MinPumpPower = MinPower; }

         double GetMaxPumpPower() const noexcept { return MaxPumpPower; }

         void SetMaxPumpPower(double MaxPower) noexcept { MaxPumpPower = MaxPower; }

         double GetWidefieldPumpPower() const noexcept { return WidefieldPumpPower; }

         void SetWidefieldPumpPower(double Power) noexcept { WidefieldPumpPower = Power; }

         double GetConfocalPumpPower() const noexcept { return ConfocalPumpPower; }

         void SetConfocalPumpPower(double Power) noexcept { ConfocalPumpPower = Power; }

         double GetMeasuredPumpPower() const noexcept { return MeasuredPumpPower; }

         void SetMeasuredPumpPower(double MeasuredPower) noexcept { MeasuredPumpPower = MeasuredPower; }

         double GetMinFocusVoltage() const noexcept { return MinFocusVoltage; }

         void SetMinFocusVoltage(double MinVoltage) noexcept { MinFocusVoltage = MinVoltage; }

         double GetMaxFocusVoltage() const noexcept { return MaxFocusVoltage; }

         void SetMaxFocusVoltage(double MaxVoltage) noexcept { MaxFocusVoltage = MaxVoltage; }

         double GetFocusCurrentVoltage() const noexcept { return FocusCurrentVoltage; }

         void SetFocusCurrentVoltage(double CurrentVoltage) noexcept { FocusCurrentVoltage = CurrentVoltage; }

         double GetFocusZeroVoltage() const noexcept { return FocusZeroVoltage; }

         void SetFocusZeroVoltage(double ZeroVoltage) noexcept { FocusZeroVoltage = ZeroVoltage; }

         double GetFocusConfocalOffsetVoltage() const noexcept { return FocusConfocalOffsetVoltage; }

         void SetFocusConfocalOffsetVoltage(double ConfocalOffsetVoltage) noexcept { FocusConfocalOffsetVoltage = ConfocalOffsetVoltage; }

         bool IsAutofocusFinished() const noexcept { return AutofocusFinished; }

         void SetAutofocusFinished() noexcept { AutofocusFinished = true; }

         void ResetAutofocusFinished() noexcept { AutofocusFinished = false; }


         CameraTimeType GetMinCameraExposureTime() const noexcept { return MinCameraExposureTime; }

         void SetMinCameraExposureTime(CameraTimeType Time) noexcept { MinCameraExposureTime = Time; }

         CameraTimeType GetMaxCameraExposureTime() const noexcept { return MaxCameraExposureTime; }

         void SetMaxCameraExposureTime(CameraTimeType Time) noexcept { MaxCameraExposureTime = Time; }

         CameraTimeType GetLEDCameraExposureTime() const noexcept { return LEDCameraExposureTime; }

         void SetLEDCameraExposureTime(CameraTimeType Time) noexcept { LEDCameraExposureTime = Time; }

         CameraTimeType GetWidefieldCameraExposureTime() const noexcept { return WidefieldCameraExposureTime; }

         void SetWidefieldCameraExposureTime(CameraTimeType Time) noexcept { WidefieldCameraExposureTime = Time; }

         QPoint GetConfocalSpotImagePosition() const noexcept { return ConfocalSpotImagePosition; }

         void SetConfocalSpotImagePosition(const QPoint& Position) noexcept { ConfocalSpotImagePosition = Position; }

         const PositionPoint& GetWidefieldPosition() const noexcept { return WidefieldPosition; }

         void SetWidefieldPosition(const PositionPoint& Position) noexcept { WidefieldPosition = Position; }


         const QImage& GetCurrentImage() const noexcept { return CurrentImage; }

         void SetCurrentImage(QImage&& Image) { CurrentImage = std::move(Image); CurrentImageChanged = true; }

         bool IsCurrentImageAvlbl() const { return !CurrentImage.isNull() && CurrentImageChanged; }

         void ResetCurrentImageAvlbl() noexcept { CurrentImageChanged = false; }

         const auto& GetCellID() const noexcept { return CurrentCellID; }

         const auto& GetLastCellID() const noexcept { return LastCellID; }

         void SetCellID(const DynExpInstr::WidefieldLocalizationCellIDType& CellID) { LastCellID = CurrentCellID; CurrentCellID = CellID; }

         void SetCellIDToLastCellID() { CurrentCellID = LastCellID; }

         void IncrementCellID();

         void ResetCellID() { CurrentCellID = {}; LastCellID = {}; }

         bool HasCellID() const noexcept { return CurrentCellID.Valid; }

         auto& GetLocalizedPositions() noexcept { return LocalizedPositions; }

         const auto& GetLocalizedPositions() const noexcept { return LocalizedPositions; }

         size_t GetNumFinishedLocalizedPositions() const;

         size_t GetNumFailedLocalizedPositions() const;

         void AppendLocalizedPosition(LocalizedPositionsMapType::value_type&& Position);

         void SetLocalizedPositions(LocalizedPositionsMapType&& Positions);

         void ClearLocalizedPositions();

         bool HaveLocalizedPositionsChanged() const noexcept { return LocalizedPositionsChanged; }

         void ResetLocalizedPositionsChanged() noexcept { LocalizedPositionsChanged = false; }

         void SetLocalizedPositionsStateChanged() { LocalizedPositionsStateChanged = true; }

         void ClearLocalizedPositionsStateChanged() { LocalizedPositionsStateChanged = false; }

         bool HaveLocalizedPositionsStateChanged() const noexcept { return LocalizedPositionsStateChanged; }


         const PositionPoint& GetSampleHomePosition() const noexcept { return SampleHomePosition; }

         void SetSampleHomePosition(const PositionPoint& Position) noexcept { SampleHomePosition = Position; }

         int GetConfocalScanWidth() const noexcept { return ConfocalScanWidth; }

         void SetConfocalScanWidth(int Width) noexcept { ConfocalScanWidth = Width; }

         int GetConfocalScanHeight() const noexcept { return ConfocalScanHeight; }

         void SetConfocalScanHeight(int Length) noexcept { ConfocalScanHeight = Length; }

         int GetConfocalScanDistPerPixel() const noexcept { return ConfocalScanDistPerPixel; }

         void SetConfocalScanDistPerPixel(int DistPerPixel) noexcept { ConfocalScanDistPerPixel = DistPerPixel; }

         SPDTimeType GetSPDExposureTime() const noexcept { return SPDExposureTime; }

         void SetSPDExposureTime(SPDTimeType Time) noexcept { SPDExposureTime = Time; }

         auto GetSPD1SamplesWritten() const noexcept { return SPD1State.StreamSamplesWritten; }

         bool GetSPD1Ready() const noexcept { return SPD1State.Ready; }

         auto GetSPD1Value() const noexcept { return SPD1State.Value; }

         void SetSPD1SamplesWritten(size_t SamplesWritten) noexcept { SPD1State.StreamSamplesWritten = SamplesWritten; }

         void SetSPD1Ready(double Value) noexcept { SPD1State.Value = Value; SPD1State.Ready = true; }

         void ResetSPD1State() noexcept { SPD1State.Reset(); }

         auto GetSPD2SamplesWritten() const noexcept { return SPD2State.StreamSamplesWritten; }

         bool GetSPD2Ready() const noexcept { return SPD2State.Ready; }

         auto GetSPD2Value() const noexcept { return SPD2State.Value; }

         void SetSPD2SamplesWritten(size_t SamplesWritten) noexcept { SPD2State.StreamSamplesWritten = SamplesWritten; }

         void SetSPD2Ready(double Value) noexcept { SPD2State.Value = Value; SPD2State.Ready = true; }

         void ResetSPD2State() noexcept { SPD2State.Reset(); }


         auto& GetConfocalScanResults() noexcept { return ConfocalScanResults; }

         const auto& GetConfocalScanResults() const noexcept { return ConfocalScanResults; }

         void ClearConfocalScanResults() { ConfocalScanResults.clear(); }

         auto GetConfocalScanSurfacePlotRows() noexcept { return std::move(ConfocalScanSurfacePlotRows); }

         void SetConfocalScanSurfacePlotRows(QSurfaceDataRowsType&& QSurfaceDataRows) noexcept { ConfocalScanSurfacePlotRows = std::move(QSurfaceDataRows); }

         bool HasConfocalScanSurfacePlotRows() const noexcept { return !ConfocalScanSurfacePlotRows.empty(); }

         void ClearConfocalScanSurfacePlotRows() { ConfocalScanSurfacePlotRows.clear(); }


         double GetConfocalOptimizationInitXYStepSize() const noexcept { return ConfocalOptimizationInitXYStepSize; }

         void SetConfocalOptimizationInitXYStepSize(double StepSize) noexcept { ConfocalOptimizationInitXYStepSize = StepSize; }

         double GetConfocalOptimizationInitZStepSize() const noexcept { return ConfocalOptimizationInitZStepSize; }

         void SetConfocalOptimizationInitZStepSize(double StepSize) noexcept { ConfocalOptimizationInitZStepSize = StepSize; }

         double GetConfocalOptimizationTolerance() const noexcept { return ConfocalOptimizationTolerance; }

         void SetConfocalOptimizationTolerance(double Tolerance) noexcept { ConfocalOptimizationTolerance = Tolerance; }

         double GetLastCountRate() const noexcept { return LastCountRate; }

         void SetLastCountRate(double CountRate) noexcept { LastCountRate = CountRate; }


         auto GetHBTBinWidth() const noexcept { return HBTBinWidth; }

         void SetHBTBinWidth(Util::picoseconds BinWidth) noexcept { HBTBinWidth = BinWidth; }

         auto GetHBTBinCount() const noexcept { return HBTBinCount; }

         void SetHBTBinCount(size_t BinCount) noexcept { HBTBinCount = BinCount; }

         auto GetHBTMaxIntegrationTime() const noexcept { return HBTMaxIntegrationTime; }

         void SetHBTMaxIntegrationTime(std::chrono::microseconds MaxIntegrationTime) noexcept { HBTMaxIntegrationTime = MaxIntegrationTime; }

         const PositionPoint& GetHBTSamplePosition() const noexcept { return HBTSamplePosition; }

         void SetHBTSamplePosition(const PositionPoint& Position) noexcept { HBTSamplePosition = Position; }

         auto GetHBTNumEventCounts() const noexcept { return HBTNumEventCounts; }

         void SetHBTNumEventCounts(long long NumEventCounts) noexcept { HBTNumEventCounts = NumEventCounts; }

         auto GetHBTTotalIntegrationTime() const noexcept { return HBTTotalIntegrationTime; }

         void SetHBTTotalIntegrationTime(std::chrono::microseconds TotalIntegrationTime) noexcept { HBTTotalIntegrationTime = TotalIntegrationTime; }

         auto& GetHBTDataPoints() noexcept { return HBTDataPoints; }

         const auto& GetHBTDataPoints() const noexcept { return HBTDataPoints; }

         void ClearHBTDataPoints() { HBTDataPoints.clear(); }

         auto GetHBTDataPointsMinValues() const noexcept { return HBTDataPointsMinValues; }

         void SetHBTDataPointsMinValues(const QPointF& DataPointsMinValues) noexcept { HBTDataPointsMinValues = DataPointsMinValues; }

         auto GetHBTDataPointsMaxValues() const noexcept { return HBTDataPointsMaxValues; }

         void SetHBTDataPointsMaxValues(const QPointF& DataPointsMaxValues) noexcept { HBTDataPointsMaxValues = DataPointsMaxValues; }


         bool IsAutoMeasureRunning() const noexcept { return AutoMeasureRunning; }

         void SetAutoMeasureRunning(bool Running) noexcept { AutoMeasureRunning = Running; }

         std::filesystem::path GetAutoMeasureSavePath() const;

         void SetAutoMeasureSavePath(std::filesystem::path SavePath) noexcept { AutoMeasureSavePath = SavePath; }

         const PositionPoint& GetAutoMeasureCurrentCellPosition() const noexcept { return AutoMeasureCurrentCellPosition; }

         void SetAutoMeasureCurrentCellPosition(const PositionPoint& Position) noexcept { AutoMeasureCurrentCellPosition = Position; }

         auto GetAutoMeasureNumberImageSets() const noexcept { return AutoMeasureNumberImageSets; }

         void SetAutoMeasureNumberImageSets(int NumberImageSets) noexcept { AutoMeasureNumberImageSets = NumberImageSets; }

         auto GetAutoMeasureCurrentImageSet() const noexcept { return AutoMeasureCurrentImageSet; }

         auto IncrementAutoMeasureCurrentImageSet() noexcept { return ++AutoMeasureCurrentImageSet; }

         void ResetAutoMeasureCurrentImageSet() noexcept { AutoMeasureCurrentImageSet = -1; }

         std::chrono::seconds GetAutoMeasureInitialImageSetWaitTime() const noexcept { return AutoMeasureInitialImageSetWaitTime; }

         void SetAutoMeasureInitialImageSetWaitTime(std::chrono::seconds Time) noexcept { AutoMeasureInitialImageSetWaitTime = Time; }

         int GetAutoMeasureImagePositionScatterRadius() const noexcept { return AutoMeasureImagePositionScatterRadius; }

         void SetAutoMeasureImagePositionScatterRadius(int ScatterRadius) noexcept { AutoMeasureImagePositionScatterRadius = ScatterRadius; }

         auto GetAutoMeasureLocalizationType() const noexcept { return AutoMeasureLocalizationType; }

         void SetAutoMeasureLocalizationType(WidefieldMicroscopeWidget::LocalizationType LocalizationType) noexcept { AutoMeasureLocalizationType = LocalizationType; }

         auto GetAutoMeasureOptimizeEnabled() const noexcept { return AutoMeasureOptimizeEnabled; }

         void SetAutoMeasureOptimizeEnabled(bool Enabled) noexcept { AutoMeasureOptimizeEnabled = Enabled; }

         auto GetAutoMeasureSpectrumEnabled() const noexcept { return AutoMeasureSpectrumEnabled; }

         void SetAutoMeasureSpectrumEnabled(bool Enabled) noexcept { AutoMeasureSpectrumEnabled = Enabled; }

         auto GetAutoMeasureHBTEnabled() const noexcept { return AutoMeasureHBTEnabled; }

         void SetAutoMeasureHBTEnabled(bool Enabled) noexcept { AutoMeasureHBTEnabled = Enabled; }

         auto GetAutoMeasureNumOptimizationAttempts() const noexcept { return AutoMeasureNumOptimizationAttempts; }

         void SetAutoMeasureNumOptimizationAttempts(int NumOptimizationAttempts) noexcept { AutoMeasureNumOptimizationAttempts = NumOptimizationAttempts; }

         auto GetAutoMeasureCurrentOptimizationAttempt() const noexcept { return AutoMeasureCurrentOptimizationAttempt; }

         auto IncrementAutoMeasureCurrentOptimizationAttempt() noexcept { return ++AutoMeasureCurrentOptimizationAttempt; }

         void ResetAutoMeasureCurrentOptimizationAttempt() noexcept { AutoMeasureCurrentOptimizationAttempt = -1; }

         auto GetAutoMeasureMaxOptimizationReruns() const noexcept { return AutoMeasureMaxOptimizationReruns; }

         void SetAutoMeasureMaxOptimizationReruns(int MaxOptimizationReruns) noexcept { AutoMeasureMaxOptimizationReruns = MaxOptimizationReruns; }

         auto GetAutoMeasureCurrentOptimizationRerun() const noexcept { return AutoMeasureCurrentOptimizationRerun; }

         auto IncrementAutoMeasureCurrentOptimizationRerun() noexcept { return ++AutoMeasureCurrentOptimizationRerun; }

         void ResetAutoMeasureCurrentOptimizationRerun() noexcept { AutoMeasureCurrentOptimizationRerun = -1; }

         auto GetAutoMeasureOptimizationMaxDistance() const noexcept { return AutoMeasureOptimizationMaxDistance; }

         void SetAutoMeasureOptimizationMaxDistance(int OptimizationMaxDistance) noexcept { AutoMeasureOptimizationMaxDistance = OptimizationMaxDistance; }

         auto GetAutoMeasureCountRateThreshold() const noexcept { return AutoMeasureCountRateThreshold; }

         void SetAutoMeasureCountRateThreshold(int CountRateThreshold) noexcept { AutoMeasureCountRateThreshold = CountRateThreshold; }

         auto& GetAutoMeasureCellRangeFrom() const noexcept { return AutoMeasureCellRangeFrom; }

         auto& GetAutoMeasureCellRangeFrom() noexcept { return AutoMeasureCellRangeFrom; }

         auto& GetAutoMeasureCellRangeTo() const noexcept { return AutoMeasureCellRangeTo; }

         auto& GetAutoMeasureCellRangeTo() noexcept { return AutoMeasureCellRangeTo; }

         bool IsCellRangeValid() const noexcept;

         int GetAutoMeasureCellLineLength() const noexcept;

         int GetAutoMeasureCellColumnLength() const noexcept;

         int GetAutoMeasureCellCount() const noexcept;

         int GetAutoMeasureCurrentCellIndex() const;

         auto& GetAutoMeasureCellSkip() const noexcept { return AutoMeasureCellSkip; }

         auto& GetAutoMeasureCellSkip() noexcept { return AutoMeasureCellSkip; }

         auto GetAutoMeasureFirstEmitter() const noexcept { return AutoMeasureFirstEmitter; }

         bool SetAutoMeasureFirstEmitter(Util::MarkerGraphicsView::MarkerType::IDType FirstEmitterID) noexcept;

         auto GetAutoMeasureCurrentEmitter() const noexcept { return AutoMeasureCurrentEmitter; }

         void ResetAutoMeasureCurrentEmitter() noexcept;

         auto IncrementAutoMeasureCurrentEmitter() noexcept { return ++AutoMeasureCurrentEmitter; }


     private:

         void ResetImpl(dispatch_tag<QModuleDataBase>) override final;

         virtual void ResetImpl(dispatch_tag<WidefieldMicroscopeData>) {};


         void Init();


         DynExp::LinkedObjectWrapperContainer<DynExpInstr::PositionerStage> SampleStageX;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::PositionerStage> SampleStageY;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::PositionerStage> SampleStageZ;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::AnalogOut> FocusPiezoZ;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::DigitalOut> LEDSwitch;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::DigitalOut> PumpSwitch;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::DigitalOut> WidefieldConfocalSwitch;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::DigitalIn> WidefieldConfocalIndicator;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::FunctionGenerator> WidefieldHBTSwitch;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::AnalogOut> PumpPower;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::AnalogIn> PumpPowerIndicator;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::Camera> WidefieldCamera;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::WidefieldLocalization> WidefieldLocalizer;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::TimeTagger> SPD1;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::TimeTagger> SPD2;

         DynExp::LinkedObjectWrapperContainer<DynExpInstr::InterModuleCommunicator> AcqCommunicator;


         Util::FeatureTester<FeatureType> Features;

         std::string UIMessage;


         // General

         SetupModeType SetupMode;

         bool LEDLightTurnedOn;

         bool PumpLightTurnedOn;

         double MinPumpPower;

         double MaxPumpPower;

         double WidefieldPumpPower;

         double ConfocalPumpPower;

         double MeasuredPumpPower;

         double MinFocusVoltage;

         double MaxFocusVoltage;

         double FocusCurrentVoltage;

         double FocusZeroVoltage;

         double FocusConfocalOffsetVoltage;

         bool AutofocusFinished;


         // Widefield imaging

         CameraTimeType MinCameraExposureTime;

         CameraTimeType MaxCameraExposureTime;

         CameraTimeType LEDCameraExposureTime;

         CameraTimeType WidefieldCameraExposureTime;

         QPoint ConfocalSpotImagePosition;

         PositionPoint WidefieldPosition;


         QImage CurrentImage;

         bool CurrentImageChanged;

         DynExpInstr::WidefieldLocalizationCellIDType CurrentCellID;

         DynExpInstr::WidefieldLocalizationCellIDType LastCellID;

         LocalizedPositionsMapType LocalizedPositions;

         bool LocalizedPositionsChanged;

         bool LocalizedPositionsStateChanged;


         // Confocal scanning

         PositionPoint SampleHomePosition;

         int ConfocalScanWidth;

         int ConfocalScanHeight;

         int ConfocalScanDistPerPixel;

         SPDTimeType SPDExposureTime;

         SPDStateType SPD1State;

         SPDStateType SPD2State;


         // Confocal optimization

         double ConfocalOptimizationInitXYStepSize;

         double ConfocalOptimizationInitZStepSize;

         double ConfocalOptimizationTolerance;

         double LastCountRate;


         // vector of pairs <sample stage positions in nm, count rate in Hz>

         std::vector<std::pair<PositionPoint, double>> ConfocalScanResults;

         QSurfaceDataRowsType ConfocalScanSurfacePlotRows;


         // HBT

         Util::picoseconds HBTBinWidth;

         size_t HBTBinCount;

         std::chrono::microseconds HBTMaxIntegrationTime;

         PositionPoint HBTSamplePosition;

         long long HBTNumEventCounts;

         std::chrono::microseconds HBTTotalIntegrationTime;


         // x is time in ps, y is g2.

         QList<QPointF> HBTDataPoints;

         QPointF HBTDataPointsMinValues;

         QPointF HBTDataPointsMaxValues;


         // Auto measure

         bool AutoMeasureRunning;

         std::filesystem::path AutoMeasureSavePath;

         PositionPoint AutoMeasureCurrentCellPosition;

         int AutoMeasureNumberImageSets;

         int AutoMeasureCurrentImageSet;

         std::chrono::seconds AutoMeasureInitialImageSetWaitTime;

         int AutoMeasureImagePositionScatterRadius;

         WidefieldMicroscopeWidget::LocalizationType AutoMeasureLocalizationType;

         bool AutoMeasureOptimizeEnabled;

         bool AutoMeasureSpectrumEnabled;

         bool AutoMeasureHBTEnabled;

         int AutoMeasureNumOptimizationAttempts;

         int AutoMeasureCurrentOptimizationAttempt;

         int AutoMeasureMaxOptimizationReruns;

         int AutoMeasureCurrentOptimizationRerun;

         int AutoMeasureOptimizationMaxDistance;

         int AutoMeasureCountRateThreshold;

         QPoint AutoMeasureCellRangeFrom;

         QPoint AutoMeasureCellRangeTo;

         QPoint AutoMeasureCellSkip;

         LocalizedPositionsMapType::iterator AutoMeasureFirstEmitter;

         LocalizedPositionsMapType::iterator AutoMeasureCurrentEmitter;

     };


     WidefieldMicroscopeData::PositionPoint operator+(const WidefieldMicroscopeData::PositionPoint& lhs, const WidefieldMicroscopeData::PositionPoint& rhs);

     WidefieldMicroscopeData::PositionPoint operator-(const WidefieldMicroscopeData::PositionPoint& lhs, const WidefieldMicroscopeData::PositionPoint& rhs);


     class WidefieldMicroscopeParams : public DynExp::QModuleParamsBase

     {

     public:

         WidefieldMicroscopeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : QModuleParamsBase(ID, Core) {}

         virtual ~WidefieldMicroscopeParams() = default;


         virtual const char* GetParamClassTag() const noexcept override { return "WidefieldMicroscopeParams"; }


         Param<DynExp::ObjectLink<DynExpInstr::PositionerStage>> SampleStageX = { *this, GetCore().GetInstrumentManager(),

             "SampleStageX", "Sample stage X", "Positioner to move sample along x coordinate", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::PositionerStage>> SampleStageY = { *this, GetCore().GetInstrumentManager(),

             "SampleStageY", "Sample stage Y", "Positioner to move sample along y coordinate", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::PositionerStage>> SampleStageZ = { *this, GetCore().GetInstrumentManager(),

             "SampleStageZ", "Sample stage Z", "Positioner to move sample along z coordinate", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::AnalogOut>> FocusPiezoZ = { *this, GetCore().GetInstrumentManager(),

             "FocusPiezoZ", "Focusing piezo (AO)", "Piezo to adjust the focus of the microscope", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::DigitalOut>> LEDSwitch = { *this, GetCore().GetInstrumentManager(),

             "LEDSwitch", "LED switch (DO)", "Digital switch to turn the LED light source on and off", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::DigitalOut>> PumpSwitch = { *this, GetCore().GetInstrumentManager(),

             "PumpSwitch", "Pump switch (DO)", "Digital switch to turn the pump light source on and off", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::DigitalOut>> WidefieldConfocalSwitch = { *this, GetCore().GetInstrumentManager(),

             "WidefieldConfocalSwitch", "Widefield/confocal mode switch (DO)",

             "Digital switch to change from widefield mode (LOW) to confocal mode (HIGH)", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::DigitalIn>> WidefieldConfocalIndicator = { *this, GetCore().GetInstrumentManager(),

             "WidefieldConfocalIndicator", "Widefield/confocal mode indicator (DI)",

             "Digital indicator which is LOW if in widefield mode and HIGH if in confocal mode", DynExpUI::Icons::Instrument, true };

         Param<ParamsConfigDialog::NumberType> WidefieldConfocalTransitionTime = { *this, "WidefieldConfocalTransitionTime",

             "Widefield/confocal transition time (ms)",

             "Time it takes to transition from widefield into confocal mode or vice versa once the widefield/confocal mode switch has been triggered",

             false, 500, 0, 10000, 10, 0 };

         Param<DynExp::ObjectLink<DynExpInstr::FunctionGenerator>> WidefieldHBTSwitch = { *this, GetCore().GetInstrumentManager(),

             "WidefieldHBTSwitch", "HBT flip mirror servo actuator (DO)", "Servo actuator to switch to HBT measurement mode", DynExpUI::Icons::Instrument, true };

         Param<ParamsConfigDialog::NumberType> WidefieldHBTSwitchLowDutyCycle = { *this, "WidefieldHBTSwitchLowDutyCycle",

             "HBT flip mirror low duty cycle",

             "Duty cycle of rectangular pulses applied to the HBT flip mirror servo actuator in order to make it flip the mirror into the low position",

             false, .2, 0, 1, .1, 2 };

         Param<ParamsConfigDialog::NumberType> WidefieldHBTSwitchHighDutyCycle = { *this, "WidefieldHBTSwitchHighDutyCycle",

             "HBT flip mirror high duty cycle",

             "Duty cycle of rectangular pulses applied to the HBT flip mirror servo actuator in order to make it flip the mirror into the high position",

             false, .8, 0, 1, .1, 2 };

         Param<ParamsConfigDialog::NumberType> WidefieldHBTTransitionTime = { *this, "WidefieldHBTTransitionTime",

             "HBT flip mirror transition time (ms)",

             "Time it takes to flip the HBT mirror once the duty cycle of the rectangular pulses applied to the flip mirror servo actuator has changed",

             false, 500, 0, 10000, 10, 0 };

         Param<DynExp::ObjectLink<DynExpInstr::AnalogOut>> PumpPower = { *this, GetCore().GetInstrumentManager(),

             "PumpPower", "Pump power (AO)", "Analog output to adjust the power of the pump light source", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::AnalogIn>> PumpPowerIndicator = { *this, GetCore().GetInstrumentManager(),

             "PumpPowerIndicator", "Pump power indicator (AI)", "Analog input to measure the current power of the pump light source",

             DynExpUI::Icons::Instrument, true };

         Param<ParamsConfigDialog::NumberType> DefaultPowerWidefieldMode = { *this, "DefaultPowerWidefieldMode", "Default pump power (widefield mode)",

             "Defines the pump power in units of the pump power (AO) parameter which is initially used in the widefield mode",

             true, 1, 0, std::numeric_limits<ParamsConfigDialog::NumberType>::max(), .1, 3 };

         Param<ParamsConfigDialog::NumberType> DefaultPowerConfocalMode = { *this, "DefaultPowerConfocalMode", "Default pump power (confocal mode)",

             "Defines the pump power in units of the pump power (AO) parameter which is initially used in the confocal mode",

             true, .1, 0, std::numeric_limits<ParamsConfigDialog::NumberType>::max(), .1, 3 };

         Param<DynExp::ObjectLink<DynExpInstr::Camera>> WidefieldCamera = { *this, GetCore().GetInstrumentManager(),

             "WidefieldCamera", "Widefield camera", "Camera to record widefield images of the sample", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::WidefieldLocalization>> WidefieldLocalizer = { *this, GetCore().GetInstrumentManager(),

             "WidefieldLocalizer", "Widefield localizer", "gRPC service to perform widefield localization of emitters within a recorded camera image",

             DynExpUI::Icons::Instrument, true };

         Param<ParamsConfigDialog::NumberType> WidefieldCameraMagnification = { *this, "WidefieldCameraMagnification", "Widefield camera magnification factor",

             "Magnification factor of the optical system between the sample and the widefield camera",

             false, 100, .01, 10000, 1, 2 };

         Param<DynExp::ObjectLink<DynExpInstr::TimeTagger>> SPD1 = { *this, GetCore().GetInstrumentManager(),

             "SPD1", "SPD 1", "First single photon detector for confocal light collection", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::TimeTagger>> SPD2 = { *this, GetCore().GetInstrumentManager(),

             "SPD2", "SPD 2", "Second single photon detector for confocal light collection", DynExpUI::Icons::Instrument, true };

         Param<DynExp::ObjectLink<DynExpInstr::InterModuleCommunicator>> AcqCommunicator = { *this, GetCore().GetInstrumentManager(),

             "AcqInterModuleCommunicator", "Acq. inter-module communicator", "Inter-module communicator to control image and spectrum capturing modules with", DynExpUI::Icons::Instrument, true };


     private:

         void ConfigureParamsImpl(dispatch_tag<QModuleParamsBase>) override final {}

     };


     class WidefieldMicroscopeConfigurator : public DynExp::QModuleConfiguratorBase

     {

     public:

         using ObjectType = WidefieldMicroscope;

         using ParamsType = WidefieldMicroscopeParams;


         WidefieldMicroscopeConfigurator() = default;

         virtual ~WidefieldMicroscopeConfigurator() = default;


     private:

         virtual DynExp::ParamsBasePtrType MakeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) const override final { return DynExp::MakeParams<WidefieldMicroscopeConfigurator>(ID, Core); }

     };


     class WidefieldMicroscope : public DynExp::QModuleBase

     {

         enum class PositionerStateType { WaitingForMovement, Moving, Arrived };

         enum class WidefieldImageProcessingStateType { Waiting, Finished, Failed };


         using AtomicPositionerStateType = std::atomic<PositionerStateType>;

         using AtomicWidefieldImageProcessingStateType = std::atomic<WidefieldImageProcessingStateType>;


     public:

         using ParamsType = WidefieldMicroscopeParams;

         using ConfigType = WidefieldMicroscopeConfigurator;

         using ModuleDataType = WidefieldMicroscopeData;


         constexpr static auto Name() noexcept { return "Widefield Microscope"; }

         constexpr static auto Category() noexcept { return "Experiments"; }


         WidefieldMicroscope(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params);

         virtual ~WidefieldMicroscope();


         virtual std::string GetName() const override { return Name(); }

         virtual std::string GetCategory() const override { return Category(); }


         std::chrono::milliseconds GetMainLoopDelay() const override final;


         // Events which the UI thread might enqueue.

         void OnSaveCurrentImage(DynExp::ModuleInstance* Instance, QString Filename) const;

         void OnGoToSamplePos(DynExp::ModuleInstance* Instance, QPointF SamplePos) const;

         void OnBringMarkerToConfocalSpot(DynExp::ModuleInstance* Instance, QPoint MarkerPos, QPointF SamplePos) const;

         void OnRunCharacterizationFromID(DynExp::ModuleInstance* Instance, Util::MarkerGraphicsView::MarkerType::IDType ID) const;


     private:

         Util::DynExpErrorCodes::DynExpErrorCodes ModuleMainLoop(DynExp::ModuleInstance& Instance) override final;


         void ResetImpl(dispatch_tag<QModuleBase>) override final;


         std::unique_ptr<DynExp::QModuleWidget> MakeUIWidget() override final;

         void UpdateUIChild(const ModuleBase::ModuleDataGetterType& ModuleDataGetter) override final;


         // Helper functions

         // ->

         template <typename PosT>

         static ModuleDataType::PositionPoint PositionPointFromPixelDist(Util::SynchronizedPointer<const ParamsType>& ModuleParams, Util::SynchronizedPointer<ModuleDataType>& ModuleData,

             const PosT x, const PosT y)

         {

             return {

                 Util::NumToT<WidefieldMicroscopeData::PositionType>(x * ModuleData->GetWidefieldCamera()->GetPixelSizeInMicrons() * 1000 / ModuleParams->WidefieldCameraMagnification),

                 Util::NumToT<WidefieldMicroscopeData::PositionType>(y * ModuleData->GetWidefieldCamera()->GetPixelSizeInMicrons() * 1000 / ModuleParams->WidefieldCameraMagnification)

             };

         }


         bool IsReadyState() const noexcept { return StateMachine.GetCurrentState()->GetState() == StateType::Ready; }

         StateType ResetState(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         bool IsCharacterizingSample() const noexcept;

         void MoveSampleTo(const ModuleDataType::PositionPoint& Point, Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         bool IsSampleMoving(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void SetFocus(Util::SynchronizedPointer<ModuleDataType>& ModuleData, double Voltage, bool IgnoreOffset = false) const;

         ModuleDataType::PositionPoint CalcMarkerToConfocalSpotDestiny(Util::SynchronizedPointer<const ParamsType>& ModuleParams, Util::SynchronizedPointer<ModuleDataType>& ModuleData,

             QPoint MarkerPos, QPointF SamplePos) const;

         void BringMarkerToConfocalSpot(Util::SynchronizedPointer<const ParamsType>& ModuleParams, Util::SynchronizedPointer<ModuleDataType>& ModuleData,

             QPoint MarkerPos, QPointF SamplePos) const;

         ModuleDataType::QSurfaceDataRowsType CalculateConfocalScanPositions(const int Width, const int Height,

             const int DistPerPixel, const WidefieldMicroscopeData::PositionPoint CenterPosition) const;

         void UpdatePumpPower(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void PrepareImageRecording(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void RecordImage(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         StateType InitiateReadCellIDFromImage(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         StateType InitiateLocalizationFromImage(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void PrepareAPDsForConfocalMode(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void InitializeConfocalOptimizer(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void SetHBTSwitch(Util::SynchronizedPointer<const ParamsType>& ModuleParams,

             Util::SynchronizedPointer<ModuleDataType>& ModuleData, bool IsHBTMode) const;

         void InitializeHBT(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         void StopHBT(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         StateType StartAutofocus(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         StateType StartAutoMeasureLocalization(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         StateType StartAutoMeasureCharacterization(Util::SynchronizedPointer<ModuleDataType>& ModuleData, Util::MarkerGraphicsView::MarkerType::IDType FirstEmitterID = -1) const;

         StateType StartAutoMeasureSampleCharacterization(Util::SynchronizedPointer<ModuleDataType>& ModuleData) const;

         std::filesystem::path BuildFilename(Util::SynchronizedPointer<ModuleDataType>& ModuleData, std::string_view FilenameSuffix) const;

         ModuleDataType::PositionPoint RandomPointInCircle(ModuleDataType::PositionType Radius) const;

         // <-


         // Function and types for automatical optimization of the sample's position to maximize the count rate

         // ->

         struct ConfocalOptimizationStateType

         {

             WidefieldMicroscopeData::PositionType X{};

             WidefieldMicroscopeData::PositionType Y{};

             DynExpInstr::AnalogOutData::SampleStreamType::SampleType Z{};

         };


         enum class ConfocalOptimizationThreadReturnType { NextStep, Finished, Failed };


         using ConfocalOptimizationFeedbackType = double;


         void ConfocalOptimizationInitPromises();

         static ConfocalOptimizationThreadReturnType ConfocalOptimizationThread(WidefieldMicroscope* Owner);

         static double ConfocalOptimizationFuncForwarder(const gsl_vector* vector, void* params);

         double ConfocalOptimizationFunc(const gsl_vector* vector) noexcept;

         // <-


         // Events, run in module thread

         void OnInit(DynExp::ModuleInstance* Instance) const override final;

         void OnExit(DynExp::ModuleInstance* Instance) const override final;

         void OnTerminate(DynExp::ModuleInstance* Instance, bool) const;

         void OnStopAction(DynExp::ModuleInstance* Instance, bool) const;

         void OnSetHomePosition(DynExp::ModuleInstance* Instance, bool) const;

         void OnGoToHomePosition(DynExp::ModuleInstance* Instance, bool) const;

         void OnToggleLEDLightSource(DynExp::ModuleInstance* Instance, bool State) const;

         void OnTogglePumpLightSource(DynExp::ModuleInstance* Instance, bool State) const;

         void OnSetupModeChanged(DynExp::ModuleInstance* Instance, QAction* Action) const;

         void OnAutofocus(DynExp::ModuleInstance* Instance, bool) const;

         void OnOptimizePositions(DynExp::ModuleInstance* Instance, bool) const;

         void OnToggleHBTMirror(DynExp::ModuleInstance* Instance, bool Checked) const;

         void OnResetCellID(DynExp::ModuleInstance* Instance, bool) const;

         void OnGeneralWidefieldPowerChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnGeneralConfocalPowerChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnGeneralFocusCurrentVoltageChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnGeneralFocusZeroVoltageChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnGeneralFocusConfocalOffsetVoltageChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnGeneralSetZeroFocus(DynExp::ModuleInstance* Instance, bool) const;

         void OnGeneralApplyZeroFocus(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldLEDExposureTimeChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnWidefieldApplyLEDExposureTime(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldPumpExposureTimeChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnWidefieldApplyPumpExposureTime(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldFindConfocalSpot(DynExp::ModuleInstance* Instance, bool) const;

         void OnCaptureLEDImage(DynExp::ModuleInstance* Instance, bool) const;

         void OnCaptureWidefieldImage(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldReadCellID(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldAnalyzeImageDistortion(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldLocalizeEmitters(DynExp::ModuleInstance* Instance, bool) const;

         void OnWidefieldImageClicked(DynExp::ModuleInstance* Instance, QPoint Position) const;

         void OnConfocalConfocalWidthChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnConfocalConfocalHeightChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnConfocalConfocalDistPerPixelChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnConfocalSPDExposureTimeChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnConfocalOptimizationInitXYStepSizeChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnConfocalOptimizationInitZStepSizeChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnConfocalOptimizationToleranceChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnPerformConfocalScan(DynExp::ModuleInstance* Instance, bool) const;

         void ConfocalSurfaceSelectedPointChanged(DynExp::ModuleInstance* Instance, QPoint Position) const;

         void OnHBTBinWidthChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnHBTBinCountChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnHHBTMaxIntegrationTimeChanged(DynExp::ModuleInstance* Instance, double Value) const;

         void OnMeasureHBT(DynExp::ModuleInstance* Instance, bool) const;

         void OnImageCapturingPaused(DynExp::ModuleInstance* Instance) const;

         void OnFinishedAutofocus(DynExp::ModuleInstance* Instance, bool Success, double Voltage) const;

         void OnSpectrumFinishedRecording(DynExp::ModuleInstance* Instance) const;

         void OnAutoMeasureSavePathChanged(DynExp::ModuleInstance* Instance, QString Path) const;

         void OnAutoMeasureNumberImageSetsChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureInitialImageSetWaitTimeChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureImagePositionScatterRadius(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureLocalizationTypeChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnToggleAutoMeasureOptimizeEnabled(DynExp::ModuleInstance* Instance, int State) const;

         void OnToggleAutoMeasureSpectrumEnabled(DynExp::ModuleInstance* Instance, int State) const;

         void OnToggleAutoMeasureHBTEnabled(DynExp::ModuleInstance* Instance, int State) const;

         void OnAutoMeasureNumOptimizationAttemptsChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureMaxOptimizationRerunsChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureOptimizationMaxDistanceChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCountRateThresholdChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellRangeFromXChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellRangeFromYChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellRangeToXChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellRangeToYChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellSkipXChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureCellSkipYChanged(DynExp::ModuleInstance* Instance, int Value) const;

         void OnAutoMeasureRunLocalization(DynExp::ModuleInstance* Instance, bool) const;

         void OnAutoMeasureRunCharacterization(DynExp::ModuleInstance* Instance, bool) const;

         void OnAutoMeasureRunSampleCharacterization(DynExp::ModuleInstance* Instance, bool) const;


         // State functions for state machine

         StateType ReturnToReadyStateFunc(DynExp::ModuleInstance& Instance);

         StateType InitializingStateFunc(DynExp::ModuleInstance& Instance);

         StateType SetupTransitionBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType SetupTransitioningStateFunc(DynExp::ModuleInstance& Instance);

         StateType SetupTransitionEndStateFunc(DynExp::ModuleInstance& Instance);

         StateType ReadyStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutofocusBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutofocusWaitingStateFunc(DynExp::ModuleInstance& Instance);

         StateType LEDImageAcquisitionBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType WidefieldImageAcquisitionBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType WaitingForImageReadyToCaptureStateFunc(DynExp::ModuleInstance& Instance);

         StateType WaitingForImageStateFunc(DynExp::ModuleInstance& Instance);

         StateType WaitingForWidefieldCellIDStateFunc(DynExp::ModuleInstance& Instance);

         StateType WidefieldCellWaitUntilCenteredStateFunc(DynExp::ModuleInstance& Instance);

         StateType WaitingForWidefieldLocalizationStateFunc(DynExp::ModuleInstance& Instance);

         StateType FindingConfocalSpotBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType FindingConfocalSpotAfterTransitioningToConfocalModeStateFunc(DynExp::ModuleInstance& Instance);

         StateType FindingConfocalSpotAfterRecordingWidefieldImageStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalScanStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalScanWaitUntilMovedStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalScanCaptureStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalScanWaitUntilCapturedStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalOptimizationInitStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalOptimizationInitSubStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalOptimizationWaitStateFunc(DynExp::ModuleInstance& Instance);

         StateType ConfocalOptimizationStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType HBTAcquiringStateFunc(DynExp::ModuleInstance& Instance);

         StateType WaitingStateFunc(DynExp::ModuleInstance& Instance);

         StateType SpectrumAcquisitionWaitingStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureLocalizationStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureLocalizationSaveLEDImageStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureLocalizationSaveWidefieldImageStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureLocalizationMovingStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationGotoEmitterStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationOptimizationFinishedStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationSpectrumBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationSpectrumFinishedStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationHBTBeginStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationHBTWaitForInitStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureCharacterizationHBTFinishedStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleStepStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleReadCellIDStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleReadCellIDFinishedStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleLocalizeStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleFindEmittersStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleCharacterizeStateFunc(DynExp::ModuleInstance& Instance);

         StateType AutoMeasureSampleAdvanceCellStateFunc(DynExp::ModuleInstance& Instance);


         // States for state machine

         static constexpr auto InitializingState = Util::StateMachineState(StateType::Initializing,

             &WidefieldMicroscope::InitializingStateFunc, "Initializing module...");

         static constexpr auto SetupTransitionBeginState = Util::StateMachineState(StateType::SetupTransitionBegin,

             &WidefieldMicroscope::SetupTransitionBeginStateFunc, "Transitioning...");

         static constexpr auto SetupTransitioningState = Util::StateMachineState(StateType::SetupTransitioning,

             &WidefieldMicroscope::SetupTransitioningStateFunc, "Transitioning...");

         static constexpr auto SetupTransitionEndState = Util::StateMachineState(StateType::SetupTransitionEnd,

             &WidefieldMicroscope::SetupTransitionEndStateFunc, "Transitioning...");

         static constexpr auto SetupTransitionFinishedState = Util::StateMachineState(StateType::SetupTransitionFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto ReadyState = Util::StateMachineState(StateType::Ready,

             &WidefieldMicroscope::ReadyStateFunc, "Ready");

         static constexpr auto AutofocusBeginState = Util::StateMachineState(StateType::AutofocusBegin,

             &WidefieldMicroscope::AutofocusBeginStateFunc);

         static constexpr auto AutofocusWaitingState = Util::StateMachineState(StateType::AutofocusWaiting,

             &WidefieldMicroscope::AutofocusWaitingStateFunc);

         static constexpr auto AutofocusFinishedState = Util::StateMachineState(StateType::AutofocusFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto LEDImageAcquisitionBeginState = Util::StateMachineState(StateType::LEDImageAcquisitionBegin,

             &WidefieldMicroscope::LEDImageAcquisitionBeginStateFunc, "Recording LED image...");

         static constexpr auto WidefieldImageAcquisitionBeginState = Util::StateMachineState(StateType::WidefieldImageAcquisitionBegin,

             &WidefieldMicroscope::WidefieldImageAcquisitionBeginStateFunc, "Recording widefield image...");

         static constexpr auto WaitingForLEDImageReadyToCaptureState = Util::StateMachineState(StateType::WaitingForLEDImageReadyToCapture,

             &WidefieldMicroscope::WaitingForImageReadyToCaptureStateFunc, "Recording LED image...");

         static constexpr auto WaitingForLEDImageState = Util::StateMachineState(StateType::WaitingForLEDImage,

             &WidefieldMicroscope::WaitingForImageStateFunc, "Recording LED image...");

         static constexpr auto WaitingForLEDImageFinishedState = Util::StateMachineState(StateType::WaitingForLEDImageFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto WaitingForWidefieldImageReadyToCaptureState = Util::StateMachineState(StateType::WaitingForWidefieldImageReadyToCapture,

             &WidefieldMicroscope::WaitingForImageReadyToCaptureStateFunc, "Recording widefield image...");

         static constexpr auto WaitingForWidefieldImageState = Util::StateMachineState(StateType::WaitingForWidefieldImage,

             &WidefieldMicroscope::WaitingForImageStateFunc, "Recording widefield image...");

         static constexpr auto WaitingForWidefieldImageFinishedState = Util::StateMachineState(StateType::WaitingForWidefieldImageFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto WaitingForWidefieldCellIDState = Util::StateMachineState(StateType::WaitingForWidefieldCellID,

             &WidefieldMicroscope::WaitingForWidefieldCellIDStateFunc, "Waiting for cell ID to be read from image...");

         static constexpr auto WidefieldCellWaitUntilCenteredState = Util::StateMachineState(StateType::WidefieldCellWaitUntilCentered,

             &WidefieldMicroscope::WidefieldCellWaitUntilCenteredStateFunc, "Waiting for cell to be centered in FOV...");

         static constexpr auto WidefieldCellIDReadFinishedState = Util::StateMachineState(StateType::WidefieldCellIDReadFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto WaitingForWidefieldLocalizationState = Util::StateMachineState(StateType::WaitingForWidefieldLocalization,

             &WidefieldMicroscope::WaitingForWidefieldLocalizationStateFunc, "Waiting for localization of emitters from image...");

         static constexpr auto WidefieldLocalizationFinishedState = Util::StateMachineState(StateType::WidefieldLocalizationFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto FindingConfocalSpotBeginState = Util::StateMachineState(StateType::FindingConfocalSpotBegin,

             &WidefieldMicroscope::FindingConfocalSpotBeginStateFunc);

         static constexpr auto FindingConfocalSpotAfterTransitioningToConfocalModeState = Util::StateMachineState(StateType::FindingConfocalSpotAfterTransitioningToConfocalMode,

             &WidefieldMicroscope::FindingConfocalSpotAfterTransitioningToConfocalModeStateFunc);

         static constexpr auto FindingConfocalSpotAfterRecordingWidefieldImageState = Util::StateMachineState(StateType::FindingConfocalSpotAfterRecordingWidefieldImage,

             &WidefieldMicroscope::FindingConfocalSpotAfterRecordingWidefieldImageStateFunc);

         static constexpr auto ConfocalScanStepState = Util::StateMachineState(StateType::ConfocalScanStep,

             &WidefieldMicroscope::ConfocalScanStepStateFunc, "Performing confocal scan...");

         static constexpr auto ConfocalScanWaitUntilMovedState = Util::StateMachineState(StateType::ConfocalScanWaitUntilMoved,

             &WidefieldMicroscope::ConfocalScanWaitUntilMovedStateFunc, "Performing confocal scan...");

         static constexpr auto ConfocalScanCaptureState = Util::StateMachineState(StateType::ConfocalScanCapture,

             &WidefieldMicroscope::ConfocalScanCaptureStateFunc, "Performing confocal scan...");

         static constexpr auto ConfocalScanWaitUntilCapturedState = Util::StateMachineState(StateType::ConfocalScanWaitUntilCaptured,

             &WidefieldMicroscope::ConfocalScanWaitUntilCapturedStateFunc, "Performing confocal scan...");

         static constexpr auto ConfocalOptimizationInitState = Util::StateMachineState(StateType::ConfocalOptimizationInit,

             &WidefieldMicroscope::ConfocalOptimizationInitStateFunc);

         static constexpr auto ConfocalOptimizationInitSubStepState = Util::StateMachineState(StateType::ConfocalOptimizationInitSubStep,

             &WidefieldMicroscope::ConfocalOptimizationInitSubStepStateFunc);

         static constexpr auto ConfocalOptimizationWaitState = Util::StateMachineState(StateType::ConfocalOptimizationWait,

             &WidefieldMicroscope::ConfocalOptimizationWaitStateFunc);

         static constexpr auto ConfocalOptimizationStepState = Util::StateMachineState(StateType::ConfocalOptimizationStep,

             &WidefieldMicroscope::ConfocalOptimizationStepStateFunc);

         static constexpr auto ConfocalOptimizationFinishedState = Util::StateMachineState(StateType::ConfocalOptimizationFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto HBTAcquiringState = Util::StateMachineState(StateType::HBTAcquiring,

             &WidefieldMicroscope::HBTAcquiringStateFunc, "HBT acquiring...");

         static constexpr auto HBTFinishedState = Util::StateMachineState(StateType::HBTFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto WaitingState = Util::StateMachineState(StateType::Waiting,

             &WidefieldMicroscope::WaitingStateFunc, "Waiting...");

         static constexpr auto WaitingFinishedState = Util::StateMachineState(StateType::WaitingFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto SpectrumAcquisitionWaitingState = Util::StateMachineState(StateType::SpectrumAcquisitionWaiting,

             &WidefieldMicroscope::SpectrumAcquisitionWaitingStateFunc, "Acquiring spectrum...");

         static constexpr auto SpectrumAcquisitionFinishedState = Util::StateMachineState(StateType::SpectrumAcquisitionFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto AutoMeasureLocalizationStepState = Util::StateMachineState(StateType::AutoMeasureLocalizationStep,

             &WidefieldMicroscope::AutoMeasureLocalizationStepStateFunc, "Recording image...");

         static constexpr auto AutoMeasureLocalizationSaveLEDImageState = Util::StateMachineState(StateType::AutoMeasureLocalizationSaveLEDImage,

             &WidefieldMicroscope::AutoMeasureLocalizationSaveLEDImageStateFunc, "Saving LED image...");

         static constexpr auto AutoMeasureLocalizationSaveWidefieldImageState = Util::StateMachineState(StateType::AutoMeasureLocalizationSaveWidefieldImage,

             &WidefieldMicroscope::AutoMeasureLocalizationSaveWidefieldImageStateFunc, "Saving widefield image...");

         static constexpr auto AutoMeasureLocalizationMovingState = Util::StateMachineState(StateType::AutoMeasureLocalizationMoving,

             &WidefieldMicroscope::AutoMeasureLocalizationMovingStateFunc, "Moving to next image capturing position...");

         static constexpr auto AutoMeasureLocalizationFinishedState = Util::StateMachineState(StateType::AutoMeasureLocalizationFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto AutoMeasureCharacterizationStepState = Util::StateMachineState(StateType::AutoMeasureCharacterizationStep,

             &WidefieldMicroscope::AutoMeasureCharacterizationStepStateFunc);

         static constexpr auto AutoMeasureCharacterizationGotoEmitterState = Util::StateMachineState(StateType::AutoMeasureCharacterizationGotoEmitter,

             &WidefieldMicroscope::AutoMeasureCharacterizationGotoEmitterStateFunc);

         static constexpr auto AutoMeasureCharacterizationOptimizationFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationOptimizationFinished,

             &WidefieldMicroscope::AutoMeasureCharacterizationOptimizationFinishedStateFunc);

         static constexpr auto AutoMeasureCharacterizationSpectrumFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationSpectrumFinished,

             &WidefieldMicroscope::AutoMeasureCharacterizationSpectrumFinishedStateFunc);

         static constexpr auto AutoMeasureCharacterizationSpectrumBeginState = Util::StateMachineState(StateType::AutoMeasureCharacterizationSpectrumBegin,

             &WidefieldMicroscope::AutoMeasureCharacterizationSpectrumBeginStateFunc);

         static constexpr auto AutoMeasureCharacterizationHBTBeginState = Util::StateMachineState(StateType::AutoMeasureCharacterizationHBTBegin,

             &WidefieldMicroscope::AutoMeasureCharacterizationHBTBeginStateFunc);

         static constexpr auto AutoMeasureCharacterizationHBTWaitForInitState = Util::StateMachineState(StateType::AutoMeasureCharacterizationHBTWaitForInit,

             &WidefieldMicroscope::AutoMeasureCharacterizationHBTWaitForInitStateFunc);

         static constexpr auto AutoMeasureCharacterizationHBTFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationHBTFinished,

             &WidefieldMicroscope::AutoMeasureCharacterizationHBTFinishedStateFunc);

         static constexpr auto AutoMeasureCharacterizationFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);

         static constexpr auto AutoMeasureSampleStepState = Util::StateMachineState(StateType::AutoMeasureSampleStep,

             &WidefieldMicroscope::AutoMeasureSampleStepStateFunc);

         static constexpr auto AutoMeasureSampleReadCellIDState = Util::StateMachineState(StateType::AutoMeasureSampleReadCellID,

             &WidefieldMicroscope::AutoMeasureSampleReadCellIDStateFunc);

         static constexpr auto AutoMeasureSampleReadCellIDFinishedState = Util::StateMachineState(StateType::AutoMeasureSampleReadCellIDFinished,

             &WidefieldMicroscope::AutoMeasureSampleReadCellIDFinishedStateFunc);

         static constexpr auto AutoMeasureSampleLocalizeState = Util::StateMachineState(StateType::AutoMeasureSampleLocalize,

             &WidefieldMicroscope::AutoMeasureSampleLocalizeStateFunc);

         static constexpr auto AutoMeasureSampleFindEmittersState = Util::StateMachineState(StateType::AutoMeasureSampleFindEmitters,

             &WidefieldMicroscope::AutoMeasureSampleFindEmittersStateFunc);

         static constexpr auto AutoMeasureSampleCharacterizeState = Util::StateMachineState(StateType::AutoMeasureSampleCharacterize,

             &WidefieldMicroscope::AutoMeasureSampleCharacterizeStateFunc);

         static constexpr auto AutoMeasureSampleAdvanceCellState = Util::StateMachineState(StateType::AutoMeasureSampleAdvanceCell,

             &WidefieldMicroscope::AutoMeasureSampleAdvanceCellStateFunc);

         static constexpr auto AutoMeasureSampleFinishedState = Util::StateMachineState(StateType::AutoMeasureSampleFinished,

             &WidefieldMicroscope::ReturnToReadyStateFunc);


         // Contexts for state machine

         const Util::StateMachineContext<StateMachineStateType> AutofocusSetupTransitioningContext = { {

             { StateType::SetupTransitionFinished, StateType::AutofocusBegin }

         }, "Autofocusing..." };

         const Util::StateMachineContext<StateMachineStateType> FindingConfocalSpotBeginContext = { {

             { StateType::SetupTransitionFinished, StateType::FindingConfocalSpotAfterTransitioningToConfocalMode }

         }, "Locating confocal spot..." };

         const Util::StateMachineContext<StateMachineStateType> FindingConfocalSpotRecordingWidefieldImageContext = { {

             { StateType::WaitingForWidefieldImageFinished, StateType::FindingConfocalSpotAfterRecordingWidefieldImage }

         }, "Locating confocal spot..." };

         const Util::StateMachineContext<StateMachineStateType> ConfocalOptimizationContext = { {

             { StateType::DummyState, StateType::ConfocalScanStep },

             { StateType::ConfocalScanStep, StateType::ConfocalOptimizationStep }

         }, "Optimizing count rate..." };

         const Util::StateMachineContext<StateMachineStateType> LEDImageAcquisitionSetupTransitioningContext = { {

             { StateType::SetupTransitionFinished, StateType::LEDImageAcquisitionBegin }

         } };

         const Util::StateMachineContext<StateMachineStateType> WidefieldImageAcquisitionSetupTransitioningContext = { {

             { StateType::SetupTransitionFinished, StateType::WidefieldImageAcquisitionBegin }

         } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureLocalizationContext = { {

             { StateType::SetupTransitionFinished, StateType::Waiting },

             { StateType::WaitingFinished, StateType::AutoMeasureLocalizationStep },

             { StateType::WaitingForLEDImageFinished, StateType::AutoMeasureLocalizationSaveLEDImage },

             { StateType::WaitingForWidefieldImageFinished, StateType::AutoMeasureLocalizationSaveWidefieldImage }

         } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureCharacterizationContext = { {

             { StateType::SetupTransitionFinished, StateType::AutoMeasureCharacterizationStep },

             { StateType::ConfocalOptimizationFinished, StateType::AutoMeasureCharacterizationOptimizationFinished },

             { StateType::SpectrumAcquisitionFinished, StateType::AutoMeasureCharacterizationSpectrumFinished },

             { StateType::HBTFinished, StateType::AutoMeasureCharacterizationHBTFinished }

         }, "Characterizing emitters...", { &ConfocalOptimizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureCharacterizationOptimizationContext = { {

             { StateType::WaitingFinished, StateType::ConfocalOptimizationInit }

         }, "Characterizing emitters (optimizing count rate)...", { &AutoMeasureCharacterizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureCharacterizationSpectrumContext = { {

             { StateType::WaitingFinished, StateType::AutoMeasureCharacterizationSpectrumBegin }

         }, "Characterizing emitters (recording spectrum)...", { &AutoMeasureCharacterizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureCharacterizationHBTContext = { {

             { StateType::WaitingFinished, StateType::AutoMeasureCharacterizationHBTBegin }

         }, "Characterizing emitters (HBT acquiring)...", { &AutoMeasureCharacterizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleContext = { {

             { StateType::AutofocusFinished, StateType::LEDImageAcquisitionBegin },

             { StateType::WaitingForLEDImageReadyToCapture, StateType::Waiting },

             { StateType::WaitingFinished, StateType::WaitingForLEDImageReadyToCapture },

             { StateType::WaitingForLEDImageFinished, StateType::AutoMeasureSampleReadCellID },

             { StateType::WidefieldCellIDReadFinished, StateType::AutoMeasureSampleReadCellIDFinished },

             { StateType::WidefieldLocalizationFinished, StateType::AutoMeasureSampleLocalize }

         }, "Characterizing sample...", { &AutofocusSetupTransitioningContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleRecenterCellContext = { {

             { StateType::WaitingForLEDImageFinished, StateType::AutoMeasureSampleReadCellIDFinished }

         }, "Characterizing sample...", { &AutoMeasureSampleContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleLocalizationContext = { {

             { StateType::AutoMeasureLocalizationFinished, StateType::AutoMeasureSampleFindEmitters },

             { StateType::WidefieldLocalizationFinished, StateType::AutoMeasureSampleCharacterize }

         }, "Characterizing sample (localizing)...", { &AutoMeasureLocalizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleCharacterizationContext = { {

             { StateType::AutoMeasureCharacterizationFinished, StateType::AutoMeasureSampleAdvanceCell }

         }, "Characterizing sample...", { &AutoMeasureCharacterizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleCharacterizationOptimizationContext = { {

         }, "Characterizing sample (optimizing count rate)...", { &AutoMeasureSampleCharacterizationContext, &AutoMeasureCharacterizationOptimizationContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleCharacterizationSpectrumContext = { {

         }, "Characterizing sample (recording spectrum)...", { &AutoMeasureSampleCharacterizationContext, &AutoMeasureCharacterizationSpectrumContext } };

         const Util::StateMachineContext<StateMachineStateType> AutoMeasureSampleCharacterizationHBTContext = { {

         }, "Characterizing sample (HBT acquiring)...", { &AutoMeasureSampleCharacterizationContext, &AutoMeasureCharacterizationHBTContext } };


         // Logical const-ness: allow events to set the state machine's current state.

         mutable Util::StateMachine<StateMachineStateType> StateMachine;


         // shared_ptr since in principle PositionerStages' tasks can outlive this module instance.

         const std::shared_ptr<AtomicPositionerStateType> ConfocalScanPositionerStateX;

         const std::shared_ptr<AtomicPositionerStateType> ConfocalScanPositionerStateY;

         const std::shared_ptr<AtomicPositionerStateType> ConfocalScanPositionerStateZ;


         // shared_ptr since in principle WidefieldLocalizer's tasks can outlive this module instance.

         const std::shared_ptr<AtomicWidefieldImageProcessingStateType> WidefieldCellIDState;

         const std::shared_ptr<AtomicWidefieldImageProcessingStateType> WidefieldLocalizationState;


         mutable std::list<WidefieldMicroscopeData::PositionPoint> ConfocalScanPositions;


         // Variables for automatical optimization of the sample's position to maximize the count rate

         static constexpr size_t GSLConfocalOptimizationNumDimensions = 3;

         const gsl_multimin_fminimizer_type* const GSLConfocalOptimizationMinimizer = gsl_multimin_fminimizer_nmsimplex2;

         gsl_multimin_function GSLConfocalOptimizationFuncDesc{ &WidefieldMicroscope::ConfocalOptimizationFuncForwarder, GSLConfocalOptimizationNumDimensions, this };

         gsl_multimin_fminimizer* const GSLConfocalOptimizationState;

         gsl_vector* const GSLConfocalOptimizationStepSize;

         gsl_vector* const GSLConfocalOptimizationInitialPoint;

         mutable std::atomic<size_t> ConfocalOptimizationNumStepsPerformed = 0;                      // To be accessed by ConfocalOptimizationThread and WidefieldMicroscope thread.

         mutable std::atomic_bool ConfocalOptimizationPromisesRenewed = false;                       // To be accessed by ConfocalOptimizationThread and WidefieldMicroscope thread.

         std::promise<ConfocalOptimizationStateType> ConfocalOptimizationStatePromise;               // To be solely accessed by ConfocalOptimizationThread.

         std::future<ConfocalOptimizationStateType> ConfocalOptimizationStateFuture;                 // To be solely accessed by WidefieldMicroscope thread.

         mutable std::promise<ConfocalOptimizationFeedbackType> ConfocalOptimizationFeedbackPromise; // To be solely accessed by WidefieldMicroscope thread.

         std::future<ConfocalOptimizationFeedbackType> ConfocalOptimizationFeedbackFuture;           // To be solely accessed by ConfocalOptimizationThread.

         std::future<ConfocalOptimizationThreadReturnType> ConfocalOptimizationThreadReturnFuture;   // To be solely accessed by WidefieldMicroscope thread.


         // Variables for switching from a confocal to a widefield setup.

         std::chrono::system_clock::time_point SetupTransitionFinishedTimePoint;

         bool TurnOnPumpSourceAfterTransitioning = false;


         // Variables for widefield image capturing.

         mutable bool ImageCapturingPaused = false;


         // Variables for managing wait times within measurements.

         mutable std::chrono::system_clock::time_point WaitingEndTimePoint;

         mutable std::chrono::microseconds HBTIntegrationTimeBeforeReset{ 0 };


         // General

         size_t NumFailedUpdateAttempts = 0;

         mutable bool LogUIMessagesOnly = false;

     };

 }

DynExpCore.h
Defines DynExp's core module as an interface between the UI and DynExp objects.

WidefieldMicroscopeWidget.h
User interface belonging to the DynExpModule::Widefield::WidefieldMicroscope module.

DynExpInstr::CameraData::TimeType
std::chrono::milliseconds TimeType
Time type describing the camera's times like its exposure time.
Definition: Camera.h:101

DynExpInstr::CircularDataStream::SampleType
SampleT SampleType
Alias for SampleT.
Definition: DataStreamInstrument.h:361

DynExpInstr::PositionerStageData::PositionType
signed long long PositionType
Numeric type to store the stage positions.
Definition: Stage.h:71

DynExpModule::Widefield::WidefieldMicroscopeConfigurator
Definition: WidefieldMicroscope.h:534

DynExpModule::Widefield::WidefieldMicroscopeConfigurator::~WidefieldMicroscopeConfigurator
virtual ~WidefieldMicroscopeConfigurator()=default

DynExpModule::Widefield::WidefieldMicroscopeConfigurator::WidefieldMicroscopeConfigurator
WidefieldMicroscopeConfigurator()=default

DynExpModule::Widefield::WidefieldMicroscopeConfigurator::MakeParams
virtual DynExp::ParamsBasePtrType MakeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore &Core) const override final
Override to make derived classes call DynExp::MakeParams with the correct configurator type derived f...
Definition: WidefieldMicroscope.h:543

DynExpModule::Widefield::WidefieldMicroscopeData
Definition: WidefieldMicroscope.h:29

DynExpModule::Widefield::WidefieldMicroscopeData::SetCellID
void SetCellID(const DynExpInstr::WidefieldLocalizationCellIDType &CellID)
Definition: WidefieldMicroscope.h:209

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureHBTEnabled
bool AutoMeasureHBTEnabled
Definition: WidefieldMicroscope.h:442

DynExpModule::Widefield::WidefieldMicroscopeData::IsCellRangeValid
bool IsCellRangeValid() const noexcept
Definition: WidefieldMicroscope.cpp:267

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanDistPerPixel
int GetConfocalScanDistPerPixel() const noexcept
Definition: WidefieldMicroscope.h:233

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureMaxOptimizationReruns
int AutoMeasureMaxOptimizationReruns
Definition: WidefieldMicroscope.h:445

DynExpModule::Widefield::WidefieldMicroscopeData::HaveLocalizedPositionsStateChanged
bool HaveLocalizedPositionsStateChanged() const noexcept
Definition: WidefieldMicroscope.h:225

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleHomePosition
const PositionPoint & GetSampleHomePosition() const noexcept
Definition: WidefieldMicroscope.h:227

DynExpModule::Widefield::WidefieldMicroscopeData::GetMinCameraExposureTime
CameraTimeType GetMinCameraExposureTime() const noexcept
Definition: WidefieldMicroscope.h:190

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedPositionsChanged
bool LocalizedPositionsChanged
Definition: WidefieldMicroscope.h:396

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureOptimizationMaxDistance
void SetAutoMeasureOptimizationMaxDistance(int OptimizationMaxDistance) noexcept
Definition: WidefieldMicroscope.h:321

DynExpModule::Widefield::WidefieldMicroscopeData::SetSPD2SamplesWritten
void SetSPD2SamplesWritten(size_t SamplesWritten) noexcept
Definition: WidefieldMicroscope.h:246

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureSpectrumEnabled
void SetAutoMeasureSpectrumEnabled(bool Enabled) noexcept
Definition: WidefieldMicroscope.h:307

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedPositions
LocalizedPositionsMapType LocalizedPositions
Definition: WidefieldMicroscope.h:395

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureSpectrumEnabled
bool AutoMeasureSpectrumEnabled
Definition: WidefieldMicroscope.h:441

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentOptimizationRerun
auto GetAutoMeasureCurrentOptimizationRerun() const noexcept
Definition: WidefieldMicroscope.h:317

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureNumOptimizationAttempts
int AutoMeasureNumOptimizationAttempts
Definition: WidefieldMicroscope.h:443

DynExpModule::Widefield::WidefieldMicroscopeData::SampleStageZ
DynExp::LinkedObjectWrapperContainer< DynExpInstr::PositionerStage > SampleStageZ
Definition: WidefieldMicroscope.h:349

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleFocusPiezoZ
auto & GetSampleFocusPiezoZ() noexcept
Definition: WidefieldMicroscope.h:118

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleFocusPiezoZ
auto & GetSampleFocusPiezoZ() const noexcept
Definition: WidefieldMicroscope.h:119

DynExpModule::Widefield::WidefieldMicroscopeData::GetLastCellID
const auto & GetLastCellID() const noexcept
Definition: WidefieldMicroscope.h:208

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldCamera
auto & GetWidefieldCamera() const noexcept
Definition: WidefieldMicroscope.h:135

DynExpModule::Widefield::WidefieldMicroscopeData::HBTBinCount
size_t HBTBinCount
Definition: WidefieldMicroscope.h:420

DynExpModule::Widefield::WidefieldMicroscopeData::SetMaxFocusVoltage
void SetMaxFocusVoltage(double MaxVoltage) noexcept
Definition: WidefieldMicroscope.h:179

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpPowerIndicator
auto & GetPumpPowerIndicator() noexcept
Definition: WidefieldMicroscope.h:132

DynExpModule::Widefield::WidefieldMicroscopeData::SampleHomePosition
PositionPoint SampleHomePosition
Location set by the user as a home position in nm.
Definition: WidefieldMicroscope.h:400

DynExpModule::Widefield::WidefieldMicroscopeData::SetFocusZeroVoltage
void SetFocusZeroVoltage(double ZeroVoltage) noexcept
Definition: WidefieldMicroscope.h:183

DynExpModule::Widefield::WidefieldMicroscopeData::FocusCurrentVoltage
double FocusCurrentVoltage
Definition: WidefieldMicroscope.h:378

DynExpModule::Widefield::WidefieldMicroscopeData::HasConfocalScanSurfacePlotRows
bool HasConfocalScanSurfacePlotRows() const noexcept
Definition: WidefieldMicroscope.h:255

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureNumOptimizationAttempts
void SetAutoMeasureNumOptimizationAttempts(int NumOptimizationAttempts) noexcept
Definition: WidefieldMicroscope.h:311

DynExpModule::Widefield::WidefieldMicroscopeData::SetWidefieldPosition
void SetWidefieldPosition(const PositionPoint &Position) noexcept
Definition: WidefieldMicroscope.h:201

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedPositionsStateChanged
bool LocalizedPositionsStateChanged
Definition: WidefieldMicroscope.h:397

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTNumEventCounts
auto GetHBTNumEventCounts() const noexcept
Definition: WidefieldMicroscope.h:275

DynExpModule::Widefield::WidefieldMicroscopeData::SetMinCameraExposureTime
void SetMinCameraExposureTime(CameraTimeType Time) noexcept
Definition: WidefieldMicroscope.h:191

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldLocalizer
auto & GetWidefieldLocalizer() const noexcept
Definition: WidefieldMicroscope.h:137

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureNumOptimizationAttempts
auto GetAutoMeasureNumOptimizationAttempts() const noexcept
Definition: WidefieldMicroscope.h:310

DynExpModule::Widefield::WidefieldMicroscopeData::GetMeasuredPumpPower
double GetMeasuredPumpPower() const noexcept
Definition: WidefieldMicroscope.h:174

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureHBTEnabled
auto GetAutoMeasureHBTEnabled() const noexcept
Definition: WidefieldMicroscope.h:308

DynExpModule::Widefield::WidefieldMicroscopeData::HBTTotalIntegrationTime
std::chrono::microseconds HBTTotalIntegrationTime
Definition: WidefieldMicroscope.h:424

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureInitialImageSetWaitTime
std::chrono::seconds AutoMeasureInitialImageSetWaitTime
Definition: WidefieldMicroscope.h:437

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageY
auto & GetSampleStageY() const noexcept
Definition: WidefieldMicroscope.h:115

DynExpModule::Widefield::WidefieldMicroscopeData::SetFocusConfocalOffsetVoltage
void SetFocusConfocalOffsetVoltage(double ConfocalOffsetVoltage) noexcept
Definition: WidefieldMicroscope.h:185

DynExpModule::Widefield::WidefieldMicroscopeData::ClearLocalizedPositions
void ClearLocalizedPositions()
Definition: WidefieldMicroscope.cpp:248

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD1
auto & GetSPD1() const noexcept
Definition: WidefieldMicroscope.h:139

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldHBTSwitch
auto & GetWidefieldHBTSwitch() const noexcept
Definition: WidefieldMicroscope.h:129

DynExpModule::Widefield::WidefieldMicroscopeData::GetMaxCameraExposureTime
CameraTimeType GetMaxCameraExposureTime() const noexcept
Definition: WidefieldMicroscope.h:192

DynExpModule::Widefield::WidefieldMicroscopeData::GetFocusCurrentVoltage
double GetFocusCurrentVoltage() const noexcept
Definition: WidefieldMicroscope.h:180

DynExpModule::Widefield::WidefieldMicroscopeData::GetCurrentImage
const QImage & GetCurrentImage() const noexcept
Definition: WidefieldMicroscope.h:203

DynExpModule::Widefield::WidefieldMicroscopeData::ClearHBTDataPoints
void ClearHBTDataPoints()
Definition: WidefieldMicroscope.h:281

DynExpModule::Widefield::WidefieldMicroscopeData::ClearConfocalScanSurfacePlotRows
void ClearConfocalScanSurfacePlotRows()
Definition: WidefieldMicroscope.h:256

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentImageSet
auto GetAutoMeasureCurrentImageSet() const noexcept
Definition: WidefieldMicroscope.h:295

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentEmitter
auto GetAutoMeasureCurrentEmitter() const noexcept
Definition: WidefieldMicroscope.h:337

DynExpModule::Widefield::WidefieldMicroscopeData::ResetAutoMeasureCurrentImageSet
void ResetAutoMeasureCurrentImageSet() noexcept
Definition: WidefieldMicroscope.h:297

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageZ
auto & GetSampleStageZ() noexcept
Definition: WidefieldMicroscope.h:116

DynExpModule::Widefield::WidefieldMicroscopeData::GetNumFailedLocalizedPositions
size_t GetNumFailedLocalizedPositions() const
Definition: WidefieldMicroscope.cpp:227

DynExpModule::Widefield::WidefieldMicroscopeData::LastCellID
DynExpInstr::WidefieldLocalizationCellIDType LastCellID
Definition: WidefieldMicroscope.h:394

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterType::Position
QPoint Position
Definition: WidefieldMicroscope.h:42

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureInitialImageSetWaitTime
void SetAutoMeasureInitialImageSetWaitTime(std::chrono::seconds Time) noexcept
Definition: WidefieldMicroscope.h:299

DynExpModule::Widefield::WidefieldMicroscopeData::ResetAutoMeasureCurrentOptimizationRerun
void ResetAutoMeasureCurrentOptimizationRerun() noexcept
Definition: WidefieldMicroscope.h:319

DynExpModule::Widefield::WidefieldMicroscopeData::LEDSwitch
DynExp::LinkedObjectWrapperContainer< DynExpInstr::DigitalOut > LEDSwitch
Definition: WidefieldMicroscope.h:351

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldConfocalSwitch
DynExp::LinkedObjectWrapperContainer< DynExpInstr::DigitalOut > WidefieldConfocalSwitch
Definition: WidefieldMicroscope.h:353

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalScanWidth
int ConfocalScanWidth
Definition: WidefieldMicroscope.h:401

DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedEmitterColor
static QColor GetLocalizedEmitterColor(LocalizedEmitterStateType State)
Definition: WidefieldMicroscope.cpp:76

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTSamplePosition
const PositionPoint & GetHBTSamplePosition() const noexcept
Definition: WidefieldMicroscope.h:273

DynExpModule::Widefield::WidefieldMicroscopeData::GetLEDSwitch
auto & GetLEDSwitch() noexcept
Definition: WidefieldMicroscope.h:120

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldConfocalIndicator
auto & GetWidefieldConfocalIndicator() noexcept
Definition: WidefieldMicroscope.h:126

DynExpModule::Widefield::WidefieldMicroscopeData::FocusZeroVoltage
double FocusZeroVoltage
Definition: WidefieldMicroscope.h:379

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalScanHeight
int ConfocalScanHeight
Definition: WidefieldMicroscope.h:402

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanResults
const auto & GetConfocalScanResults() const noexcept
Definition: WidefieldMicroscope.h:251

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTBinWidth
void SetHBTBinWidth(Util::picoseconds BinWidth) noexcept
Definition: WidefieldMicroscope.h:268

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellRangeFrom
auto & GetAutoMeasureCellRangeFrom() noexcept
Definition: WidefieldMicroscope.h:325

DynExpModule::Widefield::WidefieldMicroscopeData::MinCameraExposureTime
CameraTimeType MinCameraExposureTime
Definition: WidefieldMicroscope.h:384

DynExpModule::Widefield::WidefieldMicroscopeData::FocusPiezoZ
DynExp::LinkedObjectWrapperContainer< DynExpInstr::AnalogOut > FocusPiezoZ
Definition: WidefieldMicroscope.h:350

DynExpModule::Widefield::WidefieldMicroscopeData::SetCurrentImage
void SetCurrentImage(QImage &&Image)
Definition: WidefieldMicroscope.h:204

DynExpModule::Widefield::WidefieldMicroscopeData::IsAutoMeasureRunning
bool IsAutoMeasureRunning() const noexcept
Definition: WidefieldMicroscope.h:287

DynExpModule::Widefield::WidefieldMicroscopeData::LEDLightTurnedOn
bool LEDLightTurnedOn
Definition: WidefieldMicroscope.h:369

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureImagePositionScatterRadius
void SetAutoMeasureImagePositionScatterRadius(int ScatterRadius) noexcept
Definition: WidefieldMicroscope.h:301

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD1
auto & GetSPD1() noexcept
Definition: WidefieldMicroscope.h:138

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureHBTEnabled
void SetAutoMeasureHBTEnabled(bool Enabled) noexcept
Definition: WidefieldMicroscope.h:309

DynExpModule::Widefield::WidefieldMicroscopeData::ResetLocalizedPositionsChanged
void ResetLocalizedPositionsChanged() noexcept
Definition: WidefieldMicroscope.h:222

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldCameraExposureTime
CameraTimeType WidefieldCameraExposureTime
Definition: WidefieldMicroscope.h:387

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalOptimizationInitXYStepSize
double GetConfocalOptimizationInitXYStepSize() const noexcept
Definition: WidefieldMicroscope.h:258

DynExpModule::Widefield::WidefieldMicroscopeData::MaxCameraExposureTime
CameraTimeType MaxCameraExposureTime
Definition: WidefieldMicroscope.h:385

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureSavePath
std::filesystem::path AutoMeasureSavePath
Definition: WidefieldMicroscope.h:433

DynExpModule::Widefield::WidefieldMicroscopeData::SampleStageX
DynExp::LinkedObjectWrapperContainer< DynExpInstr::PositionerStage > SampleStageX
Definition: WidefieldMicroscope.h:347

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldPumpPower
double WidefieldPumpPower
Definition: WidefieldMicroscope.h:373

DynExpModule::Widefield::WidefieldMicroscopeData::WriteConfocalScanResults
void WriteConfocalScanResults(std::stringstream &Stream) const
Definition: WidefieldMicroscope.cpp:178

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldPumpPower
double GetWidefieldPumpPower() const noexcept
Definition: WidefieldMicroscope.h:170

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalOptimizationInitXYStepSize
void SetConfocalOptimizationInitXYStepSize(double StepSize) noexcept
Definition: WidefieldMicroscope.h:259

DynExpModule::Widefield::WidefieldMicroscopeData::SetSPD2Ready
void SetSPD2Ready(double Value) noexcept
Definition: WidefieldMicroscope.h:247

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalScanSurfacePlotRows
QSurfaceDataRowsType ConfocalScanSurfacePlotRows
Definition: WidefieldMicroscope.h:416

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalScanResults
std::vector< std::pair< PositionPoint, double > > ConfocalScanResults
Definition: WidefieldMicroscope.h:415

DynExpModule::Widefield::WidefieldMicroscopeData::GetMinFocusVoltage
double GetMinFocusVoltage() const noexcept
Definition: WidefieldMicroscope.h:176

DynExpModule::Widefield::WidefieldMicroscopeData::SetUIMessage
void SetUIMessage(const std::string &Message)
Definition: WidefieldMicroscope.h:152

DynExpModule::Widefield::WidefieldMicroscopeData::ResetImpl
virtual void ResetImpl(dispatch_tag< WidefieldMicroscopeData >)
Definition: WidefieldMicroscope.h:343

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTDataPointsMaxValues
auto GetHBTDataPointsMaxValues() const noexcept
Definition: WidefieldMicroscope.h:284

DynExpModule::Widefield::WidefieldMicroscopeData::CurrentImage
QImage CurrentImage
Definition: WidefieldMicroscope.h:391

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCellRangeTo
QPoint AutoMeasureCellRangeTo
Definition: WidefieldMicroscope.h:450

DynExpModule::Widefield::WidefieldMicroscopeData::~WidefieldMicroscopeData
virtual ~WidefieldMicroscopeData()=default

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTDataPointsMinValues
auto GetHBTDataPointsMinValues() const noexcept
Definition: WidefieldMicroscope.h:282

DynExpModule::Widefield::WidefieldMicroscopeData::ClearUIMessage
void ClearUIMessage()
Definition: WidefieldMicroscope.h:153

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTNumEventCounts
void SetHBTNumEventCounts(long long NumEventCounts) noexcept
Definition: WidefieldMicroscope.h:276

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTBinWidth
auto GetHBTBinWidth() const noexcept
Definition: WidefieldMicroscope.h:267

DynExpModule::Widefield::WidefieldMicroscopeData::SPD2
DynExp::LinkedObjectWrapperContainer< DynExpInstr::TimeTagger > SPD2
Definition: WidefieldMicroscope.h:361

DynExpModule::Widefield::WidefieldMicroscopeData::HBTBinWidth
Util::picoseconds HBTBinWidth
Definition: WidefieldMicroscope.h:419

DynExpModule::Widefield::WidefieldMicroscopeData::ResetCellID
void ResetCellID()
Definition: WidefieldMicroscope.h:212

DynExpModule::Widefield::WidefieldMicroscopeData::IncrementAutoMeasureCurrentEmitter
auto IncrementAutoMeasureCurrentEmitter() noexcept
Definition: WidefieldMicroscope.h:339

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureLocalizationType
WidefieldMicroscopeWidget::LocalizationType AutoMeasureLocalizationType
Definition: WidefieldMicroscope.h:439

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldPosition
PositionPoint WidefieldPosition
Location where the current widefield image has been taken in nm.
Definition: WidefieldMicroscope.h:389

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCurrentEmitter
LocalizedPositionsMapType::iterator AutoMeasureCurrentEmitter
Iterator to the emitter being characterized.
Definition: WidefieldMicroscope.h:453

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCountRateThreshold
int AutoMeasureCountRateThreshold
Definition: WidefieldMicroscope.h:448

DynExpModule::Widefield::WidefieldMicroscopeData::MeasuredPumpPower
double MeasuredPumpPower
Definition: WidefieldMicroscope.h:375

DynExpModule::Widefield::WidefieldMicroscopeData::SampleStageY
DynExp::LinkedObjectWrapperContainer< DynExpInstr::PositionerStage > SampleStageY
Definition: WidefieldMicroscope.h:348

DynExpModule::Widefield::WidefieldMicroscopeData::HBTDataPoints
QList< QPointF > HBTDataPoints
Definition: WidefieldMicroscope.h:427

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureNumberImageSets
auto GetAutoMeasureNumberImageSets() const noexcept
Definition: WidefieldMicroscope.h:293

DynExpModule::Widefield::WidefieldMicroscopeData::CurrentCellID
DynExpInstr::WidefieldLocalizationCellIDType CurrentCellID
Definition: WidefieldMicroscope.h:393

DynExpModule::Widefield::WidefieldMicroscopeData::HBTMaxIntegrationTime
std::chrono::microseconds HBTMaxIntegrationTime
Definition: WidefieldMicroscope.h:421

DynExpModule::Widefield::WidefieldMicroscopeData::MaxPumpPower
double MaxPumpPower
Definition: WidefieldMicroscope.h:372

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterStateType
LocalizedEmitterStateType
Definition: WidefieldMicroscope.h:38

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterStateType::Characterizing
@ Characterizing

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterStateType::Finished
@ Finished

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterStateType::Failed
@ Failed

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterStateType::NotSet
@ NotSet

DynExpModule::Widefield::WidefieldMicroscopeData::Features
Util::FeatureTester< FeatureType > Features
Definition: WidefieldMicroscope.h:364

DynExpModule::Widefield::WidefieldMicroscopeData::SetMeasuredPumpPower
void SetMeasuredPumpPower(double MeasuredPower) noexcept
Definition: WidefieldMicroscope.h:175

DynExpModule::Widefield::WidefieldMicroscopeData::GetSetupMode
SetupModeType GetSetupMode() const noexcept
Definition: WidefieldMicroscope.h:160

DynExpModule::Widefield::WidefieldMicroscopeData::GetLEDSwitch
auto & GetLEDSwitch() const noexcept
Definition: WidefieldMicroscope.h:121

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureFirstEmitter
bool SetAutoMeasureFirstEmitter(Util::MarkerGraphicsView::MarkerType::IDType FirstEmitterID) noexcept
Returns true in case of success, false otherwise.
Definition: WidefieldMicroscope.cpp:297

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTDataPoints
auto & GetHBTDataPoints() noexcept
Definition: WidefieldMicroscope.h:279

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalPumpPower
double ConfocalPumpPower
Definition: WidefieldMicroscope.h:374

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentOptimizationAttempt
auto GetAutoMeasureCurrentOptimizationAttempt() const noexcept
Definition: WidefieldMicroscope.h:312

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalOptimizationInitZStepSize
double ConfocalOptimizationInitZStepSize
Definition: WidefieldMicroscope.h:410

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpSwitch
auto & GetPumpSwitch() const noexcept
Definition: WidefieldMicroscope.h:123

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType
FeatureType
Definition: WidefieldMicroscope.h:31

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::PumpLightToggle
@ PumpLightToggle

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::LEDLightToggle
@ LEDLightToggle

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::NUM_ELEMENTS
@ NUM_ELEMENTS

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::Confocal
@ Confocal

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::HBTSwitch
@ HBTSwitch

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::ConfocalOptimization
@ ConfocalOptimization

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::FocusAdjustment
@ FocusAdjustment

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::Widefield
@ Widefield

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::InterModuleCommunicator
@ InterModuleCommunicator

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::HBT
@ HBT

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::WidefieldLocalization
@ WidefieldLocalization

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::SetPumpPower
@ SetPumpPower

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::WidefieldConfocalIndicator
@ WidefieldConfocalIndicator

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::SampleXYPositioning
@ SampleXYPositioning

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::WidefieldConfocalSwitch
@ WidefieldConfocalSwitch

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::SampleZPositioning
@ SampleZPositioning

DynExpModule::Widefield::WidefieldMicroscopeData::FeatureType::MeasurePumpPower
@ MeasurePumpPower

DynExpModule::Widefield::WidefieldMicroscopeData::ClearConfocalScanResults
void ClearConfocalScanResults()
Definition: WidefieldMicroscope.h:252

DynExpModule::Widefield::WidefieldMicroscopeData::HBTNumEventCounts
long long HBTNumEventCounts
Definition: WidefieldMicroscope.h:423

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureOptimizationMaxDistance
auto GetAutoMeasureOptimizationMaxDistance() const noexcept
Definition: WidefieldMicroscope.h:320

DynExpModule::Widefield::WidefieldMicroscopeData::IncrementAutoMeasureCurrentOptimizationAttempt
auto IncrementAutoMeasureCurrentOptimizationAttempt() noexcept
Definition: WidefieldMicroscope.h:313

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureFirstEmitter
LocalizedPositionsMapType::iterator AutoMeasureFirstEmitter
Iterator to the first emitter to be characterized.
Definition: WidefieldMicroscope.h:452

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalPumpPower
void SetConfocalPumpPower(double Power) noexcept
Definition: WidefieldMicroscope.h:173

DynExpModule::Widefield::WidefieldMicroscopeData::SetMinFocusVoltage
void SetMinFocusVoltage(double MinVoltage) noexcept
Definition: WidefieldMicroscope.h:177

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureCurrentCellPosition
void SetAutoMeasureCurrentCellPosition(const PositionPoint &Position) noexcept
Definition: WidefieldMicroscope.h:292

DynExpModule::Widefield::WidefieldMicroscopeData::GetFocusZeroVoltage
double GetFocusZeroVoltage() const noexcept
Definition: WidefieldMicroscope.h:182

DynExpModule::Widefield::WidefieldMicroscopeData::IsCurrentImageAvlbl
bool IsCurrentImageAvlbl() const
Definition: WidefieldMicroscope.h:205

DynExpModule::Widefield::WidefieldMicroscopeData::SetFeature
void SetFeature(FeatureType Flag)
Definition: WidefieldMicroscope.h:149

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureImagePositionScatterRadius
int GetAutoMeasureImagePositionScatterRadius() const noexcept
Definition: WidefieldMicroscope.h:300

DynExpModule::Widefield::WidefieldMicroscopeData::IncrementAutoMeasureCurrentOptimizationRerun
auto IncrementAutoMeasureCurrentOptimizationRerun() noexcept
Definition: WidefieldMicroscope.h:318

DynExpModule::Widefield::WidefieldMicroscopeData::SetSetupMode
void SetSetupMode(SetupModeType NewMode) noexcept
Definition: WidefieldMicroscope.h:161

DynExpModule::Widefield::WidefieldMicroscopeData::SetLEDCameraExposureTime
void SetLEDCameraExposureTime(CameraTimeType Time) noexcept
Definition: WidefieldMicroscope.h:195

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureMaxOptimizationReruns
void SetAutoMeasureMaxOptimizationReruns(int MaxOptimizationReruns) noexcept
Definition: WidefieldMicroscope.h:316

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalScanDistPerPixel
void SetConfocalScanDistPerPixel(int DistPerPixel) noexcept
Definition: WidefieldMicroscope.h:234

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalOptimizationTolerance
void SetConfocalOptimizationTolerance(double Tolerance) noexcept
Definition: WidefieldMicroscope.h:263

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD2
auto & GetSPD2() noexcept
Definition: WidefieldMicroscope.h:140

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellRangeTo
auto & GetAutoMeasureCellRangeTo() const noexcept
Definition: WidefieldMicroscope.h:326

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalSpotImagePosition
void SetConfocalSpotImagePosition(const QPoint &Position) noexcept
Definition: WidefieldMicroscope.h:199

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpPower
auto & GetPumpPower() const noexcept
Definition: WidefieldMicroscope.h:131

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalScanWidth
void SetConfocalScanWidth(int Width) noexcept
Definition: WidefieldMicroscope.h:230

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalOptimizationTolerance
double ConfocalOptimizationTolerance
Definition: WidefieldMicroscope.h:411

DynExpModule::Widefield::WidefieldMicroscopeData::SetWidefieldPumpPower
void SetWidefieldPumpPower(double Power) noexcept
Definition: WidefieldMicroscope.h:171

DynExpModule::Widefield::WidefieldMicroscopeData::SetupModeType
SetupModeType
Definition: WidefieldMicroscope.h:37

DynExpModule::Widefield::WidefieldMicroscopeData::SetupModeType::Confocal
@ Confocal

DynExpModule::Widefield::WidefieldMicroscopeData::SetupModeType::Widefield
@ Widefield

DynExpModule::Widefield::WidefieldMicroscopeData::SetupModeType::Unknown
@ Unknown

DynExpModule::Widefield::WidefieldMicroscopeData::SetSPD1Ready
void SetSPD1Ready(double Value) noexcept
Definition: WidefieldMicroscope.h:241

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageY
auto & GetSampleStageY() noexcept
Definition: WidefieldMicroscope.h:114

DynExpModule::Widefield::WidefieldMicroscopeData::GetAcqCommunicator
auto & GetAcqCommunicator() const noexcept
Definition: WidefieldMicroscope.h:143

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldConfocalIndicator
auto & GetWidefieldConfocalIndicator() const noexcept
Definition: WidefieldMicroscope.h:127

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureMaxOptimizationReruns
auto GetAutoMeasureMaxOptimizationReruns() const noexcept
Definition: WidefieldMicroscope.h:315

DynExpModule::Widefield::WidefieldMicroscopeData::PumpLightTurnedOn
bool PumpLightTurnedOn
Definition: WidefieldMicroscope.h:370

DynExpModule::Widefield::WidefieldMicroscopeData::GetCellID
const auto & GetCellID() const noexcept
Definition: WidefieldMicroscope.h:207

DynExpModule::Widefield::WidefieldMicroscopeData::GetSamplePosition
PositionPoint GetSamplePosition() const
Returns current sample position.
Definition: WidefieldMicroscope.cpp:91

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD1Ready
bool GetSPD1Ready() const noexcept
Definition: WidefieldMicroscope.h:238

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureInitialImageSetWaitTime
std::chrono::seconds GetAutoMeasureInitialImageSetWaitTime() const noexcept
Definition: WidefieldMicroscope.h:298

DynExpModule::Widefield::WidefieldMicroscopeData::HBTDataPointsMinValues
QPointF HBTDataPointsMinValues
Definition: WidefieldMicroscope.h:428

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCurrentOptimizationAttempt
int AutoMeasureCurrentOptimizationAttempt
Definition: WidefieldMicroscope.h:444

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalPumpPower
double GetConfocalPumpPower() const noexcept
Definition: WidefieldMicroscope.h:172

DynExpModule::Widefield::WidefieldMicroscopeData::PumpPowerIndicator
DynExp::LinkedObjectWrapperContainer< DynExpInstr::AnalogIn > PumpPowerIndicator
Definition: WidefieldMicroscope.h:357

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTMaxIntegrationTime
void SetHBTMaxIntegrationTime(std::chrono::microseconds MaxIntegrationTime) noexcept
Definition: WidefieldMicroscope.h:272

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureCountRateThreshold
void SetAutoMeasureCountRateThreshold(int CountRateThreshold) noexcept
Definition: WidefieldMicroscope.h:323

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpPower
auto & GetPumpPower() noexcept
Definition: WidefieldMicroscope.h:130

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCurrentOptimizationRerun
int AutoMeasureCurrentOptimizationRerun
Definition: WidefieldMicroscope.h:446

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalScanDistPerPixel
int ConfocalScanDistPerPixel
Definition: WidefieldMicroscope.h:403

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTMaxIntegrationTime
auto GetHBTMaxIntegrationTime() const noexcept
Definition: WidefieldMicroscope.h:271

DynExpModule::Widefield::WidefieldMicroscopeData::HasCellID
bool HasCellID() const noexcept
Definition: WidefieldMicroscope.h:213

DynExpModule::Widefield::WidefieldMicroscopeData::LastCountRate
double LastCountRate
Definition: WidefieldMicroscope.h:412

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureOptimizeEnabled
bool AutoMeasureOptimizeEnabled
Definition: WidefieldMicroscope.h:440

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalScanSurfacePlotRows
void SetConfocalScanSurfacePlotRows(QSurfaceDataRowsType &&QSurfaceDataRows) noexcept
Definition: WidefieldMicroscope.h:254

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalSpotImagePosition
QPoint ConfocalSpotImagePosition
Location of confocal spot in units of px within widefield image.
Definition: WidefieldMicroscope.h:388

DynExpModule::Widefield::WidefieldMicroscopeData::SPD1State
SPDStateType SPD1State
Definition: WidefieldMicroscope.h:405

DynExpModule::Widefield::WidefieldMicroscopeData::IncrementCellID
void IncrementCellID()
Definition: WidefieldMicroscope.cpp:209

DynExpModule::Widefield::WidefieldMicroscopeData::ResetAutoMeasureCurrentOptimizationAttempt
void ResetAutoMeasureCurrentOptimizationAttempt() noexcept
Definition: WidefieldMicroscope.h:314

DynExpModule::Widefield::WidefieldMicroscopeData::CameraTimeType
DynExpInstr::CameraData::TimeType CameraTimeType
Definition: WidefieldMicroscope.h:50

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD1SamplesWritten
auto GetSPD1SamplesWritten() const noexcept
Definition: WidefieldMicroscope.h:237

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldConfocalIndicator
DynExp::LinkedObjectWrapperContainer< DynExpInstr::DigitalIn > WidefieldConfocalIndicator
Definition: WidefieldMicroscope.h:354

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldLocalizer
auto & GetWidefieldLocalizer() noexcept
Definition: WidefieldMicroscope.h:136

DynExpModule::Widefield::WidefieldMicroscopeData::ResetAutoMeasureCurrentEmitter
void ResetAutoMeasureCurrentEmitter() noexcept
Definition: WidefieldMicroscope.cpp:312

DynExpModule::Widefield::WidefieldMicroscopeData::SetPumpLightTurnedOn
void SetPumpLightTurnedOn(bool State)
Definition: WidefieldMicroscope.cpp:203

DynExpModule::Widefield::WidefieldMicroscopeData::ConfocalOptimizationInitXYStepSize
double ConfocalOptimizationInitXYStepSize
Definition: WidefieldMicroscope.h:409

DynExpModule::Widefield::WidefieldMicroscopeData::SetSPD1SamplesWritten
void SetSPD1SamplesWritten(size_t SamplesWritten) noexcept
Definition: WidefieldMicroscope.h:240

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPDExposureTime
SPDTimeType GetSPDExposureTime() const noexcept
Definition: WidefieldMicroscope.h:235

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTDataPoints
const auto & GetHBTDataPoints() const noexcept
Definition: WidefieldMicroscope.h:280

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpSwitch
auto & GetPumpSwitch() noexcept
Definition: WidefieldMicroscope.h:122

DynExpModule::Widefield::WidefieldMicroscopeData::ClearLocalizedPositionsStateChanged
void ClearLocalizedPositionsStateChanged()
Definition: WidefieldMicroscope.h:224

DynExpModule::Widefield::WidefieldMicroscopeData::SetMaxCameraExposureTime
void SetMaxCameraExposureTime(CameraTimeType Time) noexcept
Definition: WidefieldMicroscope.h:193

DynExpModule::Widefield::WidefieldMicroscopeData::GetLEDLightTurnedOn
bool GetLEDLightTurnedOn() const noexcept
Definition: WidefieldMicroscope.h:162

DynExpModule::Widefield::WidefieldMicroscopeData::PositionType
DynExpInstr::PositionerStageData::PositionType PositionType
Definition: WidefieldMicroscope.h:49

DynExpModule::Widefield::WidefieldMicroscopeData::GetFocusConfocalOffsetVoltage
double GetFocusConfocalOffsetVoltage() const noexcept
Definition: WidefieldMicroscope.h:184

DynExpModule::Widefield::WidefieldMicroscopeData::GetAcqCommunicator
auto & GetAcqCommunicator() noexcept
Definition: WidefieldMicroscope.h:142

DynExpModule::Widefield::WidefieldMicroscopeData::SPDTimeType
std::chrono::milliseconds SPDTimeType
Definition: WidefieldMicroscope.h:52

DynExpModule::Widefield::WidefieldMicroscopeData::IsAutofocusFinished
bool IsAutofocusFinished() const noexcept
Definition: WidefieldMicroscope.h:186

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageX
auto & GetSampleStageX() const noexcept
Definition: WidefieldMicroscope.h:113

DynExpModule::Widefield::WidefieldMicroscopeData::PumpSwitch
DynExp::LinkedObjectWrapperContainer< DynExpInstr::DigitalOut > PumpSwitch
Definition: WidefieldMicroscope.h:352

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureFirstEmitter
auto GetAutoMeasureFirstEmitter() const noexcept
Definition: WidefieldMicroscope.h:335

DynExpModule::Widefield::WidefieldMicroscopeData::MinPumpPower
double MinPumpPower
Definition: WidefieldMicroscope.h:371

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureOptimizeEnabled
void SetAutoMeasureOptimizeEnabled(bool Enabled) noexcept
Definition: WidefieldMicroscope.h:305

DynExpModule::Widefield::WidefieldMicroscopeData::HBTDataPointsMaxValues
QPointF HBTDataPointsMaxValues
Definition: WidefieldMicroscope.h:429

DynExpModule::Widefield::WidefieldMicroscopeData::QSurfaceDataRowsType
std::vector< std::unique_ptr< QSurfaceDataRow > > QSurfaceDataRowsType
Definition: WidefieldMicroscope.h:53

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentCellIndex
int GetAutoMeasureCurrentCellIndex() const
Definition: WidefieldMicroscope.cpp:288

DynExpModule::Widefield::WidefieldMicroscopeData::ResetSPD1State
void ResetSPD1State() noexcept
Definition: WidefieldMicroscope.h:242

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanHeight
int GetConfocalScanHeight() const noexcept
Definition: WidefieldMicroscope.h:231

DynExpModule::Widefield::WidefieldMicroscopeData::MinFocusVoltage
double MinFocusVoltage
Definition: WidefieldMicroscope.h:376

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTDataPointsMinValues
void SetHBTDataPointsMinValues(const QPointF &DataPointsMinValues) noexcept
Definition: WidefieldMicroscope.h:283

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTSamplePosition
void SetHBTSamplePosition(const PositionPoint &Position) noexcept
Definition: WidefieldMicroscope.h:274

DynExpModule::Widefield::WidefieldMicroscopeData::UIMessage
std::string UIMessage
Definition: WidefieldMicroscope.h:365

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellSkip
auto & GetAutoMeasureCellSkip() noexcept
Definition: WidefieldMicroscope.h:334

DynExpModule::Widefield::WidefieldMicroscopeData::SetFocusCurrentVoltage
void SetFocusCurrentVoltage(double CurrentVoltage) noexcept
Definition: WidefieldMicroscope.h:181

DynExpModule::Widefield::WidefieldMicroscopeData::SetMinPumpPower
void SetMinPumpPower(double MinPower) noexcept
Definition: WidefieldMicroscope.h:167

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD2Value
auto GetSPD2Value() const noexcept
Definition: WidefieldMicroscope.h:245

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureNumberImageSets
void SetAutoMeasureNumberImageSets(int NumberImageSets) noexcept
Definition: WidefieldMicroscope.h:294

DynExpModule::Widefield::WidefieldMicroscopeData::GetNumFinishedLocalizedPositions
size_t GetNumFinishedLocalizedPositions() const
Definition: WidefieldMicroscope.cpp:220

DynExpModule::Widefield::WidefieldMicroscopeData::FocusConfocalOffsetVoltage
double FocusConfocalOffsetVoltage
Definition: WidefieldMicroscope.h:380

DynExpModule::Widefield::WidefieldMicroscopeData::SetSampleHomePosition
void SetSampleHomePosition(const PositionPoint &Position) noexcept
Definition: WidefieldMicroscope.h:228

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellRangeTo
auto & GetAutoMeasureCellRangeTo() noexcept
Definition: WidefieldMicroscope.h:327

DynExpModule::Widefield::WidefieldMicroscopeData::HaveLocalizedPositionsChanged
bool HaveLocalizedPositionsChanged() const noexcept
Definition: WidefieldMicroscope.h:221

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldCamera
DynExp::LinkedObjectWrapperContainer< DynExpInstr::Camera > WidefieldCamera
Definition: WidefieldMicroscope.h:358

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCurrentCellPosition
PositionPoint AutoMeasureCurrentCellPosition
Center position of the current cell in nm where an automated measurement takes place.
Definition: WidefieldMicroscope.h:434

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellColumnLength
int GetAutoMeasureCellColumnLength() const noexcept
Definition: WidefieldMicroscope.cpp:278

DynExpModule::Widefield::WidefieldMicroscopeData::AutofocusFinished
bool AutofocusFinished
Definition: WidefieldMicroscope.h:381

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellCount
int GetAutoMeasureCellCount() const noexcept
Definition: WidefieldMicroscope.cpp:283

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTTotalIntegrationTime
void SetHBTTotalIntegrationTime(std::chrono::microseconds TotalIntegrationTime) noexcept
Definition: WidefieldMicroscope.h:278

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureLocalizationType
void SetAutoMeasureLocalizationType(WidefieldMicroscopeWidget::LocalizationType LocalizationType) noexcept
Definition: WidefieldMicroscope.h:303

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanWidth
int GetConfocalScanWidth() const noexcept
Definition: WidefieldMicroscope.h:229

DynExpModule::Widefield::WidefieldMicroscopeData::ResetImpl
void ResetImpl(dispatch_tag< QModuleDataBase >) override final
Definition: WidefieldMicroscope.cpp:262

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldHBTSwitch
DynExp::LinkedObjectWrapperContainer< DynExpInstr::FunctionGenerator > WidefieldHBTSwitch
Definition: WidefieldMicroscope.h:355

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCellRangeFrom
QPoint AutoMeasureCellRangeFrom
Definition: WidefieldMicroscope.h:449

DynExpModule::Widefield::WidefieldMicroscopeData::GetMinPumpPower
double GetMinPumpPower() const noexcept
Definition: WidefieldMicroscope.h:166

DynExpModule::Widefield::WidefieldMicroscopeData::WriteHBTResults
void WriteHBTResults(std::stringstream &Stream) const
Definition: WidefieldMicroscope.cpp:189

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldMicroscopeData
WidefieldMicroscopeData()
Definition: WidefieldMicroscope.h:109

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpPowerIndicator
auto & GetPumpPowerIndicator() const noexcept
Definition: WidefieldMicroscope.h:133

DynExpModule::Widefield::WidefieldMicroscopeData::SetLocalizedPositions
void SetLocalizedPositions(LocalizedPositionsMapType &&Positions)
Definition: WidefieldMicroscope.cpp:240

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCountRateThreshold
auto GetAutoMeasureCountRateThreshold() const noexcept
Definition: WidefieldMicroscope.h:322

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureLocalizationType
auto GetAutoMeasureLocalizationType() const noexcept
Definition: WidefieldMicroscope.h:302

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureSavePath
void SetAutoMeasureSavePath(std::filesystem::path SavePath) noexcept
Definition: WidefieldMicroscope.h:290

DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedEmitterStateString
static const char * GetLocalizedEmitterStateString(LocalizedEmitterStateType State)
Definition: WidefieldMicroscope.cpp:65

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedPositionsMapType
std::map< Util::MarkerGraphicsView::MarkerType::IDType, LocalizedEmitterType > LocalizedPositionsMapType
Definition: WidefieldMicroscope.h:51

DynExpModule::Widefield::WidefieldMicroscopeData::AppendLocalizedPosition
void AppendLocalizedPosition(LocalizedPositionsMapType::value_type &&Position)
Definition: WidefieldMicroscope.cpp:234

DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedPositions
const auto & GetLocalizedPositions() const noexcept
Definition: WidefieldMicroscope.h:215

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD2
auto & GetSPD2() const noexcept
Definition: WidefieldMicroscope.h:141

DynExpModule::Widefield::WidefieldMicroscopeData::SetLocalizedPositionsStateChanged
void SetLocalizedPositionsStateChanged()
Definition: WidefieldMicroscope.h:223

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD2Ready
bool GetSPD2Ready() const noexcept
Definition: WidefieldMicroscope.h:244

DynExpModule::Widefield::WidefieldMicroscopeData::GetMaxPumpPower
double GetMaxPumpPower() const noexcept
Definition: WidefieldMicroscope.h:168

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldPosition
const PositionPoint & GetWidefieldPosition() const noexcept
Definition: WidefieldMicroscope.h:200

DynExpModule::Widefield::WidefieldMicroscopeData::SetLastCountRate
void SetLastCountRate(double CountRate) noexcept
Definition: WidefieldMicroscope.h:265

DynExpModule::Widefield::WidefieldMicroscopeData::GetLEDCameraExposureTime
CameraTimeType GetLEDCameraExposureTime() const noexcept
Definition: WidefieldMicroscope.h:194

DynExpModule::Widefield::WidefieldMicroscopeData::GetLocalizedPositions
auto & GetLocalizedPositions() noexcept
Definition: WidefieldMicroscope.h:214

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanResults
auto & GetConfocalScanResults() noexcept
Definition: WidefieldMicroscope.h:250

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalOptimizationInitZStepSize
void SetConfocalOptimizationInitZStepSize(double StepSize) noexcept
Definition: WidefieldMicroscope.h:261

DynExpModule::Widefield::WidefieldMicroscopeData::SPDExposureTime
SPDTimeType SPDExposureTime
Definition: WidefieldMicroscope.h:404

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD2SamplesWritten
auto GetSPD2SamplesWritten() const noexcept
Definition: WidefieldMicroscope.h:243

DynExpModule::Widefield::WidefieldMicroscopeData::HBTSamplePosition
PositionPoint HBTSamplePosition
Location in nm where the HBT measurement has been started.
Definition: WidefieldMicroscope.h:422

DynExpModule::Widefield::WidefieldMicroscopeData::LEDCameraExposureTime
CameraTimeType LEDCameraExposureTime
Definition: WidefieldMicroscope.h:386

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalScanSurfacePlotRows
auto GetConfocalScanSurfacePlotRows() noexcept
Definition: WidefieldMicroscope.h:253

DynExpModule::Widefield::WidefieldMicroscopeData::SetupMode
SetupModeType SetupMode
Definition: WidefieldMicroscope.h:368

DynExpModule::Widefield::WidefieldMicroscopeData::SetLEDLightTurnedOn
void SetLEDLightTurnedOn(bool State)
Definition: WidefieldMicroscope.cpp:197

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCurrentImageSet
int AutoMeasureCurrentImageSet
Index of the image set being recorded if auto-measure localization is running, -1 otherwise.
Definition: WidefieldMicroscope.h:436

DynExpModule::Widefield::WidefieldMicroscopeData::CurrentImageChanged
bool CurrentImageChanged
Definition: WidefieldMicroscope.h:392

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageZ
auto & GetSampleStageZ() const noexcept
Definition: WidefieldMicroscope.h:117

DynExpModule::Widefield::WidefieldMicroscopeData::SetConfocalScanHeight
void SetConfocalScanHeight(int Length) noexcept
Definition: WidefieldMicroscope.h:232

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldConfocalSwitch
auto & GetWidefieldConfocalSwitch() noexcept
Definition: WidefieldMicroscope.h:124

DynExpModule::Widefield::WidefieldMicroscopeData::ResetCurrentImageAvlbl
void ResetCurrentImageAvlbl() noexcept
Definition: WidefieldMicroscope.h:206

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTDataPointsMaxValues
void SetHBTDataPointsMaxValues(const QPointF &DataPointsMaxValues) noexcept
Definition: WidefieldMicroscope.h:285

DynExpModule::Widefield::WidefieldMicroscopeData::TestFeature
bool TestFeature(const std::array< FeatureType, N > &Flags) const
Definition: WidefieldMicroscope.h:146

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalOptimizationTolerance
double GetConfocalOptimizationTolerance() const noexcept
Definition: WidefieldMicroscope.h:262

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutoMeasureRunning
void SetAutoMeasureRunning(bool Running) noexcept
Definition: WidefieldMicroscope.h:288

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalSpotImagePosition
QPoint GetConfocalSpotImagePosition() const noexcept
Definition: WidefieldMicroscope.h:198

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellLineLength
int GetAutoMeasureCellLineLength() const noexcept
Definition: WidefieldMicroscope.cpp:273

DynExpModule::Widefield::WidefieldMicroscopeData::SetWidefieldCameraExposureTime
void SetWidefieldCameraExposureTime(CameraTimeType Time) noexcept
Definition: WidefieldMicroscope.h:197

DynExpModule::Widefield::WidefieldMicroscopeData::GetMaxFocusVoltage
double GetMaxFocusVoltage() const noexcept
Definition: WidefieldMicroscope.h:178

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureRunning
bool AutoMeasureRunning
Definition: WidefieldMicroscope.h:432

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureOptimizeEnabled
auto GetAutoMeasureOptimizeEnabled() const noexcept
Definition: WidefieldMicroscope.h:304

DynExpModule::Widefield::WidefieldMicroscopeData::GetPumpLightTurnedOn
bool GetPumpLightTurnedOn() const noexcept
Definition: WidefieldMicroscope.h:164

DynExpModule::Widefield::WidefieldMicroscopeData::SetAutofocusFinished
void SetAutofocusFinished() noexcept
Definition: WidefieldMicroscope.h:187

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellRangeFrom
auto & GetAutoMeasureCellRangeFrom() const noexcept
Definition: WidefieldMicroscope.h:324

DynExpModule::Widefield::WidefieldMicroscopeData::GetSPD1Value
auto GetSPD1Value() const noexcept
Definition: WidefieldMicroscope.h:239

DynExpModule::Widefield::WidefieldMicroscopeData::MaxFocusVoltage
double MaxFocusVoltage
Definition: WidefieldMicroscope.h:377

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldConfocalSwitch
auto & GetWidefieldConfocalSwitch() const noexcept
Definition: WidefieldMicroscope.h:125

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterType::State
LocalizedEmitterStateType State
Definition: WidefieldMicroscope.h:43

DynExpModule::Widefield::WidefieldMicroscopeData::AcqCommunicator
DynExp::LinkedObjectWrapperContainer< DynExpInstr::InterModuleCommunicator > AcqCommunicator
Definition: WidefieldMicroscope.h:362

DynExpModule::Widefield::WidefieldMicroscopeData::WidefieldLocalizer
DynExp::LinkedObjectWrapperContainer< DynExpInstr::WidefieldLocalization > WidefieldLocalizer
Definition: WidefieldMicroscope.h:359

DynExpModule::Widefield::WidefieldMicroscopeData::GetSampleStageX
auto & GetSampleStageX() noexcept
Definition: WidefieldMicroscope.h:112

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureCellSkip
QPoint AutoMeasureCellSkip
Definition: WidefieldMicroscope.h:451

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTTotalIntegrationTime
auto GetHBTTotalIntegrationTime() const noexcept
Definition: WidefieldMicroscope.h:277

DynExpModule::Widefield::WidefieldMicroscopeData::AssembleCSVHeader
std::stringstream AssembleCSVHeader(bool IncludeConfocalScan, bool IncludeHBT, bool IncludeAutoMeasure) const
Definition: WidefieldMicroscope.cpp:103

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureSavePath
std::filesystem::path GetAutoMeasureSavePath() const
Definition: WidefieldMicroscope.cpp:256

DynExpModule::Widefield::WidefieldMicroscopeData::PumpPower
DynExp::LinkedObjectWrapperContainer< DynExpInstr::AnalogOut > PumpPower
Definition: WidefieldMicroscope.h:356

DynExpModule::Widefield::WidefieldMicroscopeData::Init
void Init()
Definition: WidefieldMicroscope.cpp:318

DynExpModule::Widefield::WidefieldMicroscopeData::SetMaxPumpPower
void SetMaxPumpPower(double MaxPower) noexcept
Definition: WidefieldMicroscope.h:169

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldHBTSwitch
auto & GetWidefieldHBTSwitch() noexcept
Definition: WidefieldMicroscope.h:128

DynExpModule::Widefield::WidefieldMicroscopeData::GetUIMessage
std::string_view GetUIMessage() const noexcept
Definition: WidefieldMicroscope.h:151

DynExpModule::Widefield::WidefieldMicroscopeData::GetLastCountRate
double GetLastCountRate() const noexcept
Definition: WidefieldMicroscope.h:264

DynExpModule::Widefield::WidefieldMicroscopeData::ResetSPD2State
void ResetSPD2State() noexcept
Definition: WidefieldMicroscope.h:248

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldCameraExposureTime
CameraTimeType GetWidefieldCameraExposureTime() const noexcept
Definition: WidefieldMicroscope.h:196

DynExpModule::Widefield::WidefieldMicroscopeData::SetCellIDToLastCellID
void SetCellIDToLastCellID()
Definition: WidefieldMicroscope.h:210

DynExpModule::Widefield::WidefieldMicroscopeData::SetSPDExposureTime
void SetSPDExposureTime(SPDTimeType Time) noexcept
Definition: WidefieldMicroscope.h:236

DynExpModule::Widefield::WidefieldMicroscopeData::SetHBTBinCount
void SetHBTBinCount(size_t BinCount) noexcept
Definition: WidefieldMicroscope.h:270

DynExpModule::Widefield::WidefieldMicroscopeData::ResetAutofocusFinished
void ResetAutofocusFinished() noexcept
Definition: WidefieldMicroscope.h:188

DynExpModule::Widefield::WidefieldMicroscopeData::GetWidefieldCamera
auto & GetWidefieldCamera() noexcept
Definition: WidefieldMicroscope.h:134

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureOptimizationMaxDistance
int AutoMeasureOptimizationMaxDistance
Definition: WidefieldMicroscope.h:447

DynExpModule::Widefield::WidefieldMicroscopeData::SPD2State
SPDStateType SPD2State
Definition: WidefieldMicroscope.h:406

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureImagePositionScatterRadius
int AutoMeasureImagePositionScatterRadius
Definition: WidefieldMicroscope.h:438

DynExpModule::Widefield::WidefieldMicroscopeData::AutoMeasureNumberImageSets
int AutoMeasureNumberImageSets
Definition: WidefieldMicroscope.h:435

DynExpModule::Widefield::WidefieldMicroscopeData::IncrementAutoMeasureCurrentImageSet
auto IncrementAutoMeasureCurrentImageSet() noexcept
Definition: WidefieldMicroscope.h:296

DynExpModule::Widefield::WidefieldMicroscopeData::GetHBTBinCount
auto GetHBTBinCount() const noexcept
Definition: WidefieldMicroscope.h:269

DynExpModule::Widefield::WidefieldMicroscopeData::TestFeature
bool TestFeature(FeatureType Flag) const
Definition: WidefieldMicroscope.h:148

DynExpModule::Widefield::WidefieldMicroscopeData::SPD1
DynExp::LinkedObjectWrapperContainer< DynExpInstr::TimeTagger > SPD1
Definition: WidefieldMicroscope.h:360

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureSpectrumEnabled
auto GetAutoMeasureSpectrumEnabled() const noexcept
Definition: WidefieldMicroscope.h:306

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCellSkip
auto & GetAutoMeasureCellSkip() const noexcept
Definition: WidefieldMicroscope.h:333

DynExpModule::Widefield::WidefieldMicroscopeData::GetAutoMeasureCurrentCellPosition
const PositionPoint & GetAutoMeasureCurrentCellPosition() const noexcept
Definition: WidefieldMicroscope.h:291

DynExpModule::Widefield::WidefieldMicroscopeData::GetConfocalOptimizationInitZStepSize
double GetConfocalOptimizationInitZStepSize() const noexcept
Definition: WidefieldMicroscope.h:260

DynExpModule::Widefield::WidefieldMicroscopeData::LocalizedEmitterType
Definition: WidefieldMicroscope.h:41

DynExpModule::Widefield::WidefieldMicroscopeParams
Definition: WidefieldMicroscope.h:460

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldMicroscopeParams
WidefieldMicroscopeParams(DynExp::ItemIDType ID, const DynExp::DynExpCore &Core)
Definition: WidefieldMicroscope.h:462

DynExpModule::Widefield::WidefieldMicroscopeParams::PumpPowerIndicator
Param< DynExp::ObjectLink< DynExpInstr::AnalogIn > > PumpPowerIndicator
Definition: WidefieldMicroscope.h:505

DynExpModule::Widefield::WidefieldMicroscopeParams::DefaultPowerConfocalMode
Param< ParamsConfigDialog::NumberType > DefaultPowerConfocalMode
Definition: WidefieldMicroscope.h:511

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldCamera
Param< DynExp::ObjectLink< DynExpInstr::Camera > > WidefieldCamera
Definition: WidefieldMicroscope.h:514

DynExpModule::Widefield::WidefieldMicroscopeParams::SampleStageX
Param< DynExp::ObjectLink< DynExpInstr::PositionerStage > > SampleStageX
Definition: WidefieldMicroscope.h:467

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldLocalizer
Param< DynExp::ObjectLink< DynExpInstr::WidefieldLocalization > > WidefieldLocalizer
Definition: WidefieldMicroscope.h:516

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldHBTSwitchLowDutyCycle
Param< ParamsConfigDialog::NumberType > WidefieldHBTSwitchLowDutyCycle
Definition: WidefieldMicroscope.h:491

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldHBTSwitch
Param< DynExp::ObjectLink< DynExpInstr::FunctionGenerator > > WidefieldHBTSwitch
Definition: WidefieldMicroscope.h:489

DynExpModule::Widefield::WidefieldMicroscopeParams::GetParamClassTag
virtual const char * GetParamClassTag() const noexcept override
This function is intended to be overridden once in each derived class returning the name of the respe...
Definition: WidefieldMicroscope.h:465

DynExpModule::Widefield::WidefieldMicroscopeParams::ConfigureParamsImpl
void ConfigureParamsImpl(dispatch_tag< QModuleParamsBase >) override final
Definition: WidefieldMicroscope.h:530

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldConfocalSwitch
Param< DynExp::ObjectLink< DynExpInstr::DigitalOut > > WidefieldConfocalSwitch
Definition: WidefieldMicroscope.h:479

DynExpModule::Widefield::WidefieldMicroscopeParams::PumpPower
Param< DynExp::ObjectLink< DynExpInstr::AnalogOut > > PumpPower
Definition: WidefieldMicroscope.h:503

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldHBTSwitchHighDutyCycle
Param< ParamsConfigDialog::NumberType > WidefieldHBTSwitchHighDutyCycle
Definition: WidefieldMicroscope.h:495

DynExpModule::Widefield::WidefieldMicroscopeParams::SampleStageY
Param< DynExp::ObjectLink< DynExpInstr::PositionerStage > > SampleStageY
Definition: WidefieldMicroscope.h:469

DynExpModule::Widefield::WidefieldMicroscopeParams::SampleStageZ
Param< DynExp::ObjectLink< DynExpInstr::PositionerStage > > SampleStageZ
Definition: WidefieldMicroscope.h:471

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldConfocalTransitionTime
Param< ParamsConfigDialog::NumberType > WidefieldConfocalTransitionTime
Definition: WidefieldMicroscope.h:485

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldHBTTransitionTime
Param< ParamsConfigDialog::NumberType > WidefieldHBTTransitionTime
Definition: WidefieldMicroscope.h:499

DynExpModule::Widefield::WidefieldMicroscopeParams::AcqCommunicator
Param< DynExp::ObjectLink< DynExpInstr::InterModuleCommunicator > > AcqCommunicator
Definition: WidefieldMicroscope.h:526

DynExpModule::Widefield::WidefieldMicroscopeParams::PumpSwitch
Param< DynExp::ObjectLink< DynExpInstr::DigitalOut > > PumpSwitch
Definition: WidefieldMicroscope.h:477

DynExpModule::Widefield::WidefieldMicroscopeParams::LEDSwitch
Param< DynExp::ObjectLink< DynExpInstr::DigitalOut > > LEDSwitch
Definition: WidefieldMicroscope.h:475

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldConfocalIndicator
Param< DynExp::ObjectLink< DynExpInstr::DigitalIn > > WidefieldConfocalIndicator
Definition: WidefieldMicroscope.h:482

DynExpModule::Widefield::WidefieldMicroscopeParams::DefaultPowerWidefieldMode
Param< ParamsConfigDialog::NumberType > DefaultPowerWidefieldMode
Definition: WidefieldMicroscope.h:508

DynExpModule::Widefield::WidefieldMicroscopeParams::SPD2
Param< DynExp::ObjectLink< DynExpInstr::TimeTagger > > SPD2
Definition: WidefieldMicroscope.h:524

DynExpModule::Widefield::WidefieldMicroscopeParams::WidefieldCameraMagnification
Param< ParamsConfigDialog::NumberType > WidefieldCameraMagnification
Definition: WidefieldMicroscope.h:519

DynExpModule::Widefield::WidefieldMicroscopeParams::FocusPiezoZ
Param< DynExp::ObjectLink< DynExpInstr::AnalogOut > > FocusPiezoZ
Definition: WidefieldMicroscope.h:473

DynExpModule::Widefield::WidefieldMicroscopeParams::SPD1
Param< DynExp::ObjectLink< DynExpInstr::TimeTagger > > SPD1
Definition: WidefieldMicroscope.h:522

DynExpModule::Widefield::WidefieldMicroscopeParams::~WidefieldMicroscopeParams
virtual ~WidefieldMicroscopeParams()=default

DynExpModule::Widefield::WidefieldMicroscopeWidget::LocalizationType
LocalizationType
Definition: WidefieldMicroscopeWidget.h:117

DynExpModule::Widefield::WidefieldMicroscope
Definition: WidefieldMicroscope.h:547

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanCaptureState
static constexpr auto ConfocalScanCaptureState
Definition: WidefieldMicroscope.h:821

DynExpModule::Widefield::WidefieldMicroscope::OnCaptureWidefieldImage
void OnCaptureWidefieldImage(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1726

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalSPDExposureTimeChanged
void OnConfocalSPDExposureTimeChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1803

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationMinimizer
const gsl_multimin_fminimizer_type *const GSLConfocalOptimizationMinimizer
Definition: WidefieldMicroscope.h:974

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTFinishedState
static constexpr auto AutoMeasureCharacterizationHBTFinishedState
Definition: WidefieldMicroscope.h:871

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleCharacterizationContext
Definition: WidefieldMicroscope.h:948

DynExpModule::Widefield::WidefieldMicroscope::OnAutofocus
void OnAutofocus(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1563

DynExpModule::Widefield::WidefieldMicroscope::OnOptimizePositions
void OnOptimizePositions(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1573

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationSaveLEDImageState
static constexpr auto AutoMeasureLocalizationSaveLEDImageState
Definition: WidefieldMicroscope.h:849

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellRangeFromXChanged
void OnAutoMeasureCellRangeFromXChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2021

DynExpModule::Widefield::WidefieldMicroscope::HBTIntegrationTimeBeforeReset
std::chrono::microseconds HBTIntegrationTimeBeforeReset
Definition: WidefieldMicroscope.h:996

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTFinishedStateFunc
StateType AutoMeasureCharacterizationHBTFinishedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2954

DynExpModule::Widefield::WidefieldMicroscope::HBTAcquiringStateFunc
StateType HBTAcquiringStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2636

DynExpModule::Widefield::WidefieldMicroscope::RandomPointInCircle
ModuleDataType::PositionPoint RandomPointInCircle(ModuleDataType::PositionType Radius) const
Returns a uniformly-distributed random coordinate within a circle of radius Radius,...
Definition: WidefieldMicroscope.cpp:1200

DynExpModule::Widefield::WidefieldMicroscope::WaitingState
static constexpr auto WaitingState
Definition: WidefieldMicroscope.h:839

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationStepState
static constexpr auto ConfocalOptimizationStepState
Definition: WidefieldMicroscope.h:831

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleContext
Definition: WidefieldMicroscope.h:933

DynExpModule::Widefield::WidefieldMicroscope::OnRunCharacterizationFromID
void OnRunCharacterizationFromID(DynExp::ModuleInstance *Instance, Util::MarkerGraphicsView::MarkerType::IDType ID) const
Definition: WidefieldMicroscope.cpp:635

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleLocalizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleLocalizationContext
Definition: WidefieldMicroscope.h:944

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationOptimizationFinishedStateFunc
StateType AutoMeasureCharacterizationOptimizationFinishedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2832

DynExpModule::Widefield::WidefieldMicroscope::OnHBTBinWidthChanged
void OnHBTBinWidthChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1877

DynExpModule::Widefield::WidefieldMicroscope::OnGoToHomePosition
void OnGoToHomePosition(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1516

DynExpModule::Widefield::WidefieldMicroscope::PrepareAPDsForConfocalMode
void PrepareAPDsForConfocalMode(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1049

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureMaxOptimizationRerunsChanged
void OnAutoMeasureMaxOptimizationRerunsChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2003

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalConfocalWidthChanged
void OnConfocalConfocalWidthChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1785

DynExpModule::Widefield::WidefieldMicroscope::InitiateReadCellIDFromImage
StateType InitiateReadCellIDFromImage(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:980

DynExpModule::Widefield::WidefieldMicroscope::MoveSampleTo
void MoveSampleTo(const ModuleDataType::PositionPoint &Point, Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:831

DynExpModule::Widefield::WidefieldMicroscope::SpectrumAcquisitionWaitingState
static constexpr auto SpectrumAcquisitionWaitingState
Definition: WidefieldMicroscope.h:843

DynExpModule::Widefield::WidefieldMicroscope::PositionPointFromPixelDist
static ModuleDataType::PositionPoint PositionPointFromPixelDist(Util::SynchronizedPointer< const ParamsType > &ModuleParams, Util::SynchronizedPointer< ModuleDataType > &ModuleData, const PosT x, const PosT y)
Definition: WidefieldMicroscope.h:587

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationInitSubStepStateFunc
StateType ConfocalOptimizationInitSubStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2559

DynExpModule::Widefield::WidefieldMicroscope::MakeUIWidget
std::unique_ptr< DynExp::QModuleWidget > MakeUIWidget() override final
Used by InitUI() as a factory function for the module's user interface widget. Create the widget here...
Definition: WidefieldMicroscope.cpp:689

DynExpModule::Widefield::WidefieldMicroscope::WaitingForImageStateFunc
StateType WaitingForImageStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2272

DynExpModule::Widefield::WidefieldMicroscope::IsCharacterizingSample
bool IsCharacterizingSample() const noexcept
Returns true if an entire sample (multiple cells) are processed, false if only a single cell is proce...
Definition: WidefieldMicroscope.cpp:817

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleRecenterCellContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleRecenterCellContext
Definition: WidefieldMicroscope.h:941

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalConfocalDistPerPixelChanged
void OnConfocalConfocalDistPerPixelChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1797

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionFinishedState
static constexpr auto SetupTransitionFinishedState
Definition: WidefieldMicroscope.h:775

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotAfterTransitioningToConfocalModeStateFunc
StateType FindingConfocalSpotAfterTransitioningToConfocalModeStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2406

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionBeginState
static constexpr auto SetupTransitionBeginState
Definition: WidefieldMicroscope.h:769

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleStepStateFunc
StateType AutoMeasureSampleStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2974

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageAcquisitionSetupTransitioningContext
const Util::StateMachineContext< StateMachineStateType > WidefieldImageAcquisitionSetupTransitioningContext
Definition: WidefieldMicroscope.h:909

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldImageState
static constexpr auto WaitingForWidefieldImageState
Definition: WidefieldMicroscope.h:797

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureNumberImageSetsChanged
void OnAutoMeasureNumberImageSetsChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1955

DynExpModule::Widefield::WidefieldMicroscope::WidefieldCellIDState
const std::shared_ptr< AtomicWidefieldImageProcessingStateType > WidefieldCellIDState
Definition: WidefieldMicroscope.h:967

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationContext
const Util::StateMachineContext< StateMachineStateType > ConfocalOptimizationContext
Definition: WidefieldMicroscope.h:902

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCountRateThresholdChanged
void OnAutoMeasureCountRateThresholdChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2015

DynExpModule::Widefield::WidefieldMicroscope::IsReadyState
bool IsReadyState() const noexcept
Definition: WidefieldMicroscope.h:596

DynExpModule::Widefield::WidefieldMicroscope::StartAutoMeasureLocalization
StateType StartAutoMeasureLocalization(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1131

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldLEDExposureTimeChanged
void OnWidefieldLEDExposureTimeChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1663

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationSaveLEDImageStateFunc
StateType AutoMeasureLocalizationSaveLEDImageStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2697

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationSpectrumBeginState
static constexpr auto AutoMeasureCharacterizationSpectrumBeginState
Definition: WidefieldMicroscope.h:865

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationStepStateFunc
StateType AutoMeasureCharacterizationStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2759

DynExpModule::Widefield::WidefieldMicroscope::OnInit
void OnInit(DynExp::ModuleInstance *Instance) const override final
This event is triggered right before the module thread starts. Override it to lock instruments this m...
Definition: WidefieldMicroscope.cpp:1296

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationSpectrumBeginStateFunc
StateType AutoMeasureCharacterizationSpectrumBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2890

DynExpModule::Widefield::WidefieldMicroscope::WidefieldCellWaitUntilCenteredStateFunc
StateType WidefieldCellWaitUntilCenteredStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2339

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralConfocalPowerChanged
void OnGeneralConfocalPowerChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1616

DynExpModule::Widefield::WidefieldMicroscope::LEDImageAcquisitionBeginState
static constexpr auto LEDImageAcquisitionBeginState
Definition: WidefieldMicroscope.h:785

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureOptimizationMaxDistanceChanged
void OnAutoMeasureOptimizationMaxDistanceChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2009

DynExpModule::Widefield::WidefieldMicroscope::OnToggleAutoMeasureSpectrumEnabled
void OnToggleAutoMeasureSpectrumEnabled(DynExp::ModuleInstance *Instance, int State) const
Definition: WidefieldMicroscope.cpp:1985

DynExpModule::Widefield::WidefieldMicroscope::WidefieldMicroscope
WidefieldMicroscope(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType &&Params)
Definition: WidefieldMicroscope.cpp:529

DynExpModule::Widefield::WidefieldMicroscope::ReadyStateFunc
StateType ReadyStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2182

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationMovingState
static constexpr auto AutoMeasureLocalizationMovingState
Definition: WidefieldMicroscope.h:853

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanPositionerStateY
const std::shared_ptr< AtomicPositionerStateType > ConfocalScanPositionerStateY
Definition: WidefieldMicroscope.h:963

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationGotoEmitterStateFunc
StateType AutoMeasureCharacterizationGotoEmitterStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2802

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalOptimizationInitZStepSizeChanged
void OnConfocalOptimizationInitZStepSizeChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1815

DynExpModule::Widefield::WidefieldMicroscope::CalcMarkerToConfocalSpotDestiny
ModuleDataType::PositionPoint CalcMarkerToConfocalSpotDestiny(Util::SynchronizedPointer< const ParamsType > &ModuleParams, Util::SynchronizedPointer< ModuleDataType > &ModuleData, QPoint MarkerPos, QPointF SamplePos) const
Definition: WidefieldMicroscope.cpp:901

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageProcessingStateType
WidefieldImageProcessingStateType
Definition: WidefieldMicroscope.h:549

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageProcessingStateType::Waiting
@ Waiting

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageProcessingStateType::Finished
@ Finished

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageProcessingStateType::Failed
@ Failed

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleFindEmittersState
static constexpr auto AutoMeasureSampleFindEmittersState
Definition: WidefieldMicroscope.h:883

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationInitStateFunc
StateType ConfocalOptimizationInitStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2550

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotBeginStateFunc
StateType FindingConfocalSpotBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2389

DynExpModule::Widefield::WidefieldMicroscope::AutofocusBeginStateFunc
StateType AutofocusBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2187

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalOptimizationInitXYStepSizeChanged
void OnConfocalOptimizationInitXYStepSizeChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1809

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralFocusConfocalOffsetVoltageChanged
void OnGeneralFocusConfocalOffsetVoltageChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1639

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationFinishedState
static constexpr auto AutoMeasureCharacterizationFinishedState
Definition: WidefieldMicroscope.h:873

DynExpModule::Widefield::WidefieldMicroscope::OnGoToSamplePos
void OnGoToSamplePos(DynExp::ModuleInstance *Instance, QPointF SamplePos) const
Definition: WidefieldMicroscope.cpp:611

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellRangeToXChanged
void OnAutoMeasureCellRangeToXChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2033

DynExpModule::Widefield::WidefieldMicroscope::OnResetCellID
void OnResetCellID(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1599

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFuncForwarder
static double ConfocalOptimizationFuncForwarder(const gsl_vector *vector, void *params)
Definition: WidefieldMicroscope.cpp:1263

DynExpModule::Widefield::WidefieldMicroscope::AutofocusSetupTransitioningContext
const Util::StateMachineContext< StateMachineStateType > AutofocusSetupTransitioningContext
Definition: WidefieldMicroscope.h:893

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanWaitUntilMovedState
static constexpr auto ConfocalScanWaitUntilMovedState
Definition: WidefieldMicroscope.h:819

DynExpModule::Widefield::WidefieldMicroscope::ParamsType
WidefieldMicroscopeParams ParamsType
Definition: WidefieldMicroscope.h:555

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionEndStateFunc
StateType SetupTransitionEndStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2159

DynExpModule::Widefield::WidefieldMicroscope::WaitingForImageReadyToCaptureStateFunc
StateType WaitingForImageReadyToCaptureStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2259

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThreadReturnFuture
std::future< ConfocalOptimizationThreadReturnType > ConfocalOptimizationThreadReturnFuture
Definition: WidefieldMicroscope.h:985

DynExpModule::Widefield::WidefieldMicroscope::WidefieldLocalizationState
const std::shared_ptr< AtomicWidefieldImageProcessingStateType > WidefieldLocalizationState
Definition: WidefieldMicroscope.h:968

DynExpModule::Widefield::WidefieldMicroscope::OnSaveCurrentImage
void OnSaveCurrentImage(DynExp::ModuleInstance *Instance, QString Filename) const
Definition: WidefieldMicroscope.cpp:589

DynExpModule::Widefield::WidefieldMicroscope::WaitingForLEDImageState
static constexpr auto WaitingForLEDImageState
Definition: WidefieldMicroscope.h:791

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureImagePositionScatterRadius
void OnAutoMeasureImagePositionScatterRadius(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1967

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizeState
static constexpr auto AutoMeasureSampleCharacterizeState
Definition: WidefieldMicroscope.h:885

DynExpModule::Widefield::WidefieldMicroscope::UpdateUIChild
void UpdateUIChild(const ModuleBase::ModuleDataGetterType &ModuleDataGetter) override final
Definition: WidefieldMicroscope.cpp:763

DynExpModule::Widefield::WidefieldMicroscope::OnCaptureLEDImage
void OnCaptureLEDImage(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1708

DynExpModule::Widefield::WidefieldMicroscope::OnToggleAutoMeasureHBTEnabled
void OnToggleAutoMeasureHBTEnabled(DynExp::ModuleInstance *Instance, int State) const
Definition: WidefieldMicroscope.cpp:1991

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalConfocalHeightChanged
void OnConfocalConfocalHeightChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1791

DynExpModule::Widefield::WidefieldMicroscope::WaitingForLEDImageFinishedState
static constexpr auto WaitingForLEDImageFinishedState
Definition: WidefieldMicroscope.h:793

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureSavePathChanged
void OnAutoMeasureSavePathChanged(DynExp::ModuleInstance *Instance, QString Path) const
Definition: WidefieldMicroscope.cpp:1949

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizationHBTContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleCharacterizationHBTContext
Definition: WidefieldMicroscope.h:955

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationState
gsl_multimin_fminimizer *const GSLConfocalOptimizationState
Definition: WidefieldMicroscope.h:976

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldLocalizeEmitters
void OnWidefieldLocalizeEmitters(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1764

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldImageReadyToCaptureState
static constexpr auto WaitingForWidefieldImageReadyToCaptureState
Definition: WidefieldMicroscope.h:795

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationInitSubStepState
static constexpr auto ConfocalOptimizationInitSubStepState
Definition: WidefieldMicroscope.h:827

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationNumStepsPerformed
std::atomic< size_t > ConfocalOptimizationNumStepsPerformed
Definition: WidefieldMicroscope.h:979

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationWaitState
static constexpr auto ConfocalOptimizationWaitState
Definition: WidefieldMicroscope.h:829

DynExpModule::Widefield::WidefieldMicroscope::InitiateLocalizationFromImage
StateType InitiateLocalizationFromImage(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1012

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationOptimizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureCharacterizationOptimizationContext
Definition: WidefieldMicroscope.h:924

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFeedbackType
double ConfocalOptimizationFeedbackType
Definition: WidefieldMicroscope.h:638

DynExpModule::Widefield::WidefieldMicroscope::AutofocusWaitingStateFunc
StateType AutofocusWaitingStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2210

DynExpModule::Widefield::WidefieldMicroscope::OnConfocalOptimizationToleranceChanged
void OnConfocalOptimizationToleranceChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1821

DynExpModule::Widefield::WidefieldMicroscope::TurnOnPumpSourceAfterTransitioning
bool TurnOnPumpSourceAfterTransitioning
Definition: WidefieldMicroscope.h:989

DynExpModule::Widefield::WidefieldMicroscope::OnToggleAutoMeasureOptimizeEnabled
void OnToggleAutoMeasureOptimizeEnabled(DynExp::ModuleInstance *Instance, int State) const
Definition: WidefieldMicroscope.cpp:1979

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureCharacterizationContext
Definition: WidefieldMicroscope.h:918

DynExpModule::Widefield::WidefieldMicroscope::OnHHBTMaxIntegrationTimeChanged
void OnHHBTMaxIntegrationTimeChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1889

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotBeginState
static constexpr auto FindingConfocalSpotBeginState
Definition: WidefieldMicroscope.h:811

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFeedbackFuture
std::future< ConfocalOptimizationFeedbackType > ConfocalOptimizationFeedbackFuture
Definition: WidefieldMicroscope.h:984

DynExpModule::Widefield::WidefieldMicroscope::ModuleMainLoop
Util::DynExpErrorCodes::DynExpErrorCodes ModuleMainLoop(DynExp::ModuleInstance &Instance) override final
Module main loop. The function is executed periodically by the module thread. Also refer to GetMainLo...
Definition: WidefieldMicroscope.cpp:642

DynExpModule::Widefield::WidefieldMicroscope::WidefieldCellWaitUntilCenteredState
static constexpr auto WidefieldCellWaitUntilCenteredState
Definition: WidefieldMicroscope.h:803

DynExpModule::Widefield::WidefieldMicroscope::SetHBTSwitch
void SetHBTSwitch(Util::SynchronizedPointer< const ParamsType > &ModuleParams, Util::SynchronizedPointer< ModuleDataType > &ModuleData, bool IsHBTMode) const
Definition: WidefieldMicroscope.cpp:1082

DynExpModule::Widefield::WidefieldMicroscope::ModuleDataType
WidefieldMicroscopeData ModuleDataType
Definition: WidefieldMicroscope.h:557

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotAfterRecordingWidefieldImageState
static constexpr auto FindingConfocalSpotAfterRecordingWidefieldImageState
Definition: WidefieldMicroscope.h:815

DynExpModule::Widefield::WidefieldMicroscope::OnPerformConfocalScan
void OnPerformConfocalScan(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1827

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanPositionerStateX
const std::shared_ptr< AtomicPositionerStateType > ConfocalScanPositionerStateX
Definition: WidefieldMicroscope.h:962

DynExpModule::Widefield::WidefieldMicroscope::OnSpectrumFinishedRecording
void OnSpectrumFinishedRecording(DynExp::ModuleInstance *Instance) const
Definition: WidefieldMicroscope.cpp:1944

DynExpModule::Widefield::WidefieldMicroscope::ImageCapturingPaused
bool ImageCapturingPaused
Definition: WidefieldMicroscope.h:992

DynExpModule::Widefield::WidefieldMicroscope::OnTogglePumpLightSource
void OnTogglePumpLightSource(DynExp::ModuleInstance *Instance, bool State) const
Definition: WidefieldMicroscope.cpp:1536

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationGotoEmitterState
static constexpr auto AutoMeasureCharacterizationGotoEmitterState
Definition: WidefieldMicroscope.h:859

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanWaitUntilMovedStateFunc
StateType ConfocalScanWaitUntilMovedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2464

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldLocalizationStateFunc
StateType WaitingForWidefieldLocalizationStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2356

DynExpModule::Widefield::WidefieldMicroscope::StartAutofocus
StateType StartAutofocus(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1116

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationStepState
static constexpr auto AutoMeasureLocalizationStepState
Definition: WidefieldMicroscope.h:847

DynExpModule::Widefield::WidefieldMicroscope::ReturnToReadyStateFunc
StateType ReturnToReadyStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2101

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldApplyPumpExposureTime
void OnWidefieldApplyPumpExposureTime(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1686

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFeedbackPromise
std::promise< ConfocalOptimizationFeedbackType > ConfocalOptimizationFeedbackPromise
Definition: WidefieldMicroscope.h:983

DynExpModule::Widefield::WidefieldMicroscope::InitializingStateFunc
StateType InitializingStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2110

DynExpModule::Widefield::WidefieldMicroscope::RecordImage
void RecordImage(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:975

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotAfterRecordingWidefieldImageStateFunc
StateType FindingConfocalSpotAfterRecordingWidefieldImageStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2421

DynExpModule::Widefield::WidefieldMicroscope::OnFinishedAutofocus
void OnFinishedAutofocus(DynExp::ModuleInstance *Instance, bool Success, double Voltage) const
Definition: WidefieldMicroscope.cpp:1912

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationWaitStateFunc
StateType ConfocalOptimizationWaitStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2566

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleAdvanceCellState
static constexpr auto AutoMeasureSampleAdvanceCellState
Definition: WidefieldMicroscope.h:887

DynExpModule::Widefield::WidefieldMicroscope::ConfocalSurfaceSelectedPointChanged
void ConfocalSurfaceSelectedPointChanged(DynExp::ModuleInstance *Instance, QPoint Position) const
Definition: WidefieldMicroscope.cpp:1861

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanPositionerStateZ
const std::shared_ptr< AtomicPositionerStateType > ConfocalScanPositionerStateZ
Definition: WidefieldMicroscope.h:964

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldApplyLEDExposureTime
void OnWidefieldApplyLEDExposureTime(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1669

DynExpModule::Widefield::WidefieldMicroscope::GetName
virtual std::string GetName() const override
Returns the name of this Object type.
Definition: WidefieldMicroscope.h:565

DynExpModule::Widefield::WidefieldMicroscope::IsSampleMoving
bool IsSampleMoving(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Checks whether the sample is moving in x- or y-direction. The z-direction is ignored currently since ...
Definition: WidefieldMicroscope.cpp:870

DynExpModule::Widefield::WidefieldMicroscope::GetCategory
virtual std::string GetCategory() const override
Returns the category of this Object type.
Definition: WidefieldMicroscope.h:566

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureLocalizationContext
Definition: WidefieldMicroscope.h:912

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTBeginStateFunc
StateType AutoMeasureCharacterizationHBTBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2927

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldImageFinishedState
static constexpr auto WaitingForWidefieldImageFinishedState
Definition: WidefieldMicroscope.h:799

DynExpModule::Widefield::WidefieldMicroscope::SpectrumAcquisitionFinishedState
static constexpr auto SpectrumAcquisitionFinishedState
Definition: WidefieldMicroscope.h:845

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageAcquisitionBeginStateFunc
StateType WidefieldImageAcquisitionBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2242

DynExpModule::Widefield::WidefieldMicroscope::StartAutoMeasureSampleCharacterization
StateType StartAutoMeasureSampleCharacterization(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1182

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureInitialImageSetWaitTimeChanged
void OnAutoMeasureInitialImageSetWaitTimeChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1961

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationSpectrumFinishedState
static constexpr auto AutoMeasureCharacterizationSpectrumFinishedState
Definition: WidefieldMicroscope.h:863

DynExpModule::Widefield::WidefieldMicroscope::OnToggleHBTMirror
void OnToggleHBTMirror(DynExp::ModuleInstance *Instance, bool Checked) const
Definition: WidefieldMicroscope.cpp:1588

DynExpModule::Widefield::WidefieldMicroscope::WaitingFinishedState
static constexpr auto WaitingFinishedState
Definition: WidefieldMicroscope.h:841

DynExpModule::Widefield::WidefieldMicroscope::AutofocusBeginState
static constexpr auto AutofocusBeginState
Definition: WidefieldMicroscope.h:779

DynExpModule::Widefield::WidefieldMicroscope::LEDImageAcquisitionSetupTransitioningContext
const Util::StateMachineContext< StateMachineStateType > LEDImageAcquisitionSetupTransitioningContext
Definition: WidefieldMicroscope.h:906

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleAdvanceCellStateFunc
StateType AutoMeasureSampleAdvanceCellStateFunc(DynExp::ModuleInstance &Instance)
Checks whether the last cell within the sample characterization range (specified as a square region b...
Definition: WidefieldMicroscope.cpp:3081

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureRunLocalization
void OnAutoMeasureRunLocalization(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:2057

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationSpectrumFinishedStateFunc
StateType AutoMeasureCharacterizationSpectrumFinishedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2900

DynExpModule::Widefield::WidefieldMicroscope::InitializeHBT
void InitializeHBT(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1091

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleFinishedState
static constexpr auto AutoMeasureSampleFinishedState
Definition: WidefieldMicroscope.h:889

DynExpModule::Widefield::WidefieldMicroscope::AtomicPositionerStateType
std::atomic< PositionerStateType > AtomicPositionerStateType
Definition: WidefieldMicroscope.h:551

DynExpModule::Widefield::WidefieldMicroscope::WaitingEndTimePoint
std::chrono::system_clock::time_point WaitingEndTimePoint
Definition: WidefieldMicroscope.h:995

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldCellIDState
static constexpr auto WaitingForWidefieldCellIDState
Definition: WidefieldMicroscope.h:801

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationOptimizationFinishedState
static constexpr auto AutoMeasureCharacterizationOptimizationFinishedState
Definition: WidefieldMicroscope.h:861

DynExpModule::Widefield::WidefieldMicroscope::OnHBTBinCountChanged
void OnHBTBinCountChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1883

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralFocusZeroVoltageChanged
void OnGeneralFocusZeroVoltageChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1633

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFinishedState
static constexpr auto ConfocalOptimizationFinishedState
Definition: WidefieldMicroscope.h:833

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionBeginStateFunc
StateType SetupTransitionBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2122

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitioningStateFunc
StateType SetupTransitioningStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2154

DynExpModule::Widefield::WidefieldMicroscope::LogUIMessagesOnly
bool LogUIMessagesOnly
Definition: WidefieldMicroscope.h:1000

DynExpModule::Widefield::WidefieldMicroscope::StateMachine
Util::StateMachine< StateMachineStateType > StateMachine
Definition: WidefieldMicroscope.h:959

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureLocalizationTypeChanged
void OnAutoMeasureLocalizationTypeChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1973

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitioningState
static constexpr auto SetupTransitioningState
Definition: WidefieldMicroscope.h:771

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureCharacterizationHBTContext
Definition: WidefieldMicroscope.h:930

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldReadCellID
void OnWidefieldReadCellID(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1744

DynExpModule::Widefield::WidefieldMicroscope::WidefieldCellIDReadFinishedState
static constexpr auto WidefieldCellIDReadFinishedState
Definition: WidefieldMicroscope.h:805

DynExpModule::Widefield::WidefieldMicroscope::WaitingStateFunc
StateType WaitingStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2676

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationMovingStateFunc
StateType AutoMeasureLocalizationMovingStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2749

DynExpModule::Widefield::WidefieldMicroscope::WidefieldImageAcquisitionBeginState
static constexpr auto WidefieldImageAcquisitionBeginState
Definition: WidefieldMicroscope.h:787

DynExpModule::Widefield::WidefieldMicroscope::ResetState
StateType ResetState(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Aborts a measurement or experimental sequence and continues with the ready state.
Definition: WidefieldMicroscope.cpp:796

DynExpModule::Widefield::WidefieldMicroscope::OnSetupModeChanged
void OnSetupModeChanged(DynExp::ModuleInstance *Instance, QAction *Action) const
Definition: WidefieldMicroscope.cpp:1546

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationStateFuture
std::future< ConfocalOptimizationStateType > ConfocalOptimizationStateFuture
Definition: WidefieldMicroscope.h:982

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellSkipYChanged
void OnAutoMeasureCellSkipYChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2051

DynExpModule::Widefield::WidefieldMicroscope::Name
constexpr static auto Name() noexcept
Definition: WidefieldMicroscope.h:559

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizationSpectrumContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleCharacterizationSpectrumContext
Definition: WidefieldMicroscope.h:953

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldCellIDStateFunc
StateType WaitingForWidefieldCellIDStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2302

DynExpModule::Widefield::WidefieldMicroscope::StopHBT
void StopHBT(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1103

DynExpModule::Widefield::WidefieldMicroscope::PositionerStateType
PositionerStateType
Definition: WidefieldMicroscope.h:548

DynExpModule::Widefield::WidefieldMicroscope::PositionerStateType::Arrived
@ Arrived

DynExpModule::Widefield::WidefieldMicroscope::PositionerStateType::WaitingForMovement
@ WaitingForMovement

DynExpModule::Widefield::WidefieldMicroscope::PositionerStateType::Moving
@ Moving

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleLocalizeState
static constexpr auto AutoMeasureSampleLocalizeState
Definition: WidefieldMicroscope.h:881

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTWaitForInitState
static constexpr auto AutoMeasureCharacterizationHBTWaitForInitState
Definition: WidefieldMicroscope.h:869

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanStepState
static constexpr auto ConfocalScanStepState
Definition: WidefieldMicroscope.h:817

DynExpModule::Widefield::WidefieldMicroscope::OnExit
void OnExit(DynExp::ModuleInstance *Instance) const override final
This event is triggered right before the module thread terminates (not due to an exception,...
Definition: WidefieldMicroscope.cpp:1429

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationFunc
double ConfocalOptimizationFunc(const gsl_vector *vector) noexcept
Definition: WidefieldMicroscope.cpp:1268

DynExpModule::Widefield::WidefieldMicroscope::OnTerminate
void OnTerminate(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1457

DynExpModule::Widefield::WidefieldMicroscope::OnImageCapturingPaused
void OnImageCapturingPaused(DynExp::ModuleInstance *Instance) const
Definition: WidefieldMicroscope.cpp:1907

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureRunCharacterization
void OnAutoMeasureRunCharacterization(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:2067

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThread
static ConfocalOptimizationThreadReturnType ConfocalOptimizationThread(WidefieldMicroscope *Owner)
Definition: WidefieldMicroscope.cpp:1227

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldAnalyzeImageDistortion
void OnWidefieldAnalyzeImageDistortion(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1754

DynExpModule::Widefield::WidefieldMicroscope::OnSetHomePosition
void OnSetHomePosition(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1506

DynExpModule::Widefield::WidefieldMicroscope::UpdatePumpPower
void UpdatePumpPower(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:950

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationInitState
static constexpr auto ConfocalOptimizationInitState
Definition: WidefieldMicroscope.h:825

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotAfterTransitioningToConfocalModeState
static constexpr auto FindingConfocalSpotAfterTransitioningToConfocalModeState
Definition: WidefieldMicroscope.h:813

DynExpModule::Widefield::WidefieldMicroscope::~WidefieldMicroscope
virtual ~WidefieldMicroscope()
Definition: WidefieldMicroscope.cpp:568

DynExpModule::Widefield::WidefieldMicroscope::AutofocusFinishedState
static constexpr auto AutofocusFinishedState
Definition: WidefieldMicroscope.h:783

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationFinishedState
static constexpr auto AutoMeasureLocalizationFinishedState
Definition: WidefieldMicroscope.h:855

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationStepStateFunc
StateType AutoMeasureLocalizationStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2687

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellRangeToYChanged
void OnAutoMeasureCellRangeToYChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2039

DynExpModule::Widefield::WidefieldMicroscope::StartAutoMeasureCharacterization
StateType StartAutoMeasureCharacterization(Util::SynchronizedPointer< ModuleDataType > &ModuleData, Util::MarkerGraphicsView::MarkerType::IDType FirstEmitterID=-1) const
Definition: WidefieldMicroscope.cpp:1153

DynExpModule::Widefield::WidefieldMicroscope::AtomicWidefieldImageProcessingStateType
std::atomic< WidefieldImageProcessingStateType > AtomicWidefieldImageProcessingStateType
Definition: WidefieldMicroscope.h:552

DynExpModule::Widefield::WidefieldMicroscope::OnMeasureHBT
void OnMeasureHBT(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1895

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionFinishedTimePoint
std::chrono::system_clock::time_point SetupTransitionFinishedTimePoint
Definition: WidefieldMicroscope.h:988

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationStepState
static constexpr auto AutoMeasureCharacterizationStepState
Definition: WidefieldMicroscope.h:857

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotRecordingWidefieldImageContext
const Util::StateMachineContext< StateMachineStateType > FindingConfocalSpotRecordingWidefieldImageContext
Definition: WidefieldMicroscope.h:899

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTBeginState
static constexpr auto AutoMeasureCharacterizationHBTBeginState
Definition: WidefieldMicroscope.h:867

DynExpModule::Widefield::WidefieldMicroscope::ResetImpl
void ResetImpl(dispatch_tag< QModuleBase >) override final
Definition: WidefieldMicroscope.cpp:665

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleLocalizeStateFunc
StateType AutoMeasureSampleLocalizeStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:3033

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizeStateFunc
StateType AutoMeasureSampleCharacterizeStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:3064

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanPositions
std::list< WidefieldMicroscopeData::PositionPoint > ConfocalScanPositions
Definition: WidefieldMicroscope.h:970

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralSetZeroFocus
void OnGeneralSetZeroFocus(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1648

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldPumpExposureTimeChanged
void OnWidefieldPumpExposureTimeChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1680

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanWaitUntilCapturedStateFunc
StateType ConfocalScanWaitUntilCapturedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2503

DynExpModule::Widefield::WidefieldMicroscope::WaitingForLEDImageReadyToCaptureState
static constexpr auto WaitingForLEDImageReadyToCaptureState
Definition: WidefieldMicroscope.h:789

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleStepState
static constexpr auto AutoMeasureSampleStepState
Definition: WidefieldMicroscope.h:875

DynExpModule::Widefield::WidefieldMicroscope::InitializeConfocalOptimizer
void InitializeConfocalOptimizer(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:1063

DynExpModule::Widefield::WidefieldMicroscope::InitializingState
static constexpr auto InitializingState
Definition: WidefieldMicroscope.h:767

DynExpModule::Widefield::WidefieldMicroscope::NumFailedUpdateAttempts
size_t NumFailedUpdateAttempts
Definition: WidefieldMicroscope.h:999

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationSaveWidefieldImageStateFunc
StateType AutoMeasureLocalizationSaveWidefieldImageStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2714

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationSpectrumContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureCharacterizationSpectrumContext
Definition: WidefieldMicroscope.h:927

DynExpModule::Widefield::WidefieldMicroscope::WaitingForWidefieldLocalizationState
static constexpr auto WaitingForWidefieldLocalizationState
Definition: WidefieldMicroscope.h:807

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralWidefieldPowerChanged
void OnGeneralWidefieldPowerChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1608

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleReadCellIDFinishedState
static constexpr auto AutoMeasureSampleReadCellIDFinishedState
Definition: WidefieldMicroscope.h:879

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationStepSize
gsl_vector *const GSLConfocalOptimizationStepSize
Definition: WidefieldMicroscope.h:977

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellRangeFromYChanged
void OnAutoMeasureCellRangeFromYChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2027

DynExpModule::Widefield::WidefieldMicroscope::PrepareImageRecording
void PrepareImageRecording(Util::SynchronizedPointer< ModuleDataType > &ModuleData) const
Definition: WidefieldMicroscope.cpp:961

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationStepStateFunc
StateType ConfocalOptimizationStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2590

DynExpModule::Widefield::WidefieldMicroscope::OnToggleLEDLightSource
void OnToggleLEDLightSource(DynExp::ModuleInstance *Instance, bool State) const
Definition: WidefieldMicroscope.cpp:1526

DynExpModule::Widefield::WidefieldMicroscope::OnStopAction
void OnStopAction(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1462

DynExpModule::Widefield::WidefieldMicroscope::CalculateConfocalScanPositions
ModuleDataType::QSurfaceDataRowsType CalculateConfocalScanPositions(const int Width, const int Height, const int DistPerPixel, const WidefieldMicroscopeData::PositionPoint CenterPosition) const
Definition: WidefieldMicroscope.cpp:916

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleReadCellIDState
static constexpr auto AutoMeasureSampleReadCellIDState
Definition: WidefieldMicroscope.h:877

DynExpModule::Widefield::WidefieldMicroscope::OnBringMarkerToConfocalSpot
void OnBringMarkerToConfocalSpot(DynExp::ModuleInstance *Instance, QPoint MarkerPos, QPointF SamplePos) const
Definition: WidefieldMicroscope.cpp:624

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationStatePromise
std::promise< ConfocalOptimizationStateType > ConfocalOptimizationStatePromise
Definition: WidefieldMicroscope.h:981

DynExpModule::Widefield::WidefieldMicroscope::GetMainLoopDelay
std::chrono::milliseconds GetMainLoopDelay() const override final
Specifies in which time intervals the module's event queue runs to handle pending events.
Definition: WidefieldMicroscope.cpp:578

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldImageClicked
void OnWidefieldImageClicked(DynExp::ModuleInstance *Instance, QPoint Position) const
Definition: WidefieldMicroscope.cpp:1774

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleReadCellIDStateFunc
StateType AutoMeasureSampleReadCellIDStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2985

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureNumOptimizationAttemptsChanged
void OnAutoMeasureNumOptimizationAttemptsChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:1997

DynExpModule::Widefield::WidefieldMicroscope::SetupTransitionEndState
static constexpr auto SetupTransitionEndState
Definition: WidefieldMicroscope.h:773

DynExpModule::Widefield::WidefieldMicroscope::WidefieldLocalizationFinishedState
static constexpr auto WidefieldLocalizationFinishedState
Definition: WidefieldMicroscope.h:809

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanCaptureStateFunc
StateType ConfocalScanCaptureStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2477

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleCharacterizationOptimizationContext
const Util::StateMachineContext< StateMachineStateType > AutoMeasureSampleCharacterizationOptimizationContext
Definition: WidefieldMicroscope.h:951

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanStepStateFunc
StateType ConfocalScanStepStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2447

DynExpModule::Widefield::WidefieldMicroscope::Category
constexpr static auto Category() noexcept
Definition: WidefieldMicroscope.h:560

DynExpModule::Widefield::WidefieldMicroscope::AutofocusWaitingState
static constexpr auto AutofocusWaitingState
Definition: WidefieldMicroscope.h:781

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationPromisesRenewed
std::atomic_bool ConfocalOptimizationPromisesRenewed
Definition: WidefieldMicroscope.h:980

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralApplyZeroFocus
void OnGeneralApplyZeroFocus(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1654

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleFindEmittersStateFunc
StateType AutoMeasureSampleFindEmittersStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:3051

DynExpModule::Widefield::WidefieldMicroscope::BuildFilename
std::filesystem::path BuildFilename(Util::SynchronizedPointer< ModuleDataType > &ModuleData, std::string_view FilenameSuffix) const
Definition: WidefieldMicroscope.cpp:1191

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationFuncDesc
gsl_multimin_function GSLConfocalOptimizationFuncDesc
Definition: WidefieldMicroscope.h:975

DynExpModule::Widefield::WidefieldMicroscope::LEDImageAcquisitionBeginStateFunc
StateType LEDImageAcquisitionBeginStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2222

DynExpModule::Widefield::WidefieldMicroscope::BringMarkerToConfocalSpot
void BringMarkerToConfocalSpot(Util::SynchronizedPointer< const ParamsType > &ModuleParams, Util::SynchronizedPointer< ModuleDataType > &ModuleData, QPoint MarkerPos, QPointF SamplePos) const
Definition: WidefieldMicroscope.cpp:910

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationNumDimensions
static constexpr size_t GSLConfocalOptimizationNumDimensions
Definition: WidefieldMicroscope.h:973

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureCellSkipXChanged
void OnAutoMeasureCellSkipXChanged(DynExp::ModuleInstance *Instance, int Value) const
Definition: WidefieldMicroscope.cpp:2045

DynExpModule::Widefield::WidefieldMicroscope::OnAutoMeasureRunSampleCharacterization
void OnAutoMeasureRunSampleCharacterization(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:2078

DynExpModule::Widefield::WidefieldMicroscope::ConfocalScanWaitUntilCapturedState
static constexpr auto ConfocalScanWaitUntilCapturedState
Definition: WidefieldMicroscope.h:823

DynExpModule::Widefield::WidefieldMicroscope::OnGeneralFocusCurrentVoltageChanged
void OnGeneralFocusCurrentVoltageChanged(DynExp::ModuleInstance *Instance, double Value) const
Definition: WidefieldMicroscope.cpp:1624

DynExpModule::Widefield::WidefieldMicroscope::ReadyState
static constexpr auto ReadyState
Definition: WidefieldMicroscope.h:777

DynExpModule::Widefield::WidefieldMicroscope::OnWidefieldFindConfocalSpot
void OnWidefieldFindConfocalSpot(DynExp::ModuleInstance *Instance, bool) const
Definition: WidefieldMicroscope.cpp:1697

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureSampleReadCellIDFinishedStateFunc
StateType AutoMeasureSampleReadCellIDFinishedStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2992

DynExpModule::Widefield::WidefieldMicroscope::HBTAcquiringState
static constexpr auto HBTAcquiringState
Definition: WidefieldMicroscope.h:835

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationInitPromises
void ConfocalOptimizationInitPromises()
Definition: WidefieldMicroscope.cpp:1215

DynExpModule::Widefield::WidefieldMicroscope::HBTFinishedState
static constexpr auto HBTFinishedState
Definition: WidefieldMicroscope.h:837

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThreadReturnType
ConfocalOptimizationThreadReturnType
Definition: WidefieldMicroscope.h:636

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThreadReturnType::Finished
@ Finished

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThreadReturnType::NextStep
@ NextStep

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationThreadReturnType::Failed
@ Failed

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureCharacterizationHBTWaitForInitStateFunc
StateType AutoMeasureCharacterizationHBTWaitForInitStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2936

DynExpModule::Widefield::WidefieldMicroscope::GSLConfocalOptimizationInitialPoint
gsl_vector *const GSLConfocalOptimizationInitialPoint
Definition: WidefieldMicroscope.h:978

DynExpModule::Widefield::WidefieldMicroscope::SpectrumAcquisitionWaitingStateFunc
StateType SpectrumAcquisitionWaitingStateFunc(DynExp::ModuleInstance &Instance)
Definition: WidefieldMicroscope.cpp:2681

DynExpModule::Widefield::WidefieldMicroscope::AutoMeasureLocalizationSaveWidefieldImageState
static constexpr auto AutoMeasureLocalizationSaveWidefieldImageState
Definition: WidefieldMicroscope.h:851

DynExpModule::Widefield::WidefieldMicroscope::FindingConfocalSpotBeginContext
const Util::StateMachineContext< StateMachineStateType > FindingConfocalSpotBeginContext
Definition: WidefieldMicroscope.h:896

DynExpModule::Widefield::WidefieldMicroscope::ConfocalOptimizationStateType
Definition: WidefieldMicroscope.h:630

DynExp::DynExpCore
DynExp's core class acts as the interface between the user interface and DynExp's internal data like ...
Definition: DynExpCore.h:127

DynExp::LinkedObjectWrapperContainer< DynExpInstr::PositionerStage >

DynExp::ModuleBase
Base class for modules. Modules implement programs on their own (e.g. measurement protocols or server...
Definition: Module.h:392

DynExp::ModuleBase::ModuleDataGetterType
Util::CallableMemberWrapper< ModuleBase, ModuleDataTypeSyncPtrType(ModuleBase::*)(const std::chrono::milliseconds)> ModuleDataGetterType
Invoking an instance of this alias is supposed to call ModuleBase::GetModuleData() of the instance th...
Definition: Module.h:587

DynExp::ModuleBase::ModuleData
const std::unique_ptr< ModuleDataType > ModuleData
Module data belonging to this ModuleBase instance.
Definition: Module.h:743

DynExp::ModuleBase::ModuleBase
ModuleBase(const std::thread::id OwnerThreadID, ParamsBasePtrType &&Params)
Constructs a ModuleBase instance.
Definition: Module.cpp:189

DynExp::ModuleConfiguratorBase
Configurator class for ModuleBase.
Definition: Module.h:374

DynExp::ModuleDataBase
Data structure to contain data which is synchronized in between different threads....
Definition: Module.h:171

DynExp::ModuleDataBase::dispatch_tag
Refer to ParamsBase::dispatch_tag.
Definition: Module.h:189

DynExp::ModuleInstance
Defines data for a thread belonging to a ModuleBase instance. Refer to RunnableInstance.
Definition: Module.h:793

DynExp::ModuleParamsBase
Parameter class for ModuleBase.
Definition: Module.h:337

DynExp::Object::OwnerThreadID
const std::thread::id OwnerThreadID
Thread id of the thread which has constructed (and owns) this Object instance.
Definition: Object.h:2302

DynExp::Object::Params
const ParamsBasePtrType Params
Pointer to the parameter class instance belonging to this Object instance.
Definition: Object.h:2303

DynExp::ParamsBase::ID
const ItemIDType ID
ID of the Object this parameter class instance belongs to.
Definition: Object.h:1779

DynExp::ParamsBase::GetCore
const auto & GetCore() const noexcept
Returns a reference to DynExp's core.
Definition: Object.h:1677

DynExp::ParamsBase::Core
const DynExpCore & Core
Reference to DynExp's core.
Definition: Object.h:1780

DynExp::ParamsBase::Param< ParamsConfigDialog::NumberType >

DynExp::ParamsBase::Param
Definition: Object.h:750

DynExp::ParamsBase::dispatch_tag
Tag for function dispatching mechanism within this class used when derived classes are not intended t...
Definition: Object.h:349

DynExp::QModuleBase
Base class for modules with a Qt-based user interface. Derive from this class to implement modules wi...
Definition: Module.h:1344

DynExp::QModuleBase::SetFocus
void SetFocus() noexcept
Focuses/activates Widget and moves it on top of other windows if possible. Does nothing if any of Wid...
Definition: Module.cpp:678

DynExp::QModuleBase::QModuleBase
QModuleBase(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType &&Params)
Constructs a QModuleBase instance.
Definition: Module.cpp:557

DynExp::QModuleConfiguratorBase
Configurator class for QModuleBase.
Definition: Module.h:1330

DynExp::QModuleDataBase
Data class for QModuleBase.
Definition: Module.h:1220

DynExp::QModuleParamsBase
Parameter class for QModuleBase.
Definition: Module.h:1306

DynExp::QModuleParamsBase::QModuleParamsBase
QModuleParamsBase(ItemIDType ID, const DynExpCore &Core)
Constructs the parameters for a QModuleBase instance.
Definition: Module.h:1312

Util::FeatureTester< FeatureType >

Util::FeatureTester::Set
void Set(EnumType Flag)
Sets a flag.
Definition: Util.h:1281

Util::FeatureTester::Test
bool Test(const std::array< EnumType, N > &Flags) const
Tests whether all of the flags passed as an array are set.
Definition: Util.h:1257

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::StateMachine
This class models a state machine. It keeps track of the current state and allows to invoke its assoc...
Definition: Util.h:1435

Util::SynchronizedPointer
Pointer to lock a class derived from ISynchronizedPointerLockable for synchronizing between threads....
Definition: Util.h:170

DynExpInstr::LockinAmplifierDefs::Y
@ Y
Y component of the signal in cartesian coordinates.
Definition: LockinAmplifier.h:51

DynExpInstr::LockinAmplifierDefs::X
@ X
X component of the signal in cartesian coordinates.
Definition: LockinAmplifier.h:50

DynExpModule::Widefield
Definition: WidefieldMicroscope.cpp:7

DynExpModule::Widefield::StateType
StateType
Definition: WidefieldMicroscopeWidget.h:21

DynExpModule::Widefield::StateType::DummyState
@ DummyState

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationGotoEmitter
@ AutoMeasureCharacterizationGotoEmitter

DynExpModule::Widefield::StateType::AutoMeasureLocalizationSaveWidefieldImage
@ AutoMeasureLocalizationSaveWidefieldImage

DynExpModule::Widefield::StateType::AutoMeasureSampleStep
@ AutoMeasureSampleStep

DynExpModule::Widefield::StateType::AutoMeasureLocalizationFinished
@ AutoMeasureLocalizationFinished

DynExpModule::Widefield::StateType::AutoMeasureLocalizationMoving
@ AutoMeasureLocalizationMoving

DynExpModule::Widefield::StateType::WaitingForWidefieldImage
@ WaitingForWidefieldImage

DynExpModule::Widefield::StateType::WaitingForLEDImageReadyToCapture
@ WaitingForLEDImageReadyToCapture

DynExpModule::Widefield::StateType::FindingConfocalSpotBegin
@ FindingConfocalSpotBegin

DynExpModule::Widefield::StateType::ConfocalScanCapture
@ ConfocalScanCapture

DynExpModule::Widefield::StateType::AutoMeasureSampleAdvanceCell
@ AutoMeasureSampleAdvanceCell

DynExpModule::Widefield::StateType::WaitingForWidefieldImageReadyToCapture
@ WaitingForWidefieldImageReadyToCapture

DynExpModule::Widefield::StateType::FindingConfocalSpotAfterTransitioningToConfocalMode
@ FindingConfocalSpotAfterTransitioningToConfocalMode

DynExpModule::Widefield::StateType::Initializing
@ Initializing

DynExpModule::Widefield::StateType::AutoMeasureSampleFinished
@ AutoMeasureSampleFinished

DynExpModule::Widefield::StateType::ConfocalScanStep
@ ConfocalScanStep

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationSpectrumFinished
@ AutoMeasureCharacterizationSpectrumFinished

DynExpModule::Widefield::StateType::AutofocusWaiting
@ AutofocusWaiting

DynExpModule::Widefield::StateType::AutoMeasureSampleReadCellIDFinished
@ AutoMeasureSampleReadCellIDFinished

DynExpModule::Widefield::StateType::WaitingForLEDImageFinished
@ WaitingForLEDImageFinished

DynExpModule::Widefield::StateType::WidefieldLocalizationFinished
@ WidefieldLocalizationFinished

DynExpModule::Widefield::StateType::LEDImageAcquisitionBegin
@ LEDImageAcquisitionBegin

DynExpModule::Widefield::StateType::Waiting
@ Waiting

DynExpModule::Widefield::StateType::AutofocusFinished
@ AutofocusFinished

DynExpModule::Widefield::StateType::SetupTransitionBegin
@ SetupTransitionBegin

DynExpModule::Widefield::StateType::AutoMeasureSampleReadCellID
@ AutoMeasureSampleReadCellID

DynExpModule::Widefield::StateType::ConfocalOptimizationFinished
@ ConfocalOptimizationFinished

DynExpModule::Widefield::StateType::WaitingForWidefieldImageFinished
@ WaitingForWidefieldImageFinished

DynExpModule::Widefield::StateType::HBTFinished
@ HBTFinished

DynExpModule::Widefield::StateType::AutoMeasureSampleFindEmitters
@ AutoMeasureSampleFindEmitters

DynExpModule::Widefield::StateType::SetupTransitioning
@ SetupTransitioning

DynExpModule::Widefield::StateType::AutoMeasureSampleCharacterize
@ AutoMeasureSampleCharacterize

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationStep
@ AutoMeasureCharacterizationStep

DynExpModule::Widefield::StateType::WidefieldCellIDReadFinished
@ WidefieldCellIDReadFinished

DynExpModule::Widefield::StateType::WaitingFinished
@ WaitingFinished

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationHBTWaitForInit
@ AutoMeasureCharacterizationHBTWaitForInit

DynExpModule::Widefield::StateType::ConfocalOptimizationInitSubStep
@ ConfocalOptimizationInitSubStep

DynExpModule::Widefield::StateType::ConfocalOptimizationWait
@ ConfocalOptimizationWait

DynExpModule::Widefield::StateType::ConfocalScanWaitUntilMoved
@ ConfocalScanWaitUntilMoved

DynExpModule::Widefield::StateType::FindingConfocalSpotAfterRecordingWidefieldImage
@ FindingConfocalSpotAfterRecordingWidefieldImage

DynExpModule::Widefield::StateType::WaitingForWidefieldCellID
@ WaitingForWidefieldCellID

DynExpModule::Widefield::StateType::WaitingForWidefieldLocalization
@ WaitingForWidefieldLocalization

DynExpModule::Widefield::StateType::SetupTransitionEnd
@ SetupTransitionEnd

DynExpModule::Widefield::StateType::ConfocalOptimizationInit
@ ConfocalOptimizationInit

DynExpModule::Widefield::StateType::WaitingForLEDImage
@ WaitingForLEDImage

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationHBTBegin
@ AutoMeasureCharacterizationHBTBegin

DynExpModule::Widefield::StateType::AutofocusBegin
@ AutofocusBegin

DynExpModule::Widefield::StateType::ConfocalOptimizationStep
@ ConfocalOptimizationStep

DynExpModule::Widefield::StateType::SpectrumAcquisitionWaiting
@ SpectrumAcquisitionWaiting

DynExpModule::Widefield::StateType::SetupTransitionFinished
@ SetupTransitionFinished

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationOptimizationFinished
@ AutoMeasureCharacterizationOptimizationFinished

DynExpModule::Widefield::StateType::AutoMeasureSampleLocalize
@ AutoMeasureSampleLocalize

DynExpModule::Widefield::StateType::Ready
@ Ready

DynExpModule::Widefield::StateType::HBTAcquiring
@ HBTAcquiring

DynExpModule::Widefield::StateType::AutoMeasureLocalizationStep
@ AutoMeasureLocalizationStep

DynExpModule::Widefield::StateType::AutoMeasureLocalizationSaveLEDImage
@ AutoMeasureLocalizationSaveLEDImage

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationFinished
@ AutoMeasureCharacterizationFinished

DynExpModule::Widefield::StateType::ConfocalScanWaitUntilCaptured
@ ConfocalScanWaitUntilCaptured

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationSpectrumBegin
@ AutoMeasureCharacterizationSpectrumBegin

DynExpModule::Widefield::StateType::AutoMeasureCharacterizationHBTFinished
@ AutoMeasureCharacterizationHBTFinished

DynExpModule::Widefield::StateType::WidefieldImageAcquisitionBegin
@ WidefieldImageAcquisitionBegin

DynExpModule::Widefield::StateType::SpectrumAcquisitionFinished
@ SpectrumAcquisitionFinished

DynExpModule::Widefield::StateType::WidefieldCellWaitUntilCentered
@ WidefieldCellWaitUntilCentered

DynExpModule::Widefield::operator-
WidefieldMicroscopeData::PositionPoint operator-(const WidefieldMicroscopeData::PositionPoint &lhs, const WidefieldMicroscopeData::PositionPoint &rhs)
Definition: WidefieldMicroscope.cpp:465

DynExpModule::Widefield::operator+
WidefieldMicroscopeData::PositionPoint operator+(const WidefieldMicroscopeData::PositionPoint &lhs, const WidefieldMicroscopeData::PositionPoint &rhs)
Definition: WidefieldMicroscope.cpp:401

DynExpUI::Icons::Instrument
constexpr auto Instrument
Definition: DynExpDefinitions.h.in:75

DynExpUI::Icons::Running
constexpr auto Running
Definition: DynExpDefinitions.h.in:81

DynExp
DynExp's main namespace contains the implementation of DynExp including classes to manage resources (...
Definition: CircuitDiagram.h:17

DynExp::ParamsBasePtrType
std::unique_ptr< ParamsBase > ParamsBasePtrType
Alias for a pointer to the parameter system base class ParamsBase.
Definition: Object.h:1807

DynExp::ItemIDType
size_t ItemIDType
ID type of objects/items managed by DynExp.
Definition: DynExpDefinitions.h.in:50

Util::DynExpErrorCodes::DynExpErrorCodes
DynExpErrorCodes
DynExp's error codes
Definition: Exception.h:22

Util
DynExp's Util namespace contains commonly used functions and templates as well as extensions to Qt an...
Definition: circularbuf.cpp:7

Util::picoseconds
std::chrono::duration< double, std::pico > picoseconds
Extends std::chrono by a duration data type for picoseconds.
Definition: Util.h:762

Util::seconds
std::chrono::duration< double > seconds
Extends std::chrono by a duration data type for seconds capable of storing fractions of seconds.
Definition: Util.h:761

stdafx.h
Accumulates include statements to provide a precompiled header.

DynExpInstr::WidefieldLocalizationCellIDType
Definition: WidefieldLocalization.h:24

DynExpInstr::WidefieldLocalizationCellIDType::Valid
bool Valid
Definition: WidefieldLocalization.h:28

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint
Definition: WidefieldMicroscope.h:56

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::z
PositionType z
Definition: WidefieldMicroscope.h:78

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::DistTo
double DistTo(const PositionPoint &Other) const
Definition: WidefieldMicroscope.cpp:26

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::ToStr
std::string ToStr(std::string_view Prefix="") const
Definition: WidefieldMicroscope.cpp:40

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::PositionPoint
constexpr PositionPoint(PositionType x, PositionType y, PositionType z)
Definition: WidefieldMicroscope.h:66

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::ColumnIndex
int ColumnIndex
Definition: WidefieldMicroscope.h:89

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::UsingX
bool UsingX
Definition: WidefieldMicroscope.h:84

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::IsEmpty
constexpr bool IsEmpty() const noexcept
Definition: WidefieldMicroscope.h:71

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::MeasuredY
PositionType MeasuredY
Definition: WidefieldMicroscope.h:81

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::PositionPoint
constexpr PositionPoint(PositionType x, PositionType y)
Definition: WidefieldMicroscope.h:63

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::x
PositionType x
Definition: WidefieldMicroscope.h:76

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::y
PositionType y
Definition: WidefieldMicroscope.h:77

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::MeasuredZ
PositionType MeasuredZ
Definition: WidefieldMicroscope.h:82

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::RowIndex
int RowIndex
Definition: WidefieldMicroscope.h:88

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::PositionPoint
constexpr PositionPoint(PositionType x) noexcept
Definition: WidefieldMicroscope.h:60

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::UsingY
bool UsingY
Definition: WidefieldMicroscope.h:85

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::UsingZ
bool UsingZ
Definition: WidefieldMicroscope.h:86

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::PositionPoint
constexpr PositionPoint() noexcept
Definition: WidefieldMicroscope.h:57

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::MeasuredX
PositionType MeasuredX
Definition: WidefieldMicroscope.h:80

DynExpModule::Widefield::WidefieldMicroscopeData::PositionPoint::Reset
constexpr void Reset() noexcept
Definition: WidefieldMicroscope.cpp:8

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType
Definition: WidefieldMicroscope.h:93

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType::Value
double Value
Definition: WidefieldMicroscope.h:104

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType::Reset
constexpr void Reset() noexcept
Definition: WidefieldMicroscope.h:97

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType::SPDStateType
constexpr SPDStateType(double Value=0, bool Ready=false, size_t StreamSamplesWritten=0) noexcept
Definition: WidefieldMicroscope.h:94

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType::StreamSamplesWritten
size_t StreamSamplesWritten
Definition: WidefieldMicroscope.h:106

DynExpModule::Widefield::WidefieldMicroscopeData::SPDStateType::Ready
bool Ready
Definition: WidefieldMicroscope.h:105

Util::MarkerGraphicsView::MarkerType::IDType
signed long long IDType
Definition: QtUtil.h:392