void
run (float pair_width, float voxel_size, float max_coplanarity_angle, int num_hypotheses_to_show)
{
PointCloud<PointXYZ>::Ptr scene_points (new PointCloud<PointXYZ> ()), model_points (new PointCloud<PointXYZ> ());
PointCloud<Normal>::Ptr scene_normals (new PointCloud<Normal> ()), model_normals (new PointCloud<Normal> ());
// Get the points and normals from the scene
if ( !vtk_to_pointcloud ("../../test/tum_table_scene.vtk", *scene_points, *scene_normals) )
return;
vtkPolyData *vtk_model = vtkPolyData::New ();
// Get the points and normals from the scene
if ( !vtk_to_pointcloud ("../../test/tum_amicelli_box.vtk", *model_points, *model_normals, vtk_model) )
return;
// The recognition object
ObjRecRANSAC objrec (pair_width, voxel_size);
objrec.setMaxCoplanarityAngleDegrees (max_coplanarity_angle);
objrec.addModel (*model_points, *model_normals, "amicelli", vtk_model);
// Switch to the test mode in which only oriented point pairs from the scene are sampled
objrec.enterTestModeTestHypotheses ();
// The visualizer
PCLVisualizer viz;
CallbackParameters params(objrec, viz, *scene_points, *scene_normals, num_hypotheses_to_show);
viz.registerKeyboardCallback (keyboardCB, static_cast<void*> (¶ms));
// Run the recognition and update the viewer
update (¶ms);
#ifdef _SHOW_SCENE_POINTS_
viz.addPointCloud (scene_points, "cloud in");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "cloud in");
#endif
#ifdef _SHOW_OCTREE_POINTS_
PointCloud<PointXYZ>::Ptr octree_points (new PointCloud<PointXYZ> ());
objrec.getSceneOctree ().getFullLeavesPoints (*octree_points);
viz.addPointCloud (octree_points, "octree points");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "octree points");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1.0, 0.0, 0.0, "octree points");
#endif
#if defined _SHOW_OCTREE_NORMALS_ && defined _SHOW_OCTREE_POINTS_
PointCloud<Normal>::Ptr octree_normals (new PointCloud<Normal> ());
objrec.getSceneOctree ().getNormalsOfFullLeaves (*octree_normals);
viz.addPointCloudNormals<PointXYZ,Normal> (octree_points, octree_normals, 1, 6.0f, "normals out");
#endif
// Enter the main loop
while (!viz.wasStopped ())
{
//main loop of the visualizer
viz.spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
vtk_model->Delete ();
}
int main()
{
PolygonMesh human_1_mesh;
loadPolygonFilePLY("../data/human_1.ply", human_1_mesh);
PCLVisualizer* viewer = new PCLVisualizer("Mesh viewer");
viewer->addPolygonMesh(human_1_mesh);
while (!viewer->wasStopped()) { viewer->spinOnce(100); }
viewer->close();
delete viewer;
}
void run (const char* file_name, float voxel_size)
{
PointCloud<PointXYZ>::Ptr points_in (new PointCloud<PointXYZ> ());
PointCloud<PointXYZ>::Ptr points_out (new PointCloud<PointXYZ> ());
// Get the points and normals from the input vtk file
if ( !vtk_to_pointcloud (file_name, *points_in) )
return;
// Build the octree with the desired resolution
ORROctree octree;
octree.build (*points_in, voxel_size);
// Now build the octree z-projection
ORROctreeZProjection zproj;
zproj.build (octree, 0.15f*voxel_size, 0.15f*voxel_size);
// The visualizer
PCLVisualizer viz;
show_octree(&octree, viz);
show_octree_zproj(&zproj, viz);
#ifdef _SHOW_POINTS_
// Get the point of every full octree leaf
octree.getFullLeafPoints (*points_out);
// Add the point clouds
viz.addPointCloud (points_in, "cloud in");
viz.addPointCloud (points_out, "cloud out");
// Change the appearance
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "cloud in");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "cloud out");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1.0, 0.0, 0.0, "cloud out");
#endif
// Enter the main loop
while (!viz.wasStopped ())
{
//main loop of the visualizer
viz.spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
}
void
visualize (const ModelLibrary::HashTable& hash_table)
{
PCLVisualizer vis;
vis.setBackgroundColor (0.1, 0.1, 0.1);
const ModelLibrary::HashTableCell* cells = hash_table.getVoxels ();
size_t max_num_entries = 0;
int i, id3[3], num_cells = hash_table.getNumberOfVoxels ();
float half_side, b[6], cell_center[3], spacing = hash_table.getVoxelSpacing ()[0];
char cube_id[128];
// Just get the maximal number of entries in the cells
for ( i = 0 ; i < num_cells ; ++i, ++cells )
{
if (cells->size ()) // That's the number of models in the cell (it's maximum one, since we loaded only one model)
{
size_t num_entries = (*cells->begin ()).second.size(); // That's the number of entries in the current cell for the model we loaded
// Get the max number of entries
if ( num_entries > max_num_entries )
max_num_entries = num_entries;
}
}
// Now, that we have the max. number of entries, we can compute the
// right scale factor for the spheres
float s = (0.5f*spacing)/static_cast<float> (max_num_entries);
cout << "s = " << s << ", max_num_entries = " << max_num_entries << endl;
// Now, render a sphere with the right radius at the right place
for ( i = 0, cells = hash_table.getVoxels () ; i < num_cells ; ++i, ++cells )
{
// Does the cell have any entries?
if (cells->size ())
{
hash_table.compute3dId (i, id3);
hash_table.computeVoxelCenter (id3, cell_center);
// That's half of the cube's side length
half_side = s*static_cast<float> ((*cells->begin ()).second.size ());
// Adjust the bounds of the cube
b[0] = cell_center[0] - half_side; b[1] = cell_center[0] + half_side;
b[2] = cell_center[1] - half_side; b[3] = cell_center[1] + half_side;
b[4] = cell_center[2] - half_side; b[5] = cell_center[2] + half_side;
// Set the id
sprintf (cube_id, "cube %i", i);
// Add to the visualizer
vis.addCube (b[0], b[1], b[2], b[3], b[4], b[5], 1.0, 1.0, 0.0, cube_id);
}
}
vis.addCoordinateSystem(1.5, "global");
vis.resetCamera ();
// Enter the main loop
while (!vis.wasStopped ())
{
vis.spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
}
void
run (float pair_width, float voxel_size, float max_coplanarity_angle)
{
// The object recognizer
ObjRecRANSAC objrec (pair_width, voxel_size);
objrec.setMaxCoplanarityAngleDegrees (max_coplanarity_angle);
// The models to be loaded
list<string> model_names;
model_names.emplace_back("tum_amicelli_box");
model_names.emplace_back("tum_rusk_box");
model_names.emplace_back("tum_soda_bottle");
list<PointCloud<PointXYZ>::Ptr> model_points_list;
list<PointCloud<Normal>::Ptr> model_normals_list;
list<vtkSmartPointer<vtkPolyData> > vtk_models_list;
// Load the models and add them to the recognizer
for (const auto &model_name : model_names)
{
PointCloud<PointXYZ>::Ptr model_points (new PointCloud<PointXYZ> ());
model_points_list.push_back (model_points);
PointCloud<Normal>::Ptr model_normals (new PointCloud<Normal> ());
model_normals_list.push_back (model_normals);
vtkSmartPointer<vtkPolyData> vtk_model = vtkSmartPointer<vtkPolyData>::New ();
vtk_models_list.push_back (vtk_model);
// Compose the file
string file_name = string("../../test/") + model_name + string (".vtk");
// Get the points and normals from the input model
if ( !vtk2PointCloud (file_name.c_str (), *model_points, *model_normals, vtk_model) )
continue;
// Add the model
objrec.addModel (*model_points, *model_normals, model_name, vtk_model);
}
// The scene in which the models are supposed to be recognized
PointCloud<PointXYZ>::Ptr non_plane_points (new PointCloud<PointXYZ> ()), plane_points (new PointCloud<PointXYZ> ());
PointCloud<Normal>::Ptr non_plane_normals (new PointCloud<Normal> ());
// Detect the largest plane in the dataset
if ( !loadScene ("../../test/tum_table_scene.vtk", *non_plane_points, *non_plane_normals, *plane_points) )
return;
// The parameters for the callback function and the visualizer
PCLVisualizer viz;
CallbackParameters params(objrec, viz, *non_plane_points, *non_plane_normals);
viz.registerKeyboardCallback (keyboardCB, static_cast<void*> (¶ms));
// Run the recognition and update the viewer. Have a look at this method, to see how to start the recognition and use the result!
update (¶ms);
// From this line on: visualization stuff only!
#ifdef _SHOW_OCTREE_
show_octree(objrec.getSceneOctree (), viz);
#endif
#ifdef _SHOW_SCENE_POINTS_
viz.addPointCloud (scene_points, "scene points");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "scene points");
#endif
#ifdef _SHOW_OCTREE_POINTS_
PointCloud<PointXYZ>::Ptr octree_points (new PointCloud<PointXYZ> ());
objrec.getSceneOctree ().getFullLeavesPoints (*octree_points);
viz.addPointCloud (octree_points, "octree points");
// viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "octree points");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1.0, 0.0, 0.0, "octree points");
viz.addPointCloud (plane_points, "plane points");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 0.9, 0.9, 0.9, "plane points");
#endif
#if defined _SHOW_OCTREE_NORMALS_ && defined _SHOW_OCTREE_POINTS_
PointCloud<Normal>::Ptr normals_octree (new PointCloud<Normal> ());
objrec.getSceneOctree ().getNormalsOfFullLeaves (*normals_octree);
viz.addPointCloudNormals<PointXYZ,Normal> (points_octree, normals_octree, 1, 6.0f, "normals out");
#endif
// Enter the main loop
while (!viz.wasStopped ())
{
//main loop of the visualizer
viz.spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
}
void run (const char* file_name, float voxel_size)
{
PointCloud<PointXYZ>::Ptr points_in (new PointCloud<PointXYZ> ());
PointCloud<PointXYZ>::Ptr points_out (new PointCloud<PointXYZ> ());
PointCloud<Normal>::Ptr normals_in (new PointCloud<Normal> ());
PointCloud<Normal>::Ptr normals_out (new PointCloud<Normal> ());
// Get the points and normals from the input vtk file
#ifdef _SHOW_OCTREE_NORMALS_
if ( !vtk_to_pointcloud (file_name, *points_in, &(*normals_in)) )
return;
#else
if ( !vtk_to_pointcloud (file_name, *points_in, NULL) )
return;
#endif
// Build the octree with the desired resolution
ORROctree octree;
if ( normals_in->size () )
octree.build (*points_in, voxel_size, &*normals_in);
else
octree.build (*points_in, voxel_size);
// Get the first full leaf in the octree (arbitrary order)
std::vector<ORROctree::Node*>::iterator leaf = octree.getFullLeaves ().begin ();
// Get the average points in every full octree leaf
octree.getFullLeavesPoints (*points_out);
// Get the average normal at the points in each leaf
if ( normals_in->size () )
octree.getNormalsOfFullLeaves (*normals_out);
// The visualizer
PCLVisualizer viz;
// Register a keyboard callback
CallbackParameters params(octree, viz, leaf);
viz.registerKeyboardCallback (keyboardCB, static_cast<void*> (¶ms));
// Add the point clouds
viz.addPointCloud (points_in, "cloud in");
viz.addPointCloud (points_out, "cloud out");
if ( normals_in->size () )
viz.addPointCloudNormals<PointXYZ,Normal> (points_out, normals_out, 1, 6.0f, "normals out");
// Change the appearance
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2, "cloud in");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 5, "cloud out");
viz.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_COLOR, 1.0, 0.0, 0.0, "cloud out");
// Convert the octree to a VTK poly-data object
// show_octree(&octree, viz, true/*show full leaves only*/);
updateViewer (octree, viz, leaf);
// Enter the main loop
while (!viz.wasStopped ())
{
//main loop of the visualizer
viz.spinOnce (100);
boost::this_thread::sleep (boost::posix_time::microseconds (100000));
}
}
