Change tensorimpl opencv future_std::span<cv::Mat> to cv::Mat

include/aidge/backend/opencv/data/TensorImpl.hpp

@@ -37,7 +37,7 @@ private:
     const Tensor &mTensor; // Impl needs to access Tensor information, but is not
                            // supposed to change it!
 
-    future_std::span<cv::Mat> mData;
+    cv::Mat mData;
 
     std::unique_ptr<cv::Mat> mDataOwner = std::unique_ptr<cv::Mat>(new cv::Mat(0,0,OpenCvType<T>::type));
     
@@ -50,9 +50,9 @@ public:
     bool operator==(const TensorImpl &otherImpl) const override final {
         // Create iterators for both matrices
         cv::MatConstIterator_<T> it1 = mDataOwner->begin<T>();
-        const future_std::span<cv::Mat> tmp = reinterpret_cast<const TensorImpl_opencv<T> &>(otherImpl).data();
+
+        const cv::Mat otherData = reinterpret_cast<const TensorImpl_opencv<T> &>(otherImpl).data();
         
-        const cv::Mat otherData = *(tmp.data());
         cv::MatConstIterator_<T> it2 = otherData.begin<T>();
 
         // Iterate over the elements and compare them
@@ -69,18 +69,18 @@ public:
     }
 
     // native interface
-    const future_std::span<cv::Mat> data() const { return mData; }
+    const cv::Mat data() const { return mData; }
 
     std::size_t scalarSize() const override { return sizeof(T); }
 
-    std::size_t size() const override { return mData.size(); }
+    std::size_t size() const override { return mData.total() * mData.channels(); }
 
     void setDevice(DeviceIdx_t device) override {
         AIDGE_ASSERT(device == 0, "device cannot be != 0 for Opencv backend");
     }
 
     void copy(const void *src, NbElts_t length, NbElts_t offset = 0) override {
-        AIDGE_ASSERT(length <= mData.size() || length <= mTensor.size(), "copy length is above capacity");
+        AIDGE_ASSERT(length <= size() || length <= mTensor.size(), "copy length is above capacity");
         std::copy(static_cast<const T *>(src), static_cast<const T *>(src) + length,
                   static_cast<T *>(rawPtr()) + offset);
     }
@@ -90,7 +90,7 @@ public:
             return;
         }
 
-        AIDGE_ASSERT(length <= mData.size() || length <= mTensor.size(), "copy length is above capacity");
+        AIDGE_ASSERT(length <= size() || length <= mTensor.size(), "copy length is above capacity");
         if (srcDt == DataType::Float64) {
             std::copy(static_cast<const double*>(src), static_cast<const double*>(src) + length,
                     static_cast<T *>(rawPtr()));
@@ -152,7 +152,7 @@ public:
     }
 
     void copyToHost(void *dst, NbElts_t length) const override {
-        AIDGE_ASSERT(length <= mData.size() || length <= mTensor.size(), "copy length is above capacity");
+        AIDGE_ASSERT(length <= size() || length <= mTensor.size(), "copy length is above capacity");
         const T* src = static_cast<const T*>(rawPtr());
         std::copy(static_cast<const T *>(src), static_cast<const T *>(src) + length,
                   static_cast<T *>(dst));
@@ -160,27 +160,29 @@ public:
 
     void *rawPtr(NbElts_t offset = 0) override {
         lazyInit();
-        return (mData.data()->ptr() + offset*sizeof(T));
+        return (mData.ptr<T>() + offset);
     };
 
     const void *rawPtr(NbElts_t offset = 0) const override {
-        AIDGE_ASSERT(mData.size() >= mTensor.size(), "accessing uninitialized const rawPtr");
-        return (mData.data()->ptr() + offset*sizeof(T));
+        AIDGE_ASSERT(size() >= mTensor.size(), "accessing uninitialized const rawPtr");
+        return (mData.ptr<T>() + offset);
     };
 
     void *hostPtr(NbElts_t offset = 0) override {
         lazyInit();
-        std::cout << *reinterpret_cast<T *>(mData.data()->ptr()) + offset << std::endl;
-        return (mData.data()->ptr() + offset*sizeof(T));
+        return (mData.ptr<T>() + offset);
     };
 
     const void *hostPtr(NbElts_t offset = 0) const override {
-        AIDGE_ASSERT(mData.size() >= mTensor.size(), "accessing uninitialized const hostPtr");
-        return (mData.data()->ptr() + offset*sizeof(T));
+        AIDGE_ASSERT(size() >= mTensor.size(), "accessing uninitialized const hostPtr");
+        AIDGE_ASSERT(mData.isContinuous(), "CV Matrix not continuous");
+        return (mData.ptr<T>() + offset);
     };
 
     const cv::Mat& getCvMat() const override { return *mDataOwner.get(); }
-    void setCvMat(const cv::Mat& mat) override {mDataOwner.reset(new cv::Mat(std::move(mat)));}
+    void setCvMat(const cv::Mat& mat) override {
+        mDataOwner.reset(new cv::Mat(std::move(mat)));
+        mData = *mDataOwner.get();}
     
 
   virtual ~TensorImpl_opencv() = default;
@@ -188,7 +190,7 @@ public:
 private:
 
   void lazyInit() {
-    if (mData.size() < mTensor.size()) {
+    if (size() < mTensor.size()) {
         // Need more data, a re-allocation will occur
         AIDGE_ASSERT(mData.empty() || mDataOwner != nullptr, "trying to enlarge non-owned data");
 
@@ -212,7 +214,7 @@ private:
         }
 
         mDataOwner.reset(new cv::Mat(std::forward<cv::Mat>(myNewMatrix)));
-        mData = future_std::span<cv::Mat>(mDataOwner.get(), mTensor.size());
+        mData = *mDataOwner.get();
       
     }
   }