gapi(simd): initialize accumulator values

original commit: 99502e99cc

CMakeLists.txt

@@ -285,12 +285,9 @@ OCV_OPTION(WITH_INF_ENGINE "Include Intel Inference Engine support" OFF
 OCV_OPTION(WITH_NGRAPH "Include nGraph support" WITH_INF_ENGINE
   VISIBLE_IF TRUE
   VERIFY TARGET ngraph::ngraph)
-OCV_OPTION(WITH_JASPER "Include JPEG2K support (Jasper)" ON
+OCV_OPTION(WITH_JASPER "Include JPEG2K support" ON
   VISIBLE_IF NOT IOS
   VERIFY HAVE_JASPER)
-OCV_OPTION(WITH_OPENJPEG "Include JPEG2K support (OpenJPEG)" ON
-  VISIBLE_IF NOT IOS
-  VERIFY HAVE_OPENJPEG)
 OCV_OPTION(WITH_JPEG "Include JPEG support" ON
   VISIBLE_IF TRUE
   VERIFY HAVE_JPEG)
@@ -946,11 +943,11 @@ endif()
 # for UNIX it does not make sense as LICENSE and readme will be part of the package automatically
 if(ANDROID OR NOT UNIX)
   install(FILES ${OPENCV_LICENSE_FILE}
-        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+        PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
         DESTINATION ./ COMPONENT libs)
   if(OPENCV_README_FILE)
     install(FILES ${OPENCV_README_FILE}
-            PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
+            PERMISSIONS OWNER_READ GROUP_READ WORLD_READ
             DESTINATION ./ COMPONENT libs)
   endif()
 endif()
@@ -1252,12 +1249,8 @@ if(WITH_TIFF OR HAVE_TIFF)
   status("    TIFF:" TIFF_FOUND THEN "${TIFF_LIBRARY} (ver ${TIFF_VERSION} / ${TIFF_VERSION_STRING})" ELSE "build (ver ${TIFF_VERSION} - ${TIFF_VERSION_STRING})")
 endif()
 
-if(HAVE_OPENJPEG)
-  status("    JPEG 2000:" "OpenJPEG (ver ${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION})")
-elseif(HAVE_JASPER)
-  status("    JPEG 2000:" JASPER_FOUND THEN "${JASPER_LIBRARY} (ver ${JASPER_VERSION_STRING})" ELSE "build Jasper (ver ${JASPER_VERSION_STRING})")
-elseif(WITH_OPENJPEG OR WITH_JASPER)
-  status("    JPEG 2000:" "NO")
+if(WITH_JASPER OR HAVE_JASPER)
+  status("    JPEG 2000:" JASPER_FOUND THEN "${JASPER_LIBRARY} (ver ${JASPER_VERSION_STRING})" ELSE "build (ver ${JASPER_VERSION_STRING})")
 endif()
 
 if(WITH_OPENEXR OR HAVE_OPENEXR)

cmake/OpenCVDetectInferenceEngine.cmake

@@ -17,34 +17,10 @@
 # INF_ENGINE_TARGET - set to name of imported library target representing InferenceEngine
 #
 
-
-macro(ocv_ie_find_extra_libraries find_prefix find_suffix)
-  file(GLOB libraries "${INF_ENGINE_LIB_DIRS}/${find_prefix}inference_engine*${find_suffix}")
-  foreach(full_path IN LISTS libraries)
-    get_filename_component(library "${full_path}" NAME_WE)
-    string(REPLACE "${find_prefix}" "" library "${library}")
-    if(library STREQUAL "inference_engine" OR library STREQUAL "inference_engined")
-      # skip
-    else()
-      add_library(${library} UNKNOWN IMPORTED)
-      set_target_properties(${library} PROPERTIES
-          IMPORTED_LOCATION "${full_path}")
-      list(APPEND custom_libraries ${library})
-    endif()
-  endforeach()
-endmacro()
-
 function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
   if(NOT _inc OR NOT (_lib OR _lib_rel OR _lib_dbg))
     return()
   endif()
-  if(NOT _lib)
-    if(_lib_rel)
-      set(_lib "${_lib_rel}")
-    else()
-      set(_lib "${_lib_dbg}")
-    endif()
-  endif()
   add_library(inference_engine UNKNOWN IMPORTED)
   set_target_properties(inference_engine PROPERTIES
     IMPORTED_LOCATION "${_lib}"
@@ -54,31 +30,24 @@ function(add_custom_ie_build _inc _lib _lib_rel _lib_dbg _msg)
   )
 
   set(custom_libraries "")
-  set(__prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}")
-  if(NOT __prefixes)
-    set(__prefixes "_empty_")
-  endif()
-  foreach(find_prefix ${__prefixes})
-    if(find_prefix STREQUAL "_empty_")  # foreach doesn't iterate over empty elements
-      set(find_prefix "")
-    endif()
-    foreach(find_suffix ${CMAKE_FIND_LIBRARY_SUFFIXES})
-      ocv_ie_find_extra_libraries("${find_prefix}" "${find_suffix}")
-    endforeach()
-    if(NOT CMAKE_FIND_LIBRARY_SUFFIXES)
-      ocv_ie_find_extra_libraries("${find_prefix}" "")
-    endif()
+  file(GLOB libraries "${INF_ENGINE_LIB_DIRS}/${CMAKE_SHARED_LIBRARY_PREFIX}inference_engine_*${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  foreach(full_path IN LISTS libraries)
+    get_filename_component(library "${full_path}" NAME_WE)
+    string(REPLACE "${CMAKE_SHARED_LIBRARY_PREFIX}" "" library "${library}")
+    add_library(${library} UNKNOWN IMPORTED)
+    set_target_properties(${library} PROPERTIES
+      IMPORTED_LOCATION "${full_path}")
+    list(APPEND custom_libraries ${library})
   endforeach()
 
   if(NOT INF_ENGINE_RELEASE VERSION_GREATER "2018050000")
     find_library(INF_ENGINE_OMP_LIBRARY iomp5 PATHS "${INF_ENGINE_OMP_DIR}" NO_DEFAULT_PATH)
     if(NOT INF_ENGINE_OMP_LIBRARY)
       message(WARNING "OpenMP for IE have not been found. Set INF_ENGINE_OMP_DIR variable if you experience build errors.")
+    else()
+      set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${INF_ENGINE_OMP_LIBRARY}")
     endif()
   endif()
-  if(EXISTS "${INF_ENGINE_OMP_LIBRARY}")
-    set_target_properties(inference_engine PROPERTIES IMPORTED_LINK_INTERFACE_LIBRARIES "${INF_ENGINE_OMP_LIBRARY}")
-  endif()
   set(INF_ENGINE_VERSION "Unknown" CACHE STRING "")
   set(INF_ENGINE_TARGET "inference_engine;${custom_libraries}" PARENT_SCOPE)
   message(STATUS "Detected InferenceEngine: ${_msg}")
@@ -95,9 +64,6 @@ endif()
 
 if(NOT INF_ENGINE_TARGET AND INF_ENGINE_LIB_DIRS AND INF_ENGINE_INCLUDE_DIRS)
   find_path(ie_custom_inc "inference_engine.hpp" PATHS "${INF_ENGINE_INCLUDE_DIRS}" NO_DEFAULT_PATH)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    find_library(ie_custom_lib_dbg "inference_engined" PATHS "${INF_ENGINE_LIB_DIRS}" NO_DEFAULT_PATH)  # Win32 and MacOSX
-  endif()
   find_library(ie_custom_lib "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}" NO_DEFAULT_PATH)
   find_library(ie_custom_lib_rel "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}/Release" NO_DEFAULT_PATH)
   find_library(ie_custom_lib_dbg "inference_engine" PATHS "${INF_ENGINE_LIB_DIRS}/Debug" NO_DEFAULT_PATH)
@@ -116,9 +82,6 @@ if(NOT INF_ENGINE_TARGET AND _loc)
   endif()
   set(INF_ENGINE_PLATFORM "${INF_ENGINE_PLATFORM_DEFAULT}" CACHE STRING "InferenceEngine platform (library dir)")
   find_path(ie_custom_env_inc "inference_engine.hpp" PATHS "${_loc}/deployment_tools/inference_engine/include" NO_DEFAULT_PATH)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    find_library(ie_custom_env_lib_dbg "inference_engined" PATHS "${_loc}/deployment_tools/inference_engine/lib/${INF_ENGINE_PLATFORM}/intel64" NO_DEFAULT_PATH)
-  endif()
   find_library(ie_custom_env_lib "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/${INF_ENGINE_PLATFORM}/intel64" NO_DEFAULT_PATH)
   find_library(ie_custom_env_lib_rel "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/intel64/Release" NO_DEFAULT_PATH)
   find_library(ie_custom_env_lib_dbg "inference_engine" PATHS "${_loc}/deployment_tools/inference_engine/lib/intel64/Debug" NO_DEFAULT_PATH)
@@ -129,9 +92,9 @@ endif()
 
 if(INF_ENGINE_TARGET)
   if(NOT INF_ENGINE_RELEASE)
-    message(WARNING "InferenceEngine version has not been set, 2020.1 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
+    message(WARNING "InferenceEngine version has not been set, 2020.2 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
   endif()
-  set(INF_ENGINE_RELEASE "2020010000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2020.1.0.2 -> 2020010002)")
+  set(INF_ENGINE_RELEASE "2020020000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2020.1.0.2 -> 2020010002)")
   set_target_properties(${INF_ENGINE_TARGET} PROPERTIES
     INTERFACE_COMPILE_DEFINITIONS "HAVE_INF_ENGINE=1;INF_ENGINE_RELEASE=${INF_ENGINE_RELEASE}"
   )

cmake/OpenCVFindLibsGrfmt.cmake

@@ -153,23 +153,8 @@ if(NOT WEBP_VERSION AND WEBP_INCLUDE_DIR)
   endif()
 endif()
 
-# --- libopenjp2 (optional, check before libjasper) ---
-if(WITH_OPENJPEG)
-  find_package(OpenJPEG QUIET)
-
-  if(NOT OpenJPEG_FOUND OR OPENJPEG_MAJOR_VERSION LESS 2)
-    set(HAVE_OPENJPEG NO)
-    ocv_clear_vars(OPENJPEG_MAJOR_VERSION OPENJPEG_MINOR_VERSION OPENJPEG_BUILD_VERSION OPENJPEG_LIBRARIES OPENJPEG_INCLUDE_DIRS)
-    message(STATUS "Could NOT find OpenJPEG (minimal suitable version: 2.0, recommended version >= 2.3.1)")
-  else()
-    set(HAVE_OPENJPEG YES)
-    message(STATUS "Found OpenJPEG: ${OPENJPEG_LIBRARIES} "
-            "(found version \"${OPENJPEG_MAJOR_VERSION}.${OPENJPEG_MINOR_VERSION}.${OPENJPEG_BUILD_VERSION}\")")
-  endif()
-endif()
-
 # --- libjasper (optional, should be searched after libjpeg) ---
-if(WITH_JASPER AND NOT HAVE_OPENJPEG)
+if(WITH_JASPER)
   if(BUILD_JASPER)
     ocv_clear_vars(JASPER_FOUND)
   else()
@@ -288,4 +273,4 @@ if(WITH_IMGCODEC_PFM)
   set(HAVE_IMGCODEC_PFM ON)
 elseif(DEFINED WITH_IMGCODEC_PFM)
   set(HAVE_IMGCODEC_PFM OFF)
-endif()
+endif()

cmake/OpenCVModule.cmake

@@ -1087,17 +1087,6 @@ macro(ocv_check_dependencies)
   endforeach()
 endmacro()
 
-################################################################################
-# OpenCV tests
-################################################################################
-
-if(DEFINED OPENCV_BUILD_TEST_MODULES_LIST)
-  string(REPLACE "," ";" OPENCV_BUILD_TEST_MODULES_LIST "${OPENCV_BUILD_TEST_MODULES_LIST}")  # support comma-separated list (,) too
-endif()
-if(DEFINED OPENCV_BUILD_PERF_TEST_MODULES_LIST)
-  string(REPLACE "," ";" OPENCV_BUILD_PERF_TEST_MODULES_LIST "${OPENCV_BUILD_PERF_TEST_MODULES_LIST}")  # support comma-separated list (,) too
-endif()
-
 # auxiliary macro to parse arguments of ocv_add_accuracy_tests and ocv_add_perf_tests commands
 macro(__ocv_parse_test_sources tests_type)
   set(OPENCV_${tests_type}_${the_module}_SOURCES "")
@@ -1138,12 +1127,7 @@ function(ocv_add_perf_tests)
   endif()
 
   set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
-  if(BUILD_PERF_TESTS AND EXISTS "${perf_path}"
-      AND (NOT DEFINED OPENCV_BUILD_PERF_TEST_MODULES_LIST
-          OR OPENCV_BUILD_PERF_TEST_MODULES_LIST STREQUAL "all"
-          OR ";${OPENCV_BUILD_PERF_TEST_MODULES_LIST};" MATCHES ";${name};"
-      )
-  )
+  if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
     __ocv_parse_test_sources(PERF ${ARGN})
 
     # opencv_imgcodecs is required for imread/imwrite
@@ -1228,12 +1212,7 @@ function(ocv_add_accuracy_tests)
   ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")
 
   set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
-  if(BUILD_TESTS AND EXISTS "${test_path}"
-      AND (NOT DEFINED OPENCV_BUILD_TEST_MODULES_LIST
-          OR OPENCV_BUILD_TEST_MODULES_LIST STREQUAL "all"
-          OR ";${OPENCV_BUILD_TEST_MODULES_LIST};" MATCHES ";${name};"
-      )
-  )
+  if(BUILD_TESTS AND EXISTS "${test_path}")
     __ocv_parse_test_sources(TEST ${ARGN})
 
     # opencv_imgcodecs is required for imread/imwrite

cmake/templates/cvconfig.h.in

@@ -81,7 +81,6 @@
 #cmakedefine HAVE_IPP_IW_LL
 
 /* JPEG-2000 codec */
-#cmakedefine HAVE_OPENJPEG
 #cmakedefine HAVE_JASPER
 
 /* IJG JPEG codec */

modules/calib3d/src/chessboard.cpp

@@ -797,6 +797,15 @@ Ellipse::Ellipse(const cv::Point2f &_center, const cv::Size2f &_axes, float _ang
 {
 }
 
+Ellipse::Ellipse(const Ellipse &other)
+{
+    center = other.center;
+    axes= other.axes;
+    angle= other.angle;
+    cosf = other.cosf;
+    sinf = other.sinf;
+}
+
 const cv::Size2f &Ellipse::getAxes()const
 {
     return axes;

modules/calib3d/src/chessboard.hpp

@@ -111,6 +111,8 @@ class Ellipse
     public:
         Ellipse();
         Ellipse(const cv::Point2f &center, const cv::Size2f &axes, float angle);
+        Ellipse(const Ellipse &other);
+
 
         void draw(cv::InputOutputArray img,const cv::Scalar &color = cv::Scalar::all(120))const;
         bool contains(const cv::Point2f &pt)const;

modules/core/include/opencv2/core/version.hpp

@@ -8,7 +8,7 @@
 #define CV_VERSION_MAJOR    4
 #define CV_VERSION_MINOR    3
 #define CV_VERSION_REVISION 0
-#define CV_VERSION_STATUS   ""
+#define CV_VERSION_STATUS   "-openvino"
 
 #define CVAUX_STR_EXP(__A)  #__A
 #define CVAUX_STR(__A)      CVAUX_STR_EXP(__A)

modules/core/perf/opencl/perf_matop.cpp

@@ -146,141 +146,6 @@ OCL_PERF_TEST_P(CopyToFixture, CopyToWithMaskUninit,
     SANITY_CHECK(dst);
 }
 
-
-
-enum ROIType {
-    ROI_FULL,
-    ROI_2_RECT,
-    ROI_2_TOP,  // contiguous memory block
-    ROI_2_LEFT,
-    ROI_4,
-    ROI_16,
-};
-static Rect getROI(enum ROIType t, const Size& sz)
-{
-    switch (t)
-    {
-        case ROI_FULL: return Rect(0, 0, sz.width, sz.height);
-        case ROI_2_RECT: return Rect(0, 0, sz.width * 71 / 100, sz.height * 71 / 100);  // 71 = sqrt(1/2) * 100
-        case ROI_2_TOP: return Rect(0, 0, sz.width, sz.height / 2);  // 71 = sqrt(1/2) * 100
-        case ROI_2_LEFT: return Rect(0, 0, sz.width / 2, sz.height);  // 71 = sqrt(1/2) * 100
-        case ROI_4: return Rect(0, 0, sz.width / 2, sz.height / 2);
-        case ROI_16: return Rect(0, 0, sz.width / 4, sz.height / 4);
-    }
-    CV_Assert(false);
-}
-
-typedef TestBaseWithParam< tuple<cv::Size, MatType, ROIType> > OpenCLBuffer;
-
-static inline void PrintTo(const tuple<cv::Size, MatType, enum ROIType>& v, std::ostream* os)
-{
-    *os << "(" << get<0>(v) << ", " << typeToString(get<1>(v)) << ", ";
-    enum ROIType roiType = get<2>(v);
-    if (roiType == ROI_FULL)
-        *os << "ROI_100_FULL";
-    else if (roiType == ROI_2_RECT)
-        *os << "ROI_050_RECT_HALF";
-    else if (roiType == ROI_2_TOP)
-        *os << "ROI_050_TOP_HALF";
-    else if (roiType == ROI_2_LEFT)
-        *os << "ROI_050_LEFT_HALF";
-    else if (roiType == ROI_4)
-        *os << "ROI_025_1/4";
-    else
-        *os << "ROI_012_1/16";
-    *os << ")";
-}
-
-PERF_TEST_P_(OpenCLBuffer, cpu_write)
-{
-    const Size srcSize = get<0>(GetParam());
-    const int type = get<1>(GetParam());
-    const Rect roi = getROI(get<2>(GetParam()), srcSize);
-
-    checkDeviceMaxMemoryAllocSize(srcSize, type);
-
-    UMat src(srcSize, type);
-    declare.in(src(roi), WARMUP_NONE);
-
-    OCL_TEST_CYCLE()
-    {
-        Mat m = src(roi).getMat(ACCESS_WRITE);
-        m.setTo(Scalar(1, 2, 3, 4));
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-PERF_TEST_P_(OpenCLBuffer, cpu_read)
-{
-    const Size srcSize = get<0>(GetParam());
-    const int type = get<1>(GetParam());
-    const Rect roi = getROI(get<2>(GetParam()), srcSize);
-
-    checkDeviceMaxMemoryAllocSize(srcSize, type);
-
-    UMat src(srcSize, type, Scalar(1, 2, 3, 4));
-    declare.in(src(roi), WARMUP_NONE);
-
-    OCL_TEST_CYCLE()
-    {
-        unsigned counter = 0;
-        Mat m = src(roi).getMat(ACCESS_READ);
-        for (int y = 0; y < m.rows; y++)
-        {
-            uchar* ptr = m.ptr(y);
-            size_t width_bytes = m.cols * m.elemSize();
-            for (size_t x_bytes = 0; x_bytes < width_bytes; x_bytes++)
-                counter += (unsigned)(ptr[x_bytes]);
-        }
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-PERF_TEST_P_(OpenCLBuffer, cpu_update)
-{
-    const Size srcSize = get<0>(GetParam());
-    const int type = get<1>(GetParam());
-    const Rect roi = getROI(get<2>(GetParam()), srcSize);
-
-    checkDeviceMaxMemoryAllocSize(srcSize, type);
-
-    UMat src(srcSize, type, Scalar(1, 2, 3, 4));
-    declare.in(src(roi), WARMUP_NONE);
-
-    OCL_TEST_CYCLE()
-    {
-        Mat m = src(roi).getMat(ACCESS_READ | ACCESS_WRITE);
-        for (int y = 0; y < m.rows; y++)
-        {
-            uchar* ptr = m.ptr(y);
-            size_t width_bytes = m.cols * m.elemSize();
-            for (size_t x_bytes = 0; x_bytes < width_bytes; x_bytes++)
-                ptr[x_bytes] += 1;
-        }
-    }
-
-    SANITY_CHECK_NOTHING();
-}
-
-INSTANTIATE_TEST_CASE_P(/*FULL*/, OpenCLBuffer,
-    testing::Combine(
-        testing::Values(szVGA, sz720p, sz1080p, sz2160p),
-        testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4),
-        testing::Values(ROI_FULL)
-    )
-);
-
-INSTANTIATE_TEST_CASE_P(ROI, OpenCLBuffer,
-    testing::Combine(
-        testing::Values(sz1080p, sz2160p),
-        testing::Values(CV_8UC1),
-        testing::Values(ROI_16, ROI_4, ROI_2_RECT, ROI_2_LEFT, ROI_2_TOP, ROI_FULL)
-    )
-);
-
-
 } } // namespace opencv_test::ocl
 
 #endif // HAVE_OPENCL

modules/core/src/matrix_expressions.cpp

@@ -10,7 +10,6 @@
 // */
 
 #include "precomp.hpp"
-#include <opencv2/core/utils/logger.hpp>
 
 namespace cv
 {
@@ -1320,18 +1319,10 @@ void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int _type) const
                 cv::add(dst, e.s, dst);
         }
         else
-        {
-            if (e.a.channels() > 1)
-                CV_LOG_ONCE_WARNING(NULL, "OpenCV/MatExpr: processing of multi-channel arrays might be changed in the future: "
-                                          "https://github.com/opencv/opencv/issues/16739");
             cv::addWeighted(e.a, e.alpha, e.b, e.beta, e.s[0], dst);
-        }
     }
     else if( e.s.isReal() && (dst.data != m.data || fabs(e.alpha) != 1))
     {
-        if (e.a.channels() > 1)
-            CV_LOG_ONCE_WARNING(NULL, "OpenCV/MatExpr: processing of multi-channel arrays might be changed in the future: "
-                                      "https://github.com/opencv/opencv/issues/16739");
         e.a.convertTo(m, _type, e.alpha, e.s[0]);
         return;
     }

modules/core/src/ocl.cpp

@@ -4602,17 +4602,6 @@ public:
         return u;
     }
 
-    static bool isOpenCLMapForced()  // force clEnqueueMapBuffer / clEnqueueUnmapMemObject OpenCL API
-    {
-        static bool value = cv::utils::getConfigurationParameterBool("OPENCV_OPENCL_BUFFER_FORCE_MAPPING", false);
-        return value;
-    }
-    static bool isOpenCLCopyingForced()  // force clEnqueueReadBuffer[Rect] / clEnqueueWriteBuffer[Rect] OpenCL API
-    {
-        static bool value = cv::utils::getConfigurationParameterBool("OPENCV_OPENCL_BUFFER_FORCE_COPYING", false);
-        return value;
-    }
-
     void getBestFlags(const Context& ctx, AccessFlag /*flags*/, UMatUsageFlags usageFlags, int& createFlags, UMatData::MemoryFlag& flags0) const
     {
         const Device& dev = ctx.device(0);
@@ -4620,15 +4609,7 @@ public:
         if ((usageFlags & USAGE_ALLOCATE_HOST_MEMORY) != 0)
             createFlags |= CL_MEM_ALLOC_HOST_PTR;
 
-        if (!isOpenCLCopyingForced() &&
-            (isOpenCLMapForced() ||
-                (dev.hostUnifiedMemory()
-#ifndef __APPLE__
-                || dev.isIntel()
-#endif
-                )
-            )
-        )
+        if( dev.hostUnifiedMemory() )
             flags0 = static_cast<UMatData::MemoryFlag>(0);
         else
             flags0 = UMatData::COPY_ON_MAP;

modules/core/src/parallel.cpp

@@ -54,7 +54,7 @@
 #endif
 
 #if defined __linux__ || defined __APPLE__ || defined __GLIBC__ \
-    || defined __HAIKU__ || defined __EMSCRIPTEN__ || defined __FreeBSD__
+    || defined __HAIKU__ || defined __EMSCRIPTEN__
     #include <unistd.h>
     #include <stdio.h>
     #include <sys/types.h>
@@ -95,9 +95,6 @@
 */
 
 #if defined HAVE_TBB
-    #ifndef TBB_SUPPRESS_DEPRECATED_MESSAGES  // supress warning
-    #define TBB_SUPPRESS_DEPRECATED_MESSAGES 1
-    #endif
     #include "tbb/tbb.h"
     #include "tbb/task.h"
     #include "tbb/tbb_stddef.h"

modules/dnn/CMakeLists.txt

@@ -122,7 +122,6 @@ endif()
 ocv_module_include_directories(${include_dirs})
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-suggest-override")  # GCC
-  ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-array-bounds")  # GCC 9.3.0 (Ubuntu 20.04)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   ocv_append_source_files_cxx_compiler_options(fw_srcs "-Wno-inconsistent-missing-override")  # Clang
 endif()

modules/dnn/src/dnn.cpp

@@ -2228,7 +2228,7 @@ struct Net::Impl
 
                     auto ieInpNode = inputNodes[i].dynamicCast<InfEngineNgraphNode>();
                     CV_Assert(oid < ieInpNode->node->get_output_size());
-                    inputNodes[i] = Ptr<BackendNode>(new InfEngineNgraphNode(ieInpNode->node->get_output_as_single_output_node(oid, false)));
+                    inputNodes[i] = Ptr<BackendNode>(new InfEngineNgraphNode(ieInpNode->node->get_output_as_single_output_node(oid/*, false*/)));
                 }
 
                 if (layer->supportBackend(preferableBackend))

modules/dnn/src/op_inf_engine.hpp

@@ -24,10 +24,11 @@
 #define INF_ENGINE_RELEASE_2019R2 2019020000
 #define INF_ENGINE_RELEASE_2019R3 2019030000
 #define INF_ENGINE_RELEASE_2020_1 2020010000
+#define INF_ENGINE_RELEASE_2020_2 2020020000
 
 #ifndef INF_ENGINE_RELEASE
-#warning("IE version have not been provided via command-line. Using 2019.1 by default")
-#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2020_1
+#warning("IE version have not been provided via command-line. Using 2020.2 by default")
+#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2020_2
 #endif
 
 #define INF_ENGINE_VER_MAJOR_GT(ver) (((INF_ENGINE_RELEASE) / 10000) > ((ver) / 10000))

modules/gapi/include/opencv2/gapi/core.hpp

@@ -486,18 +486,10 @@ namespace core {
         }
     };
 
-    G_TYPED_KERNEL(GWarpPerspective, <GMat(GMat, const Mat&, Size, int, int, const cv::Scalar&)>, "org.opencv.core.warpPerspective") {
-        static GMatDesc outMeta(GMatDesc in, const Mat&, Size dsize, int, int borderMode, const cv::Scalar&) {
-            GAPI_Assert((borderMode == cv::BORDER_CONSTANT || borderMode == cv::BORDER_REPLICATE) &&
-                        "cv::gapi::warpPerspective supports only cv::BORDER_CONSTANT and cv::BORDER_REPLICATE border modes");
-            return in.withType(in.depth, in.chan).withSize(dsize);
-        }
-    };
-
     G_TYPED_KERNEL(GWarpAffine, <GMat(GMat, const Mat&, Size, int, int, const cv::Scalar&)>, "org.opencv.core.warpAffine") {
         static GMatDesc outMeta(GMatDesc in, const Mat&, Size dsize, int, int border_mode, const cv::Scalar&) {
             GAPI_Assert(border_mode != cv::BORDER_TRANSPARENT &&
-                        "cv::BORDER_TRANSPARENT mode is not supported in cv::gapi::warpAffine");
+                        "cv::BORDER_TRANSPARENT mode isn't support in G-API");
             return in.withType(in.depth, in.chan).withSize(dsize);
         }
     };
@@ -1670,30 +1662,6 @@ number of channels as src and the depth =ddepth.
 GAPI_EXPORTS GMat normalize(const GMat& src, double alpha, double beta,
                             int norm_type, int ddepth = -1);
 
-/** @brief Applies a perspective transformation to an image.
-
-The function warpPerspective transforms the source image using the specified matrix:
-
-\f[\texttt{dst} (x,y) =  \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,
-     \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\f]
-
-when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted with invert
-and then put in the formula above instead of M. The function cannot operate in-place.
-
-@param src input image.
-@param M \f$3\times 3\f$ transformation matrix.
-@param dsize size of the output image.
-@param flags combination of interpolation methods (#INTER_LINEAR or #INTER_NEAREST) and the
-optional flag #WARP_INVERSE_MAP, that sets M as the inverse transformation (
-\f$\texttt{dst}\rightarrow\texttt{src}\f$ ).
-@param borderMode pixel extrapolation method (#BORDER_CONSTANT or #BORDER_REPLICATE).
-@param borderValue value used in case of a constant border; by default, it equals 0.
-
-@sa  warpAffine, resize, remap, getRectSubPix, perspectiveTransform
- */
-GAPI_EXPORTS GMat warpPerspective(const GMat& src, const Mat& M, const Size& dsize, int flags = cv::INTER_LINEAR,
-                                  int borderMode = cv::BORDER_CONSTANT, const Scalar& borderValue = Scalar());
-
 /** @brief Applies an affine transformation to an image.
 
 The function warpAffine transforms the source image using the specified matrix:

modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp

@@ -99,8 +99,8 @@ public:
     const cv::gapi::own::Mat&   inMat(int input);
     cv::gapi::own::Mat&         outMatR(int output); // FIXME: Avoid cv::gapi::own::Mat m = ctx.outMatR()
 
-    const cv::Scalar& inVal(int input);
-    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
+    const cv::gapi::own::Scalar& inVal(int input);
+    cv::gapi::own::Scalar& outValR(int output); // FIXME: Avoid cv::gapi::own::Scalar s = ctx.outValR()
     template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
     {
         return outVecRef(output).wref<T>();
@@ -155,7 +155,7 @@ template<> struct get_in<cv::GMatP>
 };
 template<> struct get_in<cv::GScalar>
 {
-    static cv::Scalar get(GCPUContext &ctx, int idx) { return ctx.inVal(idx); }
+    static cv::Scalar get(GCPUContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); }
 };
 template<typename U> struct get_in<cv::GArray<U> >
 {
@@ -208,12 +208,23 @@ struct tracked_cv_mat{
     }
 };
 
+struct scalar_wrapper
+{
+    scalar_wrapper(cv::gapi::own::Scalar& s) : m_s{cv::gapi::own::to_ocv(s)}, m_org_s(s) {};
+    operator cv::Scalar& () { return m_s; }
+    void writeBack() const  { m_org_s = to_own(m_s); }
+
+    cv::Scalar m_s;
+    cv::gapi::own::Scalar& m_org_s;
+};
+
 template<typename... Outputs>
 void postprocess(Outputs&... outs)
 {
     struct
     {
         void operator()(tracked_cv_mat* bm) { bm->validate();  }
+        void operator()(scalar_wrapper* sw) { sw->writeBack(); }
         void operator()(...)                {                  }
 
     } validate;
@@ -240,9 +251,10 @@ template<> struct get_out<cv::GMatP>
 };
 template<> struct get_out<cv::GScalar>
 {
-    static cv::Scalar& get(GCPUContext &ctx, int idx)
+    static scalar_wrapper get(GCPUContext &ctx, int idx)
     {
-        return ctx.outValR(idx);
+        auto& s = ctx.outValR(idx);
+        return {s};
     }
 };
 template<typename U> struct get_out<cv::GArray<U>>

modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp

@@ -18,6 +18,7 @@
 #include <opencv2/gapi/gmat.hpp>
 
 #include <opencv2/gapi/util/optional.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
 #include <opencv2/gapi/own/mat.hpp>
 
 namespace cv {
@@ -26,11 +27,13 @@ namespace fluid {
 
 struct Border
 {
+#if !defined(GAPI_STANDALONE)
     // This constructor is required to support existing kernels which are part of G-API
-    Border(int _type, cv::Scalar _val) : type(_type), value(_val) {};
-
+    Border(int _type, cv::Scalar _val) : type(_type), value(to_own(_val)) {};
+#endif // !defined(GAPI_STANDALONE)
+    Border(int _type, cv::gapi::own::Scalar _val) : type(_type), value(_val) {};
     int type;
-    cv::Scalar value;
+    cv::gapi::own::Scalar value;
 };
 
 using BorderOpt = util::optional<Border>;

modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp

@@ -17,6 +17,7 @@
 #include <opencv2/gapi/gcommon.hpp>
 #include <opencv2/gapi/gkernel.hpp>
 #include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/own/types.hpp>
 
 #include <opencv2/gapi/fluid/gfluidbuffer.hpp>
 
@@ -108,7 +109,7 @@ public:
  */
 struct GFluidOutputRois
 {
-    std::vector<cv::Rect> rois;
+    std::vector<cv::gapi::own::Rect> rois;
 };
 
 /**
@@ -178,10 +179,17 @@ template<> struct fluid_get_in<cv::GMat>
 template<> struct fluid_get_in<cv::GScalar>
 {
     // FIXME: change to return by reference when moved to own::Scalar
+#if !defined(GAPI_STANDALONE)
     static const cv::Scalar get(const cv::GArgs &in_args, int idx)
     {
-        return in_args[idx].unsafe_get<cv::Scalar>();
+        return cv::gapi::own::to_ocv(in_args[idx].unsafe_get<cv::gapi::own::Scalar>());
     }
+#else
+    static const cv::gapi::own::Scalar get(const cv::GArgs &in_args, int idx)
+    {
+        return in_args[idx].get<cv::gapi::own::Scalar>();
+    }
+#endif // !defined(GAPI_STANDALONE)
 };
 
 template<typename U> struct fluid_get_in<cv::GArray<U>>

modules/gapi/include/opencv2/gapi/garg.hpp

@@ -23,6 +23,7 @@
 #include <opencv2/gapi/gopaque.hpp>
 #include <opencv2/gapi/gtype_traits.hpp>
 #include <opencv2/gapi/gmetaarg.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
 #include <opencv2/gapi/streaming/source.hpp>
 
 namespace cv {
@@ -90,11 +91,12 @@ using GArgs = std::vector<GArg>;
 using GRunArg  = util::variant<
 #if !defined(GAPI_STANDALONE)
     cv::Mat,
+    cv::Scalar,
     cv::UMat,
 #endif // !defined(GAPI_STANDALONE)
     cv::gapi::wip::IStreamSource::Ptr,
     cv::gapi::own::Mat,
-    cv::Scalar,
+    cv::gapi::own::Scalar,
     cv::detail::VectorRef,
     cv::detail::OpaqueRef
     >;
@@ -123,10 +125,11 @@ struct Data: public GRunArg
 using GRunArgP = util::variant<
 #if !defined(GAPI_STANDALONE)
     cv::Mat*,
+    cv::Scalar*,
     cv::UMat*,
 #endif // !defined(GAPI_STANDALONE)
     cv::gapi::own::Mat*,
-    cv::Scalar*,
+    cv::gapi::own::Scalar*,
     cv::detail::VectorRef,
     cv::detail::OpaqueRef
     >;

modules/gapi/include/opencv2/gapi/gmat.hpp

@@ -14,6 +14,8 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/gcommon.hpp> // GShape
 
+#include <opencv2/gapi/own/types.hpp> // cv::gapi::own::Size
+#include <opencv2/gapi/own/convert.hpp> // to_own
 #include <opencv2/gapi/own/assert.hpp>
 
 // TODO GAPI_EXPORTS or so
@@ -80,11 +82,11 @@ struct GAPI_EXPORTS GMatDesc
     // FIXME: Default initializers in C++14
     int depth;
     int chan;
-    cv::Size size; // NB.: no multi-dimensional cases covered yet
+    cv::gapi::own::Size size; // NB.: no multi-dimensional cases covered yet
     bool planar;
     std::vector<int> dims; // FIXME: Maybe it's real questionable to have it here
 
-    GMatDesc(int d, int c, cv::Size s, bool p = false)
+    GMatDesc(int d, int c, cv::gapi::own::Size s, bool p = false)
         : depth(d), chan(c), size(s), planar(p) {}
 
     GMatDesc(int d, const std::vector<int> &dd)
@@ -120,13 +122,23 @@ struct GAPI_EXPORTS GMatDesc
     // Meta combinator: return a new GMatDesc which differs in size by delta
     // (all other fields are taken unchanged from this GMatDesc)
     // FIXME: a better name?
-    GMatDesc withSizeDelta(cv::Size delta) const
+    GMatDesc withSizeDelta(cv::gapi::own::Size delta) const
     {
         GMatDesc desc(*this);
         desc.size += delta;
         return desc;
     }
 #if !defined(GAPI_STANDALONE)
+    GMatDesc withSizeDelta(cv::Size delta) const
+    {
+        return withSizeDelta(to_own(delta));
+    }
+
+    GMatDesc withSize(cv::Size sz) const
+    {
+        return withSize(to_own(sz));
+    }
+
     bool canDescribe(const cv::Mat& mat) const;
 #endif // !defined(GAPI_STANDALONE)
     // Meta combinator: return a new GMatDesc which differs in size by delta
@@ -135,10 +147,10 @@ struct GAPI_EXPORTS GMatDesc
     // This is an overload.
     GMatDesc withSizeDelta(int dx, int dy) const
     {
-        return withSizeDelta(cv::Size{dx,dy});
+        return withSizeDelta(cv::gapi::own::Size{dx,dy});
     }
 
-    GMatDesc withSize(cv::Size sz) const
+    GMatDesc withSize(cv::gapi::own::Size sz) const
     {
         GMatDesc desc(*this);
         desc.size = sz;

modules/gapi/include/opencv2/gapi/gscalar.hpp

@@ -14,6 +14,7 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/gcommon.hpp> // GShape
 #include <opencv2/gapi/util/optional.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
 
 namespace cv
 {
@@ -30,9 +31,11 @@ class GAPI_EXPORTS GScalar
 {
 public:
     GScalar();                                         // Empty constructor
-    explicit GScalar(const cv::Scalar& s);  // Constant value constructor from cv::Scalar
-    explicit GScalar(cv::Scalar&& s);       // Constant value move-constructor from cv::Scalar
-
+    explicit GScalar(const cv::gapi::own::Scalar& s);  // Constant value constructor from cv::gapi::own::Scalar
+    explicit GScalar(cv::gapi::own::Scalar&& s);       // Constant value move-constructor from cv::gapi::own::Scalar
+#if !defined(GAPI_STANDALONE)
+    explicit GScalar(const cv::Scalar& s);             // Constant value constructor from cv::Scalar
+#endif  // !defined(GAPI_STANDALONE)
     GScalar(double v0);                                // Constant value constructor from double
     GScalar(const GNode &n, std::size_t out);          // Operation result constructor
 
@@ -66,7 +69,12 @@ struct GScalarDesc
 
 static inline GScalarDesc empty_scalar_desc() { return GScalarDesc(); }
 
+#if !defined(GAPI_STANDALONE)
 GAPI_EXPORTS GScalarDesc descr_of(const cv::Scalar            &scalar);
+#endif // !defined(GAPI_STANDALONE)
+/** @} */
+
+GAPI_EXPORTS GScalarDesc descr_of(const cv::gapi::own::Scalar &scalar);
 
 std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &desc);
 

modules/gapi/include/opencv2/gapi/gtype_traits.hpp

@@ -107,9 +107,10 @@ namespace detail
 #if !defined(GAPI_STANDALONE)
     template<>           struct GTypeOf<cv::Mat>               { using type = cv::GMat;      };
     template<>           struct GTypeOf<cv::UMat>              { using type = cv::GMat;      };
+    template<>           struct GTypeOf<cv::Scalar>            { using type = cv::GScalar;   };
 #endif // !defined(GAPI_STANDALONE)
     template<>           struct GTypeOf<cv::gapi::own::Mat>    { using type = cv::GMat;      };
-    template<>           struct GTypeOf<cv::Scalar>            { using type = cv::GScalar;   };
+    template<>           struct GTypeOf<cv::gapi::own::Scalar> { using type = cv::GScalar;   };
     template<typename U> struct GTypeOf<std::vector<U> >       { using type = cv::GArray<U>; };
     template<typename U> struct GTypeOf                        { using type = cv::GOpaque<U>;};
     // FIXME: This is not quite correct since IStreamSource may produce not only Mat but also Scalar

modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp

@@ -62,8 +62,8 @@ public:
     const cv::UMat&  inMat(int input);
     cv::UMat&  outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR()
 
-    const cv::Scalar& inVal(int input);
-    cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR()
+    const cv::gapi::own::Scalar& inVal(int input);
+    cv::gapi::own::Scalar& outValR(int output); // FIXME: Avoid cv::gapi::own::Scalar s = ctx.outValR()
     template<typename T> std::vector<T>& outVecR(int output) // FIXME: the same issue
     {
         return outVecRef(output).wref<T>();
@@ -110,7 +110,7 @@ template<> struct ocl_get_in<cv::GMat>
 };
 template<> struct ocl_get_in<cv::GScalar>
 {
-    static cv::Scalar get(GOCLContext &ctx, int idx) { return ctx.inVal(idx); }
+    static cv::Scalar get(GOCLContext &ctx, int idx) { return to_ocv(ctx.inVal(idx)); }
 };
 template<typename U> struct ocl_get_in<cv::GArray<U> >
 {
@@ -146,12 +146,24 @@ struct tracked_cv_umat{
     }
 };
 
+struct scalar_wrapper_ocl
+{
+    //FIXME reuse CPU (OpenCV) plugin code
+    scalar_wrapper_ocl(cv::gapi::own::Scalar& s) : m_s{cv::gapi::own::to_ocv(s)}, m_org_s(s) {};
+    operator cv::Scalar& () { return m_s; }
+    void writeBack() const  { m_org_s = to_own(m_s); }
+
+    cv::Scalar m_s;
+    cv::gapi::own::Scalar& m_org_s;
+};
+
 template<typename... Outputs>
 void postprocess_ocl(Outputs&... outs)
 {
     struct
     {
         void operator()(tracked_cv_umat* bm) { bm->validate(); }
+        void operator()(scalar_wrapper_ocl* sw) { sw->writeBack(); }
         void operator()(...) {                  }
 
     } validate;
@@ -171,9 +183,10 @@ template<> struct ocl_get_out<cv::GMat>
 };
 template<> struct ocl_get_out<cv::GScalar>
 {
-    static cv::Scalar& get(GOCLContext &ctx, int idx)
+    static scalar_wrapper_ocl get(GOCLContext &ctx, int idx)
     {
-        return ctx.outValR(idx);
+        auto& s = ctx.outValR(idx);
+        return{ s };
     }
 };
 template<typename U> struct ocl_get_out<cv::GArray<U> >

modules/gapi/include/opencv2/gapi/own/convert.hpp

@@ -11,7 +11,9 @@
 #if !defined(GAPI_STANDALONE)
 
 #include <opencv2/gapi/opencv_includes.hpp>
+#include <opencv2/gapi/own/types.hpp>
 #include <opencv2/gapi/own/mat.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
 
 namespace cv
 {
@@ -32,6 +34,15 @@ namespace cv
             ?  cv::gapi::own::Mat{m.rows, m.cols, m.type(), m.data, m.step}
             :  cv::gapi::own::Mat{to_own<int>(m.size), m.type(), m.data};
     };
+
+
+    inline cv::gapi::own::Scalar to_own(const cv::Scalar& s) { return {s[0], s[1], s[2], s[3]}; };
+
+    inline cv::gapi::own::Size to_own (const Size& s) { return {s.width, s.height}; };
+
+    inline cv::gapi::own::Rect to_own (const Rect& r) { return {r.x, r.y, r.width, r.height}; };
+
+
 namespace gapi
 {
 namespace own
@@ -42,6 +53,13 @@ namespace own
             : cv::Mat{m.dims, m.type(), m.data};
     }
            cv::Mat to_ocv(Mat&&)    = delete;
+
+    inline cv::Scalar to_ocv(const Scalar& s) { return {s[0], s[1], s[2], s[3]}; };
+
+    inline cv::Size to_ocv (const Size& s) { return cv::Size(s.width, s.height); };
+
+    inline cv::Rect to_ocv (const Rect& r) { return cv::Rect(r.x, r.y, r.width, r.height); };
+
 } // namespace own
 } // namespace gapi
 } // namespace cv

