nareshmlx/opencv-pr huggingface dataset:
**File:** modules/core/src/stat.cpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...
**Review Line:** 2250

**Code Changes:**
```diff
+
+    try
+    {
+        ivx::Context ctx = ivx::Context::create();
+        ivx::Image
+            ia = ivx::Image::createFromHandle(ctx, stype == CV_8UC1 ? VX_DF_IMAGE_U8 : VX_DF_IMAGE_S16,
+                ivx::Image::createAddressing(cols, rows, stype == CV_8UC1 ? 1 : 2, (vx_int32)(src.step[0])), src.ptr());
+
+        ivx::Scalar vxMinVal = ivx::Scalar::create(ctx, stype == CV_8UC1 ? VX_TYPE_UINT8 : VX_TYPE_INT16, 0);
+        ivx::Scalar vxMaxVal = ivx::Scalar::create(ctx, stype == CV_8UC1 ? VX_TYPE_UINT8 : VX_TYPE_INT16, 0);
+        ivx::Array vxMinInd, vxMaxInd;
```

Review comment:
consider another `createFromHandle` overload for a single plane image
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...
**Review Line:** 213

**Code Changes:**
```diff
@@ -1693,6 +1693,160 @@ class Array : public RefWrapper<vx_array>
     /// vxCreateVirtualArray() wrapper
     static Array createVirtual(vx_graph g, vx_enum type, vx_size capacity)
     { return Array(vxCreateVirtualArray(g, type, capacity)); }
+
+#ifndef VX_VERSION_1_1
+    static const vx_enum
+        VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
+        VX_ARRAY_ITEMTYPE   = VX_ARRAY_ATTRIBUTE_ITEMTYPE,
+        VX_ARRAY_NUMITEMS   = VX_ARRAY_ATTRIBUTE_NUMITEMS,
+        VX_ARRAY_CAPACITY   = VX_ARRAY_ATTRIBUTE_CAPACITY,
+        VX_ARRAY_ITEMSIZE   = VX_ARRAY_ATTRIBUTE_ITEMSIZE;
+#endif
+
+    template<typename T>
```

Review comment:
maybe we'd better exclude `VX_TYPE_UINT32` if it's not supported properly in OpenCV?
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...

**Code Changes:**
```diff
@@ -1693,6 +1693,160 @@ class Array : public RefWrapper<vx_array>
     /// vxCreateVirtualArray() wrapper
     static Array createVirtual(vx_graph g, vx_enum type, vx_size capacity)
     { return Array(vxCreateVirtualArray(g, type, capacity)); }
+
+#ifndef VX_VERSION_1_1
+    static const vx_enum
+        VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
+        VX_ARRAY_ITEMTYPE   = VX_ARRAY_ATTRIBUTE_ITEMTYPE,
+        VX_ARRAY_NUMITEMS   = VX_ARRAY_ATTRIBUTE_NUMITEMS,
```

Review comment:
`std::vector` creation seems more useful, but it can be done with new `copyTo()` method
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...
**Review Line:** 1850

**Code Changes:**
```diff
+    }
+
+    void copyFrom(const cv::Mat& m)
+    { copyRangeFrom(0, itemCount(), m); }
+#endif //IVX_USE_OPENCV
 };
 
 /*
```

Review comment:
I think wrapping also `vxAddArrayItems` and `vxTruncateArray` would be useful (at least in future in user kernels)
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...
**Review Line:** 213

**Code Changes:**
```diff
@@ -1693,6 +1693,160 @@ class Array : public RefWrapper<vx_array>
     /// vxCreateVirtualArray() wrapper
     static Array createVirtual(vx_graph g, vx_enum type, vx_size capacity)
     { return Array(vxCreateVirtualArray(g, type, capacity)); }
+
+#ifndef VX_VERSION_1_1
+    static const vx_enum
+        VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST,
+        VX_ARRAY_ITEMTYPE   = VX_ARRAY_ATTRIBUTE_ITEMTYPE,
+        VX_ARRAY_NUMITEMS   = VX_ARRAY_ATTRIBUTE_NUMITEMS,
+        VX_ARRAY_CAPACITY   = VX_ARRAY_ATTRIBUTE_CAPACITY,
+        VX_ARRAY_ITEMSIZE   = VX_ARRAY_ATTRIBUTE_ITEMSIZE;
+#endif
+
+    template<typename T>
```

Review comment:
VX_TYPE_UINT32 is necessary for vx_distribution object used by vxuHistogram. So anyway we will have to handle it somehow when try to wrap histograms
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7677: Added OpenVX based processing to minMaxLoc - ### This pullrequest changes Implemented minMaxInd evaluation via OpenVX minMaxLoc immediate mo...
**Review Line:** 1850

