Spectrometer.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Instrument.h"
 
namespace DynExpInstr
{
    class Spectrometer;
 
    namespace SpectrometerTasks
    {
        class InitTask : public DynExp::InitTaskBase
        {
            void InitFuncImpl(dispatch_tag<InitTaskBase>, DynExp::InstrumentInstance& Instance) override final { InitFuncImpl(dispatch_tag<InitTask>(), Instance); }
 
            virtual void InitFuncImpl(dispatch_tag<InitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class ExitTask : public DynExp::ExitTaskBase
        {
            void ExitFuncImpl(dispatch_tag<ExitTaskBase>, DynExp::InstrumentInstance& Instance) override final { ExitFuncImpl(dispatch_tag<ExitTask>(), Instance); }
 
            virtual void ExitFuncImpl(dispatch_tag<ExitTask>, DynExp::InstrumentInstance& Instance) {}
        };
 
        class UpdateTask : public DynExp::UpdateTaskBase
        {
            void UpdateFuncImpl(dispatch_tag<UpdateTaskBase>, DynExp::InstrumentInstance& Instance) override final { UpdateFuncImpl(dispatch_tag<UpdateTask>(), Instance); }
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
        };
    }
 
    class SpectrometerData : public DynExp::InstrumentDataBase
    {
    public:
        using TimeType = std::chrono::milliseconds;
 
        enum class FrequencyUnitType {
            Hz,         
            nm,         
            Inv_cm      
        };
 
        enum class IntensityUnitType {
            Counts      
        };
 
        static const char* FrequencyUnitTypeToStr(const FrequencyUnitType& Unit);
 
        static const char* IntensityUnitTypeToStr(const IntensityUnitType& Unit);
 
        enum class CapturingStateType {
            Ready,      
            Warning,    
            Error,      
            Capturing   
        };
 
        class SpectrumType
        {
        public:
            SpectrumType() : FrequencyUnit(FrequencyUnitType::Hz), IntensityUnit(IntensityUnitType::Counts) {}
            
            SpectrumType(FrequencyUnitType FrequencyUnit, IntensityUnitType IntensityUnit) : FrequencyUnit(FrequencyUnit), IntensityUnit(IntensityUnit) {}
            
            SpectrumType(const SpectrumType& Other) : FrequencyUnit(Other.FrequencyUnit), IntensityUnit(Other.IntensityUnit), Samples(Other.Samples) {}
            
            SpectrumType(SpectrumType&& Other);
 
            SpectrumType& operator=(const SpectrumType& Other);
 
            SpectrumType& operator=(SpectrumType&& Other);
 
            void Reset();   
 
            auto GetFrequencyUnit() const noexcept { return FrequencyUnit; }    
            auto GetIntensityUnit() const noexcept { return IntensityUnit; }    
            auto& GetSpectrum() const noexcept { return Samples; }              
            auto& GetSpectrum() noexcept { return Samples; }                    
 
            bool HasSpectrum() const noexcept { return !Samples.empty(); }
 
        private:
            FrequencyUnitType FrequencyUnit;    
            IntensityUnitType IntensityUnit;    
 
            std::map<double, double> Samples;   
        };
 
        SpectrometerData() = default;
        virtual ~SpectrometerData() = default;
 
        auto GetMinExposureTime() const noexcept { return MinExposureTime; }                                                                                
        void SetMinExposureTime(double MinExposureTime) noexcept { this->MinExposureTime = TimeType(Util::NumToT<int>(MinExposureTime)); }                  
        void SetMinExposureTime(TimeType MinExposureTime) noexcept { this->MinExposureTime = MinExposureTime; }                                             
        auto GetMaxExposureTime() const noexcept { return MaxExposureTime; }                                                                                
        void SetMaxExposureTime(double MaxExposureTime) noexcept { this->MaxExposureTime = TimeType(Util::NumToT<int>(MaxExposureTime)); }                  
        void SetMaxExposureTime(TimeType MaxExposureTime) noexcept { this->MaxExposureTime = MaxExposureTime; }                                             
        auto GetCurrentExposureTime() const noexcept { return CurrentExposureTime; }                                                                        
        void SetCurrentExposureTime(double CurrentExposureTime) noexcept { this->CurrentExposureTime = TimeType(Util::NumToT<int>(CurrentExposureTime)); }  
        void SetCurrentExposureTime(TimeType CurrentExposureTime) noexcept { this->CurrentExposureTime = CurrentExposureTime; }                             
        auto GetCurrentLowerFrequency() const noexcept { return CurrentLowerFrequency; }                                                                    
        void SetCurrentLowerFrequency(double CurrentLowerFrequency) noexcept { this->CurrentLowerFrequency = CurrentLowerFrequency; }                       
        auto GetCurrentUpperFrequency() const noexcept { return CurrentUpperFrequency; }                                                                    
        void SetCurrentUpperFrequency(double CurrentUpperFrequency) noexcept { this->CurrentUpperFrequency = CurrentUpperFrequency; }                       
        auto GetSilentModeEnabled() const noexcept { return SilentModeEnabled; }                                                                            
        void SetSilentModeEnabled(bool Enable) noexcept { SilentModeEnabled = Enable; }                                                                     
        
