dataFrame.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_DATA_FRAME_HPP_H_
#define CCF_COMMON_DATA_FRAME_HPP_H_
 
#include <ifw/fnd/defs/dataType.hpp>
 
#include <ifw/core/utils/param/parameter.hpp>
 
#include <ifw/ccf/common/base.hpp>
 
 
namespace ifw::ccf::common {
 
  class DataFrame: public Base {
  public:
 
    //inline static int32_t GetCFitsioType(const DataType data_type);
 
    DataFrame(const std::string& frame_id,
              const int16_t frame_q_nb);
 
    DataFrame(const DataFrame& source);
 
    DataFrame();
 
    ~DataFrame();
 
    void Reset();
 
    const std::string& GetFrameId() const;
 
    int16_t GetFrameQNb() const;
 
    void Store(const void*                    buffer,
               const uint32_t                 size,
               const double                   time,
               const int64_t                  cam_frame_count,
               const int64_t                  int_frame_count,
               const int64_t                  sub_frame_count,
               const int64_t                  exp_nb_sub_frames,
               const ifw::fnd::datatype::DataType  data_type,
               const int32_t                  offset_x,
               const int32_t                  offset_y,
               const int32_t                  width,
               const int32_t                  height,
               const int32_t                  depth = 1);
 
    void AddData(const void*         buffer,
                 const uint32_t      size);
 
    const void* GetBuffer() const;
 
    void* GetBufferReadWrite() const;
 
    uint32_t GetBufferSize() const;
 
    uint32_t GetDataSize() const;
 
    void ResetDataSize();
 
    double GetDataSum() const;
 
    double GetTime() const;
 
    int64_t GetCamFrameCount() const;
 
    int64_t GetIntFrameCount() const;
 
    int64_t GetSubFrameCount() const;
 
    int64_t GetExpNbSubFrames() const;
 
    int32_t GetOffsetX() const;
 
    int32_t GetOffsetY() const;
 
    int32_t GetWidth() const;
 
    int32_t GetHeight() const;
 
    int32_t GetDepth() const;
 
    ifw::fnd::datatype::DataType GetDataType() const;
 
    int32_t GetResolution() const;
 
    bool GetCompleted() const;
 
    void SetCompleted();
 
    template <class TYPE>
      void AddMetaData(const std::string& name,
                       TYPE& value) {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        //m_meta_data[name] = ifw::core::utils::param::Parameter(name, std::to_string(value));
        if constexpr(std::is_arithmetic_v<TYPE>) {
            // Use std::to_string for numeric types
            m_meta_data[name] = ifw::core::utils::param::Parameter(name, std::to_string(value));
        } else if constexpr(std::is_same_v<TYPE, std::string>) {
            // Use the string directly
            m_meta_data[name] = ifw::core::utils::param::Parameter(name, value);
        } else {
            // Compilation error for unsupported types
            static_assert(std::is_arithmetic_v<TYPE> || std::is_same_v<TYPE, std::string>,
                          "Unsupported type: AddMetaData only supports numeric types and "
                          "std::string");
        }
      }
 
    void RemoveMetaData(const std::string& name);
 
    template <class TYPE>
      bool HasMetadata(const std::string& name,
                       TYPE& value) const {
        LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
        auto it = m_meta_data.find(name);
        if (it == m_meta_data.end()) {
          return false;
        }
        it->second.GetValue(value);
        return true;
    }
 
    std::string ToString(const bool full = false) const;
 
    void SetConsumerCount(const uint8_t count);
 
    uint8_t GetConsumerCount() const;
 
    void DecrementConsumerCount(const uint8_t decr = 1);
 
    void SetHandlingStartTime(const double time);
 
    double GetHandlingStartTime() const;
 
    double GetHandlingTime() const;
 
    DataFrame& operator = (const DataFrame& source);
 
  protected:
 
  private:
    void Initialise(const std::string& frame_id = "",
                     const int64_t frame_nb = -1);
    void Copy(const DataFrame& source);
 
    std::string    m_frame_id;
    int64_t        m_frame_q_nb;
 
    int64_t        m_cam_frame_count{0};
    int64_t        m_int_frame_count{0};
 
    int64_t        m_sub_frame_count{0};
    int64_t        m_exp_nb_sub_frames{0};
 
    uint8_t        m_consumer_count{0};
 
    double         m_handling_start_time{0.0};
 
    void*          m_buffer{nullptr};
    uint32_t       m_size{0};
    uint32_t       m_expected_size{0};
    uint32_t       m_cur_allocated{0};
    bool           m_completed{false};
 
    double         m_time{0.0};
 
    ifw::fnd::datatype::DataType   m_data_type{ifw::fnd::datatype::DataType::UNSPECIFIED};
    int32_t                   m_offset_x{1};
    int32_t                   m_offset_y{1};
    int32_t                   m_width{0};
    int32_t                   m_height{0};
    int32_t                   m_depth{1};
 
    std::map<std::string, ifw::core::utils::param::Parameter> m_meta_data;
 
    template <class DATA_TYPE>
    double Sum() const {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
      double sum = 0;
      DATA_TYPE* p = static_cast<DATA_TYPE*>(m_buffer);
      for (int64_t i = 0; i < GetDataSize(); i++) {
          sum += static_cast<DATA_TYPE>(*p++);
        }
      return sum;
    }
 
  };
 
}
 
#endif // CCF_COMMON_DATA_FRAME_HPP_H_