modules/gapi/include/opencv2/gapi/own/cvdefs.hpp

@@ -9,8 +9,6 @@
 #define OPENCV_GAPI_CV_DEFS_HPP
 
 #if defined(GAPI_STANDALONE)
-#include <opencv2/gapi/own/types.hpp> // cv::gapi::own::Rect/Size/Point
-#include <opencv2/gapi/own/scalar.hpp> // cv::gapi::own::Scalar
 
 // Simulate OpenCV definitions taken from various
 // OpenCV interface headers if G-API is built in a
@@ -139,11 +137,6 @@ enum InterpolationFlags{
     INTER_LINEAR_EXACT   = 5,
     INTER_MAX            = 7,
 };
-// replacement of cv's structures:
-using Rect   = gapi::own::Rect;
-using Size   = gapi::own::Size;
-using Point  = gapi::own::Point;
-using Scalar = gapi::own::Scalar;
 } // namespace cv
 
 static inline int cvFloor( double value )

modules/gapi/include/opencv2/gapi/render/render.hpp

@@ -17,6 +17,7 @@
 #include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/util/variant.hpp>
 #include <opencv2/gapi/own/exports.hpp>
+#include <opencv2/gapi/own/scalar.hpp>
 
 
 /** \defgroup gapi_draw G-API Drawing and composition functionality

modules/gapi/src/api/gbackend.cpp

@@ -152,11 +152,14 @@ void bindInArg(Mag& mag, const RcDesc &rc, const GRunArg &arg, bool is_umat)
 
     case GShape::GSCALAR:
     {
-        auto& mag_scalar = mag.template slot<cv::Scalar>()[rc.id];
+        auto& mag_scalar = mag.template slot<cv::gapi::own::Scalar>()[rc.id];
         switch (arg.index())
         {
-        case GRunArg::index_of<cv::Scalar>() : mag_scalar = util::get<cv::Scalar>(arg);    break;
-        default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
+            case GRunArg::index_of<cv::gapi::own::Scalar>() : mag_scalar = util::get<cv::gapi::own::Scalar>(arg); break;
+#if !defined(GAPI_STANDALONE)
+            case GRunArg::index_of<cv::Scalar>()            : mag_scalar = to_own(util::get<cv::Scalar>(arg));    break;
+#endif //  !defined(GAPI_STANDALONE)
+            default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;
     }
@@ -219,11 +222,14 @@ void bindOutArg(Mag& mag, const RcDesc &rc, const GRunArgP &arg, bool is_umat)
 
     case GShape::GSCALAR:
     {
-        auto& mag_scalar = mag.template slot<cv::Scalar>()[rc.id];
+        auto& mag_scalar = mag.template slot<cv::gapi::own::Scalar>()[rc.id];
         switch (arg.index())
         {
-        case GRunArgP::index_of<cv::Scalar*>() : mag_scalar = *util::get<cv::Scalar*>(arg); break;
-        default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
+            case GRunArgP::index_of<cv::gapi::own::Scalar*>() : mag_scalar = *util::get<cv::gapi::own::Scalar*>(arg); break;
+#if !defined(GAPI_STANDALONE)
+            case GRunArgP::index_of<cv::Scalar*>()            : mag_scalar = to_own(*util::get<cv::Scalar*>(arg)); break;
+#endif //  !defined(GAPI_STANDALONE)
+            default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;
     }
@@ -259,7 +265,7 @@ void resetInternalData(Mag& mag, const Data &d)
         break;
 
     case GShape::GSCALAR:
-        mag.template slot<cv::Scalar>()[d.rc] = cv::Scalar();
+        mag.template slot<cv::gapi::own::Scalar>()[d.rc] = cv::gapi::own::Scalar();
         break;
 
     case GShape::GMAT:
@@ -278,7 +284,7 @@ cv::GRunArg getArg(const Mag& mag, const RcDesc &ref)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GRunArg(mag.template slot<cv::gapi::own::Mat>().at(ref.id));
-    case GShape::GSCALAR: return GRunArg(mag.template slot<cv::Scalar>().at(ref.id));
+    case GShape::GSCALAR: return GRunArg(mag.template slot<cv::gapi::own::Scalar>().at(ref.id));
     // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GRunArg(mag.template slot<cv::detail::VectorRef>().at(ref.id));
@@ -304,7 +310,7 @@ cv::GRunArgP getObjPtr(Mag& mag, const RcDesc &rc, bool is_umat)
         }
         else
             return GRunArgP(&mag.template slot<cv::gapi::own::Mat>()[rc.id]);
-    case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::Scalar>()[rc.id]);
+    case GShape::GSCALAR: return GRunArgP(&mag.template slot<cv::gapi::own::Scalar>()[rc.id]);
     // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
     //   (and constructor by either bindIn/Out or resetInternal)
     case GShape::GARRAY:
@@ -375,8 +381,11 @@ void writeBack(const Mag& mag, const RcDesc &rc, GRunArgP &g_arg, bool is_umat)
     {
         switch (g_arg.index())
         {
-        case GRunArgP::index_of<cv::Scalar*>() : *util::get<cv::Scalar*>(g_arg) = mag.template slot<cv::Scalar>().at(rc.id); break;
-        default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
+            case GRunArgP::index_of<cv::gapi::own::Scalar*>() : *util::get<cv::gapi::own::Scalar*>(g_arg) = mag.template slot<cv::gapi::own::Scalar>().at(rc.id); break;
+#if !defined(GAPI_STANDALONE)
+            case GRunArgP::index_of<cv::Scalar*>()            : *util::get<cv::Scalar*>(g_arg) = cv::gapi::own::to_ocv(mag.template slot<cv::gapi::own::Scalar>().at(rc.id)); break;
+#endif //  !defined(GAPI_STANDALONE)
+            default: util::throw_error(std::logic_error("content type of the runtime argument does not match to resource description ?"));
         }
         break;
     }
@@ -395,7 +404,7 @@ void createMat(const cv::GMatDesc &desc, cv::gapi::own::Mat& mat)
     if (desc.dims.empty())
     {
         const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
-        const auto size = desc.planar ? cv::Size{desc.size.width, desc.size.height*desc.chan}
+        const auto size = desc.planar ? cv::gapi::own::Size{desc.size.width, desc.size.height*desc.chan}
                                       : desc.size;
         mat.create(size, type);
     }
@@ -414,7 +423,7 @@ void createMat(const cv::GMatDesc &desc, cv::Mat& mat)
     {
         const auto type = desc.planar ? desc.depth : CV_MAKETYPE(desc.depth, desc.chan);
         const auto size = desc.planar ? cv::Size{desc.size.width, desc.size.height*desc.chan}
-                                      : desc.size;
+                                      : cv::gapi::own::to_ocv(desc.size);
         mat.create(size, type);
     }
     else

modules/gapi/src/api/gmat.cpp

@@ -10,6 +10,7 @@
 #include <ade/util/iota_range.hpp>
 #include <ade/util/algorithm.hpp>
 
+#include <opencv2/gapi/opencv_includes.hpp>
 #include <opencv2/gapi/own/mat.hpp> //gapi::own::Mat
 #include <opencv2/gapi/gmat.hpp>
 

modules/gapi/src/api/gproto.cpp

@@ -74,7 +74,7 @@ cv::GRunArg cv::value_of(const cv::GOrigin &origin)
 {
     switch (origin.shape)
     {
-    case GShape::GSCALAR: return GRunArg(util::get<cv::Scalar>(origin.value));
+    case GShape::GSCALAR: return GRunArg(util::get<cv::gapi::own::Scalar>(origin.value));
     default: util::throw_error(std::logic_error("Unsupported shape for constant"));
     }
 }
@@ -102,13 +102,15 @@ cv::GMetaArg cv::descr_of(const cv::GRunArg &arg)
         case GRunArg::index_of<cv::Mat>():
             return cv::GMetaArg(descr_of(util::get<cv::Mat>(arg)));
 
+        case GRunArg::index_of<cv::Scalar>():
+            return cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
 #endif // !defined(GAPI_STANDALONE)
 
         case GRunArg::index_of<cv::gapi::own::Mat>():
             return cv::GMetaArg(descr_of(util::get<cv::gapi::own::Mat>(arg)));
 
-        case GRunArg::index_of<cv::Scalar>():
-            return cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
+        case GRunArg::index_of<cv::gapi::own::Scalar>():
+            return cv::GMetaArg(descr_of(util::get<cv::gapi::own::Scalar>(arg)));
 
         case GRunArg::index_of<cv::detail::VectorRef>():
             return cv::GMetaArg(util::get<cv::detail::VectorRef>(arg).descr_of());
@@ -137,11 +139,12 @@ cv::GMetaArg cv::descr_of(const cv::GRunArgP &argp)
 #if !defined(GAPI_STANDALONE)
     case GRunArgP::index_of<cv::Mat*>():               return GMetaArg(descr_of(*util::get<cv::Mat*>(argp)));
     case GRunArgP::index_of<cv::UMat*>():              return GMetaArg(descr_of(*util::get<cv::UMat*>(argp)));
+    case GRunArgP::index_of<cv::Scalar*>():            return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
 #endif //  !defined(GAPI_STANDALONE)
     case GRunArgP::index_of<cv::gapi::own::Mat*>():    return GMetaArg(descr_of(*util::get<cv::gapi::own::Mat*>(argp)));
-    case GRunArgP::index_of<cv::Scalar*>():            return GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
-    case GRunArgP::index_of<cv::detail::VectorRef>():  return GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of());
-    case GRunArgP::index_of<cv::detail::OpaqueRef>():  return GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
+    case GRunArgP::index_of<cv::gapi::own::Scalar*>(): return GMetaArg(descr_of(*util::get<cv::gapi::own::Scalar*>(argp)));
+    case GRunArgP::index_of<cv::detail::VectorRef>(): return GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of());
+    case GRunArgP::index_of<cv::detail::OpaqueRef>(): return GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
     default: util::throw_error(std::logic_error("Unsupported GRunArgP type"));
     }
 }
@@ -154,10 +157,11 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArgP& argp)
     case GRunArgP::index_of<cv::Mat*>():               return util::holds_alternative<GMatDesc>(meta) &&
                                                               util::get<GMatDesc>(meta).canDescribe(*util::get<cv::Mat*>(argp));
     case GRunArgP::index_of<cv::UMat*>():              return meta == GMetaArg(descr_of(*util::get<cv::UMat*>(argp)));
+    case GRunArgP::index_of<cv::Scalar*>():            return meta == GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
 #endif //  !defined(GAPI_STANDALONE)
     case GRunArgP::index_of<cv::gapi::own::Mat*>():    return util::holds_alternative<GMatDesc>(meta) &&
                                                               util::get<GMatDesc>(meta).canDescribe(*util::get<cv::gapi::own::Mat*>(argp));
-    case GRunArgP::index_of<cv::Scalar*>():            return meta == GMetaArg(descr_of(*util::get<cv::Scalar*>(argp)));
+    case GRunArgP::index_of<cv::gapi::own::Scalar*>(): return meta == GMetaArg(descr_of(*util::get<cv::gapi::own::Scalar*>(argp)));
     case GRunArgP::index_of<cv::detail::VectorRef>():  return meta == GMetaArg(util::get<cv::detail::VectorRef>(argp).descr_of());
     case GRunArgP::index_of<cv::detail::OpaqueRef>():  return meta == GMetaArg(util::get<cv::detail::OpaqueRef>(argp).descr_of());
     default: util::throw_error(std::logic_error("Unsupported GRunArgP type"));
@@ -172,10 +176,11 @@ bool cv::can_describe(const GMetaArg& meta, const GRunArg& arg)
     case GRunArg::index_of<cv::Mat>():               return util::holds_alternative<GMatDesc>(meta) &&
                                                             util::get<GMatDesc>(meta).canDescribe(util::get<cv::Mat>(arg));
     case GRunArg::index_of<cv::UMat>():              return meta == cv::GMetaArg(descr_of(util::get<cv::UMat>(arg)));
+    case GRunArg::index_of<cv::Scalar>():            return meta == cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
 #endif //  !defined(GAPI_STANDALONE)
     case GRunArg::index_of<cv::gapi::own::Mat>():    return util::holds_alternative<GMatDesc>(meta) &&
                                                             util::get<GMatDesc>(meta).canDescribe(util::get<cv::gapi::own::Mat>(arg));
-    case GRunArg::index_of<cv::Scalar>():            return meta == cv::GMetaArg(descr_of(util::get<cv::Scalar>(arg)));
+    case GRunArg::index_of<cv::gapi::own::Scalar>(): return meta == cv::GMetaArg(descr_of(util::get<cv::gapi::own::Scalar>(arg)));
     case GRunArg::index_of<cv::detail::VectorRef>(): return meta == cv::GMetaArg(util::get<cv::detail::VectorRef>(arg).descr_of());
     case GRunArg::index_of<cv::detail::OpaqueRef>(): return meta == cv::GMetaArg(util::get<cv::detail::OpaqueRef>(arg).descr_of());
     case GRunArg::index_of<cv::gapi::wip::IStreamSource::Ptr>(): return util::holds_alternative<GMatDesc>(meta); // FIXME(?) may be not the best option

modules/gapi/src/api/gscalar.cpp

@@ -22,18 +22,18 @@ cv::GScalar::GScalar(const GNode &n, std::size_t out)
 {
 }
 
-cv::GScalar::GScalar(const cv::Scalar& s)
+cv::GScalar::GScalar(const cv::gapi::own::Scalar& s)
     : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(s)))
 {
 }
 
-cv::GScalar::GScalar(cv::Scalar&& s)
+cv::GScalar::GScalar(cv::gapi::own::Scalar&& s)
     : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(std::move(s))))
 {
 }
 
 cv::GScalar::GScalar(double v0)
-    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(cv::Scalar(v0))))
+    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(cv::gapi::own::Scalar(v0))))
 {
 }
 
@@ -47,11 +47,23 @@ const cv::GOrigin& cv::GScalar::priv() const
     return *m_priv;
 }
 
-cv::GScalarDesc cv::descr_of(const cv::Scalar &)
+cv::GScalarDesc cv::descr_of(const cv::gapi::own::Scalar &)
 {
     return empty_scalar_desc();
 }
 
+#if !defined(GAPI_STANDALONE)
+cv::GScalar::GScalar(const cv::Scalar& s)
+    : m_priv(new GOrigin(GShape::GSCALAR, cv::gimpl::ConstVal(to_own(s))))
+{
+}
+
+cv::GScalarDesc cv::descr_of(const cv::Scalar& s)
+{
+    return cv::descr_of(to_own(s));
+}
+#endif // !defined(GAPI_STANDALONE)
+
 namespace cv {
 std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &)
 {

modules/gapi/src/api/kernels_core.cpp

@@ -371,12 +371,6 @@ GMat normalize(const GMat& _src, double a, double b,
     return core::GNormalize::on(_src, a, b, norm_type, ddepth);
 }
 
-GMat warpPerspective(const GMat& src, const Mat& M, const Size& dsize, int flags,
-                     int borderMode, const Scalar& borderValue)
-{
-    return core::GWarpPerspective::on(src, M, dsize, flags, borderMode, borderValue);
-}
-
 GMat warpAffine(const GMat& src, const Mat& M, const Size& dsize, int flags,
                 int borderMode, const Scalar& borderValue)
 {

modules/gapi/src/backends/common/gbackend.hpp

@@ -17,6 +17,7 @@
 #include "opencv2/gapi/own/mat.hpp"
 
 #include "opencv2/gapi/util/optional.hpp"
+#include "opencv2/gapi/own/scalar.hpp"
 
 #include "compiler/gmodel.hpp"
 
@@ -45,9 +46,9 @@ namespace magazine {
 
 } // namespace magazine
 #if !defined(GAPI_STANDALONE)
-using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+using Mag = magazine::Class<cv::gapi::own::Mat, cv::UMat, cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
 #else
-using Mag = magazine::Class<cv::gapi::own::Mat, cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+using Mag = magazine::Class<cv::gapi::own::Mat, cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
 #endif
 
 namespace magazine

modules/gapi/src/backends/cpu/gcpubackend.cpp

@@ -129,7 +129,7 @@ cv::GArg cv::gimpl::GCPUExecutable::packArg(const GArg &arg)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GArg(m_res.slot<cv::gapi::own::Mat>()   [ref.id]);
-    case GShape::GSCALAR: return GArg(m_res.slot<cv::Scalar>()[ref.id]);
+    case GShape::GSCALAR: return GArg(m_res.slot<cv::gapi::own::Scalar>()[ref.id]);
     // Note: .at() is intentional for GArray and GOpaque as objects MUST be already there
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id));

modules/gapi/src/backends/cpu/gcpucore.cpp

@@ -558,15 +558,6 @@ GAPI_OCV_KERNEL(GCPUNormalize, cv::gapi::core::GNormalize)
     }
 };
 
-GAPI_OCV_KERNEL(GCPUWarpPerspective, cv::gapi::core::GWarpPerspective)
-{
-    static void run(const cv::Mat& src, const cv::Mat& M,  const cv::Size& dsize,
-                    int flags, int borderMode, const cv::Scalar& borderValue, cv::Mat& out)
-    {
-        cv::warpPerspective(src, out, M, dsize, flags, borderMode, borderValue);
-    }
-};
-
 GAPI_OCV_KERNEL(GCPUWarpAffine, cv::gapi::core::GWarpAffine)
 {
     static void run(const cv::Mat& src, const cv::Mat& M,  const cv::Size& dsize,
@@ -645,7 +636,6 @@ cv::gapi::GKernelPackage cv::gapi::core::cpu::kernels()
          , GCPUConvertTo
          , GCPUSqrt
          , GCPUNormalize
-         , GCPUWarpPerspective
          , GCPUWarpAffine
          >();
     return pkg;

modules/gapi/src/backends/cpu/gcpuimgproc.cpp

@@ -353,7 +353,7 @@ G_TYPED_KERNEL(GYUV2Gray, <cv::GMat(cv::GMat)>, "yuvtogray") {
          * U V U V U V U V
          */
 