        auto GetCapturingState() const noexcept { return GetCapturingStateChild(); }
 
        bool IsCapturing() const noexcept { return GetCapturingStateChild() == CapturingStateType::Capturing; }
 
        auto GetCapturingProgress() const noexcept { return GetCapturingProgressChild(); }
        
        bool HasSpectrum() const noexcept { return CurrentSpectrum.HasSpectrum(); }
 
        SpectrumType GetSpectrum() const;
 
        SpectrumType GetSpectrumCopy() const;
 
        void SetSpectrum(SpectrumType&& Other);
 
        void ClearSpectrum() const;
 
    private:
        void ResetImpl(dispatch_tag<InstrumentDataBase>) override final;
        virtual void ResetImpl(dispatch_tag<SpectrometerData>) {};                  
 
        virtual CapturingStateType GetCapturingStateChild() const noexcept = 0;     
        virtual double GetCapturingProgressChild() const noexcept { return 0; }     
 
        TimeType MinExposureTime;               
        TimeType MaxExposureTime;               
        TimeType CurrentExposureTime;           
        double CurrentLowerFrequency = 0.0;     
        double CurrentUpperFrequency = 0.0;     
        bool SilentModeEnabled = false;         
 
        mutable SpectrumType CurrentSpectrum;
    };
 
    class SpectrometerParams : public DynExp::InstrumentParamsBase
    {
    public:
        SpectrometerParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : InstrumentParamsBase(ID, Core) {}
 
        virtual ~SpectrometerParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "SpectrometerParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InstrumentParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<SpectrometerParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<SpectrometerParams>) {}   
 
        DummyParam Dummy = { *this };                                           
    };
 
    class SpectrometerConfigurator : public DynExp::InstrumentConfiguratorBase
    {
    public:
        using ObjectType = Spectrometer;
        using ParamsType = SpectrometerParams;
 
        SpectrometerConfigurator() = default;
        virtual ~SpectrometerConfigurator() = 0;
    };
 
    class Spectrometer : public DynExp::InstrumentBase
    {
    public:
        using ParamsType = SpectrometerParams;                                      
        using ConfigType = SpectrometerConfigurator;                                
        using InstrumentDataType = SpectrometerData;                                
 
        using InitTaskType = SpectrometerTasks::InitTask;                           
        using ExitTaskType = SpectrometerTasks::ExitTask;                           
        using UpdateTaskType = SpectrometerTasks::UpdateTask;                       
 
        constexpr static auto Name() noexcept { return "Spectrometer"; }            
        constexpr static auto Category() noexcept { return "Image Capturing"; }     
 
        Spectrometer(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InstrumentBase(OwnerThreadID, std::move(Params)) {}
 
        virtual ~Spectrometer() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }     
 
        virtual std::chrono::milliseconds GetTaskQueueDelay() const override { return std::chrono::milliseconds(50); }
 
 
        virtual SpectrometerData::FrequencyUnitType GetFrequencyUnit() const = 0;
 
        virtual SpectrometerData::IntensityUnitType GetIntensityUnit() const = 0;
 
        virtual double GetMinFrequency() const = 0;
 
        virtual double GetMaxFrequency() const = 0;
 
 
        virtual void SetExposureTime(SpectrometerData::TimeType ExposureTime, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetFrequencyRange(double LowerFrequency, double UpperFrequency, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void SetSilentMode(bool Enable, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void Record(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void Abort(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
    private:
        void ResetImpl(dispatch_tag<InstrumentBase>) override final;
        virtual void ResetImpl(dispatch_tag<Spectrometer>) = 0;         
    };
}