string query_look() {
string str;
int m = sizeof(m_indices(signator));
int n = sizeof(m_indices(locations));
str = desc::query_look() + "\n";
if (pages) {
str += "It has " + pages + " pages";
if (m)
str += " and has been signed by " + comma_list( map(m_indices(signator), (: capitalize($1) :)) ) + ".";
else
str += ".";
} else {
/*
* call-seq:
*
*
* From: https://code.ros.org/trac/opencv/browser/trunk/opencv/samples/c/find_obj.cpp?rev=2065
*/
VALUE
rb_flann(VALUE klass, VALUE objectDesc, VALUE imageDesc)
{
const cv::Mat m_object(CVMAT(objectDesc));
const cv::Mat m_image(CVMAT(imageDesc));
cv::Mat m_indices(m_object.rows, 2, CV_32S);
cv::Mat m_dists(m_object.rows, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64)); // maximum number of leafs checked
VALUE ptpairs = rb_ary_new();
int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i = 0; i < m_indices.rows; ++i) {
if (dists_ptr[2 * i] < 0.6 * dists_ptr[2 * i + 1]) {
rb_ary_push(ptpairs, rb_int_new(i));
rb_ary_push(ptpairs, rb_int_new(indices_ptr[2 * i]));
}
}
return ptpairs;
}
float knn(Mat& m_destinations, Mat& m_object, vector<int>& ptpairs, vector<float>& dists)
{
// find nearest neighbors using FLANN
cv::Mat m_indices(m_object.rows, 1, CV_32S);
cv::Mat m_dists(m_object.rows, 1, CV_32F);
Mat dest_32f; m_destinations.convertTo(dest_32f,CV_32FC2);
Mat obj_32f; m_object.convertTo(obj_32f,CV_32FC2);
assert(dest_32f.type() == CV_32F);
//cout << "h" << endl;
cv::flann::Index flann_index(dest_32f, cv::flann::KDTreeIndexParams(2)); // using 2 randomized kdtrees
flann_index.knnSearch(obj_32f, m_indices, m_dists, 1, cv::flann::SearchParams(64) );
//cout << "p" << endl;
int* indices_ptr = m_indices.ptr<int>(0);
//float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i) {
ptpairs.push_back(indices_ptr[i]);
}
dists.resize(m_dists.rows);
m_dists.copyTo(Mat(dists));
return cv::sum(m_dists)[0];
}
mixed *
vspaces()
{
if(!mappingp(variables))
return 0;
return m_indices(variables);
}
int print_access(string bit, mapping bing, int depth, int cols) {
mixed *bits;
int i;
if (this_player() != this_player(1))
return 0;
bits = m_indices(bing);
if (depth == 4) {
/* Do the ident printing... */
for (i=0;i<sizeof(bits);i++)
switch (bing[bits[i]]) {
case NO_NEW :
printf("%s@%-=*s", bits[i], cols - strlen(bits[i]), bit +
" set to no new characters.\n");
break;
case NO_ACCESS :
printf("%s@%-=*s", bits[i], cols - strlen(bits[i]), bit +
" set to no characters.\n");
break;
case ACCESS :
printf("%s@%-=*s", bits[i], cols - strlen(bits[i]), bit +
" set to normal access.\n");
break;
}
return 1;
}
for (i=0;i<sizeof(bits);i++)
print_access(bit+"."+bits[i], bing[bits[i]], depth+1, cols);
return 1;
} /* print_access() */
int Index::radiusSearch(const vector<float>& query, vector<int>& indices, vector<float>& dists, float radius, const SearchParams& searchParams)
{
::cvflann::Matrix<float> m_query(1, query.size(), (float*)&query[0]);
::cvflann::Matrix<int> m_indices(1, indices.size(), &indices[0]);
::cvflann::Matrix<float> m_dists(1, dists.size(), &dists[0]);
return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,::cvflann::SearchParams(searchParams.checks));
}
void Index::knnSearch(const vector<float>& query, vector<int>& indices, vector<float>& dists, int knn, const SearchParams& searchParams)
{
::cvflann::Matrix<float> m_query(1, query.size(), (float*)&query[0]);
::cvflann::Matrix<int> m_indices(1, indices.size(), &indices[0]);
::cvflann::Matrix<float> m_dists(1, dists.size(), &dists[0]);
nnIndex->knnSearch(m_query,m_indices,m_dists,knn,::cvflann::SearchParams(searchParams.checks));
}
void FlannMatcher::getMatches(pcl::PointCloud<pcl::PointXYZRGB>::Ptr& pc1,
pcl::PointCloud<pcl::PointXYZRGB>::Ptr& pc2,
cv::Mat& rgb1,cv::Mat& rgb2,
std::vector<cv::DMatch>& matches,
vector<cv::KeyPoint>& keypoints1,
vector<cv::KeyPoint>& keypoints2)
{
//vector<cv::KeyPoint> keypoints1,keypoints2;
cv::Mat desp1,desp2;
vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > eigenPoint1,eigenPoint2;
detector->detect(rgb1,keypoints1);
detector->detect(rgb2,keypoints2);
projectTo3D(keypoints1,pc1,eigenPoint1);
projectTo3D(keypoints2,pc2,eigenPoint2);
//extract descriptors
extractor->compute(rgb1,keypoints1,desp1);
extractor->compute(rgb2,keypoints2,desp2);
cout<<"descriptors size is: "<<desp1.rows<<" "<<desp2.rows<<endl;
//flann match
cv::Mat m_indices(desp1.rows,2,CV_32S);
cv::Mat m_dists(desp1.rows,2,CV_32S);
cv::flann::Index flann_index(desp2,cv::flann::KDTreeIndexParams(4));
flann_index.knnSearch(desp1,m_indices,m_dists,2,cv::flann::SearchParams(64));
int* indices_ptr=m_indices.ptr<int>(0);
float* dists_ptr=m_dists.ptr<float>(0);
cv::DMatch match;
//vector<cv::DMatch> matches;
for (int i=0;i<m_indices.rows;++i) {
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1]) {
match.queryIdx=i;
match.trainIdx=indices_ptr[ 2*i ];
match.distance=dists_ptr[ 2*i ];
matches.push_back(match);
}
}
cout<<"matches size is: "<<matches.size()<<endl;
cout<<"keypoints1 size is: "<<keypoints1.size()<<endl;
cout<<"keypoints2 size is: "<<keypoints2.size()<<endl;
/*
//draw matches
cv::Mat img_matches;
cv::drawMatches(rgb1,keypoints1,rgb2,keypoints2,
matches,img_matches);
cv::imshow("test matches",img_matches);
*/
}
add_property(arg1,arg2) {
mapping map;
int i,size;
if (mappingp(arg1)) {
prop += arg1;
map=arg1;
arg1=m_indices(map);
arg2=m_values(map);
for(i=0,size = sizeof(arg1);i<size;i++)
map_array("/obj/daemon/propd"->give_me_links(arg1[i]),"add_property",this_object(),arg2[i]);
return;
}
if (!arg2)
arg2 = 1;
if (stringp(arg1)) {
map_array("/obj/daemon/propd"->give_me_links(arg1),"add_property",this_object(),arg2);
prop[arg1] = arg2;
return;
}
if (pointerp(arg1))
if (pointerp(arg2))
{
map = mkmapping(arg1,arg2);
prop+=map;
arg1=m_indices(map);
arg2=m_values(map);
for(i=0,size = sizeof(arg1);i<size;i++)
map_array("/obj/daemon/propd"->give_me_links(arg1[i]),"add_property",this_object(),arg2[i]);
}
else
{
for(i=0,size = sizeof(arg1);i<size;i++) {
prop[arg1[i]] = arg2;
map_array("/obj/daemon/propd"->give_me_links(arg1[i]),"add_property",this_object(),arg2);
}
}
}
int Index::radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& searchParams)
{
CV_Assert(query.type() == CV_32F);
CV_Assert(query.isContinuous());
::cvflann::Matrix<float> m_query(query.rows, query.cols, (float*)query.ptr<float>(0));
CV_Assert(indices.type() == CV_32S);
CV_Assert(indices.isContinuous());
::cvflann::Matrix<int> m_indices(indices.rows, indices.cols, (int*)indices.ptr<int>(0));
CV_Assert(dists.type() == CV_32F);
CV_Assert(dists.isContinuous());
::cvflann::Matrix<float> m_dists(dists.rows, dists.cols, (float*)dists.ptr<float>(0));
return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,::cvflann::SearchParams(searchParams.checks));
}
void
flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,
const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int length = (int)(objectDescriptors->elem_size/sizeof(float));
cv::Mat m_object(objectDescriptors->total, length, CV_32F);
cv::Mat m_image(imageDescriptors->total, length, CV_32F);
// copy descriptors
CvSeqReader obj_reader;
float* obj_ptr = m_object.ptr<float>(0);
cvStartReadSeq( objectDescriptors, &obj_reader );
for(int i = 0; i < objectDescriptors->total; i++ )
{
const float* descriptor = (const float*)obj_reader.ptr;
CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );
memcpy(obj_ptr, descriptor, length*sizeof(float));
obj_ptr += length;
}
CvSeqReader img_reader;
float* img_ptr = m_image.ptr<float>(0);
cvStartReadSeq( imageDescriptors, &img_reader );
for(int i = 0; i < imageDescriptors->total; i++ )
{
const float* descriptor = (const float*)img_reader.ptr;
CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );
memcpy(img_ptr, descriptor, length*sizeof(float));
img_ptr += length;
}
// find nearest neighbors using FLANN
cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);
cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked
int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i) {
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1]) {
ptpairs.push_back(i);
ptpairs.push_back(indices_ptr[2*i]);
}
}
}
/* lists all of the players skills.
* giving levels (default) or bonuses
*/
string rec_list(mapping sks, string path, int all, int lvl, int n_rec) {
int i, sk;
string str, tp;
string *sks_i;
str = "";
sks_i = m_indices(sks);
for (i=0; i<sizeof(sks_i); i++) {
tp = path + "." + sks_i[i];
sk = (int)this_player()->query_skill(tp);
str += sprintf("%*'| 's%*'.'-s %4d %4d\n", (lvl-1)*2, "", 20-((lvl-1)*2),
sks_i[i], sk, (int)this_player()->query_skill_bonus(tp));
if (sizeof(sks[sks_i[i]][SKILL_BIT]) && (all || sk > 5*lvl) && !n_rec)
str += rec_list(sks[sks_i[i]][SKILL_BIT], tp, all, lvl+1, 1);
}
return str;
} /* rec_list() */
void Index::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams)
{
CV_Assert(queries.type() == CV_32F);
CV_Assert(queries.isContinuous());
::cvflann::Matrix<float> m_queries(queries.rows, queries.cols, (float*)queries.ptr<float>(0));
CV_Assert(indices.type() == CV_32S);
CV_Assert(indices.isContinuous());
::cvflann::Matrix<int> m_indices(indices.rows, indices.cols, (int*)indices.ptr<int>(0));
CV_Assert(dists.type() == CV_32F);
CV_Assert(dists.isContinuous());
::cvflann::Matrix<float> m_dists(dists.rows, dists.cols, (float*)dists.ptr<float>(0));
nnIndex->knnSearch(m_queries,m_indices,m_dists,knn,::cvflann::SearchParams(searchParams.checks));
}
void FindOneWayDescriptor(cv::flann::Index* m_pca_descriptors_tree, CvSize patch_size, int m_pca_dim_low, int m_pose_count, IplImage* patch, int& desc_idx, int& pose_idx, float& distance,
CvMat* avg, CvMat* eigenvectors)
{
desc_idx = -1;
pose_idx = -1;
distance = 1e10;
//--------
//PCA_coeffs precalculating
CvMat* pca_coeffs = cvCreateMat(1, m_pca_dim_low, CV_32FC1);
int patch_width = patch_size.width;
int patch_height = patch_size.height;
//if (avg)
//{
CvRect _roi = cvGetImageROI((IplImage*)patch);
IplImage* test_img = cvCreateImage(cvSize(patch_width,patch_height), IPL_DEPTH_8U, 1);
if(_roi.width != patch_width|| _roi.height != patch_height)
{
cvResize(patch, test_img);
_roi = cvGetImageROI(test_img);
}
else
{
cvCopy(patch,test_img);
}
IplImage* patch_32f = cvCreateImage(cvSize(_roi.width, _roi.height), IPL_DEPTH_32F, 1);
float sum = cvSum(test_img).val[0];
cvConvertScale(test_img, patch_32f, 1.0f/sum);
//ProjectPCASample(patch_32f, avg, eigenvectors, pca_coeffs);
//Projecting PCA
CvMat* patch_mat = ConvertImageToMatrix(patch_32f);
CvMat* temp = cvCreateMat(1, eigenvectors->cols, CV_32FC1);
cvProjectPCA(patch_mat, avg, eigenvectors, temp);
CvMat temp1;
cvGetSubRect(temp, &temp1, cvRect(0, 0, pca_coeffs->cols, 1));
cvCopy(&temp1, pca_coeffs);
cvReleaseMat(&temp);
cvReleaseMat(&patch_mat);
//End of projecting
cvReleaseImage(&patch_32f);
cvReleaseImage(&test_img);
// }
//--------
//float* target = new float[m_pca_dim_low];
//::flann::KNNResultSet res(1,pca_coeffs->data.fl,m_pca_dim_low);
//::flann::SearchParams params;
//params.checks = -1;
//int maxDepth = 1000000;
//int neighbors_count = 1;
//int* neighborsIdx = new int[neighbors_count];
//float* distances = new float[neighbors_count];
//if (m_pca_descriptors_tree->findNearest(pca_coeffs->data.fl,neighbors_count,maxDepth,neighborsIdx,0,distances) > 0)
//{
// desc_idx = neighborsIdx[0] / m_pose_count;
// pose_idx = neighborsIdx[0] % m_pose_count;
// distance = distances[0];
//}
//delete[] neighborsIdx;
//delete[] distances;
cv::Mat m_object(1, m_pca_dim_low, CV_32F);
cv::Mat m_indices(1, 1, CV_32S);
cv::Mat m_dists(1, 1, CV_32F);
float* object_ptr = m_object.ptr<float>(0);
for (int i=0;i<m_pca_dim_low;i++)
{
object_ptr[i] = pca_coeffs->data.fl[i];
}
m_pca_descriptors_tree->knnSearch(m_object, m_indices, m_dists, 1, cv::flann::SearchParams(-1) );
desc_idx = ((int*)(m_indices.ptr<int>(0)))[0] / m_pose_count;
pose_idx = ((int*)(m_indices.ptr<int>(0)))[0] % m_pose_count;
distance = ((float*)(m_dists.ptr<float>(0)))[0];
// delete[] target;
// for(int i = 0; i < desc_count; i++)
// {
// int _pose_idx = -1;
// float _distance = 0;
//
//#if 0
// descriptors[i].EstimatePose(patch, _pose_idx, _distance);
//#else
// if (!avg)
// {
// descriptors[i].EstimatePosePCA(patch, _pose_idx, _distance, avg, eigenvectors);
// }
// else
// {
// descriptors[i].EstimatePosePCA(pca_coeffs, _pose_idx, _distance, avg, eigenvectors);
// }
//#endif
//
// if(_distance < distance)
// {
// desc_idx = i;
// pose_idx = _pose_idx;
// distance = _distance;
// }
// }
cvReleaseMat(&pca_coeffs);
}
