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;
}
void FeatureTracker::changeType(vx_array vx_pt, vector<cv::Point2f> &cv_pt )
{
vx_size vCount = 0;
vxQueryArray(vx_pt, VX_ARRAY_ATTRIBUTE_NUMITEMS, &vCount, sizeof(vCount));
vx_enum item_type = 0;
NVXIO_SAFE_CALL( vxQueryArray(vx_pt, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type, sizeof(item_type)) );
NVXIO_ASSERT( item_type == NVX_TYPE_POINT2F) ;
vx_size stride;
void * featureData = NULL;
NVXIO_SAFE_CALL( vxAccessArrayRange(vx_pt, 0, vCount, &stride,
(void**)&featureData, VX_READ_ONLY) );
int id = 0;
cv_pt.resize(vCount);
for (vx_size i = 0; i < vCount; i++)
{
nvx_point2f_t feature = vxArrayItem(nvx_point2f_t, featureData, i, stride);
cv_pt[id].x = feature.x;
cv_pt[id].y = feature.y;
id++;
}
NVXIO_SAFE_CALL( vxCommitArrayRange(vx_pt, 0, vCount, featureData) );
cv_pt.resize(id);
//cout<<"point size "<<cv_pt.size()<<" id "<<id<<endl;
}
void userCalculatePerspectiveTransformFromLK(vx_matrix matrix_forward, vx_matrix matrix_backward, vx_array old_features,
vx_array new_features)
{
vx_float32 mat1[3][3];
vx_float32 mat2[3][3];
vx_size olen = 0;
vx_size nlen = 0;
vx_keypoint_t *old_features_ptr = NULL;
vx_keypoint_t *new_features_ptr = NULL;
vx_size old_features_stride = 0;
vx_size new_features_stride = 0;
vx_uint32 ind;
//vx_float32 *A = malloc(olen+nlen);
//vx_float32 *b = malloc(olen+nlen);
vxQueryArray(old_features, VX_ARRAY_ATTRIBUTE_NUMITEMS, &olen, sizeof(olen));
vxQueryArray(new_features, VX_ARRAY_ATTRIBUTE_NUMITEMS, &nlen, sizeof(nlen));
if (olen != nlen)
return;
vxAccessArrayRange(old_features, 0, olen, &old_features_stride, (void **) &old_features_ptr, VX_READ_ONLY);
vxAccessArrayRange(new_features, 0, nlen, &new_features_stride, (void **) &new_features_ptr, VX_READ_ONLY);
/*! \internal do least square algorithm that find perspective transform */
/*! \see "Computer Vision Algorithm and Application by Richard Szeliski section 6.1.3 */
for (ind = 0; ind < nlen; ind++)
{
//vx_int32 matrix_index = 2 * ind;
//vx_keypoint_t old_kp = vxArrayItem(vx_keypoint_t, old_features_ptr, ind, old_features_stride);
//vx_keypoint_t new_kp = vxArrayItem(vx_keypoint_t, new_features_ptr, ind, new_features_stride);
/*
A[matrix_index] = {old_kp.x, old_kp.y, 1,
0, 0, 0,
-old_kp.x*new_kp.x,
-old_kp.x*new_kp.y};
A[matrix_index+1] = {0, 0, 0,
old_kp.x,
old_kp.y,
1,
-old_kp.y*new_kp.x,
-old_kp.y*new_kp.y};
b[matrix_index] = new_kp.x - old_kp.x;
b[matrix_index+1] = new_kp.y - old_kp.y;
*/
}
//least_square_divide(A,b, mat1);
//inverse_matrix(mat1, mat2);
vxCommitArrayRange(old_features, 0, 0, old_features_ptr);
vxCommitArrayRange(new_features, 0, 0, new_features_ptr);
vxWriteMatrix(matrix_forward, mat1);
vxWriteMatrix(matrix_backward, mat2);
}
int CVxParamArray::Finalize()
{
// get attributes
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_ITEMSIZE, &m_itemSize, sizeof(m_itemSize)));
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_CAPACITY, &m_capacity, sizeof(m_capacity)));
// process user requested directives
if (m_useSyncOpenCLWriteDirective) {
ERROR_CHECK_AND_WARN(vxDirective((vx_reference)m_array, VX_DIRECTIVE_AMD_COPY_TO_OPENCL), VX_ERROR_NOT_ALLOCATED);
}
return 0;
}
static vx_status VX_CALLBACK vxFindWarpInputValidator(vx_node node, vx_uint32 index)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 0 || index == 1 )
{
vx_parameter param1 = vxGetParameterByIndex(node, 0);
vx_parameter param2 = vxGetParameterByIndex(node, 1);
if (param1 && param2)
{
vx_array arr1 = 0, arr2 = 0;
vxQueryParameter(param1, VX_PARAMETER_ATTRIBUTE_REF, &arr1, sizeof(arr1));
vxQueryParameter(param2, VX_PARAMETER_ATTRIBUTE_REF, &arr2, sizeof(arr2));
if (arr1 && arr2)
{
vx_enum item_type1 = 0, item_type2 = 0;
vxQueryArray(arr1, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type1, sizeof(item_type1));
vxQueryArray(arr2, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &item_type2, sizeof(item_type2));
if (item_type1 == VX_TYPE_KEYPOINT && item_type2 == VX_TYPE_KEYPOINT)
{
vx_size num1, num2;
vxQueryArray(arr1, VX_ARRAY_ATTRIBUTE_NUMITEMS, &num1, sizeof(num1));
vxQueryArray(arr2, VX_ARRAY_ATTRIBUTE_NUMITEMS, &num2, sizeof(num2));
if(num1 == num2)
{
status = VX_SUCCESS;
}
}
vxReleaseArray(&arr1);
vxReleaseArray(&arr2);
}
vxReleaseParameter(¶m1);
vxReleaseParameter(¶m2);
}
}
return status;
}
int CVxParamArray::CompareFrame(int frameNumber)
{
// check if user specified file to write
if (m_fileNameCompare.length() < 1) return 0;
// clear items from m_arrayListForView
m_arrayListForView.clear();
// reading data from reference file
char fileName[MAX_FILE_NAME_LENGTH]; sprintf(fileName, m_fileNameCompare.c_str(), frameNumber);
FILE * fp = fopen(fileName, m_compareFileIsBinary ? "rb" : "r");
if (!fp) {
ReportError("ERROR: Unable to open: %s\n", fileName);
}
size_t numItemsRef = ReadFileIntoBuffer(fp, m_compareFileIsBinary);
fclose(fp);
// get numItems of the array
vx_size numItems;
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_NUMITEMS, &numItems, sizeof(numItems)));
// compare array items
bool mismatchDetected = false;
if (m_format == VX_TYPE_KEYPOINT && numItems > 0)
{ // keypoint compare with user specified tolerance limits
mismatchDetected = CompareFrameKeypoints(numItems, numItemsRef, m_bufForRead, frameNumber, fileName);
}
else if (m_format == VX_TYPE_COORDINATES2D && numItems > 0)
{ // coordinates2d compare with user specified tolerance limits
mismatchDetected = CompareFrameCoord2d(numItems, numItemsRef, m_bufForRead, frameNumber, fileName);
}
else
{ // fallback to bitwise exact compare
mismatchDetected = CompareFrameBitwiseExact(numItems, numItemsRef, m_bufForRead, frameNumber, fileName);
}
// report error if mismatched
if (mismatchDetected) {
m_compareCountMismatches++;
if (!m_discardCompareErrors) return -1;
}
else {
m_compareCountMatches++;
}
return 0;
}
/*!***********************************************************************************************************
output parameter validator.
*************************************************************************************************************/
static vx_status VX_CALLBACK CV_SURF_Compute_OutputValidator(vx_node node, vx_uint32 index, vx_meta_format meta)
{
vx_status status = VX_SUCCESS;
if (index == 2)
{
vx_parameter output_param = vxGetParameterByIndex(node, 2);
vx_array output; vx_size size = 0;
STATUS_ERROR_CHECK(vxQueryParameter(output_param, VX_PARAMETER_ATTRIBUTE_REF, &output, sizeof(vx_array)));
STATUS_ERROR_CHECK(vxQueryArray(output, VX_ARRAY_ATTRIBUTE_CAPACITY, &size, sizeof(size)));
if (size <= 0)
status = VX_ERROR_INVALID_VALUE;
vxReleaseArray(&output);
vxReleaseParameter(&output_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_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;
}
static vx_status VX_CALLBACK vxFindWarpKernel(vx_node node, vx_reference *parameters, vx_uint32 num)
{
if(num != 3)
return VX_ERROR_INVALID_PARAMETERS;
vx_status status = VX_SUCCESS;
vx_array def_pnts = (vx_array) parameters[0];
vx_array moved_pnts = (vx_array) parameters[1];
vx_matrix matrix = (vx_matrix)parameters[2];
vx_size points_num;
status |= vxQueryArray(def_pnts, VX_ARRAY_ATTRIBUTE_NUMITEMS, &points_num, sizeof(points_num));
if(status != VX_SUCCESS)
{
VX_PRINT(VX_ZONE_ERROR, "Can't query array attribute(%d)!\n", status);
return VX_FAILURE;
}
if(points_num < 4)
{
vx_float32 matr_buff[9];
vxAccessMatrix(matrix, (void*)matr_buff);
memset(matr_buff, 0, sizeof(vx_float32) * 9);
matr_buff[0] = matr_buff[4] = matr_buff[8] = 1.;
vxCommitMatrix(matrix, (void*)matr_buff);
VX_PRINT(VX_ZONE_WARNING, "Number of points less then 4(%d)!\n", points_num);
return VX_SUCCESS;//VX_FAILURE;
}
/*** CV array initialize ***/
std::vector<cv::Point2f> cv_points_from, cv_points_to;
cv_points_from.reserve(points_num);
cv_points_to.reserve(points_num);
/***************************/
vx_size i, stride1 = 0ul, stride2 = 0ul;
void *def_buff = NULL, *moved_buff = NULL;
status |= vxAccessArrayRange(def_pnts, 0, points_num, &stride1, &def_buff, VX_READ_AND_WRITE);
status |= vxAccessArrayRange(moved_pnts, 0, points_num, &stride2, &moved_buff, VX_READ_AND_WRITE);
if(def_buff && moved_buff)
{
for (i = 0; i < points_num; i++)
{
if(vxArrayItem(vx_keypoint_t, moved_buff, i, stride2).tracking_status)
{
cv::Point2f pnt_from;
pnt_from.x = vxArrayItem(vx_keypoint_t, def_buff, i, stride1).x;
pnt_from.y = vxArrayItem(vx_keypoint_t, def_buff, i, stride1).y;
cv_points_from.push_back(pnt_from);
cv::Point2f pnt_to;
pnt_to.x = vxArrayItem(vx_keypoint_t, moved_buff, i, stride2).x;
pnt_to.y = vxArrayItem(vx_keypoint_t, moved_buff, i, stride2).y;
cv_points_to.push_back(pnt_to);
}
}
}
else
{
status = VX_FAILURE;
}
status |= vxCommitArrayRange(def_pnts, 0, points_num, def_buff);
status |= vxCommitArrayRange(moved_pnts, 0, points_num, moved_buff);
VX_PRINT(VX_ZONE_LOG, "Number of points = (%d)!\n", cv_points_from.size());
/*** CV find homography ***/
cv::Mat_<float> cv_matr = cv::Mat::eye(3, 3, CV_32FC1);
if(cv_points_from.size() > 0 && cv_points_to.size() > 0)
cv_matr = cv::findHomography(cv_points_from, cv_points_to, CV_RANSAC);
else
VX_PRINT(VX_ZONE_WARNING, "Number of points is equal to zero!\n");
vx_float32 matr_buff[9];
status |= vxAccessMatrix(matrix, (void*)matr_buff);
memcpy(matr_buff, cv_matr.data, sizeof(vx_float32) * 9);
status |= vxCommitMatrix(matrix, (void*)matr_buff);
return status;
}
int CVxParamArray::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
// save reference object and get object attributes
m_vxObjRef = ref;
m_array = (vx_array)m_vxObjRef;
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_ITEMTYPE, &m_format, sizeof(m_format)));
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_CAPACITY, &m_capacity, sizeof(m_capacity)));
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_ITEMSIZE, &m_itemSize, sizeof(m_itemSize)));
// process I/O parameters
if (*io_params == ':') io_params++;
while (*io_params) {
char ioType[64], fileName[256];
io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
if (!_stricmp(ioType, "read"))
{ // read request syntax: read,<fileName>[,ascii|binary]
m_fileNameRead.assign(RootDirUpdated(fileName));
m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_readFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_readFileIsBinary = true;
}
else ReportError("ERROR: invalid array read option: %s\n", option);
}
}
else if (!_stricmp(ioType, "write"))
{ // write request syntax: write,<fileName>[,ascii|binary]
m_fileNameWrite.assign(RootDirUpdated(fileName));
m_writeFileIsBinary = (m_fileNameWrite.find(".txt") != m_fileNameWrite.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_writeFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_writeFileIsBinary = true;
}
else ReportError("ERROR: invalid array write option: %s\n", option);
}
}
else if (!_stricmp(ioType, "compare"))
{ // compare syntax: compare,fileName[,ascii|binary][,err{<x>;<y>[;<strength>][;<%mismatch>]}][,log{<fileName>}]
m_fileNameCompareLog = "";
m_fileNameCompare.assign(RootDirUpdated(fileName));
m_compareFileIsBinary = (m_fileNameCompare.find(".txt") != m_fileNameCompare.npos) ? false : true;
while (*io_params == ',') {
char option[256];
io_params = ScanParameters(io_params, ",ascii|binary|err{<x>;<y>[;<strength>][;<%mismatch>]}|log{<fileName>}", ",S", option);
if (!_stricmp(option, "ascii")) {
m_compareFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_compareFileIsBinary = true;
}
else if (!_strnicmp(option, "err{", 4)) {
if (m_format == VX_TYPE_KEYPOINT) {
const char * p = ScanParameters(&option[3], "{<x>;<y>;<strength>[;<%mismatch>]}", "{d;d;f", &m_errX, &m_errY, &m_errStrength);
if (*p == ';') {
ScanParameters(p, ";<%mismatch>}", ";f}", &m_errMismatchPercent);
}
}
else if (m_format == VX_TYPE_COORDINATES2D) {
const char * p = ScanParameters(&option[3], "{<x>;<y>[;<%mismatch>]}", "{d;d", &m_errX, &m_errY);
if (*p == ';') {
ScanParameters(p, ";<%mismatch>}", ";f}", &m_errMismatchPercent);
}
}
else ReportError("ERROR: array compare option not supported for this array: %s\n", option);
}
else if (!_strnicmp(option, "log{", 4)) {
option[strlen(option) - 1] = 0;
m_fileNameCompareLog.assign(RootDirUpdated(&option[4]));
}
else ReportError("ERROR: invalid array compare option: %s\n", option);
}
}
else if (!_stricmp(ioType, "view")) {
m_displayName.assign(fileName);
m_paramList.push_back(this);
}
else if (!_stricmp(ioType, "directive") && (!_stricmp(fileName, "VX_DIRECTIVE_AMD_COPY_TO_OPENCL") || !_stricmp(fileName, "sync-cl-write"))) {
m_useSyncOpenCLWriteDirective = true;
}
else if (!_stricmp(ioType, "init")) {
m_fileNameRead.assign(RootDirUpdated(fileName));
m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_readFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_readFileIsBinary = true;
}
else ReportError("ERROR: invalid array init option: %s\n", option);
}
if (ReadFrame(0) < 0)
ReportError("ERROR: reading from input file for array init\n");
}
else ReportError("ERROR: invalid array operation: %s\n", ioType);
if (*io_params == ':') io_params++;
else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
}
return 0;
}
int CVxParamArray::WriteFrame(int frameNumber)
{
// check if user specified file to write
if (m_fileNameWrite.length() < 1) return 0;
// create the output file
char fileName[MAX_FILE_NAME_LENGTH]; sprintf(fileName, m_fileNameWrite.c_str(), frameNumber);
FILE * fp = fopen(fileName, m_writeFileIsBinary ? "wb" : "w");
if(!fp) ReportError("ERROR: Unable to create: %s\n", fileName);
// get numItems and write if any items exist
vx_size numItems;
ERROR_CHECK(vxQueryArray(m_array, VX_ARRAY_ATTRIBUTE_NUMITEMS, &numItems, sizeof(numItems)));
if (numItems > 0) {
vx_uint8 * base = nullptr;
vx_size stride;
ERROR_CHECK(vxAccessArrayRange(m_array, 0, numItems, &stride, (void **)&base, VX_READ_ONLY));
if (m_writeFileIsBinary)
{ // write in binary
for (size_t i = 0; i < numItems; i++) {
vx_uint8 * item = vxFormatArrayPointer(base, i, stride);
fwrite(item, 1, m_itemSize, fp);
}
}
else
{ // write in ASCII mode
if (m_format == VX_TYPE_KEYPOINT) {
for (size_t i = 0; i < numItems; i++) {
vx_keypoint_t * item = (vx_keypoint_t *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%4d %4d %20.12e %20.12e %20.12e %d %20.12e\n", item->x, item->y, item->strength, item->scale, item->orientation, item->tracking_status, item->error);
}
}
else if (m_format == VX_TYPE_COORDINATES2D) {
for (size_t i = 0; i < numItems; i++) {
vx_coordinates2d_t * item = (vx_coordinates2d_t *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%4d %4d\n", item->x, item->y);
}
}
else if (m_format == VX_TYPE_COORDINATES3D) {
for (size_t i = 0; i < numItems; i++) {
vx_coordinates3d_t * item = (vx_coordinates3d_t *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%4d %4d %4d\n", item->x, item->y, item->z);
}
}
else if (m_format == VX_TYPE_RECTANGLE) {
for (size_t i = 0; i < numItems; i++) {
vx_rectangle_t * item = (vx_rectangle_t *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%4d %4d %4d %4d\n", item->start_x, item->start_y, item->end_x, item->end_y);
}
}
else if (m_format == VX_TYPE_INT32 || m_format == VX_TYPE_BOOL) {
for (size_t i = 0; i < numItems; i++) {
vx_int32 * item = (vx_int32 *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%d\n", *item);
}
}
else if (m_format == VX_TYPE_UINT32) {
for (size_t i = 0; i < numItems; i++) {
vx_uint32 * item = (vx_uint32 *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%u\n", *item);
}
}
else if (m_format == VX_TYPE_FLOAT32) {
for (size_t i = 0; i < numItems; i++) {
vx_float32 * item = (vx_float32 *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%.12g\n", *item);
}
}
else if (m_format == VX_TYPE_FLOAT64) {
for (size_t i = 0; i < numItems; i++) {
vx_float64 * item = (vx_float64 *)vxFormatArrayPointer(base, i, stride);
fprintf(fp, "%.12lg\n", *item);
}
}
else {
// write output as hex values
for (size_t i = 0; i < numItems; i++) {
vx_uint8 * item = vxFormatArrayPointer(base, i, stride);
for (size_t j = 0; j < m_itemSize; j++)
fprintf(fp, " %02X", item[j]);
fprintf(fp, "\n");
}
}
}
ERROR_CHECK(vxCommitArrayRange(m_array, 0, numItems, base));
}
fclose(fp);
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;
}