**Code Changes:**
```diff
+    }
+
+    void copyFrom(const cv::Mat& m)
+    { copyRangeFrom(0, itemCount(), m); }
+#endif //IVX_USE_OPENCV
 };
 
 /*
```

Review comment:
Agree. But I think it would be better to separate it to another PR
**File:** modules/imgproc/src/smooth.cpp
**Change Type:** modified
**Context:** PR #7478: Added OpenVX based processing to boxFilter - ### This pullrequest changes Implemented box image filtering via OpenVX box3x3 immediate mode c...

**Code Changes:**
```diff
@@ -44,6 +44,11 @@
 #include "precomp.hpp"
 #include "opencl_kernels_imgproc.hpp"
 
+#ifdef HAVE_OPENVX
+#define IVX_HIDE_INFO_WARNINGS
+#define IVX_USE_OPENCV
+#include "ivx.hpp"
+#endif
 /*
```

Review comment:
Agree. I'm going to make PR **_WIP**_ while new wrappers are unavailable.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7732: Added OpenVX context and convolution attribute wrappers - ### This pullrequest changes Added wrappers for OpenVX context attributes and sett...
**Review Line:** 814

**Code Changes:**
```diff
+        query(VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION, v);
+        return v;
+    }
+
+    /// vxQueryContext(VX_CONTEXT_IMMEDIATE_BORDER) wrapper
+    vx_border_t borderMode() const
+    {
+        vx_border_t v;
+        query(VX_CONTEXT_IMMEDIATE_BORDER, v);
+        return v;
+    }
```

Review comment:
In OpenVX 1.0.1 the structure is called `vx_border_mode_t`.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7732: Added OpenVX context and convolution attribute wrappers - ### This pullrequest changes Added wrappers for OpenVX context attributes and sett...

**Code Changes:**
```diff
@@ -696,6 +696,11 @@ template <typename T> class RefWrapper
 
 #endif // IVX_USE_EXTERNAL_REFCOUNT
 
+#ifndef VX_VERSION_1_1
+//TODO: provide wrapper for border mode
+typedef vx_border_mode_t vx_border_t;
+#endif
+
 /// vx_context wrapper
```

Review comment:
I think it will be better to use `std::string` instead of `std::vector`.
**File:** modules/objdetect/include/opencv2/objdetect/detection_based_tracker.hpp
**Change Type:** modified
**Context:** PR #7745: objdetect: Properly check for C++11 as it's done in the matching .cpp… - resolves #7623 ### This pullrequest changes Fixes #7623
**Review Line:** 49

**Code Changes:**
```diff
@@ -46,7 +46,7 @@
 
 // After this condition removal update blacklist for bindings: modules/python/common.cmake
 #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(__ANDROID__) || \
-  (defined(__cplusplus) &&  __cplusplus > 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1700)
+  (defined(__cplusplus) &&  __cplusplus > 199711L) || (defined(_MSC_VER) && _MSC_VER >= 1700)
 
 #include <vector>
 
```

Review comment:
I believe it should be (`>` --> `>=`): ``` __cplusplus >= 201103L ```
**File:** modules/objdetect/include/opencv2/objdetect/detection_based_tracker.hpp
**Change Type:** modified
**Context:** PR #7745: objdetect: Properly check for C++11 as it's done in the matching .cpp… - resolves #7623 ### This pullrequest changes Fixes #7623
**Review Line:** 49

**Code Changes:**
```diff
@@ -46,7 +46,7 @@
 
 // After this condition removal update blacklist for bindings: modules/python/common.cmake
 #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(__ANDROID__) || \
-  (defined(__cplusplus) &&  __cplusplus > 201103L) || (defined(_MSC_VER) && _MSC_VER >= 1700)
+  (defined(__cplusplus) &&  __cplusplus > 199711L) || (defined(_MSC_VER) && _MSC_VER >= 1700)
 
 #include <vector>
 
```

Review comment:
Doesn't matter as there is no valid value in between. My proposal only requires change to a single file and fixes the problem.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
I would also add a check that `m` is continuous, since `vxCopyConvolutionCoefficients` expects that.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
I don't see much value in this public method. I suggest removing it.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
I suggest calling `Mat::create()` only if an empty `Mat` is provided and check the shape and continuity otherwise.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
why not to group this one with the other aliases below?
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
I suggest calling `Mat::create()` only if an **empty** `Mat` is provided and check the shape and continuity otherwise.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
need to check shape and continuity
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
while it's theoretically correct, I would suggest use of `CV_8U` here since `CV_8S` support in OpenCV is incomplete...
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1692