-        return {CV_8U, 1, cv::Size{in.size.width, in.size.height - (in.size.height / 3)}, false};
+        return {CV_8U, 1, cv::gapi::own::Size{in.size.width, in.size.height - (in.size.height / 3)}, false};
     }
 };
 
@@ -367,7 +367,7 @@ GAPI_OCV_KERNEL(GCPUYUV2Gray, GYUV2Gray)
 
 G_TYPED_KERNEL(GConcatYUVPlanes, <cv::GMat(cv::GMat, cv::GMat)>, "concatyuvplanes") {
     static cv::GMatDesc outMeta(cv::GMatDesc y, cv::GMatDesc uv) {
-        return {CV_8U, 1, cv::Size{y.size.width, y.size.height + uv.size.height}, false};
+        return {CV_8U, 1, cv::gapi::own::Size{y.size.width, y.size.height + uv.size.height}, false};
     }
 };
 

modules/gapi/src/backends/cpu/gcpukernel.cpp

@@ -21,14 +21,14 @@ cv::gapi::own::Mat&  cv::GCPUContext::outMatR(int output)
     return *util::get<cv::gapi::own::Mat*>(m_results.at(output));
 }
 
-const cv::Scalar& cv::GCPUContext::inVal(int input)
+const cv::gapi::own::Scalar& cv::GCPUContext::inVal(int input)
 {
-    return inArg<cv::Scalar>(input);
+    return inArg<cv::gapi::own::Scalar>(input);
 }
 
-cv::Scalar& cv::GCPUContext::outValR(int output)
+cv::gapi::own::Scalar& cv::GCPUContext::outValR(int output)
 {
-    return *util::get<cv::Scalar*>(m_results.at(output));
+    return *util::get<cv::gapi::own::Scalar*>(m_results.at(output));
 }
 
 cv::detail::VectorRef& cv::GCPUContext::outVecRef(int output)

modules/gapi/src/backends/fluid/gfluidbackend.cpp

