/************************************************************************************************************
Execution Kernel
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_norm_Kernel(vx_node node, const vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_SUCCESS;
vx_image image_in = (vx_image) parameters[0];
vx_scalar scalar = (vx_scalar) parameters[1];
vx_scalar scalar1 = (vx_scalar) parameters[2];
Mat *mat;
int Type;
vx_int32 value = 0;
//Extracting Values from the Scalar into Type
STATUS_ERROR_CHECK(vxReadScalarValue(scalar1, &value)); Type = value;
//Converting VX Image to OpenCV Mat
STATUS_ERROR_CHECK(VX_to_CV_Image(&mat, image_in));
//Compute using OpenCV
float NORM_Val = 0;
NORM_Val = (float) norm(*mat, Type);
//Converting int to Scalar
STATUS_ERROR_CHECK(vxWriteScalarValue(scalar, &NORM_Val));
return status;
}
// write scalar value from a string
int WriteScalarFromString(vx_scalar scalar, const char str[])
{
vx_enum type; ERROR_CHECK(vxQueryScalar(scalar, VX_SCALAR_ATTRIBUTE_TYPE, &type, sizeof(type)));
if (type == VX_TYPE_FLOAT32) {
float v = 0; (void)sscanf(str, "%g", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_FLOAT64) {
double v = 0; (void)sscanf(str, "%lg", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_SIZE) {
vx_size v = 0; (void)sscanf(str, VX_FMT_SIZE, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_INT8 || type == VX_TYPE_INT16 || type == VX_TYPE_INT32 ||
type == VX_TYPE_UINT8 || type == VX_TYPE_UINT16 || type == VX_TYPE_UINT32 ||
type == VX_TYPE_CHAR || type == VX_TYPE_BOOL)
{
vx_int32 v = 0; (void)sscanf(str, "%i", &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_INT64 || type == VX_TYPE_UINT64) {
vx_int64 v = 0; (void)sscanf(str, "%" PRIi64, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_ENUM) {
vx_enum v = ovxName2Enum(str);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
else if (type == VX_TYPE_DF_IMAGE || type == VX_TYPE_STRING_AMD) {
ERROR_CHECK(vxWriteScalarValue(scalar, str));
}
else {
// unknown types will be assumed to be in hex format
vx_int64 v = 0; (void)sscanf(str, "%" PRIi64, &v);
ERROR_CHECK(vxWriteScalarValue(scalar, &v));
}
return 0;
}
// nodeless version of the Fast9Corners kernel
vx_status vxFast9Corners(vx_image src, vx_scalar sens, vx_scalar nonm, vx_array points,
vx_scalar s_num_corners, vx_border_mode_t *bordermode)
{
vx_float32 b = 0.0f;
vx_imagepatch_addressing_t src_addr;
void *src_base = NULL;
vx_rectangle_t rect;
vx_uint8 tolerance = 0;
vx_bool do_nonmax;
vx_uint32 num_corners = 0;
vx_size dst_capacity = 0;
vx_keypoint_t kp;
vx_status status = vxGetValidRegionImage(src, &rect);
status |= vxReadScalarValue(sens, &b);
status |= vxReadScalarValue(nonm, &do_nonmax);
/* remove any pre-existing points */
status |= vxTruncateArray(points, 0);
status |= vxAccessImagePatch(src, &rect, 0, &src_addr, &src_base, VX_READ_ONLY);
tolerance = (vx_uint8)b;
status |= vxQueryArray(points, VX_ARRAY_ATTRIBUTE_CAPACITY, &dst_capacity, sizeof(dst_capacity));
memset(&kp, 0, sizeof(kp));
if (status == VX_SUCCESS)
{
/*! \todo implement other Fast9 Corners border modes */
if (bordermode->mode == VX_BORDER_MODE_UNDEFINED)
{
vx_int32 y, x;
for (y = APERTURE; y < (vx_int32)(src_addr.dim_y - APERTURE); y++)
{
for (x = APERTURE; x < (vx_int32)(src_addr.dim_x - APERTURE); x++)
{
vx_uint8 strength = vxGetFastCornerStrength(x, y, src_base, &src_addr, tolerance);
if (strength > 0)
{
if (do_nonmax)
{
if (strength >= vxGetFastCornerStrength(x-1, y-1, src_base, &src_addr, tolerance) &&
strength >= vxGetFastCornerStrength(x, y-1, src_base, &src_addr, tolerance) &&
strength >= vxGetFastCornerStrength(x+1, y-1, src_base, &src_addr, tolerance) &&
strength >= vxGetFastCornerStrength(x-1, y, src_base, &src_addr, tolerance) &&
strength > vxGetFastCornerStrength(x+1, y, src_base, &src_addr, tolerance) &&
strength > vxGetFastCornerStrength(x-1, y+1, src_base, &src_addr, tolerance) &&
strength > vxGetFastCornerStrength(x, y+1, src_base, &src_addr, tolerance) &&
strength > vxGetFastCornerStrength(x+1, y+1, src_base, &src_addr, tolerance))
;
else
continue;
}
if (num_corners < dst_capacity)
{
kp.x = x;
kp.y = y;
kp.strength = strength;
status |= vxAddArrayItems(points, 1, &kp, 0);
}
num_corners++;
}
}
}
}
else
{
status = VX_ERROR_NOT_IMPLEMENTED;
}
if (s_num_corners)
status |= vxWriteScalarValue(s_num_corners, &num_corners);
status |= vxCommitImagePatch(src, NULL, 0, &src_addr, src_base);
}
return status;
}
