vx_status vxMatrixInverse(vx_matrix input, vx_matrix output) { vx_size ci, co; vx_size ri, ro; vx_enum ti, to; vx_status status = VX_SUCCESS; status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_COLUMNS, &ci, sizeof(ci)); status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_ROWS, &ri, sizeof(ri)); status |= vxQueryMatrix(input, VX_MATRIX_ATTRIBUTE_TYPE, &ti, sizeof(ti)); status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_COLUMNS, &co, sizeof(co)); status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_ROWS, &ro, sizeof(ro)); status |= vxQueryMatrix(output, VX_MATRIX_ATTRIBUTE_TYPE, &to, sizeof(to)); if (status != VX_SUCCESS) return status; if (ci != co || ri != ro || ci != ri) return VX_ERROR_INVALID_DIMENSION; if (ti != to) return VX_ERROR_INVALID_TYPE; if (ti == VX_TYPE_FLOAT32) { vx_float32 in[ri][ci]; vx_float32 ou[ro][co]; vxAccessMatrix(input, in); vxAccessMatrix(output, NULL); vxh_matrix_inverse_f32(ci, ri, ou, in); vxCommitMatrix(output, ou); vxCommitMatrix(input, NULL); } /*! \bug implement integer */ return status; }
static vx_status ModifyMatrix(vx_matrix in_matr, vx_matrix out_matr, vx_uint32 width, vx_uint32 height, vx_float32 scale) { vx_rectangle_t rect = { 0, 0, width, height}; vx_uint32 w_mod = (width * (1 - scale)) / 2.; vx_uint32 h_mod = (height * (1 - scale)) / 2.; vx_coordinates2d_t srect[4] = { {w_mod, h_mod}, {width - w_mod, h_mod}, {width - w_mod, height - h_mod}, {w_mod, height - h_mod}}; vx_float32 m[9]; vx_float32 res[9]; vx_float32 inv[9]; vxAccessMatrix(in_matr, m); vxAccessMatrix(out_matr, res); // invert cv::Mat_<float> cv_matr(3, 3), cv_inv(3, 3); memcpy(cv_matr.data, m, sizeof(vx_float32) * 9); cv_inv = cv_matr.inv(); memcpy(inv, cv_inv.data,sizeof(vx_float32) * 9); // check need modify bool do_modify = !CheckRectArea(srect, rect, inv); if(do_modify) { vx_float32 left = 0., right = 1.; cv::Mat_<float> cv_eye = cv::Mat::eye(3, 3, CV_32FC1); cv::Mat_<float> cv_res(3, 3); while(right - left > ACCURACY) { vx_float32 alpha = (left + right) / 2.; cv_res = alpha * cv_matr + (1. - alpha) * cv_eye; cv_inv = cv_res.inv(); bool check = CheckRectArea(srect, rect, (vx_float32*)cv_inv.data); if(check) left = alpha; else right = alpha; } memcpy(res, cv_res.data, sizeof(vx_float32) * 9); } else { memcpy(res, m, sizeof(vx_float32) * 9); } vxCommitMatrix(in_matr, m); vxCommitMatrix(out_matr, res); return VX_SUCCESS; }
vx_status vxMatrixTrace(vx_matrix matrix, vx_scalar trace) { vx_size columns = 0u; vx_size rows = 0u; vx_status status = VX_SUCCESS; vx_enum mtype = VX_TYPE_INVALID, stype = VX_TYPE_INVALID; status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns)); status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows)); status |= vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &mtype, sizeof(mtype)); status |= vxQueryScalar(trace, VX_SCALAR_ATTRIBUTE_TYPE, &stype, sizeof(stype)); if (status != VX_SUCCESS) return VX_ERROR_INVALID_REFERENCE; if (mtype == VX_TYPE_INVALID || mtype != stype) return VX_ERROR_INVALID_TYPE; if (columns == 0 || columns != rows) return VX_ERROR_INVALID_DIMENSION; if (stype == VX_TYPE_INT32) { vx_int32 mat[rows][columns]; vx_int32 t = 0; status |= vxAccessScalarValue(trace, NULL); status |= vxAccessMatrix(matrix, mat); t = vxh_matrix_trace_i32(columns, rows, mat); status |= vxCommitMatrix(matrix, NULL); status |= vxCommitScalarValue(trace, &t); } else if (stype == VX_TYPE_FLOAT32) { vx_float32 mat[rows][columns]; vx_float32 t = 0.0f; status |= vxAccessScalarValue(trace, NULL); status |= vxAccessMatrix(matrix, mat); t = vxh_matrix_trace_f32(columns, rows, mat); status |= vxCommitMatrix(matrix, NULL); status |= vxCommitScalarValue(trace, &t); } return status; }
vx_status vx_example_warp_affine(vx_context context, vx_image src, vx_image dst) { vx_float32 a = 1.0f, b = 0.0f, c = 0.0f, d = 1.0f, e = 0.0f , f = 0.0f; //! [warp affine] // x0 = a x + b y + c; // y0 = d x + e y + f; vx_float32 mat[3][2] = { {a, d}, // 'x' coefficients {b, e}, // 'y' coefficients {c, f}, // 'offsets' }; vx_matrix matrix = vxCreateMatrix(context, VX_TYPE_FLOAT32, 2, 3); vxAccessMatrix(matrix, NULL); vxCommitMatrix(matrix, mat); //! [warp affine] return vxuWarpAffine(context, src, matrix, VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR, dst); }
vx_status vx_example_warp_perspective(vx_context context, vx_image src, vx_image dst) { vx_float32 a = 1.0f, b = 0.0f, c = 0.0f, d = 1.0f, e = 0.0f, f = 0.0f, g = 1.0f, h = 0.0f, i = 0.0f; //! [warp perspective] // x0 = a x + b y + c; // y0 = d x + e y + f; // z0 = g x + h y + i; vx_float32 mat[3][3] = { {a, d, g}, // 'x' coefficients {b, e, h}, // 'y' coefficients {c, f, i}, // 'offsets' }; vx_matrix matrix = vxCreateMatrix(context, VX_TYPE_FLOAT32, 3, 3); vxAccessMatrix(matrix, NULL); vxCommitMatrix(matrix, mat); //! [warp perspective] return vxuWarpPerspective(context, src, matrix, VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR, dst); }
vx_status vxSetAffineRotationMatrix(vx_matrix matrix, vx_float32 angle, vx_float32 scale, vx_float32 center_x, vx_float32 center_y) { vx_status status = VX_FAILURE; vx_float32 mat[3][2]; vx_size columns = 0ul, rows = 0ul; vx_enum type = 0; vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_COLUMNS, &columns, sizeof(columns)); vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_ROWS, &rows, sizeof(rows)); vxQueryMatrix(matrix, VX_MATRIX_ATTRIBUTE_TYPE, &type, sizeof(type)); if ((columns == 2) && (rows == 3) && (type == VX_TYPE_FLOAT32)) { status = vxAccessMatrix(matrix, mat); if (status == VX_SUCCESS) { vx_float32 radians = (angle / 360.0f) * (VX_TAU); vx_float32 a = scale * cos(radians); vx_float32 b = scale * sin(radians); mat[0][0] = a; mat[1][0] = b; mat[2][0] = ((1.0f - a) * center_x) - (b * center_y); mat[0][1] = -b; mat[1][1] = a; mat[2][1] = (b * center_y) + ((1.0f - a) * center_y); status = vxCommitMatrix(matrix, mat); } } else { vxAddLogEntry(matrix, status, "Failed to set affine matrix due to type or dimension mismatch!\n"); } 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; }