**Code Changes:**
```diff
+    {
+        vx_size v;
+        query(VX_CONVOLUTION_SIZE, v);
+        return v;
+    }
+
+    vx_enum dataType()
+    {
+        return VX_TYPE_INT16;
+    }
+
```

Review comment:
while this is hardcoded inside the sample implementation, I don't see in OpenVX standard the statement that the convolution element type is exactly `vx_int16` I suggest adding another method: ``` cpp vx_size elemSize() const { return size() / rows() / columns(); /* sizeof(vx_int16) ? */} ``` Thoughts?
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
`m.elemSize() == elemSize()` ?
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
to be safe, I suggest checking `tmp.elemSize() == elemSize()`...
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1698

**Code Changes:**
```diff
+    vx_enum dataType()
+    {
+        return VX_TYPE_INT16;
+    }
+
+    void copyTo(void* data)
+    {
+        if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
+#ifdef VX_VERSION_1_1
+        IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
+#else
```

Review comment:
I would also suggest an overload with `std::vector<vx_int16>& data` as more C++ way (with resizing it if empty)
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1708

**Code Changes:**
```diff
+#else
+        IVX_CHECK_STATUS(vxReadConvolutionCoefficients(ref, (vx_int16 *)data));
+#endif
+    }
+
+    void copyFrom(const void* data)
+    {
+        if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0");
+#ifdef VX_VERSION_1_1
+        IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, const_cast<void*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
+#else
```

Review comment:
I would also suggest an overload with `const std::vector<vx_int16>& data` as more C++ way
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
`m.type()?`
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1925

**Code Changes:**
```diff
+
+        if (m.isContinuous() && (vx_size)(m.rows) == rows() && (vx_size)(m.cols) == columns())
+        {
+            copyTo(m.ptr());
+        }
+        else
+        {
+            cv::Mat tmp((int)rows(), (int)columns(), enumToCVType(dataType()));
+            copyTo(tmp.ptr());
+            if (m.empty())
+                m = tmp;
```

Review comment:
see my comment regarding the non-empty Mat in `Convolution`
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1858

**Code Changes:**
```diff
+        query(VX_MATRIX_PATTERN, v);
+        return v;
+    }
+#endif // VX_VERSION_1_1
+
+    void copyTo(void* data)
+    {
+        if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0");
+#ifdef VX_VERSION_1_1
+        IVX_CHECK_STATUS(vxCopyMatrix(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST));
+#else
```

Review comment:
would you consider `template<typename T> void copyTo(std::vector<T>&)` signature with runtime type check? (as a additional more C++ way)
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...
**Review Line:** 1692

**Code Changes:**
```diff
+    {
+        vx_size v;
+        query(VX_CONVOLUTION_SIZE, v);
+        return v;
+    }
+
+    vx_enum dataType()
+    {
+        return VX_TYPE_INT16;
+    }
+
```

Review comment:
Both 1.0.1 and 1.1 standard say that `vxuConvolve` kernel expect `vx_int16` convolution matrix for `vx_convolution conv` parameter. Since there is no way to choose nor to query element type for the convolution any implementation have to use `vx_int16` as convolution element type. Also `VX_CONVOLUTION_SIZE` parameter isn't well defined and IMHO it should be an overall storage size. So `size()` could be greater than `rows()*columns()*sizeof(convolutionType)` if implementation store data with strides.
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
here compilation fails because `data` is expected to be `const vx_int16 *`, not `void*`
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
the same as above: here compilation fails because `data` is expected to be `const vx_int16 *`, not `void*`
**File:** 3rdparty/openvx/include/ivx.hpp
**Change Type:** modified
**Context:** PR #7651: Added wrappers for vx_matrix and vx_convolution - ### This pullrequest changes Added wrappers for vx_matrix and vx_convolution to ivx wrappe...

**Code Changes:**
```diff
@@ -179,6 +179,27 @@ template<> struct TypeToEnum<vx_bool>     { static const vx_enum value = VX_TYPE
 //template<> struct TypeToEnum<vx_size>     { static const vx_enum val = VX_TYPE_SIZE; };
 //template<> struct TypeToEnum<vx_df_image> { static const vx_enum val = VX_TYPE_DF_IMAGE; };
 
+#ifdef IVX_USE_OPENCV
+inline int enumToCVType(vx_enum type)
+{
+    switch (type)
+    {
+    case VX_TYPE_CHAR: return CV_8UC1;//While OpenCV support 8S as well, 8U is supported wider
```

Review comment:
here and 2 lines above the same thing: here compilation fails because `data` is expected to be `const vx_int16 *`, not `void*`