WidefieldMicroscope.h

Go to the documentation of this file.

// 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 "CommonModuleEvents.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,
            ImageInterModuleCommunicator, SpectrumInterModuleCommunicator, PLEInterModuleCommunicator,
            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;
 
        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& GetImageAcqCommunicator() noexcept { return ImageAcqCommunicator; }
        auto& GetImageAcqCommunicator() const noexcept { return ImageAcqCommunicator; }
        auto& GetSpectrumAcqCommunicator() noexcept { return SpectrumAcqCommunicator; }
        auto& GetSpectrumAcqCommunicator() const noexcept { return SpectrumAcqCommunicator; }
        auto& GetPLEAcqCommunicator() noexcept { return PLEAcqCommunicator; }
        auto& GetPLEAcqCommunicator() const noexcept { return PLEAcqCommunicator; }
 
        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(QSurfaceDataArray&& 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 GetAutoMeasureWidefieldPLEEnabled() const noexcept { return AutoMeasureWidefieldPLEEnabled; }
        auto SetAutoMeasureWidefieldPLEEnabled(bool Enabled) noexcept { AutoMeasureWidefieldPLEEnabled = Enabled; }
        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 GetAutoMeasureConfocalPLEEnabled() const noexcept { return AutoMeasureConfocalPLEEnabled; }
        auto SetAutoMeasureConfocalPLEEnabled(bool Enabled) noexcept { AutoMeasureConfocalPLEEnabled = 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; }
        bool GetAutoMeasureSampleRotated() const noexcept { return AutoMeasureSampleRotated; }
        void SetAutoMeasureSampleRotated(bool IsRotated) noexcept { AutoMeasureSampleRotated = IsRotated; }
        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::DigitalOut> 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> ImageAcqCommunicator;
        DynExp::LinkedObjectWrapperContainer<DynExpInstr::InterModuleCommunicator> SpectrumAcqCommunicator;
        DynExp::LinkedObjectWrapperContainer<DynExpInstr::InterModuleCommunicator> PLEAcqCommunicator;
 
        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;
        QSurfaceDataArray 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 AutoMeasureWidefieldPLEEnabled;
        bool AutoMeasureOptimizeEnabled;
        bool AutoMeasureSpectrumEnabled;
        bool AutoMeasureConfocalPLEEnabled;
        bool AutoMeasureHBTEnabled;
        int AutoMeasureNumOptimizationAttempts;
        int AutoMeasureCurrentOptimizationAttempt;
        int AutoMeasureMaxOptimizationReruns;
        int AutoMeasureCurrentOptimizationRerun;
        int AutoMeasureOptimizationMaxDistance;
        int AutoMeasureCountRateThreshold;
        QPoint AutoMeasureCellRangeFrom;
        QPoint AutoMeasureCellRangeTo;
        QPoint AutoMeasureCellSkip;
        bool AutoMeasureSampleRotated;
        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 to confocal mode or vice versa once the widefield/confocal mode switch has been triggered",
            false, 500, 0, 10000, 10, 0 };
        Param<DynExp::ObjectLink<DynExpInstr::DigitalOut>> WidefieldHBTSwitch = { *this, GetCore().GetInstrumentManager(),
            "WidefieldHBTSwitch", "Spectrometer/HBT mode switch (DO)",
            "Digital switch to change from spectrometer mode (LOW) to HBT mode (HIGH)", DynExpUI::Icons::Instrument, true };
        Param<ParamsConfigDialog::NumberType> WidefieldHBTTransitionTime = { *this, "WidefieldHBTTransitionTime",
            "Spectrometer/HBT transition time (ms)",
            "Time it takes to transition from spectrometer to HBT mode or vice versa once the spectrometer/HBT mode switch has been triggered",
            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>> ImageAcqCommunicator = { *this, GetCore().GetInstrumentManager(),
            "ImageAcqInterModuleCommunicator", "Image acq. inter-module communicator", "Inter-module communicator to control image capturing modules", DynExpUI::Icons::Instrument, true };
        Param<DynExp::ObjectLink<DynExpInstr::InterModuleCommunicator>> SpectrumAcqCommunicator = { *this, GetCore().GetInstrumentManager(),
            "SpectrumAcqInterModuleCommunicator", "Spectrum acq. inter-module communicator", "Inter-module communicator to control spectrum acquisition modules", DynExpUI::Icons::Instrument, true };
        Param<DynExp::ObjectLink<DynExpInstr::InterModuleCommunicator>> PLEAcqCommunicator = { *this, GetCore().GetInstrumentManager(),
            "PLEAcqInterModuleCommunicator", "PLE acq. inter-module communicator", "Inter-module communicator to control PLE acquisition modules", 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;
 
        void RegisterConfocalGraphEvents(DynExpQuick::DynExpSurfaceGraphBackend* ConfocalGraph);
 
        // 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;
        QSurfaceDataArray 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 OnPLEAcquisitionFinished(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 OnToggleAutoMeasureWidefieldPLEEnabled(DynExp::ModuleInstance* Instance, bool State) const;
        void OnToggleAutoMeasureOptimizeEnabled(DynExp::ModuleInstance* Instance, bool State) const;
        void OnToggleAutoMeasureSpectrumEnabled(DynExp::ModuleInstance* Instance, bool State) const;
        void OnToggleAutoMeasureConfocalPLEEnabled(DynExp::ModuleInstance* Instance, bool State) const;
        void OnToggleAutoMeasureHBTEnabled(DynExp::ModuleInstance* Instance, bool 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 OnToggleAutoMeasureSampleRotated(DynExp::ModuleInstance* Instance, Qt::CheckState State) 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 PLEAcquisitionWaitingStateFunc(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 AutoMeasureLocalizationPLEBeginStateFunc(DynExp::ModuleInstance& Instance);
        StateType AutoMeasureLocalizationPLEFinishedStateFunc(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 AutoMeasureCharacterizationPLEBeginStateFunc(DynExp::ModuleInstance& Instance);
        StateType AutoMeasureCharacterizationPLEFinishedStateFunc(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 PLEAcquisitionWaitingState = Util::StateMachineState(StateType::PLEAcquisitionWaiting,
            &WidefieldMicroscope::PLEAcquisitionWaitingStateFunc, "Performing widefield PLE...");
        static constexpr auto PLEAcquisitionFinishedState = Util::StateMachineState(StateType::PLEAcquisitionFinished,
            &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 AutoMeasureLocalizationPLEBeginState = Util::StateMachineState(StateType::AutoMeasureLocalizationPLEBegin,
            &WidefieldMicroscope::AutoMeasureLocalizationPLEBeginStateFunc);
        static constexpr auto AutoMeasureLocalizationPLEFinishedState = Util::StateMachineState(StateType::AutoMeasureLocalizationPLEFinished,
            &WidefieldMicroscope::AutoMeasureLocalizationPLEFinishedStateFunc);
        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 AutoMeasureCharacterizationSpectrumBeginState = Util::StateMachineState(StateType::AutoMeasureCharacterizationSpectrumBegin,
            &WidefieldMicroscope::AutoMeasureCharacterizationSpectrumBeginStateFunc);
        static constexpr auto AutoMeasureCharacterizationSpectrumFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationSpectrumFinished,
            &WidefieldMicroscope::AutoMeasureCharacterizationSpectrumFinishedStateFunc);
        static constexpr auto AutoMeasureCharacterizationPLEBeginState = Util::StateMachineState(StateType::AutoMeasureCharacterizationPLEBegin,
            &WidefieldMicroscope::AutoMeasureCharacterizationPLEBeginStateFunc);
        static constexpr auto AutoMeasureCharacterizationPLEFinishedState = Util::StateMachineState(StateType::AutoMeasureCharacterizationPLEFinished,
            &WidefieldMicroscope::AutoMeasureCharacterizationPLEFinishedStateFunc);
        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 },
            { StateType::PLEAcquisitionFinished, StateType::AutoMeasureLocalizationPLEFinished }
        } };
        const Util::StateMachineContext<StateMachineStateType> AutoMeasureCharacterizationContext = { {
            { StateType::SetupTransitionFinished, StateType::AutoMeasureCharacterizationStep },
            { StateType::ConfocalOptimizationFinished, StateType::AutoMeasureCharacterizationOptimizationFinished },
            { StateType::SpectrumAcquisitionFinished, StateType::AutoMeasureCharacterizationSpectrumFinished },
            { StateType::PLEAcquisitionFinished, StateType::AutoMeasureCharacterizationPLEFinished },
            { 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> AutoMeasureCharacterizationPLEContext = { {
            { StateType::WaitingFinished, StateType::AutoMeasureCharacterizationPLEBegin }
        }, "Characterizing emitters (performing confocal PLE)...", { &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> AutoMeasureSampleCharacterizationPLEContext = { {
        }, "Characterizing sample (performing confocal PLE)...", { &AutoMeasureSampleCharacterizationContext, &AutoMeasureCharacterizationPLEContext } };
        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;
    };
}