Scope.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 "Storage.h"
#include "Runstates.h"
#include "Framescan.h"
#include "Devices.h"
#include "IO.h"
#include "Windows.h"

namespace scope {

namespace parameters {

using boost::property_tree::wptree;

class Stimulation
    : public Base {

public:
    Stimulation();

    ScopeString channel;
    
    ScopeString timingsource;
    
    ScopeNumber<bool> enable;
    
    ScopeNumber<double> onset;
    
    ScopeNumber<double> duration;
    
    ScopeNumber<double> ontime;
    
    ScopeNumber<double> offtime;

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


class Area
    : public Base {

public:
    ScopeNumber<uint32_t> area;

    ScopeNumber<bool> isslave;

    Area* masterarea;
    
    Daq daq;

    SCOPE_FPUXYCONTROL_T fpuxystage;
    
    SCOPE_FPUZCONTROL_T fpuzstage;
    
    ScopeValue<ScannerVectorType> scanmode;

    std::map<ScannerVectorTypeHelper::Mode, std::unique_ptr<ScannerVectorFrameBasic>> scannervectorframesmap;

    ScopeNumber<double> basemicronperpixelx;
    ScopeNumber<double> basemicronperpixely;
    ScopeNumber<double> micronperpixelx;
    ScopeNumber<double> micronperpixely;
    ScopeNumber<double> linerate;
    
    ScopeNumber<double> framerate;

    ScopeNumber<double> frametime;

    ScopeNumber<uint32_t> histrange;

    Area(const uint32_t& _area = 0, const bool& _isslave = false, Area * const _masterarea = nullptr);

    Area(const Area& _other);

    Area& operator=(const Area& v);

    virtual ~Area() { }

    void SetMasterArea(Area* const _masterarea);

    void CopyFromMasterArea();

    ScannerVectorFrameBasic& Currentframe() const;

    ScannerVectorFrameSaw& FrameSaw() const;

    ScannerVectorFrameResonance& FrameResonance() const;

    ScannerVectorFrameBiDi& FrameBiDi() const;

    ScannerVectorFramePlaneHopper& FrameHopper() const;

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

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

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

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

    virtual double FrameTime() const;

    virtual double LineTime() const;

    virtual uint32_t TotalPixelsAllChannels() const;

    virtual double XOffsetInMicron() const;

    virtual double YOffsetInMicron() const;

protected:
    virtual void InitializeConnections();

    virtual void ChangeScanMode();

    virtual void UpdateRates();

    virtual void UpdateFastZCalibration();

    virtual void CalculateMicronPerPixel();

    virtual void CalculateResolution();
};

class Scope
    : public Base {

protected:
    virtual void UpdateTotaltimeFromFrames();

    virtual void UpdateFramesFromTotaltime();

public:
    ScopeString date;
    
    ScopeString time;

    ScopeString scopecommit;
    
    ScopeString comment;

    ScopeValue<ScannerType> scannertype;
    
    std::array<std::unique_ptr<Area>, SCOPE_NAREAS> areas;
    
    Storage storage;
    
    Stack stack;
    
    Timeseries timeseries;

    Behavior behavior;
    
    SCOPE_XYZCONTROL_T stage;
    
    Stimulation stimulation;

    WindowCollection frames;

    ScopeNumber<bool> startinputsfirst;

    ScopeString commontrigger;

    ScopeNumber<double> masterfovsizex;

    ScopeNumber<double> masterfovsizey;

    ScopeValue<RunState> run_state;
    
    ScopeValue<DaqMode> requested_mode;

public:
    Scope();

    Scope(const Scope& _scope);

    Scope& operator=(const Scope& _scope);

    void Load(const std::wstring& filename);

    void Save(const std::wstring& filename) const;

    void SetReadOnlyWhileScanning(const RunState& _runstate) override;
};


}

}