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