diff --git a/3rdparty/openvx/CMakeLists.txt b/3rdparty/openvx/CMakeLists.txt deleted file mode 100644 index 41fd377d70..0000000000 --- a/3rdparty/openvx/CMakeLists.txt +++ /dev/null @@ -1,7 +0,0 @@ -if(NOT HAVE_OPENVX) - message(STATUS "OpenVX is not available, disabling openvx-related HAL and stuff") - return() -endif() - -set(OPENCV_3P_OPENVX_DIR ${CMAKE_CURRENT_SOURCE_DIR}) -add_subdirectory(hal) \ No newline at end of file diff --git a/3rdparty/openvx/README.md b/3rdparty/openvx/README.md deleted file mode 100644 index 339b5072cc..0000000000 --- a/3rdparty/openvx/README.md +++ /dev/null @@ -1,97 +0,0 @@ -# C++ wrappers for OpenVX-1.x C API - -## Core ideas: - -* lightweight - minimal overhead vs standard C API -* automatic references counting -* exceptions instead of return codes -* object-oriented design -* (NYI) helpers for user-defined kernels & nodes -* C++ 11 friendly - -## Quick start sample - -The following short sample gives basic knowledges on the wrappers usage: - -```cpp -#include "ivx.hpp" -#include "ivx_lib_debug.hpp" // ivx::debug::* - -int main() -{ - vx_uint32 width = 640, height = 480; - try - { - ivx::Context context = ivx::Context::create(); - ivx::Graph graph = ivx::Graph::create(context); - ivx::Image - gray = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8), - gb = ivx::Image::createVirtual(graph), - res = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8); - - context.loadKernels("openvx-debug"); // ivx::debug::* - - ivx::debug::fReadImage(context, inputPath, gray); - - ivx::Node::create(graph, VX_KERNEL_GAUSSIAN_3x3, gray, gb); - ivx::Node::create( - graph, - VX_KERNEL_THRESHOLD, - gb, - ivx::Threshold::createBinary(context, VX_TYPE_UINT8, 50), - res - ); - - graph.verify(); - graph.process(); - - ivx::debug::fWriteImage(context, res, "ovx-res-cpp.pgm"); - } - catch (const ivx::RuntimeError& e) - { - printf("ErrorRuntime: code = %d(%x), message = %s\n", e.status(), e.status(), e.what()); - return e.status(); - } - catch (const ivx::WrapperError& e) - { - printf("ErrorWrapper: message = %s\n", e.what()); - return -1; - } - catch(const std::exception& e) - { - printf("runtime_error: message = %s\n", e.what()); - return -1; - } - - return 0; -} - -``` -## C++ API overview - -The wrappers have **header-only** implementation that simplifies their integration to projects. -All the API is inside `ivx` namespace (E.g. `class ivx::Graph`). - -While the C++ API is pretty much the same for underlying OpenVX version **1.0** and **1.1**, there are alternative code branches for some features implementation that are selected at **compile time** via `#ifdef` preprocessor directives. -E.g. external ref-counting is implemented for 1.0 version and native OpenVX one is used (via `vxRetainReference()` and `vxReleaseXYZ()`) for version 1.1. - -Also there are some **C++ 11** features are used (e.g. rvalue ref-s) when their availability is detected at ***compile time***. - -C++ exceptions are used for errors indication instead of return codes. There are two types of exceptions are defined: `RuntimeError` is thrown when OpenVX C call returned unsuccessful result and `WrapperError` is thrown when a problem is occurred in the wrappers code. Both exception calsses are derived from `std::exception` (actually from its inheritants). - -The so called **OpenVX objects** (e.g. `vx_image`) are represented as C++ classes in wrappers. -All these classes use automatic ref-counting that allows development of exception-safe code. -All these classes have `create()` or `createXYZ()` `static` methods for instances creation. (E.g. `Image::create()`, `Image::createVirtual()` and `Image::createFromHandle()`) -Most of the wrapped OpenVX functions are represented as methods of the corresponding C++ classes, but in most cases they still accept C "object" types (e.g. `vx_image` or `vx_context`) that allows mixing of C and C++ OpenVX API use. -E.g.: -```cpp -class Image -{ - static Image create(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format); - static Image createVirtual(vx_graph graph, vx_uint32 width = 0, vx_uint32 height = 0, vx_df_image format = VX_DF_IMAGE_VIRT); - // ... -} -``` -All the classes instances can automatically be converted to the corresponding C "object" types. - -For more details please refer to C++ wrappers reference manual or directly to their source code. diff --git a/3rdparty/openvx/hal/CMakeLists.txt b/3rdparty/openvx/hal/CMakeLists.txt deleted file mode 100644 index 4824c45a24..0000000000 --- a/3rdparty/openvx/hal/CMakeLists.txt +++ /dev/null @@ -1,18 +0,0 @@ -add_library(openvx_hal STATIC openvx_hal.cpp openvx_hal.hpp ${OPENCV_3P_OPENVX_DIR}/include/ivx.hpp ${OPENCV_3P_OPENVX_DIR}/include/ivx_lib_debug.hpp) -target_include_directories(openvx_hal PUBLIC - ${CMAKE_CURRENT_SOURCE_DIR} - ${OPENCV_3P_OPENVX_DIR}/include - ${CMAKE_SOURCE_DIR}/modules/core/include - ${CMAKE_SOURCE_DIR}/modules/imgproc/include - ${OPENVX_INCLUDE_DIR}) -target_link_libraries(openvx_hal PUBLIC ${OPENVX_LIBRARIES}) -set_target_properties(openvx_hal PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}) -if(NOT BUILD_SHARED_LIBS) - ocv_install_target(openvx_hal EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev) -endif() - -set(OPENVX_HAL_FOUND TRUE CACHE INTERNAL "") -set(OPENVX_HAL_VERSION 0.0.1 CACHE INTERNAL "") -set(OPENVX_HAL_LIBRARIES "openvx_hal" CACHE INTERNAL "") -set(OPENVX_HAL_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/openvx_hal.hpp" CACHE INTERNAL "") -set(OPENVX_HAL_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}" "${OPENCV_3P_OPENVX_DIR}/include" "${OPENVX_INCLUDE_DIR}" CACHE INTERNAL "") diff --git a/3rdparty/openvx/hal/README.md b/3rdparty/openvx/hal/README.md deleted file mode 100644 index a4266015a7..0000000000 --- a/3rdparty/openvx/hal/README.md +++ /dev/null @@ -1,4 +0,0 @@ -#OpenVX-based HAL implementation. -It's built when OpenVX is available (`HAVE_OPENVX`). -To build OpenCV with OpenVX support add the following **cmake** options: -`-DOPENVX_ROOT=/path/to/prebuilt/openvx -DWITH_OPENVX=YES` \ No newline at end of file diff --git a/3rdparty/openvx/hal/openvx_hal.cpp b/3rdparty/openvx/hal/openvx_hal.cpp deleted file mode 100644 index b87c38706e..0000000000 --- a/3rdparty/openvx/hal/openvx_hal.cpp +++ /dev/null @@ -1,1147 +0,0 @@ -#include "openvx_hal.hpp" -#include "opencv2/imgproc/hal/interface.h" - -#define IVX_HIDE_INFO_WARNINGS -#include "ivx.hpp" - -#include -#include - -#include -#include -#include -#include -#include - -//================================================================================================== -// utility -// ... - -#if 0 -#include -#define PRINT(...) printf(__VA_ARGS__) -#define PRINT_HALERR_MSG(type) PRINT("OpenVX HAL impl "#type" error: %s\n", e.what()) -#else -#define PRINT(...) -#define PRINT_HALERR_MSG(type) (void)e -#endif - - -#if __cplusplus >= 201103L -#include -struct Tick -{ - typedef std::chrono::time_point point_t; - point_t start; - point_t point; - Tick() - { - start = std::chrono::steady_clock::now(); - point = std::chrono::steady_clock::now(); - } - inline int one() - { - point_t old = point; - point = std::chrono::steady_clock::now(); - return std::chrono::duration_cast(point - old).count(); - } - inline int total() - { - return std::chrono::duration_cast(std::chrono::steady_clock::now() - start).count(); - } -}; -#endif - -inline ivx::Context& getOpenVXHALContext() -{ -#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800) - //CXX11 - static thread_local ivx::Context instance = ivx::Context::create(); -#else //__cplusplus >= 201103L || _MSC_VER >= 1800 - //CXX98 -#ifdef _WIN32 - static __declspec(thread) ivx::Context instance = ivx::Context::create(); -#else - static __thread ivx::Context instance = ivx::Context::create(); -#endif -#endif - return instance; -} - -inline bool dimTooBig(int size) -{ - static vx_uint16 current_vendor = getOpenVXHALContext().vendorID(); - - if (current_vendor == VX_ID_KHRONOS || current_vendor == VX_ID_DEFAULT) - { - //OpenVX use uint32_t for image addressing - return ((unsigned)size > (UINT_MAX / VX_SCALE_UNITY)); - } - else - return false; -} - -//OpenVX calls have essential overhead so it make sense to skip them for small images -template inline bool skipSmallImages(int w, int h) { return w*h < 7680 * 4320; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 640 * 480; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 2048 * 1536; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 640 * 480; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 1280 * 720; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } -template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } - -inline void setConstantBorder(ivx::border_t &border, vx_uint8 val) -{ - border.mode = VX_BORDER_CONSTANT; -#if VX_VERSION > VX_VERSION_1_0 - border.constant_value.U8 = val; -#else - border.constant_value = val; -#endif -} - -inline void refineStep(int w, int h, int imgType, size_t& step) -{ - if (h == 1) - step = w * ((imgType == VX_DF_IMAGE_RGBX || - imgType == VX_DF_IMAGE_U32 || imgType == VX_DF_IMAGE_S32) ? 4 : - imgType == VX_DF_IMAGE_RGB ? 3 : - (imgType == VX_DF_IMAGE_U16 || imgType == VX_DF_IMAGE_S16 || - imgType == VX_DF_IMAGE_UYVY || imgType == VX_DF_IMAGE_YUYV) ? 2 : 1); -} - -//================================================================================================== -// ivx::Image wrapped to simplify call to swapHandle prior to release -// TODO update ivx::Image to handle swapHandle prior to release on the own - -class vxImage: public ivx::Image -{ -public: - vxImage(const ivx::Image &_img) : ivx::Image(_img) {} - - ~vxImage() - { -#if VX_VERSION > VX_VERSION_1_0 - swapHandle(); -#endif - } -}; - -//================================================================================================== -// real code starts here -// ... - -#define OVX_BINARY_OP(hal_func, ovx_call, kernel_id) \ -template \ -int ovx_hal_##hal_func(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h) \ -{ \ - if(skipSmallImages(w, h)) \ - return CV_HAL_ERROR_NOT_IMPLEMENTED; \ - if(dimTooBig(w) || dimTooBig(h)) \ - return CV_HAL_ERROR_NOT_IMPLEMENTED; \ - refineStep(w, h, ivx::TypeToEnum::imgType, astep); \ - refineStep(w, h, ivx::TypeToEnum::imgType, bstep); \ - refineStep(w, h, ivx::TypeToEnum::imgType, cstep); \ - try \ - { \ - ivx::Context ctx = getOpenVXHALContext(); \ - vxImage \ - ia = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, \ - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(astep)), (void*)a), \ - ib = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, \ - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(bstep)), (void*)b), \ - ic = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, \ - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(cstep)), (void*)c); \ - ovx_call \ - } \ - catch (ivx::RuntimeError & e) \ - { \ - PRINT_HALERR_MSG(runtime); \ - return CV_HAL_ERROR_UNKNOWN; \ - } \ - catch (ivx::WrapperError & e) \ - { \ - PRINT_HALERR_MSG(wrapper); \ - return CV_HAL_ERROR_UNKNOWN; \ - } \ - return CV_HAL_ERROR_OK; \ -} - -OVX_BINARY_OP(add, { ivx::IVX_CHECK_STATUS(vxuAdd(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); }, VX_KERNEL_ADD) -OVX_BINARY_OP(sub, { ivx::IVX_CHECK_STATUS(vxuSubtract(ctx, ia, ib, VX_CONVERT_POLICY_SATURATE, ic)); }, VX_KERNEL_SUBTRACT) - -OVX_BINARY_OP(absdiff, { ivx::IVX_CHECK_STATUS(vxuAbsDiff(ctx, ia, ib, ic)); }, VX_KERNEL_ABSDIFF) - -OVX_BINARY_OP(and, { ivx::IVX_CHECK_STATUS(vxuAnd(ctx, ia, ib, ic)); }, VX_KERNEL_AND) -OVX_BINARY_OP(or , { ivx::IVX_CHECK_STATUS(vxuOr(ctx, ia, ib, ic)); }, VX_KERNEL_OR) -OVX_BINARY_OP(xor, { ivx::IVX_CHECK_STATUS(vxuXor(ctx, ia, ib, ic)); }, VX_KERNEL_XOR) - -template -int ovx_hal_mul(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h, double scale) -{ - if(scale == 1.0 || sizeof(T) > 1 ? - skipSmallImages(w, h) : /*actually it could be any kernel with generic minimum size*/ - skipSmallImages(w, h) ) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, ivx::TypeToEnum::imgType, astep); - refineStep(w, h, ivx::TypeToEnum::imgType, bstep); - refineStep(w, h, ivx::TypeToEnum::imgType, cstep); -#ifdef _WIN32 - const float MAGIC_SCALE = 0x0.01010102p0; -#else - const float MAGIC_SCALE = 0x1.010102p-8; -#endif - try - { - int rounding_policy = VX_ROUND_POLICY_TO_ZERO; - float fscale = (float)scale; - if (fabs(fscale - MAGIC_SCALE) > FLT_EPSILON) - { - int exp = 0; - double significand = frexp(fscale, &exp); - if ((significand != 0.5) || (exp > 1) || (exp < -14)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - else - { - fscale = MAGIC_SCALE; - rounding_policy = VX_ROUND_POLICY_TO_NEAREST_EVEN;// That's the only rounding that MUST be supported for 1/255 scale - } - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(bstep)), (void*)b), - ic = ivx::Image::createFromHandle(ctx, ivx::TypeToEnum::imgType, - ivx::Image::createAddressing(w, h, sizeof(T), (vx_int32)(cstep)), (void*)c); - ivx::IVX_CHECK_STATUS(vxuMultiply(ctx, ia, ib, fscale, VX_CONVERT_POLICY_SATURATE, rounding_policy, ic)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -template int ovx_hal_add(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); -template int ovx_hal_add(const short *a, size_t astep, const short *b, size_t bstep, short *c, size_t cstep, int w, int h); -template int ovx_hal_sub(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); -template int ovx_hal_sub(const short *a, size_t astep, const short *b, size_t bstep, short *c, size_t cstep, int w, int h); - -template int ovx_hal_absdiff(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); -template int ovx_hal_absdiff(const short *a, size_t astep, const short *b, size_t bstep, short *c, size_t cstep, int w, int h); - -template int ovx_hal_and(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); -template int ovx_hal_or(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); -template int ovx_hal_xor(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h); - -template int ovx_hal_mul(const uchar *a, size_t astep, const uchar *b, size_t bstep, uchar *c, size_t cstep, int w, int h, double scale); -template int ovx_hal_mul(const short *a, size_t astep, const short *b, size_t bstep, short *c, size_t cstep, int w, int h, double scale); - -int ovx_hal_not(const uchar *a, size_t astep, uchar *c, size_t cstep, int w, int h) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, VX_DF_IMAGE_U8, astep); - refineStep(w, h, VX_DF_IMAGE_U8, cstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)(astep)), (void*)a), - ic = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)(cstep)), (void*)c); - ivx::IVX_CHECK_STATUS(vxuNot(ctx, ia, ic)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_merge8u(const uchar **src_data, uchar *dst_data, int len, int cn) -{ - if (skipSmallImages(len, 1)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(len)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (cn != 3 && cn != 4) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(len, 1, 1, (vx_int32)(len)), (void*)src_data[0]), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(len, 1, 1, (vx_int32)(len)), (void*)src_data[1]), - ic = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(len, 1, 1, (vx_int32)(len)), (void*)src_data[2]), - id = ivx::Image::createFromHandle(ctx, cn == 4 ? VX_DF_IMAGE_RGBX : VX_DF_IMAGE_RGB, - ivx::Image::createAddressing(len, 1, cn, (vx_int32)(len*cn)), (void*)dst_data); - ivx::IVX_CHECK_STATUS(vxuChannelCombine(ctx, ia, ib, ic, - cn == 4 ? (vx_image)(ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(len, 1, 1, (vx_int32)(len)), (void*)src_data[3])) : NULL, - id)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_resize(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, double inv_scale_x, double inv_scale_y, int interpolation) -{ - if (skipSmallImages(aw, ah)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(aw, ah, VX_DF_IMAGE_U8, astep); - refineStep(bw, bh, VX_DF_IMAGE_U8, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(aw, ah, 1, (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(bw, bh, 1, (vx_int32)(bstep)), (void*)b); - - if (!((atype == CV_8UC1 || atype == CV_8SC1) && - inv_scale_x > 0 && inv_scale_y > 0 && - (bw - 0.5) / inv_scale_x - 0.5 < aw && (bh - 0.5) / inv_scale_y - 0.5 < ah && - (bw + 0.5) / inv_scale_x + 0.5 >= aw && (bh + 0.5) / inv_scale_y + 0.5 >= ah && - std::abs(bw / inv_scale_x - aw) < 0.1 && std::abs(bh / inv_scale_y - ah) < 0.1)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - int mode; - if (interpolation == CV_HAL_INTER_LINEAR) - { - mode = VX_INTERPOLATION_BILINEAR; - if (inv_scale_x > 1 || inv_scale_y > 1) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - else if (interpolation == CV_HAL_INTER_AREA) - return CV_HAL_ERROR_NOT_IMPLEMENTED; //mode = VX_INTERPOLATION_AREA; - else if (interpolation == CV_HAL_INTER_NEAREST) - return CV_HAL_ERROR_NOT_IMPLEMENTED; //mode = VX_INTERPOLATION_NEAREST_NEIGHBOR; - else - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - ivx::IVX_CHECK_STATUS(vxuScaleImage(ctx, ia, ib, mode)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_warpAffine(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[6], int interpolation, int borderType, const double borderValue[4]) -{ - if (skipSmallImages(aw, ah)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(aw, ah, VX_DF_IMAGE_U8, astep); - refineStep(bw, bh, VX_DF_IMAGE_U8, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(aw, ah, 1, (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(bw, bh, 1, (vx_int32)(bstep)), (void*)b); - - if (!(atype == CV_8UC1 || atype == CV_8SC1)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if(borderType != CV_HAL_BORDER_CONSTANT) // Neither 1.0 nor 1.1 OpenVX support BORDER_REPLICATE for warpings - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - int mode; - if (interpolation == CV_HAL_INTER_LINEAR) - mode = VX_INTERPOLATION_BILINEAR; - //AREA interpolation is unsupported - //else if (interpolation == CV_HAL_INTER_AREA) - // mode = VX_INTERPOLATION_AREA; - else if (interpolation == CV_HAL_INTER_NEAREST) - mode = VX_INTERPOLATION_NEAREST_NEIGHBOR; - else - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - std::vector data; - data.reserve(6); - for (int j = 0; j < 3; ++j) - for (int i = 0; i < 2; ++i) - data.push_back((float)(M[i * 3 + j])); - - ivx::Matrix mtx = ivx::Matrix::create(ctx, VX_TYPE_FLOAT32, 2, 3); - mtx.copyFrom(data); - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(VX_BORDER_CONSTANT, (vx_uint8)borderValue[0]); - ivx::IVX_CHECK_STATUS(vxuWarpAffine(ctx, ia, mtx, mode, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_warpPerspective(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4]) -{ - if (skipSmallImages(aw, ah)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(aw) || dimTooBig(ah) || dimTooBig(bw) || dimTooBig(bh)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(aw, ah, VX_DF_IMAGE_U8, astep); - refineStep(bw, bh, VX_DF_IMAGE_U8, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(aw, ah, 1, (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(bw, bh, 1, (vx_int32)(bstep)), (void*)b); - - if (!(atype == CV_8UC1 || atype == CV_8SC1)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (borderType != CV_HAL_BORDER_CONSTANT) // Neither 1.0 nor 1.1 OpenVX support BORDER_REPLICATE for warpings - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - int mode; - if (interpolation == CV_HAL_INTER_LINEAR) - mode = VX_INTERPOLATION_BILINEAR; - //AREA interpolation is unsupported - //else if (interpolation == CV_HAL_INTER_AREA) - // mode = VX_INTERPOLATION_AREA; - else if (interpolation == CV_HAL_INTER_NEAREST) - mode = VX_INTERPOLATION_NEAREST_NEIGHBOR; - else - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - std::vector data; - data.reserve(9); - for (int j = 0; j < 3; ++j) - for (int i = 0; i < 3; ++i) - data.push_back((float)(M[i * 3 + j])); - - ivx::Matrix mtx = ivx::Matrix::create(ctx, VX_TYPE_FLOAT32, 3, 3); - mtx.copyFrom(data); - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(VX_BORDER_CONSTANT, (vx_uint8)borderValue[0]); - ivx::IVX_CHECK_STATUS(vxuWarpPerspective(ctx, ia, mtx, mode, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -struct cvhalFilter2D; - -struct FilterCtx -{ - ivx::Convolution cnv; - int dst_type; - ivx::border_t border; - FilterCtx(ivx::Context &ctx, const std::vector data, int w, int h, int _dst_type, ivx::border_t & _border) : - cnv(ivx::Convolution::create(ctx, w, h)), dst_type(_dst_type), border(_border) { - cnv.copyFrom(data); - } -}; - -int ovx_hal_filterInit(cvhalFilter2D **filter_context, uchar *kernel_data, size_t kernel_step, int kernel_type, int kernel_width, int kernel_height, - int, int, int src_type, int dst_type, int borderType, double delta, int anchor_x, int anchor_y, bool allowSubmatrix, bool allowInplace) -{ - if (!filter_context || !kernel_data || allowSubmatrix || allowInplace || delta != 0 || - src_type != CV_8UC1 || (dst_type != CV_8UC1 && dst_type != CV_16SC1) || - kernel_width % 2 == 0 || kernel_height % 2 == 0 || anchor_x != kernel_width / 2 || anchor_y != kernel_height / 2) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - ivx::border_t border; - switch (borderType) - { - case CV_HAL_BORDER_CONSTANT: - setConstantBorder(border, 0); - break; - case CV_HAL_BORDER_REPLICATE: - border.mode = VX_BORDER_REPLICATE; - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - ivx::Context ctx = getOpenVXHALContext(); - - std::vector data; - data.reserve(kernel_width*kernel_height); - switch (kernel_type) - { - case CV_8UC1: - for (int j = 0; j < kernel_height; ++j) - { - uchar * row = (uchar*)(kernel_data + kernel_step*j); - for (int i = 0; i < kernel_width; ++i) - data.push_back(row[i]); - } - break; - case CV_8SC1: - for (int j = 0; j < kernel_height; ++j) - { - schar * row = (schar*)(kernel_data + kernel_step*j); - for (int i = 0; i < kernel_width; ++i) - data.push_back(row[i]); - } - break; - case CV_16SC1: - for (int j = 0; j < kernel_height; ++j) - { - short * row = (short*)(kernel_data + kernel_step*j); - for (int i = 0; i < kernel_width; ++i) - data.push_back(row[i]); - } - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - FilterCtx* cnv = new FilterCtx(ctx, data, kernel_width, kernel_height, dst_type, border); - if (!cnv) - return CV_HAL_ERROR_UNKNOWN; - - *filter_context = (cvhalFilter2D*)(cnv); - return CV_HAL_ERROR_OK; -} - -int ovx_hal_filterFree(cvhalFilter2D *filter_context) -{ - if (filter_context) - { - delete (FilterCtx*)filter_context; - return CV_HAL_ERROR_OK; - } - else - { - return CV_HAL_ERROR_UNKNOWN; - } -} - -int ovx_hal_filter(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int, int, int, int) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - try - { - FilterCtx* cnv = (FilterCtx*)filter_context; - if (!cnv) - throw ivx::WrapperError("Bad HAL context"); - refineStep(w, h, VX_DF_IMAGE_U8, astep); - refineStep(w, h, cnv->dst_type == CV_16SC1 ? VX_DF_IMAGE_S16 : VX_DF_IMAGE_U8, bstep); - - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, cnv->dst_type == CV_16SC1 ? VX_DF_IMAGE_S16 : VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, cnv->dst_type == CV_16SC1 ? 2 : 1, (vx_int32)(bstep)), (void*)b); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(cnv->border); - ivx::IVX_CHECK_STATUS(vxuConvolve(ctx, ia, cnv->cnv, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_sepFilterInit(cvhalFilter2D **filter_context, int src_type, int dst_type, - int kernel_type, uchar *kernelx_data, int kernelx_length, uchar *kernely_data, int kernely_length, - int anchor_x, int anchor_y, double delta, int borderType) -{ - if (!filter_context || !kernelx_data || !kernely_data || delta != 0 || - src_type != CV_8UC1 || (dst_type != CV_8UC1 && dst_type != CV_16SC1) || - kernelx_length != 3 || kernely_length != 3 || anchor_x != 1 || anchor_y != 1) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - ivx::border_t border; - switch (borderType) - { - case CV_HAL_BORDER_CONSTANT: - setConstantBorder(border, 0); - break; - case CV_HAL_BORDER_REPLICATE: - border.mode = VX_BORDER_REPLICATE; - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - ivx::Context ctx = getOpenVXHALContext(); - - //At the moment OpenVX doesn't support separable filters natively so combine kernels to generic convolution - std::vector data; - data.reserve(kernelx_length*kernely_length); - switch (kernel_type) - { - case CV_8UC1: - for (int j = 0; j < kernely_length; ++j) - for (int i = 0; i < kernelx_length; ++i) - data.push_back((short)(kernely_data[j]) * kernelx_data[i]); - break; - case CV_8SC1: - for (int j = 0; j < kernely_length; ++j) - for (int i = 0; i < kernelx_length; ++i) - data.push_back((short)(((schar*)kernely_data)[j]) * ((schar*)kernelx_data)[i]); - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - FilterCtx* cnv = new FilterCtx(ctx, data, kernelx_length, kernely_length, dst_type, border); - if (!cnv) - return CV_HAL_ERROR_UNKNOWN; - - *filter_context = (cvhalFilter2D*)(cnv); - return CV_HAL_ERROR_OK; -} - -#if VX_VERSION > VX_VERSION_1_0 - -struct MorphCtx -{ - ivx::Matrix mask; - int operation; - ivx::border_t border; - MorphCtx(ivx::Context &ctx, const std::vector data, int w, int h, int _operation, ivx::border_t & _border) : - mask(ivx::Matrix::create(ctx, ivx::TypeToEnum::value, w, h)), operation(_operation), border(_border) { - mask.copyFrom(data); - } -}; - -int ovx_hal_morphInit(cvhalFilter2D **filter_context, int operation, int src_type, int dst_type, int, int, - int kernel_type, uchar *kernel_data, size_t kernel_step, int kernel_width, int kernel_height, int anchor_x, int anchor_y, - int borderType, const double borderValue[4], int iterations, bool allowSubmatrix, bool allowInplace) -{ - if (!filter_context || !kernel_data || allowSubmatrix || allowInplace || iterations != 1 || - src_type != CV_8UC1 || dst_type != CV_8UC1 || - kernel_width % 2 == 0 || kernel_height % 2 == 0 || anchor_x != kernel_width / 2 || anchor_y != kernel_height / 2) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - ivx::border_t border; - switch (borderType) - { - case CV_HAL_BORDER_CONSTANT: - if (borderValue[0] == DBL_MAX && borderValue[1] == DBL_MAX && borderValue[2] == DBL_MAX && borderValue[3] == DBL_MAX) - { - if (operation == CV_HAL_MORPH_ERODE) - setConstantBorder(border, UCHAR_MAX); - else - setConstantBorder(border, 0); - } - else - { - int rounded = (int)round(borderValue[0]); - setConstantBorder(border, (vx_uint8)((unsigned)rounded <= UCHAR_MAX ? rounded : rounded > 0 ? UCHAR_MAX : 0)); - } - break; - case CV_HAL_BORDER_REPLICATE: - border.mode = VX_BORDER_REPLICATE; - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - ivx::Context ctx = getOpenVXHALContext(); - - vx_size maxKernelDim = ctx.nonlinearMaxDimension(); - if ((vx_size)kernel_width > maxKernelDim || (vx_size)kernel_height > maxKernelDim) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - std::vector kernel_mat; - kernel_mat.reserve(kernel_width * kernel_height); - switch (CV_MAT_DEPTH(kernel_type)) - { - case CV_8U: - case CV_8S: - for (int j = 0; j < kernel_height; ++j) - { - uchar * kernel_row = kernel_data + j * kernel_step; - for (int i = 0; i < kernel_width; ++i) - kernel_mat.push_back(kernel_row[i] ? 255 : 0); - } - break; - case CV_16U: - case CV_16S: - for (int j = 0; j < kernel_height; ++j) - { - short * kernel_row = (short*)(kernel_data + j * kernel_step); - for (int i = 0; i < kernel_width; ++i) - kernel_mat.push_back(kernel_row[i] ? 255 : 0); - } - break; - case CV_32S: - for (int j = 0; j < kernel_height; ++j) - { - int * kernel_row = (int*)(kernel_data + j * kernel_step); - for (int i = 0; i < kernel_width; ++i) - kernel_mat.push_back(kernel_row[i] ? 255 : 0); - } - break; - case CV_32F: - for (int j = 0; j < kernel_height; ++j) - { - float * kernel_row = (float*)(kernel_data + j * kernel_step); - for (int i = 0; i < kernel_width; ++i) - kernel_mat.push_back(kernel_row[i] ? 255 : 0); - } - break; - case CV_64F: - for (int j = 0; j < kernel_height; ++j) - { - double * kernel_row = (double*)(kernel_data + j * kernel_step); - for (int i = 0; i < kernel_width; ++i) - kernel_mat.push_back(kernel_row[i] ? 255 : 0); - } - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - - MorphCtx* mat; - switch (operation) - { - case CV_HAL_MORPH_ERODE: - mat = new MorphCtx(ctx, kernel_mat, kernel_width, kernel_height, VX_NONLINEAR_FILTER_MIN, border); - break; - case CV_HAL_MORPH_DILATE: - mat = new MorphCtx(ctx, kernel_mat, kernel_width, kernel_height, VX_NONLINEAR_FILTER_MAX, border); - break; - default: - return CV_HAL_ERROR_NOT_IMPLEMENTED; - } - if (!mat) - return CV_HAL_ERROR_UNKNOWN; - - *filter_context = (cvhalFilter2D*)(mat); - return CV_HAL_ERROR_OK; -} - -int ovx_hal_morphFree(cvhalFilter2D *filter_context) -{ - if (filter_context) - { - delete (MorphCtx*)filter_context; - return CV_HAL_ERROR_OK; - } - else - { - return CV_HAL_ERROR_UNKNOWN; - } -} - -int ovx_hal_morph(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int, int, int, int, int, int, int, int) -{ - if (skipSmallImages(w, h))//Actually it make sense to separate checks if implementations of dilation and erosion have different performance gain - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, VX_DF_IMAGE_U8, astep); - refineStep(w, h, VX_DF_IMAGE_U8, bstep); - try - { - MorphCtx* mat = (MorphCtx*)filter_context; - if (!mat) - throw ivx::WrapperError("Bad HAL context"); - - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)(astep)), (void*)a), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)(bstep)), (void*)b); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standart says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(mat->border); - ivx::IVX_CHECK_STATUS(vxuNonLinearFilter(ctx, mat->operation, ia, mat->mask, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -#endif // 1.0 guard - -int ovx_hal_cvtBGRtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int acn, int bcn, bool swapBlue) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (depth != CV_8U || swapBlue || acn == bcn || (acn != 3 && acn != 4) || (bcn != 3 && bcn != 4)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (w & 1 || h & 1) // It's strange but sample implementation unable to convert odd sized images - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, acn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, astep); - refineStep(w, h, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, acn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, acn, (vx_int32)astep), (void*)a), - ib = ivx::Image::createFromHandle(ctx, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, bcn, (vx_int32)bstep), b); - ivx::IVX_CHECK_STATUS(vxuColorConvert(ctx, ia, ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_cvtGraytoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int bcn) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (depth != CV_8U || (bcn != 3 && bcn != 4)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, VX_DF_IMAGE_U8, astep); - refineStep(w, h, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)astep), const_cast(a)), - ib = ivx::Image::createFromHandle(ctx, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, bcn, (vx_int32)bstep), b); - ivx::IVX_CHECK_STATUS(vxuChannelCombine(ctx, ia, ia, ia, - bcn == 4 ? (vx_image)(ivx::Image::createUniform(ctx, w, h, VX_DF_IMAGE_U8, vx_uint8(255))) : NULL, - ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_cvtTwoPlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx) -{ - return ovx_hal_cvtTwoPlaneYUVtoBGREx(a, astep, a + h * astep, astep, b, bstep, w, h, bcn, swapBlue, uIdx); -} - -int ovx_hal_cvtTwoPlaneYUVtoBGREx(const uchar * a, size_t astep, const uchar * b, size_t bstep, uchar * c, size_t cstep, int w, int h, int bcn, bool swapBlue, int uIdx) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (!swapBlue || (bcn != 3 && bcn != 4)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (w & 1 || h & 1) // It's not described in spec but sample implementation unable to convert odd sized images - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - try - { - ivx::Context ctx = getOpenVXHALContext(); - - std::vector addr; - std::vector ptrs; - addr.push_back(ivx::Image::createAddressing(w, h, 1, (vx_int32)astep)); - ptrs.push_back((void*)a); - addr.push_back(ivx::Image::createAddressing(w / 2, h / 2, 2, (vx_int32)bstep)); - ptrs.push_back((void*)b); - - vxImage - ia = ivx::Image::createFromHandle(ctx, uIdx ? VX_DF_IMAGE_NV21 : VX_DF_IMAGE_NV12, addr, ptrs); - if (ia.range() == VX_CHANNEL_RANGE_FULL) - return CV_HAL_ERROR_NOT_IMPLEMENTED; // OpenCV store NV12/NV21 as RANGE_RESTRICTED while OpenVX expect RANGE_FULL - vxImage - ib = ivx::Image::createFromHandle(ctx, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, bcn, (vx_int32)cstep), c); - ivx::IVX_CHECK_STATUS(vxuColorConvert(ctx, ia, ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_cvtThreePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (!swapBlue || (bcn != 3 && bcn != 4) || uIdx || (size_t)w / 2 != astep - (size_t)w / 2) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (w & 1 || h & 1) // It's not described in spec but sample implementation unable to convert odd sized images - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, VX_DF_IMAGE_IYUV, astep); - refineStep(w, h, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - - std::vector addr; - std::vector ptrs; - addr.push_back(ivx::Image::createAddressing(w, h, 1, (vx_int32)astep)); - ptrs.push_back((void*)a); - addr.push_back(ivx::Image::createAddressing(w / 2, h / 2, 1, w / 2)); - ptrs.push_back((void*)(a + h * astep)); - if (addr[1].dim_x != (astep - addr[1].dim_x)) - throw ivx::WrapperError("UV planes use variable stride"); - addr.push_back(ivx::Image::createAddressing(w / 2, h / 2, 1, w / 2)); - ptrs.push_back((void*)(a + h * astep + addr[1].dim_y * addr[1].stride_y)); - - vxImage - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_IYUV, addr, ptrs); - if (ia.range() == VX_CHANNEL_RANGE_FULL) - return CV_HAL_ERROR_NOT_IMPLEMENTED; // OpenCV store NV12/NV21 as RANGE_RESTRICTED while OpenVX expect RANGE_FULL - vxImage - ib = ivx::Image::createFromHandle(ctx, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, bcn, (vx_int32)bstep), b); - ivx::IVX_CHECK_STATUS(vxuColorConvert(ctx, ia, ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_cvtBGRtoThreePlaneYUV(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int acn, bool swapBlue, int uIdx) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (!swapBlue || (acn != 3 && acn != 4) || uIdx || (size_t)w / 2 != bstep - (size_t)w / 2) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (w & 1 || h & 1) // It's not described in spec but sample implementation unable to convert odd sized images - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, acn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, astep); - refineStep(w, h, VX_DF_IMAGE_IYUV, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, acn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, acn, (vx_int32)astep), (void*)a); - - std::vector addr; - std::vector ptrs; - addr.push_back(ivx::Image::createAddressing(w, h, 1, (vx_int32)bstep)); - ptrs.push_back((void*)b); - addr.push_back(ivx::Image::createAddressing(w / 2, h / 2, 1, w / 2)); - ptrs.push_back((void*)(b + h * bstep)); - if (addr[1].dim_x != (bstep - addr[1].dim_x)) - throw ivx::WrapperError("UV planes use variable stride"); - addr.push_back(ivx::Image::createAddressing(w / 2, h / 2, 1, w / 2)); - ptrs.push_back((void*)(b + h * bstep + addr[1].dim_y * addr[1].stride_y)); - - vxImage - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_IYUV, addr, ptrs); - ivx::IVX_CHECK_STATUS(vxuColorConvert(ctx, ia, ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_cvtOnePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx, int ycn) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (dimTooBig(w) || dimTooBig(h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (!swapBlue || (bcn != 3 && bcn != 4) || uIdx) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - - if (w & 1) // It's not described in spec but sample implementation unable to convert odd sized images - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, ycn ? VX_DF_IMAGE_UYVY : VX_DF_IMAGE_YUYV, astep); - refineStep(w, h, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, bstep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - vxImage - ia = ivx::Image::createFromHandle(ctx, ycn ? VX_DF_IMAGE_UYVY : VX_DF_IMAGE_YUYV, - ivx::Image::createAddressing(w, h, 2, (vx_int32)astep), (void*)a); - if (ia.range() == VX_CHANNEL_RANGE_FULL) - return CV_HAL_ERROR_NOT_IMPLEMENTED; // OpenCV store NV12/NV21 as RANGE_RESTRICTED while OpenVX expect RANGE_FULL - vxImage - ib = ivx::Image::createFromHandle(ctx, bcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX, - ivx::Image::createAddressing(w, h, bcn, (vx_int32)bstep), b); - ivx::IVX_CHECK_STATUS(vxuColorConvert(ctx, ia, ib)); - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - return CV_HAL_ERROR_OK; -} - -int ovx_hal_integral(int depth, int sdepth, int, const uchar * a, size_t astep, uchar * b, size_t bstep, uchar * c, size_t, uchar * d, size_t, int w, int h, int cn) -{ - if (skipSmallImages(w, h)) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - if (depth != CV_8U || sdepth != CV_32S || c != NULL || d != NULL || cn != 1) - return CV_HAL_ERROR_NOT_IMPLEMENTED; - refineStep(w, h, VX_DF_IMAGE_U8, astep); - try - { - ivx::Context ctx = getOpenVXHALContext(); - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(w, h, 1, (vx_int32)astep), const_cast(a)), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U32, - ivx::Image::createAddressing(w, h, 4, (vx_int32)bstep), (unsigned int *)(b + bstep + sizeof(unsigned int))); - ivx::IVX_CHECK_STATUS(vxuIntegralImage(ctx, ia, ib)); - std::memset(b, 0, (w + 1) * sizeof(unsigned int)); - b += bstep; - for (int i = 0; i < h; i++, b += bstep) - { - *((unsigned int*)b) = 0; - } - } - catch (ivx::RuntimeError & e) - { - PRINT_HALERR_MSG(runtime); - return CV_HAL_ERROR_UNKNOWN; - } - catch (ivx::WrapperError & e) - { - PRINT_HALERR_MSG(wrapper); - return CV_HAL_ERROR_UNKNOWN; - } - - return CV_HAL_ERROR_OK; -} diff --git a/3rdparty/openvx/hal/openvx_hal.hpp b/3rdparty/openvx/hal/openvx_hal.hpp deleted file mode 100644 index 4fba576f1a..0000000000 --- a/3rdparty/openvx/hal/openvx_hal.hpp +++ /dev/null @@ -1,145 +0,0 @@ -#ifndef OPENCV_OPENVX_HAL_HPP_INCLUDED -#define OPENCV_OPENVX_HAL_HPP_INCLUDED - -#include "opencv2/core/hal/interface.h" - -#include "VX/vx.h" - -template -int ovx_hal_add(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); -template -int ovx_hal_sub(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); - -template -int ovx_hal_absdiff(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); - -template -int ovx_hal_and(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); -template -int ovx_hal_or(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); -template -int ovx_hal_xor(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h); -int ovx_hal_not(const uchar *a, size_t astep, uchar *c, size_t cstep, int w, int h); - -template -int ovx_hal_mul(const T *a, size_t astep, const T *b, size_t bstep, T *c, size_t cstep, int w, int h, double scale); - -int ovx_hal_merge8u(const uchar **src_data, uchar *dst_data, int len, int cn); -int ovx_hal_resize(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, double inv_scale_x, double inv_scale_y, int interpolation); -int ovx_hal_warpAffine(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[6], int interpolation, int borderType, const double borderValue[4]); -int ovx_hal_warpPerspective(int atype, const uchar *a, size_t astep, int aw, int ah, uchar *b, size_t bstep, int bw, int bh, const double M[9], int interpolation, int borderType, const double borderValue[4]); - -struct cvhalFilter2D; -int ovx_hal_filterInit(cvhalFilter2D **filter_context, uchar *kernel_data, size_t kernel_step, int kernel_type, int kernel_width, int kernel_height, - int, int, int src_type, int dst_type, int borderType, double delta, int anchor_x, int anchor_y, bool allowSubmatrix, bool allowInplace); -int ovx_hal_filterFree(cvhalFilter2D *filter_context); -int ovx_hal_filter(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int, int, int, int); -int ovx_hal_sepFilterInit(cvhalFilter2D **filter_context, int src_type, int dst_type, - int kernel_type, uchar *kernelx_data, int kernelx_length, uchar *kernely_data, int kernely_length, - int anchor_x, int anchor_y, double delta, int borderType); - -#if VX_VERSION > VX_VERSION_1_0 -int ovx_hal_morphInit(cvhalFilter2D **filter_context, int operation, int src_type, int dst_type, int , int , - int kernel_type, uchar *kernel_data, size_t kernel_step, int kernel_width, int kernel_height, int anchor_x, int anchor_y, - int borderType, const double borderValue[4], int iterations, bool allowSubmatrix, bool allowInplace); -int ovx_hal_morphFree(cvhalFilter2D *filter_context); -int ovx_hal_morph(cvhalFilter2D *filter_context, uchar *a, size_t astep, uchar *b, size_t bstep, int w, int h, int , int , int , int , int , int , int , int ); -#endif // 1.0 guard - -int ovx_hal_cvtBGRtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int acn, int bcn, bool swapBlue); -int ovx_hal_cvtGraytoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int depth, int bcn); -int ovx_hal_cvtTwoPlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx); -int ovx_hal_cvtTwoPlaneYUVtoBGREx(const uchar * a, size_t astep, const uchar * b, size_t bstep, uchar * c, size_t cstep, int w, int h, int bcn, bool swapBlue, int uIdx); -int ovx_hal_cvtThreePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx); -int ovx_hal_cvtBGRtoThreePlaneYUV(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int acn, bool swapBlue, int uIdx); -int ovx_hal_cvtOnePlaneYUVtoBGR(const uchar * a, size_t astep, uchar * b, size_t bstep, int w, int h, int bcn, bool swapBlue, int uIdx, int ycn); -int ovx_hal_integral(int depth, int sdepth, int, const uchar * a, size_t astep, uchar * b, size_t bstep, uchar * c, size_t, uchar * d, size_t, int w, int h, int cn); - -//================================================================================================== -// functions redefinition -// ... - -#undef cv_hal_add8u -#define cv_hal_add8u ovx_hal_add -#undef cv_hal_add16s -#define cv_hal_add16s ovx_hal_add -#undef cv_hal_sub8u -#define cv_hal_sub8u ovx_hal_sub -#undef cv_hal_sub16s -#define cv_hal_sub16s ovx_hal_sub - -#undef cv_hal_absdiff8u -#define cv_hal_absdiff8u ovx_hal_absdiff -#undef cv_hal_absdiff16s -#define cv_hal_absdiff16s ovx_hal_absdiff - -#undef cv_hal_and8u -#define cv_hal_and8u ovx_hal_and -#undef cv_hal_or8u -#define cv_hal_or8u ovx_hal_or -#undef cv_hal_xor8u -#define cv_hal_xor8u ovx_hal_xor -#undef cv_hal_not8u -#define cv_hal_not8u ovx_hal_not - -#undef cv_hal_mul8u -#define cv_hal_mul8u ovx_hal_mul -#undef cv_hal_mul16s -#define cv_hal_mul16s ovx_hal_mul - -#undef cv_hal_merge8u -#define cv_hal_merge8u ovx_hal_merge8u - -//#undef cv_hal_resize -//#define cv_hal_resize ovx_hal_resize - -//OpenVX warps use round to zero policy at least in sample implementation -//while OpenCV require round to nearest -//#undef cv_hal_warpAffine -//#define cv_hal_warpAffine ovx_hal_warpAffine -//#undef cv_hal_warpPerspective -//#define cv_hal_warpPerspective ovx_hal_warpPerspective - -#undef cv_hal_filterInit -#define cv_hal_filterInit ovx_hal_filterInit -#undef cv_hal_filter -#define cv_hal_filter ovx_hal_filter -#undef cv_hal_filterFree -#define cv_hal_filterFree ovx_hal_filterFree - -//#undef cv_hal_sepFilterInit -//#define cv_hal_sepFilterInit ovx_hal_sepFilterInit -//#undef cv_hal_sepFilter -//#define cv_hal_sepFilter ovx_hal_filter -//#undef cv_hal_sepFilterFree -//#define cv_hal_sepFilterFree ovx_hal_filterFree - -#if VX_VERSION > VX_VERSION_1_0 - -#undef cv_hal_morphInit -#define cv_hal_morphInit ovx_hal_morphInit -#undef cv_hal_morph -#define cv_hal_morph ovx_hal_morph -#undef cv_hal_morphFree -#define cv_hal_morphFree ovx_hal_morphFree - -#endif // 1.0 guard - -#undef cv_hal_cvtBGRtoBGR -#define cv_hal_cvtBGRtoBGR ovx_hal_cvtBGRtoBGR -#undef cv_hal_cvtGraytoBGR -#define cv_hal_cvtGraytoBGR ovx_hal_cvtGraytoBGR -#undef cv_hal_cvtTwoPlaneYUVtoBGR -#define cv_hal_cvtTwoPlaneYUVtoBGR ovx_hal_cvtTwoPlaneYUVtoBGR -#undef cv_hal_cvtTwoPlaneYUVtoBGREx -#define cv_hal_cvtTwoPlaneYUVtoBGREx ovx_hal_cvtTwoPlaneYUVtoBGREx -#undef cv_hal_cvtThreePlaneYUVtoBGR -#define cv_hal_cvtThreePlaneYUVtoBGR ovx_hal_cvtThreePlaneYUVtoBGR -#undef cv_hal_cvtBGRtoThreePlaneYUV -#define cv_hal_cvtBGRtoThreePlaneYUV ovx_hal_cvtBGRtoThreePlaneYUV -#undef cv_hal_cvtOnePlaneYUVtoBGR -#define cv_hal_cvtOnePlaneYUVtoBGR ovx_hal_cvtOnePlaneYUVtoBGR -#undef cv_hal_integral -#define cv_hal_integral ovx_hal_integral - -#endif diff --git a/3rdparty/openvx/include/ivx.hpp b/3rdparty/openvx/include/ivx.hpp deleted file mode 100644 index 44ed0eb42e..0000000000 --- a/3rdparty/openvx/include/ivx.hpp +++ /dev/null @@ -1,3277 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. - -// Copyright (C) 2016, Intel Corporation, all rights reserved. -// Third party copyrights are property of their respective owners. - -/* -C++ wrappers over OpenVX 1.x C API -Details: TBD -*/ - -#pragma once -#ifndef IVX_HPP -#define IVX_HPP - -#ifndef __cplusplus - #error This file has to be compiled with C++ compiler -#endif - - -#include -#include - -#ifndef VX_VERSION_1_1 -// 1.1 to 1.0 backward compatibility defines - -static const vx_enum VX_INTERPOLATION_BILINEAR = VX_INTERPOLATION_TYPE_BILINEAR; -static const vx_enum VX_INTERPOLATION_AREA = VX_INTERPOLATION_TYPE_AREA; -static const vx_enum VX_INTERPOLATION_NEAREST_NEIGHBOR = VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR; - -static const vx_enum VX_BORDER_CONSTANT = VX_BORDER_MODE_CONSTANT; -static const vx_enum VX_BORDER_REPLICATE = VX_BORDER_MODE_REPLICATE; - -#else - - #ifdef IVX_RENAMED_REFS - static const vx_enum VX_REF_ATTRIBUTE_TYPE = VX_REFERENCE_TYPE; - #endif - -#endif - -#ifndef IVX_USE_CXX98 - // checking compiler - #if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_VER < 1800) - #define IVX_USE_CXX98 - #endif -#endif // IVX_USE_CXX98 - -#if defined(IVX_USE_CXX98) && !defined(IVX_HIDE_INFO_WARNINGS) - #ifdef _MSC_VER - #pragma message ("ivx.hpp: The ISO C++ 2011 standard is not enabled, switching to C++98 fallback implementation.") - #else - #warning The ISO C++ 2011 standard is not enabled, switching to C++98 fallback implementation. - #endif -#endif // IVX_USE_CXX98 - -#ifndef IVX_USE_EXTERNAL_REFCOUNT - // checking OpenVX version - #ifndef VX_VERSION_1_1 - #define IVX_USE_EXTERNAL_REFCOUNT - #endif -#endif // IVX_USE_CXX98 - -#if defined(IVX_USE_EXTERNAL_REFCOUNT) && !defined(IVX_HIDE_INFO_WARNINGS) - #ifdef _MSC_VER - #pragma message ("ivx.hpp: OpenVX version < 1.1, switching to external refcounter implementation.") - #else - #warning OpenVX version < 1.1, switching to external refcounter implementation. - #endif -#endif // IVX_USE_EXTERNAL_REFCOUNT - -#include -#include -#include -#include -#include - -#ifndef IVX_USE_CXX98 - #include - namespace ivx - { - using std::is_same; - using std::is_pointer; - } -#else - namespace ivx - { - // helpers for compile-time type checking - - template struct is_same { static const bool value = false; }; - template struct is_same { static const bool value = true; }; - - template struct is_pointer { static const bool value = false; }; - template struct is_pointer { static const bool value = true; }; - template struct is_pointer { static const bool value = true; }; - } -#endif - -#ifdef IVX_USE_OPENCV - #include "opencv2/core.hpp" -#endif - -// disabling false alarm warnings -#if defined(_MSC_VER) - #pragma warning(push) - //#pragma warning( disable : 4??? ) -#elif defined(__clang__) - #pragma clang diagnostic push - #pragma clang diagnostic ignored "-Wunused-local-typedef" - #pragma clang diagnostic ignored "-Wmissing-prototypes" -#elif defined(__GNUC__) - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wunused-local-typedefs" - #pragma GCC diagnostic ignored "-Wunused-value" - #pragma GCC diagnostic ignored "-Wmissing-declarations" -#endif // compiler macro - -namespace ivx -{ - -inline vx_uint16 compiledWithVersion() -{ return VX_VERSION; } - -/// Exception class for OpenVX runtime errors -class RuntimeError : public std::runtime_error -{ -public: - /// Constructor - explicit RuntimeError(vx_status st, const std::string& msg = "") - : runtime_error(msg), _status(st) - {} - - /// OpenVX error code - vx_status status() const - { return _status; } - -private: - vx_status _status; -}; - -/// Exception class for wrappers logic errors -class WrapperError : public std::logic_error -{ -public: - /// Constructor - explicit WrapperError(const std::string& msg) : logic_error(msg) - {} -}; - -inline void checkVxStatus(vx_status status, const std::string& func, const std::string& msg) -{ - if(status != VX_SUCCESS) throw RuntimeError( status, func + "() : " + msg ); -} - - -/// Helper macro for turning a runtime error in the provided code into a \RuntimeError -#define IVX_CHECK_STATUS(code) checkVxStatus(code, __func__, #code) - - -/// OpenVX enum to type compile-time converter (TODO: add more types) -template struct EnumToType {}; -template<> struct EnumToType { typedef vx_char type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_int8 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_uint8 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_int16 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_uint16 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_int32 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_uint32 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_int64 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_uint64 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_float32 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_float64 type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_enum type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_size type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_df_image type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_bool type; static const vx_size bytes = sizeof(type); }; -template<> struct EnumToType { typedef vx_keypoint_t type;static const vx_size bytes = sizeof(type); }; -#ifndef IVX_USE_CXX98 -template using EnumToType_t = typename EnumToType::type; -#endif - -/// Gets size in bytes for the provided OpenVX type enum -inline vx_size enumToTypeSize(vx_enum type) -{ - switch (type) - { - case VX_TYPE_CHAR: return EnumToType::bytes; - case VX_TYPE_INT8: return EnumToType::bytes; - case VX_TYPE_UINT8: return EnumToType::bytes; - case VX_TYPE_INT16: return EnumToType::bytes; - case VX_TYPE_UINT16: return EnumToType::bytes; - case VX_TYPE_INT32: return EnumToType::bytes; - case VX_TYPE_UINT32: return EnumToType::bytes; - case VX_TYPE_INT64: return EnumToType::bytes; - case VX_TYPE_UINT64: return EnumToType::bytes; - case VX_TYPE_FLOAT32: return EnumToType::bytes; - case VX_TYPE_FLOAT64: return EnumToType::bytes; - case VX_TYPE_ENUM: return EnumToType::bytes; - case VX_TYPE_SIZE: return EnumToType::bytes; - case VX_TYPE_DF_IMAGE: return EnumToType::bytes; - case VX_TYPE_BOOL: return EnumToType::bytes; - case VX_TYPE_KEYPOINT: return EnumToType::bytes; - default: throw WrapperError(std::string(__func__) + ": unsupported type enum"); - } -} - -/// type to enum compile-time converter (TODO: add more types) -template struct TypeToEnum {}; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_CHAR; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_INT8; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_UINT8, imgType = VX_DF_IMAGE_U8; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_INT16, imgType = VX_DF_IMAGE_S16; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_UINT16, imgType = VX_DF_IMAGE_U16; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_INT32, imgType = VX_DF_IMAGE_S32; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_UINT32, imgType = VX_DF_IMAGE_U32; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_INT64; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_UINT64; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_FLOAT32, imgType = VX_DF_IMAGE('F', '0', '3', '2'); }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_FLOAT64; }; -template<> struct TypeToEnum { static const vx_enum value = VX_TYPE_BOOL; }; -template<> struct TypeToEnum {static const vx_enum value = VX_TYPE_KEYPOINT; }; -// the commented types are aliases (of integral tyes) and have conflicts with the types above -//template<> struct TypeToEnum { static const vx_enum val = VX_TYPE_ENUM; }; -//template<> struct TypeToEnum { static const vx_enum val = VX_TYPE_SIZE; }; -//template<> struct TypeToEnum { static const vx_enum val = VX_TYPE_DF_IMAGE; }; - -inline bool areTypesCompatible(const vx_enum a, const vx_enum b) -{ - return enumToTypeSize(a) == enumToTypeSize(b); -} - -#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 - case VX_TYPE_INT8: return CV_8SC1; - case VX_TYPE_UINT8: return CV_8UC1; - case VX_TYPE_INT16: return CV_16SC1; - case VX_TYPE_UINT16: return CV_16UC1; - case VX_TYPE_INT32: return CV_32SC1; - case VX_TYPE_UINT32: return CV_32SC1;//That's not the best option but there is CV_32S type only - case VX_TYPE_FLOAT32: return CV_32FC1; - case VX_TYPE_FLOAT64: return CV_64FC1; - case VX_TYPE_ENUM: return CV_32SC1; - case VX_TYPE_BOOL: return CV_32SC1; - default: throw WrapperError(std::string(__func__) + ": unsupported type enum"); - } -} -#endif - -/// Helper type, provides info for OpenVX 'objects' (vx_reference extending) types -template struct RefTypeTraits {}; - -class Context; -template <> struct RefTypeTraits -{ - typedef vx_context vxType; - typedef Context wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_CONTEXT; - static vx_status release(vxType& ref) { return vxReleaseContext(&ref); } -}; - -class Graph; -template <> struct RefTypeTraits -{ - typedef vx_graph vxType; - typedef Graph wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_GRAPH; - static vx_status release(vxType& ref) { return vxReleaseGraph(&ref); } -}; - -class Node; -template <> struct RefTypeTraits -{ - typedef vx_node vxType; - typedef Node wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_NODE; - static vx_status release(vxType& ref) { return vxReleaseNode(&ref); } -}; - -class Kernel; -template <> struct RefTypeTraits -{ - typedef vx_kernel vxType; - typedef Kernel wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_KERNEL; - static vx_status release(vxType& ref) { return vxReleaseKernel(&ref); } -}; - -class Param; -template <> struct RefTypeTraits -{ - typedef vx_parameter vxType; - typedef Param wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_PARAMETER; - static vx_status release(vxType& ref) { return vxReleaseParameter(&ref); } -}; - -class Image; -template <> struct RefTypeTraits -{ - typedef vx_image vxType; - typedef Image wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_IMAGE; - static vx_status release(vxType& ref) { return vxReleaseImage(&ref); } -}; - -class Scalar; -template <> struct RefTypeTraits -{ - typedef vx_scalar vxType; - typedef Scalar wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_SCALAR; - static vx_status release(vxType& ref) { return vxReleaseScalar(&ref); } -}; - -class Array; -template <> struct RefTypeTraits -{ - typedef vx_array vxType; - typedef Array wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_ARRAY; - static vx_status release(vxType& ref) { return vxReleaseArray(&ref); } -}; - -class Threshold; -template <> struct RefTypeTraits -{ - typedef vx_threshold vxType; - typedef Threshold wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_THRESHOLD; - static vx_status release(vxType& ref) { return vxReleaseThreshold(&ref); } -}; - -class Convolution; -template <> struct RefTypeTraits -{ - typedef vx_convolution vxType; - typedef Convolution wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_CONVOLUTION; - static vx_status release(vxType& ref) { return vxReleaseConvolution(&ref); } -}; - -class Matrix; -template <> struct RefTypeTraits -{ - typedef vx_matrix vxType; - typedef Matrix wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_MATRIX; - static vx_status release(vxType& ref) { return vxReleaseMatrix(&ref); } -}; - -class LUT; -template <> struct RefTypeTraits -{ - typedef vx_lut vxType; - typedef LUT wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_LUT; - static vx_status release(vxType& ref) { return vxReleaseLUT(&ref); } -}; - -class Pyramid; -template <> struct RefTypeTraits -{ - typedef vx_pyramid vxType; - typedef Pyramid wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_PYRAMID; - static vx_status release(vxType& ref) { return vxReleasePyramid(&ref); } -}; - -class Distribution; -template <> struct RefTypeTraits -{ - typedef vx_distribution vxType; - typedef Distribution wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_DISTRIBUTION; - static vx_status release(vxType& ref) { return vxReleaseDistribution(&ref); } -}; - -class Remap; -template <> struct RefTypeTraits -{ - typedef vx_remap vxType; - typedef Remap wrapperType; - static const vx_enum vxTypeEnum = VX_TYPE_REMAP; - static vx_status release(vxType& ref) { return vxReleaseRemap(&ref); } -}; - -#ifdef IVX_USE_CXX98 - -/// Casting to vx_reference with compile-time check - -// takes 'vx_reference' itself and RefWrapper via 'operator vx_reference()' -inline vx_reference castToReference(vx_reference ref) -{ return ref; } - -// takes vx_reference extensions that have RefTypeTraits specializations -template -inline vx_reference castToReference(const T& ref, typename RefTypeTraits::vxType dummy = 0) -{ (void)dummy; return (vx_reference)ref; } - -#else - -template -struct is_ref : std::is_same{}; // allow vx_reference - -// allow RefWrapper<> types -template -#ifndef _MSC_VER -struct is_ref : std::true_type {}; -#else -// workarounding VC14 compiler crash -struct is_ref : std::true_type {}; -#endif - -// allow vx_reference extensions -template -struct is_ref::vxTypeEnum, void())> : std::true_type {}; - -/// Casting to vx_reference with compile-time check - -template -inline vx_reference castToReference(const T& obj) -{ - static_assert(is_ref::value, "unsupported conversion"); - return (vx_reference) obj; -} - -#endif // IVX_USE_CXX98 - -inline void checkVxRef(vx_reference ref, const std::string& func, const std::string& msg) -{ - vx_status status = vxGetStatus(ref); - if(status != VX_SUCCESS) throw RuntimeError( status, func + "() : " + msg ); -} - -/// Helper macro for checking the provided OpenVX 'object' and throwing a \RuntimeError in case of error -#define IVX_CHECK_REF(code) checkVxRef(castToReference(code), __func__, #code) - - -#ifdef IVX_USE_EXTERNAL_REFCOUNT - -/// Base class for OpenVX 'objects' wrappers -template class RefWrapper -{ -public: - typedef T vxType; - static const vx_enum vxTypeEnum = RefTypeTraits ::vxTypeEnum; - - /// Default constructor - RefWrapper() : ref(0), refcount(0) - {} - - /// Constructor - /// \param r OpenVX 'object' (e.g. vx_image) - /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default) - explicit RefWrapper(T r, bool retainRef = false) : ref(0), refcount(0) - { reset(r, retainRef); } - - /// Copy constructor - RefWrapper(const RefWrapper& r) : ref(r.ref), refcount(r.refcount) - { addRef(); } - -#ifndef IVX_USE_CXX98 - /// Move constructor - RefWrapper(RefWrapper&& rw) noexcept : RefWrapper() - { - using std::swap; - swap(ref, rw.ref); - swap(refcount, rw.refcount); - } -#endif - - /// Casting to the wrapped OpenVX 'object' - operator T() const - { return ref; } - - /// Casting to vx_reference since every OpenVX 'object' extends it - operator vx_reference() const - { return castToReference(ref); } - - /// Assigning a new value (decreasing ref counter for the old one) - /// \param r OpenVX 'object' (e.g. vx_image) - /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default) - void reset(T r, bool retainRef = false) - { - release(); - ref = r; -#ifdef VX_VERSION_1_1 - if(retainRef) addRef(); -#else - // if 'retainRef' -just don't use ref-counting for v 1.0 - if(!retainRef) refcount = new int(1); -#endif - checkRef(); - } - - /// Assigning an empty value (decreasing ref counter for the old one) - void reset() - { release(); } - - /// Dropping kept value without releas decreasing ref counter - /// \return the value being dropped - T detach() - { - T tmp = ref; - ref = 0; - release(); - return tmp; - } - - /// Unified assignment operator (covers both copy and move cases) - RefWrapper& operator=(RefWrapper r) - { - using std::swap; - swap(ref, r.ref); - swap(refcount, r.refcount); - return *this; - } - - /// Checking for non-empty - bool operator !() const - { return ref == 0; } - -#ifndef IVX_USE_CXX98 - /// Explicit boolean evaluation (called automatically inside conditional operators only) - explicit operator bool() const - { return ref != 0; } -#endif - - /// Getting a context that is kept in each OpenVX 'object' (call get()) - template - C get() const - { - typedef int static_assert_context[is_same::value ? 1 : -1]; - vx_context c = vxGetContext(castToReference(ref)); - // vxGetContext doesn't increment ref count, let do it in wrapper c-tor - return C(c, true); - } - -#ifndef IVX_USE_CXX98 - /// Getting a context that is kept in each OpenVX 'object' - template::value>::type> - C getContext() const - { - vx_context c = vxGetContext(castToReference(ref)); - // vxGetContext doesn't increment ref count, let do it in wrapper c-tor - return C(c, true); - } -#endif // IVX_USE_CXX98 - -protected: - T ref; - int* refcount; - - void addRef() - { -#ifdef VX_VERSION_1_1 - if(ref) IVX_CHECK_STATUS(vxRetainReference(castToReference(ref))); -#else //TODO: make thread-safe - if(refcount) ++(*refcount); -#endif - } - - void release() - { -#ifdef VX_VERSION_1_1 - if(ref) RefTypeTraits::release(ref); -#else //TODO: make thread-safe - if(refcount && --(*refcount) == 0) - { - if(ref) RefTypeTraits::release(ref); - ref = 0; - delete refcount; - refcount = 0; - } -#endif - } - - void checkRef() const - { - IVX_CHECK_REF(ref); - vx_enum type; - IVX_CHECK_STATUS(vxQueryReference((vx_reference)ref, VX_REF_ATTRIBUTE_TYPE, &type, sizeof(type))); - if (type != vxTypeEnum) throw WrapperError("incompatible reference type"); - } - - ~RefWrapper() - { release(); } -}; - -#ifdef IVX_USE_CXX98 - - #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \ - Class() : RefWrapper() {} \ - explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \ - Class(const Class& _obj) : RefWrapper(_obj) {} \ - \ - Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); swap(refcount, _obj.refcount); return *this; } - -#else - - #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \ - Class() : RefWrapper() {} \ - explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \ - Class(const Class& _obj) : RefWrapper(_obj) {} \ - Class(Class&& _obj) : RefWrapper(std::move(_obj)) {} \ - \ - Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); swap(refcount, _obj.refcount); return *this; } - -#endif // IVX_USE_CXX98 - -#else // not IVX_USE_EXTERNAL_REFCOUNT - -/// Base class for OpenVX 'objects' wrappers -template class RefWrapper -{ -public: - typedef T vxType; - static const vx_enum vxTypeEnum = RefTypeTraits ::vxTypeEnum; - - /// Default constructor - RefWrapper() : ref(0) - {} - - /// Constructor - /// \param r OpenVX 'object' (e.g. vx_image) - /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default) - explicit RefWrapper(T r, bool retainRef = false) : ref(0) - { reset(r, retainRef); } - - /// Copy constructor - RefWrapper(const RefWrapper& r) : ref(r.ref) - { addRef(); } - -#ifndef IVX_USE_CXX98 - /// Move constructor - RefWrapper(RefWrapper&& rw) noexcept : RefWrapper() - { - using std::swap; - swap(ref, rw.ref); - } -#endif - - /// Casting to the wrapped OpenVX 'object' - operator T() const - { return ref; } - - /// Casting to vx_reference since every OpenVX 'object' extends it - operator vx_reference() const - { return castToReference(ref); } - - /// Getting a context that is kept in each OpenVX 'object' (call get()) - template - C get() const - { - typedef int static_assert_context[is_same::value ? 1 : -1]; - vx_context c = vxGetContext(castToReference(ref)); - // vxGetContext doesn't increment ref count, let do it in wrapper c-tor - return C(c, true); - } - -#ifndef IVX_USE_CXX98 - /// Getting a context that is kept in each OpenVX 'object' - template::value>::type> - C getContext() const - { - vx_context c = vxGetContext(castToReference(ref)); - // vxGetContext doesn't increment ref count, let do it in wrapper c-tor - return C(c, true); - } -#endif // IVX_USE_CXX98 - - /// Assigning a new value (decreasing ref counter for the old one) - /// \param r OpenVX 'object' (e.g. vx_image) - /// \param retainRef flag indicating whether to increase ref counter in constructor (false by default) - void reset(T r, bool retainRef = false) - { - release(); - ref = r; - if (retainRef) addRef(); - checkRef(); - } - - /// Assigning an empty value (decreasing ref counter for the old one) - void reset() - { release(); } - - /// Dropping kept value without releas decreasing ref counter - /// \return the value being dropped - T detach() - { - T tmp = ref; - ref = 0; - return tmp; - } - - /// Unified assignment operator (covers both copy and move cases) - RefWrapper& operator=(RefWrapper r) - { - using std::swap; - swap(ref, r.ref); - return *this; - } - - /// Checking for non-empty - bool operator !() const - { return ref == 0; } - -#ifndef IVX_USE_CXX98 - /// Explicit boolean evaluation (called automatically inside conditional operators only) - explicit operator bool() const - { return ref != 0; } -#endif - -protected: - T ref; - - void addRef() - { if (ref) IVX_CHECK_STATUS(vxRetainReference((vx_reference)ref)); } - - void release() - { - if (ref) RefTypeTraits::release(ref); - ref = 0; - } - - void checkRef() const - { - IVX_CHECK_REF(ref); - vx_enum type; - IVX_CHECK_STATUS(vxQueryReference((vx_reference)ref, VX_REF_ATTRIBUTE_TYPE, &type, sizeof(type))); - if (type != vxTypeEnum) throw WrapperError("incompatible reference type"); - } - - ~RefWrapper() - { release(); } -}; - -#ifdef IVX_USE_CXX98 - - #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \ - Class() : RefWrapper() {} \ - explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \ - Class(const Class& _obj) : RefWrapper(_obj) {} \ - \ - Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); return *this; } - -#else - - #define IVX_REF_STD_CTORS_AND_ASSIGNMENT(Class) \ - Class() : RefWrapper() {} \ - explicit Class(Class::vxType _ref, bool retainRef = false) : RefWrapper(_ref, retainRef) {} \ - Class(const Class& _obj) : RefWrapper(_obj) {} \ - Class(Class&& _obj) : RefWrapper(std::move(_obj)) {} \ - \ - Class& operator=(Class _obj) { using std::swap; swap(ref, _obj.ref); return *this; } - -#endif // IVX_USE_CXX98 - -#endif // IVX_USE_EXTERNAL_REFCOUNT - -#ifndef VX_VERSION_1_1 -typedef vx_border_mode_t border_t; -#else -typedef vx_border_t border_t; -#endif - -/// vx_context wrapper -class Context : public RefWrapper -{ -public: - - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Context) - - /// vxCreateContext() wrapper - static Context create() - { return Context(vxCreateContext()); } - - /// vxGetContext() wrapper - template - static Context getFrom(const T& ref) - { - vx_context c = vxGetContext(castToReference(ref)); - // vxGetContext doesn't increment ref count, let do it in wrapper c-tor - return Context(c, true); - } - - /// vxLoadKernels() wrapper - void loadKernels(const std::string& module) - { IVX_CHECK_STATUS( vxLoadKernels(ref, module.c_str()) ); } - - /// vxQueryContext() wrapper - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS(vxQueryContext(ref, att, &value, sizeof(value))); } - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_CONTEXT_VENDOR_ID = VX_CONTEXT_ATTRIBUTE_VENDOR_ID, - VX_CONTEXT_VERSION = VX_CONTEXT_ATTRIBUTE_VERSION, - VX_CONTEXT_UNIQUE_KERNELS = VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNELS, - VX_CONTEXT_MODULES = VX_CONTEXT_ATTRIBUTE_MODULES, - VX_CONTEXT_REFERENCES = VX_CONTEXT_ATTRIBUTE_REFERENCES, - VX_CONTEXT_IMPLEMENTATION = VX_CONTEXT_ATTRIBUTE_IMPLEMENTATION, - VX_CONTEXT_EXTENSIONS_SIZE = VX_CONTEXT_ATTRIBUTE_EXTENSIONS_SIZE, - VX_CONTEXT_EXTENSIONS = VX_CONTEXT_ATTRIBUTE_EXTENSIONS, - VX_CONTEXT_CONVOLUTION_MAX_DIMENSION = VX_CONTEXT_ATTRIBUTE_CONVOLUTION_MAXIMUM_DIMENSION, - VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION = VX_CONTEXT_ATTRIBUTE_OPTICAL_FLOW_WINDOW_MAXIMUM_DIMENSION, - VX_CONTEXT_IMMEDIATE_BORDER = VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER_MODE, - VX_CONTEXT_UNIQUE_KERNEL_TABLE = VX_CONTEXT_ATTRIBUTE_UNIQUE_KERNEL_TABLE; -#endif - - /// vxQueryContext(VX_CONTEXT_VENDOR_ID) wrapper - vx_uint16 vendorID() const - { - vx_uint16 v; - query(VX_CONTEXT_VENDOR_ID, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_VERSION) wrapper - vx_uint16 version() const - { - vx_uint16 v; - query(VX_CONTEXT_VERSION, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_UNIQUE_KERNELS) wrapper - vx_uint32 uniqueKernelsNum() const - { - vx_uint32 v; - query(VX_CONTEXT_UNIQUE_KERNELS, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_MODULES) wrapper - vx_uint32 modulesNum() const - { - vx_uint32 v; - query(VX_CONTEXT_MODULES, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_REFERENCES) wrapper - vx_uint32 refsNum() const - { - vx_uint32 v; - query(VX_CONTEXT_REFERENCES, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_EXTENSIONS_SIZE) wrapper - vx_size extensionsSize() const - { - vx_size v; - query(VX_CONTEXT_EXTENSIONS_SIZE, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_CONVOLUTION_MAX_DIMENSION) wrapper - vx_size convolutionMaxDimension() const - { - vx_size v; - query(VX_CONTEXT_CONVOLUTION_MAX_DIMENSION, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION) wrapper - vx_size opticalFlowMaxWindowSize() const - { - vx_size v; - query(VX_CONTEXT_OPTICAL_FLOW_MAX_WINDOW_DIMENSION, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_IMMEDIATE_BORDER) wrapper - border_t immediateBorder() const - { - border_t v; - query(VX_CONTEXT_IMMEDIATE_BORDER, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_IMPLEMENTATION) wrapper - std::string implName() const - { - std::vector v(VX_MAX_IMPLEMENTATION_NAME); - IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_IMPLEMENTATION, &v[0], v.size() * sizeof(vx_char))); - return std::string(v.data()); - } - - /// vxQueryContext(VX_CONTEXT_EXTENSIONS) wrapper - std::string extensionsStr() const - { - std::vector v(extensionsSize()); - IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_EXTENSIONS, &v[0], v.size() * sizeof(vx_char))); - return std::string(v.data()); - } - - /// vxQueryContext(VX_CONTEXT_UNIQUE_KERNEL_TABLE) wrapper - std::vector kernelTable() const - { - std::vector v(uniqueKernelsNum()); - IVX_CHECK_STATUS(vxQueryContext(ref, VX_CONTEXT_UNIQUE_KERNEL_TABLE, &v[0], v.size() * sizeof(vx_kernel_info_t))); - return v; - } - -#ifdef VX_VERSION_1_1 - /// vxQueryContext(VX_CONTEXT_IMMEDIATE_BORDER_POLICY) wrapper - vx_enum immediateBorderPolicy() const - { - vx_enum v; - query(VX_CONTEXT_IMMEDIATE_BORDER_POLICY, v); - return v; - } - - /// vxQueryContext(VX_CONTEXT_NONLINEAR_MAX_DIMENSION) wrapper - vx_size nonlinearMaxDimension() const - { - vx_size v; - query(VX_CONTEXT_NONLINEAR_MAX_DIMENSION, v); - return v; - } -#endif - - /// vxSetContextAttribute() wrapper - template - void setAttribute(vx_enum att, const T& value) - { IVX_CHECK_STATUS( vxSetContextAttribute(ref, att, &value, sizeof(value)) ); } - - /// vxSetContextAttribute(BORDER) wrapper - void setImmediateBorder(const border_t& bm) - { setAttribute(VX_CONTEXT_IMMEDIATE_BORDER, bm); } - -#ifndef VX_VERSION_1_1 - /// vxSetContextAttribute(BORDER) wrapper - void setImmediateBorder(vx_enum mode, vx_uint32 val = 0) - { border_t bm = {mode, val}; setImmediateBorder(bm); } -#else - /// vxSetContextAttribute(BORDER) wrapper - void setImmediateBorder(vx_enum mode, const vx_pixel_value_t& val) - { border_t bm = {mode, val}; setImmediateBorder(bm); } - - /// vxSetContextAttribute(BORDER) wrapper - template - void setImmediateBorder(vx_enum mode, const T& _val) - { - vx_pixel_value_t val; - switch (TypeToEnum::value) - { - case VX_TYPE_UINT8: - val.U8 = _val; - break; - case VX_TYPE_INT16: - val.S16 = _val; - break; - case VX_TYPE_UINT16: - val.U16 = _val; - break; - case VX_TYPE_INT32: - val.S32 = _val; - break; - case VX_TYPE_UINT32: - val.U32 = _val; - break; - default: - throw WrapperError("Unsupported constant border value type"); - } - setImmediateBorder(mode, val); - } - - /// vxSetContextAttribute(BORDER) wrapper - void setImmediateBorder(vx_enum mode) - { vx_pixel_value_t val = {}; setImmediateBorder(mode, val); } -#endif -}; - -/// vx_graph wrapper -class Graph : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Graph); - - /// vxCreateGraph() wrapper - static Graph create(vx_context c) - { return Graph(vxCreateGraph(c)); } - - /// vxVerifyGraph() wrapper - void verify() - { IVX_CHECK_STATUS( vxVerifyGraph(ref) ); } - - /// vxProcessGraph() wrapper - void process() - { IVX_CHECK_STATUS( vxProcessGraph(ref) ); } - - /// vxScheduleGraph() wrapper - void schedule() - { IVX_CHECK_STATUS(vxScheduleGraph(ref) ); } - - /// vxWaitGraph() wrapper - void wait() - { IVX_CHECK_STATUS(vxWaitGraph(ref)); } -}; - -/// vx_kernel wrapper -class Kernel : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Kernel); - - /// vxGetKernelByEnum() wrapper - static Kernel getByEnum(vx_context c, vx_enum kernelID) - { return Kernel(vxGetKernelByEnum(c, kernelID)); } - - /// vxGetKernelByName() wrapper - static Kernel getByName(vx_context c, const std::string& name) - { return Kernel(vxGetKernelByName(c, name.c_str())); } -}; - - -/// vx_node wrapper -class Node : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Node); - - /// vxCreateGenericNode() wrapper - static Node create(vx_graph g, vx_kernel k) - { return Node(vxCreateGenericNode(g, k)); } - - /// Create node for the kernel and set the parameters - static Node create(vx_graph graph, vx_kernel kernel, const std::vector& params) - { - Node node = Node::create(graph, kernel); - vx_uint32 i = 0; - for (std::vector::const_iterator p = params.begin(); p != params.end(); ++p) - node.setParameterByIndex(i++, *p); - return node; - } - - /// Create node for the kernel ID and set the parameters - static Node create(vx_graph graph, vx_enum kernelID, const std::vector& params) - { return Node::create(graph, Kernel::getByEnum(Context::getFrom(graph), kernelID), params); } - -#ifdef IVX_USE_CXX98 - /// Create node for the kernel ID and set one parameter - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0) - { - std::vector params; - params.push_back(castToReference(arg0)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set two parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set three parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set four parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set five parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set six parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4, const T5& arg5) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - params.push_back(castToReference(arg5)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set seven parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4, const T5& arg5, - const T6& arg6) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - params.push_back(castToReference(arg5)); - params.push_back(castToReference(arg6)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set eight parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4, const T5& arg5, - const T6& arg6, const T7& arg7) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - params.push_back(castToReference(arg5)); - params.push_back(castToReference(arg6)); - params.push_back(castToReference(arg7)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set nine parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4, const T5& arg5, - const T6& arg6, const T7& arg7, const T8& arg8) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - params.push_back(castToReference(arg5)); - params.push_back(castToReference(arg6)); - params.push_back(castToReference(arg7)); - params.push_back(castToReference(arg8)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - - /// Create node for the kernel ID and set ten parameters - template - static Node create(vx_graph g, vx_enum kernelID, - const T0& arg0, const T1& arg1, const T2& arg2, - const T3& arg3, const T4& arg4, const T5& arg5, - const T6& arg6, const T7& arg7, const T8& arg8, - const T9& arg9) - { - std::vector params; - params.push_back(castToReference(arg0)); - params.push_back(castToReference(arg1)); - params.push_back(castToReference(arg2)); - params.push_back(castToReference(arg3)); - params.push_back(castToReference(arg4)); - params.push_back(castToReference(arg5)); - params.push_back(castToReference(arg6)); - params.push_back(castToReference(arg7)); - params.push_back(castToReference(arg8)); - params.push_back(castToReference(arg9)); - return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), params); - } - -#else // not IVX_USE_CXX98 - - /// Create node for the kernel ID and set the specified parameters - template - static Node create(vx_graph g, vx_enum kernelID, const Ts&...args) - { return create(g, Kernel::getByEnum(Context::getFrom(g), kernelID), { castToReference(args)... }); } - -#endif // IVX_USE_CXX98 - - /// vxSetParameterByIndex() wrapper - void setParameterByIndex(vx_uint32 index, vx_reference value) - { IVX_CHECK_STATUS(vxSetParameterByIndex(ref, index, value)); } - - /// vxQueryNode() wrapper - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryNode(ref, att, &value, sizeof(value)) ); } - -#ifndef VX_VERSION_1_1 -static const vx_enum - VX_NODE_STATUS = VX_NODE_ATTRIBUTE_STATUS, - VX_NODE_PERFORMANCE = VX_NODE_ATTRIBUTE_PERFORMANCE, - VX_NODE_BORDER = VX_NODE_ATTRIBUTE_BORDER_MODE, - VX_NODE_LOCAL_DATA_SIZE = VX_NODE_ATTRIBUTE_LOCAL_DATA_SIZE, - VX_NODE_LOCAL_DATA_PTR = VX_NODE_ATTRIBUTE_LOCAL_DATA_PTR, - VX_BORDER_UNDEFINED = VX_BORDER_MODE_UNDEFINED; -#endif - - /// vxQueryNode(STATUS) wrapper - vx_status status() const - { - vx_status v; - query(VX_NODE_STATUS, v); - return v; - } - - /// vxQueryNode(PERFORMANCE) wrapper - vx_perf_t performance() const - { - vx_perf_t v; - query(VX_NODE_PERFORMANCE, v); - return v; - } - - /// vxQueryNode(BORDER) wrapper - border_t border() const - { - border_t v; - v.mode = VX_BORDER_UNDEFINED; - query(VX_NODE_BORDER, v); - return v; - } - - /// vxQueryNode(LOCAL_DATA_SIZE) wrapper - vx_size dataSize() const - { - vx_size v; - query(VX_NODE_LOCAL_DATA_SIZE, v); - return v; - } - - /// vxQueryNode(LOCAL_DATA_PTR) wrapper - void* dataPtr() const - { - void* v; - query(VX_NODE_LOCAL_DATA_PTR, v); - return v; - } - -#ifdef VX_VERSION_1_1 - /// vxQueryNode(PARAMETERS) wrapper - vx_uint32 paramsNum() const - { - vx_uint32 v; - query(VX_NODE_PARAMETERS, v); - return v; - } - - /// vxQueryNode(REPLICATED) wrapper - vx_bool isReplicated() const - { - vx_bool v; - query(VX_NODE_IS_REPLICATED, v); - return v; - } - - /// vxQueryNode(REPLICATE_FLAGS) wrapper - void replicateFlags(std::vector& flags) const - { - if(flags.empty()) flags.resize(paramsNum(), vx_false_e); - IVX_CHECK_STATUS( vxQueryNode(ref, VX_NODE_REPLICATE_FLAGS, &flags[0], flags.size()*sizeof(flags[0])) ); - } - - /// vxQueryNode(VX_NODE_VALID_RECT_RESET) wrapper - vx_bool resetValidRect() const - { - vx_bool v; - query(VX_NODE_VALID_RECT_RESET, v); - return v; - } -#endif // VX_VERSION_1_1 - - /// vxSetNodeAttribute() wrapper - template - void setAttribute(vx_enum att, const T& value) - { IVX_CHECK_STATUS( vxSetNodeAttribute(ref, att, &value, sizeof(value)) ); } - - /// vxSetNodeAttribute(BORDER) wrapper - void setBorder(const border_t& bm) - { setAttribute(VX_NODE_BORDER, bm); } - -#ifndef VX_VERSION_1_1 - /// vxSetNodeAttribute(BORDER) wrapper - void setBorder(vx_enum mode, vx_uint32 val = 0) - { vx_border_mode_t bm = {mode, val}; setBorder(bm); } -#else - /// vxSetNodeAttribute(BORDER) wrapper - void setBorder(vx_enum mode, const vx_pixel_value_t& val) - { vx_border_t bm = {mode, val}; setBorder(bm); } - - /// vxSetNodeAttribute(BORDER) wrapper - template - void setBorder(vx_enum mode, const T& _val) - { - vx_pixel_value_t val; - switch (TypeToEnum::value) - { - case VX_TYPE_UINT8: - val.U8 = _val; - break; - case VX_TYPE_INT16: - val.S16 = _val; - break; - case VX_TYPE_UINT16: - val.U16 = _val; - break; - case VX_TYPE_INT32: - val.S32 = _val; - break; - case VX_TYPE_UINT32: - val.U32 = _val; - break; - default: - throw WrapperError("Unsupported constant border value type"); - } - setBorder(mode, val); - } - - /// vxSetNodeAttribute(BORDER) wrapper - void setBorder(vx_enum mode) - { vx_pixel_value_t val = {}; setBorder(mode, val); } -#endif - - /// vxSetNodeAttribute(LOCAL_DATA_SIZE) wrapper - void setDataSize(vx_size size) - { setAttribute(VX_NODE_LOCAL_DATA_SIZE, size); } - - /// vxSetNodeAttribute(LOCAL_DATA_PTR) wrapper - void setDataPtr(void* ptr) - { setAttribute(VX_NODE_LOCAL_DATA_PTR, ptr); } -}; - - -/// vx_image wrapper -class Image : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Image); - - /// vxCreateImage() wrapper - static Image create(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format) - { return Image(vxCreateImage(context, width, height, format)); } - - /// vxCreateVirtualImage() wrapper - static Image createVirtual(vx_graph graph, vx_uint32 width = 0, vx_uint32 height = 0, vx_df_image format = VX_DF_IMAGE_VIRT) - { return Image(vxCreateVirtualImage(graph, width, height, format)); } - -#ifdef VX_VERSION_1_1 - /// vxCreateUniformImage() wrapper - static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const vx_pixel_value_t& value) - { return Image(vxCreateUniformImage(context, width, height, format, &value)); } -#else - /// vxCreateUniformImage() wrapper - static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const void* value) - { return Image(vxCreateUniformImage(context, width, height, format, value)); } -#endif - template - static Image createUniform(vx_context context, vx_uint32 width, vx_uint32 height, vx_df_image format, const T value) - { -#if VX_VERSION > VX_VERSION_1_0 - vx_pixel_value_t pixel; - switch (format) - { - case VX_DF_IMAGE_U8:pixel.U8 = (vx_uint8)value; break; - case VX_DF_IMAGE_S16:pixel.S16 = (vx_int16)value; break; - case VX_DF_IMAGE_U16:pixel.U16 = (vx_uint16)value; break; - case VX_DF_IMAGE_S32:pixel.S32 = (vx_int32)value; break; - case VX_DF_IMAGE_U32:pixel.U32 = (vx_uint32)value; break; - default:throw ivx::WrapperError("uniform image type unsupported by this call"); - } - return Image(vxCreateUniformImage(context, width, height, format, &pixel)); -#else - return Image(vxCreateUniformImage(context, width, height, format, &value)); -#endif - } - - /// Planes number for the specified image format (fourcc) - /// \return 0 for unknown formats - static vx_size planes(vx_df_image format) - { - switch (format) - { - case VX_DF_IMAGE_IYUV: - case VX_DF_IMAGE_YUV4: return 3; - case VX_DF_IMAGE_NV12: - case VX_DF_IMAGE_NV21: return 2; - case VX_DF_IMAGE_RGB: - case VX_DF_IMAGE_RGBX: - case VX_DF_IMAGE_UYVY: - case VX_DF_IMAGE_YUYV: - case VX_DF_IMAGE_U8: - case VX_DF_IMAGE_U16: - case VX_DF_IMAGE_S16: - case VX_DF_IMAGE_U32: - case VX_DF_IMAGE_S32: - case /*VX_DF_IMAGE_F32*/VX_DF_IMAGE('F', '0', '3', '2'): - return 1; - default: return 0; - } - } - - /// Create vx_imagepatch_addressing_t structure with default values - static vx_imagepatch_addressing_t createAddressing() - { vx_imagepatch_addressing_t ipa = VX_IMAGEPATCH_ADDR_INIT; return ipa; } - - /// Create vx_imagepatch_addressing_t structure with the provided values - static vx_imagepatch_addressing_t createAddressing( - vx_uint32 dimX, vx_uint32 dimY, - vx_int32 strideX, vx_int32 strideY, - vx_uint32 scaleX = VX_SCALE_UNITY, vx_uint32 scaleY = VX_SCALE_UNITY ) - { - if (std::abs(strideY) < std::abs(strideX*(vx_int32)dimX)) - throw WrapperError(std::string(__func__)+"(): invalid arguments"); - vx_imagepatch_addressing_t ipa = VX_IMAGEPATCH_ADDR_INIT; - ipa.dim_x = dimX; - ipa.dim_y = dimY; - ipa.stride_x = strideX; - ipa.stride_y = strideY; - ipa.scale_x = scaleX; - ipa.scale_y = scaleY; - return ipa; - } - - /// Create vx_imagepatch_addressing_t structure for the specified image plane and its valid region - vx_imagepatch_addressing_t createAddressing(vx_uint32 planeIdx) - { return createAddressing(planeIdx, getValidRegion()); } - - /// Create vx_imagepatch_addressing_t structure for the specified image plane and the provided region - vx_imagepatch_addressing_t createAddressing(vx_uint32 planeIdx, const vx_rectangle_t& rect) - { - vx_uint32 w = rect.end_x-rect.start_x, h = rect.end_y-rect.start_y; - vx_size patchBytes = computePatchSize(planeIdx, rect); - vx_imagepatch_addressing_t ipa = createAddressing(w, h, (vx_int32)(patchBytes/w/h), (vx_int32)(patchBytes/h)); - return ipa; - } - -#ifndef VX_VERSION_1_1 - static const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST; -#endif - /// vxCreateImageFromHandle() wrapper - static Image createFromHandle( - vx_context context, vx_df_image format, - const std::vector& addrs, - const std::vector& ptrs, vx_enum memType = VX_MEMORY_TYPE_HOST ) - { - vx_size num = planes(format); - if(num == 0) - throw WrapperError(std::string(__func__)+"(): unknown/unexpected planes number for the requested format"); - if (addrs.size() != num || ptrs.size() != num) - throw WrapperError(std::string(__func__)+"(): incomplete input"); -#ifdef VX_VERSION_1_1 - return Image(vxCreateImageFromHandle(context, format, &addrs[0], &ptrs[0], memType)); -#else - return Image( vxCreateImageFromHandle(context, format, - const_cast(&addrs[0]), - const_cast(&ptrs[0]), memType) ); -#endif - } - - /// vxCreateImageFromHandle() wrapper for a single plane image - static Image createFromHandle(vx_context context, vx_df_image format,const vx_imagepatch_addressing_t& addr, void* ptr) - { - if(planes(format) != 1) throw WrapperError(std::string(__func__)+"(): not a single plane format"); - return Image(vxCreateImageFromHandle(context, format, const_cast (&addr), &ptr, VX_MEMORY_TYPE_HOST)); - } - -#ifdef VX_VERSION_1_1 - /// vxSwapImageHandle() wrapper - /// \param newPtrs keeps addresses of new image planes data, can be of image planes size or empty when new pointers are not provided - /// \param prevPtrs storage for the previous addresses of image planes data, can be of image planes size or empty when previous pointers are not needed - void swapHandle(const std::vector& newPtrs, std::vector& prevPtrs) - { - vx_size num = planes(); - if(num == 0) - throw WrapperError(std::string(__func__)+"(): unexpected planes number"); - if (!newPtrs.empty() && newPtrs.size() != num) - throw WrapperError(std::string(__func__)+"(): unexpected number of input pointers"); - if (!prevPtrs.empty() && prevPtrs.size() != num) - throw WrapperError(std::string(__func__)+"(): unexpected number of output pointers"); - IVX_CHECK_STATUS( vxSwapImageHandle( ref, - newPtrs.empty() ? 0 : &newPtrs[0], - prevPtrs.empty() ? 0 : &prevPtrs[0], - num ) ); - } - - /// vxSwapImageHandle() wrapper for a single plane image - /// \param newPtr an address of new image data, can be zero when new pointer is not provided - /// \return the previuos address of image data - void* swapHandle(void* newPtr) - { - if(planes() != 1) throw WrapperError(std::string(__func__)+"(): not a single plane image"); - void* prevPtr = 0; - IVX_CHECK_STATUS( vxSwapImageHandle(ref, &newPtr, &prevPtr, 1) ); - return prevPtr; - } - - /// vxSwapImageHandle() wrapper for the case when no new pointers provided and previous ones are not needed (retrive memory back) - void swapHandle() - { IVX_CHECK_STATUS( vxSwapImageHandle(ref, 0, 0, 0) ); } - - /// vxCreateImageFromChannel() wrapper - Image createFromChannel(vx_enum channel) - { return Image(vxCreateImageFromChannel(ref, channel)); } -#endif // VX_VERSION_1_1 - - /// vxQueryImage() wrapper - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryImage(ref, att, &value, sizeof(value)) ); } - -#ifndef VX_VERSION_1_1 -static const vx_enum - VX_IMAGE_WIDTH = VX_IMAGE_ATTRIBUTE_WIDTH, - VX_IMAGE_HEIGHT = VX_IMAGE_ATTRIBUTE_HEIGHT, - VX_IMAGE_FORMAT = VX_IMAGE_ATTRIBUTE_FORMAT, - VX_IMAGE_PLANES = VX_IMAGE_ATTRIBUTE_PLANES, - VX_IMAGE_SPACE = VX_IMAGE_ATTRIBUTE_SPACE, - VX_IMAGE_RANGE = VX_IMAGE_ATTRIBUTE_RANGE, - VX_IMAGE_SIZE = VX_IMAGE_ATTRIBUTE_SIZE; -#endif - - /// vxQueryImage(VX_IMAGE_WIDTH) wrapper - vx_uint32 width() const - { - vx_uint32 v; - query(VX_IMAGE_WIDTH, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_HEIGHT) wrapper - vx_uint32 height() const - { - vx_uint32 v; - query(VX_IMAGE_HEIGHT, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_FORMAT) wrapper - vx_df_image format() const - { - vx_df_image v; - query(VX_IMAGE_FORMAT, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_PLANES) wrapper - vx_size planes() const - { - vx_size v; - query(VX_IMAGE_PLANES, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_SPACE) wrapper - vx_enum space() const - { - vx_enum v; - query(VX_IMAGE_SPACE, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_RANGE) wrapper - vx_enum range() const - { - vx_enum v; - query(VX_IMAGE_RANGE, v); - return v; - } - - /// vxQueryImage(VX_IMAGE_SIZE) wrapper - vx_size size() const - { - vx_size v; - query(VX_IMAGE_SIZE, v); - return v; - } - -#ifdef VX_VERSION_1_1 - /// vxQueryImage(VX_IMAGE_MEMORY_TYPE) wrapper - vx_memory_type_e memType() const - { - vx_memory_type_e v; - query(VX_IMAGE_MEMORY_TYPE, v); - return v; - } -#endif // VX_VERSION_1_1 - - /// vxSetImageAttribute() wrapper - template - void setAttribute(vx_enum att, T& value) const - { IVX_CHECK_STATUS(vxSetImageAttribute(ref, att, &value, sizeof(value))); } - - /// vxSetImageAttribute(SPACE) wrapper - void setColorSpace(const vx_enum& sp) - { setAttribute(VX_IMAGE_SPACE, sp); } - - /// vxGetValidRegionImage() wrapper - vx_rectangle_t getValidRegion() const - { - vx_rectangle_t rect; - IVX_CHECK_STATUS( vxGetValidRegionImage(ref, &rect) ); - return rect; - } - - /// vxComputeImagePatchSize(valid region) wrapper - vx_size computePatchSize(vx_uint32 planeIdx) - { return computePatchSize(planeIdx, getValidRegion()); } - - /// vxComputeImagePatchSize() wrapper - vx_size computePatchSize(vx_uint32 planeIdx, const vx_rectangle_t& rect) - { - vx_size bytes = vxComputeImagePatchSize(ref, &rect, planeIdx); - if (bytes == 0) throw WrapperError(std::string(__func__)+"(): vxComputeImagePatchSize returned 0"); - return bytes; - } - -#ifdef VX_VERSION_1_1 - /// vxSetImageValidRectangle() wrapper - void setValidRectangle(const vx_rectangle_t& rect) - { IVX_CHECK_STATUS( vxSetImageValidRectangle(ref, &rect) ); } -#endif // VX_VERSION_1_1 - - /// Copy image plane content to the provided memory - void copyTo(vx_uint32 planeIdx, const vx_imagepatch_addressing_t& addr, void* data) - { - if(!data) throw WrapperError(std::string(__func__)+"(): output pointer is 0"); - vx_rectangle_t r = getValidRegion(); - // TODO: add sizes consistency checks - /* - vx_uint32 w = r.end_x - r.start_x, h = r.end_y - r.start_y; - if (w != addr.dim_x) throw WrapperError("Image::copyTo(): inconsistent dimension X"); - if (h != addr.dim_y) throw WrapperError("Image::copyTo(): inconsistent dimension Y"); - */ -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyImagePatch(ref, &r, planeIdx, &addr, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); -#else - vx_imagepatch_addressing_t* a = const_cast(&addr); - IVX_CHECK_STATUS(vxAccessImagePatch(ref, &r, planeIdx, a, &data, VX_READ_ONLY)); - IVX_CHECK_STATUS(vxCommitImagePatch(ref, 0, planeIdx, a, data)); -#endif - } - - /// Copy the provided memory data to the specified image plane - void copyFrom(vx_uint32 planeIdx, const vx_imagepatch_addressing_t& addr, const void* data) - { - if (!data) throw WrapperError(std::string(__func__)+"(): input pointer is 0"); - vx_rectangle_t r = getValidRegion(); - // TODO: add sizes consistency checks - /* - vx_uint32 w = r.end_x - r.start_x, h = r.end_y - r.start_y; - //vx_size patchBytes = vxComputeImagePatchSize(ref, &r, planeIdx); - if (w != addr.dim_x) throw WrapperError("Image::copyFrom(): inconsistent dimension X"); - if (h != addr.dim_y) throw WrapperError("Image::copyFrom(): inconsistent dimension Y"); - */ -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyImagePatch(ref, &r, planeIdx, &addr, (void*)data, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - vx_imagepatch_addressing_t* a = const_cast(&addr); - IVX_CHECK_STATUS(vxAccessImagePatch(ref, &r, planeIdx, a, const_cast(&data), VX_WRITE_ONLY)); - IVX_CHECK_STATUS(vxCommitImagePatch(ref, &r, planeIdx, a, data)); -#endif - } - - /// vxCopyImagePatch() wrapper (or vxAccessImagePatch() + vxCommitImagePatch() for OpenVX 1.0) - void copy( vx_uint32 planeIdx, vx_rectangle_t rect, - const vx_imagepatch_addressing_t& addr, void* data, - vx_enum usage, vx_enum memoryType = VX_MEMORY_TYPE_HOST ) - { -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyImagePatch(ref, &rect, planeIdx, &addr, (void*)data, usage, memoryType)); -#else - (void)memoryType; - vx_imagepatch_addressing_t* a = const_cast(&addr); - IVX_CHECK_STATUS(vxAccessImagePatch(ref, &rect, planeIdx, a, &data, usage)); - IVX_CHECK_STATUS(vxCommitImagePatch(ref, &rect, planeIdx, a, data)); -#endif - } - -#ifdef IVX_USE_OPENCV - /// Convert image format (fourcc) to cv::Mat type, throws WrapperError if not possible - static int formatToMatType(vx_df_image format, vx_uint32 planeIdx = 0) - { - switch (format) - { - case VX_DF_IMAGE_RGB: return CV_8UC3; - case VX_DF_IMAGE_RGBX: return CV_8UC4; - case VX_DF_IMAGE_U8: return CV_8UC1; - case VX_DF_IMAGE_U16: return CV_16UC1; - case VX_DF_IMAGE_S16: return CV_16SC1; - case VX_DF_IMAGE_U32: - case VX_DF_IMAGE_S32: return CV_32SC1; - case VX_DF_IMAGE('F', '0', '3', '2'): - return CV_32FC1; - case VX_DF_IMAGE_YUV4: - case VX_DF_IMAGE_IYUV: return CV_8UC1; - case VX_DF_IMAGE_UYVY: - case VX_DF_IMAGE_YUYV: return CV_8UC2; - case VX_DF_IMAGE_NV12: - case VX_DF_IMAGE_NV21: return planeIdx == 0 ? CV_8UC1 : CV_8UC2; - default: throw WrapperError(std::string(__func__)+"(): unsupported image format"); - } - } - - /// Convert cv::Mat type to standard image format (fourcc), throws WrapperError if not possible - static vx_df_image matTypeToFormat(int matType) - { - switch (matType) - { - case CV_8UC4: return VX_DF_IMAGE_RGBX; - case CV_8UC3: return VX_DF_IMAGE_RGB; - case CV_8UC1: return VX_DF_IMAGE_U8; - case CV_16UC1: return VX_DF_IMAGE_U16; - case CV_16SC1: return VX_DF_IMAGE_S16; - case CV_32SC1: return VX_DF_IMAGE_S32; - case CV_32FC1: return VX_DF_IMAGE('F', '0', '3', '2'); - default: throw WrapperError(std::string(__func__)+"(): unsupported cv::Mat type"); - } - } - - /// Initialize cv::Mat shape to fit the specified image plane data - void createMatForPlane(cv::Mat& m, vx_uint32 planeIdx) - { - vx_df_image f = format(); - //vx_uint32 w = width(), h = height(); - vx_rectangle_t r = getValidRegion(); - vx_int32 w = vx_int32(r.end_x - r.start_x), h = vx_int32(r.end_y - r.start_y); - switch (f) - { - case VX_DF_IMAGE_IYUV: - if (planeIdx == 0u) m.create(h, w, formatToMatType(f)); - else if (planeIdx == 1u || planeIdx == 2u) m.create(h/2, w/2, formatToMatType(f)); - else throw WrapperError(std::string(__func__)+"(): wrong plane index"); - break; - case VX_DF_IMAGE_YUV4: - if (planeIdx == 0u || planeIdx == 1u || planeIdx == 2u) m.create(h, w, formatToMatType(f)); - else throw WrapperError(std::string(__func__)+"(): wrong plane index"); - break; - case VX_DF_IMAGE_NV12: - case VX_DF_IMAGE_NV21: - if (planeIdx == 0u) m.create(h, w, formatToMatType(f, 0)); - else if (planeIdx == 1u) m.create(h/2, w/2, formatToMatType(f, 1)); - else throw WrapperError(std::string(__func__)+"(): wrong plane index"); - break; - case VX_DF_IMAGE_RGB: - case VX_DF_IMAGE_RGBX: - case VX_DF_IMAGE_UYVY: - case VX_DF_IMAGE_YUYV: - case VX_DF_IMAGE_U8: - case VX_DF_IMAGE_U16: - case VX_DF_IMAGE_S16: - case VX_DF_IMAGE_U32: - case VX_DF_IMAGE_S32: - case /*VX_DF_IMAGE_F32*/VX_DF_IMAGE('F', '0', '3', '2'): - if(planeIdx == 0u) m.create(h, w, formatToMatType(f)); - else throw WrapperError(std::string(__func__)+"(): wrong plane index"); - break; - default: throw WrapperError(std::string(__func__)+"(): unsupported color format"); - } - } - - /// Create vx_imagepatch_addressing_t corresponding to the provided cv::Mat - static vx_imagepatch_addressing_t createAddressing(const cv::Mat& m) - { - if(m.empty()) throw WrapperError(std::string(__func__)+"(): empty input Mat"); - return createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step); - } - - /// Copy image plane content to the provided cv::Mat (reallocate if needed) - void copyTo(vx_uint32 planeIdx, cv::Mat& m) - { - createMatForPlane(m, planeIdx); - copyTo(planeIdx, createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step), m.ptr()); - } - - /// Copy the provided cv::Mat data to the specified image plane - void copyFrom(vx_uint32 planeIdx, const cv::Mat& m) - { - if(m.empty()) throw WrapperError(std::string(__func__)+"(): empty input Mat"); - // TODO: add sizes consistency checks - //vx_rectangle_t r = getValidRegion(); - copyFrom(planeIdx, createAddressing((vx_uint32)m.cols, (vx_uint32)m.rows, (vx_int32)m.elemSize(), (vx_int32)m.step), m.ptr()); - } - -/* -private: - cv::Mat _mat; // TODO: update copy/move-c-tors, operator=() and swapHandles() -public: - static Image createFromHandle(vx_context context, const cv::Mat& mat) - { - if(mat.empty()) throw WrapperError(std::string(__func__)+"(): empty cv::Mat"); - Image res = createFromHandle(context, matTypeToFormat(mat.type()), createAddressing(mat), mat.data ); - res._mat = mat; - return res; - } -*/ -#endif //IVX_USE_OPENCV - - struct Patch; -}; - -/// Helper class for a mapping vx_image patch -struct Image::Patch -{ -public: - /// reference to the current vx_imagepatch_addressing_t - const vx_imagepatch_addressing_t& addr() const - { return _addr;} - - /// current pixels data pointer - void* data() const - { return _data; } - -#ifdef VX_VERSION_1_1 - /// vx_memory_type_e for the current data pointer - vx_memory_type_e memType() const - { return _memType; } - - /// vx_map_id for the current mapping - vx_map_id mapId() const - { return _mapId; } -#else - /// reference to vx_rectangle_t for the current mapping - const vx_rectangle_t& rectangle() const - { return _rect; } - - /// Image plane index for the current mapping - vx_uint32 planeIndex() const - { return _planeIdx; } -#endif // VX_VERSION_1_1 - - /// vx_image for the current mapping - vx_image image() const - { return _img; } - - /// where this patch is mapped - bool isMapped() const - { return _img != 0; } - -#ifdef IVX_USE_OPENCV - /// Reference to cv::Mat instance wrapping the mapped image data, becomes invalid after unmap() - cv::Mat& getMat() - { return _m; } -#endif //IVX_USE_OPENCV - -protected: - vx_imagepatch_addressing_t _addr; - void* _data; - vx_image _img; -#ifdef VX_VERSION_1_1 - vx_memory_type_e _memType; - vx_map_id _mapId; -#else - vx_rectangle_t _rect; - vx_uint32 _planeIdx; -#endif -#ifdef IVX_USE_OPENCV - cv::Mat _m; -#endif - -public: - /// Default constructor - Patch() : _addr(createAddressing()), _data(0), _img(0) -#ifdef VX_VERSION_1_1 - , _memType(VX_MEMORY_TYPE_HOST), _mapId(0) - {} -#else - , _planeIdx(-1) - { _rect.start_x = _rect.end_x = _rect.start_y = _rect.end_y = 0u; } -#endif - -#ifndef IVX_USE_CXX98 - /// Move constructor - Patch(Patch&& p) : Patch() - { - using std::swap; - swap(_addr, p._addr); - swap(_data, p._data); -#ifdef VX_VERSION_1_1 - swap(_memType, p._memType); - swap(_mapId, p._mapId); -#else - swap(_rect, p._rect); - swap(_planeIdx, p._planeIdx); -#endif - swap(_img, p._img); -#ifdef IVX_USE_OPENCV - swap(_m, p._m); -#endif - } -#endif - - /// vxMapImagePatch(VX_READ_ONLY, planeIdx valid region) - void map(vx_image img, vx_uint32 planeIdx) - { map(img, planeIdx, Image(img, true).getValidRegion()); } - - /// vxMapImagePatch() wrapper (or vxAccessImagePatch() for 1.0) - void map(vx_image img, vx_uint32 planeIdx, const vx_rectangle_t& rect, vx_enum usage = VX_READ_ONLY, vx_uint32 flags = 0) - { - if (isMapped()) throw WrapperError(std::string(__func__)+"(): already mapped"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxMapImagePatch(img, &rect, planeIdx, &_mapId, &_addr, &_data, usage, _memType, flags) ); -#else - IVX_CHECK_STATUS(vxAccessImagePatch(img, &rect, planeIdx, &_addr, &_data, usage)); - (void)flags; - _rect = rect; - _planeIdx = planeIdx; -#endif - if (_data == 0) throw WrapperError(std::string(__func__)+"(): mapped address is null"); - _img = img; -#ifdef IVX_USE_OPENCV - vx_df_image format; - IVX_CHECK_STATUS( vxQueryImage(_img, VX_IMAGE_FORMAT, &format, sizeof(format)) ); - int matType = formatToMatType(format); - _m = cv::Mat( vx_int32((vx_int64)_addr.dim_y * VX_SCALE_UNITY / _addr.scale_y), - vx_int32((vx_int64)_addr.dim_x * VX_SCALE_UNITY / _addr.scale_x), - matType, _data, std::size_t(_addr.stride_y) ); -#endif - } - - /// vxUnmapImagePatch() wrapper (or vxCommitImagePatch() for 1.0) - void unmap() - { -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxUnmapImagePatch(_img, _mapId)); - _mapId = 0; -#else - IVX_CHECK_STATUS(vxCommitImagePatch(_img, &_rect, _planeIdx, &_addr, _data)); - _rect.start_x = _rect.end_x = _rect.start_y = _rect.end_y = 0u; - _planeIdx = -1; - -#endif - _img = 0; - _data = 0; - _addr = createAddressing(); -#ifdef IVX_USE_OPENCV - _m.release(); -#endif - } - - /// Destructor - ~Patch() - { try { if (_img) unmap(); } catch(...) {; /*ignore*/} } - - /// Pointer to the specified pixel data (vxFormatImagePatchAddress2d) - void* pixelPtr(vx_uint32 x, vx_uint32 y) - { - if (!_data) throw WrapperError(std::string(__func__)+"(): base pointer is NULL"); - if (x >= _addr.dim_x) throw WrapperError(std::string(__func__)+"(): X out of range"); - if (y >= _addr.dim_y) throw WrapperError(std::string(__func__)+"(): Y out of range"); - return vxFormatImagePatchAddress2d(_data, x, y, &_addr); - } - -private: - Patch(const Patch& p); // = delete - Patch& operator=(const Patch&); // = delete -#ifndef IVX_USE_CXX98 - Patch& operator=(Patch&&); // = delete -#endif -}; - -/// vx_parameter wrapper -class Param : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Param); - // NYI -}; - -/// vx_scalar wrapper -class Scalar : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Scalar); - - /// vxCreateScalar() wrapper - static Scalar create(vx_context c, vx_enum dataType, const void *ptr) - { return Scalar( vxCreateScalar(c, dataType, ptr) ); } - - /// vxCreateScalar() wrapper, value is passed as a value not as a pointer - template static Scalar create(vx_context c, vx_enum dataType, T value) - { - typedef int static_assert_not_pointer[is_pointer::value ? -1 : 1]; - return Scalar( vxCreateScalar(c, dataType, &value) ); - } - - /// vxCreateScalar() wrapper, data type is guessed based on the passed value - template static Scalar create(vx_context c, typename EnumToType::type value) - { return Scalar( vxCreateScalar(c, E, &value) ); } - -#ifndef VX_VERSION_1_1 -static const vx_enum VX_SCALAR_TYPE = VX_SCALAR_ATTRIBUTE_TYPE; -#endif - /// Get scalar data type - vx_enum type() - { - vx_enum val; - IVX_CHECK_STATUS( vxQueryScalar(ref, VX_SCALAR_TYPE, &val, sizeof(val)) ); - return val; - } - - /// Get scalar value - template - void getValue(T& val) - { - if (!areTypesCompatible(TypeToEnum::value, type())) - throw WrapperError(std::string(__func__)+"(): incompatible types"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS( vxCopyScalar(ref, &val, VX_READ_ONLY, VX_MEMORY_TYPE_HOST) ); -#else - IVX_CHECK_STATUS( vxReadScalarValue(ref, &val) ); -#endif - } - - /// Get scalar value - template - T getValue() - { - T val; - getValue(val); - return val; - } - - - /// Set scalar value - template - void setValue(T val) - { - if (!areTypesCompatible(TypeToEnum::value, type())) - throw WrapperError(std::string(__func__)+"(): incompatible types"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyScalar(ref, &val, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS( vxWriteScalarValue(ref, &val) ); -#endif - } -}; - -/// vx_threshold wrapper -class Threshold : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Threshold); - - /// vxCreateThreshold() wrapper - static Threshold create(vx_context c, vx_enum threshType, vx_enum dataType) - { return Threshold(vxCreateThreshold(c, threshType, dataType)); } - -#ifndef VX_VERSION_1_1 -static const vx_enum - VX_THRESHOLD_TYPE = VX_THRESHOLD_ATTRIBUTE_TYPE, - VX_THRESHOLD_THRESHOLD_VALUE = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_VALUE, - VX_THRESHOLD_THRESHOLD_LOWER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_LOWER, - VX_THRESHOLD_THRESHOLD_UPPER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_UPPER, - VX_THRESHOLD_TRUE_VALUE = VX_THRESHOLD_ATTRIBUTE_TRUE_VALUE, - VX_THRESHOLD_FALSE_VALUE = VX_THRESHOLD_ATTRIBUTE_FALSE_VALUE, - VX_THRESHOLD_DATA_TYPE = VX_THRESHOLD_ATTRIBUTE_DATA_TYPE; -#endif - - - /// Create binary threshold with the provided value - static Threshold createBinary(vx_context c, vx_enum dataType, vx_int32 val) - { - Threshold thr = create(c, VX_THRESHOLD_TYPE_BINARY, dataType); - IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_VALUE, &val, sizeof(val)) ); - return thr; - } - - /// Create range threshold with the provided low and high values - static Threshold createRange(vx_context c, vx_enum dataType, vx_int32 valLower, vx_int32 valUpper) - { - Threshold thr = create(c, VX_THRESHOLD_TYPE_RANGE, dataType); - IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_LOWER, &valLower, sizeof(valLower)) ); - IVX_CHECK_STATUS( vxSetThresholdAttribute(thr.ref, VX_THRESHOLD_THRESHOLD_UPPER, &valUpper, sizeof(valUpper)) ); - return thr; - } - - /// vxQueryThreshold() wrapper - template - void query(vx_enum att, T& val) const - { IVX_CHECK_STATUS( vxQueryThreshold(ref, att, &val, sizeof(val)) ); } - - /// vxQueryThreshold(VX_THRESHOLD_TYPE) wrapper - vx_enum type() const - { - vx_enum v; - query(VX_THRESHOLD_TYPE, v); - return v; - } - - /// vxQueryThreshold(DATA_TYPE) wrapper - vx_enum dataType() const - { - vx_enum v; - query(VX_THRESHOLD_DATA_TYPE, v); - return v; - } - - /// vxQueryThreshold(THRESHOLD_VALUE) wrapper - vx_int32 value() const - { - vx_int32 v; - query(VX_THRESHOLD_THRESHOLD_VALUE, v); - return v; - } - - /// vxQueryThreshold(THRESHOLD_LOWER) wrapper - vx_int32 valueLower() const - { - vx_int32 v; - query(VX_THRESHOLD_THRESHOLD_LOWER, v); - return v; - } - - /// vxQueryThreshold(THRESHOLD_UPPER) wrapper - vx_int32 valueUpper() const - { - vx_int32 v; - query(VX_THRESHOLD_THRESHOLD_UPPER, v); - return v; - } - - /// vxQueryThreshold(TRUE_VALUE) wrapper - vx_int32 valueTrue() const - { - vx_int32 v; - query(VX_THRESHOLD_TRUE_VALUE, v); - return v; - } - - /// vxQueryThreshold(FALSE_VALUE) wrapper - vx_int32 valueFalse() const - { - vx_int32 v; - query(VX_THRESHOLD_FALSE_VALUE, v); - return v; - } - - /// vxSetThresholdAttribute(THRESHOLD_VALUE) wrapper - void setValue(vx_int32 &val) - { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_VALUE, &val, sizeof(val))); } - - /// vxSetThresholdAttribute(THRESHOLD_LOWER) wrapper - void setValueLower(vx_int32 &val) - { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_LOWER, &val, sizeof(val))); } - - /// vxSetThresholdAttribute(THRESHOLD_UPPER) wrapper - void setValueUpper(vx_int32 &val) - { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_THRESHOLD_UPPER, &val, sizeof(val))); } - - /// vxSetThresholdAttribute(TRUE_VALUE) wrapper - void setValueTrue(vx_int32 &val) - { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_TRUE_VALUE, &val, sizeof(val))); } - - /// vxSetThresholdAttribute(FALSE_VALUE) wrapper - void setValueFalse(vx_int32 &val) - { IVX_CHECK_STATUS(vxSetThresholdAttribute(ref, VX_THRESHOLD_FALSE_VALUE, &val, sizeof(val))); } -}; - -/// vx_array wrapper -class Array : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Array); - - /// vxCreateArray() wrapper - static Array create(vx_context c, vx_enum type, vx_size capacity) - { return Array(vxCreateArray(c, type, capacity)); } - - /// 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 - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryArray(ref, att, &value, sizeof(value)) ); } - - vx_enum itemType() const - { - vx_enum v; - query(VX_ARRAY_ITEMTYPE, v); - return v; - } - - vx_size itemSize() const - { - vx_size v; - query(VX_ARRAY_ITEMSIZE, v); - return v; - } - - vx_size capacity() const - { - vx_size v; - query(VX_ARRAY_CAPACITY, v); - return v; - } - - vx_size itemCount() const - { - vx_size v; - query(VX_ARRAY_NUMITEMS, v); - return v; - } - - void addItems(vx_size count, const void* ptr, vx_size stride) - { - IVX_CHECK_STATUS(vxAddArrayItems(ref, count, ptr, stride)); - } - - void truncateArray(vx_size new_count) - { - if(new_count <= itemCount()) - IVX_CHECK_STATUS(vxTruncateArray(ref, new_count)); - else - throw WrapperError(std::string(__func__) + "(): array is too small"); - } - - void copyRangeTo(size_t start, size_t end, void* data) - { - if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); -#else - vx_size stride = itemSize(); - IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, &data, VX_READ_ONLY)); - IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data)); -#endif - } - - void copyTo(void* data) - { copyRangeTo(0, itemCount(), data); } - - void copyRangeFrom(size_t start, size_t end, const void* data) - { - if (!data) throw WrapperError(std::string(__func__) + "(): input pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), const_cast(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - vx_size stride = itemSize(); - IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, const_cast(&data), VX_WRITE_ONLY)); - IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data)); -#endif - } - - void copyFrom(const void* data) - { copyRangeFrom(0, itemCount(), data); } - - void copyRange(size_t start, size_t end, void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { - if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyArrayRange(ref, start, end, itemSize(), data, usage, memType)); -#else - vx_size stride = itemSize(); - IVX_CHECK_STATUS(vxAccessArrayRange(ref, start, end, &stride, &data, usage)); - IVX_CHECK_STATUS(vxCommitArrayRange(ref, start, end, data)); - (void)memType; -#endif - } - - void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { copyRange(0, itemCount(), data, usage, memType); } - - template void addItem(const T& item) - { - if (!areTypesCompatible(TypeToEnum::value, itemType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - addItems(1, &item, sizeof(T)); - } - - template void addItems(const std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, itemType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - addItems(data.size(), &data[0], itemSize()); - } - - template void copyRangeTo(size_t start, size_t end, std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, itemType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (data.empty()) - data.resize((end - start)); - else if (data.size() != (end - start)) - { - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - } - copyRangeTo(start, end, &data[0]); - } - - template void copyTo(std::vector& data) - { copyRangeTo(0, itemCount(), data); } - - template void copyRangeFrom(size_t start, size_t end, const std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, itemType())) - throw WrapperError(std::string(__func__) + "(): source type is wrong"); - if (data.size() != (end - start)) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - copyRangeFrom(start, end, &data[0]); - } - - template void copyFrom(std::vector& data) - { copyRangeFrom(0, itemCount(), data); } - -#ifdef IVX_USE_OPENCV - void addItems(cv::InputArray ia) - { - cv::Mat m = ia.getMat(); - if (m.type() != enumToCVType(itemType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - addItems(m.total(), m.isContinuous() ? m.ptr() : m.clone().ptr(), - (vx_size)(m.elemSize())); - } - - void copyRangeTo(size_t start, size_t end, cv::Mat& m) - { - if (m.type() != enumToCVType(itemType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (!( - ((vx_size)(m.rows) == (end - start) && m.cols == 1) || - ((vx_size)(m.cols) == (end - start) && m.rows == 1) - ) && !m.empty()) - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - - if (m.isContinuous() && (vx_size)(m.total()) == (end - start)) - { - copyRangeTo(start, end, m.ptr()); - } - else - { - cv::Mat tmp(1, (int)(end - start), enumToCVType(itemType())); - copyRangeTo(start, end, tmp.ptr()); - if (m.empty()) - m = tmp; - else - tmp.copyTo(m); - } - } - - void copyTo(cv::Mat& m) - { copyRangeTo(0, itemCount(), m); } - - void copyRangeFrom(size_t start, size_t end, const cv::Mat& m) - { - if (!( - ((vx_size)(m.rows) == (end - start) && m.cols == 1) || - ((vx_size)(m.cols) == (end - start) && m.rows == 1) - )) - throw WrapperError(std::string(__func__) + "(): source size is wrong"); - if (m.type() != enumToCVType(itemType())) - throw WrapperError(std::string(__func__) + "(): source type is wrong"); - copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr()); - } - - void copyFrom(const cv::Mat& m) - { copyRangeFrom(0, itemCount(), m); } -#endif //IVX_USE_OPENCV -}; - -/* -* Convolution -*/ -class Convolution : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Convolution); - - static Convolution create(vx_context context, vx_size columns, vx_size rows) - { return Convolution(vxCreateConvolution(context, columns, rows)); } - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST, - VX_CONVOLUTION_ROWS = VX_CONVOLUTION_ATTRIBUTE_ROWS, - VX_CONVOLUTION_COLUMNS = VX_CONVOLUTION_ATTRIBUTE_COLUMNS, - VX_CONVOLUTION_SCALE = VX_CONVOLUTION_ATTRIBUTE_SCALE, - VX_CONVOLUTION_SIZE = VX_CONVOLUTION_ATTRIBUTE_SIZE; -#endif - - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryConvolution(ref, att, &value, sizeof(value)) ); } - - vx_size columns() const - { - vx_size v; - query(VX_CONVOLUTION_COLUMNS, v); - return v; - } - - vx_size rows() const - { - vx_size v; - query(VX_CONVOLUTION_ROWS, v); - return v; - } - - vx_uint32 scale() const - { - vx_uint32 v; - query(VX_CONVOLUTION_SCALE, v); - return v; - } - - vx_size size() const - { - vx_size v; - query(VX_CONVOLUTION_SIZE, v); - return v; - } - - vx_enum dataType() - { - return VX_TYPE_INT16; - } - - void setScale(vx_uint32 newScale) - { IVX_CHECK_STATUS( vxSetConvolutionAttribute(ref, VX_CONVOLUTION_SCALE, &newScale, sizeof(newScale)) ); } - - 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 - 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(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxWriteConvolutionCoefficients(ref, (const vx_int16 *)data)); -#endif - } - - void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { - if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyConvolutionCoefficients(ref, data, usage, memType)); -#else - if (usage == VX_READ_ONLY) - IVX_CHECK_STATUS(vxReadConvolutionCoefficients(ref, (vx_int16 *)data)); - else if (usage == VX_WRITE_ONLY) - IVX_CHECK_STATUS(vxWriteConvolutionCoefficients(ref, (const vx_int16 *)data)); - else - throw WrapperError(std::string(__func__) + "(): unknown copy direction"); - (void)memType; -#endif - } - - template void copyTo(std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (data.size()*sizeof(T) != size()) - { - if (data.size() == 0) - data.resize(size()/sizeof(T)); - else - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - } - copyTo(&data[0]); - } - - template void copyFrom(const std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): source type is wrong"); - if (data.size()*sizeof(T) != size()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - copyFrom(&data[0]); - } - -#ifdef IVX_USE_OPENCV - void copyTo(cv::Mat& m) - { - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) && !m.empty()) - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - - 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; - else - tmp.copyTo(m); - } - } - - void copyFrom(const cv::Mat& m) - { - if ((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong"); - copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr()); - } -#endif //IVX_USE_OPENCV -}; - -/* -* Matrix -*/ -class Matrix : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Matrix); - - static Matrix create(vx_context context, vx_enum dataType, vx_size columns, vx_size rows) - { return Matrix(vxCreateMatrix(context, dataType, columns, rows)); } - -#ifdef VX_VERSION_1_1 - static Matrix createFromPattern(vx_context context, vx_enum pattern, vx_size columns, vx_size rows) - { return Matrix(vxCreateMatrixFromPattern(context, pattern, columns, rows)); } -#endif - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST, - VX_MATRIX_TYPE = VX_MATRIX_ATTRIBUTE_TYPE, - VX_MATRIX_ROWS = VX_MATRIX_ATTRIBUTE_ROWS, - VX_MATRIX_COLUMNS = VX_MATRIX_ATTRIBUTE_COLUMNS, - VX_MATRIX_SIZE = VX_MATRIX_ATTRIBUTE_SIZE; -#endif - - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryMatrix(ref, att, &value, sizeof(value)) ); } - - vx_enum dataType() const - { - vx_enum v; - query(VX_MATRIX_TYPE, v); - return v; - } - - vx_size columns() const - { - vx_size v; - query(VX_MATRIX_COLUMNS, v); - return v; - } - - vx_size rows() const - { - vx_size v; - query(VX_MATRIX_ROWS, v); - return v; - } - - vx_size size() const - { - vx_size v; - query(VX_MATRIX_SIZE, v); - return v; - } - -#ifdef VX_VERSION_1_1 - vx_coordinates2d_t origin() const - { - vx_coordinates2d_t v; - query(VX_MATRIX_ORIGIN, v); - return v; - } - - vx_enum pattern() const - { - vx_enum v; - 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 - IVX_CHECK_STATUS(vxReadMatrix(ref, 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(vxCopyMatrix(ref, const_cast(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxWriteMatrix(ref, data)); -#endif - } - - void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { - if (!data) throw WrapperError(std::string(__func__) + "(): data pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyMatrix(ref, data, usage, memType)); -#else - if (usage == VX_READ_ONLY) - IVX_CHECK_STATUS(vxReadMatrix(ref, data)); - else if (usage == VX_WRITE_ONLY) - IVX_CHECK_STATUS(vxWriteMatrix(ref, data)); - else - throw WrapperError(std::string(__func__) + "(): unknown copy direction"); - (void)memType; -#endif - } - - template void copyTo(std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (data.size()*sizeof(T) != size()) - { - if (data.size() == 0) - data.resize(size()/sizeof(T)); - else - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - } - copyTo(&data[0]); - } - - template void copyFrom(const std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): source type is wrong"); - if (data.size()*sizeof(T) != size()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - copyFrom(&data[0]); - } - -#ifdef IVX_USE_OPENCV - void copyTo(cv::Mat& m) - { - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) && !m.empty()) - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - - 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; - else - tmp.copyTo(m); - } - } - - void copyFrom(const cv::Mat& m) - { - if ((vx_size)(m.rows) != rows() || (vx_size)(m.cols) != columns()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong"); - copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr()); - } -#endif //IVX_USE_OPENCV -}; - -/* -* LUT -*/ -class LUT : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(LUT); - -#ifdef VX_VERSION_1_1 - static LUT create(vx_context context, vx_enum dataType = VX_TYPE_UINT8, vx_size count = 256) - { -#else - static LUT create(vx_context context) - { - vx_enum dataType = VX_TYPE_UINT8; - vx_size count = 256; -#endif - return LUT(vxCreateLUT(context, dataType, count)); - } - -#ifndef VX_VERSION_1_1 - static const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST; -#endif - - template - void query(vx_enum att, T& value) const - { - IVX_CHECK_STATUS(vxQueryLUT(ref, att, &value, sizeof(value))); - } - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_LUT_TYPE = VX_LUT_ATTRIBUTE_TYPE, - VX_LUT_COUNT = VX_LUT_ATTRIBUTE_COUNT, - VX_LUT_SIZE = VX_LUT_ATTRIBUTE_SIZE; -#endif - - vx_enum dataType() const - { - vx_enum v; - query(VX_LUT_TYPE, v); - return v; - } - - vx_size count() const - { - vx_size v; - query(VX_LUT_COUNT, v); - return v; - } - - vx_size size() const - { - vx_size v; - query(VX_LUT_SIZE, v); - return v; - } - -#ifdef VX_VERSION_1_1 - vx_uint32 offset() const - { - vx_enum v; - query(VX_LUT_OFFSET, 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(vxCopyLUT(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxAccessLUT(ref, &data, VX_READ_ONLY)); - IVX_CHECK_STATUS(vxCommitLUT(ref, 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(vxCopyLUT(ref, const_cast(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxAccessLUT(ref, const_cast(&data), VX_WRITE_ONLY)); - IVX_CHECK_STATUS(vxCommitLUT(ref, data)); -#endif - } - - void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyLUT(ref, data, usage, memType)); -#else - IVX_CHECK_STATUS(vxAccessLUT(ref, const_cast(&data), usage)); - IVX_CHECK_STATUS(vxCommitLUT(ref, data)); - (void)memType; -#endif - } - - template void copyTo(std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (data.size() != count()) - { - if (data.size() == 0) - data.resize(count()); - else - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - } - copyTo(&data[0]); - } - - template void copyFrom(const std::vector& data) - { - if (!areTypesCompatible(TypeToEnum::value, dataType())) - throw WrapperError(std::string(__func__) + "(): source type is wrong"); - if (data.size() != count()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - copyFrom(&data[0]); - } - -#ifdef IVX_USE_OPENCV - void copyTo(cv::Mat& m) - { - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (!( - ((vx_size)(m.rows) == count() && m.cols == 1) || - ((vx_size)(m.cols) == count() && m.rows == 1) - ) && !m.empty()) - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - - if (m.isContinuous() && (vx_size)(m.total()) == count()) - { - copyTo(m.ptr()); - } - else - { - cv::Mat tmp(1, (int)count(), enumToCVType(dataType())); - copyTo(tmp.ptr()); - if (m.empty()) - m = tmp; - else - tmp.copyTo(m); - } - } - - void copyFrom(const cv::Mat& m) - { - if (!( - ((vx_size)(m.rows) == count() && m.cols == 1) || - ((vx_size)(m.cols) == count() && m.rows == 1) - )) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong"); - copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr()); - } -#endif //IVX_USE_OPENCV -}; - -/* - * Pyramid - */ -class Pyramid : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Pyramid) - - static Pyramid create(vx_context context, vx_size levels, vx_float32 scale, - vx_uint32 width, vx_uint32 height, vx_df_image format) - {return Pyramid(vxCreatePyramid(context, levels, scale, width, height, format));} - - static Pyramid createVirtual(vx_graph graph, vx_size levels, vx_float32 scale, - vx_uint32 width, vx_uint32 height, vx_df_image format) - {return Pyramid(vxCreateVirtualPyramid(graph, levels, scale, width, height, format));} - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_PYRAMID_LEVELS = VX_PYRAMID_ATTRIBUTE_LEVELS, - VX_PYRAMID_SCALE = VX_PYRAMID_ATTRIBUTE_SCALE, - VX_PYRAMID_WIDTH = VX_PYRAMID_ATTRIBUTE_WIDTH, - VX_PYRAMID_HEIGHT = VX_PYRAMID_ATTRIBUTE_HEIGHT, - VX_PYRAMID_FORMAT = VX_PYRAMID_ATTRIBUTE_FORMAT; -#endif - - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS( vxQueryPyramid(ref, att, &value, sizeof(value)) ); } - - vx_size levels() const - { - vx_size l; - query(VX_PYRAMID_LEVELS, l); - return l; - } - - vx_float32 scale() const - { - vx_float32 s; - query(VX_PYRAMID_SCALE, s); - return s; - } - - vx_uint32 width() const - { - vx_uint32 v; - query(VX_PYRAMID_WIDTH, v); - return v; - } - - vx_uint32 height() const - { - vx_uint32 v; - query(VX_PYRAMID_HEIGHT, v); - return v; - } - - vx_df_image format() const - { - vx_df_image f; - query(VX_PYRAMID_FORMAT, f); - return f; - } - - Image getLevel(vx_uint32 index) - { return Image(vxGetPyramidLevel(ref, index)); } -}; - -/* -* Distribution -*/ -class Distribution : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Distribution); - - static Distribution create(vx_context context, vx_size numBins, vx_int32 offset, vx_uint32 range) - { - return Distribution(vxCreateDistribution(context, numBins, offset, range)); - } - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST, - VX_DISTRIBUTION_DIMENSIONS = VX_DISTRIBUTION_ATTRIBUTE_DIMENSIONS, - VX_DISTRIBUTION_OFFSET = VX_DISTRIBUTION_ATTRIBUTE_OFFSET, - VX_DISTRIBUTION_RANGE = VX_DISTRIBUTION_ATTRIBUTE_RANGE, - VX_DISTRIBUTION_BINS = VX_DISTRIBUTION_ATTRIBUTE_BINS, - VX_DISTRIBUTION_WINDOW = VX_DISTRIBUTION_ATTRIBUTE_WINDOW, - VX_DISTRIBUTION_SIZE = VX_DISTRIBUTION_ATTRIBUTE_SIZE; -#endif - - template - void query(vx_enum att, T& value) const - { - IVX_CHECK_STATUS(vxQueryDistribution(ref, att, &value, sizeof(value))); - } - - vx_size dimensions() const - { - vx_size v; - query(VX_DISTRIBUTION_DIMENSIONS, v); - return v; - } - - vx_int32 offset() const - { - vx_int32 v; - query(VX_DISTRIBUTION_OFFSET, v); - return v; - } - - vx_uint32 range() const - { - vx_uint32 v; - query(VX_DISTRIBUTION_RANGE, v); - return v; - } - - vx_size bins() const - { - vx_size v; - query(VX_DISTRIBUTION_BINS, v); - return v; - } - - vx_uint32 window() const - { - vx_uint32 v; - query(VX_DISTRIBUTION_WINDOW, v); - return v; - } - - vx_size size() const - { - vx_size v; - query(VX_DISTRIBUTION_SIZE, v); - return v; - } - - vx_size dataType() const - { - return VX_TYPE_UINT32; - } - - void copyTo(void* data) - { - if (!data) throw WrapperError(std::string(__func__) + "(): output pointer is 0"); -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyDistribution(ref, data, VX_READ_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxAccessDistribution(ref, &data, VX_READ_ONLY)); - IVX_CHECK_STATUS(vxCommitDistribution(ref, 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(vxCopyDistribution(ref, const_cast(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST)); -#else - IVX_CHECK_STATUS(vxAccessDistribution(ref, const_cast(&data), VX_WRITE_ONLY)); - IVX_CHECK_STATUS(vxCommitDistribution(ref, data)); -#endif - } - - void copy(void* data, vx_enum usage, vx_enum memType = VX_MEMORY_TYPE_HOST) - { -#ifdef VX_VERSION_1_1 - IVX_CHECK_STATUS(vxCopyDistribution(ref, data, usage, memType)); -#else - IVX_CHECK_STATUS(vxAccessDistribution(ref, const_cast(&data), usage)); - IVX_CHECK_STATUS(vxCommitDistribution(ref, data)); - (void)memType; -#endif - } - - template void copyTo(std::vector& data) - { - if (TypeToEnum::value != dataType()) throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (data.size() != bins()) - { - if (data.size() == 0) - data.resize(bins()); - else - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - } - copyTo(&data[0]); - } - - template void copyFrom(const std::vector& data) - { - if (TypeToEnum::value != dataType()) throw WrapperError(std::string(__func__) + "(): source type is wrong"); - if (data.size() != bins()) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - copyFrom(&data[0]); - } - -#ifdef IVX_USE_OPENCV - void copyTo(cv::Mat& m) - { - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): destination type is wrong"); - if (!( - ((vx_size)(m.rows) == bins() && m.cols == 1) || - ((vx_size)(m.cols) == bins() && m.rows == 1) - ) && !m.empty()) - throw WrapperError(std::string(__func__) + "(): destination size is wrong"); - - if (m.isContinuous() && (vx_size)(m.total()) == bins()) - { - copyTo(m.ptr()); - } - else - { - cv::Mat tmp(1, (int)bins(), enumToCVType(dataType())); - copyTo(tmp.ptr()); - if (m.empty()) - m = tmp; - else - tmp.copyTo(m); - } - } - - void copyFrom(const cv::Mat& m) - { - if (!( - ((vx_size)(m.rows) == bins() && m.cols == 1) || - ((vx_size)(m.cols) == bins() && m.rows == 1) - )) throw WrapperError(std::string(__func__) + "(): source size is wrong"); - if (m.type() != enumToCVType(dataType())) throw WrapperError(std::string(__func__) + "(): source type is wrong"); - copyFrom(m.isContinuous() ? m.ptr() : m.clone().ptr()); - } -#endif //IVX_USE_OPENCV -}; - -/* -* Remap -*/ -class Remap : public RefWrapper -{ -public: - IVX_REF_STD_CTORS_AND_ASSIGNMENT(Remap); - - static Remap create(vx_context context, vx_uint32 src_width, vx_uint32 src_height, vx_uint32 dst_width, vx_uint32 dst_height) - { - return Remap(vxCreateRemap(context, src_width, src_height, dst_width, dst_height)); - } - -#ifndef VX_VERSION_1_1 - static const vx_enum - VX_REMAP_SOURCE_WIDTH = VX_REMAP_ATTRIBUTE_SOURCE_WIDTH, - VX_REMAP_SOURCE_HEIGHT = VX_REMAP_ATTRIBUTE_SOURCE_HEIGHT, - VX_REMAP_DESTINATION_WIDTH = VX_REMAP_ATTRIBUTE_DESTINATION_WIDTH, - VX_REMAP_DESTINATION_HEIGHT = VX_REMAP_ATTRIBUTE_DESTINATION_HEIGHT; -#endif - - template - void query(vx_enum att, T& value) const - { IVX_CHECK_STATUS(vxQueryRemap(ref, att, &value, sizeof(value))); } - - vx_uint32 srcWidth() const - { - vx_uint32 v; - query(VX_REMAP_SOURCE_WIDTH, v); - return v; - } - - vx_uint32 srcHeight() const - { - vx_uint32 v; - query(VX_REMAP_SOURCE_HEIGHT, v); - return v; - } - - vx_uint32 dstWidth() const - { - vx_uint32 v; - query(VX_REMAP_DESTINATION_WIDTH, v); - return v; - } - - vx_uint32 dstHeight() const - { - vx_uint32 v; - query(VX_REMAP_DESTINATION_HEIGHT, v); - return v; - } - - vx_uint32 srcCoordType() const - { return VX_TYPE_FLOAT32; } - - vx_uint32 dstCoordType() const - { return VX_TYPE_UINT32; } - - void setMapping(vx_uint32 dst_x, vx_uint32 dst_y, vx_float32 src_x, vx_float32 src_y) - { IVX_CHECK_STATUS(vxSetRemapPoint(ref, dst_x, dst_y, src_x, src_y)); } - - void getMapping(vx_uint32 dst_x, vx_uint32 dst_y, vx_float32 &src_x, vx_float32 &src_y) const - { IVX_CHECK_STATUS(vxGetRemapPoint(ref, dst_x, dst_y, &src_x, &src_y)); } - -#ifdef IVX_USE_OPENCV - void setMappings(const cv::Mat& map_x, const cv::Mat& map_y) - { - if (map_x.type() != enumToCVType(srcCoordType()) || map_y.type() != enumToCVType(srcCoordType())) - throw WrapperError(std::string(__func__) + "(): mapping type is wrong"); - if ((vx_uint32)(map_x.rows) != dstHeight() || (vx_uint32)(map_x.cols) != dstWidth()) - throw WrapperError(std::string(__func__) + "(): x mapping size is wrong"); - if ((vx_uint32)(map_y.rows) != dstHeight() || (vx_uint32)(map_y.cols) != dstWidth()) - throw WrapperError(std::string(__func__) + "(): y mapping size is wrong"); - - for (vx_uint32 y = 0; y < dstHeight(); y++) - { - const vx_float32* map_x_line = map_x.ptr(y); - const vx_float32* map_y_line = map_y.ptr(y); - for (vx_uint32 x = 0; x < dstWidth(); x++) - setMapping(x, y, map_x_line[x], map_y_line[x]); - } - } - - void setMappings(const cv::Mat& map) - { - if (map.depth() != CV_MAT_DEPTH(enumToCVType(srcCoordType())) || map.channels() != 2) - throw WrapperError(std::string(__func__) + "(): mapping type is wrong"); - if ((vx_uint32)(map.rows) != dstHeight() || (vx_uint32)(map.cols) != dstWidth()) - throw WrapperError(std::string(__func__) + "(): x mapping size is wrong"); - - for (vx_uint32 y = 0; y < dstHeight(); y++) - { - const vx_float32* map_line = map.ptr(y); - for (vx_uint32 x = 0; x < 2*dstWidth(); x+=2) - setMapping(x, y, map_line[x], map_line[x+1]); - } - } - - void getMappings(cv::Mat& map_x, cv::Mat& map_y) const - { - if (map_x.type() != enumToCVType(srcCoordType()) || map_y.type() != enumToCVType(srcCoordType())) - throw WrapperError(std::string(__func__) + "(): mapping type is wrong"); - if (((vx_uint32)(map_x.rows) != dstHeight() || (vx_uint32)(map_x.cols) != dstWidth()) && !map_x.empty()) - throw WrapperError(std::string(__func__) + "(): x mapping size is wrong"); - if (((vx_uint32)(map_y.rows) != dstHeight() || (vx_uint32)(map_y.cols) != dstWidth()) && !map_y.empty()) - throw WrapperError(std::string(__func__) + "(): y mapping size is wrong"); - - if (map_x.empty()) - map_x = cv::Mat((int)dstHeight(), (int)dstWidth(), enumToCVType(srcCoordType())); - if (map_y.empty()) - map_y = cv::Mat((int)dstHeight(), (int)dstWidth(), enumToCVType(srcCoordType())); - - for (vx_uint32 y = 0; y < dstHeight(); y++) - { - vx_float32* map_x_line = map_x.ptr(y); - vx_float32* map_y_line = map_y.ptr(y); - for (vx_uint32 x = 0; x < dstWidth(); x++) - getMapping(x, y, map_x_line[x], map_y_line[x]); - } - } - - void getMappings(cv::Mat& map) const - { - if (map.depth() != CV_MAT_DEPTH(enumToCVType(srcCoordType())) || map.channels() != 2) - throw WrapperError(std::string(__func__) + "(): mapping type is wrong"); - if (((vx_uint32)(map.rows) != dstHeight() || (vx_uint32)(map.cols) != dstWidth()) && !map.empty()) - throw WrapperError(std::string(__func__) + "(): x mapping size is wrong"); - - if (map.empty()) - map = cv::Mat((int)dstHeight(), (int)dstWidth(), CV_MAKETYPE(CV_MAT_DEPTH(enumToCVType(srcCoordType())),2)); - - for (vx_uint32 y = 0; y < dstHeight(); y++) - { - vx_float32* map_line = map.ptr(y); - for (vx_uint32 x = 0; x < 2*dstWidth(); x+=2) - getMapping(x, y, map_line[x], map_line[x+1]); - } - } -#endif //IVX_USE_OPENCV -}; - -/// Standard nodes -namespace nodes { - -/// Creates a Gaussian Filter 3x3 Node (vxGaussian3x3Node) -inline Node gaussian3x3(vx_graph graph, vx_image inImg, vx_image outImg) -{ return Node(vxGaussian3x3Node(graph, inImg, outImg)); } - -} // namespace nodes - -} // namespace ivx - -// restore warnings -#if defined(_MSC_VER) - #pragma warning(pop) -#elif defined(__clang__) - #pragma clang diagnostic pop -#elif defined(__GNUC__) - #pragma GCC diagnostic pop -#endif // compiler macro - -#endif //IVX_HPP diff --git a/3rdparty/openvx/include/ivx_lib_debug.hpp b/3rdparty/openvx/include/ivx_lib_debug.hpp deleted file mode 100644 index df0d307e24..0000000000 --- a/3rdparty/openvx/include/ivx_lib_debug.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. - -// Copyright (C) 2016, Intel Corporation, all rights reserved. -// Third party copyrights are property of their respective owners. - -/* -C++ wrappers over OpenVX 1.x C API ("openvx-debug" module) -Details: TBD -*/ - -#pragma once -#ifndef IVX_LIB_DEBUG_HPP -#define IVX_LIB_DEBUG_HPP - -#include "ivx.hpp" - -namespace ivx -{ -namespace debug -{ -/* -* "openvx-debug" module -*/ - -// -void fReadImage(vx_context c, const std::string& path, vx_image img) -{ - IVX_CHECK_STATUS( vxuFReadImage(c, (vx_char*)path.c_str(), img) ); -} - -// -void fWriteImage(vx_context c, vx_image img, const std::string& path) -{ - IVX_CHECK_STATUS( vxuFWriteImage(c, img, (vx_char*)path.c_str()) ); -} - -} // namespace debug -} // namespace ivx - -#endif //IVX_LIB_DEBUG_HPP diff --git a/CMakeLists.txt b/CMakeLists.txt index bb5195f22f..0ccc86aed0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -332,9 +332,6 @@ OCV_OPTION(WITH_OPENEXR "Include ILM support via OpenEXR" ((WIN32 OR ANDROID OR OCV_OPTION(WITH_OPENGL "Include OpenGL support" OFF VISIBLE_IF NOT ANDROID AND NOT WINRT VERIFY HAVE_OPENGL) -OCV_OPTION(WITH_OPENVX "Include OpenVX support" OFF - VISIBLE_IF TRUE - VERIFY HAVE_OPENVX) OCV_OPTION(WITH_OPENNI "Include OpenNI support" OFF VISIBLE_IF NOT ANDROID AND NOT IOS AND NOT XROS AND NOT WINRT VERIFY HAVE_OPENNI) @@ -913,10 +910,6 @@ if(WITH_VTK) include(cmake/OpenCVDetectVTK.cmake) endif() -if(WITH_OPENVX) - include(cmake/FindOpenVX.cmake) -endif() - if(WITH_QUIRC) add_subdirectory(3rdparty/quirc) set(HAVE_QUIRC TRUE) @@ -950,12 +943,6 @@ if(NOT DEFINED OpenCV_HAL) set(OpenCV_HAL "OpenCV_HAL") endif() -if(HAVE_OPENVX) - if(NOT ";${OpenCV_HAL};" MATCHES ";openvx;") - set(OpenCV_HAL "openvx;${OpenCV_HAL}") - endif() -endif() - if(WITH_CAROTENE) ocv_debug_message(STATUS "Enable carotene acceleration") if(NOT ";${OpenCV_HAL};" MATCHES ";carotene;") @@ -980,10 +967,6 @@ foreach(hal ${OpenCV_HAL}) else() message(STATUS "Carotene: NEON is not available, disabling carotene...") endif() - elseif(hal STREQUAL "openvx") - add_subdirectory(3rdparty/openvx) - ocv_hal_register(OPENVX_HAL_LIBRARIES OPENVX_HAL_HEADERS OPENVX_HAL_INCLUDE_DIRS) - list(APPEND OpenCV_USED_HAL "openvx (ver ${OPENVX_HAL_VERSION})") else() ocv_debug_message(STATUS "OpenCV HAL: ${hal} ...") ocv_clear_vars(OpenCV_HAL_LIBRARIES OpenCV_HAL_HEADERS OpenCV_HAL_INCLUDE_DIRS) @@ -1751,10 +1734,6 @@ if(WITH_EIGEN OR HAVE_EIGEN) status(" Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO) endif() -if(WITH_OPENVX OR HAVE_OPENVX) - status(" OpenVX:" HAVE_OPENVX THEN "YES (${OPENVX_LIBRARIES})" ELSE "NO") -endif() - status(" Custom HAL:" OpenCV_USED_HAL THEN "YES (${OpenCV_USED_HAL})" ELSE "NO") foreach(s ${CUSTOM_STATUS}) diff --git a/cmake/FindOpenVX.cmake b/cmake/FindOpenVX.cmake deleted file mode 100644 index 6cba52717c..0000000000 --- a/cmake/FindOpenVX.cmake +++ /dev/null @@ -1,46 +0,0 @@ -ocv_clear_vars(HAVE_OPENVX) - -set(OPENVX_ROOT "" CACHE PATH "OpenVX install directory") -set(OPENVX_LIB_CANDIDATES "openvx;vxu" CACHE STRING "OpenVX library candidates list") - -function(find_openvx_libs _found) - foreach(one ${OPENVX_LIB_CANDIDATES}) - find_library(OPENVX_${one}_LIBRARY ${one} PATHS "${OPENVX_ROOT}/lib" "${OPENVX_ROOT}/bin") - if(OPENVX_${one}_LIBRARY) - list(APPEND _list ${OPENVX_${one}_LIBRARY}) - endif() - endforeach() - set(${_found} ${_list} PARENT_SCOPE) -endfunction() - -if(OPENVX_ROOT) - find_path(OPENVX_INCLUDE_DIR "VX/vx.h" PATHS "${OPENVX_ROOT}/include" DOC "OpenVX include path") - if(NOT DEFINED OPENVX_LIBRARIES) - find_openvx_libs(found) - if(found) - set(OPENVX_LIBRARIES "${found}" CACHE STRING "OpenVX libraries") - endif() - endif() -endif() - -if(OPENVX_INCLUDE_DIR AND OPENVX_LIBRARIES) - set(HAVE_OPENVX TRUE) - - try_compile(OPENVX_RENAMED_REF - "${OpenCV_BINARY_DIR}" - "${OpenCV_SOURCE_DIR}/cmake/checks/openvx_refenum_test.cpp" - CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${OPENVX_INCLUDE_DIR}" - LINK_LIBRARIES ${OPENVX_LIBRARIES} - OUTPUT_VARIABLE OUTPUT - ) - if(OPENVX_RENAMED_REF) - add_definitions(-DIVX_RENAMED_REFS=1) - message(STATUS "OpenVX: Checking reference attribute name convention... New") - else() - message(STATUS "OpenVX: Checking reference attribute name convention... Old") - endif() -endif() - -if(NOT HAVE_OPENVX) - ocv_clear_vars(HAVE_OPENVX OPENVX_LIBRARIES OPENVX_INCLUDE_DIR) -endif() diff --git a/cmake/OpenCVFindTIMVX.cmake b/cmake/OpenCVFindTIMVX.cmake index ce084e45fb..01683ba7b9 100644 --- a/cmake/OpenCVFindTIMVX.cmake +++ b/cmake/OpenCVFindTIMVX.cmake @@ -1,6 +1,6 @@ set(TIMVX_INSTALL_DIR "" CACHE PATH "Path to libtim-vx installation") set(VIVANTE_SDK_DIR "" CACHE PATH "Path to VIVANTE SDK needed by TIM-VX.") -set(VIVANTE_SDK_LIB_CANDIDATES "OpenVX;VSC;GAL;ArchModelSw;NNArchPerf" CACHE STRING "VIVANTE SDK library candidates") +set(VIVANTE_SDK_LIB_CANDIDATES "VSC;GAL;ArchModelSw;NNArchPerf" CACHE STRING "VIVANTE SDK library candidates") # Ensure VIVANTE SDK library candidates are present in given search path function(find_vivante_sdk_libs _viv_notfound _viv_search_path) diff --git a/cmake/checks/openvx_refenum_test.cpp b/cmake/checks/openvx_refenum_test.cpp deleted file mode 100644 index f28db050cb..0000000000 --- a/cmake/checks/openvx_refenum_test.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include -int main() -{ - return VX_REFERENCE_COUNT == VX_REFERENCE_TYPE ? VX_REFERENCE_NAME : 0; -} diff --git a/cmake/templates/cvconfig.h.in b/cmake/templates/cvconfig.h.in index 057a92843e..b4e6903943 100644 --- a/cmake/templates/cvconfig.h.in +++ b/cmake/templates/cvconfig.h.in @@ -137,9 +137,6 @@ /* Library was compiled with functions instrumentation */ #cmakedefine ENABLE_INSTRUMENTATION -/* OpenVX */ -#cmakedefine HAVE_OPENVX - /* OpenCV trace utilities */ #cmakedefine OPENCV_TRACE diff --git a/doc/tutorials/introduction/config_reference/config_reference.markdown b/doc/tutorials/introduction/config_reference/config_reference.markdown index 09742ca9ba..3c61ae1c9a 100644 --- a/doc/tutorials/introduction/config_reference/config_reference.markdown +++ b/doc/tutorials/introduction/config_reference/config_reference.markdown @@ -623,7 +623,6 @@ Following build options are utilized in `opencv_contrib` modules, as stated [pre `WITH_CAROTENE` `WITH_CPUFEATURES` `WITH_EIGEN` -`WITH_OPENVX` `WITH_DIRECTX` `WITH_VA` `WITH_LAPACK` diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp index eb62b13345..435de869d5 100644 --- a/modules/core/include/opencv2/core.hpp +++ b/modules/core/include/opencv2/core.hpp @@ -3404,6 +3404,5 @@ struct ParamType<_Tp, typename std::enable_if< std::is_enum<_Tp>::value >::type> #include "opencv2/core/cvstd.inl.hpp" #include "opencv2/core/utility.hpp" #include "opencv2/core/optim.hpp" -#include "opencv2/core/ovx.hpp" #endif /*OPENCV_CORE_HPP*/ diff --git a/modules/core/include/opencv2/core/openvx/ovx_defs.hpp b/modules/core/include/opencv2/core/openvx/ovx_defs.hpp deleted file mode 100644 index a29db1b8ff..0000000000 --- a/modules/core/include/opencv2/core/openvx/ovx_defs.hpp +++ /dev/null @@ -1,48 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. - -// Copyright (C) 2016, Intel Corporation, all rights reserved. -// Third party copyrights are property of their respective owners. - -// OpenVX related definitions and declarations - -#pragma once -#ifndef OPENCV_OVX_DEFS_HPP -#define OPENCV_OVX_DEFS_HPP - -#include "cvconfig.h" - -// utility macro for running OpenVX-based implementations -#ifdef HAVE_OPENVX - -#define IVX_HIDE_INFO_WARNINGS -#define IVX_USE_OPENCV -#include "ivx.hpp" - -namespace cv{ -namespace ovx{ -// Get common thread local OpenVX context -CV_EXPORTS_W ivx::Context& getOpenVXContext(); - -template inline bool skipSmallImages(int w, int h) { return w*h < 3840 * 2160; } -}} - -#define CV_OVX_RUN(condition, func, ...) \ - if (cv::useOpenVX() && (condition) && func) \ - { \ - return __VA_ARGS__; \ - } - -#else - #define CV_OVX_RUN(condition, func, ...) -#endif // HAVE_OPENVX - -// Throw an error in debug mode or try another implementation in release -#ifdef _DEBUG -#define VX_DbgThrow(s) CV_Error(cv::Error::StsInternal, (s)) -#else -#define VX_DbgThrow(s) return false -#endif - -#endif // OPENCV_OVX_DEFS_HPP diff --git a/modules/core/include/opencv2/core/ovx.hpp b/modules/core/include/opencv2/core/ovx.hpp deleted file mode 100644 index 8bb7d54911..0000000000 --- a/modules/core/include/opencv2/core/ovx.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. - -// Copyright (C) 2016, Intel Corporation, all rights reserved. -// Third party copyrights are property of their respective owners. - -// OpenVX related definitions and declarations - -#pragma once -#ifndef OPENCV_OVX_HPP -#define OPENCV_OVX_HPP - -#include "cvdef.h" - -namespace cv -{ -/// Check if use of OpenVX is possible -CV_EXPORTS_W bool haveOpenVX(); - -/// Check if use of OpenVX is enabled -CV_EXPORTS_W bool useOpenVX(); - -/// Enable/disable use of OpenVX -CV_EXPORTS_W void setUseOpenVX(bool flag); -} // namespace cv - -#endif // OPENCV_OVX_HPP diff --git a/modules/core/include/opencv2/core/utils/trace.hpp b/modules/core/include/opencv2/core/utils/trace.hpp index ea43bbeea1..1244690e4d 100644 --- a/modules/core/include/opencv2/core/utils/trace.hpp +++ b/modules/core/include/opencv2/core/utils/trace.hpp @@ -106,7 +106,6 @@ enum RegionLocationFlag { REGION_FLAG_IMPL_IPP = (1 << 16), ///< region is part of IPP code path REGION_FLAG_IMPL_OPENCL = (2 << 16), ///< region is part of OpenCL code path - REGION_FLAG_IMPL_OPENVX = (3 << 16), ///< region is part of OpenVX code path REGION_FLAG_IMPL_MASK = (15 << 16), diff --git a/modules/core/include/opencv2/core/utils/trace.private.hpp b/modules/core/include/opencv2/core/utils/trace.private.hpp index 5a826b417b..885d818a72 100644 --- a/modules/core/include/opencv2/core/utils/trace.private.hpp +++ b/modules/core/include/opencv2/core/utils/trace.private.hpp @@ -79,9 +79,6 @@ struct RegionStatistics #ifdef HAVE_OPENCL int64 durationImplOpenCL; #endif -#ifdef HAVE_OPENVX - int64 durationImplOpenVX; -#endif RegionStatistics() : currentSkippedRegions(0), @@ -91,9 +88,6 @@ struct RegionStatistics #endif #ifdef HAVE_OPENCL ,durationImplOpenCL(0) -#endif -#ifdef HAVE_OPENVX - ,durationImplOpenVX(0) #endif {} @@ -106,9 +100,6 @@ struct RegionStatistics #endif #ifdef HAVE_OPENCL result.durationImplOpenCL = durationImplOpenCL; durationImplOpenCL = 0; -#endif -#ifdef HAVE_OPENVX - result.durationImplOpenVX = durationImplOpenVX; durationImplOpenVX = 0; #endif } @@ -121,9 +112,6 @@ struct RegionStatistics #endif #ifdef HAVE_OPENCL durationImplOpenCL += stat.durationImplOpenCL; -#endif -#ifdef HAVE_OPENVX - durationImplOpenVX += stat.durationImplOpenVX; #endif } @@ -135,9 +123,6 @@ struct RegionStatistics #endif #ifdef HAVE_OPENCL durationImplOpenCL = (int64)(durationImplOpenCL * c); -#endif -#ifdef HAVE_OPENVX - durationImplOpenVX = (int64)(durationImplOpenVX * c); #endif } }; @@ -152,9 +137,6 @@ std::ostream& operator<<(std::ostream& out, const RegionStatistics& stat) #endif #ifdef HAVE_OPENCL << " durationImplOpenCL=" << stat.durationImplOpenCL -#endif -#ifdef HAVE_OPENVX - << " durationImplOpenVX=" << stat.durationImplOpenVX #endif ; return out; @@ -169,9 +151,6 @@ struct RegionStatisticsStatus #ifdef HAVE_OPENCL int ignoreDepthImplOpenCL; #endif -#ifdef HAVE_OPENVX - int ignoreDepthImplOpenVX; -#endif RegionStatisticsStatus() { reset(); } @@ -183,9 +162,6 @@ struct RegionStatisticsStatus #endif #ifdef HAVE_OPENCL ignoreDepthImplOpenCL = 0; -#endif -#ifdef HAVE_OPENVX - ignoreDepthImplOpenVX = 0; #endif } @@ -199,9 +175,6 @@ struct RegionStatisticsStatus #endif #ifdef HAVE_OPENCL ignoreDepthImplOpenCL = src.ignoreDepthImplOpenCL ? 1 : 0; -#endif -#ifdef HAVE_OPENVX - ignoreDepthImplOpenVX = src.ignoreDepthImplOpenVX ? 1 : 0; #endif } @@ -222,10 +195,6 @@ std::ostream& operator<<(std::ostream& out, const RegionStatisticsStatus& s) #ifdef HAVE_OPENCL if (s.ignoreDepthImplOpenCL) out << " OpenCL=" << s.ignoreDepthImplOpenCL; -#endif -#ifdef HAVE_OPENVX - if (s.ignoreDepthImplOpenVX) - out << " OpenVX=" << s.ignoreDepthImplOpenVX; #endif out << "}"; return out; @@ -389,8 +358,7 @@ public: enum OptimizationPath { CODE_PATH_PLAIN = 0, CODE_PATH_IPP, - CODE_PATH_OPENCL, - CODE_PATH_OPENVX + CODE_PATH_OPENCL }; #ifdef OPENCV_WITH_ITT diff --git a/modules/core/src/lut.cpp b/modules/core/src/lut.cpp index 8d01a9d8a1..6e29cdfef0 100644 --- a/modules/core/src/lut.cpp +++ b/modules/core/src/lut.cpp @@ -6,7 +6,6 @@ #include "precomp.hpp" #include "opencl_kernels_core.hpp" #include "convert.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" /****************************************************************************************\ * LUT Transform * @@ -100,39 +99,6 @@ static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst) #endif -#ifdef HAVE_OPENVX -static bool openvx_LUT(Mat src, Mat dst, Mat _lut) -{ - if (src.type() != CV_8UC1 || dst.type() != src.type() || _lut.type() != src.type() || !_lut.isContinuous()) - return false; - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(src.cols, src.rows, 1, (vx_int32)(src.step)), src.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - ivx::LUT lut = ivx::LUT::create(ctx); - lut.copyFrom(_lut); - ivx::IVX_CHECK_STATUS(vxuTableLookup(ctx, ia, lut, ib)); - } - catch (const ivx::RuntimeError& e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError& e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -#endif - #if defined(HAVE_IPP) #if !IPP_DISABLE_PERF_LUT // there are no performance benefits (PR #2653) namespace ipp { @@ -374,8 +340,6 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst ) _dst.createSameSize(_src, CV_MAKETYPE(_lut.depth(), cn)); Mat dst = _dst.getMat(); - CV_OVX_RUN(!ovx::skipSmallImages(src.cols, src.rows), - openvx_LUT(src, dst, lut)) #if !IPP_DISABLE_PERF_LUT CV_IPP_RUN(_src.dims() <= 2, ipp_lut(src, lut, dst)); diff --git a/modules/core/src/mean.dispatch.cpp b/modules/core/src/mean.dispatch.cpp index 15c7077f50..6bc9a288dd 100644 --- a/modules/core/src/mean.dispatch.cpp +++ b/modules/core/src/mean.dispatch.cpp @@ -5,7 +5,6 @@ #include "precomp.hpp" #include "opencl_kernels_core.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" #include "stat.hpp" #ifndef OPENCV_IPP_MEAN @@ -319,69 +318,6 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv } #endif -#ifdef HAVE_OPENVX - static bool openvx_meanStdDev(Mat& src, OutputArray _mean, OutputArray _sdv, Mat& mask) - { - size_t total_size = src.total(); - int rows = src.size[0], cols = rows ? (int)(total_size / rows) : 0; - if (src.type() != CV_8UC1|| !mask.empty() || - (src.dims != 2 && !(src.isContinuous() && cols > 0 && (size_t)rows*cols == total_size)) - ) - return false; - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); -#ifndef VX_VERSION_1_1 - if (ctx.vendorID() == VX_ID_KHRONOS) - return false; // Do not use OpenVX meanStdDev estimation for sample 1.0.1 implementation due to lack of accuracy -#endif - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(cols, rows, 1, (vx_int32)(src.step[0])), src.ptr()); - - vx_float32 mean_temp, stddev_temp; - ivx::IVX_CHECK_STATUS(vxuMeanStdDev(ctx, ia, &mean_temp, &stddev_temp)); - - if (_mean.needed()) - { - if (!_mean.fixedSize()) - _mean.create(1, 1, CV_64F, -1, true); - Mat mean = _mean.getMat(); - CV_Assert(mean.type() == CV_64F && mean.isContinuous() && - (mean.cols == 1 || mean.rows == 1) && mean.total() >= 1); - double *pmean = mean.ptr(); - pmean[0] = mean_temp; - for (int c = 1; c < (int)mean.total(); c++) - pmean[c] = 0; - } - - if (_sdv.needed()) - { - if (!_sdv.fixedSize()) - _sdv.create(1, 1, CV_64F, -1, true); - Mat stddev = _sdv.getMat(); - CV_Assert(stddev.type() == CV_64F && stddev.isContinuous() && - (stddev.cols == 1 || stddev.rows == 1) && stddev.total() >= 1); - double *pstddev = stddev.ptr(); - pstddev[0] = stddev_temp; - for (int c = 1; c < (int)stddev.total(); c++) - pstddev[c] = 0; - } - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; - } -#endif #ifdef HAVE_IPP static bool ipp_meanStdDev(Mat& src, OutputArray _mean, OutputArray _sdv, Mat& mask) @@ -532,9 +468,6 @@ void meanStdDev(InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray Mat src = _src.getMat(), mask = _mask.getMat(); - CV_OVX_RUN(!ovx::skipSmallImages(src.cols, src.rows), - openvx_meanStdDev(src, _mean, _sdv, mask)) - CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_meanStdDev(src, _mean, _sdv, mask)); int k, cn = src.channels(), depth = src.depth(); diff --git a/modules/core/src/minmax.dispatch.cpp b/modules/core/src/minmax.dispatch.cpp index 411d0c4b75..529bd80b9f 100644 --- a/modules/core/src/minmax.dispatch.cpp +++ b/modules/core/src/minmax.dispatch.cpp @@ -5,7 +5,6 @@ #include "precomp.hpp" #include "opencl_kernels_core.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" #include "stat.hpp" #include "opencv2/core/detail/dispatch_helper.impl.hpp" #include diff --git a/modules/core/src/ovx.cpp b/modules/core/src/ovx.cpp deleted file mode 100644 index 560c601fce..0000000000 --- a/modules/core/src/ovx.cpp +++ /dev/null @@ -1,105 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. - -// Copyright (C) 2016, Intel Corporation, all rights reserved. -// Third party copyrights are property of their respective owners. - -// OpenVX related functions - -#include "precomp.hpp" -#include "opencv2/core/utils/tls.hpp" -#include "opencv2/core/ovx.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - -namespace cv -{ - -namespace ovx -{ -#ifdef HAVE_OPENVX - -// Simple TLSData doesn't work, because default constructor doesn't create any OpenVX context. -struct OpenVXTLSData -{ - OpenVXTLSData() : ctx(ivx::Context::create()) {} - ivx::Context ctx; -}; - -static TLSData& getOpenVXTLSData() -{ - CV_SINGLETON_LAZY_INIT_REF(TLSData, new TLSData()) -} - -struct OpenVXCleanupFunctor -{ - ~OpenVXCleanupFunctor() { getOpenVXTLSData().cleanup(); } -}; -static OpenVXCleanupFunctor g_openvx_cleanup_functor; - -ivx::Context& getOpenVXContext() -{ - return getOpenVXTLSData().get()->ctx; -} - -#endif - -} // namespace - - -bool haveOpenVX() -{ -#ifdef HAVE_OPENVX - static int g_haveOpenVX = -1; - if(g_haveOpenVX < 0) - { - try - { - ivx::Context context = ovx::getOpenVXContext(); - vx_uint16 vComp = ivx::compiledWithVersion(); - vx_uint16 vCurr = context.version(); - g_haveOpenVX = - VX_VERSION_MAJOR(vComp) == VX_VERSION_MAJOR(vCurr) && - VX_VERSION_MINOR(vComp) == VX_VERSION_MINOR(vCurr) - ? 1 : 0; - } - catch(const ivx::WrapperError&) - { g_haveOpenVX = 0; } - catch(const ivx::RuntimeError&) - { g_haveOpenVX = 0; } - } - return g_haveOpenVX == 1; -#else - return false; -#endif -} - -bool useOpenVX() -{ -#ifdef HAVE_OPENVX - CoreTLSData& data = getCoreTlsData(); - if (data.useOpenVX < 0) - { - // enabled (if available) by default - data.useOpenVX = haveOpenVX() ? 1 : 0; - } - return data.useOpenVX > 0; -#else - return false; -#endif -} - -void setUseOpenVX(bool flag) -{ -#ifdef HAVE_OPENVX - if( haveOpenVX() ) - { - CoreTLSData& data = getCoreTlsData(); - data.useOpenVX = flag ? 1 : 0; - } -#else - CV_Assert(!flag && "OpenVX support isn't enabled at compile time"); -#endif -} - -} // namespace cv diff --git a/modules/core/src/precomp.hpp b/modules/core/src/precomp.hpp index 1b0945d412..a361951c0e 100644 --- a/modules/core/src/precomp.hpp +++ b/modules/core/src/precomp.hpp @@ -353,9 +353,6 @@ struct CoreTLSData //#endif useIPP(-1), useIPP_NE(-1) -#ifdef HAVE_OPENVX - ,useOpenVX(-1) -#endif {} RNG rng; @@ -366,9 +363,6 @@ struct CoreTLSData //#endif int useIPP; // 1 - use, 0 - do not use, -1 - auto/not initialized int useIPP_NE; // 1 - use, 0 - do not use, -1 - auto/not initialized -#ifdef HAVE_OPENVX - int useOpenVX; // 1 - use, 0 - do not use, -1 - auto/not initialized -#endif }; CoreTLSData& getCoreTlsData(); diff --git a/modules/core/src/trace.cpp b/modules/core/src/trace.cpp index 05acbde7c9..29d5b2c563 100644 --- a/modules/core/src/trace.cpp +++ b/modules/core/src/trace.cpp @@ -171,10 +171,6 @@ public: #ifdef HAVE_OPENCL if (result.durationImplOpenCL) ok &= this->printf(",tOCL=%lld", (long long int)result.durationImplOpenCL); -#endif -#ifdef HAVE_OPENVX - if (result.durationImplOpenVX) - ok &= this->printf(",tOVX=%lld", (long long int)result.durationImplOpenVX); #endif ok &= this->printf("\n"); return ok; @@ -359,10 +355,6 @@ void Region::Impl::leaveRegion(TraceManagerThreadLocal& ctx) #ifdef HAVE_OPENCL if (result.durationImplOpenCL) __itt_metadata_add(domain, itt_id, __itt_string_handle_create("tOpenCL"), __itt_metadata_u64, 1, &result.durationImplOpenCL); -#endif -#ifdef HAVE_OPENVX - if (result.durationImplOpenVX) - __itt_metadata_add(domain, itt_id, __itt_string_handle_create("tOpenVX"), __itt_metadata_u64, 1, &result.durationImplOpenVX); #endif __itt_task_end(domain); } @@ -492,12 +484,6 @@ Region::Region(const LocationStaticStorage& location) : if (!ctx.stat_status.ignoreDepthImplOpenCL) ctx.stat_status.ignoreDepthImplOpenCL = currentDepth; break; -#endif -#ifdef HAVE_OPENVX - case REGION_FLAG_IMPL_OPENVX: - if (!ctx.stat_status.ignoreDepthImplOpenVX) - ctx.stat_status.ignoreDepthImplOpenVX = currentDepth; - break; #endif default: break; @@ -615,11 +601,6 @@ void Region::destroy() cv::ocl::finish(); myCodePath = Impl::CODE_PATH_OPENCL; break; -#endif -#ifdef HAVE_OPENVX - case REGION_FLAG_IMPL_OPENVX: - myCodePath = Impl::CODE_PATH_OPENVX; - break; #endif default: break; @@ -665,19 +646,6 @@ void Region::destroy() ctx.stat.durationImplOpenCL = duration; } break; -#endif -#ifdef HAVE_OPENVX - case Impl::CODE_PATH_OPENVX: - if (ctx.stat_status.ignoreDepthImplOpenVX == currentDepth) - { - ctx.stat.durationImplOpenVX += duration; - ctx.stat_status.ignoreDepthImplOpenVX = 0; - } - else if (active) - { - ctx.stat.durationImplOpenVX = duration; - } - break; #endif default: break; diff --git a/modules/features2d/src/fast.cpp b/modules/features2d/src/fast.cpp index ef1fd9378c..31f526104d 100644 --- a/modules/features2d/src/fast.cpp +++ b/modules/features2d/src/fast.cpp @@ -49,8 +49,6 @@ The references are: #include "opencv2/core/hal/intrin.hpp" #include "opencv2/core/utils/buffer_area.private.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - namespace cv { @@ -371,70 +369,6 @@ static bool ocl_FAST( InputArray _img, std::vector& keypoints, #endif -#ifdef HAVE_OPENVX -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 800 * 600; } -} -static bool openvx_FAST(InputArray _img, std::vector& keypoints, - int _threshold, bool nonmaxSuppression, int type) -{ - using namespace ivx; - - // Nonmax suppression is done differently in OpenCV than in OpenVX - // 9/16 is the only supported mode in OpenVX - if(nonmaxSuppression || type != FastFeatureDetector::TYPE_9_16) - return false; - - Mat imgMat = _img.getMat(); - if(imgMat.empty() || imgMat.type() != CV_8UC1) - return false; - - if (ovx::skipSmallImages(imgMat.cols, imgMat.rows)) - return false; - - try - { - Context context = ovx::getOpenVXContext(); - Image img = Image::createFromHandle(context, Image::matTypeToFormat(imgMat.type()), - Image::createAddressing(imgMat), (void*)imgMat.data); - ivx::Scalar threshold = ivx::Scalar::create(context, _threshold); - vx_size capacity = imgMat.cols * imgMat.rows; - Array corners = Array::create(context, VX_TYPE_KEYPOINT, capacity); - - ivx::Scalar numCorners = ivx::Scalar::create(context, 0); - - IVX_CHECK_STATUS(vxuFastCorners(context, img, threshold, (vx_bool)nonmaxSuppression, corners, numCorners)); - - size_t nPoints = numCorners.getValue(); - keypoints.clear(); keypoints.reserve(nPoints); - std::vector vxCorners; - corners.copyTo(vxCorners); - for(size_t i = 0; i < nPoints; i++) - { - vx_keypoint_t kp = vxCorners[i]; - //if nonmaxSuppression is false, kp.strength is undefined - keypoints.push_back(KeyPoint((float)kp.x, (float)kp.y, 7.f, -1, kp.strength)); - } - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - img.swapHandle(); -#endif - } - catch (const RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} - -#endif static inline int hal_FAST(cv::Mat& src, std::vector& keypoints, int threshold, bool nonmax_suppression, FastFeatureDetector::DetectorType type) { @@ -507,9 +441,6 @@ void FAST(InputArray _img, std::vector& keypoints, int threshold, bool CALL_HAL(fast, cv_hal_FAST, img.data, img.step, img.cols, img.rows, (uchar*)(keypoints.data()), &keypoints_count, threshold, nonmax_suppression, type); - CV_OVX_RUN(true, - openvx_FAST(_img, keypoints, threshold, nonmax_suppression, type)) - switch(type) { case FastFeatureDetector::TYPE_5_8: FAST_t<8>(_img, keypoints, threshold, nonmax_suppression); diff --git a/modules/imgproc/src/accum.cpp b/modules/imgproc/src/accum.cpp index bfb9f162b3..64631746ee 100644 --- a/modules/imgproc/src/accum.cpp +++ b/modules/imgproc/src/accum.cpp @@ -47,7 +47,6 @@ #define CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY #include "accum.simd.hpp" #include "accum.simd_declarations.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" namespace cv { @@ -231,80 +230,6 @@ static bool ipp_accumulate(InputArray _src, InputOutputArray _dst, InputArray _m } #endif -#ifdef HAVE_OPENVX -namespace cv -{ -enum -{ - VX_ACCUMULATE_OP = 0, - VX_ACCUMULATE_SQUARE_OP = 1, - VX_ACCUMULATE_WEIGHTED_OP = 2 -}; - -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 120 * 60; } -} -static bool openvx_accumulate(InputArray _src, InputOutputArray _dst, InputArray _mask, double _weight, int opType) -{ - Mat srcMat = _src.getMat(), dstMat = _dst.getMat(); - if (ovx::skipSmallImages(srcMat.cols, srcMat.rows)) - return false; - if(!_mask.empty() || - (opType == VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_8UC1 ) || - (opType != VX_ACCUMULATE_WEIGHTED_OP && dstMat.type() != CV_16SC1 ) || - srcMat.type() != CV_8UC1) - { - return false; - } - //TODO: handle different number of channels (channel extract && channel combine) - //TODO: handle mask (threshold mask to 0xff && bitwise AND with src) - //(both things can be done by creating a graph) - - try - { - ivx::Context context = ovx::getOpenVXContext(); - ivx::Image srcImage = ivx::Image::createFromHandle(context, ivx::Image::matTypeToFormat(srcMat.type()), - ivx::Image::createAddressing(srcMat), srcMat.data); - ivx::Image dstImage = ivx::Image::createFromHandle(context, ivx::Image::matTypeToFormat(dstMat.type()), - ivx::Image::createAddressing(dstMat), dstMat.data); - ivx::Scalar shift = ivx::Scalar::create(context, 0); - ivx::Scalar alpha = ivx::Scalar::create(context, _weight); - - switch (opType) - { - case VX_ACCUMULATE_OP: - ivx::IVX_CHECK_STATUS(vxuAccumulateImage(context, srcImage, dstImage)); - break; - case VX_ACCUMULATE_SQUARE_OP: - ivx::IVX_CHECK_STATUS(vxuAccumulateSquareImage(context, srcImage, shift, dstImage)); - break; - case VX_ACCUMULATE_WEIGHTED_OP: - ivx::IVX_CHECK_STATUS(vxuAccumulateWeightedImage(context, srcImage, alpha, dstImage)); - break; - default: - break; - } - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - srcImage.swapHandle(); dstImage.swapHandle(); -#endif - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -} -#endif - void cv::accumulate( InputArray _src, InputOutputArray _dst, InputArray _mask ) { CV_INSTRUMENT_REGION(); @@ -321,9 +246,6 @@ void cv::accumulate( InputArray _src, InputOutputArray _dst, InputArray _mask ) CV_IPP_RUN((_src.dims() <= 2 || (_src.isContinuous() && _dst.isContinuous() && (_mask.empty() || _mask.isContinuous()))), ipp_accumulate(_src, _dst, _mask)); - CV_OVX_RUN(_src.dims() <= 2, - openvx_accumulate(_src, _dst, _mask, 0.0, VX_ACCUMULATE_OP)) - Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat(); @@ -420,9 +342,6 @@ void cv::accumulateSquare( InputArray _src, InputOutputArray _dst, InputArray _m CV_IPP_RUN((_src.dims() <= 2 || (_src.isContinuous() && _dst.isContinuous() && (_mask.empty() || _mask.isContinuous()))), ipp_accumulate_square(_src, _dst, _mask)); - CV_OVX_RUN(_src.dims() <= 2, - openvx_accumulate(_src, _dst, _mask, 0.0, VX_ACCUMULATE_SQUARE_OP)) - Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat(); int fidx = getAccTabIdx(sdepth, ddepth); @@ -624,9 +543,6 @@ void cv::accumulateWeighted( InputArray _src, InputOutputArray _dst, CV_IPP_RUN((_src.dims() <= 2 || (_src.isContinuous() && _dst.isContinuous() && _mask.isContinuous())), ipp_accumulate_weighted(_src, _dst, alpha, _mask)); - CV_OVX_RUN(_src.dims() <= 2, - openvx_accumulate(_src, _dst, _mask, alpha, VX_ACCUMULATE_WEIGHTED_OP)) - Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat(); diff --git a/modules/imgproc/src/box_filter.dispatch.cpp b/modules/imgproc/src/box_filter.dispatch.cpp index 6baefdff1a..55ac5c65bd 100644 --- a/modules/imgproc/src/box_filter.dispatch.cpp +++ b/modules/imgproc/src/box_filter.dispatch.cpp @@ -48,8 +48,6 @@ #include "opencv2/core/hal/intrin.hpp" #include "opencl_kernels_imgproc.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - #include "box_filter.simd.hpp" #include "box_filter.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content @@ -315,79 +313,6 @@ Ptr createBoxFilter(int srcType, int dstType, Size ksize, CV_CPU_DISPATCH_MODES_ALL); } -#ifdef HAVE_OPENVX - namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 640 * 480; } - } - static bool openvx_boxfilter(InputArray _src, OutputArray _dst, int ddepth, - Size ksize, Point anchor, - bool normalize, int borderType) - { - if (ddepth < 0) - ddepth = CV_8UC1; - if (_src.type() != CV_8UC1 || ddepth != CV_8U || !normalize || - _src.cols() < 3 || _src.rows() < 3 || - ksize.width != 3 || ksize.height != 3 || - (anchor.x >= 0 && anchor.x != 1) || - (anchor.y >= 0 && anchor.y != 1) || - ovx::skipSmallImages(_src.cols(), _src.rows())) - return false; - - Mat src = _src.getMat(); - - if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix()) - return false; //Process isolated borders only - vx_enum border; - switch (borderType & ~BORDER_ISOLATED) - { - case BORDER_CONSTANT: - border = VX_BORDER_CONSTANT; - break; - case BORDER_REPLICATE: - border = VX_BORDER_REPLICATE; - break; - default: - return false; - } - - _dst.create(src.size(), CV_8UC1); - Mat dst = _dst.getMat(); - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standard says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(border, (vx_uint8)(0)); - ivx::IVX_CHECK_STATUS(vxuBox3x3(ctx, ia, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; - } -#endif #if 0 //defined(HAVE_IPP) static bool ipp_boxfilter(Mat &src, Mat &dst, Size ksize, Point anchor, bool normalize, int borderType) @@ -475,9 +400,6 @@ void boxFilter(InputArray _src, OutputArray _dst, int ddepth, ofs.x, ofs.y, wsz.width - src.cols - ofs.x, wsz.height - src.rows - ofs.y, ksize.width, ksize.height, anchor.x, anchor.y, normalize, borderType&~BORDER_ISOLATED); - CV_OVX_RUN(true, - openvx_boxfilter(src, dst, ddepth, ksize, anchor, normalize, borderType)) - //CV_IPP_RUN_FAST(ipp_boxfilter(src, dst, ksize, anchor, normalize, borderType)); borderType = (borderType&~BORDER_ISOLATED); diff --git a/modules/imgproc/src/canny.cpp b/modules/imgproc/src/canny.cpp index 1eaa169e2b..2e8e13a119 100644 --- a/modules/imgproc/src/canny.cpp +++ b/modules/imgproc/src/canny.cpp @@ -45,8 +45,6 @@ #include "opencv2/core/hal/intrin.hpp" #include -#include "opencv2/core/openvx/ovx_defs.hpp" - namespace cv { @@ -761,65 +759,6 @@ private: finalPass& operator=(const finalPass&); // = delete }; -#ifdef HAVE_OPENVX -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 640 * 480; } -} -static bool openvx_canny(const Mat& src, Mat& dst, int loVal, int hiVal, int kSize, bool useL2) -{ - using namespace ivx; - - Context context = ovx::getOpenVXContext(); - try - { - Image _src = Image::createFromHandle( - context, - Image::matTypeToFormat(src.type()), - Image::createAddressing(src), - src.data ); - Image _dst = Image::createFromHandle( - context, - Image::matTypeToFormat(dst.type()), - Image::createAddressing(dst), - dst.data ); - Threshold threshold = Threshold::createRange(context, VX_TYPE_UINT8, saturate_cast(loVal), saturate_cast(hiVal)); - -#if 0 - // the code below is disabled because vxuCannyEdgeDetector() - // ignores context attribute VX_CONTEXT_IMMEDIATE_BORDER - - // FIXME: may fail in multithread case - border_t prevBorder = context.immediateBorder(); - context.setImmediateBorder(VX_BORDER_REPLICATE); - IVX_CHECK_STATUS( vxuCannyEdgeDetector(context, _src, threshold, kSize, (useL2 ? VX_NORM_L2 : VX_NORM_L1), _dst) ); - context.setImmediateBorder(prevBorder); -#else - // alternative code without vxuCannyEdgeDetector() - Graph graph = Graph::create(context); - ivx::Node node = ivx::Node(vxCannyEdgeDetectorNode(graph, _src, threshold, kSize, (useL2 ? VX_NORM_L2 : VX_NORM_L1), _dst) ); - node.setBorder(VX_BORDER_REPLICATE); - graph.verify(); - graph.process(); -#endif - -#ifdef VX_VERSION_1_1 - _src.swapHandle(); - _dst.swapHandle(); -#endif - } - catch(const WrapperError& e) - { - VX_DbgThrow(e.what()); - } - catch(const RuntimeError& e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -#endif // HAVE_OPENVX - void Canny( InputArray _src, OutputArray _dst, double low_thresh, double high_thresh, int aperture_size, bool L2gradient ) @@ -864,21 +803,6 @@ void Canny( InputArray _src, OutputArray _dst, CALL_HAL(canny, cv_hal_canny, src.data, src.step, dst.data, dst.step, src.cols, src.rows, src.channels(), low_thresh, high_thresh, aperture_size, L2gradient); - CV_OVX_RUN( - false && /* disabling due to accuracy issues */ - src.type() == CV_8UC1 && - !src.isSubmatrix() && - src.cols >= aperture_size && - src.rows >= aperture_size && - !ovx::skipSmallImages(src.cols, src.rows), - openvx_canny( - src, - dst, - cvFloor(low_thresh), - cvFloor(high_thresh), - aperture_size, - L2gradient ) ) - CV_IPP_RUN_FAST(ipp_Canny(src, Mat(), Mat(), dst, (float)low_thresh, (float)high_thresh, L2gradient, aperture_size)) if (L2gradient) diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp index 8fa297a841..dbc2c0815a 100644 --- a/modules/imgproc/src/deriv.cpp +++ b/modules/imgproc/src/deriv.cpp @@ -43,7 +43,6 @@ #include "precomp.hpp" #include "opencl_kernels_imgproc.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" #include "filter.hpp" /****************************************************************************************\ @@ -182,83 +181,6 @@ cv::Ptr cv::createDerivFilter(int srcType, int dstType, kx, ky, Point(-1,-1), 0, borderType ); } -#ifdef HAVE_OPENVX -namespace cv -{ - namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } - } - static bool openvx_sobel(InputArray _src, OutputArray _dst, - int dx, int dy, int ksize, - double scale, double delta, int borderType) - { - if (_src.type() != CV_8UC1 || _dst.type() != CV_16SC1 || - ksize != 3 || scale != 1.0 || delta != 0.0 || - (dx | dy) != 1 || (dx + dy) != 1 || - _src.cols() < ksize || _src.rows() < ksize || - ovx::skipSmallImages(_src.cols(), _src.rows()) - ) - return false; - - Mat src = _src.getMat(); - Mat dst = _dst.getMat(); - - if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix()) - return false; //Process isolated borders only - vx_enum border; - switch (borderType & ~BORDER_ISOLATED) - { - case BORDER_CONSTANT: - border = VX_BORDER_CONSTANT; - break; - case BORDER_REPLICATE: -// border = VX_BORDER_REPLICATE; -// break; - default: - return false; - } - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - //if ((vx_size)ksize > ctx.convolutionMaxDimension()) - // return false; - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_S16, - ivx::Image::createAddressing(dst.cols, dst.rows, 2, (vx_int32)(dst.step)), dst.data); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standard says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(border, (vx_uint8)(0)); - if(dx) - ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, ib, NULL)); - else - ivx::IVX_CHECK_STATUS(vxuSobel3x3(ctx, ia, NULL, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; - } -} -#endif #if 0 //defined HAVE_IPP namespace cv @@ -456,8 +378,6 @@ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy, CALL_HAL(sobel, cv_hal_sobel, src.ptr(), src.step, dst.ptr(), dst.step, src.cols, src.rows, sdepth, ddepth, cn, ofs.x, ofs.y, wsz.width - src.cols - ofs.x, wsz.height - src.rows - ofs.y, dx, dy, ksize, scale, delta, borderType&~BORDER_ISOLATED); - CV_OVX_RUN(true, - openvx_sobel(src, dst, dx, dy, ksize, scale, delta, borderType)) //CV_IPP_RUN_FAST(ipp_Deriv(src, dst, dx, dy, ksize, scale, delta, borderType)); diff --git a/modules/imgproc/src/featureselect.cpp b/modules/imgproc/src/featureselect.cpp index 5d71315614..5b34c36f29 100644 --- a/modules/imgproc/src/featureselect.cpp +++ b/modules/imgproc/src/featureselect.cpp @@ -42,8 +42,6 @@ #include "precomp.hpp" #include "opencl_kernels_imgproc.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - #include #include #include @@ -274,95 +272,6 @@ static bool ocl_goodFeaturesToTrack( InputArray _image, OutputArray _corners, #endif -#ifdef HAVE_OPENVX -struct VxKeypointsComparator -{ - bool operator () (const vx_keypoint_t& a, const vx_keypoint_t& b) - { - return a.strength > b.strength; - } -}; - -static bool openvx_harris(Mat image, OutputArray _corners, - int _maxCorners, double _qualityLevel, double _minDistance, - int _blockSize, int _gradientSize, double _harrisK) -{ - using namespace ivx; - - if(image.type() != CV_8UC1) return false; - - //OpenVX implementations don't have to provide other sizes - if(!(_blockSize == 3 || _blockSize == 5 || _blockSize == 7)) return false; - - try - { - Context context = ovx::getOpenVXContext(); - - Image ovxImage = Image::createFromHandle(context, Image::matTypeToFormat(image.type()), - Image::createAddressing(image), image.data); - //The minimum threshold which to eliminate Harris Corner scores (computed using the normalized Sobel kernel). - //set to 0, we'll filter it later by threshold - ivx::Scalar strengthThresh = ivx::Scalar::create(context, 0); - - //The gradient window size to use on the input. - vx_int32 gradientSize = _gradientSize; - - //The block window size used to compute the harris corner score - vx_int32 blockSize = _blockSize; - - //The scalar sensitivity threshold k from the Harris-Stephens equation - ivx::Scalar sensivity = ivx::Scalar::create(context, _harrisK); - - //The radial Euclidean distance for non-maximum suppression - ivx::Scalar minDistance = ivx::Scalar::create(context, _minDistance); - - vx_size capacity = image.cols * image.rows; - Array corners = Array::create(context, VX_TYPE_KEYPOINT, capacity); - ivx::Scalar numCorners = ivx::Scalar::create(context, 0); - - IVX_CHECK_STATUS(vxuHarrisCorners(context, ovxImage, strengthThresh, minDistance, sensivity, - gradientSize, blockSize, corners, numCorners)); - - std::vector vxKeypoints; - corners.copyTo(vxKeypoints); - - std::sort(vxKeypoints.begin(), vxKeypoints.end(), VxKeypointsComparator()); - - vx_float32 maxStrength = 0.0f; - if(vxKeypoints.size() > 0) - maxStrength = vxKeypoints[0].strength; - size_t maxKeypoints = min((size_t)_maxCorners, vxKeypoints.size()); - std::vector keypoints; - keypoints.reserve(maxKeypoints); - for(size_t i = 0; i < maxKeypoints; i++) - { - vx_keypoint_t kp = vxKeypoints[i]; - if(kp.strength < maxStrength*_qualityLevel) break; - keypoints.push_back(Point2f((float)kp.x, (float)kp.y)); - } - - Mat(keypoints).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F); - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - ovxImage.swapHandle(); -#endif - } - catch (const RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} - -#endif - } void cv::goodFeaturesToTrack( InputArray image, OutputArray corners, @@ -403,11 +312,6 @@ void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners, return; } - // Disabled due to bad accuracy - CV_OVX_RUN(false && useHarrisDetector && _mask.empty() && - !ovx::skipSmallImages(image.cols, image.rows), - openvx_harris(image, _corners, maxCorners, qualityLevel, minDistance, blockSize, gradientSize, harrisK)) - if( useHarrisDetector ) cornerHarris( image, eig, blockSize, gradientSize, harrisK ); else diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp index da80cd0738..a6be08eb5c 100644 --- a/modules/imgproc/src/histogram.cpp +++ b/modules/imgproc/src/histogram.cpp @@ -43,8 +43,6 @@ #include "opencl_kernels_imgproc.hpp" #include "opencv2/core/hal/intrin.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - #include "opencv2/core/utils/tls.hpp" void cvSetHistBinRanges( CvHistogram* hist, float** ranges, int uniform ); @@ -838,64 +836,6 @@ private: } -#ifdef HAVE_OPENVX -namespace cv -{ - namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 2048 * 1536; } - } - static bool openvx_calchist(const Mat& image, OutputArray _hist, const int histSize, - const float* _range) - { - vx_int32 offset = (vx_int32)(_range[0]); - vx_uint32 range = (vx_uint32)(_range[1] - _range[0]); - if (float(offset) != _range[0] || float(range) != (_range[1] - _range[0])) - return false; - - size_t total_size = image.total(); - int rows = image.dims > 1 ? image.size[0] : 1, cols = rows ? (int)(total_size / rows) : 0; - if (image.dims > 2 && !(image.isContinuous() && cols > 0 && (size_t)rows*cols == total_size)) - return false; - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); -#if VX_VERSION <= VX_VERSION_1_0 - if (ctx.vendorID() == VX_ID_KHRONOS && (range % histSize)) - return false; -#endif - - ivx::Image - img = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(cols, rows, 1, (vx_int32)(image.step[0])), image.data); - - ivx::Distribution vxHist = ivx::Distribution::create(ctx, histSize, offset, range); - ivx::IVX_CHECK_STATUS(vxuHistogram(ctx, img, vxHist)); - - _hist.create(1, &histSize, CV_32F); - Mat hist = _hist.getMat(), ihist = hist; - ihist.flags = (ihist.flags & ~CV_MAT_TYPE_MASK) | CV_32S; - vxHist.copyTo(ihist); - ihist.convertTo(hist, CV_32F); - -#ifdef VX_VERSION_1_1 - img.swapHandle(); -#endif - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; - } -} -#endif - #ifdef HAVE_IPP #define IPP_HISTOGRAM_PARALLEL 1 namespace cv @@ -956,14 +896,6 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels, CV_Assert(images && nimages > 0); - CV_OVX_RUN( - images && histSize && - nimages == 1 && images[0].type() == CV_8UC1 && dims == 1 && _mask.getMat().empty() && - (!channels || channels[0] == 0) && !accumulate && uniform && - ranges && ranges[0] && - !ovx::skipSmallImages(images[0].cols, images[0].rows), - openvx_calchist(images[0], _hist, histSize[0], ranges[0])) - Mat mask = _mask.getMat(); CV_Assert(dims > 0 && histSize); @@ -2611,43 +2543,6 @@ static bool ocl_equalizeHist(InputArray _src, OutputArray _dst) #endif -#ifdef HAVE_OPENVX -namespace cv -{ -static bool openvx_equalize_hist(Mat srcMat, Mat dstMat) -{ - using namespace ivx; - - try - { - Context context = ovx::getOpenVXContext(); - Image srcImage = Image::createFromHandle(context, Image::matTypeToFormat(srcMat.type()), - Image::createAddressing(srcMat), srcMat.data); - Image dstImage = Image::createFromHandle(context, Image::matTypeToFormat(dstMat.type()), - Image::createAddressing(dstMat), dstMat.data); - - IVX_CHECK_STATUS(vxuEqualizeHist(context, srcImage, dstImage)); - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - srcImage.swapHandle(); dstImage.swapHandle(); -#endif - } - catch (const RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -} -#endif - void cv::equalizeHist( InputArray _src, OutputArray _dst ) { CV_INSTRUMENT_REGION(); @@ -2664,9 +2559,6 @@ void cv::equalizeHist( InputArray _src, OutputArray _dst ) _dst.create( src.size(), src.type() ); Mat dst = _dst.getMat(); - CV_OVX_RUN(!ovx::skipSmallImages(src.cols, src.rows), - openvx_equalize_hist(src, dst)) - Mutex histogramLockInstance; const int hist_sz = EqualizeHistCalcHist_Invoker::HIST_SZ; diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 4710515f9b..ee5ef0af94 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -52,7 +52,6 @@ #include "hal_replacement.hpp" #include #include "opencv2/core/hal/intrin.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" #include "opencv2/core/softfloat.hpp" #include "imgwarp.hpp" @@ -1573,94 +1572,6 @@ static bool ocl_logPolar(InputArray _src, OutputArray _dst, #endif -#ifdef HAVE_OPENVX -static bool openvx_remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation, const Scalar& borderValue) -{ - vx_interpolation_type_e inter_type; - switch (interpolation) - { - case INTER_LINEAR: -#if VX_VERSION > VX_VERSION_1_0 - inter_type = VX_INTERPOLATION_BILINEAR; -#else - inter_type = VX_INTERPOLATION_TYPE_BILINEAR; -#endif - break; - case INTER_NEAREST: -/* NEAREST_NEIGHBOR mode disabled since OpenCV round half to even while OpenVX sample implementation round half up -#if VX_VERSION > VX_VERSION_1_0 - inter_type = VX_INTERPOLATION_NEAREST_NEIGHBOR; -#else - inter_type = VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR; -#endif - if (!map1.empty()) - for (int y = 0; y < map1.rows; ++y) - { - float* line = map1.ptr(y); - for (int x = 0; x < map1.cols; ++x) - line[x] = cvRound(line[x]); - } - if (!map2.empty()) - for (int y = 0; y < map2.rows; ++y) - { - float* line = map2.ptr(y); - for (int x = 0; x < map2.cols; ++x) - line[x] = cvRound(line[x]); - } - break; -*/ - case INTER_AREA://AREA interpolation mode is unsupported - default: - return false; - } - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standard says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(VX_BORDER_CONSTANT, (vx_uint8)(borderValue[0])); - - ivx::Remap map = ivx::Remap::create(ctx, src.cols, src.rows, dst.cols, dst.rows); - if (map1.empty()) map.setMappings(map2); - else if (map2.empty()) map.setMappings(map1); - else map.setMappings(map1, map2); - ivx::IVX_CHECK_STATUS(vxuRemap(ctx, ia, map, inter_type, ib)); -#ifdef VX_VERSION_1_1 - ib.swapHandle(); - ia.swapHandle(); -#endif - - ctx.setImmediateBorder(prevBorder); - } - catch (const ivx::RuntimeError & e) - { - CV_Error(cv::Error::StsInternal, e.what()); - return false; - } - catch (const ivx::WrapperError & e) - { - CV_Error(cv::Error::StsInternal, e.what()); - return false; - } - return true; -} -#endif - #if defined HAVE_IPP && !IPP_DISABLE_REMAP typedef IppStatus (CV_STDCALL * ippiRemap)(const void * pSrc, IppiSize srcSize, int srcStep, IppiRect srcRoi, @@ -1800,17 +1711,6 @@ void cv::remap( InputArray _src, OutputArray _dst, Mat dst = _dst.getMat(); - CV_OVX_RUN( - src.type() == CV_8UC1 && dst.type() == CV_8UC1 && - !ovx::skipSmallImages(src.cols, src.rows) && - (borderType& ~BORDER_ISOLATED) == BORDER_CONSTANT && - ((map1.type() == CV_32FC2 && map2.empty() && map1.size == dst.size) || - (map1.type() == CV_32FC1 && map2.type() == CV_32FC1 && map1.size == dst.size && map2.size == dst.size) || - (map1.empty() && map2.type() == CV_32FC2 && map2.size == dst.size)) && - ((borderType & BORDER_ISOLATED) != 0 || !src.isSubmatrix()) && - !hasRelativeFlag, - openvx_remap(src, dst, map1, map2, interpolation, borderValue)); - CV_Assert( dst.cols < SHRT_MAX && dst.rows < SHRT_MAX && src.cols < SHRT_MAX && src.rows < SHRT_MAX ); if( dst.data == src.data ) diff --git a/modules/imgproc/src/median_blur.dispatch.cpp b/modules/imgproc/src/median_blur.dispatch.cpp index 949a0a9ece..6e1b9c917d 100644 --- a/modules/imgproc/src/median_blur.dispatch.cpp +++ b/modules/imgproc/src/median_blur.dispatch.cpp @@ -48,8 +48,6 @@ #include "opencv2/core/hal/intrin.hpp" #include "opencl_kernels_imgproc.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - #include "median_blur.simd.hpp" #include "median_blur.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content @@ -112,97 +110,6 @@ static bool ocl_medianFilter(InputArray _src, OutputArray _dst, int m) #endif -#ifdef HAVE_OPENVX -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 1280 * 720; } -} -static bool openvx_medianFilter(InputArray _src, OutputArray _dst, int ksize) -{ - if (_src.type() != CV_8UC1 || _dst.type() != CV_8U -#ifndef VX_VERSION_1_1 - || ksize != 3 -#endif - ) - return false; - - Mat src = _src.getMat(); - Mat dst = _dst.getMat(); - - if ( -#ifdef VX_VERSION_1_1 - ksize != 3 ? ovx::skipSmallImages(src.cols, src.rows) : -#endif - ovx::skipSmallImages(src.cols, src.rows) - ) - return false; - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); -#ifdef VX_VERSION_1_1 - if ((vx_size)ksize > ctx.nonlinearMaxDimension()) - return false; -#endif - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standard says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(VX_BORDER_REPLICATE); -#ifdef VX_VERSION_1_1 - if (ksize == 3) -#endif - { - ivx::IVX_CHECK_STATUS(vxuMedian3x3(ctx, ia, ib)); - } -#ifdef VX_VERSION_1_1 - else - { - ivx::Matrix mtx; - if(ksize == 5) - mtx = ivx::Matrix::createFromPattern(ctx, VX_PATTERN_BOX, ksize, ksize); - else - { - vx_size supportedSize; - ivx::IVX_CHECK_STATUS(vxQueryContext(ctx, VX_CONTEXT_NONLINEAR_MAX_DIMENSION, &supportedSize, sizeof(supportedSize))); - if ((vx_size)ksize > supportedSize) - { - ctx.setImmediateBorder(prevBorder); - return false; - } - Mat mask(ksize, ksize, CV_8UC1, Scalar(255)); - mtx = ivx::Matrix::create(ctx, VX_TYPE_UINT8, ksize, ksize); - mtx.copyFrom(mask); - } - ivx::IVX_CHECK_STATUS(vxuNonLinearFilter(ctx, VX_NONLINEAR_FILTER_MEDIAN, ia, mtx, ib)); - } -#endif - ctx.setImmediateBorder(prevBorder); - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -#endif - #if 0 //defined HAVE_IPP static bool ipp_medianFilter(Mat &src0, Mat &dst, int ksize) { @@ -300,9 +207,6 @@ void medianBlur( InputArray _src0, OutputArray _dst, int ksize ) CALL_HAL(medianBlur, cv_hal_medianBlur, src0.data, src0.step, dst.data, dst.step, src0.cols, src0.rows, src0.depth(), src0.channels(), ksize); - CV_OVX_RUN(true, - openvx_medianFilter(_src0, _dst, ksize)) - //CV_IPP_RUN_FAST(ipp_medianFilter(src0, dst, ksize)); CV_CPU_DISPATCH(medianBlur, (src0, dst, ksize), diff --git a/modules/imgproc/src/pyramids.cpp b/modules/imgproc/src/pyramids.cpp index 9b810d464f..1978638102 100644 --- a/modules/imgproc/src/pyramids.cpp +++ b/modules/imgproc/src/pyramids.cpp @@ -45,7 +45,6 @@ #include "opencl_kernels_imgproc.hpp" #include "opencv2/core/hal/intrin.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" namespace cv { @@ -1329,85 +1328,6 @@ static bool ipp_pyrdown( InputArray _src, OutputArray _dst, const Size& _dsz, in } #endif -#ifdef HAVE_OPENVX -namespace cv -{ -static bool openvx_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType ) -{ - using namespace ivx; - - Mat srcMat = _src.getMat(); - - if (ovx::skipSmallImages(srcMat.cols, srcMat.rows)) - return false; - - CV_Assert(!srcMat.empty()); - - Size ssize = _src.size(); - Size acceptableSize = Size((ssize.width + 1) / 2, (ssize.height + 1) / 2); - - // OpenVX limitations - if((srcMat.type() != CV_8U) || - (borderType != BORDER_REPLICATE) || - (_dsz != acceptableSize && !_dsz.empty())) - return false; - - // The only border mode which is supported by both cv::pyrDown() and OpenVX - // and produces predictable results - ivx::border_t borderMode; - borderMode.mode = VX_BORDER_REPLICATE; - - _dst.create( acceptableSize, srcMat.type() ); - Mat dstMat = _dst.getMat(); - - CV_Assert( ssize.width > 0 && ssize.height > 0 && - std::abs(acceptableSize.width*2 - ssize.width) <= 2 && - std::abs(acceptableSize.height*2 - ssize.height) <= 2 ); - - try - { - Context context = ovx::getOpenVXContext(); - if(context.vendorID() == VX_ID_KHRONOS) - { - // This implementation performs floor-like rounding - // (OpenCV uses floor(x+0.5)-like rounding) - // and ignores border mode (and loses 1px size border) - return false; - } - - Image srcImg = Image::createFromHandle(context, Image::matTypeToFormat(srcMat.type()), - Image::createAddressing(srcMat), (void*)srcMat.data); - Image dstImg = Image::createFromHandle(context, Image::matTypeToFormat(dstMat.type()), - Image::createAddressing(dstMat), (void*)dstMat.data); - - ivx::Scalar kernelSize = ivx::Scalar::create(context, 5); - Graph graph = Graph::create(context); - ivx::Node halfNode = ivx::Node::create(graph, VX_KERNEL_HALFSCALE_GAUSSIAN, srcImg, dstImg, kernelSize); - halfNode.setBorder(borderMode); - graph.verify(); - graph.process(); - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - srcImg.swapHandle(); dstImg.swapHandle(); -#endif - } - catch (const RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} - -} -#endif - void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType ) { CV_INSTRUMENT_REGION(); @@ -1417,9 +1337,6 @@ void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borde CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(), ocl_pyrDown(_src, _dst, _dsz, borderType)) - CV_OVX_RUN(_src.dims() <= 2, - openvx_pyrDown(_src, _dst, _dsz, borderType)) - Mat src = _src.getMat(); Size dsz = _dsz.empty() ? Size((src.cols + 1)/2, (src.rows + 1)/2) : _dsz; _dst.create( dsz, src.type() ); diff --git a/modules/imgproc/src/resize.cpp b/modules/imgproc/src/resize.cpp index 49914ad415..9b0f72fcfb 100644 --- a/modules/imgproc/src/resize.cpp +++ b/modules/imgproc/src/resize.cpp @@ -53,7 +53,6 @@ #include "opencv2/core/hal/intrin.hpp" #include "opencv2/core/utils/buffer_area.private.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" #include "resize.hpp" #include "opencv2/core/softfloat.hpp" diff --git a/modules/imgproc/src/smooth.dispatch.cpp b/modules/imgproc/src/smooth.dispatch.cpp index 3ab8501601..3e23187de2 100644 --- a/modules/imgproc/src/smooth.dispatch.cpp +++ b/modules/imgproc/src/smooth.dispatch.cpp @@ -53,8 +53,6 @@ #include "opencv2/core/hal/intrin.hpp" #include "opencl_kernels_imgproc.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - #include "filter.hpp" #include "opencv2/core/softfloat.hpp" @@ -386,88 +384,6 @@ static bool ocl_GaussianBlur_8UC1(InputArray _src, OutputArray _dst, Size ksize, #endif -#ifdef HAVE_OPENVX - -namespace ovx { - template <> inline bool skipSmallImages(int w, int h) { return w*h < 320 * 240; } -} -static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize, - double sigma1, double sigma2, int borderType) -{ - if (sigma2 <= 0) - sigma2 = sigma1; - // automatic detection of kernel size from sigma - if (ksize.width <= 0 && sigma1 > 0) - ksize.width = cvRound(sigma1*6 + 1) | 1; - if (ksize.height <= 0 && sigma2 > 0) - ksize.height = cvRound(sigma2*6 + 1) | 1; - - if (_src.type() != CV_8UC1 || - _src.cols() < 3 || _src.rows() < 3 || - ksize.width != 3 || ksize.height != 3) - return false; - - sigma1 = std::max(sigma1, 0.); - sigma2 = std::max(sigma2, 0.); - - if (!(sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) || !(sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON) || - ovx::skipSmallImages(_src.cols(), _src.rows())) - return false; - - Mat src = _src.getMat(); - Mat dst = _dst.getMat(); - - if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix()) - return false; //Process isolated borders only - vx_enum border; - switch (borderType & ~BORDER_ISOLATED) - { - case BORDER_CONSTANT: - border = VX_BORDER_CONSTANT; - break; - case BORDER_REPLICATE: - border = VX_BORDER_REPLICATE; - break; - default: - return false; - } - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - - Mat a; - if (dst.data != src.data) - a = src; - else - src.copyTo(a); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - //ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments - //since OpenVX standard says nothing about thread-safety for now - ivx::border_t prevBorder = ctx.immediateBorder(); - ctx.setImmediateBorder(border, (vx_uint8)(0)); - ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib)); - ctx.setImmediateBorder(prevBorder); - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - return true; -} - -#endif - #if defined ENABLE_IPP_GAUSSIAN_BLUR // see CMake's OPENCV_IPP_GAUSSIAN_BLUR option #define IPP_DISABLE_GAUSSIAN_BLUR_LARGE_KERNELS_1TH 1 @@ -746,9 +662,6 @@ void GaussianBlur(InputArray _src, OutputArray _dst, Size ksize, ofs.x, ofs.y, wsz.width - src.cols - ofs.x, wsz.height - src.rows - ofs.y, ksize.width, ksize.height, sigma1, sigma2, borderType&~BORDER_ISOLATED); - CV_OVX_RUN(true, - openvx_gaussianBlur(src, dst, ksize, sigma1, sigma2, borderType)) - #if defined ENABLE_IPP_GAUSSIAN_BLUR // IPP is not bit-exact to OpenCV implementation CV_IPP_RUN_FAST(ipp_GaussianBlur(src, dst, ksize, sigma1, sigma2, borderType)); diff --git a/modules/imgproc/src/thresh.cpp b/modules/imgproc/src/thresh.cpp index f1c1b1069a..f9b872bc14 100644 --- a/modules/imgproc/src/thresh.cpp +++ b/modules/imgproc/src/thresh.cpp @@ -44,8 +44,6 @@ #include "opencl_kernels_imgproc.hpp" #include "opencv2/core/hal/intrin.hpp" -#include "opencv2/core/openvx/ovx_defs.hpp" - namespace cv { @@ -1443,98 +1441,6 @@ static bool ocl_threshold( InputArray _src, OutputArray _dst, double & thresh, d } #endif - - -#ifdef HAVE_OPENVX -#define IMPL_OPENVX_TOZERO 1 -static bool openvx_threshold(Mat src, Mat dst, int thresh, int maxval, int type) -{ - Mat a = src; - - int trueVal, falseVal; - switch (type) - { - case THRESH_BINARY: -#ifndef VX_VERSION_1_1 - if (maxval != 255) - return false; -#endif - trueVal = maxval; - falseVal = 0; - break; - case THRESH_TOZERO: -#if IMPL_OPENVX_TOZERO - trueVal = 255; - falseVal = 0; - if (dst.data == src.data) - { - a = Mat(src.size(), src.type()); - src.copyTo(a); - } - break; -#endif - case THRESH_BINARY_INV: -#ifdef VX_VERSION_1_1 - trueVal = 0; - falseVal = maxval; - break; -#endif - case THRESH_TOZERO_INV: -#ifdef VX_VERSION_1_1 -#if IMPL_OPENVX_TOZERO - trueVal = 0; - falseVal = 255; - if (dst.data == src.data) - { - a = Mat(src.size(), src.type()); - src.copyTo(a); - } - break; -#endif -#endif - case THRESH_TRUNC: - default: - return false; - } - - try - { - ivx::Context ctx = ovx::getOpenVXContext(); - - ivx::Threshold thh = ivx::Threshold::createBinary(ctx, VX_TYPE_UINT8, thresh); - thh.setValueTrue(trueVal); - thh.setValueFalse(falseVal); - - ivx::Image - ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(a.cols*a.channels(), a.rows, 1, (vx_int32)(a.step)), src.data), - ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols*dst.channels(), dst.rows, 1, (vx_int32)(dst.step)), dst.data); - - ivx::IVX_CHECK_STATUS(vxuThreshold(ctx, ia, thh, ib)); -#if IMPL_OPENVX_TOZERO - if (type == THRESH_TOZERO || type == THRESH_TOZERO_INV) - { - ivx::Image - ic = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8, - ivx::Image::createAddressing(dst.cols*dst.channels(), dst.rows, 1, (vx_int32)(dst.step)), dst.data); - ivx::IVX_CHECK_STATUS(vxuAnd(ctx, ib, ia, ic)); - } -#endif - } - catch (const ivx::RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const ivx::WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; -} -#endif - } double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double maxval, int type ) @@ -1590,8 +1496,6 @@ double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double m return thresh; } - CV_OVX_RUN(!ovx::skipSmallImages(src.cols, src.rows), - openvx_threshold(src, dst, ithresh, imaxval, type), (double)ithresh) thresh = ithresh; maxval = imaxval; diff --git a/modules/imgproc/test/test_canny.cpp b/modules/imgproc/test/test_canny.cpp index be46efe7b9..806a6f3cbd 100644 --- a/modules/imgproc/test/test_canny.cpp +++ b/modules/imgproc/test/test_canny.cpp @@ -316,108 +316,5 @@ int CV_CannyTest::validate_test_results( int test_case_idx ) TEST(Imgproc_Canny, accuracy) { CV_CannyTest test; test.safe_run(); } TEST(Imgproc_Canny, accuracy_deriv) { CV_CannyTest test(true); test.safe_run(); } - -/* - * Comparing OpenVX based implementation with the main one -*/ - -#ifndef IMPLEMENT_PARAM_CLASS -#define IMPLEMENT_PARAM_CLASS(name, type) \ - class name \ - { \ - public: \ - name ( type arg = type ()) : val_(arg) {} \ - operator type () const {return val_;} \ - private: \ - type val_; \ - }; \ - inline void PrintTo( name param, std::ostream* os) \ - { \ - *os << #name << "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \ - } -#endif // IMPLEMENT_PARAM_CLASS - -IMPLEMENT_PARAM_CLASS(ImagePath, string) -IMPLEMENT_PARAM_CLASS(ApertureSize, int) -IMPLEMENT_PARAM_CLASS(L2gradient, bool) - -PARAM_TEST_CASE(CannyVX, ImagePath, ApertureSize, L2gradient) -{ - string imgPath; - int kSize; - bool useL2; - Mat src, dst; - - virtual void SetUp() - { - imgPath = GET_PARAM(0); - kSize = GET_PARAM(1); - useL2 = GET_PARAM(2); - } - - void loadImage() - { - src = cv::imread(cvtest::TS::ptr()->get_data_path() + imgPath, IMREAD_GRAYSCALE); - ASSERT_FALSE(src.empty()) << "can't load image: " << imgPath; - } -}; - -TEST_P(CannyVX, Accuracy) -{ - if(haveOpenVX()) - { - loadImage(); - - setUseOpenVX(false); - Mat canny; - cv::Canny(src, canny, 100, 150, 3); - - setUseOpenVX(true); - Mat cannyVX; - cv::Canny(src, cannyVX, 100, 150, 3); - - // 'smart' diff check (excluding isolated pixels) - Mat diff, diff1; - absdiff(canny, cannyVX, diff); - boxFilter(diff, diff1, -1, Size(3,3)); - const int minPixelsAroud = 3; // empirical number - diff1 = diff1 > 255/9 * minPixelsAroud; - erode(diff1, diff1, Mat()); - double error = cv::norm(diff1, NORM_L1) / 255; - const int maxError = std::min(10, diff.size().area()/100); // empirical number - if(error > maxError) - { - string outPath = - string("CannyVX-diff-") + - imgPath + '-' + - 'k' + char(kSize+'0') + '-' + - (useL2 ? "l2" : "l1"); - std::replace(outPath.begin(), outPath.end(), '/', '_'); - std::replace(outPath.begin(), outPath.end(), '\\', '_'); - std::replace(outPath.begin(), outPath.end(), '.', '_'); - imwrite(outPath+".png", diff); - } - ASSERT_LE(error, maxError); - - } -} - - INSTANTIATE_TEST_CASE_P( - ImgProc, CannyVX, - testing::Combine( - testing::Values( - string("shared/baboon.png"), - string("shared/fruits.png"), - string("shared/lena.png"), - string("shared/pic1.png"), - string("shared/pic3.png"), - string("shared/pic5.png"), - string("shared/pic6.png") - ), - testing::Values(ApertureSize(3), ApertureSize(5)), - testing::Values(L2gradient(false), L2gradient(true)) - ) - ); - }} // namespace /* End of file. */ diff --git a/modules/video/src/lkpyramid.cpp b/modules/video/src/lkpyramid.cpp index d27c4481ae..662ac13235 100644 --- a/modules/video/src/lkpyramid.cpp +++ b/modules/video/src/lkpyramid.cpp @@ -49,8 +49,6 @@ #include "opencv2/3d.hpp" #endif -#include "opencv2/core/openvx/ovx_defs.hpp" - #define CV_DESCALE(x,n) (((x) + (1 << ((n)-1))) >> (n)) namespace @@ -1084,154 +1082,6 @@ namespace } #endif -#ifdef HAVE_OPENVX - bool openvx_pyrlk(InputArray _prevImg, InputArray _nextImg, InputArray _prevPts, InputOutputArray _nextPts, - OutputArray _status, OutputArray _err) - { - using namespace ivx; - - // Pyramids as inputs are not acceptable because there's no (direct or simple) way - // to build vx_pyramid on user data - if(_prevImg.kind() != _InputArray::MAT || _nextImg.kind() != _InputArray::MAT) - return false; - - Mat prevImgMat = _prevImg.getMat(), nextImgMat = _nextImg.getMat(); - - if(prevImgMat.type() != CV_8UC1 || nextImgMat.type() != CV_8UC1) - return false; - - if (ovx::skipSmallImages(prevImgMat.cols, prevImgMat.rows)) - return false; - - CV_Assert(prevImgMat.size() == nextImgMat.size()); - Mat prevPtsMat = _prevPts.getMat(); - int checkPrev = prevPtsMat.checkVector(2, CV_32F, false); - CV_Assert( checkPrev >= 0 ); - size_t npoints = checkPrev; - - if( !(flags & OPTFLOW_USE_INITIAL_FLOW) ) - _nextPts.create(prevPtsMat.size(), prevPtsMat.type(), -1, true); - Mat nextPtsMat = _nextPts.getMat(); - CV_Assert( nextPtsMat.checkVector(2, CV_32F, false) == (int)npoints ); - - _status.create((int)npoints, 1, CV_8U, -1, true); - Mat statusMat = _status.getMat(); - uchar* status = statusMat.ptr(); - for(size_t i = 0; i < npoints; i++ ) - status[i] = true; - - // OpenVX doesn't return detection errors - if( _err.needed() ) - { - return false; - } - - try - { - Context context = ovx::getOpenVXContext(); - - if(context.vendorID() == VX_ID_KHRONOS) - { - // PyrLK in OVX 1.0.1 performs vxCommitImagePatch incorrecty and crashes - if(VX_VERSION == VX_VERSION_1_0) - return false; - // Implementation ignores border mode - // So check that minimal size of image in pyramid is big enough - int width = prevImgMat.cols, height = prevImgMat.rows; - for(int i = 0; i < maxLevel+1; i++) - { - if(width < winSize.width + 1 || height < winSize.height + 1) - return false; - else - { - width /= 2; height /= 2; - } - } - } - - Image prevImg = Image::createFromHandle(context, Image::matTypeToFormat(prevImgMat.type()), - Image::createAddressing(prevImgMat), (void*)prevImgMat.data); - Image nextImg = Image::createFromHandle(context, Image::matTypeToFormat(nextImgMat.type()), - Image::createAddressing(nextImgMat), (void*)nextImgMat.data); - - Graph graph = Graph::create(context); - - Pyramid prevPyr = Pyramid::createVirtual(graph, (vx_size)maxLevel+1, VX_SCALE_PYRAMID_HALF, - prevImg.width(), prevImg.height(), prevImg.format()); - Pyramid nextPyr = Pyramid::createVirtual(graph, (vx_size)maxLevel+1, VX_SCALE_PYRAMID_HALF, - nextImg.width(), nextImg.height(), nextImg.format()); - - ivx::Node::create(graph, VX_KERNEL_GAUSSIAN_PYRAMID, prevImg, prevPyr); - ivx::Node::create(graph, VX_KERNEL_GAUSSIAN_PYRAMID, nextImg, nextPyr); - - Array prevPts = Array::create(context, VX_TYPE_KEYPOINT, npoints); - Array estimatedPts = Array::create(context, VX_TYPE_KEYPOINT, npoints); - Array nextPts = Array::create(context, VX_TYPE_KEYPOINT, npoints); - - std::vector vxPrevPts(npoints), vxEstPts(npoints), vxNextPts(npoints); - for(size_t i = 0; i < npoints; i++) - { - vx_keypoint_t& prevPt = vxPrevPts[i]; vx_keypoint_t& estPt = vxEstPts[i]; - prevPt.x = prevPtsMat.at(i).x; prevPt.y = prevPtsMat.at(i).y; - estPt.x = nextPtsMat.at(i).x; estPt.y = nextPtsMat.at(i).y; - prevPt.tracking_status = estPt.tracking_status = vx_true_e; - } - prevPts.addItems(vxPrevPts); estimatedPts.addItems(vxEstPts); - - if( (criteria.type & TermCriteria::COUNT) == 0 ) - criteria.maxCount = 30; - else - criteria.maxCount = std::min(std::max(criteria.maxCount, 0), 100); - if( (criteria.type & TermCriteria::EPS) == 0 ) - criteria.epsilon = 0.01; - else - criteria.epsilon = std::min(std::max(criteria.epsilon, 0.), 10.); - criteria.epsilon *= criteria.epsilon; - - vx_enum termEnum = (criteria.type == TermCriteria::COUNT) ? VX_TERM_CRITERIA_ITERATIONS : - (criteria.type == TermCriteria::EPS) ? VX_TERM_CRITERIA_EPSILON : - VX_TERM_CRITERIA_BOTH; - - //minEigThreshold is fixed to 0.0001f - ivx::Scalar termination = ivx::Scalar::create(context, termEnum); - ivx::Scalar epsilon = ivx::Scalar::create(context, criteria.epsilon); - ivx::Scalar numIterations = ivx::Scalar::create(context, criteria.maxCount); - ivx::Scalar useInitial = ivx::Scalar::create(context, (vx_bool)(flags & OPTFLOW_USE_INITIAL_FLOW)); - //assume winSize is square - ivx::Scalar windowSize = ivx::Scalar::create(context, (vx_size)winSize.width); - - ivx::Node::create(graph, VX_KERNEL_OPTICAL_FLOW_PYR_LK, prevPyr, nextPyr, prevPts, estimatedPts, - nextPts, termination, epsilon, numIterations, useInitial, windowSize); - - graph.verify(); - graph.process(); - - nextPts.copyTo(vxNextPts); - for(size_t i = 0; i < npoints; i++) - { - vx_keypoint_t kp = vxNextPts[i]; - nextPtsMat.at(i) = Point2f(kp.x, kp.y); - statusMat.at(i) = (bool)kp.tracking_status; - } - -#ifdef VX_VERSION_1_1 - //we should take user memory back before release - //(it's not done automatically according to standard) - prevImg.swapHandle(); nextImg.swapHandle(); -#endif - } - catch (const RuntimeError & e) - { - VX_DbgThrow(e.what()); - } - catch (const WrapperError & e) - { - VX_DbgThrow(e.what()); - } - - return true; - } -#endif }; @@ -1247,10 +1097,6 @@ void SparsePyrLKOpticalFlowImpl::calc( InputArray _prevImg, InputArray _nextImg, ocl::Image2D::isFormatSupported(CV_32F, 1, false), ocl_calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err)) - // Disabled due to bad accuracy - CV_OVX_RUN(false, - openvx_pyrlk(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err)) - Mat prevPtsMat = _prevPts.getMat(); const int derivDepth = DataType::depth; diff --git a/platforms/js/build_js.py b/platforms/js/build_js.py index 3a8bf725d1..1634a3bea6 100755 --- a/platforms/js/build_js.py +++ b/platforms/js/build_js.py @@ -103,7 +103,6 @@ class Builder: "-DWITH_WEBP=OFF", "-DWITH_OPENEXR=OFF", "-DWITH_OPENGL=OFF", - "-DWITH_OPENVX=OFF", "-DWITH_OPENNI=OFF", "-DWITH_OPENNI2=OFF", "-DWITH_PNG=OFF", diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt index 6a18b61afa..355a252185 100644 --- a/samples/CMakeLists.txt +++ b/samples/CMakeLists.txt @@ -33,9 +33,6 @@ endif() if((NOT ANDROID) AND HAVE_OPENGL) add_subdirectory(opengl) endif() -if(HAVE_OPENVX) - add_subdirectory(openvx) -endif() if(UNIX AND NOT ANDROID AND HAVE_VA) add_subdirectory(va_intel) endif() @@ -131,7 +128,6 @@ add_subdirectory(dnn) add_subdirectory(opencl) add_subdirectory(sycl) # add_subdirectory(opengl) -# add_subdirectory(openvx) add_subdirectory(tapi) # add_subdirectory(va_intel) diff --git a/samples/openvx/CMakeLists.txt b/samples/openvx/CMakeLists.txt deleted file mode 100644 index fd04e6b9e2..0000000000 --- a/samples/openvx/CMakeLists.txt +++ /dev/null @@ -1,25 +0,0 @@ -ocv_install_example_src(cpp *.cpp *.hpp CMakeLists.txt) - -cmake_minimum_required(VERSION 2.8.12.2) - -set(OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS - opencv_core - opencv_imgproc - opencv_imgcodecs - opencv_videoio - opencv_highgui) -ocv_check_dependencies(${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS}) - -if(NOT BUILD_EXAMPLES OR NOT OCV_DEPENDENCIES_FOUND) - return() -endif() - -project(openvx_samples) -ocv_include_modules_recurse(${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS}) -add_definitions(-DIVX_USE_OPENCV) -add_definitions(-DIVX_HIDE_INFO_WARNINGS) -file(GLOB_RECURSE cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp) -foreach(sample_filename ${cpp_samples}) - ocv_define_sample(tgt ${sample_filename} openvx) - ocv_target_link_libraries(${tgt} PRIVATE ${OPENCV_LINKER_LIBS} ${OPENCV_OPENVX_SAMPLE_REQUIRED_DEPS}) -endforeach() diff --git a/samples/openvx/no_wrappers.cpp b/samples/openvx/no_wrappers.cpp deleted file mode 100644 index 7809f7b9ca..0000000000 --- a/samples/openvx/no_wrappers.cpp +++ /dev/null @@ -1,385 +0,0 @@ -#include -#include - -//OpenVX includes -#include - -//OpenCV includes -#include "opencv2/core.hpp" -#include "opencv2/imgproc.hpp" -#include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui.hpp" - -#ifndef VX_VERSION_1_1 -const vx_enum VX_IMAGE_FORMAT = VX_IMAGE_ATTRIBUTE_FORMAT; -const vx_enum VX_IMAGE_WIDTH = VX_IMAGE_ATTRIBUTE_WIDTH; -const vx_enum VX_IMAGE_HEIGHT = VX_IMAGE_ATTRIBUTE_HEIGHT; -const vx_enum VX_MEMORY_TYPE_HOST = VX_IMPORT_TYPE_HOST; -const vx_enum VX_MEMORY_TYPE_NONE = VX_IMPORT_TYPE_NONE; -const vx_enum VX_THRESHOLD_THRESHOLD_VALUE = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_VALUE; -const vx_enum VX_THRESHOLD_THRESHOLD_LOWER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_LOWER; -const vx_enum VX_THRESHOLD_THRESHOLD_UPPER = VX_THRESHOLD_ATTRIBUTE_THRESHOLD_UPPER; -typedef uintptr_t vx_map_id; -#endif - -enum UserMemoryMode -{ - COPY, USER_MEM -}; - -vx_image convertCvMatToVxImage(vx_context context, cv::Mat image, bool toCopy); -cv::Mat copyVxImageToCvMat(vx_image ovxImage); -void swapVxImage(vx_image ovxImage); -vx_status createProcessingGraph(vx_image inputImage, vx_image outputImage, vx_graph& graph); -int ovxDemo(std::string inputPath, UserMemoryMode mode); - - -vx_image convertCvMatToVxImage(vx_context context, cv::Mat image, bool toCopy) -{ - if (!(!image.empty() && image.dims <= 2 && image.channels() == 1)) - throw std::runtime_error("Invalid format"); - - vx_uint32 width = image.cols; - vx_uint32 height = image.rows; - - vx_df_image color; - switch (image.depth()) - { - case CV_8U: - color = VX_DF_IMAGE_U8; - break; - case CV_16U: - color = VX_DF_IMAGE_U16; - break; - case CV_16S: - color = VX_DF_IMAGE_S16; - break; - case CV_32S: - color = VX_DF_IMAGE_S32; - break; - default: - throw std::runtime_error("Invalid format"); - break; - } - - vx_imagepatch_addressing_t addr; - addr.dim_x = width; - addr.dim_y = height; - addr.stride_x = (vx_uint32)image.elemSize(); - addr.stride_y = (vx_uint32)image.step.p[0]; - vx_uint8* ovxData = image.data; - - vx_image ovxImage; - if (toCopy) - { - ovxImage = vxCreateImage(context, width, height, color); - if (vxGetStatus((vx_reference)ovxImage) != VX_SUCCESS) - throw std::runtime_error("Failed to create image"); - vx_rectangle_t rect; - - vx_status status = vxGetValidRegionImage(ovxImage, &rect); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to get valid region"); - -#ifdef VX_VERSION_1_1 - status = vxCopyImagePatch(ovxImage, &rect, 0, &addr, ovxData, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to copy image patch"); -#else - status = vxAccessImagePatch(ovxImage, &rect, 0, &addr, (void**)&ovxData, VX_WRITE_ONLY); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to access image patch"); - status = vxCommitImagePatch(ovxImage, &rect, 0, &addr, ovxData); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to commit image patch"); -#endif - } - else - { - ovxImage = vxCreateImageFromHandle(context, color, &addr, (void**)&ovxData, VX_MEMORY_TYPE_HOST); - if (vxGetStatus((vx_reference)ovxImage) != VX_SUCCESS) - throw std::runtime_error("Failed to create image from handle"); - } - - return ovxImage; -} - - -cv::Mat copyVxImageToCvMat(vx_image ovxImage) -{ - vx_status status; - vx_df_image df_image = 0; - vx_uint32 width, height; - status = vxQueryImage(ovxImage, VX_IMAGE_FORMAT, &df_image, sizeof(vx_df_image)); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to query image"); - status = vxQueryImage(ovxImage, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32)); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to query image"); - status = vxQueryImage(ovxImage, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32)); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to query image"); - - if (!(width > 0 && height > 0)) throw std::runtime_error("Invalid format"); - - int depth; - switch (df_image) - { - case VX_DF_IMAGE_U8: - depth = CV_8U; - break; - case VX_DF_IMAGE_U16: - depth = CV_16U; - break; - case VX_DF_IMAGE_S16: - depth = CV_16S; - break; - case VX_DF_IMAGE_S32: - depth = CV_32S; - break; - default: - throw std::runtime_error("Invalid format"); - break; - } - - cv::Mat image(height, width, CV_MAKE_TYPE(depth, 1)); - - vx_rectangle_t rect; - rect.start_x = rect.start_y = 0; - rect.end_x = width; rect.end_y = height; - - vx_imagepatch_addressing_t addr; - addr.dim_x = width; - addr.dim_y = height; - addr.stride_x = (vx_uint32)image.elemSize(); - addr.stride_y = (vx_uint32)image.step.p[0]; - vx_uint8* matData = image.data; - -#ifdef VX_VERSION_1_1 - status = vxCopyImagePatch(ovxImage, &rect, 0, &addr, matData, VX_READ_ONLY, VX_MEMORY_TYPE_HOST); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to copy image patch"); -#else - status = vxAccessImagePatch(ovxImage, &rect, 0, &addr, (void**)&matData, VX_READ_ONLY); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to access image patch"); - status = vxCommitImagePatch(ovxImage, &rect, 0, &addr, matData); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to commit image patch"); -#endif - - return image; -} - - -void swapVxImage(vx_image ovxImage) -{ -#ifdef VX_VERSION_1_1 - vx_status status; - vx_memory_type_e memType; - status = vxQueryImage(ovxImage, VX_IMAGE_MEMORY_TYPE, &memType, sizeof(vx_memory_type_e)); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to query image"); - if (memType == VX_MEMORY_TYPE_NONE) - { - //was created by copying user data - throw std::runtime_error("Image wasn't created from user handle"); - } - else - { - //was created from user handle - status = vxSwapImageHandle(ovxImage, NULL, NULL, 0); - if (status != VX_SUCCESS) - throw std::runtime_error("Failed to swap image handle"); - } -#else - //not supported until OpenVX 1.1 - (void) ovxImage; -#endif -} - - -vx_status createProcessingGraph(vx_image inputImage, vx_image outputImage, vx_graph& graph) -{ - vx_status status; - vx_context context = vxGetContext((vx_reference)inputImage); - status = vxGetStatus((vx_reference)context); - if(status != VX_SUCCESS) return status; - - graph = vxCreateGraph(context); - status = vxGetStatus((vx_reference)graph); - if (status != VX_SUCCESS) return status; - - vx_uint32 width, height; - status = vxQueryImage(inputImage, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32)); - if (status != VX_SUCCESS) return status; - status = vxQueryImage(inputImage, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32)); - if (status != VX_SUCCESS) return status; - - // Intermediate images - vx_image - smoothed = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT), - cannied = vxCreateVirtualImage(graph, 0, 0, VX_DF_IMAGE_VIRT), - halfImg = vxCreateImage(context, width, height, VX_DF_IMAGE_U8), - halfCanny = vxCreateImage(context, width, height, VX_DF_IMAGE_U8); - - vx_image virtualImages[] = {smoothed, cannied, halfImg, halfCanny}; - for(size_t i = 0; i < sizeof(virtualImages)/sizeof(vx_image); i++) - { - status = vxGetStatus((vx_reference)virtualImages[i]); - if (status != VX_SUCCESS) return status; - } - - // Constants - vx_uint32 threshValue = 50; - vx_threshold thresh = vxCreateThreshold(context, VX_THRESHOLD_TYPE_BINARY, VX_TYPE_UINT8); - vxSetThresholdAttribute(thresh, VX_THRESHOLD_THRESHOLD_VALUE, - &threshValue, sizeof(threshValue)); - - vx_uint32 threshCannyMin = 127; - vx_uint32 threshCannyMax = 192; - vx_threshold threshCanny = vxCreateThreshold(context, VX_THRESHOLD_TYPE_RANGE, VX_TYPE_UINT8); - vxSetThresholdAttribute(threshCanny, VX_THRESHOLD_THRESHOLD_LOWER, &threshCannyMin, - sizeof(threshCannyMin)); - vxSetThresholdAttribute(threshCanny, VX_THRESHOLD_THRESHOLD_UPPER, &threshCannyMax, - sizeof(threshCannyMax)); - vx_float32 alphaValue = 0.5; - vx_scalar alpha = vxCreateScalar(context, VX_TYPE_FLOAT32, &alphaValue); - - // Sequence of meaningless image operations - vx_node nodes[] = { - vxGaussian3x3Node(graph, inputImage, smoothed), - vxCannyEdgeDetectorNode(graph, smoothed, threshCanny, 3, VX_NORM_L2, cannied), - vxAccumulateWeightedImageNode(graph, inputImage, alpha, halfImg), - vxAccumulateWeightedImageNode(graph, cannied, alpha, halfCanny), - vxAddNode(graph, halfImg, halfCanny, VX_CONVERT_POLICY_SATURATE, outputImage) - }; - - for (size_t i = 0; i < sizeof(nodes) / sizeof(vx_node); i++) - { - status = vxGetStatus((vx_reference)nodes[i]); - if (status != VX_SUCCESS) return status; - } - - status = vxVerifyGraph(graph); - return status; -} - - -int ovxDemo(std::string inputPath, UserMemoryMode mode) -{ - cv::Mat image = cv::imread(inputPath, cv::IMREAD_GRAYSCALE); - if (image.empty()) return -1; - - //check image format - if (image.depth() != CV_8U || image.channels() != 1) return -1; - - vx_status status; - vx_context context = vxCreateContext(); - status = vxGetStatus((vx_reference)context); - if (status != VX_SUCCESS) return status; - - //put user data from cv::Mat to vx_image - vx_image ovxImage; - ovxImage = convertCvMatToVxImage(context, image, mode == COPY); - - vx_uint32 width = image.cols, height = image.rows; - - vx_image ovxResult; - cv::Mat output; - if (mode == COPY) - { - //we will copy data from vx_image to cv::Mat - ovxResult = vxCreateImage(context, width, height, VX_DF_IMAGE_U8); - if (vxGetStatus((vx_reference)ovxResult) != VX_SUCCESS) - throw std::runtime_error("Failed to create image"); - } - else - { - //create vx_image based on user data, no copying required - output = cv::Mat(height, width, CV_8U, cv::Scalar(0)); - ovxResult = convertCvMatToVxImage(context, output, false); - } - - vx_graph graph; - status = createProcessingGraph(ovxImage, ovxResult, graph); - if (status != VX_SUCCESS) return status; - - // Graph execution - status = vxProcessGraph(graph); - if (status != VX_SUCCESS) return status; - - //getting resulting image in cv::Mat - if (mode == COPY) - { - output = copyVxImageToCvMat(ovxResult); - } - else - { - //we should take user memory back from vx_image before using it (even before reading) - swapVxImage(ovxResult); - } - - //here output goes - cv::imshow("processing result", output); - cv::waitKey(0); - - //we need to take user memory back before releasing the image - if (mode == USER_MEM) - swapVxImage(ovxImage); - - cv::destroyAllWindows(); - - status = vxReleaseContext(&context); - return status; -} - - -int main(int argc, char *argv[]) -{ - const std::string keys = - "{help h usage ? | | }" - "{image | | image to be processed}" - "{mode | copy | user memory interaction mode: \n" - "copy: create VX images and copy data to/from them\n" - "user_mem: use handles to user-allocated memory}" - ; - - cv::CommandLineParser parser(argc, argv, keys); - parser.about("OpenVX interoperability sample demonstrating standard OpenVX API." - "The application loads an image, processes it with OpenVX graph and outputs result in a window"); - if (parser.has("help")) - { - parser.printMessage(); - return 0; - } - std::string imgPath = parser.get("image"); - std::string modeString = parser.get("mode"); - UserMemoryMode mode; - if(modeString == "copy") - { - mode = COPY; - } - else if(modeString == "user_mem") - { - mode = USER_MEM; - } - else if(modeString == "map") - { - std::cerr << modeString << " is not implemented in this sample" << std::endl; - return -1; - } - else - { - std::cerr << modeString << ": unknown memory mode" << std::endl; - return -1; - } - - if (!parser.check()) - { - parser.printErrors(); - return -1; - } - - return ovxDemo(imgPath, mode); -} diff --git a/samples/openvx/wrappers.cpp b/samples/openvx/wrappers.cpp deleted file mode 100644 index b591862c10..0000000000 --- a/samples/openvx/wrappers.cpp +++ /dev/null @@ -1,214 +0,0 @@ -#include -#include - -//wrappers -#include "ivx.hpp" - -//OpenCV includes -#include "opencv2/core.hpp" -#include "opencv2/imgproc.hpp" -#include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui.hpp" - -enum UserMemoryMode -{ - COPY, USER_MEM, MAP -}; - -ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage); -int ovxDemo(std::string inputPath, UserMemoryMode mode); - - -ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage) -{ - using namespace ivx; - - Context context = inputImage.get(); - Graph graph = Graph::create(context); - - vx_uint32 width = inputImage.width(); - vx_uint32 height = inputImage.height(); - - // Intermediate images - Image - smoothed = Image::createVirtual(graph), - cannied = Image::createVirtual(graph), - halfImg = Image::create(context, width, height, VX_DF_IMAGE_U8), - halfCanny = Image::create(context, width, height, VX_DF_IMAGE_U8); - - // Constants - vx_uint32 threshCannyMin = 127; - vx_uint32 threshCannyMax = 192; - Threshold threshCanny = Threshold::createRange(context, VX_TYPE_UINT8, threshCannyMin, threshCannyMax); - - ivx::Scalar alpha = ivx::Scalar::create(context, 0.5); - - // Sequence of some image operations - // Node can also be added in function-like style - nodes::gaussian3x3(graph, inputImage, smoothed); - Node::create(graph, VX_KERNEL_CANNY_EDGE_DETECTOR, smoothed, threshCanny, - ivx::Scalar::create(context, 3), - ivx::Scalar::create(context, VX_NORM_L2), cannied); - Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, inputImage, alpha, halfImg); - Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, cannied, alpha, halfCanny); - Node::create(graph, VX_KERNEL_ADD, halfImg, halfCanny, - ivx::Scalar::create(context, VX_CONVERT_POLICY_SATURATE), outputImage); - - graph.verify(); - - return graph; -} - - -int ovxDemo(std::string inputPath, UserMemoryMode mode) -{ - using namespace cv; - using namespace ivx; - - Mat image = imread(inputPath, IMREAD_GRAYSCALE); - if (image.empty()) return -1; - - //check image format - if (image.depth() != CV_8U || image.channels() != 1) return -1; - - try - { - Context context = Context::create(); - //put user data from cv::Mat to vx_image - vx_df_image color = Image::matTypeToFormat(image.type()); - vx_uint32 width = image.cols, height = image.rows; - Image ivxImage; - if (mode == COPY) - { - ivxImage = Image::create(context, width, height, color); - ivxImage.copyFrom(0, image); - } - else - { - ivxImage = Image::createFromHandle(context, color, Image::createAddressing(image), image.data); - } - - Image ivxResult; - Image::Patch resultPatch; - Mat output; - if (mode == COPY || mode == MAP) - { - //we will copy or map data from vx_image to cv::Mat - ivxResult = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8); - } - else // if (mode == MAP_TO_VX) - { - //create vx_image based on user data, no copying required - output = cv::Mat(height, width, CV_8U, cv::Scalar(0)); - ivxResult = Image::createFromHandle(context, Image::matTypeToFormat(CV_8U), - Image::createAddressing(output), output.data); - } - - Graph graph = createProcessingGraph(ivxImage, ivxResult); - - // Graph execution - graph.process(); - - //getting resulting image in cv::Mat - if (mode == COPY) - { - ivxResult.copyTo(0, output); - } - else if (mode == MAP) - { - //create cv::Mat based on vx_image mapped data - resultPatch.map(ivxResult, 0, ivxResult.getValidRegion()); - //generally this is very bad idea! - //but in our case unmap() won't happen until output is in use - output = resultPatch.getMat(); - } - else // if (mode == MAP_TO_VX) - { -#ifdef VX_VERSION_1_1 - //we should take user memory back from vx_image before using it (even before reading) - ivxResult.swapHandle(); -#endif - } - - //here output goes - cv::imshow("processing result", output); - cv::waitKey(0); - - cv::destroyAllWindows(); - -#ifdef VX_VERSION_1_1 - if (mode != COPY) - { - //we should take user memory back before release - //(it's not done automatically according to standard) - ivxImage.swapHandle(); - if (mode == USER_MEM) ivxResult.swapHandle(); - } -#endif - - //the line is unnecessary since unmapping is done on destruction of patch - //resultPatch.unmap(); - } - catch (const ivx::RuntimeError& e) - { - std::cerr << "Error: code = " << e.status() << ", message = " << e.what() << std::endl; - return e.status(); - } - catch (const ivx::WrapperError& e) - { - std::cerr << "Error: message = " << e.what() << std::endl; - return -1; - } - - return 0; -} - - -int main(int argc, char *argv[]) -{ - const std::string keys = - "{help h usage ? | | }" - "{image | | image to be processed}" - "{mode | copy | user memory interaction mode: \n" - "copy: create VX images and copy data to/from them\n" - "user_mem: use handles to user-allocated memory\n" - "map: map resulting VX image to user memory}" - ; - - cv::CommandLineParser parser(argc, argv, keys); - parser.about("OpenVX interoperability sample demonstrating OpenVX wrappers usage." - "The application loads an image, processes it with OpenVX graph and outputs result in a window"); - if (parser.has("help")) - { - parser.printMessage(); - return 0; - } - std::string imgPath = parser.get("image"); - std::string modeString = parser.get("mode"); - UserMemoryMode mode; - if(modeString == "copy") - { - mode = COPY; - } - else if(modeString == "user_mem") - { - mode = USER_MEM; - } - else if(modeString == "map") - { - mode = MAP; - } - else - { - std::cerr << modeString << ": unknown memory mode" << std::endl; - return -1; - } - - if (!parser.check()) - { - parser.printErrors(); - return -1; - } - - return ovxDemo(imgPath, mode); -} diff --git a/samples/openvx/wrappers_video.cpp b/samples/openvx/wrappers_video.cpp deleted file mode 100644 index 737f052b85..0000000000 --- a/samples/openvx/wrappers_video.cpp +++ /dev/null @@ -1,250 +0,0 @@ -#include -#include - -//wrappers -#include "ivx.hpp" - -//OpenCV includes -#include "opencv2/core.hpp" -#include "opencv2/imgproc.hpp" -#include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui.hpp" - -enum UserMemoryMode -{ - COPY, USER_MEM, MAP -}; - -ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage); -int ovxDemo(std::string inputPath, UserMemoryMode mode); - - -ivx::Graph createProcessingGraph(ivx::Image& inputImage, ivx::Image& outputImage) -{ - using namespace ivx; - - Context context = inputImage.get(); - Graph graph = Graph::create(context); - - vx_uint32 width = inputImage.width(); - vx_uint32 height = inputImage.height(); - - // Intermediate images - Image - yuv = Image::createVirtual(graph, 0, 0, VX_DF_IMAGE_YUV4), - gray = Image::createVirtual(graph), - smoothed = Image::createVirtual(graph), - cannied = Image::createVirtual(graph), - halfImg = Image::create(context, width, height, VX_DF_IMAGE_U8), - halfCanny = Image::create(context, width, height, VX_DF_IMAGE_U8); - - // Constants - vx_uint32 threshCannyMin = 127; - vx_uint32 threshCannyMax = 192; - Threshold threshCanny = Threshold::createRange(context, VX_TYPE_UINT8, threshCannyMin, threshCannyMax); - - ivx::Scalar alpha = ivx::Scalar::create(context, 0.5); - - // Sequence of some image operations - Node::create(graph, VX_KERNEL_COLOR_CONVERT, inputImage, yuv); - Node::create(graph, VX_KERNEL_CHANNEL_EXTRACT, yuv, - ivx::Scalar::create(context, VX_CHANNEL_Y), gray); - //node can also be added in function-like style - nodes::gaussian3x3(graph, gray, smoothed); - Node::create(graph, VX_KERNEL_CANNY_EDGE_DETECTOR, smoothed, threshCanny, - ivx::Scalar::create(context, 3), - ivx::Scalar::create(context, VX_NORM_L2), cannied); - Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, gray, alpha, halfImg); - Node::create(graph, VX_KERNEL_ACCUMULATE_WEIGHTED, cannied, alpha, halfCanny); - Node::create(graph, VX_KERNEL_ADD, halfImg, halfCanny, - ivx::Scalar::create(context, VX_CONVERT_POLICY_SATURATE), outputImage); - - graph.verify(); - - return graph; -} - - -int ovxDemo(std::string inputPath, UserMemoryMode mode) -{ - using namespace cv; - using namespace ivx; - - Mat frame; - VideoCapture vc(inputPath); - if (!vc.isOpened()) - return -1; - - vc >> frame; - if (frame.empty()) return -1; - - //check frame format - if (frame.type() != CV_8UC3) return -1; - - try - { - Context context = Context::create(); - //put user data from cv::Mat to vx_image - vx_df_image color = Image::matTypeToFormat(frame.type()); - vx_uint32 width = frame.cols, height = frame.rows; - Image ivxImage; - if (mode == COPY) - { - ivxImage = Image::create(context, width, height, color); - } - else - { - ivxImage = Image::createFromHandle(context, color, Image::createAddressing(frame), frame.data); - } - - Image ivxResult; - - Mat output; - if (mode == COPY || mode == MAP) - { - //we will copy or map data from vx_image to cv::Mat - ivxResult = ivx::Image::create(context, width, height, VX_DF_IMAGE_U8); - } - else // if (mode == MAP_TO_VX) - { - //create vx_image based on user data, no copying required - output = cv::Mat(height, width, CV_8U, cv::Scalar(0)); - ivxResult = Image::createFromHandle(context, Image::matTypeToFormat(CV_8U), - Image::createAddressing(output), output.data); - } - - Graph graph = createProcessingGraph(ivxImage, ivxResult); - - bool stop = false; - while (!stop) - { - if (mode == COPY) ivxImage.copyFrom(0, frame); - - // Graph execution - graph.process(); - - //getting resulting image in cv::Mat - Image::Patch resultPatch; - std::vector ptrs; - std::vector prevPtrs(ivxResult.planes()); - if (mode == COPY) - { - ivxResult.copyTo(0, output); - } - else if (mode == MAP) - { - //create cv::Mat based on vx_image mapped data - resultPatch.map(ivxResult, 0, ivxResult.getValidRegion(), VX_READ_AND_WRITE); - //generally this is very bad idea! - //but in our case unmap() won't happen until output is in use - output = resultPatch.getMat(); - } - else // if(mode == MAP_TO_VX) - { -#ifdef VX_VERSION_1_1 - //we should take user memory back from vx_image before using it (even before reading) - ivxResult.swapHandle(ptrs, prevPtrs); -#endif - } - - //here output goes - imshow("press q to quit", output); - if ((char)waitKey(1) == 'q') stop = true; - -#ifdef VX_VERSION_1_1 - //restore handle - if (mode == USER_MEM) - { - ivxResult.swapHandle(prevPtrs, ptrs); - } -#endif - - //this line is unnecessary since unmapping is done on destruction of patch - //resultPatch.unmap(); - - //grab next frame - Mat temp = frame; - vc >> frame; - if (frame.empty()) stop = true; - if (mode != COPY && frame.data != temp.data) - { - //frame was reallocated, pointer to data changed - frame.copyTo(temp); - } - } - - destroyAllWindows(); - -#ifdef VX_VERSION_1_1 - if (mode != COPY) - { - //we should take user memory back before release - //(it's not done automatically according to standard) - ivxImage.swapHandle(); - if (mode == USER_MEM) ivxResult.swapHandle(); - } -#endif - } - catch (const ivx::RuntimeError& e) - { - std::cerr << "Error: code = " << e.status() << ", message = " << e.what() << std::endl; - return e.status(); - } - catch (const ivx::WrapperError& e) - { - std::cerr << "Error: message = " << e.what() << std::endl; - return -1; - } - - return 0; -} - - -int main(int argc, char *argv[]) -{ - const std::string keys = - "{help h usage ? | | }" - "{video | | video file to be processed}" - "{mode | copy | user memory interaction mode: \n" - "copy: create VX images and copy data to/from them\n" - "user_mem: use handles to user-allocated memory\n" - "map: map resulting VX image to user memory}" - ; - - cv::CommandLineParser parser(argc, argv, keys); - parser.about("OpenVX interoperability sample demonstrating OpenVX wrappers usage." - "The application opens a video and processes it with OpenVX graph while outputting result in a window"); - if (parser.has("help")) - { - parser.printMessage(); - return 0; - } - std::string videoPath = parser.get("video"); - std::string modeString = parser.get("mode"); - UserMemoryMode mode; - if(modeString == "copy") - { - mode = COPY; - } - else if(modeString == "user_mem") - { - mode = USER_MEM; - } - else if(modeString == "map") - { - mode = MAP; - } - else - { - std::cerr << modeString << ": unknown memory mode" << std::endl; - return -1; - } - - if (!parser.check()) - { - parser.printErrors(); - return -1; - } - - return ovxDemo(videoPath, mode); -}