@@ -554,8 +554,8 @@ void cv::gimpl::FluidAgent::debug(std::ostream &os)
 // GCPUExcecutable implementation //////////////////////////////////////////////
 
 void cv::gimpl::GFluidExecutable::initBufferRois(std::vector<int>& readStarts,
-                                                 std::vector<cv::Rect>& rois,
-                                                 const std::vector<cv::Rect>& out_rois)
+                                                 std::vector<cv::gapi::own::Rect>& rois,
+                                                 const std::vector<cv::gapi::own::Rect>& out_rois)
 {
     GConstFluidModel fg(m_g);
     auto proto = m_gm.metadata().get<Protocol>();
@@ -592,9 +592,9 @@ void cv::gimpl::GFluidExecutable::initBufferRois(std::vector<int>& readStarts,
             readStarts[id] = 0;
 
             const auto& out_roi = out_rois[idx];
-            if (out_roi == cv::Rect{})
+            if (out_roi == gapi::own::Rect{})
             {
-                rois[id] = cv::Rect{ 0, 0, desc.size.width, desc.size.height };
+                rois[id] = gapi::own::Rect{ 0, 0, desc.size.width, desc.size.height };
             }
             else
             {
@@ -639,14 +639,14 @@ void cv::gimpl::GFluidExecutable::initBufferRois(std::vector<int>& readStarts,
                     const auto& in_meta = util::get<GMatDesc>(in_data.meta);
                     const auto& fd = fg.metadata(in_node).get<FluidData>();
 
-                    auto adjFilterRoi = [](cv::Rect produced, int b, int max_height) {
+                    auto adjFilterRoi = [](cv::gapi::own::Rect produced, int b, int max_height) {
                         // Extend with border roi which should be produced, crop to logical image size
-                        cv::Rect roi = {produced.x, produced.y - b, produced.width, produced.height + 2*b};
-                        cv::Rect fullImg{ 0, 0, produced.width, max_height };
+                        cv::gapi::own::Rect roi = {produced.x, produced.y - b, produced.width, produced.height + 2*b};
+                        cv::gapi::own::Rect fullImg{ 0, 0, produced.width, max_height };
                         return roi & fullImg;
                     };
 
-                    auto adjResizeRoi = [](cv::Rect produced, cv::Size inSz, cv::Size outSz) {
+                    auto adjResizeRoi = [](cv::gapi::own::Rect produced, cv::gapi::own::Size inSz, cv::gapi::own::Size outSz) {
                         auto map = [](int outCoord, int producedSz, int inSize, int outSize) {
                             double ratio = (double)inSize / outSize;
                             int w0 = 0, w1 = 0;
@@ -671,30 +671,30 @@ void cv::gimpl::GFluidExecutable::initBufferRois(std::vector<int>& readStarts,
                         auto x0 = mapX.first;
                         auto x1 = mapX.second;
 
-                        cv::Rect roi = {x0, y0, x1 - x0, y1 - y0};
+                        cv::gapi::own::Rect roi = {x0, y0, x1 - x0, y1 - y0};
                         return roi;
                     };
 
-                    auto adj420Roi = [&](cv::Rect produced, std::size_t port) {
+                    auto adj420Roi = [&](cv::gapi::own::Rect produced, std::size_t port) {
                         GAPI_Assert(produced.x % 2 == 0);
                         GAPI_Assert(produced.y % 2 == 0);
                         GAPI_Assert(produced.width % 2 == 0);
                         GAPI_Assert(produced.height % 2 == 0);
 
-                        cv::Rect roi;
+                        cv::gapi::own::Rect roi;
                         switch (port) {
                         case 0: roi = produced; break;
                         case 1:
-                        case 2: roi = cv::Rect{ produced.x/2, produced.y/2, produced.width/2, produced.height/2 }; break;
+                        case 2: roi = cv::gapi::own::Rect{ produced.x/2, produced.y/2, produced.width/2, produced.height/2 }; break;
                         default: GAPI_Assert(false);
                         }
                         return roi;
                     };
 
-                    cv::Rect produced = rois[m_id_map.at(data.rc)];
+                    cv::gapi::own::Rect produced = rois[m_id_map.at(data.rc)];
 
                     // Apply resize-specific roi transformations
-                    cv::Rect resized;
+                    cv::gapi::own::Rect resized;
                     switch (fg.metadata(oh).get<FluidUnit>().k.m_kind)
                     {
                     case GFluidKernel::Kind::Filter:      resized = produced; break;
@@ -727,7 +727,7 @@ void cv::gimpl::GFluidExecutable::initBufferRois(std::vector<int>& readStarts,
                     auto roi = adjFilterRoi(resized, fd.border_size, in_meta.size.height);
 
                     auto in_id = m_id_map.at(in_data.rc);
-                    if (rois[in_id] == cv::Rect{})
+                    if (rois[in_id] == cv::gapi::own::Rect{})
                     {
                         readStarts[in_id] = readStart;
                         rois[in_id] = roi;
@@ -828,7 +828,7 @@ cv::gimpl::FluidGraphInputData cv::gimpl::fluidExtractInputDataFromGraph(const a
 
 cv::gimpl::GFluidExecutable::GFluidExecutable(const ade::Graph                       &g,
                                               const cv::gimpl::FluidGraphInputData   &traverse_res,
-                                              const std::vector<cv::Rect> &outputRois)
+                                              const std::vector<cv::gapi::own::Rect> &outputRois)
     : m_g(g), m_gm(m_g),
       m_num_int_buffers (traverse_res.m_mat_count),
       m_scratch_users   (traverse_res.m_scratch_users),
@@ -1146,13 +1146,13 @@ namespace
     }
 }
 
-void cv::gimpl::GFluidExecutable::makeReshape(const std::vector<cv::Rect> &out_rois)
+void cv::gimpl::GFluidExecutable::makeReshape(const std::vector<gapi::own::Rect> &out_rois)
 {
     GConstFluidModel fg(m_g);
 
     // Calculate rois for each fluid buffer
     std::vector<int> readStarts(m_num_int_buffers);
-    std::vector<cv::Rect> rois(m_num_int_buffers);
+    std::vector<cv::gapi::own::Rect> rois(m_num_int_buffers);
     initBufferRois(readStarts, rois, out_rois);
 
     // NB: Allocate ALL buffer object at once, and avoid any further reallocations
@@ -1248,7 +1248,7 @@ void cv::gimpl::GFluidExecutable::bindInArg(const cv::gimpl::RcDesc &rc, const G
     switch (rc.shape)
     {
     case GShape::GMAT:    m_buffers[m_id_map.at(rc.id)].priv().bindTo(util::get<cv::gapi::own::Mat>(arg), true); break;
-    case GShape::GSCALAR: m_res.slot<cv::Scalar>()[rc.id] = util::get<cv::Scalar>(arg); break;
+    case GShape::GSCALAR: m_res.slot<cv::gapi::own::Scalar>()[rc.id] = util::get<cv::gapi::own::Scalar>(arg); break;
     case GShape::GARRAY:  m_res.slot<cv::detail::VectorRef>()[rc.id] = util::get<cv::detail::VectorRef>(arg); break;
     case GShape::GOPAQUE: m_res.slot<cv::detail::OpaqueRef>()[rc.id] = util::get<cv::detail::OpaqueRef>(arg); break;
     }
@@ -1301,7 +1301,7 @@ void cv::gimpl::GFluidExecutable::packArg(cv::GArg &in_arg, const cv::GArg &op_a
         const cv::gimpl::RcDesc &ref = op_arg.get<cv::gimpl::RcDesc>();
         if (ref.shape == GShape::GSCALAR)
         {
-            in_arg = GArg(m_res.slot<cv::Scalar>()[ref.id]);
+            in_arg = GArg(m_res.slot<cv::gapi::own::Scalar>()[ref.id]);
         }
         else if (ref.shape == GShape::GARRAY)
         {

modules/gapi/src/backends/fluid/gfluidbackend.hpp

@@ -129,7 +129,7 @@ class GFluidExecutable final: public GIslandExecutable
 
     std::vector<FluidAgent*> m_script;
 
-    using Magazine = detail::magazine<cv::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
+    using Magazine = detail::magazine<cv::gapi::own::Scalar, cv::detail::VectorRef, cv::detail::OpaqueRef>;
     Magazine m_res;
 
     std::size_t m_num_int_buffers; // internal buffers counter (m_buffers - num_scratch)
@@ -142,8 +142,8 @@ class GFluidExecutable final: public GIslandExecutable
     void bindOutArg(const RcDesc &rc, const GRunArgP &arg);
     void packArg   (GArg &in_arg, const GArg &op_arg);
 
-    void initBufferRois(std::vector<int>& readStarts, std::vector<cv::Rect>& rois, const std::vector<cv::Rect> &out_rois);
-    void makeReshape(const std::vector<cv::Rect>& out_rois);
+    void initBufferRois(std::vector<int>& readStarts, std::vector<cv::gapi::own::Rect>& rois, const std::vector<gapi::own::Rect> &out_rois);
+    void makeReshape(const std::vector<cv::gapi::own::Rect>& out_rois);
     std::size_t total_buffers_size() const;
 
 public:
@@ -159,7 +159,7 @@ public:
 
      GFluidExecutable(const ade::Graph                          &g,
                       const FluidGraphInputData                 &graph_data,
-                      const std::vector<cv::Rect>               &outputRois);
+                      const std::vector<cv::gapi::own::Rect>    &outputRois);
 };
 
 

modules/gapi/src/backends/fluid/gfluidbuffer.cpp

@@ -9,6 +9,9 @@
 
 #include <iomanip>   // hex, dec (debug)
 
+#include <opencv2/gapi/own/convert.hpp>
+#include <opencv2/gapi/own/types.hpp>
+
 #include <opencv2/gapi/fluid/gfluidbuffer.hpp>
 #include "backends/fluid/gfluidbuffer_priv.hpp"
 #include <opencv2/gapi/opencv_includes.hpp>
@@ -61,7 +64,7 @@ void fillBorderReflectRow(uint8_t* row, int length, int chan, int borderSize)
 }
 
 template<typename T>
-void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::Scalar borderValue)
+void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::gapi::own::Scalar borderValue)
 {
     GAPI_DbgAssert(chan > 0 && chan <= 4);
 
@@ -78,7 +81,7 @@ void fillConstBorderRow(uint8_t* row, int length, int chan, int borderSize, cv::
 }
 
 // Fills const border pixels in the whole mat
-void fillBorderConstant(int borderSize, cv::Scalar borderValue, cv::gapi::own::Mat& mat)
+void fillBorderConstant(int borderSize, cv::gapi::own::Scalar borderValue, cv::gapi::own::Mat& mat)
 {
     // cv::Scalar can contain maximum 4 chan
     GAPI_Assert(mat.channels() > 0 && mat.channels() <= 4);
@@ -166,7 +169,7 @@ const uint8_t* fluid::BorderHandlerT<BorderType>::inLineB(int log_idx, const Buf
     return data.ptr(idx);
 }
 
-fluid::BorderHandlerT<cv::BORDER_CONSTANT>::BorderHandlerT(int border_size, cv::Scalar border_value)
+fluid::BorderHandlerT<cv::BORDER_CONSTANT>::BorderHandlerT(int border_size, cv::gapi::own::Scalar border_value)
     : BorderHandler(border_size), m_border_value(border_value)
 { /* nothing */ }
 
@@ -178,9 +181,7 @@ const uint8_t* fluid::BorderHandlerT<cv::BORDER_CONSTANT>::inLineB(int /*log_idx
 void fluid::BorderHandlerT<cv::BORDER_CONSTANT>::fillCompileTimeBorder(BufferStorageWithBorder& data)
 {
     m_const_border.create(1, data.cols(), data.data().type());
-    // FIXME: remove this crutch in deowned Mat
-    m_const_border = {m_border_value[0], m_border_value[1],
-                      m_border_value[2], m_border_value[3]};
+    m_const_border = m_border_value;
 
     cv::gapi::fillBorderConstant(m_border_size, m_border_value, data.data());
 }
@@ -268,8 +269,8 @@ const uint8_t* fluid::BufferStorageWithBorder::inLineB(int log_idx, int desc_hei
 
 static void copyWithoutBorder(const cv::gapi::own::Mat& src, int src_border_size, cv::gapi::own::Mat& dst, int dst_border_size, int startSrcLine, int startDstLine, int lpi)
 {
-    auto subSrc = src(cv::Rect{src_border_size, startSrcLine, src.cols - 2*src_border_size, lpi});
-    auto subDst = dst(cv::Rect{dst_border_size, startDstLine, dst.cols - 2*dst_border_size, lpi});
+    auto subSrc = src(cv::gapi::own::Rect{src_border_size, startSrcLine, src.cols - 2*src_border_size, lpi});
+    auto subDst = dst(cv::gapi::own::Rect{dst_border_size, startDstLine, dst.cols - 2*dst_border_size, lpi});
 
     subSrc.copyTo(subDst);
 }
@@ -362,8 +363,8 @@ std::unique_ptr<fluid::BufferStorage> createStorage(int capacity, int desc_width
 #endif
 }
 
-std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::Rect roi);
-std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::Rect roi)
+std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::gapi::own::Rect roi);
+std::unique_ptr<BufferStorage> createStorage(const cv::gapi::own::Mat& data, cv::gapi::own::Rect roi)
 {
     std::unique_ptr<BufferStorageWithoutBorder> storage(new BufferStorageWithoutBorder);
     storage->attach(data, roi);
@@ -501,7 +502,7 @@ void fluid::View::Priv::initCache(int lineConsumption)
 
 // Fluid Buffer implementation /////////////////////////////////////////////////
 
-fluid::Buffer::Priv::Priv(int read_start, cv::Rect roi)
+fluid::Buffer::Priv::Priv(int read_start, cv::gapi::own::Rect roi)
     : m_readStart(read_start)
     , m_roi(roi)
 {}
@@ -509,12 +510,12 @@ fluid::Buffer::Priv::Priv(int read_start, cv::Rect roi)
 void fluid::Buffer::Priv::init(const cv::GMatDesc &desc,
                                int writer_lpi,
                                int readStartPos,
-                               cv::Rect roi)
+                               cv::gapi::own::Rect roi)
 {
     m_writer_lpi = writer_lpi;
     m_desc       = desc;
     m_readStart  = readStartPos;
-    m_roi        = roi == cv::Rect{} ? cv::Rect{ 0, 0, desc.size.width, desc.size.height }
+    m_roi        = roi == own::Rect{} ? own::Rect{ 0, 0, desc.size.width, desc.size.height }
                                       : roi;
     m_cache.m_linePtrs.resize(writer_lpi);
     m_cache.m_desc = desc;
@@ -649,7 +650,7 @@ fluid::Buffer::Buffer(const cv::GMatDesc &desc)
 {
     int lineConsumption = 1;
     int border = 0, skew = 0, wlpi = 1, readStart = 0;
-    cv::Rect roi = {0, 0, desc.size.width, desc.size.height};
+    cv::gapi::own::Rect roi = {0, 0, desc.size.width, desc.size.height};
     m_priv->init(desc, wlpi, readStart, roi);
     m_priv->allocate({}, border, lineConsumption, skew);
 }
@@ -664,7 +665,7 @@ fluid::Buffer::Buffer(const cv::GMatDesc &desc,
     , m_cache(&m_priv->cache())
 {
     int readStart = 0;
-    cv::Rect roi = {0, 0, desc.size.width, desc.size.height};
+    cv::gapi::own::Rect roi = {0, 0, desc.size.width, desc.size.height};
     m_priv->init(desc, wlpi, readStart, roi);
     m_priv->allocate(border, border_size, max_line_consumption, skew);
 }
@@ -674,7 +675,7 @@ fluid::Buffer::Buffer(const cv::gapi::own::Mat &data, bool is_input)
     , m_cache(&m_priv->cache())
 {
     int wlpi = 1, readStart = 0;
-    cv::Rect roi{0, 0, data.cols, data.rows};
+    cv::gapi::own::Rect roi{0, 0, data.cols, data.rows};
     m_priv->init(descr_of(data), wlpi, readStart, roi);
     m_priv->bindTo(data, is_input);
 }

modules/gapi/src/backends/fluid/gfluidbuffer_priv.hpp

@@ -52,11 +52,11 @@ public:
 template<>
 class BorderHandlerT<cv::BORDER_CONSTANT> : public BorderHandler
 {
-    cv::Scalar m_border_value;
+    cv::gapi::own::Scalar m_border_value;
     cv::gapi::own::Mat m_const_border;
 
 public:
-    BorderHandlerT(int border_size, cv::Scalar border_value);
+    BorderHandlerT(int border_size, cv::gapi::own::Scalar border_value);
     virtual const uint8_t* inLineB(int log_idx, const BufferStorageWithBorder &data, int desc_height) const override;
     virtual void fillCompileTimeBorder(BufferStorageWithBorder &) override;
     virtual std::size_t size() const override;
@@ -101,23 +101,23 @@ public:
 class BufferStorageWithoutBorder final : public BufferStorage
 {
     bool m_is_virtual = true;
-    cv::Rect m_roi;
+    cv::gapi::own::Rect m_roi;
 
 public:
     virtual void copyTo(BufferStorageWithBorder &dst, int startLine, int nLines) const override;
 
     inline virtual const uint8_t* ptr(int idx) const override
     {
-        GAPI_DbgAssert((m_is_virtual && m_roi == cv::Rect{}) || (!m_is_virtual && m_roi != cv::Rect{}));
+        GAPI_DbgAssert((m_is_virtual && m_roi == cv::gapi::own::Rect{}) || (!m_is_virtual && m_roi != cv::gapi::own::Rect{}));
         return m_data.ptr(physIdx(idx), 0);
     }
     inline virtual uint8_t* ptr(int idx) override
     {
-        GAPI_DbgAssert((m_is_virtual && m_roi == cv::Rect{}) || (!m_is_virtual && m_roi != cv::Rect{}));
+        GAPI_DbgAssert((m_is_virtual && m_roi == cv::gapi::own::Rect{}) || (!m_is_virtual && m_roi != cv::gapi::own::Rect{}));
         return m_data.ptr(physIdx(idx), 0);
     }
 
-    inline void attach(const cv::gapi::own::Mat& _data, cv::Rect _roi)
+    inline void attach(const cv::gapi::own::Mat& _data, cv::gapi::own::Rect _roi)
     {
         m_data = _data(_roi);
         m_roi = _roi;
@@ -246,13 +246,13 @@ class GAPI_EXPORTS Buffer::Priv
     // Coordinate starting from which this buffer is assumed
     // to be read (with border not being taken into account)
     int m_readStart;
-    cv::Rect m_roi;
+    cv::gapi::own::Rect m_roi;
 
     friend void debugBufferPriv(const Buffer& p, std::ostream &os);
 
 public:
     Priv() = default;
-    Priv(int read_start, cv::Rect roi);
+    Priv(int read_start, cv::gapi::own::Rect roi);
 
     inline const BufferStorage& storage() const { return *m_storage.get(); }
 
@@ -260,7 +260,7 @@ public:
     void init(const cv::GMatDesc &desc,
               int writer_lpi,
               int readStart,
-              cv::Rect roi);
+              cv::gapi::own::Rect roi);
 
     void allocate(BorderOpt border, int border_size, int line_consumption, int skew);
     void bindTo(const cv::gapi::own::Mat &data, bool is_input);

modules/gapi/src/backends/fluid/gfluidcore.cpp

@@ -2040,7 +2040,7 @@ GAPI_FLUID_KERNEL(GFluidResize, cv::gapi::core::GResize, true)
         cv::GMatDesc desc;
         desc.chan  = 1;
         desc.depth = CV_8UC1;
-        desc.size  = scratch_size;
+        desc.size  = to_own(scratch_size);
 
         cv::gapi::fluid::Buffer buffer(desc);
         scratch = std::move(buffer);

modules/gapi/src/backends/fluid/gfluidimgproc.cpp

@@ -15,6 +15,8 @@
 #include <opencv2/gapi/core.hpp>
 #include <opencv2/gapi/imgproc.hpp>
 
+#include <opencv2/gapi/own/types.hpp>
+
 #include <opencv2/gapi/fluid/gfluidbuffer.hpp>
 #include <opencv2/gapi/fluid/gfluidkernel.hpp>
 #include <opencv2/gapi/fluid/imgproc.hpp>
@@ -449,7 +451,7 @@ GAPI_FLUID_KERNEL(GFluidBlur, cv::gapi::imgproc::GBlur, true)
 
         int buflen = width * chan * Window;  // work buffers
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -524,7 +526,7 @@ GAPI_FLUID_KERNEL(GFluidBoxFilter, cv::gapi::imgproc::GBoxFilter, true)
 
         int buflen = width * chan * Window;  // work buffers
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -746,7 +748,7 @@ GAPI_FLUID_KERNEL(GFluidSepFilter, cv::gapi::imgproc::GSepFilter, true)
         int buflen = kxLen + kyLen +         // x, y kernels
                      width * chan * Window;  // work buffers
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -849,7 +851,7 @@ GAPI_FLUID_KERNEL(GFluidGaussBlur, cv::gapi::imgproc::GGaussBlur, true)
         int buflen = kxsize + kysize +       // x, y kernels
                      width * chan * ksize.height;  // work buffers
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1014,7 +1016,7 @@ GAPI_FLUID_KERNEL(GFluidSobel, cv::gapi::imgproc::GSobel, true)
         int buflen = ksz + ksz            // kernels: kx, ky
                    + ksz * width * chan;  // working buffers
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1169,7 +1171,7 @@ GAPI_FLUID_KERNEL(GFluidSobelXY, cv::gapi::imgproc::GSobelXY, true)
         int chan  = in.chan;
         int buflen = BufHelper::length(ksz, width, chan);
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1317,7 +1319,7 @@ GAPI_FLUID_KERNEL(GFluidFilter2D, cv::gapi::imgproc::GFilter2D, true)
 
         int buflen = krows * kcols;  // kernel size
 
-        cv::Size bufsize(buflen, 1);
+        cv::gapi::own::Size bufsize(buflen, 1);
         GMatDesc bufdesc = {CV_32F, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1494,7 +1496,7 @@ GAPI_FLUID_KERNEL(GFluidErode, cv::gapi::imgproc::GErode, true)
         int k_cols = kernel.cols;
         int k_size = k_rows * k_cols;
 
-        cv::Size bufsize(k_size + 1, 1);
+        cv::gapi::own::Size bufsize(k_size + 1, 1);
         GMatDesc bufdesc = {CV_8U, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1523,7 +1525,7 @@ GAPI_FLUID_KERNEL(GFluidErode, cv::gapi::imgproc::GErode, true)
     #if 1
         // TODO: saturate borderValue to image type in general case (not only maximal border)
         GAPI_Assert(borderType == cv::BORDER_CONSTANT && borderValue[0] == DBL_MAX);
-        return { borderType, cv::Scalar::all(INT_MAX) };
+        return { borderType, cv::gapi::own::Scalar::all(INT_MAX) };
     #else
         return { borderType, borderValue };
     #endif
@@ -1580,7 +1582,7 @@ GAPI_FLUID_KERNEL(GFluidDilate, cv::gapi::imgproc::GDilate, true)
         int k_cols = kernel.cols;
         int k_size = k_rows * k_cols;
 
-        cv::Size bufsize(k_size + 1, 1);
+        cv::gapi::own::Size bufsize(k_size + 1, 1);
         GMatDesc bufdesc = {CV_8U, 1, bufsize};
         Buffer buffer(bufdesc);
         scratch = std::move(buffer);
@@ -1609,7 +1611,7 @@ GAPI_FLUID_KERNEL(GFluidDilate, cv::gapi::imgproc::GDilate, true)
     #if 1
         // TODO: fix borderValue for Dilate in general case (not only minimal border)
         GAPI_Assert(borderType == cv::BORDER_CONSTANT && borderValue[0] == DBL_MAX);
-        return { borderType, cv::Scalar::all(INT_MIN) };
+        return { borderType, cv::gapi::own::Scalar::all(INT_MIN) };
     #else
         return { borderType, borderValue };
     #endif
@@ -1747,7 +1749,7 @@ GAPI_FLUID_KERNEL(GFluidRGB2HSV, cv::gapi::imgproc::GRGB2HSV, true)
         cv::GMatDesc desc;
         desc.chan  = 1;
         desc.depth = CV_32S;
-        desc.size  = cv::Size(512, 1);
+        desc.size  = cv::gapi::own::Size(512, 1);
 
         cv::gapi::fluid::Buffer buffer(desc);
         scratch = std::move(buffer);

modules/gapi/src/backends/ocl/goclbackend.cpp

@@ -129,7 +129,7 @@ cv::GArg cv::gimpl::GOCLExecutable::packArg(const GArg &arg)
     switch (ref.shape)
     {
     case GShape::GMAT:    return GArg(m_res.slot<cv::UMat>()[ref.id]);
-    case GShape::GSCALAR: return GArg(m_res.slot<cv::Scalar>()[ref.id]);
+    case GShape::GSCALAR: return GArg(m_res.slot<cv::gapi::own::Scalar>()[ref.id]);
     // Note: .at() is intentional for GArray as object MUST be already there
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GARRAY:  return GArg(m_res.slot<cv::detail::VectorRef>().at(ref.id));

modules/gapi/src/backends/ocl/goclkernel.cpp

@@ -19,14 +19,14 @@ cv::UMat& cv::GOCLContext::outMatR(int output)
     return (*(util::get<cv::UMat*>(m_results.at(output))));
 }
 
-const cv::Scalar& cv::GOCLContext::inVal(int input)
+const cv::gapi::own::Scalar& cv::GOCLContext::inVal(int input)
 {
-    return inArg<cv::Scalar>(input);
+    return inArg<cv::gapi::own::Scalar>(input);
 }
 
-cv::Scalar& cv::GOCLContext::outValR(int output)
+cv::gapi::own::Scalar& cv::GOCLContext::outValR(int output)
 {
-    return *util::get<cv::Scalar*>(m_results.at(output));
+    return *util::get<cv::gapi::own::Scalar*>(m_results.at(output));
 }
 
 cv::detail::VectorRef& cv::GOCLContext::outVecRef(int output)

modules/gapi/src/compiler/gobjref.hpp

@@ -28,7 +28,7 @@ namespace gimpl
 
     using ConstVal = util::variant
     < util::monostate
-    , cv::Scalar
+    , cv::gapi::own::Scalar
     >;
 
     struct RcDesc

modules/gapi/src/executor/gstreamingexecutor.cpp

@@ -112,12 +112,15 @@ void sync_data(cv::GRunArgs &results, cv::GRunArgsP &outputs)
         case T::index_of<cv::Mat*>():
             *cv::util::get<cv::Mat*>(out_obj) = std::move(cv::util::get<cv::Mat>(res_obj));
             break;
+        case T::index_of<cv::Scalar*>():
+            *cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj));
+            break;
 #endif // !GAPI_STANDALONE
         case T::index_of<own::Mat*>():
             *cv::util::get<own::Mat*>(out_obj) = std::move(cv::util::get<own::Mat>(res_obj));
             break;
-        case T::index_of<cv::Scalar*>():
-            *cv::util::get<cv::Scalar*>(out_obj) = std::move(cv::util::get<cv::Scalar>(res_obj));
+        case T::index_of<own::Scalar*>():
+            *cv::util::get<own::Scalar*>(out_obj) = std::move(cv::util::get<own::Scalar>(res_obj));
             break;
         case T::index_of<cv::detail::VectorRef>():
             cv::util::get<cv::detail::VectorRef>(out_obj).mov(cv::util::get<cv::detail::VectorRef>(res_obj));
@@ -415,7 +418,7 @@ void islandActorThread(std::vector<cv::gimpl::RcDesc> in_rcs,                //
                 isl_input.second = cv::GRunArg{cv::to_own(cv::util::get<cv::Mat>(in_arg))};
                 break;
             case cv::GRunArg::index_of<cv::Scalar>():
-                isl_input.second = cv::GRunArg{cv::util::get<cv::Scalar>(in_arg)};
+                isl_input.second = cv::GRunArg{cv::to_own(cv::util::get<cv::Scalar>(in_arg))};
                 break;
             default:
                 isl_input.second = in_arg;
@@ -440,7 +443,7 @@ void islandActorThread(std::vector<cv::gimpl::RcDesc> in_rcs,                //
             using SclType = cv::Scalar;
 #else
             using MatType = cv::gapi::own::Mat;
-            using SclType = cv::Scalar;
+            using SclType = cv::gapi::own::Scalar;
 #endif // GAPI_STANDALONE
 
             switch (r.shape) {

modules/gapi/test/common/gapi_core_tests.hpp

@@ -142,13 +142,8 @@ struct BackendOutputAllocationTest : TestWithParamBase<>
 struct BackendOutputAllocationLargeSizeWithCorrectSubmatrixTest : BackendOutputAllocationTest {};
 GAPI_TEST_FIXTURE(ReInitOutTest, initNothing, <cv::Size>, 1, out_sz)
 
-GAPI_TEST_FIXTURE(WarpPerspectiveTest, initMatrixRandU,
-        FIXTURE_API(CompareMats, double , double, int, int, cv::Scalar),
-        6, cmpF, angle, scale, flags, border_mode, border_value)
-
-GAPI_TEST_FIXTURE(WarpAffineTest, initMatrixRandU,
-        FIXTURE_API(CompareMats, double , double, int, int, cv::Scalar),
-        6, cmpF, angle, scale, flags, border_mode, border_value)
+GAPI_TEST_FIXTURE(WarpAffineTest, initMatrixRandU, FIXTURE_API(CompareMats, double , double, int, int, cv::Scalar), 6,
+    cmpF, angle, scale, flags, border_mode, border_value)
 } // opencv_test
 
 #endif //OPENCV_GAPI_CORE_TESTS_HPP

modules/gapi/test/common/gapi_core_tests_inl.hpp

@@ -1266,30 +1266,6 @@ TEST_P(SqrtTest, AccuracyTest)
     }
 }
 
-TEST_P(WarpPerspectiveTest, AccuracyTest)
-{
-    cv::Point center{in_mat1.size() / 2};
-    cv::Mat xy = cv::getRotationMatrix2D(center, angle, scale);
-    cv::Matx13d z (0, 0, 1);
-    cv::Mat transform_mat;
-    cv::vconcat(xy, z, transform_mat);
-
-    // G-API code //////////////////////////////////////////////////////////////
-    cv::GMat in;
-    auto out = cv::gapi::warpPerspective(in, transform_mat, in_mat1.size(), flags, border_mode, border_value);
-
-    cv::GComputation c(in, out);
-    c.apply(in_mat1, out_mat_gapi, getCompileArgs());
-
-    // OpenCV code /////////////////////////////////////////////////////////////
-    cv::warpPerspective(in_mat1, out_mat_ocv, cv::Mat(transform_mat), in_mat1.size(), flags, border_mode, border_value);
-
-    // Comparison //////////////////////////////////////////////////////////////
-    {
-        EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
-    }
-}
-
 TEST_P(WarpAffineTest, AccuracyTest)
 {
     cv::Point center{in_mat1.size() / 2};

modules/gapi/test/cpu/gapi_core_tests_cpu.cpp

@@ -435,19 +435,6 @@ INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
                                 Values(-1),
                                 Values(CORE_CPU)));
 
-INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
-                        Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
-                                Values(-1),
-                                Values(CORE_CPU),
-                                Values(AbsExact().to_compare_obj()),
-                                Values(-50.0, 90.0),
-                                Values(0.6),
-                                Values(cv::INTER_LINEAR),
-                                Values(cv::BORDER_CONSTANT),
-                                Values(cv::Scalar())));
-
 INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
                                 Values(cv::Size(1280, 720),

modules/gapi/test/gapi_async_test.cpp

@@ -388,10 +388,11 @@ namespace {
             switch (arg.index()){
     #if !defined(GAPI_STANDALONE)
                 case GRunArgP::index_of<cv::Mat*>()                 :   result.emplace_back(*util::get<cv::Mat*>(arg));     break;
+                case GRunArgP::index_of<cv::Scalar*>()              :   result.emplace_back(*util::get<cv::Scalar*>(arg));  break;
                 case GRunArgP::index_of<cv::UMat*>()                :   result.emplace_back(*util::get<cv::UMat*>(arg));    break;
     #endif // !defined(GAPI_STANDALONE)
                 case GRunArgP::index_of<cv::gapi::own::Mat*>()      :   result.emplace_back(*util::get<cv::gapi::own::Mat*>   (arg));   break;
-                case GRunArgP::index_of<cv::Scalar*>()              :   result.emplace_back(*util::get<cv::Scalar*>           (arg));   break;
+                case GRunArgP::index_of<cv::gapi::own::Scalar*>()   :   result.emplace_back(*util::get<cv::gapi::own::Scalar*>(arg));   break;
                 case GRunArgP::index_of<cv::detail::VectorRef>()    :   result.emplace_back(util::get<cv::detail::VectorRef>  (arg));   break;
                 default : ;
             }
@@ -405,11 +406,12 @@ namespace {
             switch (arg.index()){
     #if !defined(GAPI_STANDALONE)
                 case GRunArg::index_of<cv::Mat>()                 :   result.emplace_back(&util::get<cv::Mat>(arg));     break;
+                case GRunArg::index_of<cv::Scalar>()              :   result.emplace_back(&util::get<cv::Scalar>(arg));  break;
                 case GRunArg::index_of<cv::UMat>()                :   result.emplace_back(&util::get<cv::UMat>(arg));    break;
     #endif // !defined(GAPI_STANDALONE)
                 case GRunArg::index_of<cv::gapi::own::Mat>()      :   result.emplace_back(&util::get<cv::gapi::own::Mat>   (arg));   break;
-                case GRunArg::index_of<cv::Scalar>()              :   result.emplace_back(&util::get<cv::Scalar>           (arg));   break;
-                case GRunArg::index_of<cv::detail::VectorRef>()   :   result.emplace_back(util::get<cv::detail::VectorRef> (arg));   break;
+                case GRunArg::index_of<cv::gapi::own::Scalar>()   :   result.emplace_back(&util::get<cv::gapi::own::Scalar>(arg));   break;
+                case GRunArg::index_of<cv::detail::VectorRef>()   :   result.emplace_back(util::get<cv::detail::VectorRef>  (arg));   break;
                 default : ;
             }
         }

modules/gapi/test/gapi_fluid_parallel_rois_test.cpp

@@ -22,7 +22,7 @@ namespace {
     cv::GFluidParallelOutputRois asGFluidParallelOutputRois(const std::vector<cv::Rect>& rois){
         cv::GFluidParallelOutputRois parallel_rois;
         for (auto const& roi : rois) {
-            parallel_rois.parallel_rois.emplace_back(GFluidOutputRois{{roi}});
+            parallel_rois.parallel_rois.emplace_back(GFluidOutputRois{{to_own(roi)}});
         }
         return parallel_rois;
     }

modules/gapi/test/gapi_fluid_resize_test.cpp

@@ -744,7 +744,7 @@ TEST_P(NV12PlusResizeTest, Test)
     auto pkg = cv::gapi::combine(fluidTestPackage, cv::gapi::core::fluid::kernels());
 
     c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat)
-           ,cv::compile_args(pkg, cv::GFluidOutputRois{{roi}}));
+           ,cv::compile_args(pkg, cv::GFluidOutputRois{{to_own(roi)}}));
 
     cv::Mat rgb_mat;
     cv::cvtColor(in_mat, rgb_mat, cv::COLOR_YUV2RGB_NV12);
@@ -823,7 +823,7 @@ TEST_P(Preproc4lpiTest, Test)
                                  fluidResizeTestPackage(interp, in_sz, out_sz, 4));
 
     c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat)
-           ,cv::compile_args(pkg, cv::GFluidOutputRois{{roi}}));
+           ,cv::compile_args(pkg, cv::GFluidOutputRois{{to_own(roi)}}));
 
     cv::Mat rgb_mat;
     cv::cvtColor(in_mat, rgb_mat, cv::COLOR_YUV2RGB_NV12);

modules/gapi/test/gapi_fluid_roi_test.cpp

@@ -38,7 +38,7 @@ TEST_P(PartialComputation, Test)
     cv::Mat out_mat_ocv = cv::Mat::zeros(sz, CV_8UC1);
 
     // Run G-API
-    auto cc = c.compile(cv::descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{roi}}));
+    auto cc = c.compile(cv::descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{to_own(roi)}}));
     cc(cv::gin(in_mat), cv::gout(out_mat_gapi));
 
     // Check with OpenCV
@@ -72,7 +72,7 @@ TEST_P(PartialComputationAddC, Test)
     cv::Mat out_mat_ocv = cv::Mat::zeros(sz, CV_8UC1);
 
     // Run G-API
-    auto cc = c.compile(cv::descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{roi}}));
+    auto cc = c.compile(cv::descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{to_own(roi)}}));
     cc(cv::gin(in_mat), cv::gout(out_mat_gapi));
 
     // Check with OpenCV
@@ -110,7 +110,7 @@ TEST_P(SequenceOfBlursRoiTest, Test)
     Mat out_mat_gapi = Mat::zeros(sz_in, CV_8UC1);
 
     GComputation c(GIn(in), GOut(out));
-    auto cc = c.compile(descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{roi}}));
+    auto cc = c.compile(descr_of(in_mat), cv::compile_args(fluidTestPackage, GFluidOutputRois{{to_own(roi)}}));
     cc(gin(in_mat), gout(out_mat_gapi));
 
     cv::Mat mid_mat_ocv = Mat::zeros(sz_in, CV_8UC1);

modules/gapi/test/gapi_fluid_test.cpp

@@ -75,7 +75,7 @@ TEST(FluidBuffer, CircularTest)
     const cv::Size buffer_size = {8,16};
 
     cv::gapi::fluid::Buffer buffer(cv::GMatDesc{CV_8U,1,buffer_size}, 3, 1, 0, 1,
-        util::make_optional(cv::gapi::fluid::Border{cv::BORDER_CONSTANT, cv::Scalar(255)}));
+        util::make_optional(cv::gapi::fluid::Border{cv::BORDER_CONSTANT, cv::gapi::own::Scalar(255)}));
     cv::gapi::fluid::View view = buffer.mkView(1, {});
     view.priv().reset(3);
     view.priv().allocate(3, {});
@@ -754,7 +754,7 @@ TEST_P(NV12RoiTest, Test)
     auto rgb = cv::gapi::NV12toRGB(y, uv);
     cv::GComputation c(cv::GIn(y, uv), cv::GOut(rgb));
 
-    c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat), cv::compile_args(fluidTestPackage, cv::GFluidOutputRois{{roi}}));
+    c.apply(cv::gin(y_mat, uv_mat), cv::gout(out_mat), cv::compile_args(fluidTestPackage, cv::GFluidOutputRois{{to_own(roi)}}));
 
     cv::cvtColor(in_mat, out_mat_ocv, cv::COLOR_YUV2RGB_NV12);
 
@@ -835,7 +835,7 @@ TEST(Fluid, InvalidROIs)
     };
 
     const auto compile_args = [] (cv::Rect roi) {
-        return cv::compile_args(cv::gapi::core::fluid::kernels(), GFluidOutputRois{{roi}});
+        return cv::compile_args(cv::gapi::core::fluid::kernels(), GFluidOutputRois{{to_own(roi)}});
     };
 
     for (const auto& roi : invalid_rois)

modules/gapi/test/gapi_fluid_test_kernels.cpp

@@ -184,7 +184,7 @@ GAPI_FLUID_KERNEL(FBlur3x3, TBlur3x3, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, borderValue};
+        return { borderType, to_own(borderValue)};
     }
 };
 
@@ -200,7 +200,7 @@ GAPI_FLUID_KERNEL(FBlur5x5, TBlur5x5, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, borderValue};
+        return { borderType, to_own(borderValue)};
     }
 };
 
@@ -217,7 +217,7 @@ GAPI_FLUID_KERNEL(FBlur3x3_2lpi, TBlur3x3_2lpi, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, borderValue};
+        return { borderType, to_own(borderValue)};
     }
 };
 
@@ -234,7 +234,7 @@ GAPI_FLUID_KERNEL(FBlur5x5_2lpi, TBlur5x5_2lpi, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc &/*src*/, int borderType, cv::Scalar borderValue)
     {
-        return { borderType, borderValue};
+        return { borderType, to_own(borderValue )};
     }
 };
 
@@ -261,7 +261,7 @@ GAPI_FLUID_KERNEL(FIdentity, TId, false)
 
     static gapi::fluid::Border getBorder(const cv::GMatDesc &)
     {
-        return { cv::BORDER_REPLICATE, cv::Scalar{} };
+        return { cv::BORDER_REPLICATE, cv::gapi::own::Scalar{} };
     }
 };
 
@@ -308,7 +308,7 @@ GAPI_FLUID_KERNEL(FId7x7, TId7x7, false)
 
     static cv::gapi::fluid::Border getBorder(const cv::GMatDesc&/* src*/)
     {
-        return { cv::BORDER_REPLICATE, cv::Scalar{} };
+        return { cv::BORDER_REPLICATE, cv::gapi::own::Scalar{} };
     }
 };
 

modules/gapi/test/gapi_gcompiled_tests.cpp

@@ -61,7 +61,7 @@ TEST_F(GCompiledValidateMetaTyped, ValidMeta)
 
 TEST_F(GCompiledValidateMetaTyped, InvalidMeta)
 {
-    auto f = m_cc.compile(cv::GMatDesc{CV_8U,1,cv::Size(64,32)},
+    auto f = m_cc.compile(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(64,32)},
                           cv::empty_scalar_desc());
 
     cv::Scalar sc(33);
@@ -106,7 +106,7 @@ TEST_F(GCompiledValidateMetaUntyped, ValidMeta)
 
 TEST_F(GCompiledValidateMetaUntyped, InvalidMetaValues)
 {
-    auto f = m_ucc.compile(cv::GMatDesc{CV_8U,1,cv::Size(64,32)},
+    auto f = m_ucc.compile(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(64,32)},
                            cv::empty_scalar_desc());
 
     cv::Scalar sc(33);
@@ -131,7 +131,7 @@ TEST_F(GCompiledValidateMetaUntyped, InvalidMetaValues)
 
 TEST_F(GCompiledValidateMetaUntyped, InvalidMetaShape)
 {
-    auto f = m_ucc.compile(cv::GMatDesc{CV_8U,1,cv::Size(64,32)},
+    auto f = m_ucc.compile(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(64,32)},
                            cv::empty_scalar_desc());
 
     cv::Mat in1 = cv::Mat::eye(cv::Size(64,32), CV_8UC1);

modules/gapi/test/gapi_gcomputation_tests.cpp

@@ -19,13 +19,13 @@ namespace opencv_test
           static cv::GMatDesc outMeta(cv::GMatDesc in, cv::Size sz, double fx, double fy, int) {
               if (sz.width != 0 && sz.height != 0)
               {
-                  return in.withSize(sz);
+                  return in.withSize(to_own(sz));
               }
               else
               {
                   GAPI_Assert(fx != 0. && fy != 0.);
                   return in.withSize
-                    (cv::Size(static_cast<int>(std::round(in.size.width  * fx)),
+                    (cv::gapi::own::Size(static_cast<int>(std::round(in.size.width  * fx)),
                                          static_cast<int>(std::round(in.size.height * fy))));
               }
           }

modules/gapi/test/gapi_kernel_tests.cpp

@@ -6,6 +6,7 @@
 
 
 #include "test_precomp.hpp"
+#include <opencv2/gapi/cpu/gcpukernel.hpp>
 #include "gapi_mock_kernels.hpp"
 
 #include <opencv2/gapi/cpu/gcpukernel.hpp>     // cpu::backend

modules/gapi/test/internal/gapi_int_gmetaarg_test.cpp

@@ -141,7 +141,7 @@ TEST(GMetaArg, Can_Describe_RunArg)
     constexpr int w = 3, h = 3, c = 3;
     uchar data[w*h*c];
     cv::gapi::own::Mat om(h, w, CV_8UC3, data);
-    cv::Scalar os;
+    cv::gapi::own::Scalar os;
     std::vector<int> v;
 
     GMetaArgs metas = {GMetaArg(descr_of(m)),
@@ -181,7 +181,7 @@ TEST(GMetaArg, Can_Describe_RunArgP)
     constexpr int w = 3, h = 3, c = 3;
     uchar data[w*h*c];
     cv::gapi::own::Mat om(h, w, CV_8UC3, data);
-    cv::Scalar os;
+    cv::gapi::own::Scalar os;
     std::vector<int> v;
 
     GMetaArgs metas = {GMetaArg(descr_of(m)),

modules/gapi/test/internal/gapi_int_gmodel_builder_test.cpp

@@ -166,8 +166,8 @@ TEST(GModelBuilder, Constant_GScalar)
     EXPECT_EQ(9u, static_cast<std::size_t>(g.nodes().size()));          // 6 data nodes (1 -input, 1 output, 2 constant, 2 temp) and 3 op nodes
     EXPECT_EQ(2u, static_cast<std::size_t>(addC_nh->inNodes().size())); // in and 3
     EXPECT_EQ(2u, static_cast<std::size_t>(mulC_nh->inNodes().size())); // addC output and c_s
-    EXPECT_EQ(3, (util::get<cv::Scalar>(gm.metadata(s_3).get<cv::gimpl::ConstValue>().arg))[0]);
-    EXPECT_EQ(5, (util::get<cv::Scalar>(gm.metadata(s_5).get<cv::gimpl::ConstValue>().arg))[0]);
+    EXPECT_EQ(3, (util::get<cv::gapi::own::Scalar>(gm.metadata(s_3).get<cv::gimpl::ConstValue>().arg))[0]);
+    EXPECT_EQ(5, (util::get<cv::gapi::own::Scalar>(gm.metadata(s_5).get<cv::gimpl::ConstValue>().arg))[0]);
 }
 
 TEST(GModelBuilder, Check_Multiple_Outputs)

modules/gapi/test/internal/gapi_int_island_fusion_tests.cpp

@@ -34,7 +34,7 @@ TEST(IslandFusion, TwoOps_OneIsland)
     cv::GComputation cc(in, out);
 
     // Prepare compilation parameters manually
-    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
+    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)});
     const auto pkg     = cv::gapi::kernels<J::Foo>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -77,7 +77,7 @@ TEST(IslandFusion, TwoOps_TwoIslands)
     cv::GComputation cc(in, out);
 
     // Prepare compilation parameters manually
-    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
+    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)});
     const auto pkg     = cv::gapi::kernels<J::Foo, S::Bar>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -142,8 +142,8 @@ TEST(IslandFusion, ConsumerHasTwoInputs)
     cv::GComputation cc(cv::GIn(in[0], in[1]), cv::GOut(out));
 
     // Prepare compilation parameters manually
-    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)}),
-                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)})};
+    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)}),
+                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)})};
     const auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -211,7 +211,7 @@ TEST(IslandFusion, DataNodeUsedDifferentBackend)
     cv::GComputation cc(cv::GIn(in), cv::GOut(out0, out1));
 
     // Prepare compilation parameters manually
