Merge pull request #21511 from dbudniko:dbudniko/gapi_media_format_gray

Dmitry Budnikov · web-flow · commit 4d0148b417e0 · 2022-02-03T15:20:21.000+03:00
G-API media format gray
diff --git a/modules/gapi/include/opencv2/gapi/gframe.hpp b/modules/gapi/include/opencv2/gapi/gframe.hpp
@@ -86,6 +86,7 @@ enum class MediaFormat: int
 {
     BGR = 0,
     NV12,
+    GRAY,
 };
 
 /**
diff --git a/modules/gapi/src/api/gframe.cpp b/modules/gapi/src/api/gframe.cpp
@@ -44,6 +44,7 @@ std::ostream& operator<<(std::ostream& os, const cv::GFrameDesc &d) {
     switch (d.fmt) {
     case MediaFormat::BGR:  os << "BGR"; break;
     case MediaFormat::NV12: os << "NV12"; break;
+    case MediaFormat::GRAY: os << "GRAY"; break;
     default: GAPI_Assert(false && "Invalid media format");
     }
     os << ' ' << d.size << ']';
diff --git a/modules/gapi/src/backends/ie/giebackend.cpp b/modules/gapi/src/backends/ie/giebackend.cpp
@@ -182,6 +182,10 @@ inline IE::Blob::Ptr wrapIE(const cv::MediaFrame::View& view,
             auto uv_plane = cv::Mat(desc.size / 2, CV_8UC2, view.ptr[1], view.stride[1]);
             return cv::gapi::ie::util::to_ie(y_plane, uv_plane);
         }
+        case cv::MediaFormat::GRAY: {
+            auto gray = cv::Mat(desc.size, CV_8UC1, view.ptr[0], view.stride[0]);
+            return wrapIE(gray, cv::gapi::ie::TraitAs::IMAGE);
+        }
         default:
             GAPI_Assert(false && "Unsupported media format for IE backend");
     }
@@ -837,6 +841,9 @@ static void configureInputInfo(const IE::InputInfo::Ptr& ii, const cv::GMetaArg
                 case cv::MediaFormat::BGR:
                     // NB: Do nothing
                     break;
+                case cv::MediaFormat::GRAY:
+                    // NB: Do nothing
+                    break;
                 default:
                     GAPI_Assert(false && "Unsupported media format for IE backend");
             }
diff --git a/modules/gapi/src/backends/streaming/gstreamingbackend.cpp b/modules/gapi/src/backends/streaming/gstreamingbackend.cpp
@@ -282,6 +282,23 @@ void GOCVBGR::Actor::extractRMat(const cv::MediaFrame& frame, cv::RMat& rmat)
             rmat = cv::make_rmat<cv::gimpl::RMatOnMat>(bgr);
             break;
         }
+        case cv::MediaFormat::GRAY:
+        {
+            std::call_once(m_warnFlag,
+                []() {
+                    GAPI_LOG_WARNING(NULL, "\nOn-the-fly conversion from GRAY to BGR will happen.\n"
+                        "Conversion may cost a lot for images with high resolution.\n"
+                        "To retrieve cv::Mat from GRAY cv::MediaFrame for free, you may use "
+                        "cv::gapi::streaming::Y.\n");
+                });
+            cv::Mat bgr;
+            auto view = frame.access(cv::MediaFrame::Access::R);
+            cv::Mat gray(desc.size, CV_8UC1, view.ptr[0], view.stride[0]);
+            cv::cvtColor(gray, bgr, cv::COLOR_GRAY2BGR);
+            rmat = cv::make_rmat<cv::gimpl::RMatOnMat>(bgr);
+            break;
+        }
+
         default:
             cv::util::throw_error(
                     std::logic_error("Unsupported MediaFormat for cv::gapi::streaming::BGR"));
@@ -339,6 +356,15 @@ void GOCVY::Actor::extractRMat(const cv::MediaFrame& frame, cv::RMat& rmat)
             });
             break;
         }
+        case cv::MediaFormat::GRAY:
+        {
+            rmat = cv::make_rmat<cv::gimpl::RMatMediaFrameAdapter>(frame,
+            [](const cv::GFrameDesc& d) { return cv::GMatDesc(CV_8U, 1, d.size); },
+            [](const cv::GFrameDesc& d, const cv::MediaFrame::View& v) {
+                return cv::Mat(d.size, CV_8UC1, v.ptr[0], v.stride[0]);
+            });
+            break;
+        }
         default:
             cv::util::throw_error(
                     std::logic_error("Unsupported MediaFormat for cv::gapi::streaming::Y"));
@@ -408,6 +434,12 @@ void GOCVUV::Actor::extractRMat(const cv::MediaFrame& frame, cv::RMat& rmat)
             });
             break;
         }
+        case cv::MediaFormat::GRAY:
+        {
+            cv::Mat uv(desc.size / 2, CV_8UC2, cv::Scalar::all(127));
+            rmat = cv::make_rmat<cv::gimpl::RMatOnMat>(uv);
+            break;
+        }
         default:
             cv::util::throw_error(
                     std::logic_error("Unsupported MediaFormat for cv::gapi::streaming::UV"));
diff --git a/modules/gapi/test/common/gapi_core_tests_inl.hpp b/modules/gapi/test/common/gapi_core_tests_inl.hpp
@@ -1701,6 +1701,25 @@ namespace {
     };
 };
 
+namespace {
+    class TestMediaGray final : public cv::MediaFrame::IAdapter {
+        cv::Mat m_mat;
+
+    public:
+        explicit TestMediaGray(cv::Mat m)
+            : m_mat(m) {
+        }
+        cv::GFrameDesc meta() const override {
+            return cv::GFrameDesc{ cv::MediaFormat::GRAY, cv::Size(m_mat.cols, m_mat.rows) };
+        }
+        cv::MediaFrame::View access(cv::MediaFrame::Access) override {
+            cv::MediaFrame::View::Ptrs pp = { m_mat.ptr(), nullptr, nullptr, nullptr };
+            cv::MediaFrame::View::Strides ss = { m_mat.step, 0u, 0u, 0u };
+            return cv::MediaFrame::View(std::move(pp), std::move(ss));
+        }
+    };
+};
+
 TEST_P(SizeMFTest, ParseTest)
 {
     cv::Size out_sz;
@@ -1715,6 +1734,20 @@ TEST_P(SizeMFTest, ParseTest)
     EXPECT_EQ(sz, out_sz);
 }
 
+TEST_P(SizeMFTest, ParseGrayTest)
+{
+    cv::Size out_sz;
+    cv::Mat gray = cv::Mat::eye(sz.height, sz.width, CV_8UC1);
+    cv::MediaFrame frame = cv::MediaFrame::Create<TestMediaGray>(gray);
+
+    cv::GFrame in;
+    auto out = cv::gapi::streaming::size(in);
+    cv::GComputation c(cv::GIn(in), cv::GOut(out));
+    c.apply(cv::gin(frame), cv::gout(out_sz), getCompileArgs());
+
+    EXPECT_EQ(sz, out_sz);
+}
+
 } // opencv_test
 
 #endif //OPENCV_GAPI_CORE_TESTS_INL_HPP
diff --git a/modules/gapi/test/gapi_frame_tests.cpp b/modules/gapi/test/gapi_frame_tests.cpp
@@ -29,6 +29,23 @@ GAPI_OCV_KERNEL(OCVBlurFrame, GBlurFrame) {
     }
 };
 
+G_API_OP(GBlurFrameGray, <GMat(GFrame)>, "test.blur_frame_gray") {
+    static GMatDesc outMeta(GFrameDesc in) {
+        return cv::GMatDesc(CV_8U, 1, in.size);
+    }
+};
+
+GAPI_OCV_KERNEL(OCVBlurFrameGray, GBlurFrameGray) {
+    static void run(const cv::MediaFrame & in, cv::Mat & out) {
+        GAPI_Assert(in.desc().fmt == cv::MediaFormat::GRAY);
+        cv::MediaFrame::View view = in.access(cv::MediaFrame::Access::R);
+        cv::blur(cv::Mat(in.desc().size, CV_8UC1, view.ptr[0], view.stride[0]),
+        out,
+        cv::Size{ 3,3 });
+    }
+};
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // cv::MediaFrame tests
 namespace {
@@ -70,6 +87,26 @@ class TestMediaNV12 final: public cv::MediaFrame::IAdapter {
         return cv::MediaFrame::View(std::move(pp), std::move(ss));
     }
 };
+
+class TestMediaGray final : public cv::MediaFrame::IAdapter {
+    cv::Mat m_mat;
+    using Cb = cv::MediaFrame::View::Callback;
+    Cb m_cb;
+
+public:
+    explicit TestMediaGray(cv::Mat m, Cb cb = []() {})
+        : m_mat(m), m_cb(cb) {
+    }
+    cv::GFrameDesc meta() const override {
+        return cv::GFrameDesc{ cv::MediaFormat::GRAY, cv::Size(m_mat.cols, m_mat.rows) };
+    }
+    cv::MediaFrame::View access(cv::MediaFrame::Access) override {
+        cv::MediaFrame::View::Ptrs pp = { m_mat.ptr(), nullptr, nullptr, nullptr };
+        cv::MediaFrame::View::Strides ss = { m_mat.step, 0u, 0u, 0u };
+        return cv::MediaFrame::View(std::move(pp), std::move(ss), Cb{ m_cb });
+    }
+};
+
 } // anonymous namespace
 
 struct MediaFrame_Test: public ::testing::Test {
@@ -120,6 +157,49 @@ TEST_F(MediaFrame_BGR, Input) {
     EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
 }
 
+struct MediaFrame_Gray : public MediaFrame_Test {
+    M gray;
+    MediaFrame_Gray()
+        : gray(M::eye(240, 320, CV_8UC1)) {
+        cv::randn(gray, cv::Scalar::all(127.0f), cv::Scalar::all(40.f));
+        frame = MF::Create<TestMediaGray>(gray);
+    }
+};
+
+TEST_F(MediaFrame_Gray, Meta) {
+    auto meta = frame.desc();
+    EXPECT_EQ(cv::MediaFormat::GRAY, meta.fmt);
+    EXPECT_EQ(cv::Size(320, 240), meta.size);
+}
+
+TEST_F(MediaFrame_Gray, Access) {
+    cv::MediaFrame::View view1 = frame.access(cv::MediaFrame::Access::R);
+    EXPECT_EQ(gray.ptr(), view1.ptr[0]);
+    EXPECT_EQ(gray.step, view1.stride[0]);
+
+    cv::MediaFrame::View view2 = frame.access(cv::MediaFrame::Access::R);
+    EXPECT_EQ(gray.ptr(), view2.ptr[0]);
+    EXPECT_EQ(gray.step, view2.stride[0]);
+}
+
+TEST_F(MediaFrame_Gray, Input) {
+    // Run the OpenCV code
+    cv::Mat out_mat_ocv, out_mat_gapi;
+    cv::blur(gray, out_mat_ocv, cv::Size{ 3,3 });
+
+    // Run the G-API code
+    cv::GFrame in;
+    cv::GMat out = GBlurFrameGray::on(in);
+    cv::GComputation(cv::GIn(in), cv::GOut(out))
+        .apply(cv::gin(frame),
+            cv::gout(out_mat_gapi),
+            cv::compile_args(cv::gapi::kernels<OCVBlurFrameGray>()));
+
+    // Compare
+    EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
+}
+
+
 struct MediaFrame_NV12: public MediaFrame_Test {
     cv::Size sz;
     cv::Mat buf, y, uv;
diff --git a/modules/gapi/test/streaming/gapi_streaming_tests.cpp b/modules/gapi/test/streaming/gapi_streaming_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,7 @@ enum class MediaFormat: int`
`86`	`86`	`{`
`87`	`87`	`BGR = 0,`
`88`	`88`	`NV12,`
	`89`	`+ GRAY,`
`89`	`90`	`};`
`90`	`91`
`91`	`92`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ std::ostream& operator<<(std::ostream& os, const cv::GFrameDesc &d) {`
`44`	`44`	`switch (d.fmt) {`
`45`	`45`	`case MediaFormat::BGR: os << "BGR"; break;`
`46`	`46`	`case MediaFormat::NV12: os << "NV12"; break;`
	`47`	`+ case MediaFormat::GRAY: os << "GRAY"; break;`
`47`	`48`	`default: GAPI_Assert(false && "Invalid media format");`
`48`	`49`	`}`
`49`	`50`	`os << ' ' << d.size << ']';`