Merge pull request #3996 from vpisarev:matshape_inside_mat

vpisarev · web-flow · commit 5c7396986ac3 · 2025-09-15T15:04:28.000+03:00
Fixed compile errors after MatShape/MatSize refactoring #3996 this is satellite for opencv/opencv#27757 ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [ ] The PR is proposed to the proper branch - [ ] There is a reference to the original bug report and related work - [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [ ] The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/fastcv/src/channel.cpp b/modules/fastcv/src/channel.cpp
@@ -26,7 +26,7 @@ void merge(InputArrayOfArrays _mv, OutputArray _dst)
         CV_Assert(mv[i].size == mv[0].size && mv[i].step[0] == mv[0].step[0] && mv[i].type() == CV_8UC1);
     }
 
-     _dst.create(mv[0].dims, mv[0].size, CV_MAKE_TYPE(CV_8U,count));
+    _dst.create(mv[0].size, CV_MAKE_TYPE(CV_8U,count));
     Mat dst = _dst.getMat();
 
     INITIALIZATION_CHECK;
@@ -89,7 +89,7 @@ void split(InputArray _src, OutputArrayOfArrays _mv)
     _mv.create(cn, 1, depth);
     for( int k = 0; k < cn; k++ )
     {
-        _mv.create(src.dims, src.size, depth, k);
+        _mv.create(src.size, depth, k);
     }
 
     std::vector<cv::Mat> mv(cn);