-    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
+    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)});
     const auto pkg     = cv::gapi::kernels<J::Foo, S::Baz>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -272,7 +272,7 @@ TEST(IslandFusion, LoopBetweenDifferentBackends)
     cv::GComputation cc(cv::GIn(in), cv::GOut(out1, out0));
 
     // Prepare compilation parameters manually
-    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
+    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)});
     const auto pkg     = cv::gapi::kernels<J::Baz, J::Quux, S::Foo, S::Qux>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -334,8 +334,8 @@ TEST(IslandsFusion, PartionOverlapUserIsland)
     cv::GComputation cc(cv::GIn(in[0], in[1]), cv::GOut(out));
 
     // Prepare compilation parameters manually
-    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)}),
-                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)})};
+    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)}),
+                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)})};
     const auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -391,8 +391,8 @@ TEST(IslandsFusion, DISABLED_IslandContainsDifferentBackends)
     cv::GComputation cc(cv::GIn(in[0], in[1]), cv::GOut(out));
 
     // Prepare compilation parameters manually
-    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)}),
-                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)})};
+    cv::GMetaArgs in_metas = {GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)}),
+                              GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)})};
     const auto pkg = cv::gapi::kernels<J::Foo, S::Bar>();
 
     // Directly instantiate G-API graph compiler and run partial compilation
@@ -424,7 +424,7 @@ TEST(IslandFusion, WithLoop)
     cv::GComputation cc(in, out);
 
     // Prepare compilation parameters manually
-    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
+    const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::gapi::own::Size(32,32)});
     const auto pkg     = cv::gapi::kernels<J::Foo, J::Baz, J::Qux>();
 
     // Directly instantiate G-API graph compiler and run partial compilation

modules/gapi/test/internal/gapi_int_recompilation_test.cpp

@@ -216,7 +216,7 @@ TEST(GComputationCompile, ReshapeRois)
         int roiH = szOut.height / niter;
         cv::Rect roi{x, y, roiW, roiH};
 
-        cc.apply(in_mat, out_mat, cv::compile_args(cv::GFluidOutputRois{{roi}}));
+        cc.apply(in_mat, out_mat, cv::compile_args(cv::GFluidOutputRois{{to_own(roi)}}));
         auto comp = cc.priv().m_lastCompiled;
 
         EXPECT_EQ(&first_comp.priv(), &comp.priv());

modules/imgcodecs/CMakeLists.txt

@@ -45,11 +45,6 @@ if(HAVE_TIFF)
   list(APPEND GRFMT_LIBS ${TIFF_LIBRARIES})
 endif()
 
-if(HAVE_OPENJPEG)
-  ocv_include_directories(${OPENJPEG_INCLUDE_DIRS})
-  list(APPEND GRFMT_LIBS ${OPENJPEG_LIBRARIES})
-endif()
-
 if(HAVE_JASPER)
   ocv_include_directories(${JASPER_INCLUDE_DIR})
   list(APPEND GRFMT_LIBS ${JASPER_LIBRARIES})

modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.cpp

@@ -1,762 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level directory
-// of this distribution and at http://opencv.org/license.html.
-//
-// Copyright (C) 2020, Stefan Brüns <stefan.bruens@rwth-aachen.de>
-
-#include "precomp.hpp"
-
-#ifdef HAVE_OPENJPEG
-#include "grfmt_jpeg2000_openjpeg.hpp"
-
-#include "opencv2/core/utils/logger.hpp"
-
-namespace cv {
-
-namespace {
-
-String colorspaceName(COLOR_SPACE colorspace)
-{
-    switch (colorspace)
-    {
-    case OPJ_CLRSPC_CMYK:
-        return "CMYK";
-    case OPJ_CLRSPC_SRGB:
-        return "sRGB";
-    case OPJ_CLRSPC_EYCC:
-        return "e-YCC";
-    case OPJ_CLRSPC_GRAY:
-        return "grayscale";
-    case OPJ_CLRSPC_SYCC:
-        return "YUV";
-    case OPJ_CLRSPC_UNKNOWN:
-        return "unknown";
-    case OPJ_CLRSPC_UNSPECIFIED:
-        return "unspecified";
-    default:
-        CV_Assert(!"Invalid colorspace");
-    }
-}
-
-template <class T>
-struct ConstItTraits {
-    using value_type = T;
-    using difference_type = std::ptrdiff_t;
-    using pointer = const T*;
-    using reference = const T&;
-};
-
-template <class T>
-struct NonConstItTraits {
-   using value_type = T;
-   using difference_type = std::ptrdiff_t;
-   using pointer = T*;
-   using reference = T&;
-};
-
-/**
- * Iterator over the channel in continuous chunk of the memory e.g. in the one row of a Mat
- * No bounds checks are preformed due to keeping this class as simple as possible while
- * fulfilling RandomAccessIterator naming requirements.
- *
- * @tparam Traits holds information about value type and constness of the defined types
- */
-template <class Traits>
-class ChannelsIterator
-{
-public:
-    using difference_type = typename Traits::difference_type;
-    using value_type = typename Traits::value_type;
-    using pointer = typename Traits::pointer;
-    using reference = typename Traits::reference;
-    using iterator_category = std::random_access_iterator_tag;
-
-    ChannelsIterator(pointer ptr, std::size_t channel, std::size_t channels_count)
-        : ptr_ { ptr + channel }, step_ { channels_count }
-    {
-    }
-
-    /* Element Access */
-    reference operator*() const
-    {
-        return *ptr_;
-    }
-
-    pointer operator->() const
-    {
-        return &(operator*());
-    }
-
-    reference operator[](difference_type n) const
-    {
-        return *(*this + n);
-    }
-
-    /* Iterator movement */
-    ChannelsIterator<Traits>& operator++()
-    {
-        ptr_ += step_;
-        return *this;
-    }
-
-    ChannelsIterator<Traits> operator++(int)
-    {
-        ChannelsIterator ret(*this);
-        ++(*this);
-        return ret;
-    }
-
-    ChannelsIterator<Traits>& operator--()
-    {
-        ptr_ -= step_;
-        return *this;
-    }
-
-    ChannelsIterator<Traits> operator--(int)
-    {
-        ChannelsIterator ret(*this);
-        --(*this);
-        return ret;
-    }
-
-    ChannelsIterator<Traits>& operator-=(difference_type n)
-    {
-        ptr_ -= n * step_;
-        return *this;
-    }
-
-    ChannelsIterator<Traits>& operator+=(difference_type n)
-    {
-        ptr_ += n * step_;
-        return *this;
-    }
-
-    ChannelsIterator<Traits> operator-(difference_type n) const
-    {
-        return ChannelsIterator<Traits>(*this) -= n;
-    }
-
-    ChannelsIterator<Traits> operator+(difference_type n) const
-    {
-        return ChannelsIterator<Traits>(*this) += n;
-    }
-
-    difference_type operator-(const ChannelsIterator<Traits>& other)
-    {
-        return (ptr_ - other.ptr_) / step_;
-    }
-
-    /* Comparision */
-    bool operator==(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return ptr_ == other.ptr_;
-    }
-
-    bool operator!=(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return !(*this == other);
-    }
-
-    bool operator<(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return ptr_ < other.ptr_;
-    }
-
-    bool operator>(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return other < *this;
-    }
-
-    bool operator>=(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return !(*this < other);
-    }
-
-    bool operator<=(const ChannelsIterator<Traits>& other) const CV_NOEXCEPT
-    {
-        return !(other < *this);
-    }
-
-private:
-    pointer ptr_{nullptr};
-    std::size_t step_{1};
-};
-
-template <class Traits>
-inline ChannelsIterator<Traits> operator+(typename Traits::difference_type n, const ChannelsIterator<Traits>& it)
-{
-    return it + n;
-}
-
-template<typename OutT, typename InT>
-void copyToMatImpl(std::vector<InT*>&& in, Mat& out, uint8_t shift)
-{
-    using ChannelsIt = ChannelsIterator<NonConstItTraits<OutT>>;
-
-    Size size = out.size();
-    if (out.isContinuous())
-    {
-        size.width *= size.height;
-        size.height = 1;
-    }
-
-    const bool isShiftRequired = shift != 0;
-
-    const std::size_t channelsCount = in.size();
-
-    if (isShiftRequired)
-    {
-        for (int i = 0; i < size.height; ++i)
-        {
-            auto rowPtr = out.ptr<OutT>(i);
-            for (std::size_t c = 0; c < channelsCount; ++c)
-            {
-                const auto first = in[c];
-                const auto last = first + size.width;
-                auto dOut = ChannelsIt(rowPtr, c, channelsCount);
-                std::transform(first, last, dOut, [shift](InT val) -> OutT { return val >> shift; });
-                in[c] += size.width;
-            }
-        }
-    }
-    else
-    {
-        for (int i = 0; i < size.height; ++i)
-        {
-            auto rowPtr = out.ptr<OutT>(i);
-            for (std::size_t c = 0; c < channelsCount; ++c)
-            {
-                const auto first = in[c];
-                const auto last = first + size.width;
-                auto dOut = ChannelsIt(rowPtr, c, channelsCount);
-                std::copy(first, last, dOut);
-                in[c] += size.width;
-            }
-        }
-    }
-}
-
-template<typename InT>
-void copyToMat(std::vector<const InT*>&& in, Mat& out, uint8_t shift)
-{
-    switch (out.depth())
-    {
-    case CV_8U:
-        copyToMatImpl<uint8_t>(std::move(in), out, shift);
-        break;
-    case CV_16U:
-        copyToMatImpl<uint16_t>(std::move(in), out, shift);
-        break;
-    default:
-        CV_Error(Error::StsNotImplemented, "only depth CV_8U and CV16_U are supported");
-    }
-}
-
-template<typename InT, typename OutT>
-void copyFromMatImpl(const Mat& in, std::vector<OutT*>&& out)
-{
-    using ChannelsIt = ChannelsIterator<ConstItTraits<InT>>;
-
-    Size size = in.size();
-    if (in.isContinuous())
-    {
-        size.width *= size.height;
-        size.height = 1;
-    }
-
-    const std::size_t outChannelsCount = out.size();
-
-    for (int i = 0; i < size.height; ++i)
-    {
-        const InT* row = in.ptr<InT>(i);
-        for (std::size_t c = 0; c < outChannelsCount; ++c)
-        {
-            auto first = ChannelsIt(row, c, outChannelsCount);
-            auto last = first + size.width;
-            out[c] = std::copy(first, last, out[c]);
-        }
-    }
-}
-
-template<typename OutT>
-void copyFromMat(const Mat& in, std::vector<OutT*>&& out)
-{
-    switch (in.depth())
-    {
-    case CV_8U:
-        copyFromMatImpl<uint8_t>(in, std::move(out));
-        break;
-    case CV_16U:
-        copyFromMatImpl<uint16_t>(in, std::move(out));
-        break;
-    default:
-        CV_Error(Error::StsNotImplemented, "only depth CV_8U and CV16_U are supported");
-    }
-}
-
-void errorLogCallback(const char* msg, void* /* userData */)
-{
-    CV_LOG_ERROR(NULL, cv::format("OpenJPEG2000: %s", msg));
-}
-
-void warningLogCallback(const char* msg, void* /* userData */)
-{
-    CV_LOG_WARNING(NULL, cv::format("OpenJPEG2000: %s", msg));
-}
-
-void setupLogCallbacks(opj_codec_t* codec)
-{
-    if (!opj_set_error_handler(codec, errorLogCallback, nullptr))
-    {
-        CV_LOG_WARNING(NULL, "OpenJPEG2000: can not set error log handler");
-    }
-    if (!opj_set_warning_handler(codec, warningLogCallback, nullptr))
-    {
-        CV_LOG_WARNING(NULL, "OpenJPEG2000: can not set warning log handler");
-    }
-}
-
-opj_dparameters setupDecoderParameters()
-{
-    opj_dparameters parameters;
-    opj_set_default_decoder_parameters(&parameters);
-    return parameters;
-}
-
-opj_cparameters setupEncoderParameters(const std::vector<int>& params)
-{
-    opj_cparameters parameters;
-    opj_set_default_encoder_parameters(&parameters);
-    for (size_t i = 0; i < params.size(); i += 2)
-    {
-        switch (params[i])
-        {
-        case cv::IMWRITE_JPEG2000_COMPRESSION_X1000:
-            parameters.tcp_rates[0] = 1000.f / std::min(std::max(params[i + 1], 1), 1000);
-            break;
-        default:
-            CV_LOG_WARNING(NULL, "OpenJPEG2000(encoder): skip unsupported parameter: " << params[i]);
-            break;
-        }
-    }
-    parameters.tcp_numlayers = 1;
-    parameters.cp_disto_alloc = 1;
-    return parameters;
-}
-
-bool decodeSRGBData(const opj_image_t& inImg, cv::Mat& outImg, uint8_t shift)
-{
-    using ImageComponents = std::vector<const OPJ_INT32*>;
-
-    const int inChannels = inImg.numcomps;
-    const int outChannels = outImg.channels();
-
-    if (outChannels == 1)
-    {
-        // Assume gray (+ alpha) for 1 channels -> gray
-        if (inChannels <= 2)
-        {
-            copyToMat(ImageComponents { inImg.comps[0].data }, outImg, shift);
-        }
-        // Assume RGB for >= 3 channels -> gray
-        else
-        {
-            Mat tmp(outImg.size(), CV_MAKETYPE(outImg.depth(), 3));
-            copyToMat(ImageComponents { inImg.comps[2].data, inImg.comps[1].data, inImg.comps[0].data },
-                      tmp, shift);
-            cvtColor(tmp, outImg, COLOR_BGR2GRAY);
-        }
-        return true;
-    }
-
-    if (inChannels >= 3)
-    {
-        // Assume RGB (+ alpha) for 3 channels -> BGR
-        ImageComponents incomps { inImg.comps[2].data, inImg.comps[1].data, inImg.comps[0].data };
-        // Assume RGBA for 4 channels -> BGRA
-        if (outChannels > 3)
-        {
-            incomps.push_back(inImg.comps[3].data);
-        }
-        copyToMat(std::move(incomps), outImg, shift);
-        return true;
-    }
-    CV_LOG_ERROR(NULL,
-                 cv::format("OpenJPEG2000: unsupported conversion from %d components to %d for SRGB image decoding",
-                            inChannels, outChannels));
-    return false;
-}
-
-bool decodeGrayscaleData(const opj_image_t& inImg, cv::Mat& outImg, uint8_t shift)
-{
-    using ImageComponents = std::vector<const OPJ_INT32*>;
-
-    const int inChannels = inImg.numcomps;
-    const int outChannels = outImg.channels();
-
-    if (outChannels == 1 || outChannels == 3)
-    {
-        copyToMat(ImageComponents(outChannels, inImg.comps[0].data), outImg, shift);
-        return true;
-    }
-    CV_LOG_ERROR(NULL,
-                 cv::format("OpenJPEG2000: unsupported conversion from %d components to %d for Grayscale image decoding",
-                            inChannels, outChannels));
-    return false;
-}
-
-bool decodeSYCCData(const opj_image_t& inImg, cv::Mat& outImg, uint8_t shift)
-{
-    using ImageComponents = std::vector<const OPJ_INT32*>;
-
-    const int inChannels = inImg.numcomps;
-    const int outChannels = outImg.channels();
-
-    if (outChannels == 1) {
-        copyToMat(ImageComponents { inImg.comps[0].data }, outImg, shift);
-        return true;
-    }
-
-    if (outChannels == 3 && inChannels >= 3) {
-        copyToMat(ImageComponents { inImg.comps[0].data, inImg.comps[1].data, inImg.comps[2].data },
-                  outImg, shift);
-        cvtColor(outImg, outImg, COLOR_YUV2BGR);
-        return true;
-    }
-
-    CV_LOG_ERROR(NULL,
-                 cv::format("OpenJPEG2000: unsupported conversion from %d components to %d for YUV image decoding",
-                            inChannels, outChannels));
-    return false;
-}
-
-OPJ_SIZE_T opjReadFromBuffer(void* dist, OPJ_SIZE_T count, detail::OpjMemoryBuffer* buffer)
-{
-    const OPJ_SIZE_T bytesToRead = std::min(buffer->availableBytes(), count);
-    if (bytesToRead > 0)
-    {
-        memcpy(dist, buffer->pos, bytesToRead);
-        buffer->pos += bytesToRead;
-        return bytesToRead;
-    }
-    else
-    {
-        return static_cast<OPJ_SIZE_T>(-1);
-    }
-}
-
-OPJ_SIZE_T opjSkipFromBuffer(OPJ_SIZE_T count, detail::OpjMemoryBuffer* buffer) {
-    const OPJ_SIZE_T bytesToSkip = std::min(buffer->availableBytes(), count);
-    if (bytesToSkip > 0)
-    {
-        buffer->pos += bytesToSkip;
-        return bytesToSkip;
-    }
-    else
-    {
-        return static_cast<OPJ_SIZE_T>(-1);
-    }
-}
-
-OPJ_BOOL opjSeekFromBuffer(OPJ_OFF_T count, detail::OpjMemoryBuffer* buffer)
-{
-    // Count should stay positive to prevent unsigned overflow
-    CV_DbgAssert(count > 0);
-    // To provide proper comparison between OPJ_OFF_T and OPJ_SIZE_T, both should be
-    // casted to uint64_t (On 32-bit systems sizeof(size_t) might be 4)
-    CV_DbgAssert(static_cast<uint64_t>(count) < static_cast<uint64_t>(std::numeric_limits<OPJ_SIZE_T>::max()));
-    const OPJ_SIZE_T pos = std::min(buffer->length, static_cast<OPJ_SIZE_T>(count));
-    buffer->pos = buffer->begin + pos;
-    return OPJ_TRUE;
-}
-
-detail::StreamPtr opjCreateBufferInputStream(detail::OpjMemoryBuffer* buf)
-{
-    detail::StreamPtr stream{ opj_stream_default_create(/* isInput */ true) };
-    if (stream)
-    {
-        opj_stream_set_user_data(stream.get(), static_cast<void*>(buf), nullptr);
-        opj_stream_set_user_data_length(stream.get(), buf->length);
-
-        opj_stream_set_read_function(stream.get(), (opj_stream_read_fn)(opjReadFromBuffer));
-        opj_stream_set_skip_function(stream.get(), (opj_stream_skip_fn)(opjSkipFromBuffer));
-        opj_stream_set_seek_function(stream.get(), (opj_stream_seek_fn)(opjSeekFromBuffer));
-    }
-    return stream;
-}
-
-} // namespace <anonymous>
-
-/////////////////////// Jpeg2KOpjDecoder ///////////////////
-
-Jpeg2KOpjDecoder::Jpeg2KOpjDecoder()
-{
-    static const unsigned char signature[] = { 0, 0, 0, 0x0c, 'j', 'P', ' ', ' ', 13, 10, 0x87, 10 };
-    m_signature = String((const char*)(signature), sizeof(signature));
-    m_buf_supported = true;
-}
-
-
-ImageDecoder Jpeg2KOpjDecoder::newDecoder() const
-{
-    return makePtr<Jpeg2KOpjDecoder>();
-}
-
-bool Jpeg2KOpjDecoder::readHeader()
-{
-    if (!m_buf.empty()) {
-        opjBuf_ = detail::OpjMemoryBuffer(m_buf);
-        stream_ = opjCreateBufferInputStream(&opjBuf_);
-    }
-    else
-    {
-        stream_.reset(opj_stream_create_default_file_stream(m_filename.c_str(), OPJ_STREAM_READ));
-    }
-    if (!stream_)
-        return false;
-
-    codec_.reset(opj_create_decompress(OPJ_CODEC_JP2));
-    if (!codec_)
-        return false;
-
-    // Callbacks are cleared, when opj_destroy_codec is called,
-    // They can provide some additional information for the user, about what goes wrong
-    setupLogCallbacks(codec_.get());
-
-    opj_dparameters parameters = setupDecoderParameters();
-    if (!opj_setup_decoder(codec_.get(), &parameters))
-        return false;
-
-    {
-        opj_image_t* rawImage;
-        if (!opj_read_header(stream_.get(), codec_.get(), &rawImage))
-            return false;
-
-        image_.reset(rawImage);
-    }
-
-    m_width = image_->x1 - image_->x0;
-    m_height = image_->y1 - image_->y0;
-
-    /* Different components may have different precision,
-     * so check all.
-     */
-    bool hasAlpha = false;
-    const int numcomps = image_->numcomps;
-    CV_Assert(numcomps >= 1);
-    for (int i = 0; i < numcomps; i++)
-    {
-        const opj_image_comp_t& comp = image_->comps[i];
-
-        if (comp.sgnd)
-        {
-            CV_Error(Error::StsNotImplemented, cv::format("OpenJPEG2000: Component %d/%d is signed", i, numcomps));
-        }
-
-        if (hasAlpha && comp.alpha)
-        {
-            CV_Error(Error::StsNotImplemented, cv::format("OpenJPEG2000: Component %d/%d is duplicate alpha channel", i, numcomps));
-        }
-
-        hasAlpha |= comp.alpha;
-
-        m_maxPrec = std::max(m_maxPrec, comp.prec);
-    }
-
-    if (m_maxPrec < 8) {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Precision < 8 not supported");
-    } else if (m_maxPrec == 8) {
-        m_type = CV_MAKETYPE(CV_8U, numcomps);
-    } else if (m_maxPrec <= 16) {
-        m_type = CV_MAKETYPE(CV_16U, numcomps);
-    } else if (m_maxPrec <= 23) {
-        m_type = CV_MAKETYPE(CV_32F, numcomps);
-    } else {
-        m_type = CV_MAKETYPE(CV_64F, numcomps);
-    }
-    return true;
-}
-
-bool Jpeg2KOpjDecoder::readData( Mat& img )
-{
-    using DecodeFunc = bool(*)(const opj_image_t&, cv::Mat&, uint8_t shift);
-
-    if (!opj_decode(codec_.get(), stream_.get(), image_.get()))
-    {
-        CV_Error(Error::StsError, "OpenJPEG2000: Decoding is failed");
-    }
-
-    if (img.channels() == 2)
-    {
-        CV_Error(Error::StsNotImplemented,
-                 cv::format("OpenJPEG2000: Unsupported number of output channels. IN: %d OUT: 2", image_->numcomps));
-    }
-
-    DecodeFunc decode = nullptr;
-    switch (image_->color_space)
-    {
-    case OPJ_CLRSPC_UNKNOWN:
-        CV_LOG_WARNING(NULL, "OpenJPEG2000: Image has unknown color space, SRGB is assumed");
-        /* FALLTHRU */
-    case OPJ_CLRSPC_SRGB:
-        decode = decodeSRGBData;
-        break;
-    case OPJ_CLRSPC_GRAY:
-        decode = decodeGrayscaleData;
-        break;
-    case OPJ_CLRSPC_SYCC:
-        decode = decodeSYCCData;
-        break;
-    case OPJ_CLRSPC_UNSPECIFIED:
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Image has unspecified color space");
-    default:
-        CV_Error(Error::StsNotImplemented,
-                 cv::format("OpenJPEG2000: Unsupported color space conversion: %s -> %s",
-                            colorspaceName(image_->color_space).c_str(),
-                            (img.channels() == 1) ? "gray" : "BGR"));
-    }
-
-    const int depth = img.depth();
-    const OPJ_UINT32 outPrec = [depth]() {
-        if (depth == CV_8U) return 8;
-        if (depth == CV_16U) return 16;
-        CV_Error(Error::StsNotImplemented,
-                 cv::format("OpenJPEG2000: output precision > 16 not supported: target depth %d", depth));
-    }();
-    const uint8_t shift = outPrec > m_maxPrec ? 0 : m_maxPrec - outPrec;
-    return decode(*image_, img, shift);
-}
-
-
-/////////////////////// Jpeg2KOpjEncoder ///////////////////
-
-Jpeg2KOpjEncoder::Jpeg2KOpjEncoder()
-{
-    m_description = "JPEG-2000 files (*.jp2)";
-}
-
-ImageEncoder Jpeg2KOpjEncoder::newEncoder() const
-{
-    return makePtr<Jpeg2KOpjEncoder>();
-}
-
-bool Jpeg2KOpjEncoder::isFormatSupported(int depth) const
-{
-    return depth == CV_8U || depth == CV_16U;
-}
-
-bool Jpeg2KOpjEncoder::write(const Mat& img, const std::vector<int>& params)
-{
-    CV_Assert(params.size() % 2 == 0);
-
-    const int channels = img.channels();
-    CV_DbgAssert(channels > 0); // passed matrix is not empty
-    if (channels > 4)
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: only BGR(a) and gray (+ alpha) images supported");
-    }
-
-    const int depth = img.depth();
-
-    const OPJ_UINT32 outPrec = [depth]() {
-        if (depth == CV_8U) return 8;
-        if (depth == CV_16U) return 16;
-        CV_Error(Error::StsNotImplemented,
-                 cv::format("OpenJPEG2000: image precision > 16 not supported. Got: %d", depth));
-    }();
-
-    opj_cparameters parameters = setupEncoderParameters(params);
-
-    std::vector<opj_image_cmptparm_t> compparams(channels);
-    for (int i = 0; i < channels; i++) {
-        compparams[i].prec = outPrec;
-        compparams[i].bpp = outPrec;
-        compparams[i].sgnd = 0; // unsigned for now
-        compparams[i].dx = parameters.subsampling_dx;
-        compparams[i].dy = parameters.subsampling_dy;
-        compparams[i].w = img.size().width;
-        compparams[i].h = img.size().height;
-    }
-
-
-    auto colorspace = (channels > 2) ? OPJ_CLRSPC_SRGB : OPJ_CLRSPC_GRAY;
-    detail::ImagePtr image(opj_image_create(channels, compparams.data(), colorspace));
-    if (!image)
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: can not create image");
-    }
-
-    if (channels == 2 || channels == 4)
-    {
-        image->comps[channels - 1].alpha = 1;
-    }
-    // we want the full image
-    image->x0 = 0;
-    image->y0 = 0;
-    image->x1 = compparams[0].dx * compparams[0].w;
-    image->y1 = compparams[0].dy * compparams[0].h;
-
-    // fill the component data arrays
-    std::vector<OPJ_INT32*> outcomps(channels, nullptr);
-    if (channels == 1)
-    {
-        outcomps.assign({ image->comps[0].data });
-    }
-    else if (channels == 2)
-    {
-        outcomps.assign({ image->comps[0].data, image->comps[1].data });
-    }
-    // Reversed order for BGR -> RGB conversion
-    else if (channels == 3)
-    {
-        outcomps.assign({ image->comps[2].data, image->comps[1].data, image->comps[0].data });
-    }
-    else if (channels == 4)
-    {
-        outcomps.assign({ image->comps[2].data, image->comps[1].data, image->comps[0].data,
-                          image->comps[3].data });
-    }
-    // outcomps holds pointers to the data, so the actual data will be modified but won't be freed
-    // The container is not needed after data was copied
-    copyFromMat(img, std::move(outcomps));
-
-    detail::CodecPtr codec(opj_create_compress(OPJ_CODEC_JP2));
-    if (!codec) {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: can not create compression codec");
-    }
-
-    setupLogCallbacks(codec.get());
-
-    if (!opj_setup_encoder(codec.get(), &parameters, image.get()))
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Can not setup encoder");
-    }
-
-    detail::StreamPtr stream(opj_stream_create_default_file_stream(m_filename.c_str(), OPJ_STREAM_WRITE));
-    if (!stream)
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Can not create stream");
-    }
-
-    if (!opj_start_compress(codec.get(), image.get(), stream.get()))
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Can not start compression");
-    }
-
-    if (!opj_encode(codec.get(), stream.get()))
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Encoding failed");
-    }
-
-    if (!opj_end_compress(codec.get(), stream.get()))
-    {
-        CV_Error(Error::StsNotImplemented, "OpenJPEG2000: Can not end compression");
-    }
-
-    return true;
-}
-
-
-} // namespace cv
-
-#endif

