Framescan.h

#pragma once

#include "ScopeDefines.h"
#include "ScopeDatatypes.h"
#include "helpers/ScopeNumber.h"
#include "helpers/ScopeString.h"
#include "helpers/helpers.h"
#include "Base.h"
#include "Plane.h"
#include "IO.h"
#include "devices/InputsDAQmx.h"
#include "devices/OutputsDAQmx.h"

namespace scope {
    
namespace parameters {

using boost::property_tree::wptree;

class ScannerVector
    : public Base {

protected:
    typedef boost::signals2::signal<void ()> signalchange_t;

public:
    virtual uint32_t TotalPixels() const { return 0; }

    virtual uint32_t TotalPixelsOneFrame() const { return 0; }
};

class ScannerVectorLine
    : public ScannerVector {
};

class ScannerVectorFrameBasic
    : public ScannerVector {

public:
    class Preset {
    public:
        ScopeString name;                                                       
    
        ScopeNumber<double> pixeltime;                                  
    
        ScopeNumber<double> scannerdelay;                                       
    
        ScopeNumber<uint32_t> averages;                                         
    
        ScopeNumber<uint32_t> xres;                                             
    
        ScopeNumber<uint32_t> yres;

        ScopeNumber<double> xaspectratio;
    
        ScopeNumber<double> yaspectratio;

        ScopeNumber<bool> squarepixels;

        Preset();

        virtual void Load(const wptree& pt);

        virtual void Save(wptree& pt) const;
    };

    std::vector<std::shared_ptr<Preset>> presets;

    ScannerVectorFrameBasic();

    static std::unique_ptr<ScannerVectorFrameBasic> Create() { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameBasic()); }

    static std::unique_ptr<ScannerVectorFrameBasic> Create(const ScannerVectorFrameBasic& _o) { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameBasic(_o)); }

    static std::unique_ptr<ScannerVectorFrameBasic> Factory(const ScannerVectorType& _type, const ScannerVectorFrameBasic* const _o = nullptr);

    virtual std::vector<boost::signals2::connection> ConnectCopyTrigger(signalchange_t::slot_type _slot);

    virtual void ConnectRateUpdate(signalchange_t::slot_type _slot);

    virtual void ConnectResolutionUpdate(signalchange_t::slot_type _slot);

    virtual void ConnectMicronPerPixelUpdate(signalchange_t::slot_type _slot);

    virtual void ConnectResolutionChange(signalchange_t::slot_type _slot);

    virtual void ConnectOnlineUpdate(signalchange_t::slot_type _slot);

    ScopeNumber<uint32_t> xres;

    ScopeNumber<uint32_t> yres;

    ScopeNumber<double> xaspectratio;
    
    ScopeNumber<double> yaspectratio;
    
    ScopeNumber<bool> squarepixels;

    ScopeNumber<double> zoom;

    ScopeNumber<double> xoffset;

    ScopeNumber<double> yoffset;

    ScopeNumber<double> fastz;

    ScopeNumber<double> pockels;

    ScopeNumber<double> xrotation;

    ScopeNumber<double> yrotation;

    virtual uint32_t XImagePixels() const { return xres(); }

    virtual uint32_t YImageLines() const { return yres(); }

    virtual uint32_t XTotalPixels() const { return xres(); }

    virtual uint32_t YTotalLines() const { return yres(); }

    uint32_t TotalPixels() const override { return TotalPixelsOneFrame(); }

    uint32_t TotalPixelsOneFrame() const override { return xres() * yres(); }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

    virtual std::unique_ptr<ScannerVectorFrameBasic::Preset> MakePreset() const;

    virtual void SaveToPreset(const std::wstring& _name, const Daq& _daq) {}

    virtual void LoadFromPreset(const std::wstring& _name, Daq& _daq) {}

    virtual void DeletePreset(const std::wstring& _name);

    virtual void CoerceOffset();
};

