#define VX_INTERPOLATION_BILINEAR VX_INTERPOLATION_TYPE_BILINEAR
#define VX_INTERPOLATION_AREA VX_INTERPOLATION_TYPE_AREA
#define VX_INTERPOLATION_NEAREST_NEIGHBOR VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR
+#define VX_IMAGE_RANGE VX_IMAGE_ATTRIBUTE_RANGE
+#define VX_IMAGE_SPACE VX_IMAGE_ATTRIBUTE_SPACE
+#define vx_border_t vx_border_mode_t
+#define VX_BORDER_CONSTANT VX_BORDER_MODE_CONSTANT
+#define VX_BORDER_REPLICATE VX_BORDER_MODE_REPLICATE
+#define VX_CONTEXT_IMMEDIATE_BORDER VX_CONTEXT_ATTRIBUTE_IMMEDIATE_BORDER_MODE
#endif
};
template <>
+struct VX_Traits<uint>
+{
+ enum {
+ ImgType = VX_DF_IMAGE_U32,
+ DataType = VX_TYPE_UINT32
+ };
+};
+
+template <>
+struct VX_Traits<int>
+{
+ enum {
+ ImgType = VX_DF_IMAGE_S32,
+ DataType = VX_TYPE_INT32
+ };
+};
+
+template <>
struct VX_Traits<float>
{
enum {
vxImage(vxContext &ctx, int imgType, const uchar *data, size_t step, int w, int h)
{
if (h == 1)
- step = w;
+ 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);
+
vx_imagepatch_addressing_t addr[4];
void *ptrs[4];
switch (imgType)
{
mtx = vxCreateMatrix(ctx.ctx, VX_Traits<T>::DataType, w, h);
vxErr::check(mtx);
+#if VX_VERSION > VX_VERSION_1_0
vxErr::check(vxCopyMatrix(mtx, const_cast<T*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
+#else
+ vxErr::check(vxWriteMatrix(mtx, const_cast<T*>(data)));
+#endif
}
~vxMatrix()
{
}
};
-#if VX_VERSION > VX_VERSION_1_0
-
struct vxConvolution
{
vx_convolution cnv;
{
cnv = vxCreateConvolution(ctx.ctx, w, h);
vxErr::check(cnv);
+#if VX_VERSION > VX_VERSION_1_0
vxErr::check(vxCopyConvolutionCoefficients(cnv, const_cast<short*>(data), VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST));
+#else
+ vxErr::check(vxWriteConvolutionCoefficients(cnv, const_cast<short*>(data)));
+#endif
}
~vxConvolution()
{
}
};
+inline void setConstantBorder(vx_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
+}
//==================================================================================================
// real code starts here
return CV_HAL_ERROR_OK;
}
-#if VX_VERSION > VX_VERSION_1_0
-
inline 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])
{
try
switch (borderType)
{
case CV_HAL_BORDER_CONSTANT:
- border.mode = VX_BORDER_CONSTANT;
- border.constant_value.U8 = (vx_uint8)(borderValue[0]);
+ setConstantBorder(border, (vx_uint8)borderValue[0]);
break;
case CV_HAL_BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
switch (borderType)
{
case CV_HAL_BORDER_CONSTANT:
- border.mode = VX_BORDER_CONSTANT;
- border.constant_value.U8 = (vx_uint8)(borderValue[0]);
+ setConstantBorder(border, (vx_uint8)borderValue[0]);
break;
case CV_HAL_BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
switch (borderType)
{
case CV_HAL_BORDER_CONSTANT:
- border.mode = VX_BORDER_CONSTANT;
- border.constant_value.U8 = 0;
+ setConstantBorder(border, 0);
break;
case CV_HAL_BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
switch (borderType)
{
case CV_HAL_BORDER_CONSTANT:
- border.mode = VX_BORDER_CONSTANT;
- border.constant_value.U8 = 0;
+ setConstantBorder(border, 0);
break;
case CV_HAL_BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
return CV_HAL_ERROR_OK;
}
+#if VX_VERSION > VX_VERSION_1_0
+
struct MorphCtx
{
vxMatrix mask;
switch (borderType)
{
case CV_HAL_BORDER_CONSTANT:
- border.mode = VX_BORDER_CONSTANT;
if (borderValue[0] == DBL_MAX && borderValue[1] == DBL_MAX && borderValue[2] == DBL_MAX && borderValue[3] == DBL_MAX)
{
if (operation == MORPH_ERODE)
- border.constant_value.U8 = UCHAR_MAX;
+ setConstantBorder(border, UCHAR_MAX);
else
- border.constant_value.U8 = 0;
+ setConstantBorder(border, 0);
}
else
{
- int rounded = round(borderValue[0]);
- border.constant_value.U8 = (uchar)((unsigned)rounded <= UCHAR_MAX ? rounded : rounded > 0 ? UCHAR_MAX : 0);
+ 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:
vx_size maxKernelDim;
vxErr::check(vxQueryContext(ctx->ctx, VX_CONTEXT_NONLINEAR_MAX_DIMENSION, &maxKernelDim, sizeof(maxKernelDim)));
- if (kernel_width > maxKernelDim || kernel_height > maxKernelDim)
+ if ((vx_size)kernel_width > maxKernelDim || (vx_size)kernel_height > maxKernelDim)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
std::vector<uchar> kernel_mat;
inline 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 (!swapBlue || (bcn != 3 && bcn != 4) || uIdx || w / 2 != astep - w / 2)
+ 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
inline 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 (!swapBlue || (acn != 3 && acn != 4) || uIdx || w / 2 != bstep - w / 2)
+ 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
#undef cv_hal_resize
#define cv_hal_resize ovx_hal_resize
-#if VX_VERSION > VX_VERSION_1_0
-
#undef cv_hal_warpAffine
#define cv_hal_warpAffine ovx_hal_warpAffine
#undef cv_hal_warpPerspective
#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