pubFits.hpp

Go to the documentation of this file.

 
#ifndef CCF_STDPUB_PUB_FITS_HPP_H_
#define CCF_STDPUB_PUB_FITS_HPP_H_
 
#include <fitsio.h>
#include <CCfits/CCfits.h>
#include <CCfits/FITS.h>
#include <CCfits/PHDU.h>
 
#include <ifw/core/dit/fits/fits.hpp>
 
#include <ifw/ccf/common/pubBase.hpp>
 
namespace ifw::ccf::stdpub {

  class PubFits: public ifw::ccf::common::PubBase {
  public:
 
    static bool s_initialised;
    static char s_padding_bytes[2880];
 
    // Setup keys.
    const std::string SETUP_KEY_NB_OF_FRAMES       = "nb_of_frames";
    const std::string SETUP_KEY_OVERWRITE          = "overwrite";
    const std::string SETUP_KEY_REC_MODE           = "rec_mode";
    const std::string SETUP_KEY_NB_REC_HDR_BLOCKS  = "nb_of_hdr_blocks";
    const std::string SETUP_KEY_ADD_TIMESTAMPS_TBL = "add_timestamps_tbl";
 
    enum class Format {
      SINGLE = 1,
      CUBE,
      MEF,
      // Same per-frame logic as CUBE (one growing 3-D image with
      // NAXIS3 incremented per frame) but the cube lives in the
      // first image extension instead of the Primary HDU; the
      // Primary HDU is empty (NAXIS=0).
      CUBE_X
    };
 
    const std::string FORMAT_SINGLE    = "Single";
    const std::string FORMAT_CUBE      = "Cube";
    const std::string FORMAT_MEF       = "MEF";
    const std::string FORMAT_CUBE_X    = "CubeX";
 
    enum class RecordingMode {
        ALL = 1,
        INTERVAL,
        PERIODIC
    };
 
    const std::string RECORDING_MODE_ALL      = "ALL";
    const std::string RECORDING_MODE_INTERVAL = "INTERVAL";
    const std::string RECORDING_MODE_PERIODIC = "PERIODIC";
 
    enum class TimestampTableType {
        NONE = 0,
        BINARY,
        ASCII
    };
 
    const std::string TIMESTAMP_TBL_NONE   = "None";
    const std::string TIMESTAMP_TBL_BINARY = "Binary";
    const std::string TIMESTAMP_TBL_ASCII  = "ASCII";
 
    PubFits(const std::string& proc_thread_name,
            const std::string& pub_thread_name);
 
    PubFits();
 
    virtual ~PubFits();
 
    virtual void InitialiseUser();
 
    virtual void PublishUser(ifw::ccf::common::DataFrame& frame);
 
    virtual void CheckForDeactivationUser();
 
    virtual void ActivateUser();
 
    virtual void DeactivateUser();
 
    virtual void CreateObjectUser(const std::string& proc_thread_name,
                                  const std::string& pub_thread_name,
                                  PubBase** new_object);
 
    virtual void EstimateExecutionUser(double& duration,
                                       int64_t& nb_of_frames);
 
    Format        FormatToNb(const std::string& format);
 
    std::string   FormatToStr(const Format format);
 
    void          DecodeRecMode(const std::string& rec_mode_specifier);
 
    std::string   RecordingModeToStr(const RecordingMode mode);
 
    TimestampTableType TimestampTblTypeToNb(const std::string& type);
 
    std::string   TimestampTblTypeToStr(const TimestampTableType type);
 
  protected:
 
  private:
    void StoreImage_(ifw::ccf::common::DataFrame& frame);
    void AddStdKeys_(ifw::ccf::common::DataFrame& frame);
    void WriteTimestampTable_();
 
    // Setup parameters.
    std::string            m_setup_file_basename;
    int32_t                m_setup_max_size;
    int32_t                m_setup_nb_of_frames;
    Format                 m_setup_format;
    bool                   m_setup_overwrite;
    RecordingMode          m_setup_rec_mode; 
    int32_t                m_setup_frame_interval;
    double                 m_setup_frame_period;
    ifw::ccf::ExpoMode          m_setup_expo_mode;
    int32_t                m_setup_expo_nb;
    int16_t                m_nb_of_hdr_blocks;
    bool                   m_store_telemetry_in_dps{false};
    TimestampTableType     m_setup_timestamps_tbl{TimestampTableType::NONE};
 
    std::string            m_stat_cur_filename;
    std::string            m_stat_prev_filename;
 
    int32_t                m_stat_frames_stored;
    double                 m_stat_last_frame_storage_time;
    double                 m_stat_size_frames_stored_mb;
 
    // Total number of frames made available to this Data Publisher.
    uint32_t               m_stat_frame_count;
 
    std::shared_ptr<CCfits::FITS> m_fits_handle;
 
    // Frame timestamp data for FRAMES_TIMESTAMPS table.
    // Columns: fits_pub_count, cam_frame_count, int_frame_count, timestamp
    std::vector<int32_t>   m_ts_fits_pub_count;
    std::vector<int64_t>   m_ts_cam_frame_count;
    std::vector<int64_t>   m_ts_int_frame_count;
    std::vector<double>    m_ts_timestamps;
 
    // Fix metadata values.
    std::string      m_det_system;
    std::string      m_det_cam_name;
    std::string      m_det_cam_id;
    std::string      m_det_cam_model;
    std::string      m_det_cam_chip_model;
    std::string      m_det_cam_type;
  };
 
}
 
#endif // CCF_STDPUB_PUB_FITS_HPP_H_