void example_explore_parameters(vx_context context, vx_kernel kernel)
{
vx_uint32 p, numParams = 0;
vx_graph graph = vxCreateGraph(context);
vx_node node = vxCreateGenericNode(graph, kernel);
vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &numParams, sizeof(numParams));
for (p = 0; p < numParams; p++)
{
//! [Getting the ref]
vx_parameter param = vxGetParameterByIndex(node, p);
vx_reference ref;
vxQueryParameter(param, VX_PARAMETER_REF, &ref, sizeof(ref));
//! [Getting the ref]
if (ref)
{
//! [Getting the type]
vx_enum type;
vxQueryParameter(param, VX_PARAMETER_TYPE, &type, sizeof(type));
/* cast the ref to the correct vx_<type>. Atomics are now vx_scalar */
//! [Getting the type]
}
vxReleaseParameter(¶m);
}
vxReleaseNode(&node);
vxReleaseGraph(&graph);
}
static vx_status vxHistogramOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 1)
{
vx_image src = 0;
vx_parameter src_param = vxGetParameterByIndex(node, 0);
vx_parameter dst_param = vxGetParameterByIndex(node, 1);
vx_distribution dist;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
vxQueryParameter(dst_param, VX_PARAMETER_ATTRIBUTE_REF, &dist, sizeof(dist));
if ((src) && (dist))
{
vx_uint32 width = 0, height = 0;
vx_df_image format;
vx_size numBins = 0;
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_BINS, &numBins, sizeof(numBins));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
/* fill in the meta data with the attributes so that the checker will pass */
ptr->type = VX_TYPE_DISTRIBUTION;
status = VX_SUCCESS;
vxReleaseDistribution(&dist);
vxReleaseImage(&src);
}
vxReleaseParameter(&dst_param);
vxReleaseParameter(&src_param);
}
return status;
}
/************************************************************************************************************
input parameter validator.
param [in] node The handle to the node.
param [in] index The index of the parameter to validate.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_transpose_InputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8 && df_image != VX_DF_IMAGE_S16)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
else if (index == 1)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8 && df_image != VX_DF_IMAGE_S16)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
vxReleaseParameter(¶m);
return status;
}
static vx_status vxMagnitudeOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, 0);
vx_parameter param2 = vxGetParameterByIndex(node, 2);
if ((param) && (param2))
{
vx_image input = 0, output = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
vxQueryParameter(param2, VX_PARAMETER_ATTRIBUTE_REF, &output, sizeof(output));
if ((input) && (output))
{
vx_uint32 width = 0, height = 0;
vx_fourcc format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
vxQueryImage(output, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
ptr->type = VX_TYPE_IMAGE;
if (format == FOURCC_U8)
ptr->dim.image.format = FOURCC_U8;
else
ptr->dim.image.format = FOURCC_S16; /* virtual images, too */
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
}
vxReleaseParameter(¶m2);
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxNonMaxSuppressionInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0) /* magnitude */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_image img = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &img, sizeof(img));
if (img)
{
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(img, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8 || format == VX_DF_IMAGE_S16 || format == VX_DF_IMAGE_U16)
{
status = VX_SUCCESS;
}
vxReleaseImage(&img);
}
vxReleaseParameter(¶m);
}
}
if (index == 1)
{
vx_parameter params[] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 1),
};
if (params[0] && params[1])
{
vx_image images[] = {0, 0};
vxQueryParameter(params[0], VX_PARAMETER_ATTRIBUTE_REF, &images[0], sizeof(images[0]));
vxQueryParameter(params[1], VX_PARAMETER_ATTRIBUTE_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if ((format == VX_DF_IMAGE_U8) &&
(width[0] == width[1]) &&
(height[0] == height[1]))
{
status = VX_SUCCESS;
}
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶ms[0]);
vxReleaseParameter(¶ms[1]);
}
}
return status;
}
static vx_status VX_CALLBACK vxChannelExtractOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param0 = vxGetParameterByIndex(node, 0);
vx_parameter param1 = vxGetParameterByIndex(node, 1);
if ((param0) && (param1))
{
vx_image input = 0;
vx_scalar chan = 0;
vx_enum channel = 0;
vxQueryParameter(param0, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
vxQueryParameter(param1, VX_PARAMETER_ATTRIBUTE_REF, &chan, sizeof(chan));
vxReadScalarValue(chan, &channel);
if ((input) && (chan))
{
vx_uint32 width = 0, height = 0;
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (channel != VX_CHANNEL_Y)
switch (format) {
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
width /= 2;
height /= 2;
break;
case VX_DF_IMAGE_YUYV:
case VX_DF_IMAGE_UYVY:
width /= 2;
break;
}
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_U8;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&input);
vxReleaseScalar(&chan);
}
vxReleaseParameter(¶m0);
vxReleaseParameter(¶m1);
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
VX_PRINT(VX_ZONE_API, "%s:%u returned %d\n", __FUNCTION__, index, status);
return status;
}
static vx_status VX_CALLBACK vxScaleImageInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum interp = 0;
vxReadScalarValue(scalar, &interp);
if ((interp == VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR) ||
(interp == VX_INTERPOLATION_TYPE_BILINEAR) ||
(interp == VX_INTERPOLATION_TYPE_AREA))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxHalfscaleGaussianInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_INT32)
{
vx_int32 ksize = 0;
vxReadScalarValue(scalar, &ksize);
if ((ksize == 3) || (ksize == 5))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxThresholdInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_image input = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_FORMAT;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_threshold threshold = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &threshold, sizeof(threshold));
if (threshold)
{
vx_enum type = 0;
vxQueryThreshold(threshold, VX_THRESHOLD_ATTRIBUTE_TYPE, &type, sizeof(type));
if ((type == VX_THRESHOLD_TYPE_BINARY) ||
(type == VX_THRESHOLD_TYPE_RANGE))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseThreshold(&threshold);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxAccumulateInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0 )
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 1)
{
vx_image images[2];
vx_parameter param[2] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 1),
};
vxQueryParameter(param[0], VX_PARAMETER_ATTRIBUTE_REF, &images[0], sizeof(images[0]));
vxQueryParameter(param[1], VX_PARAMETER_ATTRIBUTE_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format[2];
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[0], VX_IMAGE_ATTRIBUTE_FORMAT, &format[0], sizeof(format[0]));
vxQueryImage(images[1], VX_IMAGE_ATTRIBUTE_FORMAT, &format[1], sizeof(format[1]));
if (width[0] == width[1] &&
height[0] == height[1] &&
format[0] == VX_DF_IMAGE_U8 &&
format[1] == VX_DF_IMAGE_S16)
{
status = VX_SUCCESS;
}
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
return status;
}
static vx_status VX_CALLBACK vxChannelCombineInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index < 4)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_image image = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(image));
if (image)
{
vx_df_image format = 0;
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8)
{
status = VX_SUCCESS;
}
vxReleaseImage(&image);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxTableLookupOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter src_param = vxGetParameterByIndex(node, 0);
if (src_param)
{
vx_image src = 0;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
if (src)
{
vx_uint32 width = 0, height = 0;
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
/* output is equal type and size */
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_U8;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&src);
}
vxReleaseParameter(&src_param);
}
}
return status;
}
/************************************************************************************************************
output parameter validator.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_transpose_OutputValidator(vx_node node, vx_uint32 index, vx_meta_format meta)
{
vx_status status = VX_SUCCESS;
if (index == 1)
{
vx_parameter output_param = vxGetParameterByIndex(node, 1);
vx_image output; vx_uint32 width = 0, height = 0; vx_df_image format = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(output_param, VX_PARAMETER_ATTRIBUTE_REF, &output, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(output, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format)));
STATUS_ERROR_CHECK(vxQueryImage(output, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width)));
STATUS_ERROR_CHECK(vxQueryImage(output, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height)));
if (format != VX_DF_IMAGE_U8 && format != VX_DF_IMAGE_S16)
status = VX_ERROR_INVALID_VALUE;
STATUS_ERROR_CHECK(vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width)));
STATUS_ERROR_CHECK(vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height)));
STATUS_ERROR_CHECK(vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format)));
vxReleaseImage(&output);
vxReleaseParameter(&output_param);
}
return status;
}
static vx_status vxCheckBufferInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
status = VX_SUCCESS;
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_UINT8)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status vxCheckOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
ptr->dim.scalar.type = VX_TYPE_UINT32;
if (param)
{
vx_scalar serr = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &serr, sizeof(serr));
if (serr)
{
vx_enum stype = 0;
vxQueryScalar(serr, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_UINT32)
{
ptr->dim.scalar.type = stype;
status = VX_SUCCESS;
}
}
vxReleaseParameter(¶m);
}
}
return VX_SUCCESS;
}
static vx_status vxBinaryBitwiseOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param0 = vxGetParameterByIndex(node, 0);
if (param0)
{
vx_image image0 = 0;
vxQueryParameter(param0, VX_PARAMETER_ATTRIBUTE_REF, &image0, sizeof(image0));
/*
* When passing on the geometry to the output image, we only look at image 0, as
* both input images are verified to match, at input validation.
*/
if (image0)
{
vx_uint32 width = 0, height = 0;
vxQueryImage(image0, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(image0, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_U8;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&image0);
}
vxReleaseParameter(¶m0);
}
}
return status;
}
static vx_status VX_CALLBACK vxFindWarpOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_matrix matrix;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &matrix, sizeof(matrix));
if (matrix)
{
vx_enum data_type = 0;
vx_size rows = 0ul, columns = 0ul;
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &data_type, sizeof(data_type));
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows));
vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns));
if ((data_type == VX_TYPE_FLOAT32) && (columns == 3) && (rows == 3))
{
status = VX_SUCCESS;
}
vxReleaseMatrix(&matrix);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxMinMaxLocInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_FORMAT, &format, sizeof(format));
if ((format == VX_DF_IMAGE_U8)
|| (format == VX_DF_IMAGE_S16)
#if defined(EXPERIMENTAL_USE_S16)
|| (format == VX_DF_IMAGE_U16)
|| (format == VX_DF_IMAGE_U32)
|| (format == VX_DF_IMAGE_S32)
#endif
)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
return status;
}
static vx_status VX_CALLBACK vxCopyArrayOutputValidator(vx_node node, vx_uint32 index, vx_meta_format meta)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index > 0)
{
vx_parameter param = vxGetParameterByIndex(node, 0);
if (param)
{
vx_array input;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(vx_array));
if (input)
{
vx_enum item_type = VX_TYPE_INVALID;
vx_size capacity = 0ul;
status = VX_SUCCESS;
status |= vxQueryArray(input, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type, sizeof(item_type));
status |= vxQueryArray(input, VX_ARRAY_ATTRIBUTE_CAPACITY, &capacity, sizeof(capacity));
status |= vxSetMetaFormatAttribute(meta, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type, sizeof(item_type));
status |= vxSetMetaFormatAttribute(meta, VX_ARRAY_ATTRIBUTE_CAPACITY, &capacity, sizeof(capacity));
vxReleaseArray(&input);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxThresholdOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter src_param = vxGetParameterByIndex(node, 0);
if (src_param)
{
vx_image src = 0;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
if (src)
{
vx_uint32 width = 0, height = 0;
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
/* fill in the meta data with the attributes so that the checker will pass */
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_U8;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&src);
}
vxReleaseParameter(&src_param);
}
}
return status;
}
static vx_status VX_CALLBACK vxMagnitudeOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, 0);
if (vxGetStatus((vx_reference)param) == VX_SUCCESS)
{
vx_image input = 0;
vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input));
if (input)
{
vx_uint32 width = 0, height = 0;
vxQueryImage(input, VX_IMAGE_WIDTH, &width, sizeof(width));
vxQueryImage(input, VX_IMAGE_HEIGHT, &height, sizeof(height));
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_S16;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxCopyImageOutputValidator(vx_node node, vx_uint32 index, vx_meta_format meta)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, 0); /* input image */
if (param)
{
vx_image input = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(vx_image));
if (input)
{
vx_uint32 width = 0, height = 0;
vx_df_image format = VX_DF_IMAGE_VIRT;
status = VX_SUCCESS;
status |= vxQueryImage(input, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
status |= vxQueryImage(input, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
status |= vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
status |= vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
status |= vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
status |= vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status vxEqualizeHistOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, 0); /* we reference the input image */
if (param)
{
vx_image input = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_uint32 width = 0, height = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = VX_DF_IMAGE_U8;
ptr->dim.image.width = width;
ptr->dim.image.height = height;
status = VX_SUCCESS;
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxEdgeTraceOutputValidator(vx_node node, vx_uint32 index, vx_meta_format meta)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 2)
{
vx_parameter src_param = vxGetParameterByIndex(node, 0);
if (src_param)
{
vx_image src = 0;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
if (src)
{
vx_uint32 width = 0, height = 0;
vx_df_image format = VX_DF_IMAGE_U8;
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
//vxQueryImage(src, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxSetMetaFormatAttribute(meta, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
status = VX_SUCCESS;
vxReleaseImage(&src);
}
vxReleaseParameter(&src_param);
}
}
return status;
}
static vx_status VX_CALLBACK vxMagnitudeInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0 || index == 1)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_S16)
{
if (index == 0)
{
status = VX_SUCCESS;
}
else
{
vx_parameter param0 = vxGetParameterByIndex(node, index);
vx_image input0 = 0;
vxQueryParameter(param0, VX_PARAMETER_REF, &input0, sizeof(input0));
if (input0)
{
vx_uint32 width0 = 0, height0 = 0, width1 = 0, height1 = 0;
vxQueryImage(input0, VX_IMAGE_WIDTH, &width0, sizeof(width0));
vxQueryImage(input0, VX_IMAGE_HEIGHT, &height0, sizeof(height0));
vxQueryImage(input, VX_IMAGE_WIDTH, &width1, sizeof(width1));
vxQueryImage(input, VX_IMAGE_HEIGHT, &height1, sizeof(height1));
if (width0 == width1 && height0 == height1)
status = VX_SUCCESS;
vxReleaseImage(&input0);
}
vxReleaseParameter(¶m0);
}
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
return status;
}
static vx_status VX_CALLBACK vxTableLookupInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0)
{
vx_image input = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if (input)
{
vx_df_image format = 0;
vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if (format == VX_DF_IMAGE_U8
#if defined(EXPERIMENTAL_USE_S16)
|| format == VX_DF_IMAGE_S16
#endif
)
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
vx_lut lut = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &lut, sizeof(lut));
if (lut)
{
vx_enum type = 0;
vxQueryLUT(lut, VX_LUT_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_UINT8 || type == VX_TYPE_INT16)
{
status = VX_SUCCESS;
}
vxReleaseLUT(&lut);
}
vxReleaseParameter(¶m);
}
return status;
}
static vx_status VX_CALLBACK vxScaleImageOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 1)
{
vx_parameter src_param = vxGetParameterByIndex(node, 0);
vx_parameter dst_param = vxGetParameterByIndex(node, index);
if (src_param && dst_param)
{
vx_image src = 0;
vx_image dst = 0;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
vxQueryParameter(dst_param, VX_PARAMETER_ATTRIBUTE_REF, &dst, sizeof(dst));
if ((src) && (dst))
{
vx_uint32 w1 = 0, h1 = 0, w2 = 0, h2 = 0;
vx_df_image f1 = VX_DF_IMAGE_VIRT, f2 = VX_DF_IMAGE_VIRT;
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &w1, sizeof(w1));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &h1, sizeof(h1));
vxQueryImage(dst, VX_IMAGE_ATTRIBUTE_WIDTH, &w2, sizeof(w2));
vxQueryImage(dst, VX_IMAGE_ATTRIBUTE_HEIGHT, &h2, sizeof(h2));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_FORMAT, &f1, sizeof(f1));
vxQueryImage(dst, VX_IMAGE_ATTRIBUTE_FORMAT, &f2, sizeof(f2));
/* output can not be virtual */
if ((w2 != 0) && (h2 != 0) && (f2 != VX_DF_IMAGE_VIRT) && (f1 == f2))
{
/* fill in the meta data with the attributes so that the checker will pass */
ptr->type = VX_TYPE_IMAGE;
ptr->dim.image.format = f2;
ptr->dim.image.width = w2;
ptr->dim.image.height = h2;
status = VX_SUCCESS;
}
vxReleaseImage(&src);
vxReleaseImage(&dst);
}
vxReleaseParameter(&src_param);
vxReleaseParameter(&dst_param);
}
}
return status;
}
static VALUE Parameter_dir(VALUE self)
{
Check_Type(self, T_DATA);
vx_enum dir;
vx_parameter param = (vx_parameter)DATA_PTR(self);
vx_status status = vxQueryParameter(param, VX_QUERY_PARAMETER_DIRECTION, &dir, sizeof(dir));
if (status == VX_SUCCESS)
return INT2FIX(dir);
else
return INT2FIX(0);
}
static VALUE Parameter_value(VALUE self)
{
Check_Type(self, T_DATA);
vx_reference ref;
vx_parameter param = (vx_parameter)DATA_PTR(self);
vx_status status = vxQueryParameter(param, VX_QUERY_PARAMETER_REF, &ref, sizeof(ref));
if (status == VX_SUCCESS)
return INT2FIX(ref);
else
return INT2FIX(0);
}
/************************************************************************************************************
input parameter validator.
param [in] node The handle to the node.
param [in] index The index of the parameter to validate.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_norm_InputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image;
vx_df_image df_image = VX_DF_IMAGE_VIRT;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(vx_image)));
STATUS_ERROR_CHECK(vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &df_image, sizeof(df_image)));
if (df_image != VX_DF_IMAGE_U8)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
else if (index == 1)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_float32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_FLOAT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 2)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_int32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
if (value < 0 || type != VX_TYPE_INT32)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
return status;
}