modules/imgcodecs/src/grfmt_jpeg2000_openjpeg.hpp

@@ -1,99 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level directory
-// of this distribution and at http://opencv.org/license.html.
-//
-// Copyright (C) 2020, Stefan Brüns <stefan.bruens@rwth-aachen.de>
-
-#ifndef _GRFMT_OPENJPEG_H_
-#define _GRFMT_OPENJPEG_H_
-
-#ifdef HAVE_OPENJPEG
-
-#include "grfmt_base.hpp"
-#include <openjpeg.h>
-
-namespace cv {
-namespace detail {
-struct OpjStreamDeleter
-{
-    void operator()(opj_stream_t* stream) const
-    {
-        opj_stream_destroy(stream);
-    }
-};
-
-struct OpjCodecDeleter
-{
-    void operator()(opj_codec_t* codec) const
-    {
-        opj_destroy_codec(codec);
-    }
-};
-
-struct OpjImageDeleter
-{
-    void operator()(opj_image_t* image) const
-    {
-        opj_image_destroy(image);
-    }
-};
-
-struct OpjMemoryBuffer {
-    OPJ_BYTE* pos{nullptr};
-    OPJ_BYTE* begin{nullptr};
-    OPJ_SIZE_T length{0};
-
-    OpjMemoryBuffer() = default;
-
-    explicit OpjMemoryBuffer(cv::Mat& mat)
-        : pos{ mat.ptr() }, begin{ mat.ptr() }, length{ mat.rows * mat.cols * mat.elemSize() }
-    {
-    }
-
-    OPJ_SIZE_T availableBytes() const CV_NOEXCEPT {
-        return begin + length - pos;
-    }
-};
-
-using StreamPtr = std::unique_ptr<opj_stream_t, detail::OpjStreamDeleter>;
-using CodecPtr = std::unique_ptr<opj_codec_t, detail::OpjCodecDeleter>;
-using ImagePtr = std::unique_ptr<opj_image_t, detail::OpjImageDeleter>;
-
-} // namespace detail
-
-class Jpeg2KOpjDecoder CV_FINAL : public BaseImageDecoder
-{
-public:
-    Jpeg2KOpjDecoder();
-     ~Jpeg2KOpjDecoder() CV_OVERRIDE = default;
-
-    ImageDecoder newDecoder() const CV_OVERRIDE;
-    bool readData( Mat& img ) CV_OVERRIDE;
-    bool readHeader() CV_OVERRIDE;
-
-private:
-    detail::StreamPtr stream_{nullptr};
-    detail::CodecPtr codec_{nullptr};
-    detail::ImagePtr image_{nullptr};
-
-    detail::OpjMemoryBuffer opjBuf_;
-
-    OPJ_UINT32 m_maxPrec = 0;
-};
-
-class Jpeg2KOpjEncoder CV_FINAL : public BaseImageEncoder
-{
-public:
-    Jpeg2KOpjEncoder();
-    ~Jpeg2KOpjEncoder() CV_OVERRIDE = default;
-
-    bool isFormatSupported( int depth ) const CV_OVERRIDE;
-    bool write( const Mat& img, const std::vector<int>& params ) CV_OVERRIDE;
-    ImageEncoder newEncoder() const CV_OVERRIDE;
-};
-
-} //namespace cv
-
-#endif
-
-#endif/*_GRFMT_OPENJPEG_H_*/

modules/imgcodecs/src/grfmts.hpp

@@ -51,7 +51,6 @@
 #include "grfmt_tiff.hpp"
 #include "grfmt_png.hpp"
 #include "grfmt_jpeg2000.hpp"
-#include "grfmt_jpeg2000_openjpeg.hpp"
 #include "grfmt_exr.hpp"
 #include "grfmt_webp.hpp"
 #include "grfmt_hdr.hpp"

modules/imgcodecs/src/loadsave.cpp

@@ -178,10 +178,6 @@ struct ImageCodecInitializer
         decoders.push_back( makePtr<Jpeg2KDecoder>() );
         encoders.push_back( makePtr<Jpeg2KEncoder>() );
     #endif
-    #ifdef HAVE_OPENJPEG
-        decoders.push_back( makePtr<Jpeg2KOpjDecoder>() );
-        encoders.push_back( makePtr<Jpeg2KOpjEncoder>() );
-    #endif
     #ifdef HAVE_OPENEXR
         decoders.push_back( makePtr<ExrDecoder>() );
         encoders.push_back( makePtr<ExrEncoder>() );

modules/imgcodecs/test/test_common.cpp

@@ -1,51 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level directory
-// of this distribution and at http://opencv.org/license.html
-#include "test_precomp.hpp"
-#include "test_common.hpp"
-
-namespace opencv_test {
-
-static
-Mat generateTestImageBGR_()
-{
-    Size sz(640, 480);
-    Mat result(sz, CV_8UC3, Scalar::all(0));
-
-    const string fname = cvtest::findDataFile("../cv/shared/baboon.png");
-    Mat image = imread(fname, IMREAD_COLOR);
-    CV_Assert(!image.empty());
-    CV_CheckEQ(image.size(), Size(512, 512), "");
-    Rect roi((640-512) / 2, 0, 512, 480);
-    image(Rect(0, 0, 512, 480)).copyTo(result(roi));
-    result(Rect(0,  0, 5, 5)).setTo(Scalar(0, 0, 255));  // R
-    result(Rect(5,  0, 5, 5)).setTo(Scalar(0, 255, 0));  // G
-    result(Rect(10, 0, 5, 5)).setTo(Scalar(255, 0, 0));  // B
-    result(Rect(0,  5, 5, 5)).setTo(Scalar(128, 128, 128));  // gray
-    //imshow("test_image", result); waitKey();
-    return result;
-}
-Mat generateTestImageBGR()
-{
-    static Mat image = generateTestImageBGR_();  // initialize once
-    CV_Assert(!image.empty());
-    return image;
-}
-
-static
-Mat generateTestImageGrayscale_()
-{
-    Mat imageBGR = generateTestImageBGR();
-    CV_Assert(!imageBGR.empty());
-
-    Mat result;
-    cvtColor(imageBGR, result, COLOR_BGR2GRAY);
-    return result;
-}
-Mat generateTestImageGrayscale()
-{
-    static Mat image = generateTestImageGrayscale_();  // initialize once
-    return image;
-}
-
-}  // namespace

modules/imgcodecs/test/test_common.hpp

@@ -1,15 +0,0 @@
-// This file is part of OpenCV project.
-// It is subject to the license terms in the LICENSE file found in the top-level directory
-// of this distribution and at http://opencv.org/license.html
-
-#ifndef OPENCV_TEST_IMGCODECS_COMMON_HPP
-#define OPENCV_TEST_IMGCODECS_COMMON_HPP
-
-namespace opencv_test {
-
-Mat generateTestImageBGR();
-Mat generateTestImageGrayscale();
-
-}  // namespace
-
-#endif  // OPENCV_TEST_IMGCODECS_COMMON_HPP

modules/imgcodecs/test/test_grfmt.cpp

@@ -71,8 +71,7 @@ TEST_P(Imgcodecs_FileMode, regression)
 
 const string all_images[] =
 {
-#if (defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)) \
-    || defined(HAVE_OPENJPEG)
+#if defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)
     "readwrite/Rome.jp2",
     "readwrite/Bretagne2.jp2",
     "readwrite/Bretagne2.jp2",

modules/imgcodecs/test/test_read_write.cpp

@@ -2,7 +2,6 @@
 // It is subject to the license terms in the LICENSE file found in the top-level directory
 // of this distribution and at http://opencv.org/license.html
 #include "test_precomp.hpp"
-#include "test_common.hpp"
 
 namespace opencv_test { namespace {
 
@@ -146,6 +145,45 @@ TEST(Imgcodecs_Image, read_write_bmp)
 typedef string Ext;
 typedef testing::TestWithParam<Ext> Imgcodecs_Image;
 
+TEST_P(Imgcodecs_Image, read_write)
+{
+    const string ext = this->GetParam();
+    const string full_name = cv::tempfile(ext.c_str());
+    const string _name = TS::ptr()->get_data_path() + "../cv/shared/baboon.png";
+    const double thresDbell = 32;
+
+    Mat image = imread(_name);
+    image.convertTo(image, CV_8UC3);
+    ASSERT_FALSE(image.empty());
+
+    imwrite(full_name, image);
+    Mat loaded = imread(full_name);
+    ASSERT_FALSE(loaded.empty());
+
+    double psnr = cvtest::PSNR(loaded, image);
+    EXPECT_GT(psnr, thresDbell);
+
+    vector<uchar> from_file;
+    FILE *f = fopen(full_name.c_str(), "rb");
+    fseek(f, 0, SEEK_END);
+    long len = ftell(f);
+    from_file.resize((size_t)len);
+    fseek(f, 0, SEEK_SET);
+    from_file.resize(fread(&from_file[0], 1, from_file.size(), f));
+    fclose(f);
+    vector<uchar> buf;
+    imencode("." + ext, image, buf);
+    ASSERT_EQ(buf, from_file);
+
+    Mat buf_loaded = imdecode(Mat(buf), 1);
+    ASSERT_FALSE(buf_loaded.empty());
+
+    psnr = cvtest::PSNR(buf_loaded, image);
+    EXPECT_GT(psnr, thresDbell);
+
+    EXPECT_EQ(0, remove(full_name.c_str()));
+}
+
 const string exts[] = {
 #ifdef HAVE_PNG
     "png",
@@ -156,8 +194,7 @@ const string exts[] = {
 #ifdef HAVE_JPEG
     "jpg",
 #endif
-#if (defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)) \
-    || defined(HAVE_OPENJPEG)
+#if defined(HAVE_JASPER) && defined(OPENCV_IMGCODECS_ENABLE_JASPER_TESTS)
     "jp2",
 #endif
 #if 0 /*defined HAVE_OPENEXR && !defined __APPLE__*/
@@ -172,98 +209,6 @@ const string exts[] = {
 #endif
 };
 
-static
-void test_image_io(const Mat& image, const std::string& fname, const std::string& ext, int imreadFlag, double psnrThreshold)
-{
-    vector<uchar> buf;
-    ASSERT_NO_THROW(imencode("." + ext, image, buf));
-
-    ASSERT_NO_THROW(imwrite(fname, image));
-
-    FILE *f = fopen(fname.c_str(), "rb");
-    fseek(f, 0, SEEK_END);
-    long len = ftell(f);
-    cout << "File size: " << len << " bytes" << endl;
-    EXPECT_GT(len, 1024) << "File is small. Test or implementation is broken";
-    fseek(f, 0, SEEK_SET);
-    vector<uchar> file_buf((size_t)len);
-    EXPECT_EQ(len, (long)fread(&file_buf[0], 1, (size_t)len, f));
-    fclose(f); f = NULL;
-
-    EXPECT_EQ(buf, file_buf) << "imwrite() / imencode() calls must provide the same output (bit-exact)";
-
-    Mat buf_loaded = imdecode(Mat(buf), imreadFlag);
-    EXPECT_FALSE(buf_loaded.empty());
-
-    Mat loaded = imread(fname, imreadFlag);
-    EXPECT_FALSE(loaded.empty());
-
-    EXPECT_EQ(0, cv::norm(loaded, buf_loaded, NORM_INF)) << "imread() and imdecode() calls must provide the same result (bit-exact)";
-
-    double psnr = cvtest::PSNR(loaded, image);
-    EXPECT_GT(psnr, psnrThreshold);
-
-    // not necessary due bitexact check above
-    //double buf_psnr = cvtest::PSNR(buf_loaded, image);
-    //EXPECT_GT(buf_psnr, psnrThreshold);
-
-#if 0  // debug
-    if (psnr <= psnrThreshold /*|| buf_psnr <= thresDbell*/)
-    {
-        cout << "File: " << fname << endl;
-        imshow("origin", image);
-        imshow("imread", loaded);
-        imshow("imdecode", buf_loaded);
-        waitKey();
-    }
-#endif
-}
-
-TEST_P(Imgcodecs_Image, read_write_BGR)
-{
-    const string ext = this->GetParam();
-    const string fname = cv::tempfile(ext.c_str());
-
-    double psnrThreshold = 100;
-    if (ext == "jpg")
-        psnrThreshold = 32;
-#ifdef HAVE_JASPER
-    if (ext == "jp2")
-        psnrThreshold = 95;
-#endif
-
-    Mat image = generateTestImageBGR();
-    EXPECT_NO_THROW(test_image_io(image, fname, ext, IMREAD_COLOR, psnrThreshold));
-
-    EXPECT_EQ(0, remove(fname.c_str()));
-}
-
-TEST_P(Imgcodecs_Image, read_write_GRAYSCALE)
-{
-    const string ext = this->GetParam();
-
-    if (false
-        || ext == "ppm"  // grayscale is not implemented
-        || ext == "ras"  // broken (black result)
-    )
-        throw SkipTestException("GRAYSCALE mode is not supported");
-
-    const string fname = cv::tempfile(ext.c_str());
-
-    double psnrThreshold = 100;
-    if (ext == "jpg")
-        psnrThreshold = 40;
-#ifdef HAVE_JASPER
-    if (ext == "jp2")
-        psnrThreshold = 70;
-#endif
-
-    Mat image = generateTestImageGrayscale();
-    EXPECT_NO_THROW(test_image_io(image, fname, ext, IMREAD_GRAYSCALE, psnrThreshold));
-
-    EXPECT_EQ(0, remove(fname.c_str()));
-}
-
 INSTANTIATE_TEST_CASE_P(imgcodecs, Imgcodecs_Image, testing::ValuesIn(exts));
 
 TEST(Imgcodecs_Image, regression_9376)

modules/imgproc/src/resize.avx2.cpp

@@ -59,8 +59,8 @@ class resizeNNInvokerAVX4 CV_FINAL :
     public ParallelLoopBody
 {
 public:
-    resizeNNInvokerAVX4(const Mat& _src, Mat &_dst, int *_x_ofs, double _ify) :
-        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs),
+    resizeNNInvokerAVX4(const Mat& _src, Mat &_dst, int *_x_ofs, int _pix_size4, double _ify) :
+        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs), pix_size4(_pix_size4),
         ify(_ify)
     {
     }
@@ -129,9 +129,9 @@ public:
     }
 
 private:
-    const Mat& src;
-    Mat& dst;
-    int* x_ofs;
+    const Mat src;
+    Mat dst;
+    int* x_ofs, pix_size4;
     double ify;
 
     resizeNNInvokerAVX4(const resizeNNInvokerAVX4&);
@@ -142,8 +142,8 @@ class resizeNNInvokerAVX2 CV_FINAL :
     public ParallelLoopBody
 {
 public:
-    resizeNNInvokerAVX2(const Mat& _src, Mat &_dst, int *_x_ofs, double _ify) :
-        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs),
+    resizeNNInvokerAVX2(const Mat& _src, Mat &_dst, int *_x_ofs, int _pix_size4, double _ify) :
+        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs), pix_size4(_pix_size4),
         ify(_ify)
     {
     }
@@ -235,24 +235,24 @@ public:
     }
 
 private:
-    const Mat& src;
-    Mat& dst;
-    int* x_ofs;
+    const Mat src;
+    Mat dst;
+    int* x_ofs, pix_size4;
     double ify;
 
     resizeNNInvokerAVX2(const resizeNNInvokerAVX2&);
     resizeNNInvokerAVX2& operator=(const resizeNNInvokerAVX2&);
 };
 
-void resizeNN2_AVX2(const Range& range, const Mat& src, Mat &dst, int *x_ofs, double ify)
+void resizeNN2_AVX2(const Range& range, const Mat& src, Mat &dst, int *x_ofs, int pix_size4, double ify)
 {
-    resizeNNInvokerAVX2 invoker(src, dst, x_ofs, ify);
+    resizeNNInvokerAVX2 invoker(src, dst, x_ofs, pix_size4, ify);
     parallel_for_(range, invoker, dst.total() / (double)(1 << 16));
 }
 
-void resizeNN4_AVX2(const Range& range, const Mat& src, Mat &dst, int *x_ofs, double ify)
+void resizeNN4_AVX2(const Range& range, const Mat& src, Mat &dst, int *x_ofs, int pix_size4, double ify)
 {
-    resizeNNInvokerAVX4 invoker(src, dst, x_ofs, ify);
+    resizeNNInvokerAVX4 invoker(src, dst, x_ofs, pix_size4, ify);
     parallel_for_(range, invoker, dst.total() / (double)(1 << 16));
 }
 

modules/imgproc/src/resize.cpp

@@ -970,8 +970,8 @@ class resizeNNInvoker :
     public ParallelLoopBody
 {
 public:
-    resizeNNInvoker(const Mat& _src, Mat &_dst, int *_x_ofs, double _ify) :
-        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs),
+    resizeNNInvoker(const Mat& _src, Mat &_dst, int *_x_ofs, int _pix_size4, double _ify) :
+        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs), pix_size4(_pix_size4),
         ify(_ify)
     {
     }
@@ -1043,18 +1043,19 @@ public:
             default:
                 for( x = 0; x < dsize.width; x++, D += pix_size )
                 {
-                    const uchar* _tS = S + x_ofs[x];
-                    for (int k = 0; k < pix_size; k++)
-                        D[k] = _tS[k];
+                    const int* _tS = (const int*)(S + x_ofs[x]);
+                    int* _tD = (int*)D;
+                    for( int k = 0; k < pix_size4; k++ )
+                        _tD[k] = _tS[k];
                 }
             }
         }
     }
 
 private:
-    const Mat& src;
-    Mat& dst;
-    int* x_ofs;
+    const Mat src;
+    Mat dst;
+    int* x_ofs, pix_size4;
     double ify;
 
     resizeNNInvoker(const resizeNNInvoker&);
@@ -1068,6 +1069,7 @@ resizeNN( const Mat& src, Mat& dst, double fx, double fy )
     AutoBuffer<int> _x_ofs(dsize.width);
     int* x_ofs = _x_ofs.data();
     int pix_size = (int)src.elemSize();
+    int pix_size4 = (int)(pix_size / sizeof(int));
     double ifx = 1./fx, ify = 1./fy;
     int x;
 
@@ -1082,9 +1084,9 @@ resizeNN( const Mat& src, Mat& dst, double fx, double fy )
     if(CV_CPU_HAS_SUPPORT_AVX2 && ((pix_size == 2) || (pix_size == 4)))
     {
         if(pix_size == 2)
-            opt_AVX2::resizeNN2_AVX2(range, src, dst, x_ofs, ify);
+            opt_AVX2::resizeNN2_AVX2(range, src, dst, x_ofs, pix_size4, ify);
         else
-            opt_AVX2::resizeNN4_AVX2(range, src, dst, x_ofs, ify);
+            opt_AVX2::resizeNN4_AVX2(range, src, dst, x_ofs, pix_size4, ify);
     }
     else
 #endif
@@ -1092,14 +1094,14 @@ resizeNN( const Mat& src, Mat& dst, double fx, double fy )
     if(CV_CPU_HAS_SUPPORT_SSE4_1 && ((pix_size == 2) || (pix_size == 4)))
     {
         if(pix_size == 2)
-            opt_SSE4_1::resizeNN2_SSE4_1(range, src, dst, x_ofs, ify);
+            opt_SSE4_1::resizeNN2_SSE4_1(range, src, dst, x_ofs, pix_size4, ify);
         else
-            opt_SSE4_1::resizeNN4_SSE4_1(range, src, dst, x_ofs, ify);
+            opt_SSE4_1::resizeNN4_SSE4_1(range, src, dst, x_ofs, pix_size4, ify);
     }
     else
 #endif
     {
-        resizeNNInvoker invoker(src, dst, x_ofs, ify);
+        resizeNNInvoker invoker(src, dst, x_ofs, pix_size4, ify);
         parallel_for_(range, invoker, dst.total()/(double)(1<<16));
     }
 }

modules/imgproc/src/resize.hpp

@@ -56,16 +56,16 @@ namespace cv
 namespace opt_AVX2
 {
 #if CV_TRY_AVX2
-void resizeNN2_AVX2(const Range&, const Mat&, Mat&, int*, double);
-void resizeNN4_AVX2(const Range&, const Mat&, Mat&, int*, double);
+void resizeNN2_AVX2(const Range&, const Mat&, Mat&, int*, int, double);
+void resizeNN4_AVX2(const Range&, const Mat&, Mat&, int*, int, double);
 #endif
 }
 
 namespace opt_SSE4_1
 {
 #if CV_TRY_SSE4_1
-void resizeNN2_SSE4_1(const Range&, const Mat&, Mat&, int*, double);
-void resizeNN4_SSE4_1(const Range&, const Mat&, Mat&, int*, double);
+void resizeNN2_SSE4_1(const Range&, const Mat&, Mat&, int*, int, double);
+void resizeNN4_SSE4_1(const Range&, const Mat&, Mat&, int*, int, double);
 
 int VResizeLanczos4Vec_32f16u_SSE41(const float** src, ushort* dst, const float* beta, int width);
 #endif

modules/imgproc/src/resize.sse4_1.cpp

@@ -59,8 +59,8 @@ class resizeNNInvokerSSE2 :
     public ParallelLoopBody
 {
 public:
-    resizeNNInvokerSSE2(const Mat& _src, Mat &_dst, int *_x_ofs, double _ify) :
-        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs),
+    resizeNNInvokerSSE2(const Mat& _src, Mat &_dst, int *_x_ofs, int _pix_size4, double _ify) :
+        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs), pix_size4(_pix_size4),
         ify(_ify)
     {
     }
@@ -110,9 +110,9 @@ public:
     }
 
 private:
-    const Mat& src;
-    Mat& dst;
-    int* x_ofs;
+    const Mat src;
+    Mat dst;
+    int* x_ofs, pix_size4;
     double ify;
 
     resizeNNInvokerSSE2(const resizeNNInvokerSSE2&);
@@ -123,8 +123,8 @@ class resizeNNInvokerSSE4 :
     public ParallelLoopBody
 {
 public:
-    resizeNNInvokerSSE4(const Mat& _src, Mat &_dst, int *_x_ofs, double _ify) :
-        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs),
+    resizeNNInvokerSSE4(const Mat& _src, Mat &_dst, int *_x_ofs, int _pix_size4, double _ify) :
+        ParallelLoopBody(), src(_src), dst(_dst), x_ofs(_x_ofs), pix_size4(_pix_size4),
         ify(_ify)
     {
     }
@@ -165,24 +165,24 @@ public:
     }
 
 private:
-    const Mat& src;
-    Mat& dst;
-    int* x_ofs;
+    const Mat src;
+    Mat dst;
+    int* x_ofs, pix_size4;
     double ify;
 
     resizeNNInvokerSSE4(const resizeNNInvokerSSE4&);
     resizeNNInvokerSSE4& operator=(const resizeNNInvokerSSE4&);
 };
 
-void resizeNN2_SSE4_1(const Range& range, const Mat& src, Mat &dst, int *x_ofs, double ify)
+void resizeNN2_SSE4_1(const Range& range, const Mat& src, Mat &dst, int *x_ofs, int pix_size4, double ify)
 {
-    resizeNNInvokerSSE2 invoker(src, dst, x_ofs, ify);
+    resizeNNInvokerSSE2 invoker(src, dst, x_ofs, pix_size4, ify);
     parallel_for_(range, invoker, dst.total() / (double)(1 << 16));
 }
 
-void resizeNN4_SSE4_1(const Range& range, const Mat& src, Mat &dst, int *x_ofs, double ify)
+void resizeNN4_SSE4_1(const Range& range, const Mat& src, Mat &dst, int *x_ofs, int pix_size4, double ify)
 {
-    resizeNNInvokerSSE4 invoker(src, dst, x_ofs, ify);
+    resizeNNInvokerSSE4 invoker(src, dst, x_ofs, pix_size4, ify);
     parallel_for_(range, invoker, dst.total() / (double)(1 << 16));
 }
 

modules/imgproc/test/test_imgwarp.cpp

@@ -1413,7 +1413,7 @@ TEST(Resize, lanczos4_regression_16192)
     EXPECT_EQ(cvtest::norm(dst, expected, NORM_INF), 0) << dst(Rect(0,0,8,8));
 }
 