class ScannerVectorFrameSaw
    : public ScannerVectorFrameBasic {

public:
    class Preset
        : public ScannerVectorFrameBasic::Preset {
    public:
        ScopeNumber<double> xcutoff;                                            
    
        ScopeNumber<double> ycutoff;
    
        ScopeNumber<double> xretrace;
    
        ScopeNumber<double> yretrace;

        Preset();

        void Load(const wptree& pt) override;
        void Save(wptree& pt) const override;
    };

    ScannerVectorFrameSaw();

    static std::unique_ptr<ScannerVectorFrameBasic> Create() { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameSaw()); }
    
    static std::unique_ptr<ScannerVectorFrameBasic> Create(const ScannerVectorFrameSaw& _o) { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameSaw(_o)); }
    
    std::vector<boost::signals2::connection> ConnectCopyTrigger(signalchange_t::slot_type _slot) override;

    void ConnectRateUpdate(signalchange_t::slot_type _slot) override;

    void ConnectMicronPerPixelUpdate(signalchange_t::slot_type _slot) override;

    void ConnectOnlineUpdate(signalchange_t::slot_type _slot) override;

    ScopeNumber<double> xcutoff;                                        
    
    ScopeNumber<double> ycutoff;                                            
    
    ScopeNumber<double> xretrace;                                           
    
    ScopeNumber<double> yretrace;                                           
    
    uint32_t XCutoffPixels() const { return round2ui32(xcutoff()*static_cast<double>(XImagePixels())); }        
    
    uint32_t XScanPixels() const { return XImagePixels() + XCutoffPixels(); }                       
    
    uint32_t XRetracePixels() const { return round2ui32(xretrace()*static_cast<double>(XImagePixels())); }      
    
    uint32_t XTotalPixels() const override { return XCutoffPixels()+XImagePixels()+XRetracePixels(); }      
    
    uint32_t YCutoffLines() const { return round2ui32(ycutoff()*static_cast<double>(YImageLines())); }
    
    uint32_t YScanLines() const { return YImageLines() + YCutoffLines(); }
    
    uint32_t YRetraceLines() const { return round2ui32(yretrace()*static_cast<double>(YImageLines())); }
    
    uint32_t YTotalLines() const override { return YCutoffLines()+YImageLines()+YRetraceLines(); }
    
    uint32_t TotalPixels() const override { return TotalPixelsOneFrame(); }

    uint32_t TotalPixelsOneFrame() const override { return XTotalPixels()*YTotalLines(); }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

    std::unique_ptr<ScannerVectorFrameBasic::Preset> MakePreset() const override;

    void SaveToPreset(const std::wstring& _name, const Daq& _daq) override;
    void LoadFromPreset(const std::wstring& _name, Daq& _daq) override;
};

class ScannerVectorFrameBiDi
    : public ScannerVectorFrameBasic {

public:
    class Preset
        : public ScannerVectorFrameBasic::Preset {
    public:
        ScopeNumber<double> xturnfraction;

        ScopeNumber<double> ycutoff;

        ScopeNumber<double> yretrace;
    
        Preset();

        void Load(const wptree& pt) override;
        void Save(wptree& pt) const override;
    };

    ScannerVectorFrameBiDi();

    static std::unique_ptr<ScannerVectorFrameBasic> Create() { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameBiDi()); }

    static std::unique_ptr<ScannerVectorFrameBasic> Create(const ScannerVectorFrameBiDi& _o) { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameBiDi(_o)); }

    std::vector<boost::signals2::connection> ConnectCopyTrigger(signalchange_t::slot_type _slot) override;

    void ConnectRateUpdate(signalchange_t::slot_type _slot) override;

    void ConnectMicronPerPixelUpdate(signalchange_t::slot_type _slot) override;

    void ConnectOnlineUpdate(signalchange_t::slot_type _slot) override;

    ScopeNumber<double> xturnfraction;
    
    ScopeNumber<double> ycutoff;

    ScopeNumber<double> yretrace;

    uint32_t XTurnPixels() const { return round2ui32(static_cast<double>(XImagePixels()) * xturnfraction()); }

    uint32_t XTotalPixels() const override { return XImagePixels() + XTurnPixels(); }

    uint32_t YCutoffLines() const { return round2ui32(ycutoff()*static_cast<double>(YImageLines())); }
    
    uint32_t YScanLines() const { return YImageLines() + YCutoffLines(); }
    
    uint32_t YRetraceLines() const { return round2ui32(yretrace()*static_cast<double>(YImageLines())); }
    
    uint32_t YTotalLines() const override { return YCutoffLines()+YImageLines()+YRetraceLines(); }
    
    
    uint32_t TotalPixels() const override { return XTotalPixels()*YTotalLines(); }

    uint32_t TotalPixelsOneFrame() const override { return XTotalPixels()*YTotalLines(); }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

    std::unique_ptr<ScannerVectorFrameBasic::Preset> MakePreset() const override;

    void SaveToPreset(const std::wstring& _name, const Daq& _daq) override;
    void LoadFromPreset(const std::wstring& _name, Daq& _daq) override;
};

