Merge pull request #27408 from KAVYANSHTYAGI:Umat-vector-contructor

KAVYANSHTYAGI · web-flow · commit 7ca36d9c5081 · 2025-06-09T16:02:38.000+03:00
Deprecate copyData Parameter in UMat Construction from std::vector and Always Copy Data #27408 Overview This PR simplifies and modernizes the construction of cv::UMat from std::vector by removing the legacy copyData parameter, always copying the data, and ensuring clearer, safer semantics. This brings UMat in line with current best practices and paves the way for the upcoming OpenCV 5.x series. What Changed? 1. Header Documentation Update Removed confusing or obsolete documentation about copyData and clarified the behavior: Old: builds matrix from std::vector with or without copying the data New: builds matrix from std::vector. The data is always copied. The copyData parameter is deprecated and will be removed in OpenCV 5.0. 2. Implementation Update In UMat::UMat(const std::vector<_Tp>& vec, bool copyData), the copyData parameter: Is now ignored and marked as deprecated. Marked with CV_UNUSED(copyData) for backward compatibility and to avoid warnings. The constructor always copies the data from the input vector, regardless of the value of copyData. All branching logic around copyData has been removed. Any code for "not copying" was not implemented and is now dropped. This guarantees data safety and predictable behavior. 3. Test Added A new test construct_from_vector in test_umat_from_vector.cpp: Verifies that UMat copies the vector data, not referencing it. Modifies the source vector after construction to confirm that the UMat is unaffected (proving copy, not reference). Checks matrix shape, type, and content to ensure correctness. Why This Change? 1. Safety and Predictability Always copying avoids dangling references and hard-to-debug lifetime issues with stack/heap-allocated vectors. Removes an undocumented, unimplemented branch (copyData=false). 2. Backward Compatibility The constructor signature remains for now, but the copyData parameter is marked as deprecated and ignored. Codebases that pass the parameter will still compile and run as before (but always copy). 3. API Clarity and Maintenance Documentation now matches the real implementation. No misleading expectations about zero-copy. Code is cleaner, future-proof, and easier to maintain. 4. Preparation for OpenCV 5.0 The copyData parameter is deprecated and will be removed in OpenCV 5.x. Prepares users and downstream libraries for the planned change. How This Helps OpenCV Users and Developers Guarantees data safety and makes behavior explicit. Removes legacy/ambiguous code. Provides a clear path to OpenCV 5.x. Minimizes future migration pain. Ensures all users see the same, reliable behavior (copy semantics). Refer:#27409
diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp
@@ -2482,8 +2482,8 @@ class CV_EXPORTS UMat
     UMat(const UMat& m, const Range* ranges);
     UMat(const UMat& m, const std::vector<Range>& ranges);
 
-    // FIXIT copyData=false is not implemented, drop this in favor of cv::Mat (OpenCV 5.0)
-    //! builds matrix from std::vector with or without copying the data
+    //! builds matrix from std::vector. The data is always copied. The copyData
+    //! parameter is deprecated and will be removed in OpenCV 5.0.
     template<typename _Tp> explicit UMat(const std::vector<_Tp>& vec, bool copyData=false);
 
     //! destructor - calls release()
diff --git a/modules/core/include/opencv2/core/mat.inl.hpp b/modules/core/include/opencv2/core/mat.inl.hpp
@@ -3254,18 +3254,13 @@ const Mat_<_Tp>& operator /= (const Mat_<_Tp>& a, const MatExpr& b)
 
 template<typename _Tp> inline
 UMat::UMat(const std::vector<_Tp>& vec, bool copyData)
-: flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2), rows((int)vec.size()),
-cols(1), allocator(0), usageFlags(USAGE_DEFAULT), u(0), offset(0), size(&rows)
+    : flags(+MAGIC_VAL + traits::Type<_Tp>::value + CV_MAT_CONT_FLAG), dims(2), rows((int)vec.size()),
+      cols(1), allocator(0), usageFlags(USAGE_DEFAULT), u(0), offset(0), size(&rows)
 {
+    CV_UNUSED(copyData); // parameter kept for backward compatibility
     if(vec.empty())
         return;
-    if( !copyData )
-    {
-        // !!!TODO!!!
-        CV_Error(Error::StsNotImplemented, "");
-    }
-    else
-        Mat((int)vec.size(), 1, traits::Type<_Tp>::value, (uchar*)&vec[0]).copyTo(*this);
+    Mat((int)vec.size(), 1, traits::Type<_Tp>::value, (uchar*)&vec[0]).copyTo(*this);
 }
 
 inline
diff --git a/modules/core/test/test_umat.cpp b/modules/core/test/test_umat.cpp
@@ -919,6 +919,28 @@ TEST(Core_UMat, getUMat)
         EXPECT_EQ(0., err);
     }
 }
+#include "test_precomp.hpp"
+
+TEST(Core_UMat, construct_from_vector)
+{
+    std::vector<int> src = {1, 2, 3, 4};
+    UMat um(src); // copyData parameter is deprecated and ignored
+
+    src[0] = 100; // modify source to ensure data was copied
+
+    Mat result;
+    um.copyTo(result);
+
+    ASSERT_EQ(4, result.rows);
+    ASSERT_EQ(1, result.cols);
+    ASSERT_EQ(CV_32S, result.type());
+    EXPECT_EQ(1, result.at<int>(0));
+    EXPECT_EQ(2, result.at<int>(1));
+    EXPECT_EQ(3, result.at<int>(2));
+    EXPECT_EQ(4, result.at<int>(3));
+}
+
+
 
 TEST(UMat, Sync)
 {
@@ -1452,4 +1474,6 @@ TEST(UMat, exceptions_refcounts_issue_20594)
     umat1.u->handle = original_handle;
 }
 
+#include "test_precomp.hpp"
+
 } } // namespace opencv_test::ocl
