Class Definition - 2023.2 English

template <int T, int ROWS, int COLS, int NPC, int XFCVDEPTH = _XFCVDEPTH_DEFAULT>
class Mat {
   public:
   unsigned char allocatedFlag; // flag to mark memory allocation in this class
   int rows, cols, size;        // actual image size

   typedef XF_TNAME(T, NPC) DATATYPE;
   using _DATATTYPE = typename std::conditional<
      (XFCVDEPTH < 0),
      DATATYPE*,                 // Case of Memory Mapped pointer
      typename std::conditional< // Case of Stream
         (XFCVDEPTH == 0),
         hls::stream<DATATYPE>,           // Case of default Dtream depth or user can override outside
         hls::stream<DATATYPE, XFCVDEPTH> // Case of Stream depth specified
         >::type>::type;
   _DATATTYPE data;

   Mat(); // default constructor
   Mat(Size _sz);
   Mat(int _rows, int _cols);
   Mat(int _size, int _rows, int _cols);
   Mat(int _rows, int _cols, void* _data);
   Mat(const Mat&); // copy constructor

   ~Mat();

   Mat& operator=(const Mat&); // Assignment operator

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void alloc_data() {
#ifndef __SYNTHESIS__
      data = (DATATYPE*)malloc(size * sizeof(DATATYPE));

      if (data == NULL) {
         fprintf(stderr, "\nFailed to allocate memory\n");
      } else {
         allocatedFlag = 1;
      }
#endif
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void alloc_data() {
      // This is a stream
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void free_data() {
      if (data != NULL) {
#ifndef __SYNTHESIS__
         free(data);
#endif
      }
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void free_data() {}

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void copyData(const Mat& src) {
      for (int i = 0; i < (rows * ((cols + NPC - 1) >> XF_BITSHIFT(NPC))); ++i) {
         data[i] = src.data[i];
      }
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void copyData(const Mat& src) {
      // This is a stream
      assert(0);
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void assignDataPtr(void* _data) {
      data = (DATATYPE*)_data;
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void assignDataPtr(void* _data) {
      // This is a stream
      assert(0);
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   XF_TNAME(T, NPC)
   read(int index) {
      return data[index];
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   XF_TNAME(T, NPC)
   read(int index) {
      return data.read();
   }
   float read_float(int index);

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void write(int index, XF_TNAME(T, NPC) val) {
      data[index] = val;
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void write(int index, XF_TNAME(T, NPC) val) {
      data.write(val);
   }
   void write_float(int index, float val);

   template <int D = XFCVDEPTH, typename std::enable_if<(D >= 0)>::type* = nullptr>
   void init(int _rows, int _cols, void* _data) {
      init(_rows, _cols);
      copyTo(_data);
   }

   template <int D = XFCVDEPTH, typename std::enable_if<(D < 0)>::type* = nullptr>
   void init(int _rows, int _cols, void* _data) {
      init(_rows, _cols, false);
      assignDataPtr(_data);
   }

   void init(int _rows, int _cols, bool allocate = true);
   void copyTo(void* fromData);
   unsigned char* copyFrom();

   const int type() const;
   const int depth() const;
   const int channels() const;

   template <int DST_T>
   void convertTo(Mat<DST_T, ROWS, COLS, NPC, XFCVDEPTH>& dst, int otype, double alpha = 1, double beta = 0);
};