OpenCV version++ (3.4.5)

OpenCV 3.4.5
Merge pull request #13497 from dkurt:dnn_torch_bn_train
2026-07-25 13:23:02 +04:00 · 2018-12-21 17:31:20 +03:00 · 2018-12-21 14:29:10 +00:00 · 2018-12-21 12:18:23 +00:00 · 2018-12-21 12:17:06 +00:00 · 2018-12-21 12:15:59 +00:00
67 changed files with 2864 additions and 2893 deletions
@@ -357,9 +357,12 @@ OCV_OPTION(WITH_LIBV4L "Use libv4l for Video 4 Linux support" OFF
 OCV_OPTION(WITH_DSHOW "Build VideoIO with DirectShow support" ON
  VISIBLE_IF WIN32 AND NOT ARM AND NOT WINRT
  VERIFY HAVE_DSHOW)
-OCV_OPTION(WITH_MSMF "Build VideoIO with Media Foundation support" ON
+OCV_OPTION(WITH_MSMF "Build VideoIO with Media Foundation support" NOT MINGW
  VISIBLE_IF WIN32
  VERIFY HAVE_MSMF)
+OCV_OPTION(WITH_MSMF_DXVA "Enable hardware acceleration in Media Foundation backend" WITH_MSMF
+  VISIBLE_IF WIN32
+  VERIFY HAVE_MSMF_DXVA)
 OCV_OPTION(WITH_XIMEA "Include XIMEA cameras support" OFF
  VISIBLE_IF NOT ANDROID AND NOT WINRT
  VERIFY HAVE_XIMEA)
@@ -605,7 +608,7 @@ else()
    endif()
  endif()
  ocv_update(OPENCV_INCLUDE_INSTALL_PATH "include")
-  ocv_update(OPENCV_PYTHON_INSTALL_PATH  "python")
+  #ocv_update(OPENCV_PYTHON_INSTALL_PATH  "python")  # no default value, see https://github.com/opencv/opencv/issues/13202
 endif()

 ocv_update(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
@@ -1478,6 +1481,7 @@ endif()

 if(WITH_MSMF OR HAVE_MSMF)
  status("    Media Foundation:" HAVE_MSMF    THEN YES                                        ELSE NO)
+  status("      DXVA:"           HAVE_MSMF_DXVA    THEN YES    ELSE NO)
 endif()

 if(WITH_XIMEA OR HAVE_XIMEA)
@@ -1,3 +1,6 @@
+set(OPENCV_JAVA_SOURCE_VERSION "" CACHE STRING "Java source version (javac Ant target)")
+set(OPENCV_JAVA_TARGET_VERSION "" CACHE STRING "Java target version (javac Ant target)")
+
 file(TO_CMAKE_PATH "$ENV{ANT_DIR}" ANT_DIR_ENV_PATH)
 file(TO_CMAKE_PATH "$ENV{ProgramFiles}" ProgramFiles_ENV_PATH)

@@ -52,7 +52,7 @@ if(CUDA_FOUND)

  message(STATUS "CUDA detected: " ${CUDA_VERSION})

-  set(_generations "Fermi" "Kepler" "Maxwell" "Pascal" "Volta")
+  set(_generations "Fermi" "Kepler" "Maxwell" "Pascal" "Volta" "Turing")
  if(NOT CMAKE_CROSSCOMPILING)
    list(APPEND _generations "Auto")
  endif()
@@ -107,7 +107,7 @@ if(CUDA_FOUND)
                       ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
      if(NOT _nvcc_res EQUAL 0)
        message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
-        set(__cuda_arch_bin "5.3 6.2 7.0 7.5")
+        set(__cuda_arch_bin "5.3 6.2 7.2")
      else()
        set(__cuda_arch_bin "${_nvcc_out}")
        string(REPLACE "2.1" "2.1(2.0)" __cuda_arch_bin "${__cuda_arch_bin}")
@@ -78,9 +78,9 @@ endif()

 if(INF_ENGINE_TARGET)
  if(NOT INF_ENGINE_RELEASE)
-    message(WARNING "InferenceEngine version have not been set, 2018R4 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
+    message(WARNING "InferenceEngine version have not been set, 2018R5 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
  endif()
-  set(INF_ENGINE_RELEASE "2018040000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2018R2.0.2 -> 2018020002)")
+  set(INF_ENGINE_RELEASE "2018050000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2018R2.0.2 -> 2018020002)")
  set_target_properties(${INF_ENGINE_TARGET} PROPERTIES
    INTERFACE_COMPILE_DEFINITIONS "HAVE_INF_ENGINE=1;INF_ENGINE_RELEASE=${INF_ENGINE_RELEASE}"
  )
@@ -274,14 +274,15 @@ endif(WITH_DSHOW)
 ocv_clear_vars(HAVE_MSMF)
 if(WITH_MSMF)
  check_include_file(Mfapi.h HAVE_MSMF)
-  check_include_file(D3D11.h D3D11_found)
-  check_include_file(D3d11_4.h D3D11_4_found)
-  if(D3D11_found AND D3D11_4_found)
-    set(HAVE_DXVA YES)
-  else()
-    set(HAVE_DXVA NO)
+  set(HAVE_MSMF_DXVA "")
+  if(WITH_MSMF_DXVA)
+    check_include_file(D3D11.h D3D11_found)
+    check_include_file(D3d11_4.h D3D11_4_found)
+    if(D3D11_found AND D3D11_4_found)
+      set(HAVE_MSMF_DXVA YES)
+    endif()
  endif()
-endif(WITH_MSMF)
+endif()

 # --- Extra HighGUI and VideoIO libs on Windows ---
 if(WIN32)
@@ -43,11 +43,24 @@ else()
 endif()
 file(RELATIVE_PATH OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG
    "${CMAKE_INSTALL_PREFIX}/${OPENCV_SETUPVARS_INSTALL_PATH}/" "${CMAKE_INSTALL_PREFIX}/")
-if(IS_ABSOLUTE "${OPENCV_PYTHON_INSTALL_PATH}")
-  set(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "${OPENCV_PYTHON_INSTALL_PATH}")
-  message(WARNING "CONFIGURATION IS NOT SUPPORTED: validate setupvars script in install directory")
+if(DEFINED OPENCV_PYTHON_INSTALL_PATH)
+  set(__python_path "${OPENCV_PYTHON_INSTALL_PATH}")
+elseif(DEFINED OPENCV_PYTHON_INSTALL_PATH_SETUPVARS)
+  set(__python_path "${OPENCV_PYTHON_INSTALL_PATH_SETUPVARS}")
+endif()
+if(DEFINED __python_path)
+  if(IS_ABSOLUTE "${__python_path}")
+    set(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "${__python_path}")
+    message(WARNING "CONFIGURATION IS NOT SUPPORTED: validate setupvars script in install directory")
+  else()
+    ocv_path_join(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "${OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG}" "${__python_path}")
+  endif()
 else()
-  ocv_path_join(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "${OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG}" "${OPENCV_PYTHON_INSTALL_PATH}")
+  if(DEFINED OPENCV_PYTHON3_INSTALL_PATH)
+    ocv_path_join(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "${OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG}" "${OPENCV_PYTHON3_INSTALL_PATH}")
+  else()
+    set(OPENCV_PYTHON_DIR_RELATIVE_CMAKECONFIG "python_loader_is_not_installed")
+  endif()
 endif()
 configure_file("${OpenCV_SOURCE_DIR}/cmake/templates/${OPENCV_SETUPVARS_TEMPLATE}" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/install/${OPENCV_SETUPVARS_FILENAME}" @ONLY)
 install(FILES "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/install/${OPENCV_SETUPVARS_FILENAME}"
@@ -508,7 +508,7 @@ macro(ocv_warnings_disable)
      foreach(var ${_flag_vars})
        foreach(warning ${_gxx_warnings})
          if(NOT warning MATCHES "^-Wno-")
-            string(REGEX REPLACE "${warning}(=[^ ]*)?" "" ${var} "${${var}}")
+            string(REGEX REPLACE "(^|[ ]+)${warning}(=[^ ]*)?([ ]+|$)" " " ${var} "${${var}}")
            string(REPLACE "-W" "-Wno-" warning "${warning}")
          endif()
          ocv_check_flag_support(${var} "${warning}" _varname "")
@@ -12,7 +12,7 @@ Tutorial was written for the following versions of corresponding software:

 - Download and install Android Studio from https://developer.android.com/studio.

- Get the latest pre-built OpenCV for Android release from https://github.com/opencv/opencv/releases and unpack it (for example, `opencv-3.4.4-android-sdk.zip`).
+- Get the latest pre-built OpenCV for Android release from https://github.com/opencv/opencv/releases and unpack it (for example, `opencv-3.4.5-android-sdk.zip`).

 - Download MobileNet object detection model from https://github.com/chuanqi305/MobileNet-SSD. We need a configuration file `MobileNetSSD_deploy.prototxt` and weights `MobileNetSSD_deploy.caffemodel`.

@@ -65,7 +65,7 @@ that should be used to find the match.
    -#  **Mask image (M):** The mask, a grayscale image that masks the template


-   Only two matching methods currently accept a mask: CV_TM_SQDIFF and CV_TM_CCORR_NORMED (see
+-   Only two matching methods currently accept a mask: TM_SQDIFF and TM_CCORR_NORMED (see
    below for explanation of all the matching methods available in opencv).


@@ -86,23 +86,23 @@ that should be used to find the match.
 Good question. OpenCV implements Template matching in the function **matchTemplate()**. The
 available methods are 6:

-#  **method=CV_TM_SQDIFF**
+-#  **method=TM_SQDIFF**

    \f[R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2\f]

-#  **method=CV_TM_SQDIFF_NORMED**
+-#  **method=TM_SQDIFF_NORMED**

    \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\f]

-#  **method=CV_TM_CCORR**
+-#  **method=TM_CCORR**

    \f[R(x,y)= \sum _{x',y'} (T(x',y')  \cdot I(x+x',y+y'))\f]

-#  **method=CV_TM_CCORR_NORMED**
+-#  **method=TM_CCORR_NORMED**

    \f[R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}}\f]

-#  **method=CV_TM_CCOEFF**
+-#  **method=TM_CCOEFF**

    \f[R(x,y)= \sum _{x',y'} (T'(x',y')  \cdot I'(x+x',y+y'))\f]

@@ -110,7 +110,7 @@ available methods are 6:

    \f[\begin{array}{l} T'(x',y')=T(x',y') - 1/(w  \cdot h)  \cdot \sum _{x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w  \cdot h)  \cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array}\f]

-#  **method=CV_TM_CCOEFF_NORMED**
+-#  **method=TM_CCOEFF_NORMED**

    \f[R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} }\f]

@@ -36,14 +36,14 @@ Open your Doxyfile using your favorite text editor and search for the key
 `TAGFILES`. Change it as follows:

@code
-TAGFILES = ./docs/doxygen-tags/opencv.tag=http://docs.opencv.org/3.4.4
+TAGFILES = ./docs/doxygen-tags/opencv.tag=http://docs.opencv.org/3.4.5
@endcode

 If you had other definitions already, you can append the line using a `\`:

@code
 TAGFILES = ./docs/doxygen-tags/libstdc++.tag=https://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen \
-           ./docs/doxygen-tags/opencv.tag=http://docs.opencv.org/3.4.4
+           ./docs/doxygen-tags/opencv.tag=http://docs.opencv.org/3.4.5
@endcode

 Doxygen can now use the information from the tag file to link to the OpenCV
@@ -60,7 +60,7 @@ namespace cv
 //! @{

 template<typename _Tp, int _rows, int _cols, int _options, int _maxRows, int _maxCols> static inline
-void eigen2cv( const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& src, Mat& dst )
+void eigen2cv( const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& src, OutputArray dst )
 {
    if( !(src.Flags & Eigen::RowMajorBit) )
    {
@@ -1125,6 +1125,12 @@ inline float v_reduce_sum(const v_float32x8& a)
    return _mm_cvtss_f32(s1);
 }

+inline double v_reduce_sum(const v_float64x4& a)
+{
+    __m256d s0 = _mm256_hadd_pd(a.val, a.val);
+    return _mm_cvtsd_f64(_mm_add_pd(_v256_extract_low(s0), _v256_extract_high(s0)));
+}
+
 inline v_float32x8 v_reduce_sum4(const v_float32x8& a, const v_float32x8& b,
                                 const v_float32x8& c, const v_float32x8& d)
 {
@@ -1272,6 +1278,16 @@ OPENCV_HAL_IMPL_AVX_CHECK_FLT(v_float64x4, 15)
 OPENCV_HAL_IMPL_AVX_MULADD(v_float32x8, ps)
 OPENCV_HAL_IMPL_AVX_MULADD(v_float64x4, pd)

+inline v_int32x8 v_fma(const v_int32x8& a, const v_int32x8& b, const v_int32x8& c)
+{
+    return a * b + c;
+}
+
+inline v_int32x8 v_muladd(const v_int32x8& a, const v_int32x8& b, const v_int32x8& c)
+{
+    return v_fma(a, b, c);
+}
+
 inline v_float32x8 v_invsqrt(const v_float32x8& x)
 {
    v_float32x8 half = x * v256_setall_f32(0.5);
@@ -984,6 +984,13 @@ OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, sum, add, f32)
 OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, max, max, f32)
 OPENCV_HAL_IMPL_NEON_REDUCE_OP_4(v_float32x4, float32x2, float, min, min, f32)

+#if CV_SIMD128_64F
+inline double v_reduce_sum(const v_float64x2& a)
+{
+    return vgetq_lane_f64(a.val, 0) + vgetq_lane_f64(a.val, 1);
+}
+#endif
+
 inline v_float32x4 v_reduce_sum4(const v_float32x4& a, const v_float32x4& b,
                                 const v_float32x4& c, const v_float32x4& d)
 {
@@ -1456,6 +1456,13 @@ OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_uint32x4, unsigned, __m128i, epi32, OPENCV
 OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_int32x4, int, __m128i, epi32, OPENCV_HAL_NOP, OPENCV_HAL_NOP, si128_si32)
 OPENCV_HAL_IMPL_SSE_REDUCE_OP_4_SUM(v_float32x4, float, __m128, ps, _mm_castps_si128, _mm_castsi128_ps, ss_f32)

+inline double v_reduce_sum(const v_float64x2& a)
+{
+    double CV_DECL_ALIGNED(32) idx[2];
+    v_store_aligned(idx, a);
+    return idx[0] + idx[1];
+}
+
 inline v_float32x4 v_reduce_sum4(const v_float32x4& a, const v_float32x4& b,
                                 const v_float32x4& c, const v_float32x4& d)
 {
@@ -716,6 +716,11 @@ OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, sum, vec_add)
 OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, max, vec_max)
 OPENCV_HAL_IMPL_VSX_REDUCE_OP_4(v_float32x4, vec_float4, float, min, vec_min)

+inline double v_reduce_sum(const v_float64x2& a)
+{
+    return vec_extract(vec_add(a.val, vec_permi(a.val, a.val, 3)), 0);
+}
+
 #define OPENCV_HAL_IMPL_VSX_REDUCE_OP_8(_Tpvec, _Tpvec2, scalartype, suffix, func) \
 inline scalartype v_reduce_##suffix(const _Tpvec& a)                               \
 {                                                                                  \
@@ -7,8 +7,8 @@

 #define CV_VERSION_MAJOR    3
 #define CV_VERSION_MINOR    4
-#define CV_VERSION_REVISION 4
-#define CV_VERSION_STATUS   "-dev"
+#define CV_VERSION_REVISION 5
+#define CV_VERSION_STATUS   ""

 #define CVAUX_STR_EXP(__A)  #__A
 #define CVAUX_STR(__A)      CVAUX_STR_EXP(__A)
@@ -1257,6 +1257,14 @@ struct Device::Impl
        else
            vendorID_ = UNKNOWN_VENDOR;

+        const size_t CV_OPENCL_DEVICE_MAX_WORK_GROUP_SIZE = utils::getConfigurationParameterSizeT("OPENCV_OPENCL_DEVICE_MAX_WORK_GROUP_SIZE", 0);
+        if (CV_OPENCL_DEVICE_MAX_WORK_GROUP_SIZE > 0)
+        {
+            const size_t new_maxWorkGroupSize = std::min(maxWorkGroupSize_, CV_OPENCL_DEVICE_MAX_WORK_GROUP_SIZE);
+            if (new_maxWorkGroupSize != maxWorkGroupSize_)
+                CV_LOG_WARNING(NULL, "OpenCL: using workgroup size: " << new_maxWorkGroupSize << " (was " << maxWorkGroupSize_ << ")");
+            maxWorkGroupSize_ = new_maxWorkGroupSize;
+        }
 #if 0
        if (isExtensionSupported("cl_khr_spir"))
        {
@@ -3,6 +3,12 @@
 // of this distribution and at http://opencv.org/license.html.
 #include "test_precomp.hpp"

+#ifdef HAVE_EIGEN
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include "opencv2/core/eigen.hpp"
+#endif
+
 namespace opencv_test { namespace {

 class Core_ReduceTest : public cvtest::BaseTest
@@ -1972,4 +1978,22 @@ TEST(Core_Vectors, issue_13078_workaround)
    ASSERT_EQ(7, ints[3]);
 }

+
+#ifdef HAVE_EIGEN
+TEST(Core_Eigen, eigen2cv_check_Mat_type)
+{
+    Mat A(4, 4, CV_32FC1, Scalar::all(0));
+    Eigen::MatrixXf eigen_A;
+    cv2eigen(A, eigen_A);
+
+    Mat_<float> f_mat;
+    EXPECT_NO_THROW(eigen2cv(eigen_A, f_mat));
+    EXPECT_EQ(CV_32FC1, f_mat.type());
+
+    Mat_<double> d_mat;
+    EXPECT_ANY_THROW(eigen2cv(eigen_A, d_mat));
+    //EXPECT_EQ(CV_64FC1, d_mat.type());
+}
+#endif // HAVE_EIGEN
+
 }} // namespace
@@ -46,9 +46,9 @@
 #include <opencv2/core.hpp>

 #if !defined CV_DOXYGEN && !defined CV_DNN_DONT_ADD_EXPERIMENTAL_NS
-#define CV__DNN_EXPERIMENTAL_NS_BEGIN namespace experimental_dnn_34_v10 {
+#define CV__DNN_EXPERIMENTAL_NS_BEGIN namespace experimental_dnn_34_v11 {
 #define CV__DNN_EXPERIMENTAL_NS_END }
-namespace cv { namespace dnn { namespace experimental_dnn_34_v10 { } using namespace experimental_dnn_34_v10; }}
+namespace cv { namespace dnn { namespace experimental_dnn_34_v11 { } using namespace experimental_dnn_34_v11; }}
 #else
 #define CV__DNN_EXPERIMENTAL_NS_BEGIN
 #define CV__DNN_EXPERIMENTAL_NS_END
@@ -754,6 +754,7 @@ CV__DNN_EXPERIMENTAL_NS_BEGIN
     *  @brief Reads a network model stored in <a href="http://torch.ch">Torch7</a> framework's format.
     *  @param model    path to the file, dumped from Torch by using torch.save() function.
     *  @param isBinary specifies whether the network was serialized in ascii mode or binary.
+     *  @param evaluate specifies testing phase of network. If true, it's similar to evaluate() method in Torch.
     *  @returns Net object.
     *
     *  @note Ascii mode of Torch serializer is more preferable, because binary mode extensively use `long` type of C language,
@@ -775,7 +776,7 @@ CV__DNN_EXPERIMENTAL_NS_BEGIN
     *
     * Also some equivalents of these classes from cunn, cudnn, and fbcunn may be successfully imported.
     */
-     CV_EXPORTS_W Net readNetFromTorch(const String &model, bool isBinary = true);
+     CV_EXPORTS_W Net readNetFromTorch(const String &model, bool isBinary = true, bool evaluate = true);

     /**
      * @brief Read deep learning network represented in one of the supported formats.
@@ -116,9 +116,15 @@ public:

    virtual bool supportBackend(int backendId) CV_OVERRIDE
    {
+#ifdef HAVE_INF_ENGINE
        if (backendId == DNN_BACKEND_INFERENCE_ENGINE)
+#if INF_ENGINE_VER_MAJOR_GE(INF_ENGINE_RELEASE_2018R5)
+            return !zeroDev && eps <= 1e-7f;
+#else
            return !zeroDev && (preferableTarget == DNN_TARGET_CPU || eps <= 1e-7f);
+#endif
        else
+#endif  // HAVE_INF_ENGINE
            return backendId == DNN_BACKEND_OPENCV;
    }

@@ -6,6 +6,7 @@
 // Third party copyrights are property of their respective owners.

 #include "../precomp.hpp"
+#include <opencv2/dnn/shape_utils.hpp>

 #ifdef HAVE_PROTOBUF

@@ -134,9 +135,38 @@ Mat getMatFromTensor(opencv_onnx::TensorProto& tensor_proto)
    else
        CV_Error(Error::StsUnsupportedFormat, "Unsupported data type: " +
                        opencv_onnx::TensorProto_DataType_Name(datatype));
+    if (tensor_proto.dims_size() == 0)
+        blob.dims = 1;  // To force 1-dimensional cv::Mat for scalars.
    return blob;
 }

+void runLayer(Ptr<Layer> layer, const std::vector<Mat>& inputs,
+              std::vector<Mat>& outputs)
+{
+    std::vector<MatShape> inpShapes(inputs.size());
+    int ddepth = CV_32F;
+    for (size_t i = 0; i < inputs.size(); ++i)
+    {
+        inpShapes[i] = shape(inputs[i]);
+        if (i > 0 && ddepth != inputs[i].depth())
+            CV_Error(Error::StsNotImplemented, "Mixed input data types.");
+        ddepth = inputs[i].depth();
+    }
+
+    std::vector<MatShape> outShapes, internalShapes;
+    layer->getMemoryShapes(inpShapes, 0, outShapes, internalShapes);
+
+    std::vector<Mat> internals(internalShapes.size());
+    outputs.resize(outShapes.size());
+    for (size_t i = 0; i < outShapes.size(); ++i)
+        outputs[i].create(outShapes[i], ddepth);
+    for (size_t i = 0; i < internalShapes.size(); ++i)
+        internals[i].create(internalShapes[i], ddepth);
+
+    layer->finalize(inputs, outputs);
+    layer->forward(inputs, outputs, internals);
+}
+
 std::map<std::string, Mat> ONNXImporter::getGraphTensors(
                                        const opencv_onnx::GraphProto& graph_proto)
 {
@@ -292,6 +322,26 @@ void ONNXImporter::populateNet(Net dstNet)
    CV_Assert(model_proto.has_graph());
    opencv_onnx::GraphProto graph_proto = model_proto.graph();
    std::map<std::string, Mat> constBlobs = getGraphTensors(graph_proto);
+    // List of internal blobs shapes.
+    std::map<std::string, MatShape> outShapes;
+    // Add all the inputs shapes. It includes as constant blobs as network's inputs shapes.
+    for (int i = 0; i < graph_proto.input_size(); ++i)
+    {
+        opencv_onnx::ValueInfoProto valueInfoProto = graph_proto.input(i);
+        CV_Assert(valueInfoProto.has_type());
+        opencv_onnx::TypeProto typeProto = valueInfoProto.type();
+        CV_Assert(typeProto.has_tensor_type());
+        opencv_onnx::TypeProto::Tensor tensor = typeProto.tensor_type();
+        CV_Assert(tensor.has_shape());
+        opencv_onnx::TensorShapeProto tensorShape = tensor.shape();
+
+        MatShape inpShape(tensorShape.dim_size());
+        for (int j = 0; j < inpShape.size(); ++j)
+        {
+            inpShape[j] = tensorShape.dim(j).dim_value();
+        }
+        outShapes[valueInfoProto.name()] = inpShape;
+    }

    std::string framework_name;
    if (model_proto.has_producer_name()) {
@@ -301,6 +351,7 @@ void ONNXImporter::populateNet(Net dstNet)
    // create map with network inputs (without const blobs)
    std::map<std::string, LayerInfo> layer_id;
    std::map<std::string, LayerInfo>::iterator layerId;
+    std::map<std::string, MatShape>::iterator shapeIt;
    // fill map: push layer name, layer id and output id
    std::vector<String> netInputs;
    for (int j = 0; j < graph_proto.input_size(); j++)
@@ -317,9 +368,9 @@ void ONNXImporter::populateNet(Net dstNet)
    LayerParams layerParams;
    opencv_onnx::NodeProto node_proto;

-    for(int i = 0; i < layersSize; i++)
+    for(int li = 0; li < layersSize; li++)
    {
-        node_proto = graph_proto.node(i);
+        node_proto = graph_proto.node(li);
        layerParams = getLayerParams(node_proto);
        CV_Assert(node_proto.output_size() >= 1);
        layerParams.name = node_proto.output(0);
@@ -369,31 +420,30 @@ void ONNXImporter::populateNet(Net dstNet)
        }
        else if (layer_type == "Sub")
        {
-            Mat blob = (-1.0f) * getBlob(node_proto, constBlobs, 1);
-            blob = blob.reshape(1, 1);
+            Mat blob = getBlob(node_proto, constBlobs, 1);
            if (blob.total() == 1) {
                layerParams.type = "Power";
-                layerParams.set("shift", blob.at<float>(0));
+                layerParams.set("shift", -blob.at<float>(0));
            }
            else {
                layerParams.type = "Scale";
                layerParams.set("has_bias", true);
-                layerParams.blobs.push_back(blob);
+                layerParams.blobs.push_back(-1.0f * blob.reshape(1, 1));
            }
        }
        else if (layer_type == "Div")
        {
            Mat blob = getBlob(node_proto, constBlobs, 1);
            CV_Assert_N(blob.type() == CV_32F, blob.total());
-            divide(1.0, blob, blob);
            if (blob.total() == 1)
            {
-                layerParams.set("scale", blob.at<float>(0));
+                layerParams.set("scale", 1.0f / blob.at<float>(0));
                layerParams.type = "Power";
            }
            else
            {
                layerParams.type = "Scale";
+                divide(1.0, blob, blob);
                layerParams.blobs.push_back(blob);
                layerParams.set("bias_term", false);
            }
@@ -598,6 +648,65 @@ void ONNXImporter::populateNet(Net dstNet)
        {
            layerParams.type = "Padding";
        }
+        else if (layer_type == "Shape")
+        {
+            CV_Assert(node_proto.input_size() == 1);
+            shapeIt = outShapes.find(node_proto.input(0));
+            CV_Assert(shapeIt != outShapes.end());
+            MatShape inpShape = shapeIt->second;
+
+            Mat shapeMat(inpShape.size(), 1, CV_32S);
+            for (int j = 0; j < inpShape.size(); ++j)
+                shapeMat.at<int>(j) = inpShape[j];
+            shapeMat.dims = 1;
+
+            constBlobs.insert(std::make_pair(layerParams.name, shapeMat));
+            continue;
+        }
+        else if (layer_type == "Gather")
+        {
+            CV_Assert(node_proto.input_size() == 2);
+            CV_Assert(layerParams.has("axis"));
+            Mat input = getBlob(node_proto, constBlobs, 0);
+            Mat indexMat = getBlob(node_proto, constBlobs, 1);
+            CV_Assert_N(indexMat.type() == CV_32S, indexMat.total() == 1);
+            int index = indexMat.at<int>(0);
+            int axis = layerParams.get<int>("axis");
+
+            std::vector<cv::Range> ranges(input.dims, Range::all());
+            ranges[axis] = Range(index, index + 1);
+
+            Mat out = input(ranges);
+            constBlobs.insert(std::make_pair(layerParams.name, out));
+            continue;
+        }
+        else if (layer_type == "Concat")
+        {
+            bool hasVariableInps = false;
+            for (int i = 0; i < node_proto.input_size(); ++i)
+            {
+                if (layer_id.find(node_proto.input(i)) != layer_id.end())
+                {
+                    hasVariableInps = true;
+                    break;
+                }
+            }
+
+            if (!hasVariableInps)
+            {
+                std::vector<Mat> inputs(node_proto.input_size()), concatenated;
+                for (size_t i = 0; i < inputs.size(); ++i)
+                {
+                    inputs[i] = getBlob(node_proto, constBlobs, i);
+                }
+                Ptr<Layer> concat = ConcatLayer::create(layerParams);
+                runLayer(concat, inputs, concatenated);
+
+                CV_Assert(concatenated.size() == 1);
+                constBlobs.insert(std::make_pair(layerParams.name, concatenated[0]));
+                continue;
+            }
+        }
        else
        {
            for (int j = 0; j < node_proto.input_size(); j++) {
@@ -609,12 +718,24 @@ void ONNXImporter::populateNet(Net dstNet)
         int id = dstNet.addLayer(layerParams.name, layerParams.type, layerParams);
         layer_id.insert(std::make_pair(layerParams.name, LayerInfo(id, 0)));

+
+         std::vector<MatShape> layerInpShapes, layerOutShapes, layerInternalShapes;
         for (int j = 0; j < node_proto.input_size(); j++) {
             layerId = layer_id.find(node_proto.input(j));
             if (layerId != layer_id.end()) {
                 dstNet.connect(layerId->second.layerId, layerId->second.outputId, id, j);
+                 // Collect input shapes.
+                 shapeIt = outShapes.find(node_proto.input(j));
+                 CV_Assert(shapeIt != outShapes.end());
+                 layerInpShapes.push_back(shapeIt->second);
             }
         }
+
+         // Compute shape of output blob for this layer.
+         Ptr<Layer> layer = dstNet.getLayer(id);
+         layer->getMemoryShapes(layerInpShapes, 0, layerOutShapes, layerInternalShapes);
+         CV_Assert(!layerOutShapes.empty());
+         outShapes[layerParams.name] = layerOutShapes[0];
     }
 }

@@ -152,6 +152,7 @@ InfEngineBackendNet::InfEngineBackendNet()
 {
    targetDevice = InferenceEngine::TargetDevice::eCPU;
    precision = InferenceEngine::Precision::FP32;
+    hasNetOwner = false;
 }

 InfEngineBackendNet::InfEngineBackendNet(InferenceEngine::CNNNetwork& net)
@@ -162,6 +163,7 @@ InfEngineBackendNet::InfEngineBackendNet(InferenceEngine::CNNNetwork& net)
    outputs = net.getOutputsInfo();
    layers.resize(net.layerCount());  // A hack to execute InfEngineBackendNet::layerCount correctly.
    netOwner = net;
+    hasNetOwner = true;
 }

 void InfEngineBackendNet::Release() noexcept
@@ -178,12 +180,12 @@ void InfEngineBackendNet::setPrecision(InferenceEngine::Precision p) noexcept

 InferenceEngine::Precision InfEngineBackendNet::getPrecision() noexcept
 {
-    return precision;
+    return hasNetOwner ? netOwner.getPrecision() : precision;
 }

 InferenceEngine::Precision InfEngineBackendNet::getPrecision() const noexcept
 {
-    return precision;
+    return hasNetOwner ? netOwner.getPrecision() : precision;
 }

 // Assume that outputs of network is unconnected blobs.
@@ -233,6 +235,12 @@ const std::string& InfEngineBackendNet::getName() const noexcept
    return name;
 }

+InferenceEngine::StatusCode InfEngineBackendNet::serialize(const std::string&, const std::string&, InferenceEngine::ResponseDesc*) const noexcept
+{
+    CV_Error(Error::StsNotImplemented, "");
+    return InferenceEngine::StatusCode::OK;
+}
+
 size_t InfEngineBackendNet::layerCount() noexcept
 {
    return const_cast<const InfEngineBackendNet*>(this)->layerCount();
@@ -26,10 +26,11 @@
 #define INF_ENGINE_RELEASE_2018R2 2018020000
 #define INF_ENGINE_RELEASE_2018R3 2018030000
 #define INF_ENGINE_RELEASE_2018R4 2018040000
+#define INF_ENGINE_RELEASE_2018R5 2018050000

 #ifndef INF_ENGINE_RELEASE
-#warning("IE version have not been provided via command-line. Using 2018R4 by default")
-#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2018R4
+#warning("IE version have not been provided via command-line. Using 2018R5 by default")
+#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2018R5
 #endif

 #define INF_ENGINE_VER_MAJOR_GT(ver) (((INF_ENGINE_RELEASE) / 10000) > ((ver) / 10000))
@@ -68,6 +69,8 @@ public:

    virtual InferenceEngine::InputInfo::Ptr getInput(const std::string &inputName) const noexcept;

+    virtual InferenceEngine::StatusCode serialize(const std::string &xmlPath, const std::string &binPath, InferenceEngine::ResponseDesc* resp) const noexcept;
+
    virtual void getName(char *pName, size_t len) noexcept;

    virtual void getName(char *pName, size_t len) const noexcept;
@@ -134,6 +137,9 @@ private:
    InferenceEngine::InferRequest infRequest;
    // In case of models from Model Optimizer we need to manage their lifetime.
    InferenceEngine::CNNNetwork netOwner;
+    // There is no way to check if netOwner is initialized or not so we use
+    // a separate flag to determine if the model has been loaded from IR.
+    bool hasNetOwner;

    std::string name;

@@ -129,13 +129,15 @@ struct TorchImporter
    Module *rootModule;
    Module *curModule;
    int moduleCounter;
+    bool testPhase;

-    TorchImporter(String filename, bool isBinary)
+    TorchImporter(String filename, bool isBinary, bool evaluate)
    {
        CV_TRACE_FUNCTION();

        rootModule = curModule = NULL;
        moduleCounter = 0;
+        testPhase = evaluate;

        file = cv::Ptr<THFile>(THDiskFile_new(filename, "r", 0), THFile_free);
        CV_Assert(file && THFile_isOpened(file));
@@ -680,7 +682,8 @@ struct TorchImporter
                    layerParams.blobs.push_back(tensorParams["bias"].second);
                }

-                if (nnName == "InstanceNormalization")
+                bool trainPhase = scalarParams.get<bool>("train", false);
+                if (nnName == "InstanceNormalization" || (trainPhase && !testPhase))
                {
                    cv::Ptr<Module> mvnModule(new Module(nnName));
                    mvnModule->apiType = "MVN";
@@ -1243,18 +1246,18 @@ struct TorchImporter

 Mat readTorchBlob(const String &filename, bool isBinary)
 {
-    TorchImporter importer(filename, isBinary);
+    TorchImporter importer(filename, isBinary, true);
    importer.readObject();
    CV_Assert(importer.tensors.size() == 1);

    return importer.tensors.begin()->second;
 }

-Net readNetFromTorch(const String &model, bool isBinary)
+Net readNetFromTorch(const String &model, bool isBinary, bool evaluate)
 {
    CV_TRACE_FUNCTION();

-    TorchImporter importer(model, isBinary);
+    TorchImporter importer(model, isBinary, evaluate);
    Net net;
    importer.populateNet(net);
    return net;
@@ -226,9 +226,9 @@ TEST_P(DNNTestNetwork, OpenPose_pose_mpi_faster_4_stages)
 TEST_P(DNNTestNetwork, OpenFace)
 {
 #if defined(INF_ENGINE_RELEASE)
-#if INF_ENGINE_RELEASE < 2018030000
+#if (INF_ENGINE_RELEASE < 2018030000 || INF_ENGINE_RELEASE == 2018050000)
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
-        throw SkipTestException("Test is enabled starts from OpenVINO 2018R3");
+        throw SkipTestException("");
 #elif INF_ENGINE_RELEASE < 2018040000
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16)
        throw SkipTestException("Test is enabled starts from OpenVINO 2018R4");
@@ -471,6 +471,7 @@ TEST(Test_Caffe, shared_weights)

  net.setInput(blob_1, "input_1");
  net.setInput(blob_2, "input_2");
+  net.setPreferableBackend(DNN_BACKEND_OPENCV);

  Mat sum = net.forward();

@@ -306,7 +306,7 @@ TEST_P(Test_Darknet_nets, TinyYoloVoc)
    // batch size 1
    testDarknetModel(config_file, weights_file, ref.rowRange(0, 2), scoreDiff, iouDiff);

-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018040000
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018040000
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target != DNN_TARGET_MYRIAD)
 #endif
    // batch size 2
@@ -166,7 +166,7 @@ TEST_P(Deconvolution, Accuracy)
    if (backendId == DNN_BACKEND_INFERENCE_ENGINE && targetId == DNN_TARGET_CPU &&
        dilation.width == 2 && dilation.height == 2)
        throw SkipTestException("");
-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018040000
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018040000
    if (backendId == DNN_BACKEND_INFERENCE_ENGINE && targetId == DNN_TARGET_CPU &&
        hasBias && group != 1)
        throw SkipTestException("Test is disabled for OpenVINO 2018R4");
@@ -190,6 +190,14 @@ TEST_P(DNNTestOpenVINO, models)
                                         modelName == "landmarks-regression-retail-0009" ||
                                          modelName == "semantic-segmentation-adas-0001")))
        throw SkipTestException("");
+#elif INF_ENGINE_RELEASE == 2018050000
+    if (modelName == "single-image-super-resolution-0063" ||
+        modelName == "single-image-super-resolution-1011" ||
+        modelName == "single-image-super-resolution-1021" ||
+        (target == DNN_TARGET_OPENCL_FP16 && modelName == "face-reidentification-retail-0095") ||
+        (target == DNN_TARGET_MYRIAD && (modelName == "license-plate-recognition-barrier-0001" ||
+                                         modelName == "semantic-segmentation-adas-0001")))
+        throw SkipTestException("");
 #endif
 #endif

@@ -137,7 +137,7 @@ TEST_P(Test_Caffe_layers, Convolution)

 TEST_P(Test_Caffe_layers, DeConvolution)
 {
-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018040000
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018040000
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_CPU)
        throw SkipTestException("Test is disabled for OpenVINO 2018R4");
 #endif
@@ -295,6 +295,10 @@ TEST_P(Test_Caffe_layers, Eltwise)
 {
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
        throw SkipTestException("");
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL)
+        throw SkipTestException("Test is disabled for OpenVINO 2018R5");
+#endif
    testLayerUsingCaffeModels("layer_eltwise");
 }

@@ -918,8 +922,11 @@ INSTANTIATE_TEST_CASE_P(/**/, Layer_Test_DWconv_Prelu, Combine(Values(3, 6), Val
 // Using Intel's Model Optimizer generate .xml and .bin files:
 // ./ModelOptimizer -w /path/to/caffemodel -d /path/to/prototxt \
 //                  -p FP32 -i -b ${batch_size} -o /path/to/output/folder
-TEST(Layer_Test_Convolution_DLDT, Accuracy)
+typedef testing::TestWithParam<Target> Layer_Test_Convolution_DLDT;
+TEST_P(Layer_Test_Convolution_DLDT, Accuracy)
 {
+    Target targetId = GetParam();
+
    Net netDefault = readNet(_tf("layer_convolution.caffemodel"), _tf("layer_convolution.prototxt"));
    Net net = readNet(_tf("layer_convolution.xml"), _tf("layer_convolution.bin"));

@@ -930,17 +937,29 @@ TEST(Layer_Test_Convolution_DLDT, Accuracy)
    Mat outDefault = netDefault.forward();

    net.setInput(inp);
-    Mat out = net.forward();
+    net.setPreferableTarget(targetId);

-    normAssert(outDefault, out);
+    if (targetId != DNN_TARGET_MYRIAD)
+    {
+        Mat out = net.forward();

-    std::vector<int> outLayers = net.getUnconnectedOutLayers();
-    ASSERT_EQ(net.getLayer(outLayers[0])->name, "output_merge");
-    ASSERT_EQ(net.getLayer(outLayers[0])->type, "Concat");
+        normAssert(outDefault, out);
+
+        std::vector<int> outLayers = net.getUnconnectedOutLayers();
+        ASSERT_EQ(net.getLayer(outLayers[0])->name, "output_merge");
+        ASSERT_EQ(net.getLayer(outLayers[0])->type, "Concat");
+    }
+    else
+    {
+        // An assertion is expected because the model is in FP32 format but
+        // Myriad plugin supports only FP16 models.
+        ASSERT_ANY_THROW(net.forward());
+    }
 }

-TEST(Layer_Test_Convolution_DLDT, setInput_uint8)
+TEST_P(Layer_Test_Convolution_DLDT, setInput_uint8)
 {
+    Target targetId = GetParam();
    Mat inp = blobFromNPY(_tf("blob.npy"));

    Mat inputs[] = {Mat(inp.dims, inp.size, CV_8U), Mat()};
@@ -951,12 +970,25 @@ TEST(Layer_Test_Convolution_DLDT, setInput_uint8)
    for (int i = 0; i < 2; ++i)
    {
        Net net = readNet(_tf("layer_convolution.xml"), _tf("layer_convolution.bin"));
+        net.setPreferableTarget(targetId);
        net.setInput(inputs[i]);
-        outs[i] = net.forward();
-        ASSERT_EQ(outs[i].type(), CV_32F);
+        if (targetId != DNN_TARGET_MYRIAD)
+        {
+            outs[i] = net.forward();
+            ASSERT_EQ(outs[i].type(), CV_32F);
+        }
+        else
+        {
+            // An assertion is expected because the model is in FP32 format but
+            // Myriad plugin supports only FP16 models.
+            ASSERT_ANY_THROW(net.forward());
+        }
    }
-    normAssert(outs[0], outs[1]);
+    if (targetId != DNN_TARGET_MYRIAD)
+        normAssert(outs[0], outs[1]);
 }
+INSTANTIATE_TEST_CASE_P(/**/, Layer_Test_Convolution_DLDT,
+    testing::ValuesIn(getAvailableTargets(DNN_BACKEND_INFERENCE_ENGINE)));

 // 1. Create a .prototxt file with the following network:
 // layer {
@@ -980,14 +1012,17 @@ TEST(Layer_Test_Convolution_DLDT, setInput_uint8)
 // net.save('/path/to/caffemodel')
 //
 // 3. Convert using ModelOptimizer.
-typedef testing::TestWithParam<tuple<int, int> > Test_DLDT_two_inputs;
+typedef testing::TestWithParam<tuple<int, int, Target> > Test_DLDT_two_inputs;
 TEST_P(Test_DLDT_two_inputs, as_IR)
 {
    int firstInpType = get<0>(GetParam());
    int secondInpType = get<1>(GetParam());
-    // TODO: It looks like a bug in Inference Engine.
+    Target targetId = get<2>(GetParam());
+
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE < 2018040000
    if (secondInpType == CV_8U)
-        throw SkipTestException("");
+        throw SkipTestException("Test is enabled starts from OpenVINO 2018R4");
+#endif

    Net net = readNet(_tf("net_two_inputs.xml"), _tf("net_two_inputs.bin"));
    int inpSize[] = {1, 2, 3};
@@ -998,11 +1033,21 @@ TEST_P(Test_DLDT_two_inputs, as_IR)

    net.setInput(firstInp, "data");
    net.setInput(secondInp, "second_input");
-    Mat out = net.forward();
+    net.setPreferableTarget(targetId);
+    if (targetId != DNN_TARGET_MYRIAD)
+    {
+        Mat out = net.forward();

-    Mat ref;
-    cv::add(firstInp, secondInp, ref, Mat(), CV_32F);
-    normAssert(out, ref);
+        Mat ref;
+        cv::add(firstInp, secondInp, ref, Mat(), CV_32F);
+        normAssert(out, ref);
+    }
+    else
+    {
+        // An assertion is expected because the model is in FP32 format but
+        // Myriad plugin supports only FP16 models.
+        ASSERT_ANY_THROW(net.forward());
+    }
 }

 TEST_P(Test_DLDT_two_inputs, as_backend)
@@ -1010,6 +1055,8 @@ TEST_P(Test_DLDT_two_inputs, as_backend)
    static const float kScale = 0.5f;
    static const float kScaleInv = 1.0f / kScale;

+    Target targetId = get<2>(GetParam());
+
    Net net;
    LayerParams lp;
    lp.type = "Eltwise";
@@ -1018,9 +1065,9 @@ TEST_P(Test_DLDT_two_inputs, as_backend)
    int eltwiseId = net.addLayerToPrev(lp.name, lp.type, lp);  // connect to a first input
    net.connect(0, 1, eltwiseId, 1);  // connect to a second input

-    int inpSize[] = {1, 2, 3};
-    Mat firstInp(3, &inpSize[0], get<0>(GetParam()));
-    Mat secondInp(3, &inpSize[0], get<1>(GetParam()));
+    int inpSize[] = {1, 2, 3, 4};
+    Mat firstInp(4, &inpSize[0], get<0>(GetParam()));
+    Mat secondInp(4, &inpSize[0], get<1>(GetParam()));
    randu(firstInp, 0, 255);
    randu(secondInp, 0, 255);

@@ -1028,15 +1075,20 @@ TEST_P(Test_DLDT_two_inputs, as_backend)
    net.setInput(firstInp, "data", kScale);
    net.setInput(secondInp, "second_input", kScaleInv);
    net.setPreferableBackend(DNN_BACKEND_INFERENCE_ENGINE);
+    net.setPreferableTarget(targetId);
    Mat out = net.forward();

    Mat ref;
    addWeighted(firstInp, kScale, secondInp, kScaleInv, 0, ref, CV_32F);
-    normAssert(out, ref);
+    // Output values are in range [0, 637.5].
+    double l1 = (targetId == DNN_TARGET_OPENCL_FP16 || targetId == DNN_TARGET_MYRIAD) ? 0.06 : 1e-6;
+    double lInf = (targetId == DNN_TARGET_OPENCL_FP16 || targetId == DNN_TARGET_MYRIAD) ? 0.3 : 1e-5;
+    normAssert(out, ref, "", l1, lInf);
 }

 INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_DLDT_two_inputs, Combine(
-  Values(CV_8U, CV_32F), Values(CV_8U, CV_32F)
+  Values(CV_8U, CV_32F), Values(CV_8U, CV_32F),
+  testing::ValuesIn(getAvailableTargets(DNN_BACKEND_INFERENCE_ENGINE))
 ));

 class UnsupportedLayer : public Layer
@@ -162,6 +162,12 @@ TEST_P(Test_ONNX_layers, MultyInputs)
    normAssert(ref, out, "", default_l1,  default_lInf);
 }

+TEST_P(Test_ONNX_layers, DynamicReshape)
+{
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
+        throw SkipTestException("");
+    testONNXModels("dynamic_reshape");
+}

 INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets());

@@ -245,6 +251,10 @@ TEST_P(Test_ONNX_nets, VGG16)
    else if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL) {
        lInf = 1.2e-4;
    }
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16)
+        l1 = 0.131;
+#endif
    testONNXModels("vgg16", pb, l1, lInf);
 }

@@ -323,7 +333,7 @@ TEST_P(Test_ONNX_nets, CNN_MNIST)
 TEST_P(Test_ONNX_nets, MobileNet_v2)
 {
    // output range: [-166; 317]
-    const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.38 : 7e-5;
+    const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.4 : 7e-5;
    const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 2.87 : 5e-4;
    testONNXModels("mobilenetv2", pb, l1, lInf);
 }
@@ -346,7 +356,17 @@ TEST_P(Test_ONNX_nets, LResNet100E_IR)

 TEST_P(Test_ONNX_nets, Emotion_ferplus)
 {
-    testONNXModels("emotion_ferplus", pb);
+    double l1 = default_l1;
+    double lInf = default_lInf;
+    // Output values are in range [-2.01109, 2.11111]
+    if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
+        l1 = 0.007;
+    else if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16)
+    {
+        l1 = 0.021;
+        lInf = 0.034;
+    }
+    testONNXModels("emotion_ferplus", pb, l1, lInf);
 }

 TEST_P(Test_ONNX_nets, Inception_v2)
@@ -367,6 +387,10 @@ TEST_P(Test_ONNX_nets, DenseNet121)

 TEST_P(Test_ONNX_nets, Inception_v1)
 {
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
+        throw SkipTestException("");
+#endif
    testONNXModels("inception_v1", pb);
 }

@@ -241,6 +241,10 @@ TEST_P(Test_TensorFlow_layers, unfused_flatten)

 TEST_P(Test_TensorFlow_layers, leaky_relu)
 {
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL)
+        throw SkipTestException("");
+#endif
    runTensorFlowNet("leaky_relu_order1");
    runTensorFlowNet("leaky_relu_order2");
    runTensorFlowNet("leaky_relu_order3");
@@ -383,6 +387,10 @@ TEST_P(Test_TensorFlow_nets, Faster_RCNN)

 TEST_P(Test_TensorFlow_nets, MobileNet_v1_SSD_PPN)
 {
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
+        throw SkipTestException("Unstable test case");
+#endif
    checkBackend();
    std::string proto = findDataFile("dnn/ssd_mobilenet_v1_ppn_coco.pbtxt", false);
    std::string model = findDataFile("dnn/ssd_mobilenet_v1_ppn_coco.pb", false);
@@ -560,6 +568,10 @@ TEST_P(Test_TensorFlow_layers, slice)
    if (backend == DNN_BACKEND_INFERENCE_ENGINE &&
        (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
        throw SkipTestException("");
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
+        throw SkipTestException("");
+#endif
    runTensorFlowNet("slice_4d");
 }

@@ -73,7 +73,7 @@ class Test_Torch_layers : public DNNTestLayer
 {
 public:
    void runTorchNet(const String& prefix, String outLayerName = "",
-                     bool check2ndBlob = false, bool isBinary = false,
+                     bool check2ndBlob = false, bool isBinary = false, bool evaluate = true,
                     double l1 = 0.0, double lInf = 0.0)
    {
        String suffix = (isBinary) ? ".dat" : ".txt";
@@ -84,7 +84,7 @@ public:

        checkBackend(backend, target, &inp, &outRef);

-        Net net = readNetFromTorch(_tf(prefix + "_net" + suffix), isBinary);
+        Net net = readNetFromTorch(_tf(prefix + "_net" + suffix), isBinary, evaluate);
        ASSERT_FALSE(net.empty());

        net.setPreferableBackend(backend);
@@ -114,7 +114,7 @@ TEST_P(Test_Torch_layers, run_convolution)
    // Output reference values are in range [23.4018, 72.0181]
    double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.08 : default_l1;
    double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.42 : default_lInf;
-    runTorchNet("net_conv", "", false, true, l1, lInf);
+    runTorchNet("net_conv", "", false, true, true, l1, lInf);
 }

 TEST_P(Test_Torch_layers, run_pool_max)
@@ -136,7 +136,7 @@ TEST_P(Test_Torch_layers, run_reshape_change_batch_size)

 TEST_P(Test_Torch_layers, run_reshape)
 {
-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018040000
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018040000
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
        throw SkipTestException("Test is disabled for OpenVINO 2018R4");
 #endif
@@ -147,7 +147,7 @@ TEST_P(Test_Torch_layers, run_reshape)
 TEST_P(Test_Torch_layers, run_reshape_single_sample)
 {
    // Reference output values in range [14.4586, 18.4492].
-    runTorchNet("net_reshape_single_sample", "", false, false,
+    runTorchNet("net_reshape_single_sample", "", false, false, true,
                (target == DNN_TARGET_MYRIAD || target == DNN_TARGET_OPENCL_FP16) ? 0.0073 : default_l1,
                (target == DNN_TARGET_MYRIAD || target == DNN_TARGET_OPENCL_FP16) ? 0.025 : default_lInf);
 }
@@ -166,13 +166,13 @@ TEST_P(Test_Torch_layers, run_concat)

 TEST_P(Test_Torch_layers, run_depth_concat)
 {
-    runTorchNet("net_depth_concat", "", false, true, 0.0,
+    runTorchNet("net_depth_concat", "", false, true, true, 0.0,
                target == DNN_TARGET_OPENCL_FP16 ? 0.021 : 0.0);
 }

 TEST_P(Test_Torch_layers, run_deconv)
 {
-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018040000
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE >= 2018040000
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
        throw SkipTestException("Test is disabled for OpenVINO 2018R4");
 #endif
@@ -182,6 +182,7 @@ TEST_P(Test_Torch_layers, run_deconv)
 TEST_P(Test_Torch_layers, run_batch_norm)
 {
    runTorchNet("net_batch_norm", "", false, true);
+    runTorchNet("net_batch_norm_train", "", false, true, false);
 }

 TEST_P(Test_Torch_layers, net_prelu)
@@ -216,7 +217,7 @@ TEST_P(Test_Torch_layers, net_conv_gemm_lrn)
 {
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
        throw SkipTestException("");
-    runTorchNet("net_conv_gemm_lrn", "", false, true,
+    runTorchNet("net_conv_gemm_lrn", "", false, true, true,
                target == DNN_TARGET_OPENCL_FP16 ? 0.046 : 0.0,
                target == DNN_TARGET_OPENCL_FP16 ? 0.023 : 0.0);
 }
@@ -266,9 +267,9 @@ class Test_Torch_nets : public DNNTestLayer {};

 TEST_P(Test_Torch_nets, OpenFace_accuracy)
 {
-#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE < 2018030000
+#if defined(INF_ENGINE_RELEASE) && (INF_ENGINE_RELEASE < 2018030000 || INF_ENGINE_RELEASE == 2018050000)
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
-        throw SkipTestException("Test is enabled starts from OpenVINO 2018R3");
+        throw SkipTestException("");
 #endif
    checkBackend();
    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16)
@@ -389,6 +390,10 @@ TEST_P(Test_Torch_nets, ENet_accuracy)
 //   -model models/instance_norm/feathers.t7
 TEST_P(Test_Torch_nets, FastNeuralStyle_accuracy)
 {
+#if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE == 2018050000
+    if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
+        throw SkipTestException("");
+#endif
    checkBackend();
    std::string models[] = {"dnn/fast_neural_style_eccv16_starry_night.t7",
                            "dnn/fast_neural_style_instance_norm_feathers.t7"};
@@ -77,7 +77,7 @@ void KeyPointsFilter::retainBest(std::vector<KeyPoint>& keypoints, int n_points)
            return;
        }
        //first use nth element to partition the keypoints into the best and worst.
-        std::nth_element(keypoints.begin(), keypoints.begin() + n_points, keypoints.end(), KeypointResponseGreater());
+        std::nth_element(keypoints.begin(), keypoints.begin() + n_points - 1, keypoints.end(), KeypointResponseGreater());
        //this is the boundary response, and in the case of FAST may be ambiguous
        float ambiguous_response = keypoints[n_points - 1].response;
        //use std::partition to grab all of the keypoints with the boundary response.
@@ -0,0 +1,38 @@
+// 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"
+
+namespace opencv_test { namespace {
+
+TEST(Features2D_KeypointUtils, retainBest_issue_12594)
+{
+    const size_t N = 9;
+
+    // Construct 4-way tie for 3rd highest - correct answer for "3 best" is 6
+    const float no_problem[] = { 5.0f, 4.0f, 1.0f, 2.0f, 0.0f, 3.0f, 3.0f, 3.0f, 3.0f };
+
+    // Same set, different order that exposes partial sort property of std::nth_element
+    // Note: the problem case may depend on your particular implementation of STL
+    const float problem[] = { 3.0f, 3.0f, 3.0f, 3.0f, 4.0f, 5.0f, 0.0f, 1.0f, 2.0f };
+
+    const size_t NBEST  = 3u;
+    const size_t ANSWER = 6u;
+
+    std::vector<cv::KeyPoint> sorted_cv(N);
+    std::vector<cv::KeyPoint> unsorted_cv(N);
+
+    for (size_t i = 0; i < N; ++i)
+    {
+        sorted_cv[i].response   = no_problem[i];
+        unsorted_cv[i].response = problem[i];
+    }
+
+    cv::KeyPointsFilter::retainBest(sorted_cv, NBEST);
+    cv::KeyPointsFilter::retainBest(unsorted_cv, NBEST);
+
+    EXPECT_EQ(ANSWER, sorted_cv.size());
+    EXPECT_EQ(ANSWER, unsorted_cv.size());
+}
+
+}} // namespace
@@ -116,6 +116,31 @@ PERF_TEST_P(MatSize, equalizeHist,
 }
 #undef MatSize

+typedef TestBaseWithParam< tuple<int, int> > Dim_Cmpmethod;
+PERF_TEST_P(Dim_Cmpmethod, compareHist,
+            testing::Combine(testing::Values(1, 3),
+                             testing::Values(HISTCMP_CORREL, HISTCMP_CHISQR, HISTCMP_INTERSECT, HISTCMP_BHATTACHARYYA, HISTCMP_CHISQR_ALT, HISTCMP_KL_DIV))
+            )
+{
+    int dims = get<0>(GetParam());
+    int method = get<1>(GetParam());
+    int histSize[] = { 2048, 128, 64 };
+
+    Mat hist1(dims, histSize, CV_32FC1);
+    Mat hist2(dims, histSize, CV_32FC1);
+    randu(hist1, 0, 256);
+    randu(hist2, 0, 256);
+
+    declare.in(hist1.reshape(1, 256), hist2.reshape(1, 256));
+
+    TEST_CYCLE()
+    {
+        compareHist(hist1, hist2, method);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
 typedef tuple<Size, double> Sz_ClipLimit_t;
 typedef TestBaseWithParam<Sz_ClipLimit_t> Sz_ClipLimit;

@@ -441,7 +441,7 @@ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
               ocl_sepFilter3x3_8UC1(_src, _dst, ddepth, kx, ky, delta, borderType));

    CV_OCL_RUN(ocl::isOpenCLActivated() && _dst.isUMat() && _src.dims() <= 2 && (size_t)_src.rows() > kx.total() && (size_t)_src.cols() > kx.total(),
-               ocl_sepFilter2D(_src, _dst, ddepth, kx, ky, Point(-1, -1), 0, borderType))
+               ocl_sepFilter2D(_src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType))

    Mat src = _src.getMat();
    Mat dst = _dst.getMat();
@@ -494,7 +494,7 @@ void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,

    CV_OCL_RUN(ocl::isOpenCLActivated() && _dst.isUMat() && _src.dims() <= 2 &&
               (size_t)_src.rows() > kx.total() && (size_t)_src.cols() > kx.total(),
-               ocl_sepFilter2D(_src, _dst, ddepth, kx, ky, Point(-1, -1), 0, borderType))
+               ocl_sepFilter2D(_src, _dst, ddepth, kx, ky, Point(-1, -1), delta, borderType))

    Mat src = _src.getMat();
    Mat dst = _dst.getMat();
@@ -41,6 +41,7 @@

 #include "precomp.hpp"
 #include "opencl_kernels_imgproc.hpp"
+#include "opencv2/core/hal/intrin.hpp"

 #include "opencv2/core/openvx/ovx_defs.hpp"

@@ -1938,10 +1939,6 @@ double cv::compareHist( InputArray _H1, InputArray _H2, int method )

    CV_Assert( it.planes[0].isContinuous() && it.planes[1].isContinuous() );

-#if CV_SSE2
-    bool haveSIMD = checkHardwareSupport(CV_CPU_SSE2);
-#endif
-
    for( size_t i = 0; i < it.nplanes; i++, ++it )
    {
        const float* h1 = it.planes[0].ptr<float>();
@@ -1961,50 +1958,63 @@ double cv::compareHist( InputArray _H1, InputArray _H2, int method )
        }
        else if( method == CV_COMP_CORREL )
        {
-            #if CV_SSE2
-            if (haveSIMD)
+#if CV_SIMD_64F
+            v_float64 v_s1 = vx_setzero_f64();
+            v_float64 v_s2 = vx_setzero_f64();
+            v_float64 v_s11 = vx_setzero_f64();
+            v_float64 v_s12 = vx_setzero_f64();
+            v_float64 v_s22 = vx_setzero_f64();
+            for ( ; j <= len - v_float32::nlanes; j += v_float32::nlanes)
            {
-                __m128d v_s1 = _mm_setzero_pd(), v_s2 = v_s1;
-                __m128d v_s11 = v_s1, v_s22 = v_s1, v_s12 = v_s1;
+                v_float32 v_a = vx_load(h1 + j);
+                v_float32 v_b = vx_load(h2 + j);

-                for ( ; j <= len - 4; j += 4)
-                {
-                    __m128 v_a = _mm_loadu_ps(h1 + j);
-                    __m128 v_b = _mm_loadu_ps(h2 + j);
+                // 0-1
+                v_float64 v_ad = v_cvt_f64(v_a);
+                v_float64 v_bd = v_cvt_f64(v_b);
+                v_s12 = v_muladd(v_ad, v_bd, v_s12);
+                v_s11 = v_muladd(v_ad, v_ad, v_s11);
+                v_s22 = v_muladd(v_bd, v_bd, v_s22);
+                v_s1 += v_ad;
+                v_s2 += v_bd;

-                    // 0-1
-                    __m128d v_ad = _mm_cvtps_pd(v_a);
-                    __m128d v_bd = _mm_cvtps_pd(v_b);
-                    v_s12 = _mm_add_pd(v_s12, _mm_mul_pd(v_ad, v_bd));
-                    v_s11 = _mm_add_pd(v_s11, _mm_mul_pd(v_ad, v_ad));
-                    v_s22 = _mm_add_pd(v_s22, _mm_mul_pd(v_bd, v_bd));
-                    v_s1 = _mm_add_pd(v_s1, v_ad);
-                    v_s2 = _mm_add_pd(v_s2, v_bd);
-
-                    // 2-3
-                    v_ad = _mm_cvtps_pd(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_a), 8)));
-                    v_bd = _mm_cvtps_pd(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_b), 8)));
-                    v_s12 = _mm_add_pd(v_s12, _mm_mul_pd(v_ad, v_bd));
-                    v_s11 = _mm_add_pd(v_s11, _mm_mul_pd(v_ad, v_ad));
-                    v_s22 = _mm_add_pd(v_s22, _mm_mul_pd(v_bd, v_bd));
-                    v_s1 = _mm_add_pd(v_s1, v_ad);
-                    v_s2 = _mm_add_pd(v_s2, v_bd);
-                }
-
-                double CV_DECL_ALIGNED(16) ar[10];
-                _mm_store_pd(ar, v_s12);
-                _mm_store_pd(ar + 2, v_s11);
-                _mm_store_pd(ar + 4, v_s22);
-                _mm_store_pd(ar + 6, v_s1);
-                _mm_store_pd(ar + 8, v_s2);
-
-                s12 += ar[0] + ar[1];
-                s11 += ar[2] + ar[3];
-                s22 += ar[4] + ar[5];
-                s1 += ar[6] + ar[7];
-                s2 += ar[8] + ar[9];
+                // 2-3
+                v_ad = v_cvt_f64_high(v_a);
+                v_bd = v_cvt_f64_high(v_b);
+                v_s12 = v_muladd(v_ad, v_bd, v_s12);
+                v_s11 = v_muladd(v_ad, v_ad, v_s11);
+                v_s22 = v_muladd(v_bd, v_bd, v_s22);
+                v_s1 += v_ad;
+                v_s2 += v_bd;
            }
-            #endif
+            s12 += v_reduce_sum(v_s12);
+            s11 += v_reduce_sum(v_s11);
+            s22 += v_reduce_sum(v_s22);
+            s1 += v_reduce_sum(v_s1);
+            s2 += v_reduce_sum(v_s2);
+#elif CV_SIMD && 0 //Disable vectorization for CV_COMP_CORREL if f64 is unsupported due to low precision
+            v_float32 v_s1 = vx_setzero_f32();
+            v_float32 v_s2 = vx_setzero_f32();
+            v_float32 v_s11 = vx_setzero_f32();
+            v_float32 v_s12 = vx_setzero_f32();
+            v_float32 v_s22 = vx_setzero_f32();
+            for (; j <= len - v_float32::nlanes; j += v_float32::nlanes)
+            {
+                v_float32 v_a = vx_load(h1 + j);
+                v_float32 v_b = vx_load(h2 + j);
+
+                v_s12 = v_muladd(v_a, v_b, v_s12);
+                v_s11 = v_muladd(v_a, v_a, v_s11);
+                v_s22 = v_muladd(v_b, v_b, v_s22);
+                v_s1 += v_a;
+                v_s2 += v_b;
+            }
+            s12 += v_reduce_sum(v_s12);
+            s11 += v_reduce_sum(v_s11);
+            s22 += v_reduce_sum(v_s22);
+            s1 += v_reduce_sum(v_s1);
+            s2 += v_reduce_sum(v_s2);
+#endif
            for( ; j < len; j++ )
            {
                double a = h1[j];
@@ -2019,67 +2029,68 @@ double cv::compareHist( InputArray _H1, InputArray _H2, int method )
        }
        else if( method == CV_COMP_INTERSECT )
        {
-            #if CV_NEON
-            float32x4_t v_result = vdupq_n_f32(0.0f);
-            for( ; j <= len - 4; j += 4 )
-                v_result = vaddq_f32(v_result, vminq_f32(vld1q_f32(h1 + j), vld1q_f32(h2 + j)));
-            float CV_DECL_ALIGNED(16) ar[4];
-            vst1q_f32(ar, v_result);
-            result += ar[0] + ar[1] + ar[2] + ar[3];
-            #elif CV_SSE2
-            if (haveSIMD)
+#if CV_SIMD_64F
+            v_float64 v_result = vx_setzero_f64();
+            for ( ; j <= len - v_float32::nlanes; j += v_float32::nlanes)
            {
-                __m128d v_result = _mm_setzero_pd();
-                for ( ; j <= len - 4; j += 4)
-                {
-                    __m128 v_src = _mm_min_ps(_mm_loadu_ps(h1 + j),
-                                              _mm_loadu_ps(h2 + j));
-                    v_result = _mm_add_pd(v_result, _mm_cvtps_pd(v_src));
-                    v_src = _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_src), 8));
-                    v_result = _mm_add_pd(v_result, _mm_cvtps_pd(v_src));
-                }
-
-                double CV_DECL_ALIGNED(16) ar[2];
-                _mm_store_pd(ar, v_result);
-                result += ar[0] + ar[1];
+                v_float32 v_src = v_min(vx_load(h1 + j), vx_load(h2 + j));
+                v_result += v_cvt_f64(v_src) + v_cvt_f64_high(v_src);
            }
-            #endif
+            result += v_reduce_sum(v_result);
+#elif CV_SIMD
+            v_float32 v_result = vx_setzero_f32();
+            for (; j <= len - v_float32::nlanes; j += v_float32::nlanes)
+            {
+                v_float32 v_src = v_min(vx_load(h1 + j), vx_load(h2 + j));
+                v_result += v_src;
+            }
+            result += v_reduce_sum(v_result);
+#endif
            for( ; j < len; j++ )
                result += std::min(h1[j], h2[j]);
        }
        else if( method == CV_COMP_BHATTACHARYYA )
        {
-            #if CV_SSE2
-            if (haveSIMD)
+#if CV_SIMD_64F
+            v_float64 v_s1 = vx_setzero_f64();
+            v_float64 v_s2 = vx_setzero_f64();
+            v_float64 v_result = vx_setzero_f64();
+            for ( ; j <= len - v_float32::nlanes; j += v_float32::nlanes)
            {
-                __m128d v_s1 = _mm_setzero_pd(), v_s2 = v_s1, v_result = v_s1;
-                for ( ; j <= len - 4; j += 4)
-                {
-                    __m128 v_a = _mm_loadu_ps(h1 + j);
-                    __m128 v_b = _mm_loadu_ps(h2 + j);
+                v_float32 v_a = vx_load(h1 + j);
+                v_float32 v_b = vx_load(h2 + j);

-                    __m128d v_ad = _mm_cvtps_pd(v_a);
-                    __m128d v_bd = _mm_cvtps_pd(v_b);
-                    v_s1 = _mm_add_pd(v_s1, v_ad);
-                    v_s2 = _mm_add_pd(v_s2, v_bd);
-                    v_result = _mm_add_pd(v_result, _mm_sqrt_pd(_mm_mul_pd(v_ad, v_bd)));
+                v_float64 v_ad = v_cvt_f64(v_a);
+                v_float64 v_bd = v_cvt_f64(v_b);
+                v_s1 += v_ad;
+                v_s2 += v_bd;
+                v_result += v_sqrt(v_ad * v_bd);

-                    v_ad = _mm_cvtps_pd(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_a), 8)));
-                    v_bd = _mm_cvtps_pd(_mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v_b), 8)));
-                    v_s1 = _mm_add_pd(v_s1, v_ad);
-                    v_s2 = _mm_add_pd(v_s2, v_bd);
-                    v_result = _mm_add_pd(v_result, _mm_sqrt_pd(_mm_mul_pd(v_ad, v_bd)));
-                }
-
-                double CV_DECL_ALIGNED(16) ar[6];
-                _mm_store_pd(ar, v_s1);
-                _mm_store_pd(ar + 2, v_s2);
-                _mm_store_pd(ar + 4, v_result);
-                s1 += ar[0] + ar[1];
-                s2 += ar[2] + ar[3];
-                result += ar[4] + ar[5];
+                v_ad = v_cvt_f64_high(v_a);
+                v_bd = v_cvt_f64_high(v_b);
+                v_s1 += v_ad;
+                v_s2 += v_bd;
+                v_result += v_sqrt(v_ad * v_bd);
            }
-            #endif
+            s1 += v_reduce_sum(v_s1);
+            s2 += v_reduce_sum(v_s2);
+            result += v_reduce_sum(v_result);
+#elif CV_SIMD && 0 //Disable vectorization for CV_COMP_BHATTACHARYYA if f64 is unsupported due to low precision
+            v_float32 v_s1 = vx_setzero_f32();
+            v_float32 v_s2 = vx_setzero_f32();
+            v_float32 v_result = vx_setzero_f32();
+            for (; j <= len - v_float32::nlanes; j += v_float32::nlanes)
+            {
+                v_float32 v_a = vx_load(h1 + j);
+                v_float32 v_b = vx_load(h2 + j);
+                v_s1 += v_a;
+                v_s2 += v_b;
+                v_result += v_sqrt(v_a * v_b);
+            }
+            s1 += v_reduce_sum(v_s1);
+            s2 += v_reduce_sum(v_s2);
+            result += v_reduce_sum(v_result);
+#endif
            for( ; j < len; j++ )
            {
                double a = h1[j];
@@ -282,10 +282,10 @@ medianBlur_8u_O1( const Mat& _src, Mat& _dst, int ksize )
                        for ( ; luc[c][k] < j+r+1; ++luc[c][k] )
                        {
 #if CV_SIMD256
-                            v_fine += v256_load(px + 16 * MIN(luc[c][k], n - 1)) - v256_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0));
+                            v_fine = v_fine + v256_load(px + 16 * MIN(luc[c][k], n - 1)) - v256_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0));
 #elif CV_SIMD128
-                            v_finel += v_load(px + 16 * MIN(luc[c][k], n - 1)    ) - v_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0));
-                            v_fineh += v_load(px + 16 * MIN(luc[c][k], n - 1) + 8) - v_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0) + 8);
+                            v_finel = v_finel + v_load(px + 16 * MIN(luc[c][k], n - 1)    ) - v_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0));
+                            v_fineh = v_fineh + v_load(px + 16 * MIN(luc[c][k], n - 1) + 8) - v_load(px + 16 * MAX(luc[c][k] - 2 * r - 1, 0) + 8);
 #else
                            for (int ind = 0; ind < 16; ++ind)
                                H[c].fine[k][ind] += px[16 * MIN(luc[c][k], n - 1) + ind] - px[16 * MAX(luc[c][k] - 2 * r - 1, 0) + ind];
@@ -321,10 +321,10 @@ medianBlur_8u_O1( const Mat& _src, Mat& _dst, int ksize )
                    CV_Assert( b < 16 );
                }
            }
-#if CV_SIMD
-            vx_cleanup();
-#endif
        }
+#if CV_SIMD
+        vx_cleanup();
+#endif
    }

 #undef HOP
@@ -439,9 +439,10 @@ __kernel void mRGBA2RGBA(__global const uchar* src, int src_step, int src_offset
                    *(__global uchar4 *)(dst + dst_index) = (uchar4)(0, 0, 0, 0);
                else
                    *(__global uchar4 *)(dst + dst_index) =
-                        (uchar4)(mad24(src_pix.x, MAX_NUM, v3_half) / v3,
-                                 mad24(src_pix.y, MAX_NUM, v3_half) / v3,
-                                 mad24(src_pix.z, MAX_NUM, v3_half) / v3, v3);
+                        (uchar4)(SAT_CAST(mad24(src_pix.x, MAX_NUM, v3_half) / v3),
+                                 SAT_CAST(mad24(src_pix.y, MAX_NUM, v3_half) / v3),
+                                 SAT_CAST(mad24(src_pix.z, MAX_NUM, v3_half) / v3),
+                                 SAT_CAST(v3));

                ++y;
                dst_index += dst_step;
@@ -2200,4 +2200,15 @@ TEST(Imgproc_Filter2D, dftFilter2d_regression_10683)

    EXPECT_LE(cvtest::norm(dst, expected, NORM_INF), 2);
 }
+
+TEST(Imgproc_MedianBlur, hires_regression_13409)
+{
+    Mat src(2048, 2048, CV_8UC1), dst_hires, dst_ref;
+    randu(src, 0, 256);
+
+    medianBlur(src, dst_hires, 9);
+    medianBlur(src(Rect(512, 512, 1024, 1024)), dst_ref, 9);
+
+    ASSERT_EQ(0.0, cvtest::norm(dst_hires(Rect(516, 516, 1016, 1016)), dst_ref(Rect(4, 4, 1016, 1016)), NORM_INF));
+}
 }} // namespace
@@ -18,6 +18,13 @@ set(depends gen_opencv_java_source "${OPENCV_DEPHELPER}/gen_opencv_java_source")
 ocv_copyfiles_add_target(${the_module}_jar_source_copy JAVA_SRC_COPY "Copy Java(JAR) source files" ${depends})
 set(depends ${the_module}_jar_source_copy "${OPENCV_DEPHELPER}/${the_module}_jar_source_copy")

+if(OPENCV_JAVA_SOURCE_VERSION)
+  set(OPENCV_ANT_JAVAC_EXTRA_ATTRS "${OPENCV_ANT_JAVAC_EXTRA_ATTRS} source=\"${OPENCV_JAVA_SOURCE_VERSION}\"")
+endif()
+if(OPENCV_JAVA_TARGET_VERSION)
+  set(OPENCV_ANT_JAVAC_EXTRA_ATTRS "${OPENCV_ANT_JAVAC_EXTRA_ATTRS} target=\"${OPENCV_JAVA_TARGET_VERSION}\"")
+endif()
+
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/build.xml.in" "${OPENCV_JAVA_DIR}/build.xml" @ONLY)
 list(APPEND depends "${OPENCV_JAVA_DIR}/build.xml")

@@ -11,7 +11,7 @@
    <!-- This is to make a jar with a source attachment, for e.g. easy -->
    <!-- navigation in Eclipse. See this question: -->
    <!-- http://stackoverflow.com/questions/3584968/ant-how-to-compile-jar-that-includes-source-attachment -->
-    <javac sourcepath="" srcdir="java" destdir="build/classes" debug="on" includeantruntime="false" >
+    <javac sourcepath="" srcdir="java" destdir="build/classes" debug="on" includeantruntime="false" @OPENCV_ANT_JAVAC_EXTRA_ATTRS@ >
      <include name="**/*.java"/>
      <compilerarg line="-encoding utf-8"/>
    </javac>
@@ -782,6 +782,9 @@ bool QRCodeDetector::detect(InputArray in, OutputArray points) const
    Mat inarr = in.getMat();
    CV_Assert(!inarr.empty());
    CV_Assert(inarr.depth() == CV_8U);
+    if (inarr.cols <= 20 || inarr.rows <= 20)
+        return false;  // image data is not enough for providing reliable results
+
    int incn = inarr.channels();
    if( incn == 3 || incn == 4 )
    {
@@ -1070,6 +1073,8 @@ cv::String QRCodeDetector::decode(InputArray in, InputArray points,
    Mat inarr = in.getMat();
    CV_Assert(!inarr.empty());
    CV_Assert(inarr.depth() == CV_8U);
+    if (inarr.cols <= 20 || inarr.rows <= 20)
+        return cv::String();  // image data is not enough for providing reliable results

    int incn = inarr.channels();
    if( incn == 3 || incn == 4 )
@@ -1108,6 +1113,8 @@ cv::String QRCodeDetector::detectAndDecode(InputArray in,
    Mat inarr = in.getMat();
    CV_Assert(!inarr.empty());
    CV_Assert(inarr.depth() == CV_8U);
+    if (inarr.cols <= 20 || inarr.rows <= 20)
+        return cv::String();  // image data is not enough for providing reliable results

    int incn = inarr.channels();
    if( incn == 3 || incn == 4 )
@@ -20,6 +20,7 @@ add_subdirectory(bindings)

 if(NOT OPENCV_SKIP_PYTHON_LOADER)
  include("./python_loader.cmake")
+  message(STATUS "OpenCV Python: during development append to PYTHONPATH: ${CMAKE_BINARY_DIR}/python_loader")
 endif()

 if(__disable_python2)
@@ -120,6 +120,21 @@ if(NOT OPENCV_SKIP_PYTHON_LOADER)
  set(__python_loader_subdir "cv2/")
 endif()

+if(NOT " ${PYTHON}" STREQUAL " PYTHON"
+    AND NOT DEFINED OPENCV_PYTHON_INSTALL_PATH
+)
+  if(DEFINED OPENCV_${PYTHON}_INSTALL_PATH)
+    set(OPENCV_PYTHON_INSTALL_PATH "${OPENCV_${PYTHON}_INSTALL_PATH}")
+  elseif(NOT OPENCV_SKIP_PYTHON_LOADER)
+    set(OPENCV_PYTHON_INSTALL_PATH "${${PYTHON}_PACKAGES_PATH}")
+  endif()
+endif()
+
+if(NOT OPENCV_SKIP_PYTHON_LOADER AND DEFINED OPENCV_PYTHON_INSTALL_PATH)
+  include("${CMAKE_CURRENT_LIST_DIR}/python_loader.cmake")
+  set(OPENCV_PYTHON_INSTALL_PATH_SETUPVARS "${OPENCV_PYTHON_INSTALL_PATH}" CACHE INTERNAL "")
+endif()
+
 if(NOT " ${PYTHON}" STREQUAL " PYTHON" AND DEFINED OPENCV_${PYTHON}_INSTALL_PATH)
  set(__python_binary_install_path "${OPENCV_${PYTHON}_INSTALL_PATH}")
 elseif(OPENCV_SKIP_PYTHON_LOADER AND DEFINED ${PYTHON}_PACKAGES_PATH)
@@ -2,20 +2,24 @@ ocv_assert(NOT OPENCV_SKIP_PYTHON_LOADER)

 set(PYTHON_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}")

-ocv_assert(DEFINED OPENCV_PYTHON_INSTALL_PATH)
 if(OpenCV_FOUND)
  set(__loader_path "${OpenCV_BINARY_DIR}/python_loader")
+  message(STATUS "OpenCV Python: during development append to PYTHONPATH: ${__loader_path}")
 else()
  set(__loader_path "${CMAKE_BINARY_DIR}/python_loader")
 endif()

 set(__python_loader_install_tmp_path "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/install/python_loader/")
-if(IS_ABSOLUTE "${OPENCV_PYTHON_INSTALL_PATH}")
-  set(OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/")
-  set(CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE "'${CMAKE_INSTALL_PREFIX}'")
+if(DEFINED OPENCV_PYTHON_INSTALL_PATH)
+  if(IS_ABSOLUTE "${OPENCV_PYTHON_INSTALL_PATH}")
+    set(OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/")
+    set(CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE "'${CMAKE_INSTALL_PREFIX}'")
+  else()
+    file(RELATIVE_PATH OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/${OPENCV_PYTHON_INSTALL_PATH}/cv2" ${CMAKE_INSTALL_PREFIX})
+    set(CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE "os.path.join(LOADER_DIR, '${OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE}')")
+  endif()
 else()
-  file(RELATIVE_PATH OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE "${CMAKE_INSTALL_PREFIX}/${OPENCV_PYTHON_INSTALL_PATH}/cv2" ${CMAKE_INSTALL_PREFIX})
-  set(CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE "os.path.join(LOADER_DIR, '${OpenCV_PYTHON_INSTALL_PATH_RELATIVE_CONFIGCMAKE}')")
+  set(CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE "os.path.join(LOADER_DIR, 'not_installed')")
 endif()

 set(PYTHON_LOADER_FILES
@@ -25,7 +29,13 @@ set(PYTHON_LOADER_FILES
 foreach(fname ${PYTHON_LOADER_FILES})
  get_filename_component(__dir "${fname}" DIRECTORY)
  file(COPY "${PYTHON_SOURCE_DIR}/package/${fname}" DESTINATION "${__loader_path}/${__dir}")
-  install(FILES "${PYTHON_SOURCE_DIR}/package/${fname}" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/${__dir}" COMPONENT python)
+  if(fname STREQUAL "setup.py")
+    if(OPENCV_PYTHON_SETUP_PY_INSTALL_PATH)
+      install(FILES "${PYTHON_SOURCE_DIR}/package/${fname}" DESTINATION "${OPENCV_PYTHON_SETUP_PY_INSTALL_PATH}" COMPONENT python)
+    endif()
+  elseif(DEFINED OPENCV_PYTHON_INSTALL_PATH)
+    install(FILES "${PYTHON_SOURCE_DIR}/package/${fname}" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/${__dir}" COMPONENT python)
+  endif()
 endforeach()

 if(NOT OpenCV_FOUND)  # Ignore "standalone" builds of Python bindings
@@ -41,14 +51,15 @@ if(NOT OpenCV_FOUND)  # Ignore "standalone" builds of Python bindings
  string(REPLACE ";" ",\n    " CMAKE_PYTHON_BINARIES_PATH "${CMAKE_PYTHON_BINARIES_PATH}")
  configure_file("${PYTHON_SOURCE_DIR}/package/template/config.py.in" "${__loader_path}/cv2/config.py" @ONLY)

-  if(WIN32)
-    list(APPEND CMAKE_PYTHON_BINARIES_INSTALL_PATH "os.path.join(${CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE}, '${OPENCV_BIN_INSTALL_PATH}')")
-  else()
-    list(APPEND CMAKE_PYTHON_BINARIES_INSTALL_PATH "os.path.join(${CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE}, '${OPENCV_LIB_INSTALL_PATH}')")
+  # install
+  if(DEFINED OPENCV_PYTHON_INSTALL_PATH)
+    if(WIN32)
+      list(APPEND CMAKE_PYTHON_BINARIES_INSTALL_PATH "os.path.join(${CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE}, '${OPENCV_BIN_INSTALL_PATH}')")
+    else()
+      list(APPEND CMAKE_PYTHON_BINARIES_INSTALL_PATH "os.path.join(${CMAKE_PYTHON_EXTENSION_INSTALL_PATH_BASE}, '${OPENCV_LIB_INSTALL_PATH}')")
+    endif()
+    string(REPLACE ";" ",\n    " CMAKE_PYTHON_BINARIES_PATH "${CMAKE_PYTHON_BINARIES_INSTALL_PATH}")
+    configure_file("${PYTHON_SOURCE_DIR}/package/template/config.py.in" "${__python_loader_install_tmp_path}/cv2/config.py" @ONLY)
+    install(FILES "${__python_loader_install_tmp_path}/cv2/config.py" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/cv2/" COMPONENT python)
  endif()
-  string(REPLACE ";" ",\n    " CMAKE_PYTHON_BINARIES_PATH "${CMAKE_PYTHON_BINARIES_INSTALL_PATH}")
-  configure_file("${PYTHON_SOURCE_DIR}/package/template/config.py.in" "${__python_loader_install_tmp_path}/cv2/config.py" @ONLY)
-  install(FILES "${__python_loader_install_tmp_path}/cv2/config.py" DESTINATION "${OPENCV_PYTHON_INSTALL_PATH}/cv2/" COMPONENT python)
-
-  message(STATUS "OpenCV Python: during development append to PYTHONPATH: ${__loader_path}")
 endif()
@@ -3,7 +3,13 @@ if(NOT DEFINED OpenCV_BINARY_DIR)
 endif()
 include("${OpenCV_BINARY_DIR}/opencv_python_config.cmake")
 if(NOT DEFINED OpenCV_SOURCE_DIR)
-  message(FATAL_ERROR "Missing define of OpenCV_SOURCE_DIR")
+  message(FATAL_ERROR "Missing OpenCV_SOURCE_DIR")
+endif()
+if(NOT OPENCV_PYTHON_INSTALL_PATH)
+  if(NOT DEFINED OPENCV_PYTHON_STANDALONE_INSTALL_PATH)
+    message(FATAL_ERROR "Missing OPENCV_PYTHON_STANDALONE_INSTALL_PATH / OPENCV_PYTHON_INSTALL_PATH")
+  endif()
+  set(OPENCV_PYTHON_INSTALL_PATH "${OPENCV_PYTHON_STANDALONE_INSTALL_PATH}")
 endif()

 include("${OpenCV_SOURCE_DIR}/cmake/OpenCVUtils.cmake")
@@ -13,6 +13,7 @@ using namespace perf;
 #define WORK_MEGAPIX 0.6

 typedef TestBaseWithParam<string> stitch;
+typedef TestBaseWithParam<int> stitchExposureCompensation;
 typedef TestBaseWithParam<tuple<string, string> > stitchDatasets;

 #ifdef HAVE_OPENCV_XFEATURES2D
@@ -20,6 +21,7 @@ typedef TestBaseWithParam<tuple<string, string> > stitchDatasets;
 #else
 #define TEST_DETECTORS testing::Values("orb", "akaze")
 #endif
+#define TEST_EXP_COMP_BS testing::Values(32, 16, 12, 10, 8)
 #define AFFINE_DATASETS testing::Values("s", "budapest", "newspaper", "prague")

 PERF_TEST_P(stitch, a123, TEST_DETECTORS)
@@ -58,6 +60,38 @@ PERF_TEST_P(stitch, a123, TEST_DETECTORS)
    SANITY_CHECK_NOTHING();
 }

+PERF_TEST_P(stitchExposureCompensation, a123, TEST_EXP_COMP_BS)
+{
+    Mat pano;
+
+    vector<Mat> imgs;
+    imgs.push_back( imread( getDataPath("stitching/a1.png") ) );
+    imgs.push_back( imread( getDataPath("stitching/a2.png") ) );
+    imgs.push_back( imread( getDataPath("stitching/a3.png") ) );
+
+    int bs = GetParam();
+
+    declare.time(30 * 10).iterations(10);
+
+    while(next())
+    {
+        Ptr<Stitcher> stitcher = Stitcher::create();
+        stitcher->setWarper(makePtr<SphericalWarper>());
+        stitcher->setRegistrationResol(WORK_MEGAPIX);
+        stitcher->setExposureCompensator(
+            makePtr<detail::BlocksGainCompensator>(bs, bs));
+
+        startTimer();
+        stitcher->stitch(imgs, pano);
+        stopTimer();
+    }
+
+    EXPECT_NEAR(pano.size().width, 1182, 50);
+    EXPECT_NEAR(pano.size().height, 682, 30);
+
+    SANITY_CHECK_NOTHING();
+}
+
 PERF_TEST_P(stitch, b12, TEST_DETECTORS)
 {
    Mat pano;
@@ -41,6 +41,10 @@
 //M*/

 #include "precomp.hpp"
+#ifdef HAVE_EIGEN
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#endif

 namespace cv {
 namespace detail {
@@ -80,6 +84,7 @@ void GainCompensator::feed(const std::vector<Point> &corners, const std::vector<
    const int num_images = static_cast<int>(images.size());
    Mat_<int> N(num_images, num_images); N.setTo(0);
    Mat_<double> I(num_images, num_images); I.setTo(0);
+    Mat_<bool> skip(num_images, 1); skip.setTo(true);

    //Rect dst_roi = resultRoi(corners, images);
    Mat subimg1, subimg2;
@@ -99,7 +104,19 @@ void GainCompensator::feed(const std::vector<Point> &corners, const std::vector<
                submask2 = masks[j].first(Rect(roi.tl() - corners[j], roi.br() - corners[j])).getMat(ACCESS_READ);
                intersect = (submask1 == masks[i].second) & (submask2 == masks[j].second);

-                N(i, j) = N(j, i) = std::max(1, countNonZero(intersect));
+                int intersect_count = countNonZero(intersect);
+                N(i, j) = N(j, i) = std::max(1, intersect_count);
+
+                // Don't compute Isums if subimages do not intersect anyway
+                if (intersect_count == 0)
+                    continue;
+
+                // Don't skip images that intersect with at least one other image
+                if (i != j)
+                {
+                    skip(i, 0) = false;
+                    skip(j, 0) = false;
+                }

                double Isum1 = 0, Isum2 = 0;
                for (int y = 0; y < roi.height; ++y)
@@ -123,22 +140,62 @@ void GainCompensator::feed(const std::vector<Point> &corners, const std::vector<

    double alpha = 0.01;
    double beta = 100;
+    int num_eq = num_images - countNonZero(skip);

-    Mat_<double> A(num_images, num_images); A.setTo(0);
-    Mat_<double> b(num_images, 1); b.setTo(0);
-    for (int i = 0; i < num_images; ++i)
+    Mat_<double> A(num_eq, num_eq); A.setTo(0);
+    Mat_<double> b(num_eq, 1); b.setTo(0);
+    for (int i = 0, ki = 0; i < num_images; ++i)
    {
-        for (int j = 0; j < num_images; ++j)
+        if (skip(i, 0))
+            continue;
+
+        for (int j = 0, kj = 0; j < num_images; ++j)
        {
-            b(i, 0) += beta * N(i, j);
-            A(i, i) += beta * N(i, j);
-            if (j == i) continue;
-            A(i, i) += 2 * alpha * I(i, j) * I(i, j) * N(i, j);
-            A(i, j) -= 2 * alpha * I(i, j) * I(j, i) * N(i, j);
+            if (skip(j, 0))
+                continue;
+
+            b(ki, 0) += beta * N(i, j);
+            A(ki, ki) += beta * N(i, j);
+            if (j != i)
+            {
+                A(ki, ki) += 2 * alpha * I(i, j) * I(i, j) * N(i, j);
+                A(ki, kj) -= 2 * alpha * I(i, j) * I(j, i) * N(i, j);
+            }
+            ++kj;
        }
+        ++ki;
    }

-    solve(A, b, gains_);
+    Mat_<double> l_gains;
+
+#ifdef HAVE_EIGEN
+    Eigen::MatrixXf eigen_A, eigen_b, eigen_x;
+    cv2eigen(A, eigen_A);
+    cv2eigen(b, eigen_b);
+
+    Eigen::LLT<Eigen::MatrixXf> solver(eigen_A);
+#if ENABLE_LOG
+    if (solver.info() != Eigen::ComputationInfo::Success)
+        LOGLN("Failed to solve exposure compensation system");
+#endif
+    eigen_x = solver.solve(eigen_b);
+
+    Mat_<float> l_gains_float;
+    eigen2cv(eigen_x, l_gains_float);
+    l_gains_float.convertTo(l_gains, CV_64FC1);
+#else
+    solve(A, b, l_gains);
+#endif
+    CV_CheckTypeEQ(l_gains.type(), CV_64FC1, "");
+
+    gains_.create(num_images, 1);
+    for (int i = 0, j = 0; i < num_images; ++i)
+    {
+        if (skip(i, 0))
+            gains_.at<double>(i, 0) = 1;
+        else
+            gains_.at<double>(i, 0) = l_gains(j++, 0);
+    }

    LOGLN("Exposure compensation, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 }
@@ -85,11 +85,11 @@ if (WIN32 AND HAVE_DSHOW)
  endif()
 endif()

-if (WIN32 AND HAVE_MSMF)
+if(WIN32 AND HAVE_MSMF)
  list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_msmf.hpp)
  list(APPEND videoio_srcs ${CMAKE_CURRENT_LIST_DIR}/src/cap_msmf.cpp)
-  if (HAVE_DXVA)
-    add_definitions(-DHAVE_DXVA)
+  if(HAVE_MSMF_DXVA)
+    add_definitions(-DHAVE_MSMF_DXVA)
  endif()
 endif()

@@ -192,7 +192,11 @@ CvDC1394::~CvDC1394()
    dc = 0;
 }

-static CvDC1394 dc1394;
+static CvDC1394& getDC1394()
+{
+    static CvDC1394 dc1394;
+    return dc1394;
+}

 class CvCaptureCAM_DC1394_v2_CPP : public CvCapture
 {
@@ -451,7 +455,7 @@ bool CvCaptureCAM_DC1394_v2_CPP::startCapture()
    code = dc1394_capture_setup(dcCam, nDMABufs, DC1394_CAPTURE_FLAGS_DEFAULT);
    if (code >= 0)
    {
-        FD_SET(dc1394_capture_get_fileno(dcCam), &dc1394.camFds);
+        FD_SET(dc1394_capture_get_fileno(dcCam), &getDC1394().camFds);
        dc1394_video_set_transmission(dcCam, DC1394_ON);
        if (cameraId == VIDERE)
        {
@@ -477,15 +481,15 @@ bool CvCaptureCAM_DC1394_v2_CPP::open(int index)

    close();

-    if (!dc1394.dc)
+    if (!getDC1394().dc)
        goto _exit_;

-    err = dc1394_camera_enumerate(dc1394.dc, &cameraList);
+    err = dc1394_camera_enumerate(getDC1394().dc, &cameraList);
    if (err < 0 || !cameraList || (unsigned)index >= (unsigned)cameraList->num)
        goto _exit_;

    guid = cameraList->ids[index].guid;
-    dcCam = dc1394_camera_new(dc1394.dc, guid);
+    dcCam = dc1394_camera_new(getDC1394().dc, guid);
    if (!dcCam)
        goto _exit_;

@@ -510,8 +514,8 @@ void CvCaptureCAM_DC1394_v2_CPP::close()
        // check for fileno valid before using
        int fileno=dc1394_capture_get_fileno(dcCam);

-        if (fileno>=0 && FD_ISSET(fileno, &dc1394.camFds))
-            FD_CLR(fileno, &dc1394.camFds);
+        if (fileno>=0 && FD_ISSET(fileno, &getDC1394().camFds))
+            FD_CLR(fileno, &getDC1394().camFds);
        dc1394_video_set_transmission(dcCam, DC1394_OFF);
        dc1394_capture_stop(dcCam);
        dc1394_camera_free(dcCam);
@@ -55,15 +55,15 @@
 #include <windows.h>
 #include <guiddef.h>
 #include <mfidl.h>
-#include <Mfapi.h>
+#include <mfapi.h>
 #include <mfplay.h>
 #include <mfobjects.h>
 #include <tchar.h>
 #include <strsafe.h>
 #include <Mfreadwrite.h>
-#ifdef HAVE_DXVA
-#include <D3D11.h>
-#include <D3d11_4.h>
+#ifdef HAVE_MSMF_DXVA
+#include <d3d11.h>
+#include <d3d11_4.h>
 #endif
 #include <new>
 #include <map>
@@ -81,7 +81,7 @@
 #pragma comment(lib, "mfuuid")
 #pragma comment(lib, "Strmiids")
 #pragma comment(lib, "Mfreadwrite")
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
 #pragma comment(lib, "d3d11")
 // MFCreateDXGIDeviceManager() is available since Win8 only.
 // To avoid OpenCV loading failure on Win7 use dynamic detection of this symbol.
@@ -99,9 +99,7 @@ static void init_MFCreateDXGIDeviceManager()
    pMFCreateDXGIDeviceManager_initialized = true;
 }
 #endif
-#if (WINVER >= 0x0602) // Available since Win 8
-#pragma comment(lib, "MinCore_Downlevel")
-#endif
+#pragma comment(lib, "Shlwapi.lib")
 #endif

 #include <mferror.h>
@@ -712,7 +710,7 @@ protected:
    cv::String filename;
    int camid;
    MSMFCapture_Mode captureMode;
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
    _ComPtr<ID3D11Device> D3DDev;
    _ComPtr<IMFDXGIDeviceManager> D3DMgr;
 #endif
@@ -737,7 +735,7 @@ CvCapture_MSMF::CvCapture_MSMF():
    filename(""),
    camid(-1),
    captureMode(MODE_SW),
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
    D3DDev(NULL),
    D3DMgr(NULL),
 #endif
@@ -776,7 +774,7 @@ void CvCapture_MSMF::close()

 bool CvCapture_MSMF::configureHW(bool enable)
 {
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
    if ((enable && D3DMgr && D3DDev) || (!enable && !D3DMgr && !D3DDev))
        return true;
    if (!pMFCreateDXGIDeviceManager_initialized)
@@ -973,7 +971,7 @@ bool CvCapture_MSMF::open(int _index)
                            SUCCEEDED(srAttr->SetUINT32(MF_SOURCE_READER_ENABLE_VIDEO_PROCESSING, FALSE)) &&
                            SUCCEEDED(srAttr->SetUINT32(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING, TRUE)))
                        {
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
                            if (D3DMgr)
                                srAttr->SetUnknown(MF_SOURCE_READER_D3D_MANAGER, D3DMgr.Get());
 #endif
@@ -1024,7 +1022,7 @@ bool CvCapture_MSMF::open(const cv::String& _filename)
        SUCCEEDED(srAttr->SetUINT32(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING, true))
        )
    {
-#ifdef HAVE_DXVA
+#ifdef HAVE_MSMF_DXVA
        if(D3DMgr)
            srAttr->SetUnknown(MF_SOURCE_READER_D3D_MANAGER, D3DMgr.Get());
 #endif
@@ -237,6 +237,11 @@ make & enjoy!
 #include <sys/videoio.h>
 #endif

+// https://github.com/opencv/opencv/issues/13335
+#ifndef V4L2_CID_ISO_SENSITIVITY
+#define V4L2_CID_ISO_SENSITIVITY (V4L2_CID_CAMERA_CLASS_BASE+23)
+#endif
+
 /* Defaults - If your board can do better, set it here.  Set for the most common type inputs. */
 #define DEFAULT_V4L_WIDTH  640
 #define DEFAULT_V4L_HEIGHT 480
@@ -1757,7 +1762,7 @@ bool CvCaptureCAM_V4L::icvSetFrameSize(int _width, int _height)
    if (_width > 0)
        width_set = _width;

-    if (height > 0)
+    if (_height > 0)
        height_set = _height;

    /* two subsequent calls setting WIDTH and HEIGHT will change
@@ -11,7 +11,7 @@

 namespace opencv_test { namespace {

-static void test_readFrames(/*const*/ VideoCapture& capture, const int N = 100)
+static void test_readFrames(/*const*/ VideoCapture& capture, const int N = 100, Mat* lastFrame = NULL)
 {
    Mat frame;
    int64 time0 = cv::getTickCount();
@@ -26,6 +26,7 @@ static void test_readFrames(/*const*/ VideoCapture& capture, const int N = 100)
    }
    int64 time1 = cv::getTickCount();
    printf("Processed %d frames on %.2f FPS\n", N, (N * cv::getTickFrequency()) / (time1 - time0 + 1));
+    if (lastFrame) *lastFrame = frame.clone();
 }

 TEST(DISABLED_VideoIO_Camera, basic)
@@ -55,4 +56,39 @@ TEST(DISABLED_VideoIO_Camera, validate_V4L2_MJPEG)
    capture.release();
 }

+TEST(DISABLED_VideoIO_Camera, validate_V4L2_FrameSize)
+{
+    VideoCapture capture(CAP_V4L2);
+    ASSERT_TRUE(capture.isOpened());
+    std::cout << "Camera 0 via " << capture.getBackendName() << " backend" << std::endl;
+    std::cout << "Frame width: " << capture.get(CAP_PROP_FRAME_WIDTH) << std::endl;
+    std::cout << "     height: " << capture.get(CAP_PROP_FRAME_HEIGHT) << std::endl;
+    std::cout << "Capturing FPS: " << capture.get(CAP_PROP_FPS) << std::endl;
+    int fourcc = (int)capture.get(CAP_PROP_FOURCC);
+    std::cout << "FOURCC code: " << cv::format("0x%8x", fourcc) << std::endl;
+    test_readFrames(capture, 30);
+
+    EXPECT_TRUE(capture.set(CAP_PROP_FRAME_WIDTH, 640));
+    EXPECT_TRUE(capture.set(CAP_PROP_FRAME_HEIGHT, 480));
+    std::cout << "Frame width: " << capture.get(CAP_PROP_FRAME_WIDTH) << std::endl;
+    std::cout << "     height: " << capture.get(CAP_PROP_FRAME_HEIGHT) << std::endl;
+    std::cout << "Capturing FPS: " << capture.get(CAP_PROP_FPS) << std::endl;
+    Mat frame640x480;
+    test_readFrames(capture, 30, &frame640x480);
+    EXPECT_EQ(640, frame640x480.cols);
+    EXPECT_EQ(480, frame640x480.rows);
+
+    EXPECT_TRUE(capture.set(CAP_PROP_FRAME_WIDTH, 1280));
+    EXPECT_TRUE(capture.set(CAP_PROP_FRAME_HEIGHT, 720));
+    std::cout << "Frame width: " << capture.get(CAP_PROP_FRAME_WIDTH) << std::endl;
+    std::cout << "     height: " << capture.get(CAP_PROP_FRAME_HEIGHT) << std::endl;
+    std::cout << "Capturing FPS: " << capture.get(CAP_PROP_FPS) << std::endl;
+    Mat frame1280x720;
+    test_readFrames(capture, 30, &frame1280x720);
+    EXPECT_EQ(1280, frame1280x720.cols);
+    EXPECT_EQ(720, frame1280x720.rows);
+
+    capture.release();
+}
+
 }} // namespace
@@ -210,7 +210,7 @@ class Builder:
        # Add extra data
        apkxmldest = check_dir(os.path.join(apkdest, "res", "xml"), create=True)
        apklibdest = check_dir(os.path.join(apkdest, "libs", abi.name), create=True)
-        for ver, d in self.extra_packs + [("3.4.4", os.path.join(self.libdest, "lib"))]:
+        for ver, d in self.extra_packs + [("3.4.5", os.path.join(self.libdest, "lib"))]:
            r = ET.Element("library", attrib={"version": ver})
            log.info("Adding libraries from %s", d)

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="org.opencv.engine"
-    android:versionCode="344@ANDROID_PLATFORM_ID@"
-    android:versionName="3.44">
+    android:versionCode="345@ANDROID_PLATFORM_ID@"
+    android:versionName="3.45">

    <uses-sdk android:minSdkVersion="@ANDROID_NATIVE_API_LEVEL@" android:targetSdkVersion="22"/>
    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>
@@ -137,7 +137,7 @@ public class OpenCVEngineService extends Service {

            @Override
            public int getEngineVersion() throws RemoteException {
-                int version = 3440;
+                int version = 3450;
                try {
                    version = getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;
                } catch (NameNotFoundException e) {
@@ -12,7 +12,7 @@ manually using adb tool:

    adb install <path-to-OpenCV-sdk>/apk/OpenCV_<version>_Manager_<app_version>_<platform>.apk

-Example: OpenCV_3.4.4-dev_Manager_3.44_armeabi-v7a.apk
+Example: OpenCV_3.4.5-dev_Manager_3.45_armeabi-v7a.apk

 Use the list of platforms below to determine proper OpenCV Manager package for your device:

@@ -49,7 +49,7 @@ def getXCodeMajor():
        raise Exception("Failed to parse Xcode version")

 class Builder:
-    def __init__(self, opencv, contrib, dynamic, bitcodedisabled, exclude, targets):
+    def __init__(self, opencv, contrib, dynamic, bitcodedisabled, exclude, enablenonfree, targets):
        self.opencv = os.path.abspath(opencv)
        self.contrib = None
        if contrib:
@@ -61,6 +61,7 @@ class Builder:
        self.dynamic = dynamic
        self.bitcodedisabled = bitcodedisabled
        self.exclude = exclude
+        self.enablenonfree = enablenonfree
        self.targets = targets

    def getBD(self, parent, t):
@@ -136,7 +137,9 @@ class Builder:
            "-DBUILD_SHARED_LIBS=ON",
            "-DCMAKE_MACOSX_BUNDLE=ON",
            "-DCMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED=NO",
-        ] if self.dynamic else [])
+        ] if self.dynamic else []) + ([
+            "-DOPENCV_ENABLE_NONFREE=ON"
+        ] if self.enablenonfree else [])

        if len(self.exclude) > 0:
            args += ["-DBUILD_opencv_world=OFF"] if not self.dynamic else []
@@ -284,6 +287,7 @@ if __name__ == "__main__":
    parser.add_argument('--iphoneos_deployment_target', default=os.environ.get('IPHONEOS_DEPLOYMENT_TARGET', IPHONEOS_DEPLOYMENT_TARGET), help='specify IPHONEOS_DEPLOYMENT_TARGET')
    parser.add_argument('--iphoneos_archs', default='armv7,armv7s,arm64', help='select iPhoneOS target ARCHS')
    parser.add_argument('--iphonesimulator_archs', default='i386,x86_64', help='select iPhoneSimulator target ARCHS')
+    parser.add_argument('--enable_nonfree', default=False, dest='enablenonfree', action='store_true', help='enable non-free modules (disabled by default)')
    args = parser.parse_args()

    os.environ['IPHONEOS_DEPLOYMENT_TARGET'] = args.iphoneos_deployment_target
@@ -293,7 +297,7 @@ if __name__ == "__main__":
    iphonesimulator_archs = args.iphonesimulator_archs.split(',')
    print('Using iPhoneSimulator ARCHS=' + str(iphonesimulator_archs))

-    b = iOSBuilder(args.opencv, args.contrib, args.dynamic, args.bitcodedisabled, args.without,
+    b = iOSBuilder(args.opencv, args.contrib, args.dynamic, args.bitcodedisabled, args.without, args.enablenonfree,
        [
            (iphoneos_archs, "iPhoneOS"),
        ] if os.environ.get('BUILD_PRECOMMIT', None) else
@@ -4,7 +4,7 @@
    <parent>
        <groupId>org.opencv</groupId>
        <artifactId>opencv-parent</artifactId>
-        <version>3.4.4</version>
+        <version>3.4.5</version>
    </parent>
    <groupId>org.opencv</groupId>
    <artifactId>opencv-it</artifactId>
@@ -4,7 +4,7 @@
    <parent>
        <groupId>org.opencv</groupId>
        <artifactId>opencv-parent</artifactId>
-        <version>3.4.4</version>
+        <version>3.4.5</version>
    </parent>
    <groupId>org.opencv</groupId>
    <artifactId>opencv</artifactId>
@@ -3,7 +3,7 @@
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.opencv</groupId>
    <artifactId>opencv-parent</artifactId>
-    <version>3.4.4</version>
+    <version>3.4.5</version>
    <packaging>pom</packaging>
    <name>OpenCV Parent POM</name>
    <licenses>
@@ -38,9 +38,10 @@ if __name__ == "__main__":
    parser.add_argument('--opencv', metavar='DIR', default=folder, help='folder with opencv repository (default is "../.." relative to script location)')
    parser.add_argument('--contrib', metavar='DIR', default=None, help='folder with opencv_contrib repository (default is "None" - build only main framework)')
    parser.add_argument('--without', metavar='MODULE', default=[], action='append', help='OpenCV modules to exclude from the framework')
+    parser.add_argument('--enable_nonfree', default=False, dest='enablenonfree', action='store_true', help='enable non-free modules (disabled by default)')
    args = parser.parse_args()

-    b = OSXBuilder(args.opencv, args.contrib, False, False, args.without,
+    b = OSXBuilder(args.opencv, args.contrib, False, False, args.without, args.enablenonfree,
        [
            (["x86_64"], "MacOSX")
        ])
@@ -0,0 +1,146 @@
+# Import required modules
+import cv2 as cv
+import math
+import argparse
+
+############ Add argument parser for command line arguments ############
+parser = argparse.ArgumentParser(description='Use this script to run TensorFlow implementation (https://github.com/argman/EAST) of EAST: An Efficient and Accurate Scene Text Detector (https://arxiv.org/abs/1704.03155v2)')
+parser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')
+parser.add_argument('--model', required=True,
+                    help='Path to a binary .pb file of model contains trained weights.')
+parser.add_argument('--width', type=int, default=320,
+                    help='Preprocess input image by resizing to a specific width. It should be multiple by 32.')
+parser.add_argument('--height',type=int, default=320,
+                    help='Preprocess input image by resizing to a specific height. It should be multiple by 32.')
+parser.add_argument('--thr',type=float, default=0.5,
+                    help='Confidence threshold.')
+parser.add_argument('--nms',type=float, default=0.4,
+                    help='Non-maximum suppression threshold.')
+args = parser.parse_args()
+
+############ Utility functions ############
+def decode(scores, geometry, scoreThresh):
+    detections = []
+    confidences = []
+
+    ############ CHECK DIMENSIONS AND SHAPES OF geometry AND scores ############
+    assert len(scores.shape) == 4, "Incorrect dimensions of scores"
+    assert len(geometry.shape) == 4, "Incorrect dimensions of geometry"
+    assert scores.shape[0] == 1, "Invalid dimensions of scores"
+    assert geometry.shape[0] == 1, "Invalid dimensions of geometry"
+    assert scores.shape[1] == 1, "Invalid dimensions of scores"
+    assert geometry.shape[1] == 5, "Invalid dimensions of geometry"
+    assert scores.shape[2] == geometry.shape[2], "Invalid dimensions of scores and geometry"
+    assert scores.shape[3] == geometry.shape[3], "Invalid dimensions of scores and geometry"
+    height = scores.shape[2]
+    width = scores.shape[3]
+    for y in range(0, height):
+
+        # Extract data from scores
+        scoresData = scores[0][0][y]
+        x0_data = geometry[0][0][y]
+        x1_data = geometry[0][1][y]
+        x2_data = geometry[0][2][y]
+        x3_data = geometry[0][3][y]
+        anglesData = geometry[0][4][y]
+        for x in range(0, width):
+            score = scoresData[x]
+
+            # If score is lower than threshold score, move to next x
+            if(score < scoreThresh):
+                continue
+
+            # Calculate offset
+            offsetX = x * 4.0
+            offsetY = y * 4.0
+            angle = anglesData[x]
+
+            # Calculate cos and sin of angle
+            cosA = math.cos(angle)
+            sinA = math.sin(angle)
+            h = x0_data[x] + x2_data[x]
+            w = x1_data[x] + x3_data[x]
+
+            # Calculate offset
+            offset = ([offsetX + cosA * x1_data[x] + sinA * x2_data[x], offsetY - sinA * x1_data[x] + cosA * x2_data[x]])
+
+            # Find points for rectangle
+            p1 = (-sinA * h + offset[0], -cosA * h + offset[1])
+            p3 = (-cosA * w + offset[0],  sinA * w + offset[1])
+            center = (0.5*(p1[0]+p3[0]), 0.5*(p1[1]+p3[1]))
+            detections.append((center, (w,h), -1*angle * 180.0 / math.pi))
+            confidences.append(float(score))
+
+    # Return detections and confidences
+    return [detections, confidences]
+
+def main():
+    # Read and store arguments
+    confThreshold = args.thr
+    nmsThreshold = args.nms
+    inpWidth = args.width
+    inpHeight = args.height
+    model = args.model
+
+    # Load network
+    net = cv.dnn.readNet(model)
+
+    # Create a new named window
+    kWinName = "EAST: An Efficient and Accurate Scene Text Detector"
+    cv.namedWindow(kWinName, cv.WINDOW_NORMAL)
+    outNames = []
+    outNames.append("feature_fusion/Conv_7/Sigmoid")
+    outNames.append("feature_fusion/concat_3")
+
+    # Open a video file or an image file or a camera stream
+    cap = cv.VideoCapture(args.input if args.input else 0)
+
+    while cv.waitKey(1) < 0:
+        # Read frame
+        hasFrame, frame = cap.read()
+        if not hasFrame:
+            cv.waitKey()
+            break
+
+        # Get frame height and width
+        height_ = frame.shape[0]
+        width_ = frame.shape[1]
+        rW = width_ / float(inpWidth)
+        rH = height_ / float(inpHeight)
+
+        # Create a 4D blob from frame.
+        blob = cv.dnn.blobFromImage(frame, 1.0, (inpWidth, inpHeight), (123.68, 116.78, 103.94), True, False)
+
+        # Run the model
+        net.setInput(blob)
+        outs = net.forward(outNames)
+        t, _ = net.getPerfProfile()
+        label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())
+
+        # Get scores and geometry
+        scores = outs[0]
+        geometry = outs[1]
+        [boxes, confidences] = decode(scores, geometry, confThreshold)
+
+        # Apply NMS
+        indices = cv.dnn.NMSBoxesRotated(boxes, confidences, confThreshold,nmsThreshold)
+        for i in indices:
+            # get 4 corners of the rotated rect
+            vertices = cv.boxPoints(boxes[i[0]])
+            # scale the bounding box coordinates based on the respective ratios
+            for j in range(4):
+                vertices[j][0] *= rW
+                vertices[j][1] *= rH
+            for j in range(4):
+                p1 = (vertices[j][0], vertices[j][1])
+                p2 = (vertices[(j + 1) % 4][0], vertices[(j + 1) % 4][1])
+                cv.line(frame, p1, p2, (0, 255, 0), 1);
+
+        # Put efficiency information
+        cv.putText(frame, label, (0, 15), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0))
+
+        # Display the frame
+        cv.imshow(kWinName,frame)
+
+if __name__ == "__main__":
+    main()
Author	SHA1	Message	Date
Alexander Alekhin	8f1356c3c5	OpenCV version++ (3.4.5) OpenCV 3.4.5	2018-12-21 17:31:20 +03:00
Alexander Alekhin	14633bc857	Merge pull request #13497 from dkurt:dnn_torch_bn_train	2018-12-21 14:29:10 +00:00
Alexander Alekhin	2bba0f297b	Merge pull request #13493 from dkurt:dnn_ie_r5	2018-12-21 12:18:23 +00:00
Alexander Alekhin	6c1638b132	Merge pull request #13487 from alalek:videoio_test_frame_size_changing	2018-12-21 12:17:06 +00:00
Alexander Alekhin	1a6c2b37ea	Merge pull request #13499 from alalek:issue_13498	2018-12-21 12:15:59 +00:00
Dmitry Kurtaev	840c892abd	Batch normalization in training phase from Torch	2018-12-21 14:36:55 +03:00
Alexander Alekhin	09d8bbb138	Merge pull request #13467 from alalek:issue_12594	2018-12-21 11:01:25 +00:00
Alexander Alekhin	832217907f	Merge pull request #13435 from alalek:issue_13434	2018-12-21 11:01:04 +00:00
Alexander Alekhin	26c5b846e6	Merge pull request #13392 from terfendail:filter_wintr	2018-12-21 11:00:44 +00:00
Dmitry Kurtaev	59ce1d80a5	Fix dnn tests for Inference Engine R5	2018-12-21 12:33:30 +03:00
Alexander Alekhin	2f3e06ac1f	objdetect(qrcode): don't process small/non-regular images	2018-12-21 12:19:35 +03:00
Alexander Alekhin	37a63ca02b	Merge pull request #13488 from alalek:fix_videoio_v4l2_build	2018-12-21 09:07:38 +00:00
Alexander Alekhin	0d63bd575c	Merge pull request #13489 from alalek:openvino_2018r5	2018-12-21 10:05:04 +03:00
Dmitry Kurtaev	257f60582a	Add serialize method for IE net wrapper backport `4ba4901ca9`	2018-12-21 05:52:27 +00:00
Alexander Alekhin	bbdc987fc6	dnn: add OpenVINO 2018R5 defines https://software.intel.com/en-us/openvino-toolkit	2018-12-21 05:52:27 +00:00
Vitaly Tuzov	124011c321	Speedup filter2d by loop unrolling	2018-12-20 21:18:42 +03:00
Alexander Alekhin	8456d096d2	videoio(v4l2): fix build due missing V4L2_CID_ISO_SENSITIVITY	2018-12-20 16:28:12 +03:00
Alexander Alekhin	32c975b533	Merge pull request #13484 from va-sorokin:fix-v4l-size	2018-12-20 12:55:41 +00:00
Alexander Alekhin	a3a3670027	videoio(test): test V4L frame size changing manual test	2018-12-20 15:14:20 +03:00
Vasiliy Sorokin	b6a72826dd	videio: Fix new frame size appling in v4l.	2018-12-20 14:59:39 +03:00
Alexander Alekhin	3d5cebb3ac	Merge pull request #13478 from terfendail:medianblur_fix	2018-12-19 16:03:55 +00:00
Vitaly Tuzov	131c09cf76	Fixed medianBlur implementation for hi-resolution images	2018-12-19 18:05:42 +03:00
Vitaly Tuzov	06f32e3b3e	Reworked separable filter to use wide universal intrinsics	2018-12-19 17:50:09 +03:00
Alexander Alekhin	b0a08cced9	Merge pull request #13466 from pstieber:AddTuringCudaGeneration	2018-12-18 18:35:47 +00:00
Alexander Alekhin	82b7803a7a	Merge pull request #13456 from alalek:fix_eigen2cv_type_check	2018-12-18 18:35:27 +00:00
Peter J. Stieber	50ef9830e2	Added Turing to the _generations list.	2018-12-18 08:52:15 -08:00
Alexander Alekhin	8ed4fb9405	Merge pull request #13464 from alalek:ocl_max_group_size_parameter	2018-12-18 12:06:14 +00:00
Alexander Alekhin	de82d9da9e	Merge pull request #13458 from alalek:fix_python_install_path	2018-12-18 11:46:03 +00:00
vishwesh5	715f8fcce0	Merge pull request #13432 from vishwesh5:patch-1 * Create text_detection.py #12270 #13429 Deep Learning text detection sample (Python) - Tested on Ubuntu 18.04 - OpenCV 3.4.3, OpenCV 3.4.4, OpenCV 4.0 (master branch) - Python version supported - Python 2 and Python 3 * Fix trailing whitespaces * Update text_detection.py * Remove whitespace * Remove comments * Remove unused packages * Update description	2018-12-18 13:40:04 +03:00
Alexander Alekhin	3f3c8823ac	features2d: fix retainBest() implementation	2018-12-18 05:33:21 +00:00
Alexander Alekhin	d9d9b05912	core(ocl): add parameter to limit device max workgroup size used by OpenCV	2018-12-17 18:33:05 +00:00
Alexander Alekhin	55171b25f8	Merge pull request #13463 from vishwesh5:patch-2	2018-12-17 18:08:20 +00:00
vishwesh5	3eb2c940de	Fix Scharr and Sobel functions Resolves #13375	2018-12-17 20:39:22 +05:30
Alexander Alekhin	bb8c19aad3	cmake: fix python install paths	2018-12-17 14:32:29 +03:00
Alexander Alekhin	b571f03016	Merge pull request #13455 from alalek:issue_13454	2018-12-16 10:16:19 +00:00
Alexander Alekhin	f605898bae	core: fix eigen2cv() - don't change fixed type of 'dst'	2018-12-16 06:43:08 +00:00
Alexander Alekhin	5736bf5dd5	stitching: fix l_gains data type from Eigen solver (float / double)	2018-12-16 06:29:18 +00:00
Alexander Alekhin	4f9c1da806	Merge pull request #13447 from alalek:issue_13445	2018-12-15 21:17:17 +00:00
Alexander Alekhin	eb1f3733ee	videoio(dc1394): use lazy initialization on demand	2018-12-15 07:58:39 +00:00
Alexander Alekhin	d993b9c1df	Merge pull request #13443 from seiko2plus:issue13442	2018-12-14 22:31:35 +00:00
Sayed Adel	4e16ae9a1f	core:vsx fix build failure on GCC<=6 due implementation of v_reduce_sum(v_float64x2)	2018-12-14 19:24:12 +00:00
Quentin Chateau	ab86f15ba0	Merge pull request #13400 from Tytan:optimize_exposure_compensation Optimize exposure compensation (#13400) * Added perf test * Optimized gains computation * Use Eigen for gains calculation	2018-12-14 21:37:00 +03:00
Alexander Alekhin	0a801354b1	Merge pull request #13438 from madan-ram:patch-2	2018-12-14 14:35:56 +00:00
Rostislav Vasilikhin	d99a4af229	Merge pull request #13379 from savuor:color_5x5 RGB to/from Gray rewritten to wide intrinsics (#13379) * 5x5 to RGB added * RGB25x5 added * Gray2RGB added * Gray2RGB5x5 added * vx_set moved out of loops * RGB5x52Gray added * RGB2Gray written * warnings fixed (int -> (u)short conversion) * warning fixed * warning fixed * "i < n-vsize+1" to "i <= n-vsize" * RGBA2mRGBA vectorized * try to fix ARM builds * fixed ARM build for RGB2RGB5x5 * mRGBA2RGBA: saturation, vectorization * fixed CL implementation of mRGBA2RGBA (saturation added)	2018-12-14 17:01:01 +03:00
Madan Ram	c1e9a7ee4b	Update template_matching.markdown Replaced CV_TM_SQDIFF to TM_SQDIFF and the rest since methods are renamed in opencv 3.4	2018-12-14 16:34:58 +05:30
Alexander Alekhin	82a02d8585	Merge pull request #13436 from alalek:cmake_with_msmf_dxva_3.4	2018-12-14 10:36:39 +00:00
Alexander Alekhin	8d907d2e32	cmake(java): add OPENCV_JAVA_SOURCE_VERSION/OPENCV_JAVA_TARGET_VERSION	2018-12-14 00:15:57 +00:00
Alexander Alekhin	b7bb79c7c8	videoio(MSMF): backport WITH_MSMF_DXVA flag	2018-12-13 14:56:20 +03:00
Vitaly Tuzov	3903174f7c	Merge pull request #13334 from terfendail:histogram_wintr * added performance test for compareHist * compareHist reworked to use wide universal intrinsics * Disabled vectorization for CV_COMP_CORREL and CV_COMP_BHATTACHARYYA if f64 is unsupported	2018-12-13 14:20:22 +03:00
Alexander Alekhin	a9771078df	Merge pull request #13427 from dkurt:dnn_onnx_dynamic_reshape	2018-12-13 11:15:51 +00:00
Alexander Alekhin	eb1f7797e4	Merge pull request #13387 from dkurt:dnn_minor_ie_fixes	2018-12-13 10:08:34 +00:00
Alexander Alekhin	aa666dfa9c	Merge pull request #13430 from tomoaki0705:fixCudaJetsonTX2file	2018-12-13 09:14:26 +00:00
Tomoaki Teshima	3e710d8eec	use correct CC value for Jetson Xavier	2018-12-13 13:35:19 +09:00
Alexander Alekhin	954098d1cb	Merge pull request #13423 from alalek:issue_13418	2018-12-12 15:38:47 +00:00
Dmitry Kurtaev	e71758cfdf	Operate with shapes in ONNX models	2018-12-12 18:34:22 +03:00
Alexander Alekhin	cea3289bd4	Merge pull request #13420 from ThadHouse:Windows7shlwapi	2018-12-12 14:58:51 +00:00
Adrian Kashivskyy	00285a5e88	Merge pull request #13424 from akashivskyy:pr/ios-nonfree Add ability to build iOS and macOS frameworks with nonfree modules (#13424) * Allow building ios framework with nonfree * Allow building osx framework with nonfree	2018-12-12 17:32:19 +03:00
Alexander Alekhin	6fa23f330f	cmake: fix compiler flags filtering	2018-12-12 13:35:43 +03:00
Thad House	857fba0878	Remove MinCore_Downlevel, replace with Shlwapi On windows 7, MinCore_Downlevel does not work correctly. However, the only API used was QISearch, which can be found in Shlwapi. Closes #12010	2018-12-11 17:06:01 -08:00
Dmitry Kurtaev	53f6198f27	Minor fixes in IE backend tests	2018-12-10 20:08:13 +03:00