void
pcl::kinfuLS::WorldModel<PointT>::getExistingData(const double previous_origin_x, const double previous_origin_y, const double previous_origin_z, const double offset_x, const double offset_y, const double offset_z, const double volume_x, const double volume_y, const double volume_z, pcl::PointCloud<PointT> &existing_slice)
{
double newOriginX = previous_origin_x + offset_x;
double newOriginY = previous_origin_y + offset_y;
double newOriginZ = previous_origin_z + offset_z;
double newLimitX = newOriginX + volume_x;
double newLimitY = newOriginY + volume_y;
double newLimitZ = newOriginZ + volume_z;
// filter points in the space of the new cube
PointCloudPtr newCube (new pcl::PointCloud<PointT>);
// condition
ConditionAndPtr range_condAND (new pcl::ConditionAnd<PointT> ());
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("x", pcl::ComparisonOps::GE, newOriginX)));
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("x", pcl::ComparisonOps::LT, newLimitX)));
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("y", pcl::ComparisonOps::GE, newOriginY)));
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("y", pcl::ComparisonOps::LT, newLimitY)));
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("z", pcl::ComparisonOps::GE, newOriginZ)));
range_condAND->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("z", pcl::ComparisonOps::LT, newLimitZ)));
// build the filter
pcl::ConditionalRemoval<PointT> condremAND (true);
condremAND.setCondition (range_condAND);
condremAND.setInputCloud (world_);
condremAND.setKeepOrganized (false);
// apply filter
condremAND.filter (*newCube);
// filter points that belong to the new slice
ConditionOrPtr range_condOR (new pcl::ConditionOr<PointT> ());
if(offset_x >= 0)
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("x", pcl::ComparisonOps::GE, previous_origin_x + volume_x - 1.0 )));
else
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("x", pcl::ComparisonOps::LT, previous_origin_x )));
if(offset_y >= 0)
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("y", pcl::ComparisonOps::GE, previous_origin_y + volume_y - 1.0 )));
else
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("y", pcl::ComparisonOps::LT, previous_origin_y )));
if(offset_z >= 0)
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("z", pcl::ComparisonOps::GE, previous_origin_z + volume_z - 1.0 )));
else
range_condOR->addComparison (FieldComparisonConstPtr (new pcl::FieldComparison<PointT> ("z", pcl::ComparisonOps::LT, previous_origin_z )));
// build the filter
pcl::ConditionalRemoval<PointT> condrem (true);
condrem.setCondition (range_condOR);
condrem.setInputCloud (newCube);
condrem.setKeepOrganized (false);
// apply filter
condrem.filter (existing_slice);
if(existing_slice.points.size () != 0)
{
//transform the slice in new cube coordinates
Eigen::Affine3f transformation;
transformation.translation ()[0] = newOriginX;
transformation.translation ()[1] = newOriginY;
transformation.translation ()[2] = newOriginZ;
transformation.linear ().setIdentity ();
transformPointCloud (existing_slice, existing_slice, transformation.inverse ());
}
}
void SystemView::render(const Eigen::Affine3f& parentTrans)
{
if(size() == 0)
return;
Eigen::Affine3f trans = getTransform() * parentTrans;
// draw the list elements (titles, backgrounds, logos)
const float logoSizeX = logoSize().x() + LOGO_PADDING;
int logoCount = (int)(mSize.x() / logoSizeX) + 2; // how many logos we need to draw
int center = (int)(mCamOffset);
if(mEntries.size() == 1)
logoCount = 1;
// draw background extras
Eigen::Affine3f extrasTrans = trans;
int extrasCenter = (int)mExtrasCamOffset;
for(int i = extrasCenter - 1; i < extrasCenter + 2; i++)
{
int index = i;
while(index < 0)
index += mEntries.size();
while(index >= (int)mEntries.size())
index -= mEntries.size();
extrasTrans.translation() = trans.translation() + Eigen::Vector3f((i - mExtrasCamOffset) * mSize.x(), 0, 0);
Eigen::Vector2i clipRect = Eigen::Vector2i((int)((i - mExtrasCamOffset) * mSize.x()), 0);
Renderer::pushClipRect(clipRect, mSize.cast<int>());
mEntries.at(index).data.backgroundExtras->render(extrasTrans);
Renderer::popClipRect();
}
// fade extras if necessary
if(mExtrasFadeOpacity)
{
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), 0x00000000 | (unsigned char)(mExtrasFadeOpacity * 255));
}
// draw logos
float xOff = (mSize.x() - logoSize().x())/2 - (mCamOffset * logoSizeX);
float yOff = (mSize.y() - logoSize().y())/2;
// background behind the logos
Renderer::setMatrix(trans);
Renderer::drawRect(0.f, (mSize.y() - BAND_HEIGHT) / 2, mSize.x(), BAND_HEIGHT, 0xFFFFFFD8);
Eigen::Affine3f logoTrans = trans;
for(int i = center - logoCount/2; i < center + logoCount/2 + 1; i++)
{
int index = i;
while(index < 0)
index += mEntries.size();
while(index >= (int)mEntries.size())
index -= mEntries.size();
logoTrans.translation() = trans.translation() + Eigen::Vector3f(i * logoSizeX + xOff, yOff, 0);
if(index == mCursor) //scale our selection up
{
// selected
const std::shared_ptr<GuiComponent>& comp = mEntries.at(index).data.logoSelected;
comp->setOpacity(0xFF);
comp->render(logoTrans);
}else{
// not selected
const std::shared_ptr<GuiComponent>& comp = mEntries.at(index).data.logo;
comp->setOpacity(0x80);
comp->render(logoTrans);
}
}
Renderer::setMatrix(trans);
Renderer::drawRect(mSystemInfo.getPosition().x(), mSystemInfo.getPosition().y() - 1, mSize.x(), mSystemInfo.getSize().y(), 0xDDDDDD00 | (unsigned char)(mSystemInfo.getOpacity() / 255.f * 0xD8));
mSystemInfo.render(trans);
}
int main(int argc, char** argv)
{
if( argc < 2 )
{
printPrompt( argv[0] );
return -1;
}
initModule_nonfree();
// Get Input Data
ifstream file(argv[1]);
if ( !file.is_open() )
return false;
string str;
// Image Name
getline( file, str ); getline( file, str );
string image_name = str;
// Cloud Name
getline( file, str ); getline( file, str );
string cloud_name = str;
// width of images to be created.
getline( file, str ); getline( file, str );
int w = atoi(str.c_str());
// height of images to be created
getline( file, str ); getline( file, str );
int h = atoi(str.c_str());
// resolution of voxel grids
getline( file, str ); getline( file, str );
float r = atof(str.c_str());
// f (distance from pinhole)
getline( file, str ); getline( file, str );
float f = atof(str.c_str());
// thetax (initial rotation about X Axis of map)
getline( file, str ); getline( file, str );
float thetaX = atof(str.c_str());
// thetay (initial rotation about Y Axis of map)
getline( file, str ); getline( file, str );
float thetaY = atof(str.c_str());
// number of points to go to
getline( file, str ); getline( file, str );
float nop = atoi(str.c_str());
// Number of divisions
getline( file, str ); getline( file, str );
float divs = atoi(str.c_str());
// Number of images to return
getline( file, str ); getline( file, str );
int numtoreturn = atoi(str.c_str());
// Should we load or create photos?
getline( file, str ); getline( file, str );
string lorc =str.c_str();
// Directory to look for photos
getline( file, str ); getline( file, str );
string dir =str.c_str();
// Directory to look for kp and descriptors
getline( file, str ); getline( file, str );
string kdir =str.c_str();
// save photos?
getline( file, str ); getline( file, str );
string savePhotos =str.c_str();
file.close();
// Done Getting Input Data
map<vector<float>, Mat> imagemap;
map<vector<float>, Mat> surfmap;
map<vector<float>, Mat> siftmap;
map<vector<float>, Mat> orbmap;
map<vector<float>, Mat> fastmap;
imagemap.clear();
vector<KeyPoint> SurfKeypoints;
vector<KeyPoint> SiftKeypoints;
vector<KeyPoint> OrbKeypoints;
vector<KeyPoint> FastKeypoints;
Mat SurfDescriptors;
Mat SiftDescriptors;
Mat OrbDescriptors;
Mat FastDescriptors;
int minHessian = 300;
SurfFeatureDetector SurfDetector (minHessian);
SiftFeatureDetector SiftDetector (minHessian);
OrbFeatureDetector OrbDetector (minHessian);
FastFeatureDetector FastDetector (minHessian);
SurfDescriptorExtractor SurfExtractor;
SiftDescriptorExtractor SiftExtractor;
OrbDescriptorExtractor OrbExtractor;
if ( !fs::exists( dir ) || lorc == "c" )
{ // Load Point Cloud and render images
PointCloud<PT>::Ptr cloud (new pcl::PointCloud<PT>);
io::loadPCDFile<PT>(cloud_name, *cloud);
Eigen::Affine3f tf = Eigen::Affine3f::Identity();
tf.rotate (Eigen::AngleAxisf (thetaX, Eigen::Vector3f::UnitX()));
pcl::transformPointCloud (*cloud, *cloud, tf);
tf = Eigen::Affine3f::Identity();
tf.rotate (Eigen::AngleAxisf (thetaY, Eigen::Vector3f::UnitY()));
pcl::transformPointCloud (*cloud, *cloud, tf);
// Create images from point cloud
imagemap = render::createImages(cloud, nop, w, h, r, f);
if (savePhotos == "y")
{
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
// Create image name and storagename
string imfn = dir + "/";
string kpfn = kdir + "/";
for (int j = 0; j < i->first.size(); j++)
{
imfn += boost::to_string(i->first[j]) + " ";
kpfn += boost::to_string(i->first[j]) + " ";
}
imfn += ".jpg";
imwrite(imfn, i->second);
// Detect keypoints, add to keypoint map. Same with descriptors
SurfDetector.detect(i->second, SurfKeypoints);
SiftDetector.detect(i->second, SiftKeypoints);
OrbDetector.detect(i->second, OrbKeypoints);
FastDetector.detect(i->second, FastKeypoints);
SurfExtractor.compute(i->second, SurfKeypoints, SurfDescriptors);
SiftExtractor.compute(i->second, SiftKeypoints, SiftDescriptors);
OrbExtractor.compute(i->second, OrbKeypoints, OrbDescriptors);
SiftExtractor.compute(i->second, FastKeypoints, FastDescriptors);
// Store KP and Descriptors in yaml file.
kpfn += ".yml";
FileStorage store(kpfn, cv::FileStorage::WRITE);
write(store,"SurfKeypoints",SurfKeypoints);
write(store,"SiftKeypoints",SiftKeypoints);
write(store,"OrbKeypoints", OrbKeypoints);
write(store,"FastKeypoints",FastKeypoints);
write(store,"SurfDescriptors",SurfDescriptors);
write(store,"SiftDescriptors",SiftDescriptors);
write(store,"OrbDescriptors", OrbDescriptors);
write(store,"FastDescriptors",FastDescriptors);
store.release();
surfmap[i->first] = SurfDescriptors;
siftmap[i->first] = SiftDescriptors;
orbmap[i->first] = OrbDescriptors;
fastmap[i->first] = FastDescriptors;
}
}
}
else
{ // load images from the folder dir
// First look into the folder to get a list of filenames
vector<fs::path> ret;
const char * pstr = dir.c_str();
fs::path p(pstr);
get_all(pstr, ret);
for (int i = 0; i < ret.size(); i++)
{
// Load Image via filename
string fn = ret[i].string();
istringstream iss(fn);
vector<string> tokens;
copy(istream_iterator<string>(iss), istream_iterator<string>(), back_inserter<vector<string> >(tokens));
// Construct ID from filename
vector<float> ID;
for (int i = 0; i < 6; i++) // 6 because there are three location floats and three direction floats
ID.push_back(::atof(tokens[i].c_str()));
string imfn = dir + "/" + fn;
// Read image and add to imagemap.
Mat m = imread(imfn);
imagemap[ID] = m;
// Create Filename for loading Keypoints and descriptors
string kpfn = kdir + "/";
for (int j = 0; j < ID.size(); j++)
{
kpfn += boost::to_string(ID[j]) + " ";
}
kpfn = kpfn+ ".yml";
// Create filestorage item to read from and add to map.
FileStorage store(kpfn, cv::FileStorage::READ);
FileNode n1 = store["SurfKeypoints"];
read(n1,SurfKeypoints);
FileNode n2 = store["SiftKeypoints"];
read(n2,SiftKeypoints);
FileNode n3 = store["OrbKeypoints"];
read(n3,OrbKeypoints);
FileNode n4 = store["FastKeypoints"];
read(n4,FastKeypoints);
FileNode n5 = store["SurfDescriptors"];
read(n5,SurfDescriptors);
FileNode n6 = store["SiftDescriptors"];
read(n6,SiftDescriptors);
FileNode n7 = store["OrbDescriptors"];
read(n7,OrbDescriptors);
FileNode n8 = store["FastDescriptors"];
read(n8,FastDescriptors);
store.release();
surfmap[ID] = SurfDescriptors;
siftmap[ID] = SiftDescriptors;
orbmap[ID] = OrbDescriptors;
fastmap[ID] = FastDescriptors;
}
}
TickMeter tm;
tm.reset();
cout << "<\n Analyzing Images ..." << endl;
// We have a bunch of images, now we compute their grayscale and black and white.
map<vector<float>, Mat> gsmap;
map<vector<float>, Mat> bwmap;
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
vector<float> ID = i->first;
Mat Image = i-> second;
GaussianBlur( Image, Image, Size(5,5), 0, 0, BORDER_DEFAULT );
gsmap[ID] = averageImage::getPixSumFromImage(Image, divs);
bwmap[ID] = averageImage::aboveBelow(gsmap[ID]);
}
Mat image = imread(image_name);
Mat gsimage = averageImage::getPixSumFromImage(image, divs);
Mat bwimage = averageImage::aboveBelow(gsimage);
// cout << gsimage <<endl;
imwrite("GS.png", gsimage);
namedWindow("GSIMAGE (Line 319)");
imshow("GSIMAGE (Line 319)", gsimage);
waitKey(0);
vector<KeyPoint> imgSurfKeypoints;
vector<KeyPoint> imgSiftKeypoints;
vector<KeyPoint> imgOrbKeypoints;
vector<KeyPoint> imgFastKeypoints;
Mat imgSurfDescriptors;
Mat imgSiftDescriptors;
Mat imgOrbDescriptors;
Mat imgFastDescriptors;
SurfDetector.detect(image, imgSurfKeypoints);
SiftDetector.detect(image, imgSiftKeypoints);
OrbDetector.detect(image, imgOrbKeypoints);
FastDetector.detect(image, imgFastKeypoints);
SurfExtractor.compute(image, imgSurfKeypoints, imgSurfDescriptors);
SiftExtractor.compute(image, imgSiftKeypoints, imgSiftDescriptors);
OrbExtractor.compute(image, imgOrbKeypoints, imgOrbDescriptors);
SiftExtractor.compute(image, imgFastKeypoints, imgFastDescriptors);
tm.start();
cout << ">\n<\n Comparing Images ..." << endl;
// We have their features, now compare them!
map<vector<float>, float> gssim; // Gray Scale Similarity
map<vector<float>, float> bwsim; // Above Below Similarity
map<vector<float>, float> surfsim;
map<vector<float>, float> siftsim;
map<vector<float>, float> orbsim;
map<vector<float>, float> fastsim;
for (map<vector<float>, Mat>::iterator i = gsmap.begin(); i != gsmap.end(); ++i)
{
vector<float> ID = i->first;
gssim[ID] = similarities::getSimilarity(i->second, gsimage);
bwsim[ID] = similarities::getSimilarity(bwmap[ID], bwimage);
surfsim[ID] = similarities::compareDescriptors(surfmap[ID], imgSurfDescriptors);
siftsim[ID] = similarities::compareDescriptors(siftmap[ID], imgSiftDescriptors);
orbsim[ID] = 0;//similarities::compareDescriptors(orbmap[ID], imgOrbDescriptors);
fastsim[ID] = 0;//similarities::compareDescriptors(fastmap[ID], imgFastDescriptors);
}
map<vector<float>, int> top;
bool gotone = false;
typedef map<vector<float>, int>::iterator iter;
// Choose the best ones!
for (map<vector<float>, Mat>::iterator i = imagemap.begin(); i != imagemap.end(); ++i)
{
vector<float> ID = i->first;
int sim = /* gssim[ID] + 0.5*bwsim[ID] + */ 5*surfsim[ID] + 0.3*siftsim[ID] + orbsim[ID] + fastsim[ID];
// cout << surfsim[ID] << "\t";
// cout << siftsim[ID] << "\t";
// cout << orbsim[ID] << "\t";
// cout << fastsim[ID] << endl;
if (!gotone)
{
top[ID] = sim;
gotone = true;
}
iter it = top.begin();
iter end = top.end();
int max_value = it->second;
vector<float> max_ID = it->first;
for( ; it != end; ++it)
{
int current = it->second;
if(current > max_value)
{
max_value = it->second;
max_ID = it->first;
}
}
// cout << "Sim: " << sim << "\tmax_value: " << max_value << endl;
if (top.size() < numtoreturn)
top[ID] = sim;
else
{
if (sim < max_value)
{
top[ID] = sim;
top.erase(max_ID);
}
}
}
tm.stop();
double s = tm.getTimeSec();
cout << ">\n<\n Writing top " << numtoreturn << " images ..." << endl;
int count = 1;
namedWindow("Image");
namedWindow("Match");
namedWindow("ImageBW");
namedWindow("MatchBW");
namedWindow("ImageGS");
namedWindow("MatchGS");
imshow("Image", image);
imshow("ImageBW", bwimage);
imshow("ImageGS", gsimage);
vector<KeyPoint> currentPoints;
for (iter i = top.begin(); i != top.end(); ++i)
{
vector<float> ID = i->first;
cout << " Score: "<< i->second << "\tGrayScale: " << gssim[ID] << "\tBW: " << bwsim[ID] << " \tSURF: " << surfsim[ID] << "\tSIFT: " << siftsim[ID] << endl;
string fn = "Sim_" + boost::to_string(count) + "_" + boost::to_string(i->second) + ".png";
imwrite(fn, imagemap[ID]);
count++;
normalize(bwmap[ID], bwmap[ID], 0, 255, NORM_MINMAX, CV_64F);
normalize(gsmap[ID], gsmap[ID], 0, 255, NORM_MINMAX, CV_64F);
imshow("Match", imagemap[ID]);
imshow("MatchBW", bwmap[ID]);
imshow("MatchGS", gsmap[ID]);
waitKey(0);
}
cout << ">\nComparisons took " << s << " seconds for " << imagemap.size() << " images ("
<< (int) imagemap.size()/s << " images per second)." << endl;
return 0;
}
void simulate_callback (const pcl::visualization::KeyboardEvent &event,
void* viewer_void)
{
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
// I choose v for virtual as s for simulate is takwen
if (event.getKeySym () == "v" && event.keyDown ())
{
std::cout << "v was pressed => simulate cloud" << std::endl;
std::vector<pcl::visualization::Camera> cams;
viewer->getCameras(cams);
if (cams.size() !=1){
std::cout << "n cams not 1 exiting\n"; // for now in case ...
return;
}
// cout << "n cams: " << cams.size() << "\n";
pcl::visualization::Camera cam = cams[0];
Eigen::Affine3f pose;
pose = viewer->getViewerPose() ;
std::cout << cam.pos[0] << " "
<< cam.pos[1] << " "
<< cam.pos[2] << " p\n";
Eigen::Matrix3f m;
m =pose.rotation();
//All axies use right hand rule. x=red axis, y=green axis, z=blue axis z direction is point into the screen. z \ \ \ -----------> x | | | | | | y
cout << pose(0,0) << " " << pose(0,1) << " " << pose(0,2) << " " << pose(0,3) << " x0\n";
cout << pose(1,0) << " " << pose(1,1) << " " << pose(1,2) << " " << pose(1,3) << " x1\n";
cout << pose(2,0) << " " << pose(2,1) << " " << pose(2,2) << " " << pose(2,3)<< "x2\n";
double yaw,pitch, roll;
wRo_to_euler(m,yaw,pitch,roll);
printf("RPY: %f %f %f\n", roll*180/M_PI,pitch*180/M_PI,yaw*180/M_PI);
// matrix->GetElement(1,0);
cout << m(0,0) << " " << m(0,1) << " " << m(0,2) << " " << " x0\n";
cout << m(1,0) << " " << m(1,1) << " " << m(1,2) << " " << " x1\n";
cout << m(2,0) << " " << m(2,1) << " " << m(2,2) << " "<< "x2\n\n";
Eigen::Quaternionf rf;
rf = Eigen::Quaternionf(m);
Eigen::Quaterniond r(rf.w(),rf.x(),rf.y(),rf.z());
Eigen::Isometry3d init_pose;
init_pose.setIdentity();
init_pose.translation() << cam.pos[0], cam.pos[1], cam.pos[2];
//Eigen::Quaterniond m = euler_to_quat(-1.54, 0, 0);
init_pose.rotate(r);
//
std::stringstream ss;
print_Isometry3d(init_pose,ss);
std::cout << "init_pose: " << ss.str() << "\n";
viewer->addCoordinateSystem (1.0,pose);
double tic = getTime();
std::stringstream ss2;
ss2.precision(20);
ss2 << "simulated_pcl_" << tic << ".pcd";
capture(init_pose,ss2.str());
cout << (getTime() -tic) << " sec\n";
// these three variables determine the position and orientation of
// the camera.
// double lookat[3]; - focal location
// double eye[3]; - my location
// double up[3]; - updirection
// std::cout << view[0] << "," << view[1] << "," << view[2]
// cameras.back ().view[2] = renderer->GetActiveCamera ()->GetOrientationWXYZ()[2];
//ViewTransform->GetOrientationWXYZ();
// Superclass::OnKeyUp ();
// vtkSmartPointer<vtkCamera> cam = event.Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
// double clip[2], focal[3], pos[3], view[3];
// cam->GetClippingRange (clip);
/* cam->GetFocalPoint (focal);
cam->GetPosition (pos);
cam->GetViewUp (view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
std::cerr << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl;
*/
}
}
void Terrain::Draw(int type, const Camera& camera, const Light& light){
//Get new position of the cube and update the model view matrix
Eigen::Affine3f wMo;//object to world matrix
Eigen::Affine3f cMw;
Eigen::Affine3f proj;
glUseProgram(m_shader);
#ifdef __APPLE__
glBindVertexArrayAPPLE(m_vertexArrayObject);
#else
glBindVertexArray(m_vertexArrayObject);
#endif
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferObject);//use as current buffer
GLint world2camera = glGetUniformLocation(m_shader, "cMw");
GLint projection = glGetUniformLocation(m_shader, "proj");
GLint kAmbient = glGetUniformLocation(m_shader,"kAmbient");
GLint kDiffuse = glGetUniformLocation(m_shader,"kDiffuse");
GLint kSpecular = glGetUniformLocation(m_shader,"kSpecular");
GLint shininess = glGetUniformLocation(m_shader,"shininess");
GLint camera_position = glGetUniformLocation(m_shader, "cameraPosition");
GLint light_position = glGetUniformLocation(m_shader, "lightPosition");
//generate the Angel::Angel::Angel::matrixes
proj = Util::Perspective( camera.m_fovy, camera.m_aspect, camera.m_znear, camera.m_zfar );
cMw = camera.m_cMw;//LookAt(camera.position,camera.lookat, camera.up );
Eigen::Vector4f v4color(0.55,0.25,0.08,1.0);
Eigen::Vector4f Ambient;
Ambient = 0.3*v4color;
Eigen::Vector4f Diffuse;
Diffuse = 0.5*v4color;
Eigen::Vector4f Specular(0.3,0.3,0.3,1.0);
glUniformMatrix4fv( world2camera, 1, GL_FALSE, cMw.data() );
glUniformMatrix4fv( projection, 1, GL_FALSE, proj.data() );
glUniform4fv(kAmbient, 1, Ambient.data());
glUniform4fv(kDiffuse, 1, Diffuse.data());
glUniform4fv(kSpecular, 1, Specular.data());
glUniform4fv(camera_position, 1, camera.m_position.data());
glUniform4fv(light_position, 1, light.m_position.data());
glUniform1f(shininess, 10);
switch (type) {
case DRAW_MESH:
glUniform1i(glGetUniformLocation(m_shader, "renderType"), 1);
glDrawArrays(GL_LINES, 0, m_NTrianglePoints);
break;
case DRAW_PHONG:
glUniform1i(glGetUniformLocation(m_shader, "renderType"), 2);
glDrawArrays(GL_TRIANGLES, 0, m_NTrianglePoints);
break;
}
//draw the obstacles
for(int i = 0; i < m_obstacles.size(); i++)
{
m_obstacles[i]->Draw(type,camera, light);
}
for(int i = 0; i < m_foods.size(); i++)
{
m_foods[i]->Draw(type,camera, light);
}
//draw the obstacles
for(int i = 0; i < m_surface_objects.size(); i++)
{
m_surface_objects[i]->Draw(type,camera, light);
}
}
void keypoint_map::optimize() {
g2o::SparseOptimizer optimizer;
optimizer.setVerbose(true);
g2o::BlockSolver_6_3::LinearSolverType * linearSolver;
linearSolver = new g2o::LinearSolverCholmod<
g2o::BlockSolver_6_3::PoseMatrixType>();
g2o::BlockSolver_6_3 * solver_ptr = new g2o::BlockSolver_6_3(linearSolver);
g2o::OptimizationAlgorithmLevenberg* solver =
new g2o::OptimizationAlgorithmLevenberg(solver_ptr);
optimizer.setAlgorithm(solver);
double focal_length = intrinsics[0];
Eigen::Vector2d principal_point(intrinsics[2], intrinsics[3]);
g2o::CameraParameters * cam_params = new g2o::CameraParameters(focal_length,
principal_point, 0.);
cam_params->setId(0);
if (!optimizer.addParameter(cam_params)) {
assert(false);
}
std::cerr << camera_positions.size() << " " << keypoints3d.size() << " "
<< observations.size() << std::endl;
int vertex_id = 0, point_id = 0;
for (size_t i = 0; i < camera_positions.size(); i++) {
Eigen::Affine3f cam_world = camera_positions[i].inverse();
Eigen::Vector3d trans(cam_world.translation().cast<double>());
Eigen::Quaterniond q(cam_world.rotation().cast<double>());
g2o::SE3Quat pose(q, trans);
g2o::VertexSE3Expmap * v_se3 = new g2o::VertexSE3Expmap();
v_se3->setId(vertex_id);
if (i < 1) {
v_se3->setFixed(true);
}
v_se3->setEstimate(pose);
optimizer.addVertex(v_se3);
vertex_id++;
}
for (size_t i = 0; i < keypoints3d.size(); i++) {
g2o::VertexSBAPointXYZ * v_p = new g2o::VertexSBAPointXYZ();
v_p->setId(vertex_id + point_id);
v_p->setMarginalized(true);
v_p->setEstimate(keypoints3d[i].getVector3fMap().cast<double>());
optimizer.addVertex(v_p);
point_id++;
}
for (size_t i = 0; i < observations.size(); i++) {
g2o::EdgeProjectXYZ2UV * e = new g2o::EdgeProjectXYZ2UV();
e->setVertex(0,
dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertices().find(
vertex_id + observations[i].point_id)->second));
e->setVertex(1,
dynamic_cast<g2o::OptimizableGraph::Vertex*>(optimizer.vertices().find(
observations[i].cam_id)->second));
e->setMeasurement(observations[i].coord.cast<double>());
e->information() = Eigen::Matrix2d::Identity();
g2o::RobustKernelHuber* rk = new g2o::RobustKernelHuber;
e->setRobustKernel(rk);
e->setParameterId(0, 0);
optimizer.addEdge(e);
}
//optimizer.save("debug.txt");
optimizer.initializeOptimization();
optimizer.setVerbose(true);
std::cout << std::endl;
std::cout << "Performing full BA:" << std::endl;
optimizer.optimize(1);
std::cout << std::endl;
for (int i = 0; i < vertex_id; i++) {
g2o::HyperGraph::VertexIDMap::iterator v_it = optimizer.vertices().find(
i);
if (v_it == optimizer.vertices().end()) {
std::cerr << "Vertex " << i << " not in graph!" << std::endl;
exit(-1);
}
g2o::VertexSE3Expmap * v_c =
dynamic_cast<g2o::VertexSE3Expmap *>(v_it->second);
if (v_c == 0) {
std::cerr << "Vertex " << i << "is not a VertexSE3Expmap!"
<< std::endl;
exit(-1);
}
Eigen::Affine3f pos;
pos.fromPositionOrientationScale(
v_c->estimate().translation().cast<float>(),
v_c->estimate().rotation().cast<float>(),
Eigen::Vector3f(1, 1, 1));
camera_positions[i] = pos.inverse();
}
for (int i = 0; i < point_id; i++) {
g2o::HyperGraph::VertexIDMap::iterator v_it = optimizer.vertices().find(
vertex_id + i);
if (v_it == optimizer.vertices().end()) {
std::cerr << "Vertex " << vertex_id + i << " not in graph!"
<< std::endl;
exit(-1);
}
g2o::VertexSBAPointXYZ * v_p =
dynamic_cast<g2o::VertexSBAPointXYZ *>(v_it->second);
if (v_p == 0) {
std::cerr << "Vertex " << vertex_id + i
<< "is not a VertexSE3Expmap!" << std::endl;
exit(-1);
}
keypoints3d[i].getVector3fMap() = v_p->estimate().cast<float>();
}
}
void jsk_pcl_ros::DepthImageCreator::publish_points(const sensor_msgs::CameraInfoConstPtr& info,
const sensor_msgs::PointCloud2ConstPtr& pcloud2) {
JSK_ROS_DEBUG("DepthImageCreator::publish_points");
if (!pcloud2) return;
bool proc_cloud = true, proc_image = true, proc_disp = true;
if ( pub_cloud_.getNumSubscribers()==0 ) {
proc_cloud = false;
}
if ( pub_image_.getNumSubscribers()==0 ) {
proc_image = false;
}
if ( pub_disp_image_.getNumSubscribers()==0 ) {
proc_disp = false;
}
if( !proc_cloud && !proc_image && !proc_disp) return;
int width = info->width;
int height = info->height;
float fx = info->P[0];
float cx = info->P[2];
float tx = info->P[3];
float fy = info->P[5];
float cy = info->P[6];
Eigen::Affine3f sensorPose;
{
tf::StampedTransform transform;
if(use_fixed_transform) {
transform = fixed_transform;
} else {
try {
tf_listener_->waitForTransform(pcloud2->header.frame_id,
info->header.frame_id,
info->header.stamp,
ros::Duration(0.001));
tf_listener_->lookupTransform(pcloud2->header.frame_id,
info->header.frame_id,
info->header.stamp, transform);
}
catch ( std::runtime_error e ) {
JSK_ROS_ERROR("%s",e.what());
return;
}
}
tf::Vector3 p = transform.getOrigin();
tf::Quaternion q = transform.getRotation();
sensorPose = (Eigen::Affine3f)Eigen::Translation3f(p.getX(), p.getY(), p.getZ());
Eigen::Quaternion<float> rot(q.getW(), q.getX(), q.getY(), q.getZ());
sensorPose = sensorPose * rot;
if (tx != 0.0) {
Eigen::Affine3f trans = (Eigen::Affine3f)Eigen::Translation3f(-tx/fx , 0, 0);
sensorPose = sensorPose * trans;
}
#if 0 // debug print
JSK_ROS_INFO("%f %f %f %f %f %f %f %f %f, %f %f %f",
sensorPose(0,0), sensorPose(0,1), sensorPose(0,2),
sensorPose(1,0), sensorPose(1,1), sensorPose(1,2),
sensorPose(2,0), sensorPose(2,1), sensorPose(2,2),
sensorPose(0,3), sensorPose(1,3), sensorPose(2,3));
#endif
}
PointCloud pointCloud;
pcl::RangeImagePlanar rangeImageP;
{
// code here is dirty, some bag is in RangeImagePlanar
PointCloud tpc;
pcl::fromROSMsg(*pcloud2, tpc);
Eigen::Affine3f inv;
#if ( PCL_MAJOR_VERSION >= 1 && PCL_MINOR_VERSION >= 5 )
inv = sensorPose.inverse();
pcl::transformPointCloud< Point > (tpc, pointCloud, inv);
#else
pcl::getInverse(sensorPose, inv);
pcl::getTransformedPointCloud<PointCloud> (tpc, inv, pointCloud);
#endif
Eigen::Affine3f dummytrans;
dummytrans.setIdentity();
rangeImageP.createFromPointCloudWithFixedSize (pointCloud,
width/scale_depth, height/scale_depth,
cx/scale_depth, cy/scale_depth,
fx/scale_depth, fy/scale_depth,
dummytrans); //sensorPose);
}
cv::Mat mat(rangeImageP.height, rangeImageP.width, CV_32FC1);
float *tmpf = (float *)mat.ptr();
for(unsigned int i = 0; i < rangeImageP.height*rangeImageP.width; i++) {
tmpf[i] = rangeImageP.points[i].z;
}
if(scale_depth != 1.0) {
cv::Mat tmpmat(info->height, info->width, CV_32FC1);
cv::resize(mat, tmpmat, cv::Size(info->width, info->height)); // LINEAR
//cv::resize(mat, tmpmat, cv::Size(info->width, info->height), 0.0, 0.0, cv::INTER_NEAREST);
mat = tmpmat;
}
if (proc_image) {
sensor_msgs::Image pubimg;
pubimg.header = info->header;
pubimg.width = info->width;
pubimg.height = info->height;
pubimg.encoding = "32FC1";
pubimg.step = sizeof(float)*info->width;
pubimg.data.resize(sizeof(float)*info->width*info->height);
// publish image
memcpy(&(pubimg.data[0]), mat.ptr(), sizeof(float)*info->height*info->width);
pub_image_.publish(boost::make_shared<sensor_msgs::Image>(pubimg));
}
if(proc_cloud || proc_disp) {
// publish point cloud
pcl::RangeImagePlanar rangeImagePP;
rangeImagePP.setDepthImage ((float *)mat.ptr(),
width, height,
cx, cy, fx, fy);
#if PCL_MAJOR_VERSION == 1 && PCL_MINOR_VERSION >= 7
rangeImagePP.header = pcl_conversions::toPCL(info->header);
#else
rangeImagePP.header = info->header;
#endif
if(proc_cloud) {
pub_cloud_.publish(boost::make_shared<pcl::PointCloud<pcl::PointWithRange > >
( (pcl::PointCloud<pcl::PointWithRange>)rangeImagePP) );
}
if(proc_disp) {
stereo_msgs::DisparityImage disp;
#if PCL_MAJOR_VERSION == 1 && PCL_MINOR_VERSION >= 7
disp.header = pcl_conversions::fromPCL(rangeImagePP.header);
#else
disp.header = rangeImagePP.header;
#endif
disp.image.encoding = sensor_msgs::image_encodings::TYPE_32FC1;
disp.image.height = rangeImagePP.height;
disp.image.width = rangeImagePP.width;
disp.image.step = disp.image.width * sizeof(float);
disp.f = fx; disp.T = 0.075;
disp.min_disparity = 0;
disp.max_disparity = disp.T * disp.f / 0.3;
disp.delta_d = 0.125;
disp.image.data.resize (disp.image.height * disp.image.step);
float *data = reinterpret_cast<float*> (&disp.image.data[0]);
float normalization_factor = disp.f * disp.T;
for (int y = 0; y < (int)rangeImagePP.height; y++ ) {
for (int x = 0; x < (int)rangeImagePP.width; x++ ) {
pcl::PointWithRange p = rangeImagePP.getPoint(x,y);
data[y*disp.image.width+x] = normalization_factor / p.z;
}
}
pub_disp_image_.publish(boost::make_shared<stereo_msgs::DisparityImage> (disp));
}
}
}
void cloud_cb(
const typename pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr& cloud) {
iter++;
if(iter != skip) return;
iter = 0;
pcl::PointCloud<pcl::PointXYZRGB> cloud_transformed,
cloud_aligned, cloud_filtered;
Eigen::Affine3f view_transform;
view_transform.matrix() << 0, 0, 1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 1;
Eigen::AngleAxis<float> rot(tilt * M_PI / 180,
Eigen::Vector3f(0, 1, 0));
view_transform.prerotate(rot);
pcl::transformPointCloud(*cloud, cloud_transformed, view_transform);
pcl::ModelCoefficients::Ptr coefficients(
new pcl::ModelCoefficients);
pcl::PointIndices::Ptr inliers(new pcl::PointIndices);
pcl::SACSegmentation<pcl::PointXYZRGB> seg;
seg.setOptimizeCoefficients(true);
seg.setModelType(pcl::SACMODEL_PLANE);
seg.setMethodType(pcl::SAC_RANSAC);
seg.setDistanceThreshold(0.05);
seg.setProbability(0.99);
seg.setInputCloud(cloud_transformed.makeShared());
seg.segment(*inliers, *coefficients);
pcl::ExtractIndices<pcl::PointXYZRGB> extract;
extract.setInputCloud(cloud_transformed.makeShared());
extract.setIndices(inliers);
extract.setNegative(true);
extract.filter(cloud_transformed);
std::cout << "Z vector: " << coefficients->values[0] << " "
<< coefficients->values[1] << " " << coefficients->values[2]
<< " " << coefficients->values[3] << std::endl;
Eigen::Vector3f z_current(coefficients->values[0],
coefficients->values[1], coefficients->values[2]);
Eigen::Vector3f y(0, 1, 0);
Eigen::Affine3f rotation;
rotation = pcl::getTransFromUnitVectorsZY(z_current, y);
rotation.translate(Eigen::Vector3f(0, 0, coefficients->values[3]));
pcl::transformPointCloud(cloud_transformed, cloud_aligned, rotation);
Eigen::Affine3f res = (rotation * view_transform);
cloud_aligned.sensor_origin_ = res * Eigen::Vector4f(0, 0, 0, 1);
cloud_aligned.sensor_orientation_ = res.rotate(
Eigen::AngleAxisf(M_PI, Eigen::Vector3f(0, 0, 1))).rotation();
seg.setInputCloud(cloud_aligned.makeShared());
seg.segment(*inliers, *coefficients);
std::cout << "Z vector: " << coefficients->values[0] << " "
<< coefficients->values[1] << " " << coefficients->values[2]
<< " " << coefficients->values[3] << std::endl;
pub.publish(cloud_aligned);
}
void IterativeClosestPoint::execute() {
float error = std::numeric_limits<float>::max(), previousError;
uint iterations = 0;
// Get access to the two point sets
PointSetAccess::pointer accessFixedSet = ((PointSet::pointer)getStaticInputData<PointSet>(0))->getAccess(ACCESS_READ);
PointSetAccess::pointer accessMovingSet = ((PointSet::pointer)getStaticInputData<PointSet>(1))->getAccess(ACCESS_READ);
// Get transformations of point sets
AffineTransformation::pointer fixedPointTransform2 = SceneGraph::getAffineTransformationFromData(getStaticInputData<PointSet>(0));
Eigen::Affine3f fixedPointTransform;
fixedPointTransform.matrix() = fixedPointTransform2->matrix();
AffineTransformation::pointer initialMovingTransform2 = SceneGraph::getAffineTransformationFromData(getStaticInputData<PointSet>(1));
Eigen::Affine3f initialMovingTransform;
initialMovingTransform.matrix() = initialMovingTransform2->matrix();
// These matrices are Nx3
MatrixXf fixedPoints = accessFixedSet->getPointSetAsMatrix();
MatrixXf movingPoints = accessMovingSet->getPointSetAsMatrix();
Eigen::Affine3f currentTransformation = Eigen::Affine3f::Identity();
// Want to choose the smallest one as moving
bool invertTransform = false;
if(false && fixedPoints.cols() < movingPoints.cols()) {
reportInfo() << "switching fixed and moving" << Reporter::end;
// Switch fixed and moving
MatrixXf temp = fixedPoints;
fixedPoints = movingPoints;
movingPoints = temp;
invertTransform = true;
// Apply initial transformations
//currentTransformation = fixedPointTransform.getTransform();
movingPoints = fixedPointTransform*movingPoints.colwise().homogeneous();
fixedPoints = initialMovingTransform*fixedPoints.colwise().homogeneous();
} else {
// Apply initial transformations
//currentTransformation = initialMovingTransform.getTransform();
movingPoints = initialMovingTransform*movingPoints.colwise().homogeneous();
fixedPoints = fixedPointTransform*fixedPoints.colwise().homogeneous();
}
do {
previousError = error;
MatrixXf movedPoints = currentTransformation*(movingPoints.colwise().homogeneous());
// Match closest points using current transformation
MatrixXf rearrangedFixedPoints = rearrangeMatrixToClosestPoints(
fixedPoints, movedPoints);
// Get centroids
Vector3f centroidFixed = getCentroid(rearrangedFixedPoints);
//reportInfo() << "Centroid fixed: " << Reporter::end;
//reportInfo() << centroidFixed << Reporter::end;
Vector3f centroidMoving = getCentroid(movedPoints);
//reportInfo() << "Centroid moving: " << Reporter::end;
//reportInfo() << centroidMoving << Reporter::end;
Eigen::Transform<float, 3, Eigen::Affine> updateTransform = Eigen::Transform<float, 3, Eigen::Affine>::Identity();
if(mTransformationType == IterativeClosestPoint::RIGID) {
// Create correlation matrix H of the deviations from centroid
MatrixXf H = (movedPoints.colwise() - centroidMoving)*
(rearrangedFixedPoints.colwise() - centroidFixed).transpose();
// Do SVD on H
Eigen::JacobiSVD<Eigen::MatrixXf> svd(H, Eigen::ComputeFullU | Eigen::ComputeFullV);
// Estimate rotation as R=V*U.transpose()
MatrixXf temp = svd.matrixV()*svd.matrixU().transpose();
Matrix3f d = Matrix3f::Identity();
d(2,2) = sign(temp.determinant());
Matrix3f R = svd.matrixV()*d*svd.matrixU().transpose();
// Estimate translation
Vector3f T = centroidFixed - R*centroidMoving;
updateTransform.linear() = R;
updateTransform.translation() = T;
} else {
// Only translation
Vector3f T = centroidFixed - centroidMoving;
updateTransform.translation() = T;
}
// Update current transformation
currentTransformation = updateTransform*currentTransformation;
// Calculate RMS error
MatrixXf distance = rearrangedFixedPoints - currentTransformation*(movingPoints.colwise().homogeneous());
error = 0;
for(uint i = 0; i < distance.cols(); i++) {
error += pow(distance.col(i).norm(),2);
}
error = sqrt(error / distance.cols());
iterations++;
reportInfo() << "Error: " << error << Reporter::end;
// To continue, change in error has to be above min error change and nr of iterations less than max iterations
} while(previousError-error > mMinErrorChange && iterations < mMaxIterations);
if(invertTransform){
currentTransformation = currentTransformation.inverse();
}
mError = error;
mTransformation->matrix() = currentTransformation.matrix();
}
void simulate_callback (const pcl::visualization::KeyboardEvent &event,
void* viewer_void)
{
pcl::visualization::PCLVisualizer::Ptr viewer = *static_cast<pcl::visualization::PCLVisualizer::Ptr *> (viewer_void);
// I choose v for virtual as s for simulate is takwen
if (event.getKeySym () == "v" && event.keyDown ())
{
std::cout << "v was pressed => simulate cloud" << std::endl;
std::vector<pcl::visualization::Camera> cams;
viewer->getCameras(cams);
if (cams.size() !=1){
std::cout << "n cams not 1 exiting\n"; // for now in case ...
return;
}
// cout << "n cams: " << cams.size() << "\n";
pcl::visualization::Camera cam = cams[0];
Eigen::Affine3f pose;
pose = viewer->getViewerPose() ;
std::cout << cam.pos[0] << " "
<< cam.pos[1] << " "
<< cam.pos[2] << " p\n";
Eigen::Matrix3f m;
m =pose.rotation();
//All axies use right hand rule. x=red axis, y=green axis, z=blue axis z direction is point into the screen. z \ \ \ -----------> x | | | | | | y
cout << pose(0,0) << " " << pose(0,1) << " " << pose(0,2) << " " << pose(0,3) << " x0\n";
cout << pose(1,0) << " " << pose(1,1) << " " << pose(1,2) << " " << pose(1,3) << " x1\n";
cout << pose(2,0) << " " << pose(2,1) << " " << pose(2,2) << " " << pose(2,3)<< "x2\n";
double yaw,pitch, roll;
wRo_to_euler(m,yaw,pitch,roll);
printf("RPY: %f %f %f\n", roll*180/M_PI,pitch*180/M_PI,yaw*180/M_PI);
// matrix->GetElement(1,0);
cout << m(0,0) << " " << m(0,1) << " " << m(0,2) << " " << " x0\n";
cout << m(1,0) << " " << m(1,1) << " " << m(1,2) << " " << " x1\n";
cout << m(2,0) << " " << m(2,1) << " " << m(2,2) << " "<< "x2\n\n";
Eigen::Quaternionf rf;
rf = Eigen::Quaternionf(m);
Eigen::Quaterniond r(rf.w(),rf.x(),rf.y(),rf.z());
Eigen::Isometry3d init_pose;
init_pose.setIdentity();
init_pose.translation() << cam.pos[0], cam.pos[1], cam.pos[2];
//Eigen::Quaterniond m = euler_to_quat(-1.54, 0, 0);
init_pose.rotate(r);
//
std::stringstream ss;
print_Isometry3d(init_pose,ss);
std::cout << "init_pose: " << ss.str() << "\n";
viewer->addCoordinateSystem (1.0,pose,"reference");
double tic = getTime();
std::stringstream ss2;
ss2.precision(20);
ss2 << "simulated_pcl_" << tic << ".pcd";
capture(init_pose);
cout << (getTime() -tic) << " sec\n";
}
}
void ShapeVisualization::setShapePosition(const visualization_msgs::InteractiveMarkerFeedbackConstPtr& feedback)//,const cob_3d_mapping_msgs::Shape& shape)
{
cob_3d_mapping_msgs::ShapeArray map_msg;
map_msg.header.frame_id = frame_id_;
map_msg.header.stamp = ros::Time::now();
int shape_id,index;
index=-1;
stringstream name(feedback->marker_name);
Eigen::Quaternionf quat;
Eigen::Matrix3f rotationMat;
Eigen::MatrixXf rotationMatInit;
Eigen::Vector3f normalVec;
Eigen::Vector3f normalVecNew;
Eigen::Vector3f newCentroid;
Eigen::Matrix4f transSecondStep;
if (feedback->marker_name != "Text"){
name >> shape_id ;
cob_3d_mapping::Polygon p;
for(unsigned int i=0;i<sha.shapes.size();++i)
{
if (sha.shapes[i].id == shape_id)
{
index = i;
}
}
// temporary fix.
//do nothing if index of shape is not found
// this is not supposed to occur , but apparently it does
if(index==-1){
ROS_WARN("shape not in map array");
return;
}
cob_3d_mapping::fromROSMsg (sha.shapes.at(index), p);
if (feedback->event_type == 2 && feedback->menu_entry_id == 5){
quatInit.x() = (float)feedback->pose.orientation.x ; //normalized
quatInit.y() = (float)feedback->pose.orientation.y ;
quatInit.z() = (float)feedback->pose.orientation.z ;
quatInit.w() = (float)feedback->pose.orientation.w ;
oldCentroid (0) = (float)feedback->pose.position.x ;
oldCentroid (1) = (float)feedback->pose.position.y ;
oldCentroid (2) = (float)feedback->pose.position.z ;
quatInit.normalize() ;
rotationMatInit = quatInit.toRotationMatrix() ;
transInit.block(0,0,3,3) << rotationMatInit ;
transInit.col(3).head(3) << oldCentroid(0) , oldCentroid(1), oldCentroid(2) ;
transInit.row(3) << 0,0,0,1 ;
transInitInv = transInit.inverse() ;
Eigen::Affine3f affineInitFinal (transInitInv) ;
affineInit = affineInitFinal ;
std::cout << "transInit : " << "\n" << affineInitFinal.matrix() << "\n" ;
}
if (feedback->event_type == 5){
/* the name of the marker is arrows_shape_.id, we need to erase the "arrows_" part */
//string strName(feedback->marker_name);
//strName.erase(strName.begin(),strName.begin()+7);
// stringstream name(strName);
stringstream name(feedback->marker_name);
/* the name of the marker is arrows_shape_.id, we need to erase the "arrows_" part */
// int test ;
// string strName(feedback->marker_name);
// strName.erase(strName.begin(),strName.begin()+7);
// stringstream nameTest(strName);
// std::cout << "nameTest : " << nameTest.str() << "\n" ;
// nameTest >> test ;
// std::cout << "test : " << test << "\n" ;
// name >> shape_id ;
cob_3d_mapping::Polygon p;
// for(size_t i=0;i<sha.shapes.size();++i)
// {
// if (sha.shapes[i].id == shape_id)
// {
// index = i;
// }
// }
std::cout << "index is : " << index << "\n" ;
cob_3d_mapping::fromROSMsg (sha.shapes.at(index), p);
quat.x() = (float)feedback->pose.orientation.x ; //normalized
quat.y() = (float)feedback->pose.orientation.y ;
quat.z() = (float)feedback->pose.orientation.z ;
quat.w() = (float)feedback->pose.orientation.w ;
quat.normalize() ;
rotationMat = quat.toRotationMatrix() ;
normalVec << sha.shapes.at(index).params[0], //normalized
sha.shapes.at(index).params[1],
sha.shapes.at(index).params[2];
newCentroid << (float)feedback->pose.position.x ,
(float)feedback->pose.position.y ,
(float)feedback->pose.position.z ;
transSecondStep.block(0,0,3,3) << rotationMat ;
transSecondStep.col(3).head(3) << newCentroid(0) , newCentroid(1), newCentroid(2) ;
transSecondStep.row(3) << 0,0,0,1 ;
Eigen::Affine3f affineSecondStep(transSecondStep) ;
std::cout << "transfrom : " << "\n" << affineSecondStep.matrix() << "\n" ;
Eigen::Affine3f affineFinal(affineSecondStep*affineInit) ;
Eigen::Matrix4f matFinal = (transSecondStep*transInitInv) ;
normalVecNew = (matFinal.block(0,0,3,3))* normalVec;
// newCentroid = transFinal *OldCentroid ;
sha.shapes.at(index).centroid.x = newCentroid(0) ;
sha.shapes.at(index).centroid.y = newCentroid(1) ;
sha.shapes.at(index).centroid.z = newCentroid(2) ;
sha.shapes.at(index).params[0] = normalVecNew(0) ;
sha.shapes.at(index).params[1] = normalVecNew(1) ;
sha.shapes.at(index).params[2] = normalVecNew(2) ;
std::cout << "transfromFinal : " << "\n" << affineFinal.matrix() << "\n" ;
pcl::PointCloud<pcl::PointXYZ> pc;
pcl::PointXYZ pt;
sensor_msgs::PointCloud2 pc2;
for(unsigned int j=0; j<p.contours.size(); j++)
{
for(unsigned int k=0; k<p.contours[j].size(); k++)
{
p.contours[j][k] = affineFinal * p.contours[j][k];
pt.x = p.contours[j][k][0] ;
pt.y = p.contours[j][k][1] ;
pt.z = p.contours[j][k][2] ;
pc.push_back(pt) ;
}
}
pcl::toROSMsg (pc, pc2);
sha.shapes.at(index).points.clear() ;
sha.shapes.at(index).points.push_back (pc2);
// uncomment when using test_shape_array
// for(unsigned int i=0;i<sha.shapes.size();i++){
// map_msg.header = sha.shapes.at(i).header ;
// map_msg.shapes.push_back(sha.shapes.at(i)) ;
// }
// shape_pub_.publish(map_msg);
// end uncomment
modified_shapes_.shapes.push_back(sha.shapes.at(index));
}
}
void PointCloudLocalization::cloudCallback(
const sensor_msgs::PointCloud2::ConstPtr& cloud_msg)
{
vital_checker_->poke();
boost::mutex::scoped_lock lock(mutex_);
//JSK_NODELET_INFO("cloudCallback");
latest_cloud_ = cloud_msg;
if (localize_requested_){
JSK_NODELET_INFO("localization is requested");
try {
pcl::PointCloud<pcl::PointNormal>::Ptr
local_cloud (new pcl::PointCloud<pcl::PointNormal>);
pcl::fromROSMsg(*latest_cloud_, *local_cloud);
JSK_NODELET_INFO("waiting for tf transformation from %s tp %s",
latest_cloud_->header.frame_id.c_str(),
global_frame_.c_str());
if (tf_listener_->waitForTransform(
latest_cloud_->header.frame_id,
global_frame_,
latest_cloud_->header.stamp,
ros::Duration(1.0))) {
pcl::PointCloud<pcl::PointNormal>::Ptr
input_cloud (new pcl::PointCloud<pcl::PointNormal>);
if (use_normal_) {
pcl_ros::transformPointCloudWithNormals(global_frame_,
*local_cloud,
*input_cloud,
*tf_listener_);
}
else {
pcl_ros::transformPointCloud(global_frame_,
*local_cloud,
*input_cloud,
*tf_listener_);
}
pcl::PointCloud<pcl::PointNormal>::Ptr
input_downsampled_cloud (new pcl::PointCloud<pcl::PointNormal>);
applyDownsampling(input_cloud, *input_downsampled_cloud);
if (isFirstTime()) {
all_cloud_ = input_downsampled_cloud;
first_time_ = false;
}
else {
// run ICP
ros::ServiceClient client
= pnh_->serviceClient<jsk_pcl_ros::ICPAlign>("icp_align");
jsk_pcl_ros::ICPAlign icp_srv;
if (clip_unseen_pointcloud_) {
// Before running ICP, remove pointcloud where we cannot see
// First, transform reference pointcloud, that is all_cloud_, into
// sensor frame.
// And after that, remove points which are x < 0.
tf::StampedTransform global_sensor_tf_transform
= lookupTransformWithDuration(
tf_listener_,
global_frame_,
sensor_frame_,
cloud_msg->header.stamp,
ros::Duration(1.0));
Eigen::Affine3f global_sensor_transform;
tf::transformTFToEigen(global_sensor_tf_transform,
global_sensor_transform);
pcl::PointCloud<pcl::PointNormal>::Ptr sensor_cloud
(new pcl::PointCloud<pcl::PointNormal>);
pcl::transformPointCloudWithNormals(
*all_cloud_,
*sensor_cloud,
global_sensor_transform.inverse());
// Remove negative-x points
pcl::PassThrough<pcl::PointNormal> pass;
pass.setInputCloud(sensor_cloud);
pass.setFilterFieldName("x");
pass.setFilterLimits(0.0, 100.0);
pcl::PointCloud<pcl::PointNormal>::Ptr filtered_cloud
(new pcl::PointCloud<pcl::PointNormal>);
pass.filter(*filtered_cloud);
JSK_NODELET_INFO("clipping: %lu -> %lu", sensor_cloud->points.size(), filtered_cloud->points.size());
// Convert the pointcloud to global frame again
pcl::PointCloud<pcl::PointNormal>::Ptr global_filtered_cloud
(new pcl::PointCloud<pcl::PointNormal>);
pcl::transformPointCloudWithNormals(
*filtered_cloud,
*global_filtered_cloud,
global_sensor_transform);
pcl::toROSMsg(*global_filtered_cloud,
icp_srv.request.target_cloud);
}
else {
pcl::toROSMsg(*all_cloud_,
icp_srv.request.target_cloud);
}
pcl::toROSMsg(*input_downsampled_cloud,
icp_srv.request.reference_cloud);
if (client.call(icp_srv)) {
Eigen::Affine3f transform;
tf::poseMsgToEigen(icp_srv.response.result.pose, transform);
Eigen::Vector3f transform_pos(transform.translation());
float roll, pitch, yaw;
pcl::getEulerAngles(transform, roll, pitch, yaw);
JSK_NODELET_INFO("aligned parameter --");
JSK_NODELET_INFO(" - pos: [%f, %f, %f]",
transform_pos[0],
transform_pos[1],
transform_pos[2]);
JSK_NODELET_INFO(" - rot: [%f, %f, %f]", roll, pitch, yaw);
pcl::PointCloud<pcl::PointNormal>::Ptr
transformed_input_cloud (new pcl::PointCloud<pcl::PointNormal>);
if (use_normal_) {
pcl::transformPointCloudWithNormals(*input_cloud,
*transformed_input_cloud,
transform);
}
else {
pcl::transformPointCloud(*input_cloud,
*transformed_input_cloud,
transform);
}
pcl::PointCloud<pcl::PointNormal>::Ptr
concatenated_cloud (new pcl::PointCloud<pcl::PointNormal>);
*concatenated_cloud = *all_cloud_ + *transformed_input_cloud;
// update *all_cloud
applyDownsampling(concatenated_cloud, *all_cloud_);
// update localize_transform_
tf::Transform icp_transform;
tf::transformEigenToTF(transform, icp_transform);
{
boost::mutex::scoped_lock tf_lock(tf_mutex_);
localize_transform_ = localize_transform_ * icp_transform;
}
}
else {
JSK_NODELET_ERROR("Failed to call ~icp_align");
return;
}
}
localize_requested_ = false;
}
else {
JSK_NODELET_WARN("No tf transformation is available");
}
}
catch (tf2::ConnectivityException &e)
{
JSK_NODELET_ERROR("[%s] Transform error: %s", __PRETTY_FUNCTION__, e.what());
return;
}
catch (tf2::InvalidArgumentException &e)
{
JSK_NODELET_ERROR("[%s] Transform error: %s", __PRETTY_FUNCTION__, e.what());
return;
}
}
}
void
pcl::CropBox<pcl::PCLPointCloud2>::applyFilter (PCLPointCloud2 &output)
{
// Resize output cloud to sample size
output.data.resize (input_->data.size ());
removed_indices_->resize (input_->data.size ());
// Copy the common fields
output.fields = input_->fields;
output.is_bigendian = input_->is_bigendian;
output.row_step = input_->row_step;
output.point_step = input_->point_step;
output.height = 1;
int indices_count = 0;
int removed_indices_count = 0;
Eigen::Affine3f transform = Eigen::Affine3f::Identity();
Eigen::Affine3f inverse_transform = Eigen::Affine3f::Identity();
if (rotation_ != Eigen::Vector3f::Zero ())
{
pcl::getTransformation (0, 0, 0,
rotation_ (0), rotation_ (1), rotation_ (2),
transform);
inverse_transform = transform.inverse();
}
//PointXYZ local_pt;
Eigen::Vector3f local_pt (Eigen::Vector3f::Zero ());
for (size_t index = 0; index < indices_->size (); ++index)
{
// Get local point
int point_offset = ((*indices_)[index] * input_->point_step);
int offset = point_offset + input_->fields[x_idx_].offset;
memcpy (&local_pt, &input_->data[offset], sizeof (float)*3);
// Check if the point is invalid
if (!pcl_isfinite (local_pt.x ()) ||
!pcl_isfinite (local_pt.y ()) ||
!pcl_isfinite (local_pt.z ()))
continue;
// Transform point to world space
if (!(transform_.matrix().isIdentity()))
local_pt = transform_ * local_pt;
if (translation_ != Eigen::Vector3f::Zero ())
{
local_pt.x () = local_pt.x () - translation_ (0);
local_pt.y () = local_pt.y () - translation_ (1);
local_pt.z () = local_pt.z () - translation_ (2);
}
// Transform point to local space of crop box
if (!(inverse_transform.matrix ().isIdentity ()))
local_pt = inverse_transform * local_pt;
// If outside the cropbox
if ( (local_pt.x () < min_pt_[0] || local_pt.y () < min_pt_[1] || local_pt.z () < min_pt_[2]) ||
(local_pt.x () > max_pt_[0] || local_pt.y () > max_pt_[1] || local_pt.z () > max_pt_[2]))
{
if (negative_)
{
memcpy (&output.data[indices_count++ * output.point_step],
&input_->data[index * output.point_step], output.point_step);
}
else if (extract_removed_indices_)
{
(*removed_indices_)[removed_indices_count++] = static_cast<int> (index);
}
}
// If inside the cropbox
else
{
if (negative_ && extract_removed_indices_)
{
(*removed_indices_)[removed_indices_count++] = static_cast<int> (index);
}
else if (!negative_) {
memcpy (&output.data[indices_count++ * output.point_step],
&input_->data[index * output.point_step], output.point_step);
}
}
}
output.width = indices_count;
output.row_step = output.point_step * output.width;
output.data.resize (output.width * output.height * output.point_step);
removed_indices_->resize (removed_indices_count);
}
void
pcl::CropBox<pcl::PCLPointCloud2>::applyFilter (std::vector<int> &indices)
{
indices.resize (input_->width * input_->height);
removed_indices_->resize (input_->width * input_->height);
int indices_count = 0;
int removed_indices_count = 0;
Eigen::Affine3f transform = Eigen::Affine3f::Identity();
Eigen::Affine3f inverse_transform = Eigen::Affine3f::Identity();
if (rotation_ != Eigen::Vector3f::Zero ())
{
pcl::getTransformation (0, 0, 0,
rotation_ (0), rotation_ (1), rotation_ (2),
transform);
inverse_transform = transform.inverse();
}
//PointXYZ local_pt;
Eigen::Vector3f local_pt (Eigen::Vector3f::Zero ());
for (size_t index = 0; index < indices_->size (); index++)
{
// Get local point
int point_offset = ((*indices_)[index] * input_->point_step);
int offset = point_offset + input_->fields[x_idx_].offset;
memcpy (&local_pt, &input_->data[offset], sizeof (float)*3);
// Transform point to world space
if (!(transform_.matrix().isIdentity()))
local_pt = transform_ * local_pt;
if (translation_ != Eigen::Vector3f::Zero ())
{
local_pt.x () -= translation_ (0);
local_pt.y () -= translation_ (1);
local_pt.z () -= translation_ (2);
}
// Transform point to local space of crop box
if (!(inverse_transform.matrix().isIdentity()))
local_pt = inverse_transform * local_pt;
// If outside the cropbox
if ( (local_pt.x () < min_pt_[0] || local_pt.y () < min_pt_[1] || local_pt.z () < min_pt_[2]) ||
(local_pt.x () > max_pt_[0] || local_pt.y () > max_pt_[1] || local_pt.z () > max_pt_[2]))
{
if (negative_)
{
indices[indices_count++] = (*indices_)[index];
}
else if (extract_removed_indices_)
{
(*removed_indices_)[removed_indices_count++] = static_cast<int> (index);
}
}
// If inside the cropbox
else
{
if (negative_ && extract_removed_indices_)
{
(*removed_indices_)[removed_indices_count++] = static_cast<int> (index);
}
else if (!negative_) {
indices[indices_count++] = (*indices_)[index];
}
}
}
indices.resize (indices_count);
removed_indices_->resize (removed_indices_count);
}
void
cloud_cb (const CloudConstPtr &cloud)
{
boost::mutex::scoped_lock lock (mtx_);
double start = pcl::getTime ();
FPS_CALC_BEGIN;
cloud_pass_.reset (new Cloud);
cloud_pass_downsampled_.reset (new Cloud);
pcl::ModelCoefficients::Ptr coefficients (new pcl::ModelCoefficients ());
pcl::PointIndices::Ptr inliers (new pcl::PointIndices ());
filterPassThrough (cloud, *cloud_pass_);
if (counter_ < 10)
{
gridSample (cloud_pass_, *cloud_pass_downsampled_, downsampling_grid_size_);
}
else if (counter_ == 10)
{
//gridSample (cloud_pass_, *cloud_pass_downsampled_, 0.01);
cloud_pass_downsampled_ = cloud_pass_;
CloudPtr target_cloud;
if (use_convex_hull_)
{
planeSegmentation (cloud_pass_downsampled_, *coefficients, *inliers);
if (inliers->indices.size () > 3)
{
CloudPtr cloud_projected (new Cloud);
cloud_hull_.reset (new Cloud);
nonplane_cloud_.reset (new Cloud);
planeProjection (cloud_pass_downsampled_, *cloud_projected, coefficients);
convexHull (cloud_projected, *cloud_hull_, hull_vertices_);
extractNonPlanePoints (cloud_pass_downsampled_, cloud_hull_, *nonplane_cloud_);
target_cloud = nonplane_cloud_;
}
else
{
PCL_WARN ("cannot segment plane\n");
}
}
else
{
PCL_WARN ("without plane segmentation\n");
target_cloud = cloud_pass_downsampled_;
}
if (target_cloud != NULL)
{
PCL_INFO ("segmentation, please wait...\n");
std::vector<pcl::PointIndices> cluster_indices;
euclideanSegment (target_cloud, cluster_indices);
if (cluster_indices.size () > 0)
{
// select the cluster to track
CloudPtr temp_cloud (new Cloud);
extractSegmentCluster (target_cloud, cluster_indices, 0, *temp_cloud);
Eigen::Vector4f c;
pcl::compute3DCentroid<RefPointType> (*temp_cloud, c);
int segment_index = 0;
double segment_distance = c[0] * c[0] + c[1] * c[1];
for (size_t i = 1; i < cluster_indices.size (); i++)
{
temp_cloud.reset (new Cloud);
extractSegmentCluster (target_cloud, cluster_indices, int (i), *temp_cloud);
pcl::compute3DCentroid<RefPointType> (*temp_cloud, c);
double distance = c[0] * c[0] + c[1] * c[1];
if (distance < segment_distance)
{
segment_index = int (i);
segment_distance = distance;
}
}
segmented_cloud_.reset (new Cloud);
extractSegmentCluster (target_cloud, cluster_indices, segment_index, *segmented_cloud_);
//pcl::PointCloud<pcl::Normal>::Ptr normals (new pcl::PointCloud<pcl::Normal>);
//normalEstimation (segmented_cloud_, *normals);
RefCloudPtr ref_cloud (new RefCloud);
//addNormalToCloud (segmented_cloud_, normals, *ref_cloud);
ref_cloud = segmented_cloud_;
RefCloudPtr nonzero_ref (new RefCloud);
removeZeroPoints (ref_cloud, *nonzero_ref);
PCL_INFO ("calculating cog\n");
RefCloudPtr transed_ref (new RefCloud);
pcl::compute3DCentroid<RefPointType> (*nonzero_ref, c);
Eigen::Affine3f trans = Eigen::Affine3f::Identity ();
trans.translation ().matrix () = Eigen::Vector3f (c[0], c[1], c[2]);
//pcl::transformPointCloudWithNormals<RefPointType> (*ref_cloud, *transed_ref, trans.inverse());
pcl::transformPointCloud<RefPointType> (*nonzero_ref, *transed_ref, trans.inverse());
CloudPtr transed_ref_downsampled (new Cloud);
gridSample (transed_ref, *transed_ref_downsampled, downsampling_grid_size_);
tracker_->setReferenceCloud (transed_ref_downsampled);
tracker_->setTrans (trans);
reference_ = transed_ref;
tracker_->setMinIndices (int (ref_cloud->points.size ()) / 2);
}
else
{
PCL_WARN ("euclidean segmentation failed\n");
}
}
}
else
{
//normals_.reset (new pcl::PointCloud<pcl::Normal>);
//normalEstimation (cloud_pass_downsampled_, *normals_);
//RefCloudPtr tracking_cloud (new RefCloud ());
//addNormalToCloud (cloud_pass_downsampled_, normals_, *tracking_cloud);
//tracking_cloud = cloud_pass_downsampled_;
//*cloud_pass_downsampled_ = *cloud_pass_;
//cloud_pass_downsampled_ = cloud_pass_;
gridSampleApprox (cloud_pass_, *cloud_pass_downsampled_, downsampling_grid_size_);
tracking (cloud_pass_downsampled_);
}
new_cloud_ = true;
double end = pcl::getTime ();
computation_time_ = end - start;
FPS_CALC_END("computation");
counter_++;
}
Eigen::Affine3f OpenNiInterfacePlain::getCloudPose() {
Eigen::Affine3f mid;
mid.setIdentity();
return mid;
}
int main(void)
{
std::cout << "Starting engine" << std::endl;
pastry::initialize();
auto dr = std::make_shared<pastry::deferred::DeferredRenderer>();
pastry::scene_add(dr);
// scene (need this first!)
auto scene = std::make_shared<pastry::deferred::Scene>();
dr->setScene(scene);
// skybox
{
auto go = pastry::deferred::FactorSkyBox();
go->skybox->setTexture("assets/stormydays_cm.jpg");
go->skybox->setGeometry("assets/sphere_4.obj");
scene->setMainSkybox(go);
}
// camera
{
auto go = pastry::deferred::FactorCamera();
go->camera->setProjection(90.0f, 1.0f, 100.0f);
go->camera->setView({4,14,6},{2,3,0},{0,0,-1});
scene->setMainCamera(go);
}
constexpr float SPACE = 3.0f;
// geometry
{
constexpr int R = 3;
for(int x=-R; x<=+R; x++) {
for(int y=-R; y<=+R; y++) {
auto go = pastry::deferred::FactorGeometry();
go->geometry->load("assets/suzanne.obj");
Eigen::Affine3f pose = Eigen::Translation3f(Eigen::Vector3f(SPACE*x,SPACE*y,0))
* Eigen::AngleAxisf(0.0f,Eigen::Vector3f{0,0,1});
go->geometry->setPose(pose.matrix());
float p = static_cast<float>(x+R)/static_cast<float>(2*R);
go->geometry->setRoughness(0.2f + 0.8f*p);
scene->add(go);
}
}
}
// lights
// {
// auto light = std::make_shared<pastry::deferred::PointLight>();
// light->setLightPosition({+3,3,4});
// light->setLightColor(20.0f*Eigen::Vector3f{1,1,1});
// scene->add(light);
// }
// {
// auto light = std::make_shared<pastry::deferred::PointLight>();
// light->setLightPosition({-4,1,4});
// light->setLightColor(20.0f*Eigen::Vector3f{1,0.5,0.5});
// scene->add(light);
// }
{
auto go = pastry::deferred::FactorEnvironmentLight();
scene->add(go);
}
{
constexpr int R = 3;
for(int x=-R; x<=+R; x++) {
for(int y=-R; y<=+R; y++) {
auto go = pastry::deferred::FactorPointLight();
((pastry::deferred::PointLight*)(go->light.get()))->setLightPosition({SPACE*x,SPACE*y,1.5});
((pastry::deferred::PointLight*)(go->light.get()))->setLightColor(35.0f*HSL(std::atan2(y,x)/6.2831853f,0.5f,0.5f));
((pastry::deferred::PointLight*)(go->light.get()))->setLightFalloff(0.05f);
scene->add(go);
}
}
}
std::cout << "Running main loop" << std::endl;
pastry::run();
std::cout << "Graceful quit" << std::endl;
return 0;
}
void rawCloudHandler(const sensor_msgs::PointCloud2ConstPtr& laserCloud)
{
//double timeScanCur = laserCloud->header.stamp.toSec();
ros::Time timestamp = laserCloud->header.stamp;
//bool returnBool;
pcl::fromROSMsg(*laserCloud, *laserCloudIn);
if (visualizationFlag)
{
viewer->removeAllPointClouds(0);
viewer->removeAllShapes(0);
}
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudRGB(new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudLabeled(new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloud<pcl::PointXYZI>::Ptr cloudRaw(new pcl::PointCloud<pcl::PointXYZI>);
// std::vector<std::string> labelsC1;
// std::vector<std::string> labelsC2;
// pcl::PointCloud<SAFEFeatures>::Ptr featureCloudC1Acc(new pcl::PointCloud<SAFEFeatures>);
// pcl::PointCloud<SAFEFeatures>::Ptr featureCloudC2Acc(new pcl::PointCloud<SAFEFeatures>);
std::vector<std::string> labelsC1;
std::vector<std::string> labelsC2;
std::vector<std::string> labelsC3;
std::vector<std::string> labels;
pcl::PointCloud<AllFeatures>::Ptr featureCloudAcc(new pcl::PointCloud<AllFeatures>);
pcl::PointCloud<AllFeatures>::Ptr featureCloudC1Acc(new pcl::PointCloud<AllFeatures>);
pcl::PointCloud<AllFeatures>::Ptr featureCloudC2Acc(new pcl::PointCloud<AllFeatures>);
pcl::PointCloud<AllFeatures>::Ptr featureCloudC3Acc(new pcl::PointCloud<AllFeatures>);
std::vector<Eigen::Matrix3f> confMats;
pcl::PointCloud<pcl::PointXYZRGB>::Ptr classificationCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
std::vector<DatasetContainer> dataset;
std::string folder = "/home/mikkel/catkin_ws/src/trainingSet/";
pcl::copyPointCloud(*laserCloudIn, *cloudRGB);
pcl::copyPointCloud(*laserCloudIn, *cloudRaw);
// Single colored
if (visualizationFlag)
{
pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> color1(cloudRGB, 0, 0, 255);
viewer->addPointCloud<pcl::PointXYZRGB>(cloudRGB,color1,"cloudRGB",viewP(RawCloud));
}
//viewer->addText ("RawCloud", 10, 10, "vPP text", viewP(RawCloud));
// Ground modeling
// pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudStat(new pcl::PointCloud<pcl::PointXYZRGB>);
// pcl::PointCloud<pcl::PointXYZ>::Ptr planeDistCloud(new pcl::PointCloud<pcl::PointXYZ>);
// pcl::copyPointCloud(*cloudRGB,*cloudStat);
// pcl::copyPointCloud(*cloudRGB,*planeDistCloud);
// Remove everything outside the two lines
pcl::PointCloud<pcl::PointXYZI>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZI>);
//pcl::copyPointCloud(*cloudRaw, *cloud_filtered);
// Rotation
float thetaZ = theta*PI/180; // The angle of rotation in radians
Eigen::Affine3f transform_2 = Eigen::Affine3f::Identity();
transform_2.rotate (Eigen::AngleAxisf (thetaZ, Eigen::Vector3f::UnitZ()));
pcl::PointCloud<pcl::PointXYZ>::Ptr transformed_cloud (new pcl::PointCloud<pcl::PointXYZ> ());
pcl::transformPointCloud (*cloudRaw, *cloud_filtered, transform_2);
// Passthrough
pcl::PassThrough<pcl::PointXYZI> passX;
passX.setInputCloud (cloud_filtered);
passX.setFilterFieldName ("x");
passX.setFilterLimits (-0.5, 100.0);
//pass.setFilterLimitsNegative (true);
passX.filter (*cloud_filtered);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_filteredRGB(new pcl::PointCloud<pcl::PointXYZRGB>);
if (receivedHough)
{
pcl::PassThrough<pcl::PointXYZI> pass;
pass.setInputCloud (cloud_filtered);
pass.setFilterFieldName ("y");
pass.setFilterLimits (r1+WALL_CLEARANCE, r2-WALL_CLEARANCE);
//pass.setFilterLimitsNegative (true);
pass.filter (*cloud_filtered);
}
pcl::copyPointCloud(*cloud_filtered, *cloud_filteredRGB);
if (visualizationFlag)
{
pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> color9(cloudRGB, 0, 0, 255);
viewer->addPointCloud<pcl::PointXYZRGB>(cloud_filteredRGB,color9,"LinesFiltered",viewP(LinesFiltered));
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "LinesFiltered");
viewer->addText ("LinesFiltered", 10, 10, fontsize, 1, 1, 1, "LinesFiltered text", viewP(LinesFiltered));
}
// Grid Minimum
// pcl::PointCloud<pcl::PointXYZI>::Ptr gridCloud(new pcl::PointCloud<pcl::PointXYZI>);
// pcl::GridMinimum<pcl::PointXYZI> gridm(1.0); // Set grid resolution
// gridm.setInputCloud(cloud_filtered);
// gridm.filter(*gridCloud);
//*** Transform point cloud to adjust for a Ground Plane ***//
pcl::ModelCoefficients ground_coefficients;
pcl::PointIndices ground_indices;
pcl::SACSegmentation<pcl::PointXYZI> ground_finder;
ground_finder.setOptimizeCoefficients(true);
ground_finder.setModelType(pcl::SACMODEL_PLANE);
ground_finder.setMethodType(pcl::SAC_RANSAC);
ground_finder.setDistanceThreshold(0.15);
ground_finder.setInputCloud(cloud_filtered);
ground_finder.segment(ground_indices, ground_coefficients);
// Convert plane normal vector from type ModelCoefficients to Vector4f
Eigen::Vector3f np = Eigen::Vector3f(ground_coefficients.values[0],ground_coefficients.values[1],ground_coefficients.values[2]);
// Find rotation vector, u, and angle, theta
Eigen::Vector3f u = np.cross(Eigen::Vector3f(0,0,1));
u.normalize();
float theta = acos(np.dot(Eigen::Vector3f(0,0,1)));
// Construct transformation matrix (rotation matrix from axis and angle)
Eigen::Affine3f tf = Eigen::Affine3f::Identity();
float d = ground_coefficients.values[3];
tf.translation() << d*np[0], d*np[1], d*np[2];
tf.rotate (Eigen::AngleAxisf (theta, u));
// Execute the transformation
pcl::PointCloud<pcl::PointXYZI>::Ptr transformedCloud (new pcl::PointCloud<pcl::PointXYZI> ());
pcl::transformPointCloud(*cloud_filtered, *transformedCloud, tf);
// Compute statistical moments for least significant direction in neighborhood
#if (OLD_METHOD)
pcl::NeighborhoodFeatures<pcl::PointXYZI, AllFeatures> features;
pcl::PointCloud<AllFeatures>::Ptr featureCloud(new pcl::PointCloud<AllFeatures>);
features.setInputCloud(transformedCloud);
pcl::search::KdTree<pcl::PointXYZI>::Ptr search_tree5( new pcl::search::KdTree<pcl::PointXYZI>());
features.setSearchMethod(search_tree5);
//principalComponentsAnalysis.setRadiusSearch(0.6);
//features.setKSearch(30);
features.setRadiusSearch(0.01); // This value does not do anything! Look inside "NeighborgoodFeatures.h" to see adaptive radius calculation.
features.compute(*featureCloud);
// ros::Time tFeatureCalculation2 = ros::Time::now();
// ros::Duration tFeatureCalculation = tFeatureCalculation2-tPreprocessing2;
// if (executionTimes==true)
// ROS_INFO("Feature calculation time = %i",tFeatureCalculation.nsec);
visualizeFeature(*cloudRGB, *featureCloud, 0, viewP(GPDistMean), "GPDistMean");
visualizeFeature(*cloudRGB, *featureCloud, 1, viewP(GPDistMin), "GPDistMin");
visualizeFeature(*cloudRGB, *featureCloud, 2, viewP(GPDistPoint), "GPDistPoint");
visualizeFeature(*cloudRGB, *featureCloud, 3, viewP(GPDistVar), "GPDistVar");
visualizeFeature(*cloudRGB, *featureCloud, 4, viewP(PCA1), "PCA1"); // 4 = PCA1
visualizeFeature(*cloudRGB, *featureCloud, 5, viewP(PCA2), "PCA2"); // 3 = GPVar
visualizeFeature(*cloudRGB, *featureCloud, 6, viewP(PCA3), "PCA3"); // 0 = GPMean
visualizeFeature(*cloudRGB, *featureCloud, 7, viewP(PCANX), "PCANX");
visualizeFeature(*cloudRGB, *featureCloud, 8, viewP(PCANY), "PCANY");
visualizeFeature(*cloudRGB, *featureCloud, 9, viewP(PCANZ), "PCANZ"); // 9 = PCANZ
visualizeFeature(*cloudRGB, *featureCloud, 10, viewP(PointDist), "PointDist");
visualizeFeature(*cloudRGB, *featureCloud, 11, viewP(RSS), "RSS");
visualizeFeature(*cloudRGB, *featureCloud, 12, viewP(Reflectance), "Reflectance");
ROS_INFO("Computed all neighborhood features");
std::vector<float>* centroid = new std::vector<float>();
std::vector<float>* stds = new std::vector<float>();
//*** Testing ***//
if (training == false)
{
Eigen::Matrix3f confMat = Eigen::Matrix3f::Zero();
if (testdata==true)
{
*featureCloud = *featureCloudAcc;
}
pcl::copyPointCloud(*cloudRGB,*classificationCloud);
// Load feature normalization parameters
std::ifstream input_file((folder + "centroid").c_str());
std::istream_iterator<float> start(input_file), end;
std::vector<float> numbers(start, end);
std::copy(numbers.begin(), numbers.end(), std::back_inserter(*centroid));
std::ifstream input_file2((folder + "stds").c_str());
std::istream_iterator<float> start2(input_file2), end2;
std::vector<float> numbers2(start2, end2);
std::copy(numbers2.begin(), numbers2.end(), std::back_inserter(*stds));
// Normalize features
// if (pcl::io::savePCDFile ("testFeaturesNonNormalized.pcd", *featureCloud) != 0)
// return (false);
ros::Time tNormalization1 = ros::Time::now();
normalizeFeatures(*featureCloud,*featureCloud, ¢roid, &stds);
ros::Time tNormalization2 = ros::Time::now();
ros::Duration tNormalization = tNormalization2-tNormalization1;
if (executionTimes==true)
ROS_INFO("Normalization time = %f",(float)(tNormalization.nsec)/1000000);
pcl::PointIndices::Ptr unclassifiedIndices (new pcl::PointIndices ());
// if (pcl::io::savePCDFile ("testFeatures.pcd", *featureCloud) != 0)
// return (false);
CvSVM SVM;
//int dim = sizeof(featureCloud->points[0])/sizeof(float);
int dim = useFeatures.size();//sizeof(useFeatures)/sizeof(int);
SVM.load((folder + "svm").c_str());
//SVM.load((folder + "svm2014-11-06-11-22-59").c_str());
//SVM.load((folder + "svm2014-11-07-14-00-31").c_str());
//SVM.load((folder + "svm2014-11-07-13-16-28").c_str());
ros::Time tClassification1 = ros::Time::now();
//int nMissingLabels = 0;
for (size_t i=0;i<classificationCloud->points.size();i++)
{
float dataSVM[dim];
for (int d=0;d<dim;d++)
{
//dataSVM[d] = featureCloud->points[i].data[d];
dataSVM[d] = featureCloud->points[i].data[useFeatures[d]];
}
Mat labelsMat(1, dim, CV_32FC1, dataSVM);
float response = SVM.predict(labelsMat);
if (response == 1.0)
classificationCloud->points[i].b = 255;
else if (response == 2.0)
classificationCloud->points[i].g = 255;
else if (response == 3.0)
classificationCloud->points[i].r = 255;
else
ROS_INFO("Another class label = %f",response);
if (testdata==true)
{
int groundTruth;
if (labels[i].compare("ground") == 0)
groundTruth = 1;
else if (labels[i].compare("vegetation") == 0)
groundTruth = 2;
else if (labels[i].compare("object") == 0)
groundTruth = 3;
confMat(groundTruth-1,(int)response-1)++;
}
}
ros::Time tClassification2 = ros::Time::now();
ros::Duration tClassification = tClassification2-tClassification1;
if (executionTimes==true)
ROS_INFO("Classification time = %f",(float)(tClassification.nsec)/100000);
//ROS_INFO("Number of missing class labels = %i", nMissingLabels);
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> colorC(classificationCloud);
viewer->addPointCloud<pcl::PointXYZRGB>(classificationCloud,colorC,"Classification",viewP(Classification));
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "Classification");
viewer->addText ("Classification", 10, 10, fontsize, 1, 1, 1, "Classification text", viewP(Classification));
// Test set - calculate performance statistics
if (testdata == true)
{
std::cout << confMat << std::endl;
confMats.push_back(confMat);
if (true)//k==files.size()-1)
{
ofstream myfile;
string resultsFolder = "/home/mikkel/catkin_ws/src/Results/";
myfile.open ((resultsFolder + "run_number_here.txt").c_str());
// Distance threshold
myfile << "DistanceThreshold:" << distThr << ";\n";
// Neighborhood parameters
myfile << "Neighborhood:" << rmin << ";" << rmindist << ";" << rmax << ";" << rmaxdist << ";\n";
// Features
myfile << "Features:";
for (int d=0;d<dim;d++)
myfile << useFeatures[d] << ";";
myfile << "\n";
myfile << "ConfusionMatrix:";
for (size_t i=0;i<confMats.size();i++)
{
for (int r=0;r<confMats[i].rows();r++)
for (int c=0;c<confMats[i].cols();c++)
myfile << confMats[i](r,c) << ";";
myfile << "\n";
}
myfile << "Accuracy:" << confMat.diagonal().sum()/confMat.sum() << ";\n";
myfile.close();
}
}
featureCloudAcc->clear();
labels.clear();
#else
for (size_t i=0;i<transformedCloud->size();i++)
{
pcl::PointXYZI pTmp2 = transformedCloud->points[i];
pcl::PointXYZRGB pTmp;
pTmp.x = pTmp2.x;
pTmp.y = pTmp2.y;
pTmp.z = pTmp2.z;
pTmp.r = 255;
pTmp.g = 255;
if (pTmp.z > 0.1) // Object
{
classificationCloud->push_back(pTmp);
}
}
if (visualizationFlag)
{
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> colorC(classificationCloud);
viewer->addPointCloud<pcl::PointXYZRGB>(classificationCloud,colorC,"Classification",viewP(Classification));
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "Classification");
viewer->addText ("Classification", 10, 10, fontsize, 1, 1, 1, "Classification text", viewP(Classification));
}
#endif
// REGION GROWING
//ROS_INFO("region growing 5");
pcl::PointCloud <pcl::PointXYZRGB>::Ptr objectCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
//pcl::PointCloud <pcl::PointXYZRGB>::Ptr cloud (new pcl::PointCloud <pcl::PointXYZRGB>);
for (size_t i=0;i<classificationCloud->size();i++)
{
pcl::PointXYZRGB pTmp = classificationCloud->points[i];
if ((pTmp.r == 255) || (pTmp.g == 255)) // Object
{
objectCloud->push_back(pTmp);
}
}
pcl::RegionGrowing<pcl::PointXYZRGB, pcl::Normal> reg;
reg.setInputCloud (objectCloud);
//reg.setIndices (indices);
pcl::search::Search<pcl::PointXYZRGB>::Ptr tree = boost::shared_ptr<pcl::search::Search<pcl::PointXYZRGB> > (new pcl::search::KdTree<pcl::PointXYZRGB>);
reg.setSearchMethod (tree);
//reg.setDistanceThreshold (0.0001f);
//reg.setResidualThreshold(0.01f);
//ROS_INFO("res = %f",reg.getSmoothnessThreshold());
//reg.setPointColorThreshold (6);
//reg.setRegionColorThreshold (5);
reg.setMinClusterSize (1);
reg.setResidualThreshold(min_cluster_distance);
reg.setCurvatureTestFlag(false);
// reg.setResidualTestFlag(true);
// reg.setNormalTestFlag(false);
// reg.setSmoothModeFlag(false);
std::vector <pcl::PointIndices> clusters;
reg.extract (clusters);
//ROS_INFO("clusters = %d", clusters.size());
//std::cout << "testefter" << std::endl;
pcl::PointCloud <pcl::PointXYZRGB>::Ptr colored_cloud = reg.getColoredCloud ();
pcl::PointCloud <pcl::PointXYZRGB>::Ptr clustersFilteredCloud(new pcl::PointCloud<pcl::PointXYZRGB>);
std::vector <pcl::PointIndices> clustersFiltered;
//pcl::PointXYZRGB min_pt, max_pt;
Eigen::Vector4f min_pt, max_pt;
obstacle_detection::boundingbox bbox;
obstacle_detection::boundingboxes bboxes;
bboxes.header.stamp = timestamp;
bboxes.header.frame_id = "/velodyne";
if (visualizationFlag)
viewer->removeAllShapes(viewP(SegmentsFiltered));
for (size_t i=0;i<clusters.size();i++)
{
//ROS_INFO("cluster size = %d",clusters[i].indices.size());
if (clusters[i].indices.size() > 100)
{
clustersFiltered.push_back(clusters[i]);
for (size_t pp=0;pp<clusters[i].indices.size();pp++)
{
clustersFilteredCloud->push_back(colored_cloud->points[clusters[i].indices[pp]]);
}
// Calculate bounding box
pcl::getMinMax3D(*colored_cloud, clusters[i], min_pt, max_pt);
bbox.start.x = min_pt[0];
bbox.start.y = min_pt[1];
bbox.start.z = min_pt[2];
bbox.width.x = max_pt[0]-min_pt[0];
bbox.width.y = max_pt[1]-min_pt[1];
bbox.width.z = max_pt[2]-min_pt[2];
bbox.header.stamp = timestamp;
bbox.header.frame_id = "/velodyne";
bboxes.boundingboxes.push_back(bbox);
if (visualizationFlag)
viewer->addCube (min_pt[0], max_pt[0], min_pt[1], max_pt[1], min_pt[2], max_pt[2], 1.0f, 1.0f, 1.0f, (boost::format("%04d") % i).str().c_str(), viewP(SegmentsFiltered));
}
}
pubBBoxesPointer->publish(bboxes);
//
// //pcl::visualization::CloudViewer viewer ("Cluster viewer");
// //viewer.showCloud (colored_cloud);
//
if (visualizationFlag)
{
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> colorC2(colored_cloud);
viewer->addPointCloud<pcl::PointXYZRGB>(colored_cloud,colorC2,"Segments",viewP(Segments));
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "Segments");
viewer->addText ("Segments", 10, 10, fontsize, 1, 1, 1, "Segments text", viewP(Segments));
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> colorC3(clustersFilteredCloud);
viewer->addPointCloud<pcl::PointXYZRGB>(clustersFilteredCloud,colorC3,"SegmentsFiltered",viewP(SegmentsFiltered));
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "SegmentsFiltered");
viewer->addText ("Segments", 10, 10, fontsize, 1, 1, 1, "SegmentsFiltered text", viewP(SegmentsFiltered));
}
//
//
// // BOUNDING BOXES
// viewer->addCube (min_pt.x, max_pt.x, min_pt.y, max_pt.y, min_pt.z, max_pt.z);
// std_msgs::Float64 testF;
// //testF.data = 10;
// testF.data = 10;
//
// Compute principal directions
// Eigen::Vector4f pcaCentroid;
// pcl::compute3DCentroid(*clustersFilteredCloud, pcaCentroid);
// Eigen::Matrix3f covariance;
// computeCovarianceMatrixNormalized(*clustersFilteredCloud, pcaCentroid, covariance);
// Eigen::SelfAdjointEigenSolver<Eigen::Matrix3f> eigen_solver(covariance, Eigen::ComputeEigenvectors);
// Eigen::Matrix3f eigenVectorsPCA = eigen_solver.eigenvectors();
// eigenVectorsPCA.col(2) = eigenVectorsPCA.col(0).cross(eigenVectorsPCA.col(1));
//
// // Transform the original cloud to the origin where the principal components correspond to the axes.
// Eigen::Matrix4f projectionTransform(Eigen::Matrix4f::Identity());
// projectionTransform.block<3,3>(0,0) = eigenVectorsPCA.transpose();
// projectionTransform.block<3,1>(0,3) = -1.f * (projectionTransform.block<3,3>(0,0) * pcaCentroid.head<3>());
// pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloudPointsProjected (new pcl::PointCloud<pcl::PointXYZRGB>);
// pcl::transformPointCloud(*clustersFilteredCloud, *cloudPointsProjected, projectionTransform);
// // Get the minimum and maximum points of the transformed cloud.
// pcl::PointXYZRGB minPoint, maxPoint;
// pcl::getMinMax3D(*cloudPointsProjected, minPoint, maxPoint);
// const Eigen::Vector3f meanDiagonal = 0.5f*(maxPoint.getVector3fMap() + minPoint.getVector3fMap());
//
// // Final transform
// const Eigen::Quaternionf bboxQuaternion(eigenVectorsPCA); //Quaternions are a way to do rotations https://www.youtube.com/watch?v=mHVwd8gYLnI
// const Eigen::Vector3f bboxTransform = eigenVectorsPCA * meanDiagonal + pcaCentroid.head<3>();
// viewer->addCube(bboxTransform, bboxQuaternion, maxPoint.x - minPoint.x, maxPoint.y - minPoint.y, maxPoint.z - minPoint.z, "bbox");
//pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> colorTTF1(featureCloudTest, 0, 255, 0);
// pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> colorTTF1(featureCloudTest);
// PCL_INFO("featureCloudTest size = %i",featureCloudTest->points.size());
// pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> colorTTF2(featureCloudTrain, 255, 0, 0);
// viewer->addPointCloud<pcl::PointXYZRGB>(featureCloudTest,colorTTF1,"TestTrainFeatures1",viewP(TestTrainFeatures));
// viewer->addPointCloud<pcl::PointXYZRGB>(featureCloudTrain,colorTTF2,"TestTrainFeatures2",viewP(TestTrainFeatures));
// viewer->addText ("TestTrainFeatures", 10, 10, "TestTrainFeatures text", viewP(TestTrainFeatures));
// sensor_msgs::PointCloud2 processedCloud;
// pcl::toROSMsg(*classificationCloud, processedCloud);
// processedCloud.header.stamp = ros::Time::now();//processedCloud->header.stamp;
// processedCloud.header.frame_id = "/velodyne";
// pubProcessedPointCloudPointer->publish(processedCloud);
//
// pcl::PointCloud<pcl::PointXYZRGB>::Ptr groundCloud2D(new pcl::PointCloud<pcl::PointXYZRGB>);
// pcl::PointCloud<pcl::PointXYZRGB>::Ptr objectCloud2D(new pcl::PointCloud<pcl::PointXYZRGB>);
//
// for (size_t i=0;i<classificationCloud->size();i++)
// {
// pcl::PointXYZRGB pTmp = classificationCloud->points[i];
// pTmp.z = 0; // 3D -> 2D
// if ((pTmp.r == 255) || (pTmp.g == 255)) // Object
// {
// objectCloud2D->push_back(pTmp);
// }
// else if (pTmp.b == 255) // Object
// {
// groundCloud2D->push_back(pTmp);
// }
// }
//
// //std::vector<int> indexVector;
// unsigned int leafNodeCounter = 0;
// unsigned int voxelDensity = 0;
// unsigned int totalPoints = 0;
// //int occupancyW = OCCUPANCY_WIDTH/OCCUPANCY_GRID_RESOLUTION;
// //int occupancyH = OCCUPANCY_DEPTH/OCCUPANCY_GRID_RESOLUTION;
// std::vector<unsigned int> ocGroundGrid(OCCUPANCY_WIDTH*OCCUPANCY_DEPTH, 0);
// std::vector<unsigned int> ocObjectGrid(OCCUPANCY_WIDTH*OCCUPANCY_DEPTH, 0);
// std::vector<signed char> ocGridFinal(OCCUPANCY_WIDTH*OCCUPANCY_DEPTH,-1);
//
// // Ground grid
// pcl::octree::OctreePointCloudDensity< pcl::PointXYZRGB > octreeGround (OCCUPANCY_GRID_RESOLUTION);
// octreeGround.setInputCloud (groundCloud2D);
// pcl::PointXYZ bot(-OCCUPANCY_DEPTH_M/2,-OCCUPANCY_WIDTH_M/2,-0.5);
// pcl::PointXYZ top(OCCUPANCY_DEPTH_M/2,OCCUPANCY_WIDTH_M/2,0.5);
// octreeGround.defineBoundingBox(bot.x, bot.y, bot.z, top.x, top.y, top.z); // I have already calculated the BBox of my point cloud
// octreeGround.addPointsFromInputCloud ();
// pcl::octree::OctreePointCloudDensity<pcl::PointXYZRGB>::LeafNodeIterator it1;
// pcl::octree::OctreePointCloudDensity<pcl::PointXYZRGB>::LeafNodeIterator it1_end = octreeGround.leaf_end();
// int minx = 1000;
// int miny = 1000;
// int maxx = -1000;
// int maxy = -1000;
// for (it1 = octreeGround.leaf_begin(); it1 != it1_end; ++it1)
// {
// pcl::octree::OctreePointCloudDensityContainer& container = it1.getLeafContainer();
// voxelDensity = container.getPointCounter();
// Eigen::Vector3f min_pt, max_pt;
// octreeGround.getVoxelBounds (it1, min_pt, max_pt);
// //ROS_INFO("x = %f, y = %f, z = %f, x2 = %f, y2 = %f, z2 = %f",min_pt[0],min_pt[1],min_pt[2],max_pt[0],max_pt[1],max_pt[2]);
// totalPoints += voxelDensity;
// if (min_pt[0] < minx)
// minx = min_pt[0];
// if (min_pt[0] > maxx)
// maxx = min_pt[0];
// if (min_pt[1] < miny)
// miny = min_pt[1];
// if (min_pt[1] > maxy)
// maxy = min_pt[1];
//
// int r = OCCUPANCY_DEPTH-(min_pt[0]+OCCUPANCY_DEPTH_M/2)/OCCUPANCY_GRID_RESOLUTION;
// int c = OCCUPANCY_WIDTH-(min_pt[1]+OCCUPANCY_WIDTH_M/2)/OCCUPANCY_GRID_RESOLUTION;
//
// // if ((r == 51) || (c==51))
// // ROS_INFO("r = %i,c = %i",r,c);
//
// //if (((int)min_pt[0] == -1) || ((int)min_pt[1]==-1))
// //ROS_INFO("min_pt[0] = %f, min_pt[1]=%f",min_pt[0],min_pt[1]);
// if (!((r < 0) || (c < 0) || (r > OCCUPANCY_DEPTH-1) || (c > OCCUPANCY_WIDTH-1)))
// ocGroundGrid[r+OCCUPANCY_DEPTH*c] = voxelDensity;
// //ROS_INFO("density = %i, r = %i, c=%i",voxelDensity, r, c);
// //ROS_INFO("x (%f) -> r (%i), y (%f) -> c (%i)",min_pt[0],r,min_pt[1],c);
// leafNodeCounter++;
// }
//
//
// // Object grid
// pcl::octree::OctreePointCloudDensity< pcl::PointXYZRGB > octreeObject (OCCUPANCY_GRID_RESOLUTION);
// octreeObject.setInputCloud (objectCloud2D);
// octreeObject.defineBoundingBox(bot.x, bot.y, bot.z, top.x, top.y, top.z); // I have already calculated the BBox of my point cloud
// octreeObject.addPointsFromInputCloud ();
// pcl::octree::OctreePointCloudDensity<pcl::PointXYZRGB>::LeafNodeIterator it2;
// pcl::octree::OctreePointCloudDensity<pcl::PointXYZRGB>::LeafNodeIterator it2_end = octreeObject.leaf_end();
// minx = 1000;
// miny = 1000;
// maxx = -1000;
// maxy = -1000;
// leafNodeCounter = 0;
// voxelDensity = 0;
// totalPoints = 0;
// int t1 = 0;
// int t2 = 0;
// int t3 = 0;
// for (it2 = octreeObject.leaf_begin(); it2 != it2_end; ++it2)
// {
// pcl::octree::OctreePointCloudDensityContainer& container = it2.getLeafContainer();
// voxelDensity = container.getPointCounter();
// Eigen::Vector3f min_pt, max_pt;
// octreeObject.getVoxelBounds (it2, min_pt, max_pt);
// //ROS_INFO("x = %f, y = %f, z = %f, x2 = %f, y2 = %f, z2 = %f",min_pt[0],min_pt[1],min_pt[2],max_pt[0],max_pt[1],max_pt[2]);
// totalPoints += voxelDensity;
// if (min_pt[0] < minx)
// minx = min_pt[0];
// if (min_pt[0] > maxx)
// maxx = min_pt[0];
// if (min_pt[1] < miny)
// miny = min_pt[1];
// if (min_pt[1] > maxy)
// maxy = min_pt[1];
//
// int r = OCCUPANCY_DEPTH-(min_pt[0]+OCCUPANCY_DEPTH_M/2)/OCCUPANCY_GRID_RESOLUTION;
// int c = OCCUPANCY_WIDTH-(min_pt[1]+OCCUPANCY_WIDTH_M/2)/OCCUPANCY_GRID_RESOLUTION;
// if (!((r < 0) || (c < 0) || (r > OCCUPANCY_DEPTH-1) || (c > OCCUPANCY_WIDTH-1)))
// ocObjectGrid[r+OCCUPANCY_DEPTH*c] = voxelDensity;
// //ROS_INFO("object points = %i -> %i: x (%f) -> r (%i), y (%f) -> c (%i)",voxelDensity,ocGridFinal[r+OCCUPANCY_DEPTH*c],min_pt[0],r,min_pt[1],c);
// //ocGrid[r+OCCUPANCY_DEPTH*c] = voxelDensity;
// //ROS_INFO("density = %i, r = %i, c=%i",voxelDensity, r, c);
//
// leafNodeCounter++;
// }
//
// for (int r=0;r<OCCUPANCY_DEPTH;r++)
// {
// for (int c=0;c<OCCUPANCY_WIDTH;c++)
// {
// if ((ocGroundGrid[r+OCCUPANCY_DEPTH*c] == 0) && (ocObjectGrid[r+OCCUPANCY_DEPTH*c] <= 1))
// {
// ocGridFinal[r+OCCUPANCY_DEPTH*c] = -1.0; // 0.5 default likelihood
// t1++;
// }
// else if ((ocObjectGrid[r+OCCUPANCY_DEPTH*c] == 0))// && (ocGroundGrid[r+OCCUPANCY_DEPTH*c] > 0))
// {
// ocGridFinal[r+OCCUPANCY_DEPTH*c] = OCCUPANCY_MIN_PROB;
// t2++;
// }
// else
// {
// ocGridFinal[r+OCCUPANCY_DEPTH*c] = 50+(OCCUPANCY_MAX_PROB-50)*ocObjectGrid[r+OCCUPANCY_DEPTH*c]/(ocObjectGrid[r+OCCUPANCY_DEPTH*c]+ocGroundGrid[r+OCCUPANCY_DEPTH*c]);
// t3++;
// }
// }
// }
//
// nav_msgs::OccupancyGrid occupancyGrid;
// occupancyGrid.info.resolution = OCCUPANCY_GRID_RESOLUTION;
// occupancyGrid.header.stamp = timestamp;//ros::Time::now();
// occupancyGrid.header.frame_id = "/velodyne";
// occupancyGrid.info.width = OCCUPANCY_WIDTH;
// occupancyGrid.info.height = OCCUPANCY_DEPTH;
// //geometry_msgs::Pose lidarPose;
// geometry_msgs::Point lidarPoint;
// lidarPoint.x = 0;
// lidarPoint.y = 0;
// lidarPoint.z = 0;
// geometry_msgs::Quaternion lidarQuaternion;
// lidarQuaternion.w = 1;
// lidarQuaternion.x = 0;
// lidarQuaternion.y = 0;
// lidarQuaternion.z = 0;
// occupancyGrid.info.origin.position = lidarPoint;
// occupancyGrid.info.origin.orientation = lidarQuaternion;
// occupancyGrid.data = ocGridFinal;
//
// //ROS_INFO("total points = %i, total leaves = %i",totalPoints,leafNodeCounter);
// //ROS_INFO("minx = %i, maxx = %i, miny = %i, maxy = %i",minx,maxx,miny,maxy);
// //ROS_INFO("t1 = %i, t2 = %i, t3 = %i",t1,t2,t3);
//
//
// pubOccupancyGridPointer->publish(occupancyGrid);
// int l = 0;
// while (*++itLeafs)
// {
// //Iteratively explore only the leaf nodes..
// std::vector<PointXYZ> points;
// itLeafs->getData(points);
// l++;
// }
//
// ROS_INFO("l = %i",l);
//pcl::octree::OctreePointCloudSearch<pcl::PointXYZ> octree (OCCUPANCY_GRID_RESOLUTION);
// sensor_msgs::PointCloud2::Ptr cloud_filtered (new sensor_msgs::PointCloud2 ());
// pcl::VoxelGrid<sensor_msgs::PointCloud2> sor;
// sor.setInputCloud (processedCloud);
// sor.setLeafSize (0.01f, 0.01f, 0.01f);
// sor.filter (*cloud_filtered);
if (n==0)
{
//viewer->setCameraPosition(-20,0,10,1,0,2,1,0,2,v1);
//viewer->setCameraPosition(-20,0,10,1,0,2,1,0,2,v2);
//viewer->loadCameraParameters("pcl_video.cam");
}
#if (OLD_METHOD)
}
#endif
if (visualizationFlag)
viewer->spinOnce();
// Save screenshot
// std::stringstream tmp;
// tmp << n;
// viewer->saveScreenshot("/home/mikkel/images/" + (boost::format("%04d") % n).str() + ".png");
// n++;
}
void keypoint_map::align_z_axis() {
pcl::PointCloud<pcl::PointXYZ>::Ptr point_cloud(
new pcl::PointCloud<pcl::PointXYZ>);
for (int v = 0; v < depth_imgs[0].rows; v++) {
for (int u = 0; u < depth_imgs[0].cols; u++) {
if (depth_imgs[0].at<unsigned short>(v, u) != 0) {
pcl::PointXYZ p;
p.z = depth_imgs[0].at<unsigned short>(v, u) / 1000.0f;
p.x = (u - intrinsics[2]) * p.z / intrinsics[0];
p.y = (v - intrinsics[3]) * p.z / intrinsics[1];
p.getVector4fMap() = camera_positions[0] * p.getVector4fMap();
point_cloud->push_back(p);
}
}
}
pcl::ModelCoefficients::Ptr coefficients(new pcl::ModelCoefficients);
pcl::PointIndices::Ptr inliers(new pcl::PointIndices);
// Create the segmentation object
pcl::SACSegmentation<pcl::PointXYZ> seg;
// Optional
seg.setOptimizeCoefficients(true);
// Mandatory
seg.setModelType(pcl::SACMODEL_PLANE);
seg.setMethodType(pcl::SAC_RANSAC);
seg.setDistanceThreshold(0.005);
seg.setProbability(0.99);
seg.setInputCloud(point_cloud);
seg.segment(*inliers, *coefficients);
std::cerr << "Model coefficients: " << coefficients->values[0] << " "
<< coefficients->values[1] << " " << coefficients->values[2] << " "
<< coefficients->values[3] << " Num inliers "
<< inliers->indices.size() << std::endl;
Eigen::Affine3f transform = Eigen::Affine3f::Identity();
if (coefficients->values[2] > 0) {
transform.matrix().coeffRef(0, 2) = coefficients->values[0];
transform.matrix().coeffRef(1, 2) = coefficients->values[1];
transform.matrix().coeffRef(2, 2) = coefficients->values[2];
} else {
transform.matrix().coeffRef(0, 2) = -coefficients->values[0];
transform.matrix().coeffRef(1, 2) = -coefficients->values[1];
transform.matrix().coeffRef(2, 2) = -coefficients->values[2];
}
transform.matrix().col(0).head<3>() =
transform.matrix().col(1).head<3>().cross(
transform.matrix().col(2).head<3>());
transform.matrix().col(1).head<3>() =
transform.matrix().col(2).head<3>().cross(
transform.matrix().col(0).head<3>());
transform = transform.inverse();
transform.matrix().coeffRef(2, 3) = coefficients->values[3];
pcl::transformPointCloud(keypoints3d, keypoints3d, transform);
for (size_t i = 0; i < camera_positions.size(); i++) {
camera_positions[i] = transform * camera_positions[i];
}
}
bool AirwaysFilter::execute()
{
std::cout << "EXECUTING AIRWAYS FILTER" << std::endl;
ImagePtr input = this->getCopiedInputImage();
if (!input)
return false;
mInputImage = input;
std::string filename = (patientService()->getActivePatientFolder()+"/"+input->getFilename()).toStdString();
try {
// Import image data from disk
fast::ImageFileImporter::pointer importer = fast::ImageFileImporter::New();
importer->setFilename(filename);
// Need to know the data type
importer->update();
fast::Image::pointer image = importer->getOutputData<fast::Image>();
std::cout << "IMAGE LOADED" << std::endl;
// Set up algorithm
fast::TubeSegmentationAndCenterlineExtraction::pointer tubeExtraction = fast::TubeSegmentationAndCenterlineExtraction::New();
tubeExtraction->setInputConnection(importer->getOutputPort());
tubeExtraction->extractDarkTubes();
if(getCroppingOption(mOptions)->getValue())
tubeExtraction->enableAutomaticCropping(true);
// Set min and max intensity based on HU unit scale
if(image->getDataType() == fast::TYPE_UINT16) {
tubeExtraction->setMinimumIntensity(0);
tubeExtraction->setMaximumIntensity(1124);
} else {
tubeExtraction->setMinimumIntensity(-1024);
tubeExtraction->setMaximumIntensity(100);
}
tubeExtraction->setMinimumRadius(0.5);
tubeExtraction->setMaximumRadius(50);
tubeExtraction->setSensitivity(getSensitivityOption(mOptions)->getValue());
// TODO set blur amount..
// Convert fast segmentation data to VTK data which CX can use
vtkSmartPointer<fast::VTKImageExporter> vtkExporter = fast::VTKImageExporter::New();
vtkExporter->setInputConnection(tubeExtraction->getSegmentationOutputPort());
vtkExporter->Update();
mSegmentationOutput = vtkExporter->GetOutput();
std::cout << "FINISHED AIRWAY SEGMENTATION" << std::endl;
// Get output segmentation data
fast::Segmentation::pointer segmentation = tubeExtraction->getOutputData<fast::Segmentation>(0);
// Get the transformation of the segmentation
Eigen::Affine3f T = fast::SceneGraph::getEigenAffineTransformationFromData(segmentation);
mTransformation.matrix() = T.matrix().cast<double>(); // cast to double
// Get centerline
vtkSmartPointer<fast::VTKLineSetExporter> vtkCenterlineExporter = fast::VTKLineSetExporter::New();
vtkCenterlineExporter->setInputConnection(tubeExtraction->getCenterlineOutputPort());
mCenterlineOutput = vtkCenterlineExporter->GetOutput();
vtkCenterlineExporter->Update();
} catch(fast::Exception& e) {
std::string error = e.what();
reportError("fast::Exception: "+qstring_cast(error));
return false;
} catch(cl::Error& e) {
reportError("cl::Error:"+qstring_cast(e.what()));
return false;
} catch (std::exception& e){
reportError("std::exception:"+qstring_cast(e.what()));
return false;
} catch (...){
reportError("Airway segmentation algorithm threw a unknown exception.");
return false;
}
return true;
}
TEST (PCL, GSHOTWithRTransNoised)
{
PointCloud<PointNormal>::Ptr cloud_nr (new PointCloud<PointNormal> ());
PointCloud<PointNormal>::Ptr cloud_rot (new PointCloud<PointNormal> ());
PointCloud<PointNormal>::Ptr cloud_trans (new PointCloud<PointNormal> ());
PointCloud<PointNormal>::Ptr cloud_rot_trans (new PointCloud<PointNormal> ());
PointCloud<PointXYZ>::Ptr cloud_noise (new PointCloud<PointXYZ> ());
Eigen::Affine3f rot = Eigen::Affine3f::Identity ();
float rot_x = static_cast <float> (rand ()) / static_cast <float> (RAND_MAX);
float rot_y = static_cast <float> (rand ()) / static_cast <float> (RAND_MAX);
float rot_z = static_cast <float> (rand ()) / static_cast <float> (RAND_MAX);
rot.prerotate (Eigen::AngleAxisf (rot_x * M_PI, Eigen::Vector3f::UnitX ()));
rot.prerotate (Eigen::AngleAxisf (rot_y * M_PI, Eigen::Vector3f::UnitY ()));
rot.prerotate (Eigen::AngleAxisf (rot_z * M_PI, Eigen::Vector3f::UnitZ ()));
//std::cout << "rot = (" << (rot_x * M_PI) << ", " << (rot_y * M_PI) << ", " << (rot_z * M_PI) << ")" << std::endl;
Eigen::Affine3f trans = Eigen::Affine3f::Identity ();
float HI = 5.0f;
float LO = -HI;
float trans_x = LO + static_cast<float> (rand ()) / (static_cast<float> (RAND_MAX / (HI - LO)));
float trans_y = LO + static_cast<float> (rand ()) / (static_cast<float> (RAND_MAX / (HI - LO)));
float trans_z = LO + static_cast<float> (rand ()) / (static_cast<float> (RAND_MAX / (HI - LO)));
//std::cout << "trans = (" << trans_x << ", " << trans_y << ", " << trans_z << ")" << std::endl;
trans.translate (Eigen::Vector3f (trans_x, trans_y, trans_z));
// Estimate normals first
float mr = 0.002;
NormalEstimation<PointXYZ, pcl::Normal> n;
PointCloud<Normal>::Ptr normals1 (new PointCloud<Normal> ());
n.setViewPoint (0.0, 0.0, 1.0);
n.setInputCloud (cloud.makeShared ());
n.setRadiusSearch (20 * mr);
n.compute (*normals1);
pcl::concatenateFields<PointXYZ, Normal, PointNormal> (cloud, *normals1, *cloud_nr);
pcl::transformPointCloudWithNormals<PointNormal, float> (*cloud_nr, *cloud_rot, rot);
pcl::transformPointCloudWithNormals<PointNormal, float> (*cloud_nr, *cloud_trans, trans);
pcl::transformPointCloudWithNormals<PointNormal, float> (*cloud_rot, *cloud_rot_trans, trans);
add_gaussian_noise (cloud.makeShared (), cloud_noise, 0.005);
PointCloud<Normal>::Ptr normals_noise (new PointCloud<Normal> ());
n.setInputCloud (cloud_noise);
n.compute (*normals_noise);
PointCloud<Normal>::Ptr normals2 (new PointCloud<Normal> ());
n.setInputCloud (cloud2.makeShared ());
n.compute (*normals2);
PointCloud<Normal>::Ptr normals3 (new PointCloud<Normal> ());
n.setInputCloud (cloud3.makeShared ());
n.compute (*normals3);
// Objects
// Descriptors for ground truth (using SHOT)
PointCloud<SHOT352>::Ptr desc01 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc02 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc03 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc04 (new PointCloud<SHOT352> ());
// Descriptors for test GSHOT
PointCloud<SHOT352>::Ptr desc1 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc2 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc3 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc4 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc5 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc6 (new PointCloud<SHOT352> ());
PointCloud<SHOT352>::Ptr desc7 (new PointCloud<SHOT352> ());
// SHOT352 (global)
GSHOTEstimation<PointNormal, PointNormal, SHOT352> gshot1;
gshot1.setInputNormals (cloud_nr);
gshot1.setInputCloud (cloud_nr);
gshot1.compute (*desc1);
// Eigen::Vector4f center_desc1 = gshot.getCentralPoint ();
gshot1.setInputNormals (cloud_rot);
gshot1.setInputCloud (cloud_rot);
gshot1.compute (*desc2);
// Eigen::Vector4f center_desc2 = gshot.getCentralPoint ();
gshot1.setInputNormals (cloud_trans);
gshot1.setInputCloud (cloud_trans);
gshot1.compute (*desc3);
// Eigen::Vector4f center_desc3 = gshot.getCentralPoint ();
gshot1.setInputNormals (cloud_rot_trans);
gshot1.setInputCloud (cloud_rot_trans);
gshot1.compute (*desc4);
// Eigen::Vector4f center_desc4 = gshot.getCentralPoint ();
GSHOTEstimation<PointXYZ, Normal, SHOT352> gshot2;
gshot2.setInputNormals (normals1);
gshot2.setInputCloud (cloud_noise);
gshot2.compute (*desc5);
gshot2.setInputNormals (normals2);
gshot2.setInputCloud (cloud2.makeShared ());
gshot2.compute (*desc6);
gshot2.setInputNormals (normals3);
gshot2.setInputCloud (cloud3.makeShared ());
gshot2.compute (*desc7);
// Eigen::Vector3f distance_desc = (center_desc3.head<3> () - center_desc1.head<3> ());
// std::cout << "dist of desc0 and desc3 -> (" << distance_desc[0] << ", " << distance_desc[1] << ", " << distance_desc[2] << ")\n";
// SHOT352 (local)
GSHOTEstimation<PointNormal, PointNormal, SHOT352> shot;
shot.setInputNormals (cloud_nr);
shot.setInputCloud (ground_truth.makeShared());
shot.setSearchSurface (cloud_nr);
shot.setRadiusSearch (radius_local_shot);
shot.compute (*desc01);
shot.setInputNormals (cloud_rot);
shot.setInputCloud (ground_truth.makeShared());
shot.setSearchSurface (cloud_rot);
shot.setRadiusSearch (radius_local_shot);
shot.compute (*desc02);
shot.setInputNormals (cloud_trans);
shot.setInputCloud (ground_truth.makeShared());
shot.setSearchSurface (cloud_trans);
shot.setRadiusSearch (radius_local_shot);
shot.compute (*desc03);
shot.setInputNormals (cloud_rot_trans);
shot.setInputCloud (ground_truth.makeShared());
shot.setSearchSurface (cloud_rot_trans);
shot.setRadiusSearch (radius_local_shot);
shot.compute (*desc04);
// CHECK GSHOT
checkDesc(*desc01, *desc1);
checkDesc(*desc02, *desc2);
checkDesc(*desc03, *desc3);
checkDesc(*desc04, *desc4);
std::vector<float> d0, d1, d2, d3, d4, d5, d6;
for(int i = 0; i < 352; ++i)
{
d0.push_back(desc1->points[0].descriptor[i]);
d1.push_back(desc2->points[0].descriptor[i]);
d2.push_back(desc3->points[0].descriptor[i]);
d3.push_back(desc4->points[0].descriptor[i]);
d4.push_back(desc5->points[0].descriptor[i]);
d5.push_back(desc6->points[0].descriptor[i]);
d6.push_back(desc7->points[0].descriptor[i]);
}
float dist_0 = pcl::selectNorm< std::vector<float> > (d0, d0, 352, pcl::HIK) ;
float dist_1 = pcl::selectNorm< std::vector<float> > (d0, d1, 352, pcl::HIK) ;
float dist_2 = pcl::selectNorm< std::vector<float> > (d0, d2, 352, pcl::HIK) ;
float dist_3 = pcl::selectNorm< std::vector<float> > (d0, d3, 352, pcl::HIK) ;
float dist_4 = pcl::selectNorm< std::vector<float> > (d0, d4, 352, pcl::HIK) ;
float dist_5 = pcl::selectNorm< std::vector<float> > (d0, d5, 352, pcl::HIK) ;
float dist_6 = pcl::selectNorm< std::vector<float> > (d0, d6, 352, pcl::HIK) ;
std::cout << ">> Itself[HIK]: " << dist_0 << std::endl
<< ">> Rotation[HIK]: " << dist_1 << std::endl
<< ">> Translate[HIK]: " << dist_2 << std::endl
<< ">> Rot+Trans[HIK] " << dist_3 << std::endl
<< ">> GaussNoise[HIK]: " << dist_4 << std::endl
<< ">> bun03[HIK]: " << dist_5 << std::endl
<< ">> milk[HIK]: " << dist_6 << std::endl;
float high_barrier = dist_0 * 0.999f;
float noise_barrier = dist_0 * 0.75f;
float cut_barrier = dist_0 * 0.20f;
float low_barrier = dist_0 * 0.02f;
EXPECT_GT (dist_1, high_barrier);
EXPECT_GT (dist_2, high_barrier);
//EXPECT_GT (dist_3, high_barrier);
EXPECT_GT (dist_4, noise_barrier);
EXPECT_GT (dist_5, cut_barrier);
EXPECT_LT (dist_6, low_barrier);
}
template<typename Point> void
TableObjectCluster<Point>::calculateBoundingBox(
const PointCloudPtr& cloud,
const pcl::PointIndices& indices,
const Eigen::Vector3f& plane_normal,
const Eigen::Vector3f& plane_point,
Eigen::Vector3f& position,
Eigen::Quaternion<float>& orientation,
Eigen::Vector3f& size)
{
// transform to table coordinate frame and project points on X-Y, save max height
Eigen::Affine3f tf;
pcl::getTransformationFromTwoUnitVectorsAndOrigin(plane_normal.unitOrthogonal(), plane_normal, plane_point, tf);
pcl::PointCloud<pcl::PointXYZ>::Ptr pc2d(new pcl::PointCloud<pcl::PointXYZ>);
float height = 0.0;
for(std::vector<int>::const_iterator it=indices.indices.begin(); it != indices.indices.end(); ++it)
{
Eigen::Vector3f tmp = tf * (*cloud)[*it].getVector3fMap();
height = std::max<float>(height, fabs(tmp(2)));
pc2d->push_back(pcl::PointXYZ(tmp(0),tmp(1),0.0));
}
// create convex hull of projected points
#ifdef PCL_MINOR_VERSION >= 6
pcl::PointCloud<pcl::PointXYZ>::Ptr conv_hull(new pcl::PointCloud<pcl::PointXYZ>);
pcl::ConvexHull<pcl::PointXYZ> chull;
chull.setDimension(2);
chull.setInputCloud(pc2d);
chull.reconstruct(*conv_hull);
#endif
/*for(int i=0; i<conv_hull->size(); ++i)
std::cout << (*conv_hull)[i].x << "," << (*conv_hull)[i].y << std::endl;*/
// find the minimal bounding rectangle in 2D and table coordinates
Eigen::Vector2f p1, p2, p3;
cob_3d_mapping::MinimalRectangle2D mr2d;
mr2d.setConvexHull(conv_hull->points);
mr2d.rotatingCalipers(p2, p1, p3);
/*std::cout << "BB: \n" << p1[0] << "," << p1[1] <<"\n"
<< p2[0] << "," << p2[1] <<"\n"
<< p3[0] << "," << p3[1] <<"\n ---" << std::endl;*/
// compute center of rectangle
position[0] = 0.5f*(p1[0] + p3[0]);
position[1] = 0.5f*(p1[1] + p3[1]);
position[2] = 0.0f;
// transform back
Eigen::Affine3f inv_tf = tf.inverse();
position = inv_tf * position;
// set size of bounding box
float norm_1 = (p3-p2).norm();
float norm_2 = (p1-p2).norm();
// BoundingBox coordinates: X:= main direction, Z:= table normal
Eigen::Vector3f direction; // y direction
if (norm_1 < norm_2)
{
direction = Eigen::Vector3f(p3[0]-p2[0], p3[1]-p2[1], 0) / (norm_1);
size[0] = norm_2 * 0.5f;
size[1] = norm_1 * 0.5f;
}
else
{
direction = Eigen::Vector3f(p1[0]-p2[0], p1[1]-p2[1], 0) / (norm_2);
size[0] = norm_1 * 0.5f;
size[1] = norm_2 * 0.5f;
}
size[2] = -height;
direction = inv_tf.rotation() * direction;
orientation = pcl::getTransformationFromTwoUnitVectors(direction, plane_normal).rotation(); // (y, z-direction)
return;
Eigen::Matrix3f M = Eigen::Matrix3f::Identity() - plane_normal * plane_normal.transpose();
Eigen::Vector3f xn = M * Eigen::Vector3f::UnitX(); // X-axis project on normal
Eigen::Vector3f xxn = M * direction;
float cos_phi = acos(xn.normalized().dot(xxn.normalized())); // angle between xn and main direction
cos_phi = cos(0.5f * cos_phi);
float sin_phi = sqrt(1.0f-cos_phi*cos_phi);
//orientation.w() = cos_phi;
//orientation.x() = sin_phi * plane_normal(0);
//orientation.y() = sin_phi * plane_normal(1);
//orientation.z() = sin_phi * plane_normal(2);
}
int
main (int argc, char** argv)
{
// Get input object and scene
if (argc < 2)
{
pcl::console::print_error ("Syntax is: %s cloud1.pcd (cloud2.pcd)\n", argv[0]);
return (1);
}
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud_in (new pcl::PointCloud<pcl::PointXYZRGBA>);
pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud_out (new pcl::PointCloud<pcl::PointXYZRGBA>);
// Load object and scene
pcl::console::print_highlight ("Loading point clouds...\n");
if(argc<3)
{
if (pcl::io::loadPCDFile<pcl::PointXYZRGBA> (argv[1], *cloud_in) < 0)
pcl::console::print_error ("Error loading first file!\n");
*cloud_out = *cloud_in;
//transform cloud
Eigen::Affine3f transformation;
transformation.setIdentity();
transformation.translate(Eigen::Vector3f(0.3,0.02,-0.1));
float roll, pitch, yaw;
roll = 0.02; pitch = 1.2; yaw = 0;
Eigen::AngleAxisf rollAngle(roll, Eigen::Vector3f::UnitX());
Eigen::AngleAxisf pitchAngle(pitch, Eigen::Vector3f::UnitY());
Eigen::AngleAxisf yawAngle(yaw, Eigen::Vector3f::UnitZ());
Eigen::Quaternion<float> q = rollAngle*pitchAngle*yawAngle;
transformation.rotate(q);
pcl::transformPointCloud<pcl::PointXYZRGBA>(*cloud_in, *cloud_out, transformation);
std::cout << "Transformed " << cloud_in->points.size () << " data points:"
<< std::endl;
}else{
if (pcl::io::loadPCDFile<pcl::PointXYZRGBA> (argv[1], *cloud_in) < 0 ||
pcl::io::loadPCDFile<pcl::PointXYZRGBA> (argv[2], *cloud_out) < 0)
{
pcl::console::print_error ("Error loading files!\n");
return (1);
}
}
// Fill in the CloudIn data
// cloud_in->width = 100;
// cloud_in->height = 1;
// cloud_in->is_dense = false;
// cloud_in->points.resize (cloud_in->width * cloud_in->height);
// for (size_t i = 0; i < cloud_in->points.size (); ++i)
// {
// cloud_in->points[i].x = 1024 * rand () / (RAND_MAX + 1.0f);
// cloud_in->points[i].y = 1024 * rand () / (RAND_MAX + 1.0f);
// cloud_in->points[i].z = 1024 * rand () / (RAND_MAX + 1.0f);
// }
std::cout << "size:" << cloud_out->points.size() << std::endl;
{
pcl::ScopeTime("icp proces");
pcl::IterativeClosestPoint<pcl::PointXYZRGBA, pcl::PointXYZRGBA> icp;
icp.setInputSource(cloud_in);
icp.setInputTarget(cloud_out);
pcl::PointCloud<pcl::PointXYZRGBA> Final;
icp.setMaximumIterations(1000000);
icp.setRANSACOutlierRejectionThreshold(0.01);
icp.align(Final);
std::cout << "has converged:" << icp.hasConverged() << " score: " <<
icp.getFitnessScore() << std::endl;
std::cout << icp.getFinalTransformation() << std::endl;
//translation, rotation
Eigen::Matrix4f icp_transformation=icp.getFinalTransformation();
Eigen::Matrix3f icp_rotation = icp_transformation.block<3,3>(0,0);
Eigen::Vector3f euler = icp_rotation.eulerAngles(0,1,2);
std::cout << "rotation: " << euler.transpose() << std::endl;
std::cout << "translation:" << icp_transformation.block<3,1>(0,3).transpose() << std::endl;
}
return (0);
}
/* ---[ */
int
main (int argc, char** argv)
{
srand (static_cast<unsigned int> (time (0)));
print_info ("The viewer window provides interactive commands; for help, press 'h' or 'H' from within the window.\n");
if (argc < 2)
{
printHelp (argc, argv);
return (-1);
}
bool debug = false;
pcl::console::parse_argument (argc, argv, "-debug", debug);
if (debug)
pcl::console::setVerbosityLevel (pcl::console::L_DEBUG);
// Parse the command line arguments for .pcd files
std::vector<int> p_file_indices = pcl::console::parse_file_extension_argument (argc, argv, ".pcd");
std::vector<int> vtk_file_indices = pcl::console::parse_file_extension_argument (argc, argv, ".vtk");
if (p_file_indices.size () == 0 && vtk_file_indices.size () == 0)
{
print_error ("No .PCD or .VTK file given. Nothing to visualize.\n");
return (-1);
}
// Command line parsing
double bcolor[3] = {0, 0, 0};
pcl::console::parse_3x_arguments (argc, argv, "-bc", bcolor[0], bcolor[1], bcolor[2]);
std::vector<double> fcolor_r, fcolor_b, fcolor_g;
bool fcolorparam = pcl::console::parse_multiple_3x_arguments (argc, argv, "-fc", fcolor_r, fcolor_g, fcolor_b);
std::vector<double> pose_x, pose_y, pose_z, pose_roll, pose_pitch, pose_yaw;
bool poseparam = pcl::console::parse_multiple_3x_arguments (argc, argv, "-position", pose_x, pose_y, pose_z);
poseparam &= pcl::console::parse_multiple_3x_arguments (argc, argv, "-orientation", pose_roll, pose_pitch, pose_yaw);
std::vector<int> psize;
pcl::console::parse_multiple_arguments (argc, argv, "-ps", psize);
std::vector<double> opaque;
pcl::console::parse_multiple_arguments (argc, argv, "-opaque", opaque);
std::vector<std::string> shadings;
pcl::console::parse_multiple_arguments (argc, argv, "-shading", shadings);
int mview = 0;
pcl::console::parse_argument (argc, argv, "-multiview", mview);
int normals = 0;
pcl::console::parse_argument (argc, argv, "-normals", normals);
float normals_scale = NORMALS_SCALE;
pcl::console::parse_argument (argc, argv, "-normals_scale", normals_scale);
int pc = 0;
pcl::console::parse_argument (argc, argv, "-pc", pc);
float pc_scale = PC_SCALE;
pcl::console::parse_argument (argc, argv, "-pc_scale", pc_scale);
bool use_vbos = false;
pcl::console::parse_argument (argc, argv, "-vbo_rendering", use_vbos);
if (use_vbos)
print_highlight ("Vertex Buffer Object (VBO) visualization enabled.\n");
bool use_pp = pcl::console::find_switch (argc, argv, "-use_point_picking");
if (use_pp)
print_highlight ("Point picking enabled.\n");
bool use_optimal_l_colors = pcl::console::find_switch (argc, argv, "-optimal_label_colors");
if (use_optimal_l_colors)
print_highlight ("Optimal glasbey colors are being assigned to existing labels.\nNote: No static mapping between label ids and colors\n");
// If VBOs are not enabled, then try to use immediate rendering
bool use_immediate_rendering = false;
if (!use_vbos)
{
pcl::console::parse_argument (argc, argv, "-immediate_rendering", use_immediate_rendering);
if (use_immediate_rendering)
print_highlight ("Using immediate mode rendering.\n");
}
// Multiview enabled?
int y_s = 0, x_s = 0;
double x_step = 0, y_step = 0;
if (mview)
{
print_highlight ("Multi-viewport rendering enabled.\n");
y_s = static_cast<int>(floor (sqrt (static_cast<float>(p_file_indices.size () + vtk_file_indices.size ()))));
x_s = y_s + static_cast<int>(ceil (double (p_file_indices.size () + vtk_file_indices.size ()) / double (y_s) - y_s));
if (p_file_indices.size () != 0)
{
print_highlight ("Preparing to load "); print_value ("%d", p_file_indices.size ()); print_info (" pcd files.\n");
}
if (vtk_file_indices.size () != 0)
{
print_highlight ("Preparing to load "); print_value ("%d", vtk_file_indices.size ()); print_info (" vtk files.\n");
}
x_step = static_cast<double>(1.0 / static_cast<double>(x_s));
y_step = static_cast<double>(1.0 / static_cast<double>(y_s));
print_value ("%d", x_s); print_info ("x"); print_value ("%d", y_s);
print_info (" / "); print_value ("%f", x_step); print_info ("x"); print_value ("%f", y_step);
print_info (")\n");
}
// Fix invalid multiple arguments
if (psize.size () != p_file_indices.size () && psize.size () > 0)
for (size_t i = psize.size (); i < p_file_indices.size (); ++i)
psize.push_back (1);
if (opaque.size () != p_file_indices.size () && opaque.size () > 0)
for (size_t i = opaque.size (); i < p_file_indices.size (); ++i)
opaque.push_back (1.0);
if (shadings.size () != p_file_indices.size () && shadings.size () > 0)
for (size_t i = shadings.size (); i < p_file_indices.size (); ++i)
shadings.push_back ("flat");
// Create the PCLVisualizer object
#if VTK_MAJOR_VERSION==6 || (VTK_MAJOR_VERSION==5 && VTK_MINOR_VERSION>6)
boost::shared_ptr<pcl::visualization::PCLPlotter> ph;
#endif
// Using min_p, max_p to set the global Y min/max range for the histogram
float min_p = FLT_MAX; float max_p = -FLT_MAX;
int k = 0, l = 0, viewport = 0;
// Load the data files
pcl::PCDReader pcd;
pcl::console::TicToc tt;
ColorHandlerPtr color_handler;
GeometryHandlerPtr geometry_handler;
// Go through VTK files
for (size_t i = 0; i < vtk_file_indices.size (); ++i)
{
// Load file
tt.tic ();
print_highlight (stderr, "Loading "); print_value (stderr, "%s ", argv[vtk_file_indices.at (i)]);
vtkPolyDataReader* reader = vtkPolyDataReader::New ();
reader->SetFileName (argv[vtk_file_indices.at (i)]);
reader->Update ();
vtkSmartPointer<vtkPolyData> polydata = reader->GetOutput ();
if (!polydata)
return (-1);
print_info ("[done, "); print_value ("%g", tt.toc ()); print_info (" ms : "); print_value ("%d", polydata->GetNumberOfPoints ()); print_info (" points]\n");
// Create the PCLVisualizer object here on the first encountered XYZ file
if (!p)
p.reset (new pcl::visualization::PCLVisualizer (argc, argv, "PCD viewer"));
// Multiview enabled?
if (mview)
{
p->createViewPort (k * x_step, l * y_step, (k + 1) * x_step, (l + 1) * y_step, viewport);
k++;
if (k >= x_s)
{
k = 0;
l++;
}
}
// Add as actor
std::stringstream cloud_name ("vtk-");
cloud_name << argv[vtk_file_indices.at (i)] << "-" << i;
p->addModelFromPolyData (polydata, cloud_name.str (), viewport);
// Change the shape rendered color
if (fcolorparam && fcolor_r.size () > i && fcolor_g.size () > i && fcolor_b.size () > i)
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, fcolor_r[i], fcolor_g[i], fcolor_b[i], cloud_name.str ());
// Change the shape rendered point size
if (psize.size () > 0)
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize.at (i), cloud_name.str ());
// Change the shape rendered opacity
if (opaque.size () > 0)
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_OPACITY, opaque.at (i), cloud_name.str ());
// Change the shape rendered shading
if (shadings.size () > 0)
{
if (shadings[i] == "flat")
{
print_highlight (stderr, "Setting shading property for %s to FLAT.\n", argv[vtk_file_indices.at (i)]);
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_SHADING, pcl::visualization::PCL_VISUALIZER_SHADING_FLAT, cloud_name.str ());
}
else if (shadings[i] == "gouraud")
{
print_highlight (stderr, "Setting shading property for %s to GOURAUD.\n", argv[vtk_file_indices.at (i)]);
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_SHADING, pcl::visualization::PCL_VISUALIZER_SHADING_GOURAUD, cloud_name.str ());
}
else if (shadings[i] == "phong")
{
print_highlight (stderr, "Setting shading property for %s to PHONG.\n", argv[vtk_file_indices.at (i)]);
p->setShapeRenderingProperties (pcl::visualization::PCL_VISUALIZER_SHADING, pcl::visualization::PCL_VISUALIZER_SHADING_PHONG, cloud_name.str ());
}
}
}
pcl::PCLPointCloud2::Ptr cloud;
// Go through PCD files
for (size_t i = 0; i < p_file_indices.size (); ++i)
{
tt.tic ();
cloud.reset (new pcl::PCLPointCloud2);
Eigen::Vector4f origin;
Eigen::Quaternionf orientation;
int version;
print_highlight (stderr, "Loading "); print_value (stderr, "%s ", argv[p_file_indices.at (i)]);
if (pcd.read (argv[p_file_indices.at (i)], *cloud, origin, orientation, version) < 0)
return (-1);
// Calculate transform if available.
if (pose_x.size () > i && pose_y.size () > i && pose_z.size () > i &&
pose_roll.size () > i && pose_pitch.size () > i && pose_yaw.size () > i)
{
Eigen::Affine3f pose =
Eigen::Translation3f (Eigen::Vector3f (pose_x[i], pose_y[i], pose_z[i])) *
Eigen::AngleAxisf (pose_yaw[i], Eigen::Vector3f::UnitZ ()) *
Eigen::AngleAxisf (pose_pitch[i], Eigen::Vector3f::UnitY ()) *
Eigen::AngleAxisf (pose_roll[i], Eigen::Vector3f::UnitX ());
orientation = pose.rotation () * orientation;
origin.block<3, 1> (0, 0) = (pose * Eigen::Translation3f (origin.block<3, 1> (0, 0))).translation ();
}
std::stringstream cloud_name;
// ---[ Special check for 1-point multi-dimension histograms
if (cloud->fields.size () == 1 && isMultiDimensionalFeatureField (cloud->fields[0]))
{
cloud_name << argv[p_file_indices.at (i)];
#if VTK_MAJOR_VERSION==6 || (VTK_MAJOR_VERSION==5 && VTK_MINOR_VERSION>6)
if (!ph)
ph.reset (new pcl::visualization::PCLPlotter);
#endif
pcl::getMinMax (*cloud, 0, cloud->fields[0].name, min_p, max_p);
#if VTK_MAJOR_VERSION==6 || (VTK_MAJOR_VERSION==5 && VTK_MINOR_VERSION>6)
ph->addFeatureHistogram (*cloud, cloud->fields[0].name, cloud_name.str ());
#endif
print_info ("[done, "); print_value ("%g", tt.toc ()); print_info (" ms : "); print_value ("%d", cloud->fields[0].count); print_info (" points]\n");
continue;
}
// ---[ Special check for 2D images
if (cloud->fields.size () == 1 && isOnly2DImage (cloud->fields[0]))
{
print_info ("[done, "); print_value ("%g", tt.toc ()); print_info (" ms : "); print_value ("%u", cloud->width * cloud->height); print_info (" points]\n");
print_info ("Available dimensions: "); print_value ("%s\n", pcl::getFieldsList (*cloud).c_str ());
std::stringstream name;
name << "PCD Viewer :: " << argv[p_file_indices.at (i)];
pcl::visualization::ImageViewer::Ptr img (new pcl::visualization::ImageViewer (name.str ()));
pcl::PointCloud<pcl::RGB> rgb_cloud;
pcl::fromPCLPointCloud2 (*cloud, rgb_cloud);
img->addRGBImage (rgb_cloud);
imgs.push_back (img);
continue;
}
cloud_name << argv[p_file_indices.at (i)] << "-" << i;
// Create the PCLVisualizer object here on the first encountered XYZ file
if (!p)
{
p.reset (new pcl::visualization::PCLVisualizer (argc, argv, "PCD viewer"));
if (use_pp) // Only enable the point picking callback if the command line parameter is enabled
p->registerPointPickingCallback (&pp_callback, static_cast<void*> (&cloud));
// Set whether or not we should be using the vtkVertexBufferObjectMapper
p->setUseVbos (use_vbos);
if (!p->cameraParamsSet () && !p->cameraFileLoaded ())
{
Eigen::Matrix3f rotation;
rotation = orientation;
p->setCameraPosition (origin [0] , origin [1] , origin [2],
origin [0] + rotation (0, 2), origin [1] + rotation (1, 2), origin [2] + rotation (2, 2),
rotation (0, 1), rotation (1, 1), rotation (2, 1));
}
}
// Multiview enabled?
if (mview)
{
p->createViewPort (k * x_step, l * y_step, (k + 1) * x_step, (l + 1) * y_step, viewport);
k++;
if (k >= x_s)
{
k = 0;
l++;
}
}
if (cloud->width * cloud->height == 0)
{
print_error ("[error: no points found!]\n");
return (-1);
}
// If no color was given, get random colors
if (fcolorparam)
{
if (fcolor_r.size () > i && fcolor_g.size () > i && fcolor_b.size () > i)
color_handler.reset (new pcl::visualization::PointCloudColorHandlerCustom<pcl::PCLPointCloud2> (cloud, fcolor_r[i], fcolor_g[i], fcolor_b[i]));
else
color_handler.reset (new pcl::visualization::PointCloudColorHandlerRandom<pcl::PCLPointCloud2> (cloud));
}
else
color_handler.reset (new pcl::visualization::PointCloudColorHandlerRandom<pcl::PCLPointCloud2> (cloud));
// Add the dataset with a XYZ and a random handler
geometry_handler.reset (new pcl::visualization::PointCloudGeometryHandlerXYZ<pcl::PCLPointCloud2> (cloud));
// Add the cloud to the renderer
//p->addPointCloud<pcl::PointXYZ> (cloud_xyz, geometry_handler, color_handler, cloud_name.str (), viewport);
p->addPointCloud (cloud, geometry_handler, color_handler, origin, orientation, cloud_name.str (), viewport);
if (mview)
// Add text with file name
p->addText (argv[p_file_indices.at (i)], 5, 5, 10, 1.0, 1.0, 1.0, "text_" + std::string (argv[p_file_indices.at (i)]), viewport);
// If normal lines are enabled
if (normals != 0)
{
int normal_idx = pcl::getFieldIndex (*cloud, "normal_x");
if (normal_idx == -1)
{
print_error ("Normal information requested but not available.\n");
continue;
//return (-1);
}
//
// Convert from blob to pcl::PointCloud
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_xyz (new pcl::PointCloud<pcl::PointXYZ>);
pcl::fromPCLPointCloud2 (*cloud, *cloud_xyz);
cloud_xyz->sensor_origin_ = origin;
cloud_xyz->sensor_orientation_ = orientation;
pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);
pcl::fromPCLPointCloud2 (*cloud, *cloud_normals);
std::stringstream cloud_name_normals;
cloud_name_normals << argv[p_file_indices.at (i)] << "-" << i << "-normals";
p->addPointCloudNormals<pcl::PointXYZ, pcl::Normal> (cloud_xyz, cloud_normals, normals, normals_scale, cloud_name_normals.str (), viewport);
}
/*
// If principal curvature lines are enabled
if (pc != 0)
{
if (normals == 0)
normals = pc;
int normal_idx = pcl::getFieldIndex (*cloud, "normal_x");
if (normal_idx == -1)
{
print_error ("Normal information requested but not available.\n");
continue;
//return (-1);
}
int pc_idx = pcl::getFieldIndex (*cloud, "principal_curvature_x");
if (pc_idx == -1)
{
print_error ("Principal Curvature information requested but not available.\n");
continue;
//return (-1);
}
//
// Convert from blob to pcl::PointCloud
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_xyz (new pcl::PointCloud<pcl::PointXYZ>);
pcl::fromPCLPointCloud2 (*cloud, *cloud_xyz);
cloud_xyz->sensor_origin_ = origin;
cloud_xyz->sensor_orientation_ = orientation;
pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>);
pcl::fromPCLPointCloud2 (*cloud, *cloud_normals);
pcl::PointCloud<pcl::PrincipalCurvatures>::Ptr cloud_pc (new pcl::PointCloud<pcl::PrincipalCurvatures>);
pcl::fromPCLPointCloud2 (*cloud, *cloud_pc);
std::stringstream cloud_name_normals_pc;
cloud_name_normals_pc << argv[p_file_indices.at (i)] << "-" << i << "-normals";
int factor = (std::min)(normals, pc);
p->addPointCloudNormals<pcl::PointXYZ, pcl::Normal> (cloud_xyz, cloud_normals, factor, normals_scale, cloud_name_normals_pc.str (), viewport);
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1.0, 0.0, 0.0, cloud_name_normals_pc.str ());
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, 3, cloud_name_normals_pc.str ());
cloud_name_normals_pc << "-pc";
p->addPointCloudPrincipalCurvatures<pcl::PointXYZ, pcl::Normal> (cloud_xyz, cloud_normals, cloud_pc, factor, pc_scale, cloud_name_normals_pc.str (), viewport);
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_LINE_WIDTH, 3, cloud_name_normals_pc.str ());
}
*/
// Add every dimension as a possible color
if (!fcolorparam)
{
int rgb_idx = 0;
int label_idx = 0;
for (size_t f = 0; f < cloud->fields.size (); ++f)
{
if (cloud->fields[f].name == "rgb" || cloud->fields[f].name == "rgba")
{
rgb_idx = f + 1;
color_handler.reset (new pcl::visualization::PointCloudColorHandlerRGBField<pcl::PCLPointCloud2> (cloud));
}
//else if (cloud->fields[f].name == "label")
//{
// label_idx = f + 1;
//color_handler.reset (new pcl::visualization::PointCloudColorHandlerLabelField<pcl::PCLPointCloud2> (cloud, !use_optimal_l_colors));
//}
else
{
if (!isValidFieldName (cloud->fields[f].name))
continue;
color_handler.reset (new pcl::visualization::PointCloudColorHandlerGenericField<pcl::PCLPointCloud2> (cloud, cloud->fields[f].name));
}
// Add the cloud to the renderer
//p->addPointCloud<pcl::PointXYZ> (cloud_xyz, color_handler, cloud_name.str (), viewport);
p->addPointCloud (cloud, color_handler, origin, orientation, cloud_name.str (), viewport);
}
// Set RGB color handler or label handler as default
p->updateColorHandlerIndex (cloud_name.str (), (rgb_idx ? rgb_idx : label_idx));
}
// Additionally, add normals as a handler
geometry_handler.reset (new pcl::visualization::PointCloudGeometryHandlerSurfaceNormal<pcl::PCLPointCloud2> (cloud));
if (geometry_handler->isCapable ())
//p->addPointCloud<pcl::PointXYZ> (cloud_xyz, geometry_handler, cloud_name.str (), viewport);
p->addPointCloud (cloud, geometry_handler, origin, orientation, cloud_name.str (), viewport);
if (use_immediate_rendering)
// Set immediate mode rendering ON
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_IMMEDIATE_RENDERING, 1.0, cloud_name.str ());
// Change the cloud rendered point size
if (psize.size () > 0)
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, psize.at (i), cloud_name.str ());
// Change the cloud rendered opacity
if (opaque.size () > 0)
p->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_OPACITY, opaque.at (i), cloud_name.str ());
// Reset camera viewpoint to center of cloud if camera parameters were not passed manually and this is the first loaded cloud
if (i == 0 && !p->cameraParamsSet () && !p->cameraFileLoaded ())
{
p->resetCameraViewpoint (cloud_name.str ());
p->resetCamera ();
}
print_info ("[done, "); print_value ("%g", tt.toc ()); print_info (" ms : "); print_value ("%u", cloud->width * cloud->height); print_info (" points]\n");
print_info ("Available dimensions: "); print_value ("%s\n", pcl::getFieldsList (*cloud).c_str ());
if (p->cameraFileLoaded ())
print_info ("Camera parameters restored from %s.\n", p->getCameraFile ().c_str ());
}
if (!mview && p)
{
std::string str;
if (!p_file_indices.empty ())
str = std::string (argv[p_file_indices.at (0)]);
else if (!vtk_file_indices.empty ())
str = std::string (argv[vtk_file_indices.at (0)]);
for (size_t i = 1; i < p_file_indices.size (); ++i)
str += ", " + std::string (argv[p_file_indices.at (i)]);
for (size_t i = 1; i < vtk_file_indices.size (); ++i)
str += ", " + std::string (argv[vtk_file_indices.at (i)]);
p->addText (str, 5, 5, 10, 1.0, 1.0, 1.0, "text_allnames");
}
if (p)
p->setBackgroundColor (bcolor[0], bcolor[1], bcolor[2]);
// Read axes settings
double axes = 0.0;
pcl::console::parse_argument (argc, argv, "-ax", axes);
if (axes != 0.0 && p)
{
float ax_x = 0.0, ax_y = 0.0, ax_z = 0.0;
pcl::console::parse_3x_arguments (argc, argv, "-ax_pos", ax_x, ax_y, ax_z);
// Draw XYZ axes if command-line enabled
p->addCoordinateSystem (axes, ax_x, ax_y, ax_z, "global");
}
// Clean up the memory used by the binary blob
// Note: avoid resetting the cloud, otherwise the PointPicking callback will fail
if (!use_pp) // Only enable the point picking callback if the command line parameter is enabled
{
cloud.reset ();
xyzcloud.reset ();
}
// If we have been given images, create our own loop so that we can spin each individually
if (!imgs.empty ())
{
bool stopped = false;
do
{
#if VTK_MAJOR_VERSION==6 || (VTK_MAJOR_VERSION==5 && VTK_MINOR_VERSION>6)
if (ph) ph->spinOnce ();
#endif
for (int i = 0; i < int (imgs.size ()); ++i)
{
if (imgs[i]->wasStopped ())
{
stopped = true;
break;
}
imgs[i]->spinOnce ();
}
if (p)
{
if (p->wasStopped ())
{
stopped = true;
break;
}
p->spinOnce ();
}
boost::this_thread::sleep (boost::posix_time::microseconds (100));
}
while (!stopped);
}
else
{
// If no images, continue
#if VTK_MAJOR_VERSION==6 || (VTK_MAJOR_VERSION==5 && VTK_MINOR_VERSION>6)
if (ph)
{
//print_highlight ("Setting the global Y range for all histograms to: "); print_value ("%f -> %f\n", min_p, max_p);
//ph->setGlobalYRange (min_p, max_p);
//ph->updateWindowPositions ();
if (p)
p->spin ();
else
ph->spin ();
}
else
#endif
if (p)
p->spin ();
}
}
// visualizzazione doppia
void VisualizationUtils::vis_doppia( string name1, string name2) {
std::stringstream firstCloud;
firstCloud<<"./../registrazione/cloud"<<name1<<".ply";
std::stringstream secondCloud;
secondCloud<<"./../registrazione/cloud"<<name2<<".ply";
cout<<firstCloud.str()<<endl;
cout<<secondCloud.str()<<endl;
pcl::PointCloud<POINT_TYPE>::Ptr cloud1 (new pcl::PointCloud<POINT_TYPE>);
pcl::PointCloud<POINT_TYPE>::Ptr cloud2 (new pcl::PointCloud<POINT_TYPE>);
pcl::io::loadPLYFile(firstCloud.str().c_str(),*cloud1);
pcl::io::loadPLYFile(secondCloud.str().c_str(),*cloud2);
pcl::PointCloud<POINT_TYPE>::Ptr clicked_points_app(new pcl::PointCloud<POINT_TYPE>);
pcl::PointCloud<POINT_TYPE>::Ptr clicked_points2_app(new pcl::PointCloud<POINT_TYPE>);
// resetto le variabili globali
clicked_points_app->clear();
clicked_points2_app->clear();
points_left.clear_stack();
points_right.clear_stack();
color_left.restart();
color_right.restart();
clicked_points = clicked_points2_app;
clicked_points2 = clicked_points2_app;
// creo la finestra
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(new pcl::visualization::PCLVisualizer("3D Viewer"));
global_viewer = viewer;
// viewer->initCameraParameters();
// viewer->setSize(1200, 650);
// assegno la prima cloud
viewer->createViewPort(0.0, 0.0, 0.5, 1.0, v1);
viewer->setCameraPosition(0.0, 0.0, 0.0, 0.0, 0.0, 0.15, 0.0, 1.0, 0.0, v1);
viewer->setBackgroundColor(0.2, 0.2, 0.2, v1); // background grigio
viewer->addText("Prossimo colore: " + color_left.getColorName(), 10, 10, "v1_text", v1);
pcl::visualization::PointCloudColorHandlerRGBField<POINT_TYPE> rgb(cloud1);
viewer->addPointCloud<POINT_TYPE>(cloud1, rgb, name1, v1);
viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, name1);
// assegno la seconda cloud
viewer->createViewPort(0.5, 0.0, 1.0, 1.0, v2);
viewer->setBackgroundColor(0.3, 0.3, 0.3, v2);
viewer->addText("Prossimo colore: " + color_right.getColorName(), 10, 10, "v2_text", v2);
pcl::visualization::PointCloudColorHandlerRGBField<POINT_TYPE> rgb2(cloud2);
// la traslo per poter identificare i suoi punti
Eigen::Affine3f transform = Eigen::Affine3f::Identity();
transform.translation() << 0.0, 0.0, TRANLSATION_Z_SECOND_CLOUD;
//cout << "matrice applicata alla seconda cloud" << endl << transform.matrix() << endl;
pcl::PointCloud<POINT_TYPE>::Ptr transformed_cloud2(new pcl::PointCloud<POINT_TYPE>);
pcl::transformPointCloud(*cloud2, *transformed_cloud2, transform);
viewer->addPointCloud<POINT_TYPE>(transformed_cloud2, rgb2, name2, v2);
viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, name2);
// gestione separata della telecamera
viewer->createViewPortCamera(v2);
viewer->setCameraPosition(0.0, 0.0, TRANLSATION_Z_SECOND_CLOUD, 0.0, 0.0, TRANLSATION_Z_SECOND_CLOUD + 0.15, 0.0, 1.0, 0.0, v2);
// viewer->registerKeyboardCallback(keyboardEventOccurred, (void*)&viewer);
// viewer->registerPointPickingCallback(pointPickDoubleViewEvent, (void*)&viewer);
loop_view(viewer);
// chiusa la view, stampo i punti catturati
cout << "Punti selezionati:" << endl << " -> cloud sinistra:" << endl;
//cout << endl << points_left.makeMatrix() << endl;
points_left.print_all();
cout << " -> cloud destra:" << endl;
//cout << endl << points_right.makeMatrix() << endl;
points_right.print_all();
Eigen::MatrixXf Mx = points_left.makeMatrix();
Eigen::MatrixXf My = points_right.makeMatrix();
if (Mx.cols() != My.cols()) {
cout << "Errore... Hai preso un numero diverso di punti tra destra e sinistra?" << endl;
return ;
}
/*if (Mx.cols() < 3) {
cout << "Dai, sforzati di prendere almeno 3 punti..." << endl;
return;
}*/
Eigen::Matrix4f T = TransformationUtils::trovaT(Mx, My);
ofstream outFile("/home/miky/Scrivania/trasformazione.txt");
outFile << T;
cout << " -> matrice di trasformazione salvata nel file trasformazione.txt" << endl;
pcl::PointCloud<POINT_TYPE>::Ptr result(new pcl::PointCloud<POINT_TYPE>);
pcl::transformPointCloud(*cloud1, *result, T);
pcl::io::savePLYFileBinary("/home/miky/Scrivania/Cloud12.ply", *result);
cout << " -> salvata la cloud traslata con nome Cloud12.ply" << endl;
return ;
}
void cloud_cb (const sensor_msgs::PointCloud2Ptr& input)
{
int is_save = false;
int is_predict = true;
// Create a container for the data.
pcl::PointCloud<pcl::PointXYZI>::Ptr conv_input(new pcl::PointCloud<pcl::PointXYZI>());
input->fields[3].name = "intensity";
pcl::fromROSMsg(*input, *conv_input);
// Size of humansize cloud
int cloud_size = conv_input->points.size();
std::cout << "cloud_size: " << cloud_size << std::endl;
if( cloud_size <= 1 ){
return;
}
pcl::PCA<pcl::PointXYZI> pca;
pcl::PointCloud<pcl::PointXYZI>::Ptr transform_cloud_translate(new pcl::PointCloud<pcl::PointXYZI>());
pcl::PointCloud<pcl::PointXYZI>::Ptr transform_cloud_rotate(new pcl::PointCloud<pcl::PointXYZI>());
sensor_msgs::PointCloud2 output;
geometry_msgs::PointStamped::Ptr output_point(new geometry_msgs::PointStamped());
geometry_msgs::PointStamped output_point_;
Eigen::Vector3f eigen_values;
Eigen::Vector4f centroid;
Eigen::Matrix3f eigen_vectors;
Eigen::Affine3f translate = Eigen::Affine3f::Identity();
Eigen::Affine3f rotate = Eigen::Affine3f::Identity();
double theta;
std::vector<double> description;
description.push_back(cloud_size);
pcl::PointCloud<pcl::PointNormal>::Ptr normals(new pcl::PointCloud<pcl::PointNormal>());
pcl::NormalEstimation<pcl::PointXYZI, pcl::PointNormal> ne;
ne.setInputCloud(conv_input);
ne.setKSearch(24);
ne.compute(*normals);
pcl::FPFHEstimation<pcl::PointXYZI, pcl::PointNormal, pcl::FPFHSignature33> fpfh;
fpfh.setInputCloud(conv_input);
fpfh.setInputNormals(normals);
pcl::search::KdTree<pcl::PointXYZI>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZI>());
fpfh.setSearchMethod(tree);
pcl::PointCloud<pcl::FPFHSignature33>::Ptr fpfhs(new pcl::PointCloud<pcl::FPFHSignature33>());
fpfh.setRadiusSearch(0.05);
fpfh.compute(*fpfhs);
// for(int i=0;i<fpfhs.histogram.size();i++){
std::cout << fpfhs->points.size();
// }
std::cout << std::endl;
//PCA
pca.setInputCloud(conv_input);
centroid = pca.getMean();
std::cout << "Centroid of pointcloud: " << centroid[0] << ", " << centroid[1] << ", " << centroid[2] << std::endl;
eigen_values = pca.getEigenValues();
std::cout << "Eigen values of PCAed pointcloud: " << eigen_values[0] << ", " << eigen_values[1] << ", " << eigen_values[2] << std::endl;
eigen_vectors << pca.getEigenVectors();
std::cout << "Eigen Vectors of PCAed pointcloud:" << std::endl;
for(int i=0;i<eigen_vectors.rows()*eigen_vectors.cols();i++){
std::cout << eigen_vectors(i) << " ";
if(!((i+1)%3)){
std::cout << std::endl;
}
}
std::cout << std::endl;
//Rotation cloud from PCA data
theta = atan2(eigen_vectors(1,0), eigen_vectors(0,0));
std::cout << "Theta: " << theta << std::endl;
translate.translation() << -centroid[0], -centroid[1], -centroid[2];
pcl::transformPointCloud(*conv_input, *transform_cloud_translate, translate);
rotate.rotate(Eigen::AngleAxisf(-theta, Eigen::Vector3f::UnitZ()));
pcl::transformPointCloud(*transform_cloud_translate, *transform_cloud_rotate, rotate);
pcl::toROSMsg(*transform_cloud_rotate, output);
output.header = input -> header;
output.header.frame_id = "map";
pub.publish(output);
pcl::PointXYZI searchPoint;
searchPoint.x = 0.0;
searchPoint.y = 0.0;
searchPoint.z = 0.0;
float min_distance,min_distance_tmp;
min_distance = sqrt(
powf( conv_input->points[0].x - searchPoint.x, 2.0f ) +
powf( conv_input->points[0].y - searchPoint.y, 2.0f ) +
powf( conv_input->points[0].z - searchPoint.z, 2.0f )
);
//brute force nearest neighbor search
for(int i=1; i<conv_input->size(); i++){
min_distance_tmp = sqrt(
powf( conv_input->points[i].x - searchPoint.x, 2.0f ) +
powf( conv_input->points[i].y - searchPoint.y, 2.0f ) +
powf( conv_input->points[i].z - searchPoint.z, 2.0f )
);
if( min_distance < min_distance_tmp){
min_distance = min_distance_tmp;
}
}
std::cout << "min_distance: " << min_distance << std::endl;
std::cout << std::endl;
description.push_back(min_distance);
// Calculate center of mass of humansize cloud
Vector4f center_of_mass;
pcl::compute3DCentroid(*transform_cloud_rotate, center_of_mass);
MatrixXf convariance_matrix = MatrixXf::Zero(3,3);
MatrixXf convariance_matrix_tmp = MatrixXf::Zero(3,3);
MatrixXf moment_of_inertia_matrix_tmp = MatrixXf::Zero(3,3);
MatrixXf moment_of_inertia_matrix = MatrixXf::Zero(3,3);
Vector3f point_tmp;
Vector3f point_from_center_of_mass;
// intensity buffer
double intensity_sum=0, intensity_ave=0, intensity_pow_sum=0, intensity_std_dev=0, max_intensity = 5000;
std::vector<double> intensity_histgram(25);
for(int i=0; i<cloud_size; i++){
point_tmp << transform_cloud_rotate->points[i].x, transform_cloud_rotate->points[i].y, transform_cloud_rotate->points[i].z;
//Calculate three dimentional convariance matrix
point_from_center_of_mass <<
center_of_mass[1] - point_tmp[1],
center_of_mass[0] - point_tmp[0],
center_of_mass[2] - point_tmp[2];
convariance_matrix_tmp += point_tmp * point_tmp.transpose();
//Calculate three dimentional moment of inertia matrix
moment_of_inertia_matrix_tmp <<
powf(point_tmp[1],2.0f)+powf(point_tmp[2],2.0f), -point_tmp[0]*point_tmp[1], -point_tmp[0]*point_tmp[2],
-point_tmp[0]*point_tmp[1], powf(point_tmp[0],2.0f)+powf(point_tmp[2],2.0f), -point_tmp[1]*point_tmp[2],
-point_tmp[0]*point_tmp[2], -point_tmp[1]*point_tmp[2], powf(point_tmp[0],2.0f)+powf(point_tmp[1],2.0f);
moment_of_inertia_matrix = moment_of_inertia_matrix + moment_of_inertia_matrix_tmp;
// Calculate intensity distribution
intensity_sum += transform_cloud_rotate->points[i].intensity;
intensity_pow_sum += powf(transform_cloud_rotate->points[i].intensity,2);
intensity_histgram[transform_cloud_rotate->points[i].intensity / (max_intensity / intensity_histgram.size())] += 1;
if( g_max_inten < transform_cloud_rotate->points[i].intensity ){
g_max_inten = transform_cloud_rotate->points[i].intensity;
}
}
//Calculate Convariance matrix
convariance_matrix = (1.0f/cloud_size) * convariance_matrix_tmp.array();
// Calculate intensity distribution
intensity_ave = intensity_sum / cloud_size;
std::cout << "max_intensity: " << g_max_inten << std::endl;
std::cout << "intensity_ave: " << intensity_ave << std::endl;
intensity_std_dev = sqrt(fabs(intensity_pow_sum / cloud_size - powf(intensity_ave,2)));
std::cout << "intensity_std_dev: " << intensity_std_dev <<std::endl;
std::cout << "intensity_histgram: ";
description.push_back(intensity_ave);
description.push_back(intensity_std_dev);
for(int i=0; i<intensity_histgram.size(); i++){
intensity_histgram[i] = intensity_histgram[i] / cloud_size;
std::cout << intensity_histgram[i] << " ";
description.push_back(intensity_histgram[i]);
}
std::cout << std::endl;
std::cout << std::endl;
std::cout << "3D convariance matrix:" << std::endl;
for(int i=0;i<convariance_matrix.rows()*convariance_matrix.cols();i++){
if(i<5 || i==6){
description.push_back(convariance_matrix(i));
}
std::cout << convariance_matrix(i) << " ";
if(!((i+1)%3)){
std::cout << std::endl;
}
}
std::cout << std::endl;
std::cout << "moment of inertia:" << std::endl;
for(int i=0;i<moment_of_inertia_matrix.rows()*moment_of_inertia_matrix.cols();i++){
if(i<5 || i==6){
description.push_back(convariance_matrix(i));
}
std::cout << moment_of_inertia_matrix(i) << " ";
if(!((i+1)%3)){
std::cout << std::endl;
}
}
std::cout << std::endl;
//Calculate Slice distribution
pcl::PointXYZI min_pt,max_pt,sliced_min_pt,sliced_max_pt;
pcl::getMinMax3D(*transform_cloud_rotate, min_pt, max_pt);
int sectors = 10;
double sector_height = (max_pt.z - min_pt.z)/sectors;
pcl::PassThrough<pcl::PointXYZI> pass;
std::vector<std::vector<double> > slice_dist(sectors,std::vector<double> (2));
for(double sec_h = min_pt.z,i = 0; sec_h < max_pt.z - sector_height; sec_h += sector_height, i++){
pcl::PointCloud<pcl::PointXYZI>::Ptr cloud_sliced(new pcl::PointCloud<pcl::PointXYZI>());
pass.setInputCloud(transform_cloud_rotate);
pass.setFilterFieldName("z");
pass.setFilterLimits(sec_h, sec_h + sector_height);
pass.filter(*cloud_sliced);
pcl::getMinMax3D(*cloud_sliced,sliced_min_pt,sliced_max_pt);
slice_dist[i][0] = sliced_max_pt.x - sliced_min_pt.x;
slice_dist[i][1] = sliced_max_pt.y - sliced_min_pt.y;
}
std::cout << "slice distribution:" << std::endl;
for(int i=0;i<2;i++){
for(int j=0;j<10;j++){
description.push_back(slice_dist[j][i]);
std::cout << slice_dist[j][i] << " ";
}
std::cout << std::endl;
}
std::cout << std::endl;
if(is_save){
std::ofstream ofs;
ofs.open("description.txt", std::ios::ate | std::ios::app);
ofs << "1 ";
for(int i=0;i<description.size();i++){
ofs << i+1 << ":" << description[i] << " ";
}
ofs << std::endl;
ofs.close();
}
if(is_predict){
FILE *fp_scale, *fp_model;
int idx,max_index;
std::vector<double> scale_min;
std::vector<double> scale_max;
double scale_min_tmp;
double scale_max_tmp;
double lower,upper;
double predict;
struct svm_model* model = svm_load_model(
model_filename.c_str());
struct svm_node *nodes;
nodes = (struct svm_node *)malloc((description.size()+1)*sizeof(struct svm_node));
fp_scale = fopen(scale_filename.c_str(),"r");
if(fp_scale == NULL || model == NULL){
ROS_ERROR_STREAM("Can't find model or scale data");
return;
}
if(fgetc(fp_scale) != 'x'){
return;
}
fscanf(fp_scale,"%lf %lf",&lower,&upper);
// ROS_INFO_STREAM("lower: " << lower << "upper: "<< upper);
while(fscanf(fp_scale,"%d %lf %lf\n",&idx,&scale_min_tmp,&scale_max_tmp) == 3){
scale_min.push_back(scale_min_tmp);
scale_max.push_back(scale_max_tmp);
}
std::cout << "scaled description :";
int index = 0;
for(int i=0;i<description.size();i++){
if(i<24 || i>28){
if(description[i] == DBL_INF || description[i] == DBL_MINF){
description[i] = 0;
}
if(description[i] < scale_min[index]){
nodes[index].index = i+1;
nodes[index].value = lower;
}
else if(description[i] > scale_max[index]){
nodes[index].index = i+1;
nodes[index].value = upper;
}
else{
nodes[index].index = i+1;
nodes[index].value = lower + (upper-lower) *
(description[i]-scale_min[index])/
(scale_max[index]-scale_min[index]);
}
std::cout << nodes[index].index << ":" << nodes[index].value << ",";
index++;
}
}
nodes[index].index = -1;
std::cout << std::endl;
predict = svm_predict(model,nodes);
ROS_INFO_STREAM("Predict" << predict);
if(predict == 1){
Vector4f center_of_mass_base;
pcl::compute3DCentroid(*conv_input, center_of_mass_base);
output_point->point.x = center_of_mass_base[0];
output_point->point.y = center_of_mass_base[1];
if(std::abs(center_of_mass_base[1]) > 2.0){
if(center_of_mass_base[1] < 0){
output_point->point.y = center_of_mass_base[1] + 1.0;
}
else{
output_point->point.y = center_of_mass_base[1] - 1.0;
}
}
else{
output_point->point.x = center_of_mass_base[0] - 2.0;
}
output_point->point.z = 0.0;
ROS_INFO_STREAM("target_center :" << center_of_mass_base[1] << "," << center_of_mass_base[0] << "," << center_of_mass_base[2]);
output_point->header.frame_id = "base_link";
output_point->header.stamp = input->header.stamp;
try{
listener->transformPoint("/map", *output_point, output_point_);
}
catch(tf::TransformException &e){
ROS_WARN_STREAM("tf::TransformException: " << e.what());
}
pub_point.publish(output_point_);
}
}
}
void setMatrix(const Eigen::Affine3f& matrix)
{
setMatrix((float*)matrix.data());
}
NORI_NAMESPACE_BEGIN
NoriObject *loadFromXML(const std::string &filename) {
/* Load the XML file using 'pugi' (a tiny self-contained XML parser implemented in C++) */
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(filename.c_str());
/* Helper function: map a position offset in bytes to a more readable row/column value */
auto offset = [&](ptrdiff_t pos) -> std::string {
std::fstream is(filename);
char buffer[1024];
int line = 0, linestart = 0, offset = 0;
while (is.good()) {
is.read(buffer, sizeof(buffer));
for (int i = 0; i < is.gcount(); ++i) {
if (buffer[i] == '\n') {
if (offset + i >= pos)
return tfm::format("row %i, col %i", line + 1, pos - linestart);
++line;
linestart = offset + i;
}
}
offset += (int) is.gcount();
}
return "byte offset " + std::to_string(pos);
};
if (!result) /* There was a parser / file IO error */
throw NoriException("Error while parsing \"%s\": %s (at %s)", filename, result.description(), offset(result.offset));
/* Set of supported XML tags */
enum ETag {
/* Object classes */
EScene = NoriObject::EScene,
EMesh = NoriObject::EMesh,
EBSDF = NoriObject::EBSDF,
ETEXTURE = NoriObject::ETEXTURE,
EPERLIN = NoriObject::EPERLIN,
EMIXTEXTURE = NoriObject::EMIXTEXTURE,
EMIXBUMPMAP = NoriObject::EMIXBUMPMAP,
EBUMPMAP = NoriObject::EBUMPMAP,
EPhaseFunction = NoriObject::EPhaseFunction,
EEmitter = NoriObject::EEmitter,
EMedium = NoriObject::EMedium,
EVolume = NoriObject::EVolume,
ECamera = NoriObject::ECamera,
EIntegrator = NoriObject::EIntegrator,
ESampler = NoriObject::ESampler,
ETest = NoriObject::ETest,
EReconstructionFilter = NoriObject::EReconstructionFilter,
/* Properties */
EBoolean = NoriObject::EClassTypeCount,
EInteger,
EFloat,
EString,
EPoint,
EVector,
EColor,
ETransform,
ETranslate,
EMatrix,
ERotate,
EScale,
ELookAt,
EInvalid
};
/* Create a mapping from tag names to tag IDs */
std::map<std::string, ETag> tags;
tags["scene"] = EScene;
tags["mesh"] = EMesh;
tags["bsdf"] = EBSDF;
tags["texture"] = ETEXTURE;
tags["bumpmap"] = EBUMPMAP;
tags["perlin"] = EPERLIN;
tags["mixTexture"] = EMIXTEXTURE;
tags["mixBumpmap"] = EMIXBUMPMAP;
tags["bumpmap"] = EBUMPMAP;
tags["emitter"] = EEmitter;
tags["camera"] = ECamera;
tags["medium"] = EMedium;
tags["volume"] = EVolume;
tags["phase"] = EPhaseFunction;
tags["integrator"] = EIntegrator;
tags["sampler"] = ESampler;
tags["rfilter"] = EReconstructionFilter;
tags["test"] = ETest;
tags["boolean"] = EBoolean;
tags["integer"] = EInteger;
tags["float"] = EFloat;
tags["string"] = EString;
tags["point"] = EPoint;
tags["vector"] = EVector;
tags["color"] = EColor;
tags["transform"] = ETransform;
tags["translate"] = ETranslate;
tags["matrix"] = EMatrix;
tags["rotate"] = ERotate;
tags["scale"] = EScale;
tags["lookat"] = ELookAt;
/* Helper function to check if attributes are fully specified */
auto check_attributes = [&](const pugi::xml_node &node, std::set<std::string> attrs) {
for (auto attr : node.attributes()) {
auto it = attrs.find(attr.name());
if (it == attrs.end())
throw NoriException("Error while parsing \"%s\": unexpected attribute \"%s\" in \"%s\" at %s",
filename, attr.name(), node.name(), offset(node.offset_debug()));
attrs.erase(it);
}
if (!attrs.empty())
throw NoriException("Error while parsing \"%s\": missing attribute \"%s\" in \"%s\" at %s",
filename, *attrs.begin(), node.name(), offset(node.offset_debug()));
};
Eigen::Affine3f transform;
/* Helper function to parse a Nori XML node (recursive) */
std::function<NoriObject *(pugi::xml_node &, PropertyList &, int)> parseTag = [&](
pugi::xml_node &node, PropertyList &list, int parentTag) -> NoriObject * {
/* Skip over comments */
if (node.type() == pugi::node_comment || node.type() == pugi::node_declaration)
return nullptr;
if (node.type() != pugi::node_element)
throw NoriException(
"Error while parsing \"%s\": unexpected content at %s",
filename, offset(node.offset_debug()));
/* Look up the name of the current element */
auto it = tags.find(node.name());
if (it == tags.end())
throw NoriException("Error while parsing \"%s\": unexpected tag \"%s\" at %s",
filename, node.name(), offset(node.offset_debug()));
int tag = it->second;
/* Perform some safety checks to make sure that the XML tree really makes sense */
bool hasParent = parentTag != EInvalid;
bool parentIsObject = hasParent && parentTag < NoriObject::EClassTypeCount;
bool currentIsObject = tag < NoriObject::EClassTypeCount;
bool parentIsTransform = parentTag == ETransform;
bool currentIsTransformOp = tag == ETranslate || tag == ERotate || tag == EScale || tag == ELookAt || tag == EMatrix;
if (!hasParent && !currentIsObject)
throw NoriException("Error while parsing \"%s\": root element \"%s\" must be a Nori object (at %s)",
filename, node.name(), offset(node.offset_debug()));
if (parentIsTransform != currentIsTransformOp)
throw NoriException("Error while parsing \"%s\": transform nodes "
"can only contain transform operations (at %s)",
filename, offset(node.offset_debug()));
if (hasParent && !parentIsObject && !(parentIsTransform && currentIsTransformOp))
throw NoriException("Error while parsing \"%s\": node \"%s\" requires a Nori object as parent (at %s)",
filename, node.name(), offset(node.offset_debug()));
if (tag == EScene)
node.append_attribute("type") = "scene";
else if (tag == ETransform)
transform.setIdentity();
PropertyList propList;
std::vector<NoriObject *> children;
for (pugi::xml_node &ch: node.children()) {
NoriObject *child = parseTag(ch, propList, tag);
if (child)
children.push_back(child);
}
NoriObject *result = nullptr;
try {
if (currentIsObject) {
check_attributes(node, { "type" });
/* This is an object, first instantiate it */
result = NoriObjectFactory::createInstance(
node.attribute("type").value(),
propList
);
if (result->getClassType() != (int) tag) {
throw NoriException(
"Unexpectedly constructed an object "
"of type <%s> (expected type <%s>): %s",
NoriObject::classTypeName(result->getClassType()),
NoriObject::classTypeName((NoriObject::EClassType) tag),
result->toString());
}
/* Add all children */
for (auto ch: children) {
result->addChild(ch);
ch->setParent(result);
}
/* Activate / configure the object */
result->activate();
} else {
/* This is a property */
switch (tag) {
case EString: {
check_attributes(node, { "name", "value" });
list.setString(node.attribute("name").value(), node.attribute("value").value());
}
break;
case EFloat: {
check_attributes(node, { "name", "value" });
list.setFloat(node.attribute("name").value(), toFloat(node.attribute("value").value()));
}
break;
case EInteger: {
check_attributes(node, { "name", "value" });
list.setInteger(node.attribute("name").value(), toInt(node.attribute("value").value()));
}
break;
case EBoolean: {
check_attributes(node, { "name", "value" });
list.setBoolean(node.attribute("name").value(), toBool(node.attribute("value").value()));
}
break;
case EPoint: {
check_attributes(node, { "name", "value" });
list.setPoint(node.attribute("name").value(), Point3f(toVector3f(node.attribute("value").value())));
}
break;
case EVector: {
check_attributes(node, { "name", "value" });
list.setVector(node.attribute("name").value(), Vector3f(toVector3f(node.attribute("value").value())));
}
break;
case EColor: {
check_attributes(node, { "name", "value" });
list.setColor(node.attribute("name").value(), Color3f(toVector3f(node.attribute("value").value()).array()));
}
break;
case ETransform: {
check_attributes(node, { "name" });
list.setTransform(node.attribute("name").value(), transform.matrix());
}
break;
case ETranslate: {
check_attributes(node, { "value" });
Eigen::Vector3f v = toVector3f(node.attribute("value").value());
transform = Eigen::Translation<float, 3>(v.x(), v.y(), v.z()) * transform;
}
break;
case EMatrix: {
check_attributes(node, { "value" });
std::vector<std::string> tokens = tokenize(node.attribute("value").value());
if (tokens.size() != 16)
throw NoriException("Expected 16 values");
Eigen::Matrix4f matrix;
for (int i=0; i<4; ++i)
for (int j=0; j<4; ++j)
matrix(i, j) = toFloat(tokens[i*4+j]);
transform = Eigen::Affine3f(matrix) * transform;
}
break;
case EScale: {
check_attributes(node, { "value" });
Eigen::Vector3f v = toVector3f(node.attribute("value").value());
transform = Eigen::DiagonalMatrix<float, 3>(v) * transform;
}
break;
case ERotate: {
check_attributes(node, { "angle", "axis" });
float angle = degToRad(toFloat(node.attribute("angle").value()));
Eigen::Vector3f axis = toVector3f(node.attribute("axis").value());
transform = Eigen::AngleAxis<float>(angle, axis) * transform;
}
break;
case ELookAt: {
check_attributes(node, { "origin", "target", "up" });
Eigen::Vector3f origin = toVector3f(node.attribute("origin").value());
Eigen::Vector3f target = toVector3f(node.attribute("target").value());
Eigen::Vector3f up = toVector3f(node.attribute("up").value());
Vector3f dir = (target - origin).normalized();
Vector3f left = up.normalized().cross(dir);
Vector3f newUp = dir.cross(left);
Eigen::Matrix4f trafo;
trafo << left, newUp, dir, origin,
0, 0, 0, 1;
transform = Eigen::Affine3f(trafo) * transform;
}
break;
default:
throw NoriException("Unhandled element \"%s\"", node.name());
};
}
} catch (const NoriException &e) {
throw NoriException("Error while parsing \"%s\": %s (at %s)", filename,
e.what(), offset(node.offset_debug()));
}
return result;
};
PropertyList list;
return parseTag(*doc.begin(), list, EInvalid);
}
Eigen::Affine3f createTransMatrix( float tx, float ty, float tz ) {
Eigen::Affine3f m = Eigen::Affine3f::Identity();
m.translation() = Eigen::Vector3f( tx, ty, tz );
return m;
}
/**
* @brief service offering table object candidates
*
* @param req request for objects of a class (table objects in this case)
* @param res response of the service which is possible table object candidates
*
* @return true if service successful
*/
bool
getTablesService2 (cob_3d_mapping_msgs::GetTablesRequest &req,
cob_3d_mapping_msgs::GetTablesResponse &res)
{
ROS_INFO("table detection started....");
cob_3d_mapping_msgs::ShapeArray sa, tables;
if (getMapService (sa))
{
tables.header = sa.header;
//test
tables.header.frame_id = "/map" ;
//end of test
processMap(sa, tables);
for (unsigned int i = 0; i < tables.shapes.size (); i++)
{
//Polygon poly;
Polygon::Ptr poly_ptr(new Polygon());
fromROSMsg(tables.shapes[i], *poly_ptr);
cob_3d_mapping_msgs::Table table;
Eigen::Affine3f pose;
Eigen::Vector4f min_pt;
Eigen::Vector4f max_pt;
poly_ptr->computePoseAndBoundingBox(pose,min_pt, max_pt);
table.pose.pose.position.x = pose.translation()(0); //poly_ptr->centroid[0];
table.pose.pose.position.y = pose.translation()(1) ;//poly_ptr->centroid[1];
table.pose.pose.position.z = pose.translation()(2) ;//poly_ptr->centroid[2];
Eigen::Quaternionf quat(pose.rotation());
// ROS_WARN("poly_ptr->centroid[0]");
// std::cout << poly_ptr->centroid[0]<< "\n";
// ROS_WARN("pose.translation()");
// std::cout << pose.translation() << "\n" ;
table.pose.pose.orientation.x = quat.x();
table.pose.pose.orientation.y = quat.y();
table.pose.pose.orientation.z = quat.z();
table.pose.pose.orientation.w = quat.w();
table.x_min = min_pt(0);
table.x_max = max_pt(0);
table.y_min = min_pt(1);
table.y_max = max_pt(1);
table.convex_hull.type = arm_navigation_msgs::Shape::MESH;
for( unsigned int j=0; j<poly_ptr->contours[0].size(); j++)
{
geometry_msgs::Point p;
p.x = poly_ptr->contours[0][j](0);
p.y = poly_ptr->contours[0][j](1);
p.z = poly_ptr->contours[0][j](2);
table.convex_hull.vertices.push_back(p);
}
cob_3d_mapping_msgs::TabletopDetectionResult det;
det.table = table;
res.tables.push_back(det);
}
// sa_pub_.publish (tables);
publishShapeMarker (tables);
table_ctr_ = tables.shapes.size();
ROS_INFO("Found %d tables", table_ctr_);
return true;
}
else
return false;
}