diff --git a/modules/gapi/include/opencv2/gapi/own/convert.hpp b/modules/gapi/include/opencv2/gapi/own/convert.hpp
@@ -17,8 +17,8 @@ namespace cv
 {
     template<typename T>
     std::vector<T> to_own(const cv::MatSize &sz) {
-        std::vector<T> result(sz.dims());
-        for (int i = 0; i < sz.dims(); i++) {
+        std::vector<T> result(sz.dims);
+        for (int i = 0; i < sz.dims; i++) {
             // Note: cv::MatSize is not iterable
             result[i] = static_cast<T>(sz[i]);
         }
diff --git a/modules/gapi/samples/onevpl_infer_with_advanced_device_selection.cpp b/modules/gapi/samples/onevpl_infer_with_advanced_device_selection.cpp
@@ -225,7 +225,7 @@ GAPI_OCV_KERNEL(OCVParseSSD, ParseSSD) {
                     const cv::Size &in_parent_size,
                     std::vector<cv::Rect> &out_objects) {
         const auto &in_ssd_dims = in_ssd_result.size;
-        GAPI_Assert(in_ssd_dims.dims() == 4u);
+        GAPI_Assert(in_ssd_dims.dims == 4);
 
         const int MAX_PROPOSALS = in_ssd_dims[2];
         const int OBJECT_SIZE   = in_ssd_dims[3];
diff --git a/modules/gapi/samples/pipeline_modeling_tool/utils.hpp b/modules/gapi/samples/pipeline_modeling_tool/utils.hpp
@@ -38,7 +38,7 @@ inline void generateRandom(cv::Mat& out) {
             break;
         case CV_16F: {
             std::vector<int> dims;
-            for (int i = 0; i < out.size.dims(); ++i) {
+            for (int i = 0; i < out.size.dims; ++i) {
                 dims.push_back(out.size[i]);
             }
             cv::Mat fp32_mat;
diff --git a/modules/gapi/samples/semantic_segmentation.cpp b/modules/gapi/samples/semantic_segmentation.cpp
@@ -144,9 +144,9 @@ G_API_OP(PostProcessing, <cv::GMat(cv::GMat, cv::GMat)>, "sample.custom.post_pro
 GAPI_OCV_KERNEL(OCVPostProcessing, PostProcessing) {
     static void run(const cv::Mat &in, const cv::Mat &out_blob, cv::Mat &out) {
         int C = -1, H = -1, W = -1;
-        if (out_blob.size.dims() == 4u) {
+        if (out_blob.size.dims == 4) {
             C = 1; H = 2, W = 3;
-        } else if (out_blob.size.dims() == 3u) {
+        } else if (out_blob.size.dims == 3) {
             C = 0; H = 1, W = 2;
         } else {
             throw std::logic_error(
diff --git a/modules/gapi/samples/text_detection.cpp b/modules/gapi/samples/text_detection.cpp
@@ -288,7 +288,7 @@ GAPI_OCV_KERNEL(OCVPostProcess, PostProcess) {
     }
 
     static std::vector<std::size_t> dimsToShape(const cv::MatSize &sz) {
-        const int n_dims = sz.dims();
+        const int n_dims = sz.dims;
         std::vector<std::size_t> result;
         result.reserve(n_dims);
 
diff --git a/modules/gapi/src/api/gbackend.cpp b/modules/gapi/src/api/gbackend.cpp
@@ -411,7 +411,7 @@ void createMat(const cv::GMatDesc &desc, cv::Mat& mat)
 #if !defined(GAPI_STANDALONE)
         // NB: WA for 1D mats.
         if (desc.dims.size() == 1u) {
-            mat.dims = 1;
+            mat.size.dims = mat.dims = 1;
         }
 #endif
     }
diff --git a/modules/gapi/src/api/gmat.cpp b/modules/gapi/src/api/gmat.cpp
@@ -87,7 +87,7 @@ namespace{
 #if !defined(GAPI_STANDALONE)
 cv::GMatDesc cv::descr_of(const cv::Mat &mat)
 {
-    const auto mat_dims = mat.size.dims();
+    const auto mat_dims = mat.size.dims;
 
     if (mat_dims <= 2)
         return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}};
@@ -111,7 +111,7 @@ cv::GMatDesc cv::gapi::own::descr_of(const Mat &mat)
 #if !defined(GAPI_STANDALONE)
 cv::GMatDesc cv::descr_of(const cv::UMat &mat)
 {
-    GAPI_Assert(mat.size.dims() == 2);
+    GAPI_Assert(mat.size.dims == 2);
     return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } };
 }
 
diff --git a/modules/gapi/src/backends/common/gbackend.hpp b/modules/gapi/src/backends/common/gbackend.hpp
@@ -46,9 +46,13 @@ namespace gimpl {
 #if !defined(GAPI_STANDALONE)
         int m_dims = m.dims < 2 ? 2 : m.dims;
         RMat::View::stepsT steps(m_dims);
-        const size_t* m_step = m.dims <= 2 ? m.step.buf : m.step.p;
-        for (int i = 0; i < m_dims; i++) {
-            steps[i] = m_step[i];
+        if (m_dims >= 2) {
+            for (int i = 0; i < m_dims; i++) {
+                steps[i] = m.step.p[i];
+            }
+        } else {
+            steps[1] = m.step.p[0];
+            steps[0] = m.cols*steps[1];
         }
         return RMat::View(cv::descr_of(m), m.data, steps, std::move(cb));
 #else
diff --git a/modules/gapi/src/backends/common/serialization.cpp b/modules/gapi/src/backends/common/serialization.cpp
@@ -276,7 +276,7 @@ void read_mat_data(IIStream &is, cv::Mat &m) {
 
 IOStream& operator<< (IOStream& os, const cv::Mat &m) {
 #if !defined(GAPI_STANDALONE)
-    GAPI_Assert(m.size.dims() == 2 && "Only 2D images are supported now");
+    GAPI_Assert(m.size.dims == 2 && "Only 2D images are supported now");
 #else
     GAPI_Assert(m.dims.size() == 2 && "Only 2D images are supported now");
 #endif
diff --git a/modules/gapi/src/backends/cpu/gnnparsers.cpp b/modules/gapi/src/backends/cpu/gnnparsers.cpp
@@ -102,7 +102,7 @@ class SSDParser
         : m_dims(in_ssd_dims), m_maxProp(in_ssd_dims[2]), m_objSize(in_ssd_dims[3]),
           m_data(data), m_surface(cv::Rect({0,0}, in_size)), m_size(in_size)
     {
-        GAPI_Assert(in_ssd_dims.dims() == 4u); // Fixed output layout
+        GAPI_Assert(in_ssd_dims.dims == 4); // Fixed output layout
         GAPI_Assert(m_objSize  == 7);          // Fixed SSD object size
     }
 
@@ -220,7 +220,7 @@ void ParseSSD(const cv::Mat&  in_ssd_result,
 }
 
 static void checkYoloDims(const MatSize& dims) {
-    const auto d = dims.dims();
+    const auto d = dims.dims;
     // Accept 1x13x13xN and 13x13xN
     GAPI_Assert(d >= 2);
     if (d >= 3) {
@@ -252,7 +252,7 @@ void parseYolo(const cv::Mat&  in_yolo_result,
     const auto& dims = in_yolo_result.size;
     checkYoloDims(dims);
     int acc = 1;
-    for (int i = 0; i < dims.dims(); i++) {
+    for (int i = 0; i < dims.dims; i++) {
         acc *= dims[i];
     }
     const auto num_classes = acc/(5*13*13)-5;
diff --git a/modules/gapi/src/backends/ie/giebackend.cpp b/modules/gapi/src/backends/ie/giebackend.cpp
@@ -236,7 +236,7 @@ cv::gapi::ie::TraitAs clarifyTrait(const cv::GMetaArg   &meta,
 
 inline IE::TensorDesc toIE(const cv::Mat &mat, cv::gapi::ie::TraitAs hint) {
     const auto &sz = mat.size;
-    if (sz.dims() == 2 && hint == cv::gapi::ie::TraitAs::IMAGE)
+    if (sz.dims == 2 && hint == cv::gapi::ie::TraitAs::IMAGE)
     {
         // NB: This logic is mainly taken from IE samples
         const size_t channels = mat.channels();
@@ -253,7 +253,7 @@ inline IE::TensorDesc toIE(const cv::Mat &mat, cv::gapi::ie::TraitAs hint) {
         return IE::TensorDesc(toIE(mat.depth()),
                               IE::SizeVector{1, channels, height, width}, bdesc);
     }
-    return IE::TensorDesc(toIE(mat.depth()), toIE(sz), toIELayout(sz.dims()));
+    return IE::TensorDesc(toIE(mat.depth()), toIE(sz), toIELayout(sz.dims));
 }
 
 // NB: Inference dimmensions always follow NCDHW order
@@ -296,7 +296,7 @@ inline IE::TensorDesc toIE(const cv::Mat               &mat,
                            const cv::gapi::ie::TraitAs hint,
                            const IE::Layout            layout) {
     const auto &sz = mat.size;
-    if (sz.dims() == 2 && hint == cv::gapi::ie::TraitAs::IMAGE)
+    if (sz.dims == 2 && hint == cv::gapi::ie::TraitAs::IMAGE)
     {
         // NB: This logic is mainly taken from IE samples
         const size_t channels = mat.channels();
diff --git a/modules/gapi/test/common/gapi_parsers_tests_common.hpp b/modules/gapi/test/common/gapi_parsers_tests_common.hpp
@@ -48,7 +48,7 @@ class ParserSSDTest
     {
         out_boxes.clear();
         const auto &in_ssd_dims = in_ssd_result.size;
-        CV_Assert(in_ssd_dims.dims() == 4u);
+        CV_Assert(in_ssd_dims.dims == 4);
 
         const int MAX_PROPOSALS = in_ssd_dims[2];
         const int OBJECT_SIZE   = in_ssd_dims[3];
@@ -99,7 +99,7 @@ class ParserSSDTest
         out_boxes.clear();
         out_labels.clear();
         const auto &in_ssd_dims = in_ssd_result.size;
-        CV_Assert(in_ssd_dims.dims() == 4u);
+        CV_Assert(in_ssd_dims.dims == 4);
 
         const int MAX_PROPOSALS = in_ssd_dims[2];
         const int OBJECT_SIZE   = in_ssd_dims[3];
diff --git a/modules/gapi/test/gapi_sample_pipelines.cpp b/modules/gapi/test/gapi_sample_pipelines.cpp
@@ -495,13 +495,13 @@ TEST(DISABLED_GAPI_Pipeline, GraphOutputIs1DMat)
 
     // NB: Computation is able to write 1D output cv::Mat to empty out_mat.
     ASSERT_NO_THROW(cc(cv::gin(in_mat), cv::gout(out_mat)));
-    ASSERT_EQ(1, out_mat.size.dims());
+    ASSERT_EQ(1, out_mat.size.dims);
     ASSERT_EQ(dim, out_mat.size[0]);
 
     // NB: Computation is able to write 1D output cv::Mat
     // to pre-allocated with the same meta out_mat.
     ASSERT_NO_THROW(cc(cv::gin(in_mat), cv::gout(out_mat)));
-    ASSERT_EQ(1, out_mat.size.dims());
+    ASSERT_EQ(1, out_mat.size.dims);
     ASSERT_EQ(dim, out_mat.size[0]);
 }
 
@@ -512,7 +512,7 @@ TEST(DISABLED_GAPI_Pipeline, 1DMatBetweenIslands)
     cv::Mat out_mat;
 
     cv::Mat ref_mat({dim}, CV_8U);
-    ref_mat.dims = 1;
+    ref_mat.size.dims = ref_mat.dims = 1;
     ref_mat.setTo(0);
 
     cv::GMat in;
@@ -534,7 +534,7 @@ TEST(DISABLED_GAPI_Pipeline, 1DMatWithinSingleIsland)
     cv::Mat out_mat;
 
     cv::Mat ref_mat({dim}, CV_8U);
-    ref_mat.dims = 1;
+    ref_mat.size.dims = ref_mat.dims = 1;
     ref_mat.setTo(0);
 
     cv::GMat in;
diff --git a/modules/tracking/src/twist.cpp b/modules/tracking/src/twist.cpp
@@ -9,52 +9,53 @@ namespace detail
 inline namespace tracking
 {
 
-void computeInteractionMatrix(const cv::Mat& uv, const cv::Mat& depths, const cv::Mat& K, cv::Mat& J)
+void computeInteractionMatrix(const cv::Mat& uv, const cv::Mat& depths, const cv::Mat& K_, cv::Mat& J)
 {
     CV_Assert(uv.cols == depths.cols);
     CV_Assert(depths.type() == CV_32F);
-    CV_Assert(K.cols == 3 && K.rows == 3);
+    CV_Assert(K_.cols == 3 && K_.rows == 3 && K_.type() == CV_32F);
 
     J.create(depths.cols * 2, 6, CV_32F);
     J.setTo(0);
 
-    cv::Mat Kinv;
-    cv::invert(K, Kinv);
+    Matx33f K, Kinv;
+    K_.copyTo(K);
+    Kinv = K.inv();
 
-    cv::Mat xy(3, 1, CV_32F);
-    cv::Mat Jp(2, 6, CV_32F);
     for (int i = 0; i < uv.cols; i++)
     {
         const float z = depths.at<float>(i);
         // skip points with zero depth
         if (cv::abs(z) < 0.001f)
             continue;
 
-        const cv::Point3f p(uv.at<float>(0, i), uv.at<float>(1, i), 1.0);
+        const cv::Matx31f p(uv.at<float>(0, i), uv.at<float>(1, i), 1.0);
 
         // convert to normalized image-plane coordinates
-        xy = Kinv * cv::Mat(p);
-        float x = xy.at<float>(0);
-        float y = xy.at<float>(1);
+        Matx31f xy = Kinv * p;
+        float x = xy(0,0);
+        float y = xy(1,0);
+
+        Matx<float, 2, 6> Jp;
 
         // 2x6 Jacobian for this point
-        Jp.at<float>(0, 0) = -1 / z;
-        Jp.at<float>(0, 1) = 0.0;
-        Jp.at<float>(0, 2) = x / z;
-        Jp.at<float>(0, 3) = x * y;
-        Jp.at<float>(0, 4) = -(1 + x * x);
-        Jp.at<float>(0, 5) = y;
-        Jp.at<float>(1, 0) = 0.0;
-        Jp.at<float>(1, 1) = -1 / z;
-        Jp.at<float>(1, 2) = y / z;
-        Jp.at<float>(1, 3) = 1 + y * y;
-        Jp.at<float>(1, 4) = -x * y;
-        Jp.at<float>(1, 5) = -x;
+        Jp(0, 0) = -1 / z;
+        Jp(0, 1) = 0.0;
+        Jp(0, 2) = x / z;
+        Jp(0, 3) = x * y;
+        Jp(0, 4) = -(1 + x * x);
+        Jp(0, 5) = y;
+        Jp(1, 0) = 0.0;
+        Jp(1, 1) = -1 / z;
+        Jp(1, 2) = y / z;
+        Jp(1, 3) = 1 + y * y;
+        Jp(1, 4) = -x * y;
+        Jp(1, 5) = -x;
 
-        Jp = K(cv::Rect(0, 0, 2, 2)) * Jp;
+        Jp = Matx22f(K(0,0), K(0,1), K(1,0), K(1,1)) * Jp;
 
         // push into Jacobian
-        Jp.copyTo(J(cv::Rect(0, 2 * i, 6, 2)));
+        Mat(2, 6, CV_32F, Jp.val).copyTo(J(cv::Rect(0, 2 * i, 6, 2)));
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ void merge(InputArrayOfArrays _mv, OutputArray _dst)`
`26`	`26`	`CV_Assert(mv[i].size == mv[0].size && mv[i].step[0] == mv[0].step[0] && mv[i].type() == CV_8UC1);`
`27`	`27`	`}`
`28`	`28`
`29`		`- _dst.create(mv[0].dims, mv[0].size, CV_MAKE_TYPE(CV_8U,count));`
	`29`	`+ _dst.create(mv[0].size, CV_MAKE_TYPE(CV_8U,count));`
`30`	`30`	`Mat dst = _dst.getMat();`
`31`	`31`
`32`	`32`	`INITIALIZATION_CHECK;`
`@@ -89,7 +89,7 @@ void split(InputArray _src, OutputArrayOfArrays _mv)`
`89`	`89`	`_mv.create(cn, 1, depth);`
`90`	`90`	`for( int k = 0; k < cn; k++ )`
`91`	`91`	`{`
`92`		`- _mv.create(src.dims, src.size, depth, k);`
	`92`	`+ _mv.create(src.size, depth, k);`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`std::vector<cv::Mat> mv(cn);`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,8 @@ namespace cv`
`17`	`17`	`{`
`18`	`18`	`template<typename T>`
`19`	`19`	`std::vector<T> to_own(const cv::MatSize &sz) {`
`20`		`- std::vector<T> result(sz.dims());`
`21`		`- for (int i = 0; i < sz.dims(); i++) {`
	`20`	`+ std::vector<T> result(sz.dims);`
	`21`	`+ for (int i = 0; i < sz.dims; i++) {`
`22`	`22`	`// Note: cv::MatSize is not iterable`
`23`	`23`	`result[i] = static_cast<T>(sz[i]);`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ inline void generateRandom(cv::Mat& out) {`
`38`	`38`	`break;`
`39`	`39`	`case CV_16F: {`
`40`	`40`	`std::vector<int> dims;`
`41`		`- for (int i = 0; i < out.size.dims(); ++i) {`
	`41`	`+ for (int i = 0; i < out.size.dims; ++i) {`
`42`	`42`	`dims.push_back(out.size[i]);`
`43`	`43`	`}`
`44`	`44`	`cv::Mat fp32_mat;`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ GAPI_OCV_KERNEL(OCVPostProcess, PostProcess) {`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`static std::vector<std::size_t> dimsToShape(const cv::MatSize &sz) {`
`291`		`- const int n_dims = sz.dims();`
	`291`	`+ const int n_dims = sz.dims;`
`292`	`292`	`std::vector<std::size_t> result;`
`293`	`293`	`result.reserve(n_dims);`
`294`	`294`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ void createMat(const cv::GMatDesc &desc, cv::Mat& mat)`
`411`	`411`	`#if !defined(GAPI_STANDALONE)`
`412`	`412`	`// NB: WA for 1D mats.`
`413`	`413`	`if (desc.dims.size() == 1u) {`
`414`		`- mat.dims = 1;`
	`414`	`+ mat.size.dims = mat.dims = 1;`
`415`	`415`	`}`
`416`	`416`	`#endif`
`417`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ namespace{`
`87`	`87`	`#if !defined(GAPI_STANDALONE)`
`88`	`88`	`cv::GMatDesc cv::descr_of(const cv::Mat &mat)`
`89`	`89`	`{`
`90`		`- const auto mat_dims = mat.size.dims();`
	`90`	`+ const auto mat_dims = mat.size.dims;`
`91`	`91`
`92`	`92`	`if (mat_dims <= 2)`
`93`	`93`	`return GMatDesc{mat.depth(), mat.channels(), {mat.cols, mat.rows}};`
`@@ -111,7 +111,7 @@ cv::GMatDesc cv::gapi::own::descr_of(const Mat &mat)`
`111`	`111`	`#if !defined(GAPI_STANDALONE)`
`112`	`112`	`cv::GMatDesc cv::descr_of(const cv::UMat &mat)`
`113`	`113`	`{`
`114`		`- GAPI_Assert(mat.size.dims() == 2);`
	`114`	`+ GAPI_Assert(mat.size.dims == 2);`
`115`	`115`	`return GMatDesc{ mat.depth(), mat.channels(),{ mat.cols, mat.rows } };`
`116`	`116`	`}`
`117`	`117`