class ScannerVectorFramePlaneHopper
    : public ScannerVectorFrameBasic {

public:
    class Preset
        : public ScannerVectorFrameBasic::Preset {
    public:
        std::vector<PlaneProperties> planes;
    
        Preset();

        void Load(const wptree& pt) override;
        void Save(wptree& pt) const override;
    };

    ScannerVectorFramePlaneHopper();

    static std::unique_ptr<ScannerVectorFrameBasic> Create() { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFramePlaneHopper()); }

    static std::unique_ptr<ScannerVectorFrameBasic> Create(const ScannerVectorFramePlaneHopper& _o) { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFramePlaneHopper(_o)); }

    std::vector<boost::signals2::connection> ConnectCopyTrigger(signalchange_t::slot_type _slot) override;

    void ConnectRateUpdate(signalchange_t::slot_type _slot) override;

    void ConnectMicronPerPixelUpdate(signalchange_t::slot_type _slot) override;

    void ConnectOnlineUpdate(signalchange_t::slot_type _slot) override;

    std::vector<PlaneProperties> planes;

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

    std::unique_ptr<ScannerVectorFrameBasic::Preset> MakePreset() const override;

    void SaveToPreset(const std::wstring& _name, const Daq& _daq) override;
    void LoadFromPreset(const std::wstring& _name, Daq& _daq) override;
};

class ScannerVectorFrameResonance
    : public ScannerVectorFrameBasic {

public:
    class Preset
        : public ScannerVectorFrameBasic::Preset {
    public:
        ScopeNumber<double> xturnfraction;

        ScopeNumber<double> ycutoff;

        ScopeNumber<double> yretrace;
    
        ScopeNumber<uint32_t> waitafterenqueuestorage;

        ScopeNumber<uint32_t> waitafterenqueuedisplay;

        Preset();

        void Load(const wptree& pt) override;
        void Save(wptree& pt) const override;
    };

    ScannerVectorFrameResonance();

    static std::unique_ptr<ScannerVectorFrameBasic> Create() { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameResonance()); }

    static std::unique_ptr<ScannerVectorFrameBasic> Create(const ScannerVectorFrameResonance& _o) { return std::unique_ptr<ScannerVectorFrameBasic>(new ScannerVectorFrameResonance(_o)); }

    std::vector<boost::signals2::connection> ConnectCopyTrigger(signalchange_t::slot_type _slot) override;

    void ConnectRateUpdate(signalchange_t::slot_type _slot) override;

    void ConnectMicronPerPixelUpdate(signalchange_t::slot_type _slot) override;

    void ConnectOnlineUpdate(signalchange_t::slot_type _slot) override;

    ScopeNumber<double> xturnfraction;
    
    ScopeNumber<double> ycutoff;

    ScopeNumber<double> yretrace;

    ScopeNumber<uint32_t> waitafterenqueuestorage;

    ScopeNumber<uint32_t> waitafterenqueuedisplay;

    uint32_t XTurnPixels() const { return round2ui32(static_cast<double>(XImagePixels()) * xturnfraction()); }

    uint32_t XTurnPixelsLeft() const { return static_cast<uint32_t>(floor(static_cast<double>(XTurnPixels()) / 2)); }
    
    uint32_t XTurnPixelsRight() const { return static_cast<uint32_t>(ceil(static_cast<double>(XTurnPixels()) / 2)); }

    uint32_t XTotalPixels() const override { return XImagePixels() + XTurnPixels(); }

    uint32_t YCutoffLines() const { return 2 * round2ui32(ycutoff()*static_cast<double>(YImageLines())/2); }
    
    uint32_t YScanLines() const { return YImageLines() + YCutoffLines(); }
    
    uint32_t YRetraceLines() const { return 2 * round2ui32(yretrace()*static_cast<double>(YImageLines())/2); }
    
    uint32_t YTotalLines() const override { return YCutoffLines()+YImageLines()+YRetraceLines(); }

    uint32_t TotalPixels() const override { return XTotalPixels()*YTotalLines(); }

    uint32_t TotalPixelsOneFrame() const override { return XTotalPixels()*YTotalLines(); }

    void Load(const wptree& pt) override;
    void Save(wptree& pt) const override;
    void SetReadOnlyWhileScanning(const RunState& _runstate) override;

    std::unique_ptr<ScannerVectorFrameBasic::Preset> MakePreset() const override;

    void SaveToPreset(const std::wstring& _name, const Daq& _daq) override;
    void LoadFromPreset(const std::wstring& _name, Daq& _daq) override;

    virtual void CoerceYResolution();

    virtual void UpdateXTurnFraction();
};

}

}