comAdptSim.hpp

Go to the documentation of this file.

 
#ifndef CCF_CONTROL_COM_ADPT_SIM_HPP_H_
#define CCF_CONTROL_COM_ADPT_SIM_HPP_H_
 
#include <vector>
 
#include <ifw/ccf/common/dataFrame.hpp>
#include <ifw/ccf/common/comAdptBase.hpp>
 
#include <ifw/ccf/control/defines.hpp>

 
namespace ifw::ccf::control {

  class ComAdptSim: public ifw::ccf::common::ComAdptBase {
  public:
    ComAdptSim();
    virtual ~ComAdptSim();
 
    virtual void InitialiseUser() override;
 
    virtual void SetDeviceAddressUser(const std::string& address) override;
 
    virtual void CheckConnectionUser(bool& connected) override;
 
    virtual void CheckStatusUser(ifw::ccf::HwStatus& status,
                                 std::string& message) override;
 
    virtual void ConnectUser() override;
 
    virtual void DisconnectUser() override;
 
    virtual void ReadUser(const std::string& name,
                          ifw::core::utils::param::Parameter& par) override;
 
    virtual void ReceiveUser(ifw::ccf::common::DataFrame& frame,
                             bool& frame_received,
                             const double timeout,
                             bool& timed_out) override;
 
    virtual void ScanUser(std::vector<ifw::core::utils::param::Parameter>& pars) override;
 
    virtual void StartUser() override;
 
    virtual void StopUser() override;
 
    virtual void WriteUser(const ifw::core::utils::param::Parameter& par) override;
 
    virtual void HandleSetupUser() override;
 
    virtual void HandleParPreWriteUser(ifw::core::utils::param::Parameter& par) override;
 
    virtual void HandleParPostWriteUser(ifw::core::utils::param::Parameter& par) override;
 
    virtual void HandleParPostReadUser(ifw::core::utils::param::Parameter& par) override;
 
    virtual void SetAcqTriggerUser();
 
  protected:
 
 
  private:
    void LoadSimImage();
    void GenSequenceFromSingleImage(void* source_image, uint32_t image_size);
    void ReadPatternParams();
    void GenSimPattern();
    void GenNextFrame(ifw::ccf::common::DataFrame& frame);
    void PreprocessAllFrames();
 
    ifw::ccf::common::DataFrame m_base_frame;
 
    // Indicates if acquisition is running
    bool                   m_acq_active{false};
    uint64_t               m_cam_frame_count; // Frame count (complete frames)
    uint64_t               m_int_frame_count; // Internal frame count, used to index FITS cubes.
    ifw::ccf::SimType      m_sim_type;

    // Input frame used as basis for the simulation:
    std::string                   m_sim_filename;
    ifw::fnd::fits::BitPix        m_bitpix;
    ifw::fnd::datatype::DataType  m_in_image_data_type;
    uint8_t                       m_in_bytes_per_pixel;
 
    int32_t        m_in_naxis1;
    int32_t        m_in_naxis2;
    int32_t        m_in_naxis3;

    // Pre-processed frame buffer (windowed + binned):
    std::vector<uint8_t> m_processed_buffer;  // All pre-processed frames concatenated
    uint32_t m_processed_frame_size{0};       // Size of one processed frame in bytes
    int32_t m_processed_naxis1{0};            // Width after window+binning
    int32_t m_processed_naxis2{0};            // Height after window+binning
    int32_t m_processed_naxis3{1};            // Number of frames (from cube)

    // Output frame parameters:
 
    double         m_time_for_last_frame; // Time for generating last frame.
    double         m_expo_time;           // Exposure time in seconds.
    double         m_frame_period;        // Period for frame generation (1/frame_rate or expo_time).
 
    // Current ROI (1-based, as per FITS convention):
    int32_t        m_out_win_offset_x{1}; // First pixel = 1
    int32_t        m_out_win_offset_y{1};
    int32_t        m_out_win_width{0};
    int32_t        m_out_win_height{0};
 
    // Binning factors:
    int32_t        m_bin_x{1};
    int32_t        m_bin_y{1};
 
    // Gain/sensitivity for scaling pixel values.
    // Pixel values in input file are assumed to correspond to expo_time=1s.
    // Output pixel = input_pixel * expo_time * gain (before binning).
    double         m_gain{1.0};

    // Pattern generation parameters:
    int16_t        m_nb_of_planes{10};
    int16_t        m_pattern_width{512};
    int16_t        m_pattern_height{512};
    int16_t        m_max_shift_pr_frame{5};
    int16_t        m_max_shift{50};
    int16_t        m_noise_level{10};
 
    // Gaussian/MultiGaussian:
    double         m_amplitude{10000.0};
    double         m_sigma{5.0};
    int16_t        m_nb_stars{1};
 
    // Flat:
    double         m_flat_intensity{1000.0};
 
    // Grid:
    int16_t        m_grid_spacing{50};
    double         m_spot_size{3.0};
 
    // Gradient:
    ifw::ccf::GradientDir m_gradient_dir{ifw::ccf::GradientDir::HORIZONTAL};
    double         m_gradient_start{0.0};
    double         m_gradient_end{10000.0};
 
    // Ring (defocused star):
    double         m_ring_inner_radius{5.0};
    double         m_ring_outer_radius{10.0};
 
    // Checkerboard:
    int16_t        m_checker_size{20};
 
    // Noise-only:
    ifw::ccf::NoiseDist m_noise_dist{ifw::ccf::NoiseDist::GAUSSIAN};
    double         m_noise_mean{1000.0};
    double         m_noise_std{100.0};
 
    // Grating:
    double         m_grating_dispersion{1.0};
    double         m_grating_wavelength_min{400.0};
    double         m_grating_wavelength_max{700.0};
    int16_t        m_grating_order{1};
 
    // Target pixel format (from PixelFormat device property):
    double         m_target_max_pixel{65535.0};  // Max pixel value based on bit depth
 
  };
 
}
 
#endif // CCF_CONTROL_COM_ADPT_SIM_HPP_H_