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;
}
/************************************************************************************************************
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;
}
VX_API_ENTRY vx_node VX_API_CALL vxConvertImageToTensorNode(vx_graph graph, vx_image input, vx_tensor output, vx_float32 a, vx_float32 b, vx_bool reverse_channel_order)
{
vx_node node = NULL;
vx_context context = vxGetContext((vx_reference)graph);
if (vxGetStatus((vx_reference)context) == VX_SUCCESS) {
vx_scalar s_a = vxCreateScalarWithSize(context, VX_TYPE_FLOAT32, &a, sizeof(a));
vx_scalar s_b = vxCreateScalarWithSize(context, VX_TYPE_FLOAT32, &b, sizeof(b));
vx_scalar s_order = vxCreateScalarWithSize(context, VX_TYPE_BOOL, &reverse_channel_order, sizeof(reverse_channel_order));
if(vxGetStatus((vx_reference)s_order) == VX_SUCCESS) {
vx_reference params[] = {
(vx_reference)input,
(vx_reference)output,
(vx_reference)s_a,
(vx_reference)s_b,
(vx_reference)s_order
};
node = createNode(graph, VX_KERNEL_CONVERT_IMAGE_TO_TENSOR_AMD, params, sizeof(params) / sizeof(params[0]));
vxReleaseScalar(&s_a);
vxReleaseScalar(&s_b);
vxReleaseScalar(&s_order);
}
}
return node;
}
//! [node]
vx_node vxXYZNode(vx_graph graph, vx_image input, vx_uint32 value, vx_image output, vx_array temp)
{
vx_uint32 i;
vx_node node = 0;
vx_context context = vxGetContext((vx_reference)graph);
vx_status status = vxLoadKernels(context, "xyz");
if (status == VX_SUCCESS)
{
//! [xyz node]
vx_kernel kernel = vxGetKernelByName(context, VX_KERNEL_NAME_KHR_XYZ);
if (kernel)
{
node = vxCreateGenericNode(graph, kernel);
if (vxGetStatus((vx_reference)node) == VX_SUCCESS)
{
vx_status statuses[4];
vx_scalar scalar = vxCreateScalar(context, VX_TYPE_INT32, &value);
statuses[0] = vxSetParameterByIndex(node, 0, (vx_reference)input);
statuses[1] = vxSetParameterByIndex(node, 1, (vx_reference)scalar);
statuses[2] = vxSetParameterByIndex(node, 2, (vx_reference)output);
statuses[3] = vxSetParameterByIndex(node, 3, (vx_reference)temp);
vxReleaseScalar(&scalar);
for (i = 0; i < dimof(statuses); i++)
{
if (statuses[i] != VX_SUCCESS)
{
status = VX_ERROR_INVALID_PARAMETERS;
vxReleaseNode(&node);
vxReleaseKernel(&kernel);
node = 0;
kernel = 0;
break;
}
}
}
else
{
vxReleaseKernel(&kernel);
}
}
else
{
vxUnloadKernels(context, "xyz");
}
//! [xyz node]
}
return node;
}
/************************************************************************************************************
output parameter validator.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_norm_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_scalar output; vx_scalar scalar = 0; vx_enum type = 0; vx_float32 value = 0;
STATUS_ERROR_CHECK(vxQueryParameter(output_param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar)));
STATUS_ERROR_CHECK(vxReadScalarValue(scalar, &value));
vxReleaseScalar(&output);
vxReleaseParameter(&output_param);
}
return status;
}
VX_API_ENTRY vx_node VX_API_CALL vxTensorAddNode(vx_graph graph, vx_tensor input1, vx_tensor input2, vx_enum policy, vx_tensor output)
{
vx_node node = NULL;
vx_context context = vxGetContext((vx_reference)graph);
if (vxGetStatus((vx_reference)context) == VX_SUCCESS) {
vx_scalar s_policy = vxCreateScalarWithSize(context, VX_TYPE_ENUM, &policy, sizeof(policy));
if (vxGetStatus((vx_reference)s_policy) == VX_SUCCESS)
{
vx_reference params[] = {
(vx_reference)input1,
(vx_reference)input2,
(vx_reference)s_policy,
(vx_reference)output
};
node = createNode(graph, VX_KERNEL_TENSOR_ADD, params, sizeof(params) / sizeof(params[0]));
vxReleaseScalar(&s_policy);
}
}
return node;
}
VX_API_ENTRY vx_node vxROIPoolingLayer(vx_graph graph, vx_tensor input_data, vx_tensor input_rois,
const vx_nn_roi_pool_params_t *roi_pool_params,vx_size size_of_roi_params, vx_tensor output_arr)
{
return NULL;
vx_node node = NULL;
vx_context context = vxGetContext((vx_reference)graph);
if(vxGetStatus((vx_reference)context) == VX_SUCCESS) {
vx_scalar roi_params = vxCreateScalarWithSize(context, VX_TYPE_NN_ROI_POOL_PARAMS, roi_pool_params, size_of_roi_params);
if(vxGetStatus((vx_reference)roi_params) == VX_SUCCESS) {
vx_reference params[] = {
(vx_reference)input_data,
(vx_reference)input_rois,
(vx_reference)roi_params,
(vx_reference)output_arr
};
node = createNode(graph, VX_KERNEL_ROI_POOLING_LAYER, params, sizeof(params)/sizeof(params[0]));
}
vxReleaseScalar(&roi_params);
}
return node;
}
static vx_status VX_CALLBACK vxAddSubtractInputValidator(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)
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_REF, &images[0], sizeof(images[0]));
vxQueryParameter(param[1], VX_PARAMETER_REF, &images[1], sizeof(images[1]));
if (images[0] && images[1])
{
vx_uint32 width[2], height[2];
vx_df_image format1;
vxQueryImage(images[0], VX_IMAGE_WIDTH, &width[0], sizeof(width[0]));
vxQueryImage(images[1], VX_IMAGE_WIDTH, &width[1], sizeof(width[1]));
vxQueryImage(images[0], VX_IMAGE_HEIGHT, &height[0], sizeof(height[0]));
vxQueryImage(images[1], VX_IMAGE_HEIGHT, &height[1], sizeof(height[1]));
vxQueryImage(images[1], VX_IMAGE_FORMAT, &format1, sizeof(format1));
if (width[0] == width[1] && height[0] == height[1] &&
(format1 == VX_DF_IMAGE_U8 || format1 == VX_DF_IMAGE_S16))
status = VX_SUCCESS;
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
else if (index == 2) /* overflow_policy: truncate or saturate. */
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (vxGetStatus((vx_reference)param) == VX_SUCCESS)
{
vx_scalar scalar = 0;
vxQueryParameter(param, VX_PARAMETER_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum stype = 0;
vxQueryScalar(scalar, VX_SCALAR_TYPE, &stype, sizeof(stype));
if (stype == VX_TYPE_ENUM)
{
vx_enum overflow_policy = 0;
vxCopyScalar(scalar, &overflow_policy, VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
if ((overflow_policy == VX_CONVERT_POLICY_WRAP) ||
(overflow_policy == VX_CONVERT_POLICY_SATURATE))
{
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 vxHarrisInputValidator(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;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &input, sizeof(input));
if ((status == VX_SUCCESS) && (input))
{
vx_df_image format = 0;
status = vxQueryImage(input, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
if ((status == VX_SUCCESS) && (format == VX_DF_IMAGE_U8))
{
status = VX_SUCCESS;
}
vxReleaseImage(&input);
}
vxReleaseParameter(¶m);
}
}
else if (index == 1)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 d = 0.0f;
status = vxAccessScalarValue(sens, &d);
if ((status == VX_SUCCESS) && (1.0 <= d) && (d <= 5.0))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 3)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar sens = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &sens, sizeof(sens));
if ((status == VX_SUCCESS) && (sens))
{
vx_enum type = 0;
vxQueryScalar(sens, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 k = 0.0f;
vxAccessScalarValue(sens, &k);
VX_PRINT(VX_ZONE_INFO, "k = %lf\n", k);
if ((0.040000f <= k) && (k < 0.150001f))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&sens);
}
vxReleaseParameter(¶m);
}
}
else if (index == 4 || index == 5)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_INT32)
{
vx_int32 size = 0;
vxAccessScalarValue(scalar, &size);
VX_PRINT(VX_ZONE_INFO, "size = %u\n", size);
if ((size == 3) || (size == 5) || (size == 7))
{
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 vxMultiplyInputValidator(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 || format == VX_DF_IMAGE_S16)
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 format1;
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[1], VX_IMAGE_ATTRIBUTE_FORMAT, &format1, sizeof(format1));
if (width[0] == width[1] && height[0] == height[1] &&
(format1 == VX_DF_IMAGE_U8 || format1 == VX_DF_IMAGE_S16))
status = VX_SUCCESS;
vxReleaseImage(&images[0]);
vxReleaseImage(&images[1]);
}
vxReleaseParameter(¶m[0]);
vxReleaseParameter(¶m[1]);
}
else if (index == 2) /* scale: must be non-negative. */
{
vx_scalar scalar = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = -1;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
vx_float32 scale = 0.0f;
if ((vxAccessScalarValue(scalar, &scale) == VX_SUCCESS) &&
(scale >= 0))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 3) /* overflow_policy: truncate or saturate. */
{
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 overflow_policy = 0;
vxAccessScalarValue(scalar, &overflow_policy);
if ((overflow_policy == VX_CONVERT_POLICY_WRAP) ||
(overflow_policy == VX_CONVERT_POLICY_SATURATE))
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_VALUE;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 4) /* rounding_policy: truncate or saturate. */
{
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 rouding_policy = 0;
vxAccessScalarValue(scalar, &rouding_policy);
if ((rouding_policy == VX_ROUND_POLICY_TO_ZERO) ||
(rouding_policy == VX_ROUND_POLICY_TO_NEAREST_EVEN))
{
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 vxEuclideanNonMaxHarrisInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0) /* image */
{
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_F32)
{
status = VX_SUCCESS;
}
vxReleaseImage(&img);
}
vxReleaseParameter(¶m);
}
}
else if (index == 1) /* strength_thresh */
{
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_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
else if (index == 2) /* min_distance */
{
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_FLOAT32)
{
vx_float32 radius = 0;
vxReadScalarValue(scalar, &radius);
if ((0.0 <= radius) && (radius <= 30.0))
{
status = VX_SUCCESS;
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxChannelExtractInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_SUCCESS;
vx_parameter param = vxGetParameterByIndex(node, index);
if (index == 0)
{
vx_image image = 0;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(image));
if (image)
{
vx_df_image format = 0;
vx_uint32 width, height;
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(width));
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
// check to make sure the input format is supported.
switch (format)
{
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_RGBX:
case VX_DF_IMAGE_YUV4:
status = VX_SUCCESS;
break;
/* 4:2:0 */
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
case VX_DF_IMAGE_IYUV:
if (width % 2 != 0 || height % 2 != 0)
status = VX_ERROR_INVALID_DIMENSION;
else
status = VX_SUCCESS;
break;
/* 4:2:2 */
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
if (width % 2 != 0)
status = VX_ERROR_INVALID_DIMENSION;
else
status = VX_SUCCESS;
break;
default:
status = VX_ERROR_INVALID_FORMAT;
break;
}
vxReleaseImage(&image);
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
}
else if (index == 1)
{
vx_scalar scalar;
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_ENUM)
{
vx_enum channel = 0;
vx_parameter param0;
vxReadScalarValue(scalar, &channel);
param0 = vxGetParameterByIndex(node, 0);
if (param0)
{
vx_image image = 0;
vxQueryParameter(param0, VX_PARAMETER_ATTRIBUTE_REF, &image, sizeof(image));
if (image)
{
vx_df_image format = VX_DF_IMAGE_VIRT;
vxQueryImage(image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
status = VX_ERROR_INVALID_VALUE;
switch (format)
{
case VX_DF_IMAGE_RGB:
case VX_DF_IMAGE_RGBX:
if ( (channel == VX_CHANNEL_R) ||
(channel == VX_CHANNEL_G) ||
(channel == VX_CHANNEL_B) ||
(channel == VX_CHANNEL_A) ) {
status = VX_SUCCESS;
}
break;
case VX_DF_IMAGE_YUV4:
case VX_DF_IMAGE_NV12:
case VX_DF_IMAGE_NV21:
case VX_DF_IMAGE_IYUV:
case VX_DF_IMAGE_UYVY:
case VX_DF_IMAGE_YUYV:
if ( (channel == VX_CHANNEL_Y) ||
(channel == VX_CHANNEL_U) ||
(channel == VX_CHANNEL_V) ) {
status = VX_SUCCESS;
}
break;
default:
break;
}
vxReleaseImage(&image);
}
vxReleaseParameter(¶m0);
}
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
}
else
{
status = VX_ERROR_INVALID_PARAMETERS;
}
vxReleaseParameter(¶m);
return status;
}
static vx_status VX_CALLBACK vxAccumulateSquaredInputValidator(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_image images[2];
vx_parameter param[2] = {
vxGetParameterByIndex(node, 0),
vxGetParameterByIndex(node, 2),
};
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]);
}
else if (index == 1) /* only weighted/squared average */
{
vx_scalar scalar = 0;
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if (scalar)
{
vx_enum type = 0;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_UINT32)
{
vx_uint32 shift = 0u;
if ((vxAccessScalarValue(scalar, &shift) == VX_SUCCESS) &&
(0 <= shift) && (shift <= 15))
{
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 vxMatrixModifyInputValidator(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_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);
}
}
if (index == 1 || index == 2)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = VX_TYPE_INVALID;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_UINT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
if (index == 3)
{
vx_parameter param = vxGetParameterByIndex(node, index);
if (param)
{
vx_scalar scalar = 0;
status = vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &scalar, sizeof(scalar));
if ((status == VX_SUCCESS) && (scalar))
{
vx_enum type = VX_TYPE_INVALID;
vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type));
if (type == VX_TYPE_FLOAT32)
{
status = VX_SUCCESS;
}
else
{
status = VX_ERROR_INVALID_TYPE;
}
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
}
}
return status;
}
static vx_status VX_CALLBACK vxHarrisInitializer(vx_node node, vx_reference parameters[], vx_uint32 num)
{
vx_status status = VX_FAILURE;
if (num == dimof(harris_kernel_params))
{
vx_image src = (vx_image)parameters[0];
vx_scalar str = (vx_scalar)parameters[1];
vx_scalar min = (vx_scalar)parameters[2];
vx_scalar sen = (vx_scalar)parameters[3];
vx_scalar win = (vx_scalar)parameters[4];
vx_scalar blk = (vx_scalar)parameters[5];
vx_array arr = (vx_array)parameters[6];
vx_scalar num_corners = (vx_scalar)parameters[7];
vx_context c = vxGetContext((vx_reference)node);
vx_graph g = vxCreateGraph(c);
vxLoadKernels(c, "openvx-extras");
vxLoadKernels(c, "openvx-debug");
if (g)
{
vx_uint32 i = 0;
vx_int32 ds = 4;
vx_scalar shift = vxCreateScalar(c, VX_TYPE_INT32, &ds);
vx_image virts[] = {
vxCreateVirtualImage(g, 0, 0, VX_DF_IMAGE_VIRT), // Gx
vxCreateVirtualImage(g, 0, 0, VX_DF_IMAGE_VIRT), // Gy
vxCreateVirtualImage(g, 0, 0, VX_DF_IMAGE_VIRT), // Score
vxCreateVirtualImage(g, 0, 0, VX_DF_IMAGE_VIRT), // Suppressed
vxCreateVirtualImage(g, 0, 0, VX_DF_IMAGE_U8), // Shifted Suppressed Log10
};
vx_node nodes[] = {
vxSobelMxNNode(g, src, win, virts[0], virts[1]),
vxHarrisScoreNode(g, virts[0], virts[1], sen, blk, virts[2]),
vxEuclideanNonMaxNode(g, virts[2], str, min, virts[3]),
vxImageListerNode(g, virts[3], arr, num_corners),
#if defined(OPENVX_DEBUGGING)
vxConvertDepthNode(g,virts[3],virts[4],VX_CONVERT_POLICY_WRAP,shift),
vxFWriteImageNode(g,virts[4],"oharris_strength_power_up4.pgm"),
#endif
};
status = VX_SUCCESS;
status |= vxAddParameterToGraphByIndex(g, nodes[0], 0); // src
status |= vxAddParameterToGraphByIndex(g, nodes[2], 1); // str
status |= vxAddParameterToGraphByIndex(g, nodes[2], 2); // min
status |= vxAddParameterToGraphByIndex(g, nodes[1], 2); // sen
status |= vxAddParameterToGraphByIndex(g, nodes[0], 1); // win
status |= vxAddParameterToGraphByIndex(g, nodes[1], 3); // blk
status |= vxAddParameterToGraphByIndex(g, nodes[3], 1); // arr
status |= vxAddParameterToGraphByIndex(g, nodes[3], 2); // num_corners
for (i = 0; i < dimof(nodes); i++)
{
vxReleaseNode(&nodes[i]);
}
for (i = 0; i < dimof(virts); i++)
{
vxReleaseImage(&virts[i]);
}
vxReleaseScalar(&shift);
status |= vxVerifyGraph(g);
VX_PRINT(VX_ZONE_INFO, "Status from Child Graph = %d\n", status);
if (status == VX_SUCCESS)
{
status = vxSetChildGraphOfNode(node, g);
}
else
{
vxReleaseGraph(&g);
}
}
}
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_SURF_Compute_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);
}
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)
status = VX_ERROR_INVALID_VALUE;
vxReleaseImage(&image);
}
else if (index == 2)
{
vx_array array; vx_size size = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &array, sizeof(array)));
STATUS_ERROR_CHECK(vxQueryArray(array, VX_ARRAY_ATTRIBUTE_CAPACITY, &size, sizeof(size)));
vxReleaseArray(&array);
}
else if (index == 3)
{
vx_array array; vx_size size = 0;
STATUS_ERROR_CHECK(vxQueryParameter(param, VX_PARAMETER_ATTRIBUTE_REF, &array, sizeof(array)));
STATUS_ERROR_CHECK(vxQueryArray(array, VX_ARRAY_ATTRIBUTE_CAPACITY, &size, sizeof(size)));
vxReleaseArray(&array);
}
else if (index == 4)
{
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 == 5)
{
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);
}
else if (index == 6)
{
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);
}
else if (index == 7)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_bool value = vx_true_e;
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 != vx_true_e && value != vx_false_e) || type != VX_TYPE_BOOL)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
else if (index == 8)
{
vx_scalar scalar = 0; vx_enum type = 0; vx_bool value = vx_true_e;
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 != vx_true_e && value != vx_false_e) || type != VX_TYPE_BOOL)
status = VX_ERROR_INVALID_VALUE;
vxReleaseScalar(&scalar);
}
vxReleaseParameter(¶m);
return status;
}
/*!
* \brief An example of an super resolution algorithm.
* \ingroup group_example
*/
int example_super_resolution(int argc, char *argv[])
{
vx_status status = VX_SUCCESS;
vx_uint32 image_index = 0, max_num_images = 4;
vx_uint32 width = 640;
vx_uint32 i = 0;
vx_uint32 winSize = 32;
vx_uint32 height = 480;
vx_int32 sens_thresh = 20;
vx_float32 alpha = 0.2f;
vx_float32 tau = 0.5f;
vx_enum criteria = VX_TERM_CRITERIA_BOTH; // lk params
vx_float32 epsilon = 0.01;
vx_int32 num_iterations = 10;
vx_bool use_initial_estimate = vx_true_e;
vx_int32 min_distance = 5; // harris params
vx_float32 sensitivity = 0.04;
vx_int32 gradient_size = 3;
vx_int32 block_size = 3;
vx_context context = vxCreateContext();
vx_scalar alpha_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &alpha);
vx_scalar tau_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &tau);
vx_matrix matrix_forward = vxCreateMatrix(context, VX_TYPE_FLOAT32, 3, 3);
vx_matrix matrix_backwords = vxCreateMatrix(context, VX_TYPE_FLOAT32, 3, 3);
vx_array old_features = vxCreateArray(context, VX_TYPE_KEYPOINT, 1000);
vx_array new_features = vxCreateArray(context, VX_TYPE_KEYPOINT, 1000);
vx_scalar epsilon_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &epsilon);
vx_scalar num_iterations_s = vxCreateScalar(context, VX_TYPE_INT32, &num_iterations);
vx_scalar use_initial_estimate_s = vxCreateScalar(context, VX_TYPE_BOOL, &use_initial_estimate);
vx_scalar min_distance_s = vxCreateScalar(context, VX_TYPE_INT32, &min_distance);
vx_scalar sensitivity_s = vxCreateScalar(context, VX_TYPE_FLOAT32, &sensitivity);
vx_scalar sens_thresh_s = vxCreateScalar(context, VX_TYPE_INT32, &sens_thresh);
vx_scalar num_corners = vxCreateScalar(context, VX_TYPE_SIZE, NULL);
if (vxGetStatus((vx_reference)context) == VX_SUCCESS)
{
vx_image images[] =
{ vxCreateImage(context, width, height, VX_DF_IMAGE_UYVY), // index 0:
vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 1: Get Y channel
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 2: scale up to high res.
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 3: back wrap: transform to the original Image.
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 4: guassian blur
vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 5: scale down
vxCreateImage(context, width, height, VX_DF_IMAGE_S16), // index 6: Subtract the transformed Image with original moved Image
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 7: Scale Up the delta image.
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 8: Guassian blur the delta Image
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_S16), // index 9: forward wrap: tranform the deltas back to the high res Image
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 10: accumulate sum?
vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 11: Get U channel
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 12: scale up to high res.
vxCreateImage(context, width, height, VX_DF_IMAGE_U8), // index 13: Get V channel
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 14: scale up to high res.
vxCreateImage(context, width, height, VX_DF_IMAGE_UYVY), // index 15: output image
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 16: original y image scaled
vxCreateImage(context, width * 2, height * 2, VX_DF_IMAGE_U8), // index 17: difference image for last calculation
};
vx_pyramid pyramid_new = vxCreatePyramid(context, 4, 2, width, height, VX_DF_IMAGE_U8);
vx_pyramid pyramid_old = vxCreatePyramid(context, 4, 2, width, height, VX_DF_IMAGE_U8);
vx_graph graphs[] =
{ vxCreateGraph(context), vxCreateGraph(context), vxCreateGraph(context), vxCreateGraph(context), };
vxLoadKernels(context, "openvx-debug");
if (vxGetStatus((vx_reference)graphs[0]) == VX_SUCCESS)
{
vxChannelExtractNode(graphs[0], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation
vxScaleImageNode(graphs[0], images[1], images[2], VX_INTERPOLATION_TYPE_BILINEAR);
vxWarpPerspectiveNode(graphs[0], images[2], matrix_forward, 0, images[3]);
vxGaussian3x3Node(graphs[0], images[3], images[4]);
vxScaleImageNode(graphs[0], images[4], images[5], VX_INTERPOLATION_TYPE_BILINEAR);
vxSubtractNode(graphs[0], images[5], images[16], VX_CONVERT_POLICY_SATURATE, images[6]);
vxScaleImageNode(graphs[0], images[6], images[7], VX_INTERPOLATION_TYPE_BILINEAR);
vxGaussian3x3Node(graphs[0], images[7], images[8]);
vxWarpPerspectiveNode(graphs[0], images[8], matrix_backwords, 0, images[9]);
vxAccumulateWeightedImageNode(graphs[0], images[9], alpha_s, images[10]);
}
if (vxGetStatus((vx_reference)graphs[1]) == VX_SUCCESS)
{
vxChannelExtractNode(graphs[1], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation
vxGaussianPyramidNode(graphs[1], images[1], pyramid_new);
vxOpticalFlowPyrLKNode(graphs[1], pyramid_old, pyramid_new, old_features, old_features, new_features,
criteria, epsilon_s, num_iterations_s, use_initial_estimate_s, winSize);
}
if (vxGetStatus((vx_reference)graphs[2]) == VX_SUCCESS)
{
vxChannelExtractNode(graphs[2], images[0], VX_CHANNEL_Y, images[1]); // One iteration of super resolution calculation
vxHarrisCornersNode(graphs[2], images[1], sens_thresh_s, min_distance_s, sensitivity_s, gradient_size,
block_size, old_features, num_corners);
vxGaussianPyramidNode(graphs[2], images[1], pyramid_old);
vxScaleImageNode(graphs[2], images[1], images[16], VX_INTERPOLATION_TYPE_BILINEAR);
}
if (vxGetStatus((vx_reference)graphs[3]) == VX_SUCCESS)
{
vxSubtractNode(graphs[3], images[10], images[16], VX_CONVERT_POLICY_SATURATE, images[17]);
vxAccumulateWeightedImageNode(graphs[3], images[17], tau_s, images[16]);
vxChannelExtractNode(graphs[3], images[16], VX_CHANNEL_U, images[11]);
vxScaleImageNode(graphs[3], images[11], images[12], VX_INTERPOLATION_TYPE_BILINEAR); // upscale the u channel
vxChannelExtractNode(graphs[3], images[0], VX_CHANNEL_V, images[13]);
vxScaleImageNode(graphs[3], images[13], images[14], VX_INTERPOLATION_TYPE_BILINEAR); // upscale the v channel
vxChannelCombineNode(graphs[3], images[10], images[12], images[14], 0, images[15]); // recombine the channels
}
status = VX_SUCCESS;
status |= vxVerifyGraph(graphs[0]);
status |= vxVerifyGraph(graphs[1]);
status |= vxVerifyGraph(graphs[2]);
status |= vxVerifyGraph(graphs[3]);
if (status == VX_SUCCESS)
{
/* read the initial image in */
status |= vxuFReadImage(context, "c:\\work\\super_res\\superres_1_UYVY.yuv", images[0]);
/* compute the "old" pyramid */
status |= vxProcessGraph(graphs[2]);
/* for each input image, read it in and run graphs[1] and [0]. */
for (image_index = 1; image_index < max_num_images; image_index++)
{
char filename[256];
sprintf(filename, "c:\\work\\super_res\\superres_%d_UYVY.yuv", image_index + 1);
status |= vxuFReadImage(context, filename, images[0]);
status |= vxProcessGraph(graphs[1]);
userCalculatePerspectiveTransformFromLK(matrix_forward, matrix_backwords, old_features, new_features);
status |= vxProcessGraph(graphs[0]);
}
/* run the final graph */
status |= vxProcessGraph(graphs[3]);
/* save the output */
status |= vxuFWriteImage(context, images[15], "superres_UYVY.yuv");
}
vxReleaseGraph(&graphs[0]);
vxReleaseGraph(&graphs[1]);
vxReleaseGraph(&graphs[2]);
vxReleaseGraph(&graphs[3]);
for (i = 0; i < dimof(images); i++)
{
vxReleaseImage(&images[i]);
}
vxReleasePyramid(&pyramid_new);
vxReleasePyramid(&pyramid_old);
}
vxReleaseMatrix(&matrix_forward);
vxReleaseMatrix(&matrix_backwords);
vxReleaseScalar(&alpha_s);
vxReleaseScalar(&tau_s);
/* Release the context last */
vxReleaseContext(&context);
return status;
}
