bool updateMat(const MatT& new_mat, MatT& my_mat, cv::Mat_<double>& cv_mat, int rows, int cols)
{
if ((my_mat == new_mat) && (my_mat.size() == cv_mat.rows*cv_mat.cols))
return false;
my_mat = new_mat;
// D may be empty if camera is uncalibrated or distortion model is non-standard
cv_mat = (my_mat.size() == 0) ? cv::Mat_<double>() : cv::Mat_<double>(rows, cols, &my_mat[0]);
return true;
}
void mod_size( MatT& A, unsigned r, unsigned c, unsigned s ) {
A.resize( r, c, s );
A.randn( r, c, s );
for( unsigned i=0; i<r; i++ ) {
for( unsigned j=0; j<c; j++ ) {
for( unsigned k=0; k<s; k++ ) {
A(i,j,k) = (typename MatT::elem_type)(i*100+j*10+k);
}
}
}
};
static void PointsToMat(
const IntrinsicBase * cam,
const PointFeatures & vec_feats,
MatT & m)
{
m.resize(2, vec_feats.size());
typedef typename MatT::Scalar Scalar; // Output matrix type
size_t i = 0;
for( PointFeatures::const_iterator iter = vec_feats.begin();
iter != vec_feats.end(); ++iter, ++i)
{
m.col(i) = cam->get_ud_pixel(Vec2(iter->x(), iter->y()));
}
}
bool updateMat(const MatT& new_mat, MatT& my_mat, MatU& cv_mat)
{
if ((my_mat == new_mat) && (my_mat.size() == cv_mat.rows*cv_mat.cols))
return false;
my_mat = new_mat;
// D may be empty if camera is uncalibrated or distortion model is non-standard
cv_mat = MatU(&my_mat[0]);
return true;
}
void benchmarkMultiplyDevice(MatT& A) {
// If we multiply a vector of 1s we should see our result equal 0 (if our
// RBF-FD weights are good)
std::vector<double> x_host(A.size1(), 1);
viennacl::vector<double> x(A.size1());
viennacl::copy(x_host.begin(), x_host.end(), x.begin());
viennacl::vector<double> b(A.size1());
b = viennacl::linalg::prod(A, x);
#if 0
std::vector<double> b_host(A.size1(), 1);
viennacl::copy(b.begin(), b.end(), b_host.begin());
#endif
//viennacl::ocl::current_context().get_queue().finish();
std::cout << "l1 Norm: " << viennacl::linalg::norm_1(b) << std::endl;
std::cout << "l2 Norm: " << viennacl::linalg::norm_2(b) << std::endl;
std::cout << "linf Norm: " << viennacl::linalg::norm_inf(b) << std::endl;
}
void benchmarkMultiplyHost(MatT& A) {
// If we multiply a vector of 1s we should see our result equal 0 (if our
// RBF-FD weights are good)
std::vector<double> x(A.size(), 1);
std::vector<double> b(A.size(), 1);
b = viennacl::linalg::prod(A, x);
std::cout << "l1 Norm: " << viennacl::linalg::norm_1(b) << std::endl;
std::cout << "l2 Norm: " << viennacl::linalg::norm_2(b) << std::endl;
std::cout << "linf Norm: " << viennacl::linalg::norm_inf(b) << std::endl;
}
void MatchesPointsToMat
(
const matching::IndMatches & putativeMatches,
const cameras::IntrinsicBase * cam_I,
const features::PointFeatures & feature_I,
const cameras::IntrinsicBase * cam_J,
const features::PointFeatures & feature_J,
MatT & x_I, MatT & x_J
)
{
const size_t n = putativeMatches.size();
x_I.resize(2, n);
x_J.resize(2, n);
typedef typename MatT::Scalar Scalar; // Output matrix type
for (size_t i=0; i < putativeMatches.size(); ++i) {
const features::PointFeature & pt_I = feature_I[putativeMatches[i].i_];
const features::PointFeature & pt_J = feature_J[putativeMatches[i].j_];
if (cam_I)
x_I.col(i) = cam_I->get_ud_pixel(pt_I.coords().cast<double>());
else
x_I.col(i) = pt_I.coords().cast<double>();
if (cam_J)
x_J.col(i) = cam_J->get_ud_pixel(pt_J.coords().cast<double>());
else
x_J.col(i) = pt_J.coords().cast<double>();
}
}
void mod_content( MatT& A ) {
A.randn( A.n_rows, A.n_cols, A.n_slices );
A.fill(25);
A(0,0,0)=0;
};
