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; }