Camera.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 Camera;
 
    namespace CameraTasks
    {
        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;
 
            virtual void UpdateFuncImpl(dispatch_tag<UpdateTask>, DynExp::InstrumentInstance& Instance) {}
 
            virtual QImage ObtainImage(DynExp::InstrumentInstance& Instance) = 0;
        };
    }
 
    class CameraData : public DynExp::InstrumentDataBase
    {
    public:
        struct ImageTransformationType
        {
            float BrightnessFactor = 0.f;
 
            float ContrastFactor = 1.f;
 
            bool IsEnabled = false;
        };
 
        using ImageDimensionType = unsigned int;            
        using CameraModesType = std::vector<std::string>;   
        using TimeType = std::chrono::milliseconds;         
 
        enum class CapturingStateType {
            Stopped,                    
            CapturingSingle,            
            CapturingContinuously       
        };
 
        enum class ComputeHistogramType {
            NoHistogram,                
            IntensityHistogram,         
            RGBHistogram,               
            IntensityAndRGBHistogram    
        };
 
        CameraData() = default;
        virtual ~CameraData() = default;
 
        auto GetImageWidth() const noexcept { return ImageWidth; }                                              
        void SetImageWidth(ImageDimensionType ImageWidth) noexcept { this->ImageWidth = ImageWidth; }           
        auto GetImageHeight() const noexcept { return ImageHeight; }                                            
        void SetImageHeight(ImageDimensionType ImageHeight) noexcept { this->ImageHeight = ImageHeight; }       
 
        auto GetCameraModes() const { return CameraModes; }                                                     
        void SetCameraModes(CameraModesType CameraModes) { this->CameraModes = CameraModes; }                   
 
        TimeType GetMinExposureTime() const { return MinExposureTime; }                                         
        TimeType GetMaxExposureTime() const { return MaxExposureTime; }                                         
        TimeType GetExposureTime() const { return CurrentExposureTime; }                                        
        void SetMinExposureTime(TimeType MinExposureTime) { this->MinExposureTime = MinExposureTime; }          
        void SetMaxExposureTime(TimeType MaxExposureTime) { this->MaxExposureTime = MaxExposureTime; }          
        void SetExposureTime(TimeType CurrentExposureTime) { this->CurrentExposureTime = CurrentExposureTime; } 
 
        auto GetCurrentFPS() const noexcept { return CurrentFPS; }                                              
        void SetCurrentFPS(float CurrentFPS) noexcept { this->CurrentFPS = CurrentFPS; }                        
 
        auto GetComputeHistogram() const noexcept { return ComputeHistogram; }                                                                              
        void SetComputeHistogram(ComputeHistogramType ComputeHistogram) const noexcept { this->ComputeHistogram = ComputeHistogram; }                       
        auto GetIntensityHistogram() const noexcept { return IntensityHistogram; }                                                                          
        void SetIntensityHistogram(Util::ImageHistogramType&& IntensityHistogram) noexcept { this->IntensityHistogram = std::move(IntensityHistogram); }    
        auto GetRGBHistogram() const noexcept { return RGBHistogram; }                                                                                      
        void SetRGBHistogram(Util::ImageRGBHistogramType&& RGBHistogram) noexcept { this->RGBHistogram = std::move(RGBHistogram); }                         
 
        const auto& GetImageTransformation() const noexcept { return ImageTransformation; }                                                     
        void SetImageTransformation(const ImageTransformationType& Transformation) const noexcept { ImageTransformation = Transformation; }     
 
        QImage GetImage() const;
 
        QImage GetImageCopy(const QRect& RegionOfInterest = QRect()) const;
 
        bool IsImageAvailbale() const noexcept { return !CurrentImage.isNull(); }
 
        void SetImage(QImage&& Other);
 
        void ClearImage() const;
 
        auto GetCapturingState() const noexcept { return GetCapturingStateChild(); }
 
        bool IsCapturing() const noexcept { return GetCapturingStateChild() != CapturingStateType::Stopped; }
 
        bool IsCapturingSingle() const noexcept { return GetCapturingStateChild() == CapturingStateType::CapturingSingle; }
 
        bool IsCapturingContinuously() const noexcept { return GetCapturingStateChild() == CapturingStateType::CapturingContinuously; }
 
    private:
        void ResetImpl(dispatch_tag<InstrumentDataBase>) override final;
        virtual void ResetImpl(dispatch_tag<CameraData>) {};                        
 
        virtual CapturingStateType GetCapturingStateChild() const noexcept = 0;     
 
        ImageDimensionType ImageWidth = 0;      
        ImageDimensionType ImageHeight = 0;     
 
        CameraModesType CameraModes;            
 
        TimeType MinExposureTime;               
        TimeType MaxExposureTime;               
        TimeType CurrentExposureTime;           
        float CurrentFPS = 0.f;                 
 
        mutable ComputeHistogramType ComputeHistogram = ComputeHistogramType::NoHistogram;
 
        mutable Util::ImageHistogramType IntensityHistogram = {};
 
        mutable Util::ImageRGBHistogramType RGBHistogram = {};
 
        mutable ImageTransformationType ImageTransformation;
 
        mutable QImage CurrentImage;
    };
 
    class CameraParams : public DynExp::InstrumentParamsBase
    {
    public:
        CameraParams(DynExp::ItemIDType ID, const DynExp::DynExpCore& Core) : InstrumentParamsBase(ID, Core) {}
 
        virtual ~CameraParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "CameraParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<InstrumentParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<CameraParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<CameraParams>) {}     
 
        DummyParam Dummy = { *this };                                       
    };
 
    class CameraConfigurator : public DynExp::InstrumentConfiguratorBase
    {
    public:
        using ObjectType = Camera;
        using ParamsType = CameraParams;
 
        CameraConfigurator() = default;
        virtual ~CameraConfigurator() = 0;
    };
 
    class Camera : public DynExp::InstrumentBase
    {
    public:
        using ParamsType = CameraParams;                                        
        using ConfigType = CameraConfigurator;                                  
        using InstrumentDataType = CameraData;                                  
 
        using InitTaskType = CameraTasks::InitTask;                             
        using ExitTaskType = CameraTasks::ExitTask;                             
        using UpdateTaskType = CameraTasks::UpdateTask;                         
 
        constexpr static auto Name() noexcept { return "Camera"; }              
        constexpr static auto Category() noexcept { return "Image Capturing"; } 
 
        Camera(const std::thread::id OwnerThreadID, DynExp::ParamsBasePtrType&& Params)
            : InstrumentBase(OwnerThreadID, std::move(Params)) {}
 
        virtual ~Camera() = 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(16); /* approx. 63 fps */ }
 
 
        virtual bool CanSetExposureTime() const noexcept { return false; }
 
        virtual double GetPixelSizeInMicrons() const noexcept = 0;
 
 
        virtual void SetCameraMode(size_t ID, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetExposureTime(const CameraData::TimeType ExposureTime, DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const;
 
        virtual void SetExposureTimeSync(const CameraData::TimeType ExposureTime) const;
 
        virtual void CaptureSingle(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void StartCapturing(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void StopCapturing(DynExp::TaskBase::CallbackType CallbackFunc = nullptr) const = 0;
 
        virtual void StopCapturingSync() const;
 
    private:
        void ResetImpl(dispatch_tag<InstrumentBase>) override final;
        virtual void ResetImpl(dispatch_tag<Camera>) = 0;               
    };
 
    template <typename T>
    inline T TransformPixel(T Pixel, const CameraData::ImageTransformationType& ImageTransformation)
    {
        // Apply user transformations
        float PixelF = ImageTransformation.ContrastFactor * Pixel + ImageTransformation.BrightnessFactor * std::numeric_limits<T>::max();
 
        // Round and apply limits.
        PixelF = std::min(static_cast<float>(std::numeric_limits<T>::max()), std::round(PixelF));
        PixelF = std::max(static_cast<float>(std::numeric_limits<T>::lowest()), PixelF);
 
        return static_cast<T>(PixelF);
    }
}