dataFrame.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_DATA_FRAME_HPP_H_
#define CCF_COMMON_DATA_FRAME_HPP_H_
 
#include <core/utils/param/parameter.hpp>
 
#include <ccf/common/base.hpp>
#include <ccf/common/dataType.hpp>
 
 
namespace 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 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;
 
    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] = core::utils::param::Parameter(name, std::to_string(value));
      }
 
    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;
    int64_t        m_int_frame_count;
 
    int64_t        m_sub_frame_count;
    int64_t        m_exp_nb_sub_frames;
 
    uint8_t        m_consumer_count;
 
    double         m_handling_start_time;
 
    void*          m_buffer;
    uint32_t       m_size;
    uint32_t       m_expected_size;
    uint32_t       m_cur_allocated;
    bool           m_completed;
 
    double         m_time;
 
    DataType       m_data_type;
    int32_t        m_offset_x;
    int32_t        m_offset_y;
    int32_t        m_width;
    int32_t        m_height;
    int32_t        m_depth;
 
    std::map<std::string, 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_