-TEST(Resize, nearest_regression_15075)
+TEST(Resize, DISABLED_nearest_regression_15075)  // reverted https://github.com/opencv/opencv/pull/16497
 {
     const int C = 5;
     const int i1 = 5, j1 = 5;

modules/stitching/src/seam_finders.cpp

@@ -778,9 +778,7 @@ void DpSeamFinder::computeCosts(
     {
         for (int x = roi.x; x < roi.br().x+1; ++x)
         {
-            if (x > 0 && x < labels_.cols &&
-                labels_(y, x) == l && labels_(y, x-1) == l
-            )
+            if (labels_(y, x) == l && x > 0 && labels_(y, x-1) == l)
             {
                 float costColor = (diff(image1, y + dy1, x + dx1 - 1, image2, y + dy2, x + dx2) +
                                    diff(image1, y + dy1, x + dx1, image2, y + dy2, x + dx2 - 1)) / 2;
@@ -804,9 +802,7 @@ void DpSeamFinder::computeCosts(
     {
         for (int x = roi.x; x < roi.br().x; ++x)
         {
-            if (y > 0 && y < labels_.rows &&
-                labels_(y, x) == l && labels_(y-1, x) == l
-            )
+            if (labels_(y, x) == l && y > 0 && labels_(y-1, x) == l)
             {
                 float costColor = (diff(image1, y + dy1 - 1, x + dx1, image2, y + dy2, x + dx2) +
                                    diff(image1, y + dy1, x + dx1, image2, y + dy2 - 1, x + dx2)) / 2;

modules/videoio/CMakeLists.txt

@@ -221,6 +221,7 @@ if(WIN32 AND HAVE_FFMPEG_WRAPPER)
   endif()
   install(FILES "${ffmpeg_path}" DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT libs RENAME "${ffmpeg_bare_name_ver}")
   if(INSTALL_CREATE_DISTRIB)
-    install(FILES "${ffmpeg_dir}/opencv_videoio_ffmpeg${FFMPEG_SUFFIX}.dll" DESTINATION "bin/" COMPONENT libs RENAME "opencv_videoio_ffmpeg${OPENCV_DLLVERSION}${FFMPEG_SUFFIX}.dll")
+    install(FILES "${ffmpeg_dir}/opencv_videoio_ffmpeg.dll" DESTINATION "bin/" COMPONENT libs RENAME "opencv_videoio_ffmpeg${OPENCV_DLLVERSION}.dll")
+    install(FILES "${ffmpeg_dir}/opencv_videoio_ffmpeg_64.dll" DESTINATION "bin/" COMPONENT libs RENAME "opencv_videoio_ffmpeg${OPENCV_DLLVERSION}_64.dll")
   endif()
 endif()

modules/videoio/src/cap_msmf.cpp

@@ -585,7 +585,7 @@ public:
     virtual bool isOpened() const CV_OVERRIDE { return isOpen; }
     virtual int getCaptureDomain() CV_OVERRIDE { return CV_CAP_MSMF; }
 protected:
-    bool configureOutput(MediaType newType, cv::uint32_t outFormat);
+    bool configureOutput(MediaType newType, cv::uint32_t outFormat, bool convertToFormat);
     bool setTime(double time, bool rough);
     bool configureHW(bool enable);
 
@@ -772,7 +772,7 @@ bool CvCapture_MSMF::configureHW(bool enable)
 #endif
 }
 
-bool CvCapture_MSMF::configureOutput(MediaType newType, cv::uint32_t outFormat)
+bool CvCapture_MSMF::configureOutput(MediaType newType, cv::uint32_t outFormat, bool convertToFormat)
 {
     FormatStorage formats;
     formats.read(videoFileSource.Get());
@@ -780,7 +780,7 @@ bool CvCapture_MSMF::configureOutput(MediaType newType, cv::uint32_t outFormat)
     dwStreamIndex = bestMatch.first.stream;
     nativeFormat = bestMatch.second;
     MediaType newFormat = nativeFormat;
-    if (convertFormat)
+    if (convertToFormat)
     {
         switch (outFormat)
         {
@@ -840,7 +840,7 @@ bool CvCapture_MSMF::open(int index)
     camid = index;
     readCallback = cb;
     duration = 0;
-    if (configureOutput(MediaType::createDefault(), outputFormat))
+    if (configureOutput(MediaType::createDefault(), outputFormat, convertFormat))
     {
         frameStep = captureFormat.getFrameStep();
     }
@@ -861,7 +861,7 @@ bool CvCapture_MSMF::open(const cv::String& _filename)
     {
         isOpen = true;
         sampleTime = 0;
-        if (configureOutput(MediaType(), outputFormat))
+        if (configureOutput(MediaType(), outputFormat, convertFormat))
         {
             frameStep = captureFormat.getFrameStep();
             filename = _filename;
@@ -1302,45 +1302,44 @@ bool CvCapture_MSMF::setProperty( int property_id, double value )
                 return false;
             }
         case CV_CAP_PROP_FOURCC:
-            return configureOutput(newFormat, (int)cvRound(value));
+            return configureOutput(newFormat, (int)cvRound(value), convertFormat);
         case CV_CAP_PROP_FORMAT:
-            return configureOutput(newFormat, (int)cvRound(value));
+            return configureOutput(newFormat, (int)cvRound(value), convertFormat);
         case CV_CAP_PROP_CONVERT_RGB:
-            convertFormat = (value != 0);
-            return configureOutput(newFormat, outputFormat);
+            return configureOutput(newFormat, outputFormat, value != 0);
         case CV_CAP_PROP_SAR_NUM:
             if (value > 0)
             {
                 newFormat.aspectRatioNum = (UINT32)cvRound(value);
-                return configureOutput(newFormat, outputFormat);
+                return configureOutput(newFormat, outputFormat, convertFormat);
             }
             break;
         case CV_CAP_PROP_SAR_DEN:
             if (value > 0)
             {
                 newFormat.aspectRatioDenom = (UINT32)cvRound(value);
-                return configureOutput(newFormat, outputFormat);
+                return configureOutput(newFormat, outputFormat, convertFormat);
             }
             break;
         case CV_CAP_PROP_FRAME_WIDTH:
             if (value >= 0)
             {
                 newFormat.width = (UINT32)cvRound(value);
-                return configureOutput(newFormat, outputFormat);
+                return configureOutput(newFormat, outputFormat, convertFormat);
             }
             break;
         case CV_CAP_PROP_FRAME_HEIGHT:
             if (value >= 0)
             {
                 newFormat.height = (UINT32)cvRound(value);
-                return configureOutput(newFormat, outputFormat);
+                return configureOutput(newFormat, outputFormat, convertFormat);
             }
             break;
         case CV_CAP_PROP_FPS:
             if (value >= 0)
             {
                 newFormat.setFramerate(value);
-                return configureOutput(newFormat, outputFormat);
+                return configureOutput(newFormat, outputFormat, convertFormat);
             }
             break;
         case CV_CAP_PROP_FRAME_COUNT:
@@ -1570,7 +1569,7 @@ bool CvVideoWriter_MSMF::open( const cv::String& filename, int fourcc,
         SUCCEEDED(mediaTypeOut->SetUINT32(MF_MT_AVG_BITRATE, bitRate)) &&
         SUCCEEDED(mediaTypeOut->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive)) &&
         SUCCEEDED(MFSetAttributeSize(mediaTypeOut.Get(), MF_MT_FRAME_SIZE, videoWidth, videoHeight)) &&
-        SUCCEEDED(MFSetAttributeRatio(mediaTypeOut.Get(), MF_MT_FRAME_RATE, (UINT32)(fps * 1000), 1000)) &&
+        SUCCEEDED(MFSetAttributeRatio(mediaTypeOut.Get(), MF_MT_FRAME_RATE, (UINT32)fps, 1)) &&
         SUCCEEDED(MFSetAttributeRatio(mediaTypeOut.Get(), MF_MT_PIXEL_ASPECT_RATIO, 1, 1)) &&
         // Set the input media type.
         SUCCEEDED(MFCreateMediaType(&mediaTypeIn)) &&
@@ -1579,7 +1578,7 @@ bool CvVideoWriter_MSMF::open( const cv::String& filename, int fourcc,
         SUCCEEDED(mediaTypeIn->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive)) &&
         SUCCEEDED(mediaTypeIn->SetUINT32(MF_MT_DEFAULT_STRIDE, 4 * videoWidth)) && //Assume BGR32 input
         SUCCEEDED(MFSetAttributeSize(mediaTypeIn.Get(), MF_MT_FRAME_SIZE, videoWidth, videoHeight)) &&
-        SUCCEEDED(MFSetAttributeRatio(mediaTypeIn.Get(), MF_MT_FRAME_RATE, (UINT32)(fps * 1000), 1000)) &&
+        SUCCEEDED(MFSetAttributeRatio(mediaTypeIn.Get(), MF_MT_FRAME_RATE, (UINT32)fps, 1)) &&
         SUCCEEDED(MFSetAttributeRatio(mediaTypeIn.Get(), MF_MT_PIXEL_ASPECT_RATIO, 1, 1)) &&
         // Set sink writer parameters
         SUCCEEDED(MFCreateAttributes(&spAttr, 10)) &&
@@ -1600,7 +1599,7 @@ bool CvVideoWriter_MSMF::open( const cv::String& filename, int fourcc,
             {
                 initiated = true;
                 rtStart = 0;
-                MFFrameRateToAverageTimePerFrame((UINT32)(fps * 1000), 1000, &rtDuration);
+                MFFrameRateToAverageTimePerFrame((UINT32)fps, 1, &rtDuration);
                 return true;
             }
         }

platforms/winpack_dldt/.gitattributes

@@ -1 +0,0 @@
-*.patch     text eol=crlf -whitespace

platforms/winpack_dldt/2020.1/20200313-dldt-disable-unused-targets.patch

@@ -1,158 +0,0 @@
-diff --git a/inference-engine/CMakeLists.txt b/inference-engine/CMakeLists.txt
-index d5feedb..1b7aa7e 100644
---- a/inference-engine/CMakeLists.txt
-+++ b/inference-engine/CMakeLists.txt
-@@ -59,11 +59,11 @@ if(ENABLE_TESTS)
-     add_subdirectory(tests)
- endif()
- 
--add_subdirectory(tools)
-+#add_subdirectory(tools)
- 
- # gflags and format_reader targets are kept inside of samples directory and
- # they must be built even if samples build is disabled (required for tests and tools).
--add_subdirectory(samples)
-+#add_subdirectory(samples)
- 
- file(GLOB_RECURSE SAMPLES_SOURCES samples/*.cpp samples/*.hpp samples/*.h)
- add_cpplint_target(sample_cpplint
-@@ -134,7 +134,7 @@ install(DIRECTORY ${ie_python_api_SOURCE_DIR}/sample/
- add_custom_target(ie_dev_targets ALL DEPENDS inference_engine HeteroPlugin)
- 
- # Developer package
--ie_developer_export_targets(format_reader)
-+#ie_developer_export_targets(format_reader)
- 
- if (ENABLE_NGRAPH)
-     ie_developer_export_targets(${NGRAPH_LIBRARIES})
-diff --git a/inference-engine/src/inference_engine/CMakeLists.txt b/inference-engine/src/inference_engine/CMakeLists.txt
-index 54e264c..c0b7495 100644
---- a/inference-engine/src/inference_engine/CMakeLists.txt
-+++ b/inference-engine/src/inference_engine/CMakeLists.txt
-@@ -228,7 +228,7 @@ target_include_directories(${TARGET_NAME}_nn_builder PRIVATE "${CMAKE_CURRENT_SO
- 
- # Static library used for unit tests which are always built
- 
--add_library(${TARGET_NAME}_s STATIC
-+add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
-             $<TARGET_OBJECTS:${TARGET_NAME}_obj>
-             ${NN_BUILDER_LIBRARY_SRC})
- 
-diff --git a/inference-engine/src/mkldnn_plugin/CMakeLists.txt b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
-index cd727fd..2f09b44 100644
---- a/inference-engine/src/mkldnn_plugin/CMakeLists.txt
-+++ b/inference-engine/src/mkldnn_plugin/CMakeLists.txt
-@@ -184,9 +184,9 @@ endif()
- add_library(mkldnn_plugin_layers_no_opt OBJECT ${CROSS_COMPILED_SOURCES})
- set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt)
- 
--add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
--set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
--target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE USE_STATIC_IE)
-+#add_library(mkldnn_plugin_layers_no_opt_s OBJECT ${CROSS_COMPILED_SOURCES})
-+#set_ie_threading_interface_for(mkldnn_plugin_layers_no_opt_s)
-+#target_compile_definitions(mkldnn_plugin_layers_no_opt_s PRIVATE USE_STATIC_IE)
- 
- set(object_libraries mkldnn_plugin_layers_no_opt)
- set(mkldnn_plugin_object_libraries mkldnn_plugin_layers_no_opt_s)
-@@ -220,7 +220,7 @@ if (ENABLE_SSE42)
-     endfunction()
- 
-     mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42)
--    mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
-+    #mkldnn_create_sse42_layers(mkldnn_plugin_layers_sse42_s)
- 
-     list(APPEND object_libraries mkldnn_plugin_layers_sse42)
-     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_sse42_s)
-@@ -259,7 +259,7 @@ if (ENABLE_AVX2)
-     endfunction()
- 
-     mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2)
--    mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
-+    #mkldnn_create_avx2_layers(mkldnn_plugin_layers_avx2_s)
- 
-     list(APPEND object_libraries mkldnn_plugin_layers_avx2)
-     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx2_s)
-@@ -297,7 +297,7 @@ if (ENABLE_AVX512F)
-     endfunction()
- 
-     mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512)
--    mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
-+    #mkldnn_create_avx512f_layers(mkldnn_plugin_layers_avx512_s)
- 
-     list(APPEND object_libraries mkldnn_plugin_layers_avx512)
-     list(APPEND mkldnn_plugin_object_libraries mkldnn_plugin_layers_avx512_s)
-@@ -317,7 +317,7 @@ target_link_libraries(${TARGET_NAME} PRIVATE inference_engine ${INTEL_ITT_LIBS}
- 
- #  add test object library
- 
--add_library(${TARGET_NAME}_obj OBJECT ${SOURCES} ${HEADERS})
-+add_library(${TARGET_NAME}_obj OBJECT EXCLUDE_FROM_ALL ${SOURCES} ${HEADERS})
- 
- target_include_directories(${TARGET_NAME}_obj PRIVATE $<TARGET_PROPERTY:inference_engine_preproc_s,INTERFACE_INCLUDE_DIRECTORIES>)
- 
-diff --git a/inference-engine/src/preprocessing/CMakeLists.txt b/inference-engine/src/preprocessing/CMakeLists.txt
-index 41f14a9..0e1b4f6 100644
---- a/inference-engine/src/preprocessing/CMakeLists.txt
-+++ b/inference-engine/src/preprocessing/CMakeLists.txt
-@@ -81,7 +81,7 @@ endif()
- 
- # Static library used for unit tests which are always built
- 
--add_library(${TARGET_NAME}_s STATIC
-+add_library(${TARGET_NAME}_s STATIC EXCLUDE_FROM_ALL
-             $<TARGET_OBJECTS:${TARGET_NAME}_obj>)
- 
- set_ie_threading_interface_for(${TARGET_NAME}_s)
-diff --git a/inference-engine/src/vpu/common/CMakeLists.txt b/inference-engine/src/vpu/common/CMakeLists.txt
-index 8995390..8413faf 100644
---- a/inference-engine/src/vpu/common/CMakeLists.txt
-+++ b/inference-engine/src/vpu/common/CMakeLists.txt
-@@ -49,7 +49,7 @@ add_common_target("vpu_common_lib" FALSE)
- 
- # Unit tests support for graph transformer
- if(WIN32)
--    add_common_target("vpu_common_lib_test_static" TRUE)
-+    #add_common_target("vpu_common_lib_test_static" TRUE)
- else()
-     add_library("vpu_common_lib_test_static" ALIAS "vpu_common_lib")
- endif()
-diff --git a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
-index e77296e..333f560 100644
---- a/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
-+++ b/inference-engine/src/vpu/graph_transformer/CMakeLists.txt
-@@ -60,7 +60,7 @@ add_graph_transformer_target("vpu_graph_transformer" FALSE)
- 
- # Unit tests support for graph transformer
- if(WIN32)
--    add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
-+    #add_graph_transformer_target("vpu_graph_transformer_test_static" TRUE)
- else()
-     add_library("vpu_graph_transformer_test_static" ALIAS "vpu_graph_transformer")
- endif()
-diff --git a/inference-engine/thirdparty/CMakeLists.txt b/inference-engine/thirdparty/CMakeLists.txt
-index ec22761..8bb3325 100644
---- a/inference-engine/thirdparty/CMakeLists.txt
-+++ b/inference-engine/thirdparty/CMakeLists.txt
-@@ -36,7 +36,7 @@ function(build_with_lto)
-     endif()
- 
-     add_subdirectory(pugixml)
--    add_subdirectory(stb_lib)
-+    #add_subdirectory(stb_lib)
-     add_subdirectory(ade)
-     add_subdirectory(fluid/modules/gapi)
- 
-diff --git a/inference-engine/thirdparty/pugixml/CMakeLists.txt b/inference-engine/thirdparty/pugixml/CMakeLists.txt
-index 8bcb280..5a17fa3 100644
---- a/inference-engine/thirdparty/pugixml/CMakeLists.txt
-+++ b/inference-engine/thirdparty/pugixml/CMakeLists.txt
-@@ -41,7 +41,7 @@ if(BUILD_SHARED_LIBS)
- else()
- 	add_library(pugixml STATIC ${SOURCES})
- 	if (MSVC)
--		add_library(pugixml_mt STATIC ${SOURCES})
-+                #add_library(pugixml_mt STATIC ${SOURCES})
- 		#if (WIN32)
- 		#	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
- 		#	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")

platforms/winpack_dldt/2020.1/20200313-dldt-fix-binaries-location.patch

@@ -1,13 +0,0 @@
-diff --git a/cmake/developer_package.cmake b/cmake/developer_package.cmake
-index e59edb2..e42ac19 100644
---- a/cmake/developer_package.cmake
-+++ b/cmake/developer_package.cmake
-@@ -99,7 +99,7 @@ if(UNIX)
-     SET(LIB_DL ${CMAKE_DL_LIBS})
- endif()
- 
--set(OUTPUT_ROOT ${OpenVINO_MAIN_SOURCE_DIR})
-+set(OUTPUT_ROOT ${CMAKE_BINARY_DIR})
- 
- # Enable postfixes for Debug/Release builds
- set(IE_DEBUG_POSTFIX_WIN "d")

platforms/winpack_dldt/2020.1/20200313-ngraph-disable-tests-examples.patch

@@ -1,25 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 631465f..723153b 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -567,7 +567,7 @@ if (NGRAPH_ONNX_IMPORT_ENABLE)
-     endif()
- endif()
- 
--include(cmake/external_gtest.cmake)
-+#include(cmake/external_gtest.cmake)
- if(NGRAPH_JSON_ENABLE)
-     include(cmake/external_json.cmake)
- endif()
-@@ -623,8 +623,8 @@ endif()
- 
- add_subdirectory(src)
- 
--add_subdirectory(test)
--add_subdirectory(doc/examples)
-+#add_subdirectory(test)
-+#add_subdirectory(doc/examples)
- 
- if (NGRAPH_DOC_BUILD_ENABLE)
-     add_subdirectory(doc)
- 

platforms/winpack_dldt/2020.1/20200318-dldt-pdb.patch

@@ -1,14 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index e48cee5..5823e92 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -12,6 +12,9 @@ endif()
- 
- project(OpenVINO)
- 
-+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
-+set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
-+
- set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
- set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
- 

platforms/winpack_dldt/2020.1/20200319-dldt-fix-msvs2019-v16.5.0.patch

@@ -1,13 +0,0 @@
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 7900b382..b5c53d09 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -24,6 +24,8 @@ include(features)
- # include developer package
- include(developer_package)
- 
-+disable_deprecated_warnings()
-+
- # These options are shared with 3rdparty plugins
- # by means of developer package
- include(check_features)

platforms/winpack_dldt/2020.1/patch.config.py

@@ -1,5 +0,0 @@
-applyPatch('20200313-ngraph-disable-tests-examples.patch', 'ngraph')
-applyPatch('20200313-dldt-disable-unused-targets.patch')
-applyPatch('20200313-dldt-fix-binaries-location.patch')
-applyPatch('20200318-dldt-pdb.patch')
-applyPatch('20200319-dldt-fix-msvs2019-v16.5.0.patch')

platforms/winpack_dldt/2020.1/sysroot.config.py

@@ -1,51 +0,0 @@
-sysroot_bin_dir = prepare_dir(self.sysrootdir / 'bin')
-copytree(self.build_dir / 'install', self.sysrootdir / 'ngraph')
-#rm_one(self.sysrootdir / 'ngraph' / 'lib' / 'ngraph.dll')
-
-build_config = 'Release' if not self.config.build_debug else 'Debug'
-build_bin_dir = self.build_dir / 'bin' / 'intel64' / build_config
-
-def copy_bin(name):
-    global build_bin_dir, sysroot_bin_dir
-    copytree(build_bin_dir / name, sysroot_bin_dir / name)
-
-dll_suffix = 'd' if self.config.build_debug else ''
-def copy_dll(name):
-    global copy_bin, dll_suffix
-    copy_bin(name + dll_suffix + '.dll')
-    copy_bin(name + dll_suffix + '.pdb')
-
-copy_bin('cldnn_global_custom_kernels')
-copy_bin('cache.json')
-copy_dll('clDNNPlugin')
-copy_dll('HeteroPlugin')
-copy_dll('inference_engine')
-copy_dll('inference_engine_nn_builder')
-copy_dll('MKLDNNPlugin')
-copy_dll('myriadPlugin')
-copy_dll('ngraph')
-copy_bin('plugins.xml')
-copytree(self.build_dir / 'bin' / 'intel64' / 'pcie-ma248x.elf', sysroot_bin_dir / 'pcie-ma248x.elf')
-copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2x8x.mvcmd', sysroot_bin_dir / 'usb-ma2x8x.mvcmd')
-copytree(self.build_dir / 'bin' / 'intel64' / 'usb-ma2450.mvcmd', sysroot_bin_dir / 'usb-ma2450.mvcmd')
-
-copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb' / 'bin', sysroot_bin_dir)
-copytree(self.srcdir / 'inference-engine' / 'temp' / 'tbb', self.sysrootdir / 'tbb')
-
-sysroot_ie_dir = prepare_dir(self.sysrootdir / 'deployment_tools' / 'inference_engine')
-sysroot_ie_lib_dir = prepare_dir(sysroot_ie_dir / 'lib' / 'intel64')
-
-copytree(self.srcdir / 'inference-engine' / 'include', sysroot_ie_dir / 'include')
-if not self.config.build_debug:
-    copytree(self.build_dir / 'install' / 'lib' / 'ngraph.lib', sysroot_ie_lib_dir / 'ngraph.lib')
-    copytree(build_bin_dir / 'inference_engine.lib', sysroot_ie_lib_dir / 'inference_engine.lib')
-    copytree(build_bin_dir / 'inference_engine_nn_builder.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builder.lib')
-else:
-    copytree(self.build_dir / 'install' / 'lib' / 'ngraphd.lib', sysroot_ie_lib_dir / 'ngraphd.lib')
-    copytree(build_bin_dir / 'inference_engined.lib', sysroot_ie_lib_dir / 'inference_engined.lib')
-    copytree(build_bin_dir / 'inference_engine_nn_builderd.lib', sysroot_ie_lib_dir / 'inference_engine_nn_builderd.lib')
-
-sysroot_license_dir = prepare_dir(self.sysrootdir / 'etc' / 'licenses')
-copytree(self.srcdir / 'LICENSE', sysroot_license_dir / 'dldt-LICENSE')
-copytree(self.srcdir / 'ngraph/LICENSE', sysroot_license_dir / 'ngraph-LICENSE')
-copytree(self.sysrootdir / 'tbb/LICENSE', sysroot_license_dir / 'tbb-LICENSE')

platforms/winpack_dldt/build_package.py

@@ -1,504 +0,0 @@
-#!/usr/bin/env python
-
-import os, sys
-import argparse
-import glob
-import re
-import shutil
-import subprocess
-import time
-
-import logging as log
-
-if sys.version_info[0] == 2:
-    sys.exit("FATAL: Python 2.x is not supported")
-
-from pathlib import Path
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-
-class Fail(Exception):
-    def __init__(self, text=None):
-        self.t = text
-    def __str__(self):
-        return "ERROR" if self.t is None else self.t
-
-def execute(cmd, cwd=None, shell=False):
-    try:
-        log.debug("Executing: %s" % cmd)
-        log.info('Executing: ' + ' '.join(cmd))
-        if cwd:
-            log.info("    in: %s" % cwd)
-        retcode = subprocess.call(cmd, shell=shell, cwd=str(cwd) if cwd else None)
-        if retcode < 0:
-            raise Fail("Child was terminated by signal: %s" % -retcode)
-        elif retcode > 0:
-            raise Fail("Child returned: %s" % retcode)
-    except OSError as e:
-        raise Fail("Execution failed: %d / %s" % (e.errno, e.strerror))
-
-def check_executable(cmd):
-    try:
-        log.debug("Executing: %s" % cmd)
-        result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
-        if not isinstance(result, str):
-            result = result.decode("utf-8")
-        log.debug("Result: %s" % (result + '\n').split('\n')[0])
-        return True
-    except OSError as e:
-        log.debug('Failed: %s' % e)
-        return False
-
-
-def rm_one(d):
-    d = str(d)  # Python 3.5 may not handle Path
-    d = os.path.abspath(d)
-    if os.path.exists(d):
-        if os.path.isdir(d):
-            log.info("Removing dir: %s", d)
-            shutil.rmtree(d)
-        elif os.path.isfile(d):
-            log.info("Removing file: %s", d)
-            os.remove(d)
-
-
-def prepare_dir(d, clean=False):
-    d = str(d)  # Python 3.5 may not handle Path
-    d = os.path.abspath(d)
-    log.info("Preparing directory: '%s' (clean: %r)", d, clean)
-    if os.path.exists(d):
-        if not os.path.isdir(d):
-            raise Fail("Not a directory: %s" % d)
-        if clean:
-            for item in os.listdir(d):
-                rm_one(os.path.join(d, item))
-    else:
-        os.makedirs(d)
-    return Path(d)
-
-
-def check_dir(d):
-    d = str(d)  # Python 3.5 may not handle Path
-    d = os.path.abspath(d)
-    log.info("Check directory: '%s'", d)
-    if os.path.exists(d):
-        if not os.path.isdir(d):
-            raise Fail("Not a directory: %s" % d)
-    else:
-        raise Fail("The directory is missing: %s" % d)
-    return Path(d)
-
-
-# shutil.copytree fails if dst exists
-def copytree(src, dst, exclude=None):
-    log.debug('copytree(%s, %s)', src, dst)
-    src = str(src)  # Python 3.5 may not handle Path
-    dst = str(dst)  # Python 3.5 may not handle Path
-    if os.path.isfile(src):
-        shutil.copy2(src, dst)
-        return
-    def copy_recurse(subdir):
-        if exclude and subdir in exclude:
-            log.debug('  skip: %s', subdir)
-            return
-        s = os.path.join(src, subdir)
-        d = os.path.join(dst, subdir)
-        if os.path.exists(d) or exclude:
-            if os.path.isfile(s):
-                shutil.copy2(s, d)
-            elif os.path.isdir(s):
-                if not os.path.isdir(d):
-                    os.makedirs(d)
-                for item in os.listdir(s):
-                    copy_recurse(os.path.join(subdir, item))
-            else:
-                assert False, s + " => " + d
-        else:
-            if os.path.isfile(s):
-                shutil.copy2(s, d)
-            elif os.path.isdir(s):
-                shutil.copytree(s, d)
-            else:
-                assert False, s + " => " + d
-    copy_recurse('')
-
-
-def git_checkout(dst, url, branch, revision, clone_extra_args, noFetch=False):
-    assert isinstance(dst, Path)
-    log.info("Git checkout: '%s' (%s @ %s)", dst, url, revision)
-    if noFetch:
-        pass
-    elif not os.path.exists(str(dst / '.git')):
-        execute(cmd=['git', 'clone'] +
-                (['-b', branch] if branch else []) +
-                clone_extra_args + [url, '.'], cwd=dst)
-    else:
-        execute(cmd=['git', 'fetch', 'origin'] + ([branch] if branch else []), cwd=dst)
-    execute(cmd=['git', 'reset', '--hard'], cwd=dst)
-    execute(cmd=['git', 'checkout', '-B', 'winpack_dldt', revision], cwd=dst)
-    execute(cmd=['git', 'clean', '-f', '-d'], cwd=dst)
-    execute(cmd=['git', 'submodule', 'init'], cwd=dst)
-    execute(cmd=['git', 'submodule', 'update', '--force', '--depth=1000'], cwd=dst)
-    log.info("Git checkout: DONE")
-    execute(cmd=['git', 'status'], cwd=dst)
-    execute(cmd=['git', 'log', '--max-count=1', 'HEAD'], cwd=dst)
-
-
-def git_apply_patch(src_dir, patch_file):
-    src_dir = str(src_dir)  # Python 3.5 may not handle Path
-    patch_file = str(patch_file)  # Python 3.5 may not handle Path
-    assert os.path.exists(patch_file), patch_file
-    execute(cmd=['git', 'apply', '--3way', '-v', '--ignore-space-change', str(patch_file)], cwd=src_dir)
-
-
-#===================================================================================================
-
-class BuilderDLDT:
-    def __init__(self, config):
-        self.config = config
-
-        cpath = self.config.dldt_config
-        log.info('DLDT build configration: %s', cpath)
-        if not os.path.exists(cpath):
-            cpath = os.path.join(SCRIPT_DIR, cpath)
-            if not os.path.exists(cpath):
-                raise Fail('Config "%s" is missing' % cpath)
-        self.cpath = Path(cpath)
-
-        clean_src_dir = self.config.clean_dldt
-        if self.config.dldt_src_dir:
-            assert os.path.exists(self.config.dldt_src_dir), self.config.dldt_src_dir
-            dldt_dir_name = 'dldt-custom'
-            self.srcdir = self.config.dldt_src_dir
-            clean_src_dir = False
-        else:
-            assert not self.config.dldt_src_dir
-            self.init_patchset()
-            dldt_dir_name = 'dldt-' + self.config.dldt_src_commit + \
-                    ('/patch-' + self.patch_hashsum if self.patch_hashsum else '')
-            if self.config.build_debug:
-                dldt_dir_name += '-debug'
-            self.srcdir = None  # updated below
-        log.info('DLDT directory: %s', dldt_dir_name)
-        self.outdir = prepare_dir(os.path.join(self.config.build_cache_dir, dldt_dir_name))
-        if self.srcdir is None:
-            self.srcdir = prepare_dir(self.outdir / 'sources', clean=clean_src_dir)
-        self.build_dir = prepare_dir(self.outdir / 'build', clean=self.config.clean_dldt)
-        self.sysrootdir = prepare_dir(self.outdir / 'sysroot', clean=self.config.clean_dldt)
-
-    def init_patchset(self):
-        cpath = self.cpath
-        self.patch_file = str(cpath / 'patch.config.py')  # Python 3.5 may not handle Path
-        with open(self.patch_file, 'r') as f:
-            self.patch_file_contents = f.read()
-
-        patch_hashsum = None
-        try:
-            import hashlib
-            patch_hashsum = hashlib.md5(self.patch_file_contents.encode('utf-8')).hexdigest()
-        except:
-            log.warn("Can't compute hashsum of patches: %s", self.patch_file)
-        self.patch_hashsum = patch_hashsum
-
-
-    def prepare_sources(self):
-        if self.config.dldt_src_dir:
-            log.info('Using DLDT custom repository: %s', self.srcdir)
-            return
-
-        def do_clone(srcdir, noFetch):
-            git_checkout(srcdir, self.config.dldt_src_url, self.config.dldt_src_branch, self.config.dldt_src_commit,
-                    ['-n', '--depth=100', '--recurse-submodules'] +
-                    (self.config.dldt_src_git_clone_extra or []),
-                    noFetch=noFetch
-            )
-
-        if not os.path.exists(str(self.srcdir / '.git')):
-            log.info('DLDT git checkout through "reference" copy.')
-            reference_dir = self.config.dldt_reference_dir
-            if reference_dir is None:
-                reference_dir = prepare_dir(os.path.join(self.config.build_cache_dir, 'dldt-git-reference-repository'))
-                do_clone(reference_dir, False)
-                log.info('DLDT reference git checkout completed. Copying...')
-            else:
-                log.info('Using DLDT reference repository. Copying...')
-            copytree(reference_dir, self.srcdir)
-            do_clone(self.srcdir, True)
-        else:
-            do_clone(self.srcdir, False)
-
-        log.info('DLDT git checkout completed. Patching...')
-
-        def applyPatch(patch_file, subdir = None):
-            if subdir:
-                log.info('Patching "%s": %s' % (subdir, patch_file))
-            else:
-                log.info('Patching: %s' % (patch_file))
-            git_apply_patch(self.srcdir / subdir if subdir else self.srcdir, self.cpath / patch_file)
-
-        exec(compile(self.patch_file_contents, self.patch_file, 'exec'))
-
-        log.info('DLDT patches applied')
-
-
-    def build(self):
-        self.cmake_path = 'cmake'
-        build_config = 'Release' if not self.config.build_debug else 'Debug'
-
-        cmd = [self.cmake_path, '-G', 'Visual Studio 16 2019', '-A', 'x64']
-
-        cmake_vars = dict(
-            CMAKE_BUILD_TYPE=build_config,
-            ENABLE_SAMPLES='OFF',
-            ENABLE_TESTS='OFF',
-            BUILD_TESTS='OFF',
-            ENABLE_OPENCV='OFF',
-            ENABLE_GNA='OFF',
-            NGRAPH_UNIT_TEST_ENABLE='OFF',
-            CMAKE_INSTALL_PREFIX=str(self.build_dir / 'install'),
-        )
-
-        cmd += [ '-D%s=%s' % (k, v) for (k, v) in cmake_vars.items() if v is not None]
-        if self.config.cmake_option_dldt:
-            cmd += self.config.cmake_option_dldt
-
-        cmd.append(str(self.srcdir))
-        execute(cmd, cwd=self.build_dir)
-
-        # build
-        cmd = [self.cmake_path, '--build', '.', '--config', build_config, # '--target', 'install',
-                '--', '/v:n', '/m:2', '/consoleloggerparameters:NoSummary'
-        ]
-        execute(cmd, cwd=self.build_dir)
-
-        # install ngraph only
-        cmd = [self.cmake_path, '-DBUILD_TYPE=' + build_config, '-P', 'cmake_install.cmake']
-        execute(cmd, cwd=self.build_dir / 'ngraph')
-
-        log.info('DLDT build completed')
-
-
-    def make_sysroot(self):
-        cfg_file = str(self.cpath / 'sysroot.config.py')  # Python 3.5 may not handle Path
-        with open(cfg_file, 'r') as f:
-            cfg = f.read()
-        exec(compile(cfg, cfg_file, 'exec'))
-
-        log.info('DLDT sysroot preparation completed')
-
-
-#===================================================================================================
-
-class Builder:
-    def __init__(self, config):
-        self.config = config
-        build_dir_name = 'opencv_build' if not self.config.build_debug else 'opencv_build_debug'
-        self.build_dir = prepare_dir(Path(self.config.output_dir) / build_dir_name, clean=self.config.clean_opencv)
-        self.package_dir = prepare_dir(Path(self.config.output_dir) / 'package/opencv', clean=True)
-        self.install_dir = prepare_dir(self.package_dir / 'build')
-        self.src_dir = check_dir(self.config.opencv_dir)
-
-
-    def build(self, builderDLDT):
-        self.cmake_path = 'cmake'
-        build_config = 'Release' if not self.config.build_debug else 'Debug'
-
-        cmd = [self.cmake_path, '-G', 'Visual Studio 16 2019', '-A', 'x64']
-
-        cmake_vars = dict(
-            CMAKE_BUILD_TYPE=build_config,
-            INSTALL_CREATE_DISTRIB='ON',
-            BUILD_opencv_world='OFF',
-            BUILD_TESTS='OFF',
-            BUILD_PERF_TESTS='OFF',
-            ENABLE_CXX11='ON',
-            WITH_INF_ENGINE='ON',
-            INF_ENGINE_RELEASE=str(self.config.dldt_release),
-            WITH_TBB='ON',
-            CPU_BASELINE='AVX2',
-            CMAKE_INSTALL_PREFIX=str(self.install_dir),
-            INSTALL_PDB='ON',
-            INSTALL_PDB_COMPONENT_EXCLUDE_FROM_ALL='OFF',
-
-            OPENCV_SKIP_CMAKE_ROOT_CONFIG='ON',
-            OPENCV_BIN_INSTALL_PATH='bin',
-            OPENCV_INCLUDE_INSTALL_PATH='include',
-            OPENCV_LIB_INSTALL_PATH='lib',
-            OPENCV_CONFIG_INSTALL_PATH='cmake',
-            OPENCV_3P_LIB_INSTALL_PATH='3rdparty',
-            OPENCV_SAMPLES_SRC_INSTALL_PATH='samples',
-            OPENCV_DOC_INSTALL_PATH='doc',
-            OPENCV_OTHER_INSTALL_PATH='etc',
-            OPENCV_LICENSES_INSTALL_PATH='etc/licenses',
-
-            OPENCV_INSTALL_DATA_DIR_RELATIVE='../../src/opencv',
-
-            BUILD_opencv_python2='OFF',
-            BUILD_opencv_python3='ON',
-            PYTHON3_LIMITED_API='ON',
-            OPENCV_PYTHON_INSTALL_PATH='python',
-        )
-
-        cmake_vars['INF_ENGINE_LIB_DIRS:PATH'] = str(builderDLDT.sysrootdir / 'deployment_tools/inference_engine/lib/intel64')
-        cmake_vars['INF_ENGINE_INCLUDE_DIRS:PATH'] = str(builderDLDT.sysrootdir / 'deployment_tools/inference_engine/include')
-        cmake_vars['ngraph_DIR:PATH'] = str(builderDLDT.sysrootdir / 'ngraph/cmake')
-        cmake_vars['TBB_DIR:PATH'] = str(builderDLDT.sysrootdir / 'tbb/cmake')
-
-        if self.config.build_debug:
-            cmake_vars['CMAKE_BUILD_TYPE'] = 'Debug'
-            cmake_vars['BUILD_opencv_python3'] ='OFF'  # python3x_d.lib is missing
-            cmake_vars['OPENCV_INSTALL_APPS_LIST'] = 'all'
-
-        if self.config.build_tests:
-            cmake_vars['BUILD_TESTS'] = 'ON'
-            cmake_vars['BUILD_PERF_TESTS'] = 'ON'
-            cmake_vars['BUILD_opencv_ts'] = 'ON'
-            cmake_vars['INSTALL_TESTS']='ON'
-
-        if self.config.build_tests_dnn:
-            cmake_vars['BUILD_TESTS'] = 'ON'
-            cmake_vars['BUILD_PERF_TESTS'] = 'ON'
-            cmake_vars['BUILD_opencv_ts'] = 'ON'
-            cmake_vars['OPENCV_BUILD_TEST_MODULES_LIST'] = 'dnn'
-            cmake_vars['OPENCV_BUILD_PERF_TEST_MODULES_LIST'] = 'dnn'
-            cmake_vars['INSTALL_TESTS']='ON'
-
-        cmd += [ "-D%s=%s" % (k, v) for (k, v) in cmake_vars.items() if v is not None]
-        if self.config.cmake_option:
-            cmd += self.config.cmake_option
-
-        cmd.append(str(self.src_dir))
-
-        log.info('Configuring OpenCV...')
-
-        execute(cmd, cwd=self.build_dir)
-
-        log.info('Building OpenCV...')
-
-        # build
-        cmd = [self.cmake_path, '--build', '.', '--config', build_config, '--target', 'install',
-                '--', '/v:n', '/m:2', '/consoleloggerparameters:NoSummary'
-        ]
-        execute(cmd, cwd=self.build_dir)
-
-        log.info('OpenCV build/install completed')
-
-
-    def copy_sysroot(self, builderDLDT):
-        log.info('Copy sysroot files')
-
-        copytree(builderDLDT.sysrootdir / 'bin', self.install_dir / 'bin')
-        copytree(builderDLDT.sysrootdir / 'etc', self.install_dir / 'etc')
-
-        log.info('Copy sysroot files - DONE')
-
-
-    def package_sources(self):
-        package_opencv = prepare_dir(self.package_dir / 'src/opencv', clean=True)
-        package_opencv = str(package_opencv)  # Python 3.5 may not handle Path
-        execute(cmd=['git', 'clone', '-s', str(self.src_dir), '.'], cwd=str(package_opencv))
-        for item in os.listdir(package_opencv):
-            if str(item).startswith('.git'):
-                rm_one(os.path.join(package_opencv, item))
-
-        with open(str(self.package_dir / 'README.md'), 'w') as f:
-            f.write('See licensing/copying statements in "build/etc/licenses"\n')
-            f.write('Wiki page: https://github.com/opencv/opencv/wiki/Intel%27s-Deep-Learning-Inference-Engine-backend\n')
-
-        log.info('Package OpenCV sources - DONE')
-
-
-#===================================================================================================
-
-def main():
-
-    dldt_src_url = 'https://github.com/opencv/dldt.git'
-    dldt_src_commit = '2020.1'
-    dldt_release = '2020010000'
-
-    build_cache_dir_default = os.environ.get('BUILD_CACHE_DIR', '.build_cache')
-
-    parser = argparse.ArgumentParser(
-            description='Build OpenCV Windows package with Inference Engine (DLDT)',
-    )
-    parser.add_argument('output_dir', nargs='?', default='.', help='Output directory')
-    parser.add_argument('opencv_dir', nargs='?', default=os.path.join(SCRIPT_DIR, '../..'), help='Path to OpenCV source dir')
-    parser.add_argument('--build_cache_dir', default=build_cache_dir_default, help='Build cache directory (sources and binaries cache of build dependencies, default = "%s")' % build_cache_dir_default)
-
-    parser.add_argument('--cmake_option', action='append', help='Append OpenCV CMake option')
-    parser.add_argument('--cmake_option_dldt', action='append', help='Append CMake option for DLDT project')
-
-    parser.add_argument('--clean_dldt', action='store_true', help='Clear DLDT build and sysroot directories')
-    parser.add_argument('--clean_opencv', action='store_true', help='Clear OpenCV build directory')
-
-    parser.add_argument('--build_debug', action='store_true', help='Build debug binaries')
-    parser.add_argument('--build_tests', action='store_true', help='Build OpenCV tests')
-    parser.add_argument('--build_tests_dnn', action='store_true', help='Build OpenCV DNN accuracy and performance tests only')
-
-    parser.add_argument('--dldt_src_url', default=dldt_src_url, help='DLDT source URL (tag / commit, default: %s)' % dldt_src_url)
-    parser.add_argument('--dldt_src_branch', help='DLDT checkout branch')
-    parser.add_argument('--dldt_src_commit', default=dldt_src_commit, help='DLDT source commit / tag (default: %s)' % dldt_src_commit)
-    parser.add_argument('--dldt_src_git_clone_extra', action='append', help='DLDT git clone extra args')
-    parser.add_argument('--dldt_release', default=dldt_release, help='DLDT release code for INF_ENGINE_RELEASE (default: %s)' % dldt_release)
-
-    parser.add_argument('--dldt_reference_dir', help='DLDT reference git repository (optional)')
-    parser.add_argument('--dldt_src_dir', help='DLDT custom source repository (skip git checkout and patching, use for TESTING only)')
-
-    parser.add_argument('--dldt_config', help='Specify DLDT build configuration (defaults to DLDT commit)')
-
-    args = parser.parse_args()
-
-    log.basicConfig(
-            format='%(asctime)s %(levelname)-8s %(message)s',
-            level=os.environ.get('LOGLEVEL', 'INFO'),
-            datefmt='%Y-%m-%d %H:%M:%S'
-    )
-    log.debug('Args: %s', args)
-
-    if not check_executable(['git', '--version']):
-        sys.exit("FATAL: 'git' is not available")
-    if not check_executable(['cmake', '--version']):
-        sys.exit("FATAL: 'cmake' is not available")
-
-    if os.path.realpath(args.output_dir) == os.path.realpath(SCRIPT_DIR):
-        raise Fail("Specify output_dir (building from script directory is not supported)")
-    if os.path.realpath(args.output_dir) == os.path.realpath(args.opencv_dir):
-        raise Fail("Specify output_dir (building from OpenCV source directory is not supported)")
-
-    # Relative paths become invalid in sub-directories
-    if args.opencv_dir is not None and not os.path.isabs(args.opencv_dir):
-        args.opencv_dir = os.path.abspath(args.opencv_dir)
-
-    if not args.dldt_config:
-        args.dldt_config = args.dldt_src_commit
-
-    _opencv_dir = check_dir(args.opencv_dir)
-    _outdir = prepare_dir(args.output_dir)
-    _cachedir = prepare_dir(args.build_cache_dir)
-
-    ocv_hooks_dir = os.environ.get('OPENCV_CMAKE_HOOKS_DIR', None)
-    hooks_dir = os.path.join(SCRIPT_DIR, 'cmake-opencv-checks')
-    os.environ['OPENCV_CMAKE_HOOKS_DIR'] = hooks_dir if ocv_hooks_dir is None else (hooks_dir + ';' + ocv_hooks_dir)
-
-    builder_dldt = BuilderDLDT(args)
-
-    builder_dldt.prepare_sources()
-    builder_dldt.build()
-    builder_dldt.make_sysroot()
-
-    builder_opencv = Builder(args)
-    builder_opencv.build(builder_dldt)
-    builder_opencv.copy_sysroot(builder_dldt)
-    builder_opencv.package_sources()
-
-    log.info("=====")
-    log.info("===== Build finished")
-    log.info("=====")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except:
-        log.info('FATAL: Error occured. To investigate problem try to change logging level using LOGLEVEL=DEBUG environment variable.')
-        raise

platforms/winpack_dldt/cmake-opencv-checks/POST_FINALIZE.cmake

@@ -1,17 +0,0 @@
-message(STATUS "Winpack-DLDT: Validating OpenCV build configuration...")
-
-if(NOT INF_ENGINE_TARGET)
-  message(SEND_ERROR "Inference engine must be detected")
-  set(HAS_ERROR 1)
-endif()
-if(NOT HAVE_NGRAPH)
-  message(SEND_ERROR "Inference engine nGraph must be detected")
-  set(HAS_ERROR 1)
-endif()
-
-if(HAS_ERROR)
-  ocv_cmake_dump_vars("^IE_|INF_|INFERENCE|ngraph")
-  message(FATAL_ERROR "Winpack-DLDT: Validating OpenCV build configuration... FAILED")
-endif()
-
-message(STATUS "Winpack-DLDT: Validating OpenCV build configuration... DONE")

platforms/winpack_dldt/package-tests/test_dnn_backends.py

@@ -1,13 +0,0 @@
-import sys
-print(sys.version_info)
-try:
-    import cv2 as cv
-    print(cv.__version__)
-    print(cv.dnn.getAvailableTargets(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE))
-except:
-    print(sys.path)
-    import os
-    print(os.environ.get('PATH', ''))
-    raise
-
-print('OK')

samples/_winpack_build_sample.cmd

@@ -4,24 +4,16 @@
 ::   - > _winpack_build_sample.cmd cpp\opencv_version.cpp
 :: Requires:
 :: - CMake
-:: - MSVS 2015/2017/2019
+:: - MSVS 2015/2017
 :: (tools are searched on default paths or environment should be pre-configured)
 @echo off
 setlocal
 
-SET SCRIPT_DIR=%~dp0
-SET "OPENCV_SETUPVARS_SCRIPT=setup_vars_opencv4.cmd"
-SET "PACKAGE_BUILD_DIR=%SCRIPT_DIR%\..\..\build"
-IF NOT EXIST "%PACKAGE_BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
-  :: Winpack DLDT
-  SET "PACKAGE_BUILD_DIR=%SCRIPT_DIR%\..\..\..\build"
-)
-IF NOT EXIST "%PACKAGE_BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+set SCRIPTDIR=%~dp0
+if NOT exist "%SCRIPTDIR%\..\..\build" (
   set "MSG=OpenCV Winpack installation is required"
   goto die
 )
-:: normalize path
-for %%i in ("%PACKAGE_BUILD_DIR%") do SET "PACKAGE_BUILD_DIR=%%~fi"
 
 if [%1]==[] (
   set "MSG=Sample path is required"
@@ -43,8 +35,8 @@ set "SRC_NAME=%~n1"
 echo SRC_NAME=%SRC_NAME%
 echo ================================================================================
 
-:: Path to root 'bin' dir
-set "PATH=%PACKAGE_BUILD_DIR%\bin;%PATH%"
+:: Path to FFMPEG binary files
+set "PATH=%PATH%;%SCRIPTDIR%\..\..\build\bin\"
 
 :: Detect compiler
 cl /? >NUL 2>NUL <NUL
@@ -110,21 +102,12 @@ if NOT DEFINED VisualStudioVersion (
 if "%VisualStudioVersion%" == "14.0" (
   set "CMAKE_GENERATOR=-G^"Visual Studio 14 Win64^""
   set "BUILD_DIR_SUFFIX=.vc14"
-  if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
-    set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
-  )
+  set "PATH=%PATH%;%SCRIPTDIR%\..\..\build\x64\vc14\bin\"
 ) else (
   if "%VisualStudioVersion%" == "15.0" (
     set "CMAKE_GENERATOR=-G^"Visual Studio 15 Win64^""
     set "BUILD_DIR_SUFFIX=.vc15"
     set "PATH=%PATH%;%SCRIPTDIR%\..\..\build\x64\vc15\bin\"
-    if EXIST "%PACKAGE_BUILD_DIR%\x64\vc15\bin" (
-      set "PATH=%PACKAGE_BUILD_DIR%\x64\vc15\bin;%PATH%"
-    ) else (
-      if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
-        set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
-      )
-    )
   ) else (
     if "%VisualStudioVersion%" == "16.0" (
       echo.==========================================
@@ -132,17 +115,7 @@ if "%VisualStudioVersion%" == "14.0" (
       echo.==========================================
       set "CMAKE_GENERATOR=-G^"Visual Studio 16 2019^" -A x64"
       set "BUILD_DIR_SUFFIX=.vc16"
-      if EXIST "%PACKAGE_BUILD_DIR%\x64\vc16\bin" (
-        set "PATH=%PACKAGE_BUILD_DIR%\x64\vc16\bin;%PATH%"
-      ) else (
-        if EXIST "%PACKAGE_BUILD_DIR%\x64\vc15\bin" (
-          set "PATH=%PACKAGE_BUILD_DIR%\x64\vc15\bin;%PATH%"
-        ) else (
-          if EXIST "%PACKAGE_BUILD_DIR%\x64\vc14\bin" (
-            set "PATH=%PACKAGE_BUILD_DIR%\x64\vc14\bin;%PATH%"
-          )
-        )
-      )
+      set "PATH=%PATH%;%SCRIPTDIR%\..\..\build\x64\vc15\bin\"
     ) else (
       set "MSG=Unsupported MSVS version. VisualStudioVersion=%VisualStudioVersion%"
       goto die
@@ -155,10 +128,10 @@ call :set_title Create build directory
 if NOT exist "%BUILD_DIR%" ( call :execute md "%BUILD_DIR%" )
 PUSHD "%BUILD_DIR%"
 if NOT exist "%BUILD_DIR%/sample" ( call :execute md "%BUILD_DIR%/sample" )
-call :execute copy /Y "%SCRIPT_DIR%/CMakeLists.example.in" "%BUILD_DIR%/sample/CMakeLists.txt"
+call :execute copy /Y "%SCRIPTDIR%/CMakeLists.example.in" "%BUILD_DIR%/sample/CMakeLists.txt"
 
 call :set_title Configuring via CMake
-call :execute cmake %CMAKE_GENERATOR% "%BUILD_DIR%\sample" -DEXAMPLE_NAME=%SRC_NAME% "-DEXAMPLE_FILE=%SRC_FILENAME%"
+call :execute cmake %CMAKE_GENERATOR% "%BUILD_DIR%\sample" -DEXAMPLE_NAME=%SRC_NAME% "-DEXAMPLE_FILE=%SRC_FILENAME%" "-DOpenCV_DIR=%SCRIPTDIR%\..\..\build"
 if %ERRORLEVEL% NEQ 0 (
   set "MSG=CMake configuration step failed: %BUILD_DIR%"
   goto die

samples/_winpack_run_python_sample.cmd

@@ -2,19 +2,11 @@
 SETLOCAL
 
 SET SCRIPT_DIR=%~dp0
-SET "OPENCV_SETUPVARS_SCRIPT=setup_vars_opencv4.cmd"
-SET "BUILD_DIR=%SCRIPT_DIR%\..\..\build"
-IF NOT EXIST "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
-  :: Winpack DLDT
-  SET "BUILD_DIR=%SCRIPT_DIR%\..\..\..\build"
-)
-IF NOT EXIST "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%" (
+IF NOT EXIST "%SCRIPT_DIR%\..\..\build\setup_vars_opencv4.cmd" (
   ECHO ERROR: OpenCV Winpack installation is required
   pause
   exit
 )
-:: normalize path
-for %%i in ("%PACKAGE_BUILD_DIR%") do SET "PACKAGE_BUILD_DIR=%%~fi"
 
 :: Detect Python binary
 python -V 2>nul
@@ -88,11 +80,7 @@ echo SRC_FILENAME=%SRC_FILENAME%
 call :dirname "%SRC_FILENAME%" SRC_DIR
 call :dirname "%PYTHON%" PYTHON_DIR
 PUSHD %SRC_DIR%
-
-CALL "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%"
-:: repair SCRIPT_DIR
-SET "SCRIPT_DIR=%~dp0"
-
+CALL "%SCRIPT_DIR%\..\..\build\setup_vars_opencv4.cmd"
 ECHO Run: %*
 %PYTHON% %*
 SET result=%errorlevel%
@@ -106,23 +94,17 @@ IF %result% NEQ 0 (
     cmd /k echo Current directory: %CD%
   )
 )
-
 POPD
 EXIT /B %result%
 
 :rundemo
 PUSHD "%SCRIPT_DIR%\python"
-
-CALL "%BUILD_DIR%\%OPENCV_SETUPVARS_SCRIPT%"
-:: repair SCRIPT_DIR
-SET "SCRIPT_DIR=%~dp0"
-
+CALL "%SCRIPT_DIR%\..\..\build\setup_vars_opencv4.cmd"
 %PYTHON% demo.py
 SET result=%errorlevel%
 IF %result% NEQ 0 (
   IF NOT DEFINED OPENCV_BATCH_MODE ( pause )
 )
-
 POPD
 EXIT /B %result%
 

samples/python/demo.py

@@ -114,24 +114,12 @@ class App:
     def on_demo_select(self, evt):
         name = self.demos_lb.get( self.demos_lb.curselection()[0] )
         fn = self.samples[name]
-
-        descr = ""
+        loc = {}
         try:
-            if sys.version_info[0] > 2:
-                # Python 3.x
-                module_globals = {}
-                module_locals = {}
-                with open(fn, 'r') as f:
-                    module_code = f.read()
-                exec(compile(module_code, fn, 'exec'), module_globals, module_locals)
-                descr = module_locals.get('__doc__', 'no-description')
-            else:
-                # Python 2
-                module_globals = {}
-                execfile(fn, module_globals)  # noqa: F821
-                descr = module_globals.get('__doc__', 'no-description')
-        except Exception as e:
-            descr = str(e)
+            execfile(fn, loc)           # Python 2
+        except NameError:
+            exec(open(fn).read(), loc)  # Python 3
+        descr = loc.get('__doc__', 'no-description')
 
         self.linker.reset()
         self.text.config(state='normal')