├── README.md
├── src
    ├── CMakeLists.txt
    └── pcl_ed_visualizer.cpp
└── .gitignore


/README.md:
--------------------------------------------------------------------------------
1 | # README
2 | 
3 | This is a project about a edge-detection application with PointCloud Library. 
4 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
 2 | 
 3 | project(pclEDVisualizer)
 4 | 
 5 | find_package(PCL 1.8 REQUIRED)
 6 | find_package(OpenCV REQUIRED)
 7 | 
 8 | include_directories(${PCL_INCLUDE_DIRS})
 9 | link_directories(${PCL_LIBRARY_DIRS})
10 | add_definitions(${PCL_DEFINITIONS})
11 | 
12 | add_executable (pclEDVisualizer pcl_ed_visualizer.cpp)
13 | target_link_libraries (pclEDVisualizer ${PCL_LIBRARIES} ${OpenCV_LIBS}) 
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | 
19 | # Compiled Static libraries
20 | *.lai
21 | *.la
22 | *.a
23 | *.lib
24 | 
25 | # Executables
26 | *.exe
27 | *.out
28 | *.app
29 | 
30 | # Directories
31 | build/
32 | .metadata/
33 | RemoteSystemsTempFiles/
34 | 


--------------------------------------------------------------------------------
/src/pcl_ed_visualizer.cpp:
--------------------------------------------------------------------------------
  1 | /* \author Geoffrey Biggs */
  2 | /* \author Ariel Hernandez */
  3 | 
  4 | 
  5 | #include <iostream>
  6 | 
  7 | #include <boost/thread/thread.hpp>
  8 | #include <pcl/common/common_headers.h>
  9 | #include <pcl/features/normal_3d.h>
 10 | #include <pcl/io/pcd_io.h>
 11 | #include <pcl/visualization/pcl_visualizer.h>
 12 | #include <pcl/features/organized_edge_detection.h>
 13 | #include <pcl/features/integral_image_normal.h>
 14 | #include <opencv2/core/core.hpp>
 15 | #include <opencv2/highgui/highgui.hpp>
 16 | 
 17 | #include <pcl/console/print.h>
 18 | #include <pcl/console/parse.h>
 19 | #include <pcl/io/pcd_io.h>
 20 | #include <pcl/point_cloud.h>
 21 | #include <pcl/point_types.h>
 22 | #include <pcl/impl/point_types.hpp>
 23 | #include <pcl/visualization/cloud_viewer.h>
 24 | #include <pcl/PCLPointCloud2.h>
 25 | 
 26 | 
 27 | using namespace std;
 28 | using namespace pcl;
 29 | using namespace pcl::io;
 30 | using namespace pcl::console;
 31 | using namespace cv;
 32 | 
 33 | #define OK 0
 34 | #define FAILED -1
 35 | 
 36 | 
 37 | // --------------
 38 | // -----Help-----
 39 | // --------------
 40 | void
 41 | printUsage (const char* progName)
 42 | {
 43 |   cout << "\n\nUsage: "<<progName<<" [options]\n\n"
 44 |             << "Options:\n"
 45 |             << "-------------------------------------------\n"
 46 |             << "-help          this help\n"
 47 |             << "-pcd           Simple viewer with a pointcloud file\n"
 48 | 			<< "-rgb           Simple viewer with a rgb file\n"
 49 |             << "-point         Simple viewer with a pointcloud file and a specific point P\n"
 50 | 			<< "-plane         Simple viewer with a pointcloud, a point P and its plane C\n"
 51 | 			<< "-edge          Simple viewer with the edgedetection over a pointcloud file (Not yet)\n"
 52 | 			<< "-all           Simple viewer with the above characteristics (Not yet)\n"
 53 |             << "\n\n";
 54 | }
 55 | 
 56 | // --------------------------------------------
 57 | // -----Open 3D viewer and add point cloud-----
 58 | // --------------------------------------------
 59 | boost::shared_ptr<visualization::PCLVisualizer> simpleVisualisation (PointCloud<PointXYZ>::ConstPtr cloud)
 60 | {
 61 |   boost::shared_ptr<visualization::PCLVisualizer> viewer (new visualization::PCLVisualizer ("3D Viewer"));
 62 |   viewer->setBackgroundColor (0, 0, 0);
 63 |   viewer->addPointCloud<PointXYZ> (cloud, "PointCloud sample");
 64 |   viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, 1, "PointCloud sample");
 65 |   viewer->addCoordinateSystem (1.0);
 66 |   viewer->initCameraParameters ();
 67 |   return (viewer);
 68 | }
 69 | 
 70 | 
 71 | // --------------------------------------------
 72 | // -----Compute EdgeDetection------------------
 73 | // --------------------------------------------
 74 | boost::shared_ptr<visualization::PCLVisualizer> computeEdgeDetection (PointCloud<PointXYZ>::ConstPtr cloud, float th_dd, int max_search)
 75 | {
 76 |   boost::shared_ptr<visualization::PCLVisualizer> viewer (new visualization::PCLVisualizer ("3D Viewer"));
 77 | 
 78 |   PointCloud<Normal>::Ptr normal (new PointCloud<Normal>);
 79 |   IntegralImageNormalEstimation<PointXYZ, Normal> ne;
 80 |   ne.setNormalEstimationMethod (ne.COVARIANCE_MATRIX);
 81 |   ne.setNormalSmoothingSize (10.0f);
 82 |   ne.setBorderPolicy (ne.BORDER_POLICY_MIRROR);
 83 |   ne.setInputCloud (cloud);
 84 |   ne.compute (*normal);
 85 | 
 86 |   OrganizedEdgeFromNormals<PointXYZ, Normal, Label> oed;
 87 |   //OrganizedEdgeFromRGBNormals<PointXYZ, Normal, Label> oed;
 88 |   oed.setInputNormals (normal);
 89 |   oed.setInputCloud (cloud);
 90 |   oed.setDepthDisconThreshold (th_dd);
 91 |   oed.setMaxSearchNeighbors (max_search);
 92 |   oed.setEdgeType (oed.EDGELABEL_NAN_BOUNDARY | oed.EDGELABEL_OCCLUDING | oed.EDGELABEL_OCCLUDED | oed.EDGELABEL_HIGH_CURVATURE | oed.EDGELABEL_RGB_CANNY);
 93 |   PointCloud<Label> labels;
 94 |   vector<PointIndices> label_indices;
 95 |   oed.compute (labels, label_indices);
 96 | 
 97 | 
 98 |   // Display edges in PCLVisualizer
 99 |   viewer->setSize (640, 480);
100 |   viewer->addCoordinateSystem (0.2f, "global");
101 |   viewer->addPointCloud (cloud, "original point cloud");
102 | 
103 |   PointCloud<PointXYZ>::Ptr occluding_edges (new PointCloud<PointXYZ>),
104 |     occluded_edges (new PointCloud<PointXYZ>),
105 |     nan_boundary_edges (new PointCloud<PointXYZ>),
106 |     high_curvature_edges (new PointCloud<PointXYZ>),
107 |     rgb_edges (new PointCloud<PointXYZ>);
108 | 
109 |   copyPointCloud (*cloud, label_indices[0].indices, *nan_boundary_edges);
110 |   copyPointCloud (*cloud, label_indices[1].indices, *occluding_edges);
111 |   copyPointCloud (*cloud, label_indices[2].indices, *occluded_edges);
112 |   copyPointCloud (*cloud, label_indices[3].indices, *high_curvature_edges);
113 |   copyPointCloud (*cloud, label_indices[4].indices, *rgb_edges);
114 | 
115 |   const int point_size = 2;
116 | //  viewer->addPointCloud<PointXYZ> (nan_boundary_edges, "nan boundary edges");
117 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, point_size, "nan boundary edges");
118 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 0.0f, 0.0f, 1.0f, "nan boundary edges");
119 | 
120 |   viewer->addPointCloud<PointXYZ> (occluding_edges, "occluding edges");
121 |   viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, point_size, "occluding edges");
122 |   viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 0.0f, 1.0f, 0.0f, "occluding edges");
123 | 
124 | //  viewer->addPointCloud<PointXYZ> (occluded_edges, "occluded edges");
125 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, point_size, "occluded edges");
126 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 1.0f, 0.0f, 0.0f, "occluded edges");
127 | //
128 | //  viewer->addPointCloud<PointXYZ> (high_curvature_edges, "high curvature edges");
129 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, point_size, "high curvature edges");
130 | //  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 1.0f, 1.0f, 0.0f, "high curvature edges");
131 | 
132 |   viewer->addPointCloud<PointXYZ> (rgb_edges, "rgb edges");
133 |   viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, point_size, "rgb edges");
134 |   viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 0.0f, 1.0f, 1.0f, "rgb edges");
135 | 
136 |   return (viewer);
137 | }
138 | 
139 | 
140 | // --------------
141 | // -----Main-----
142 | // --------------
143 | int main (int argc, char** argv)
144 | {
145 |   // --------------------------------------
146 |   // -----Parse Command Line Arguments-----
147 |   // --------------------------------------
148 | 
149 |   if (find_argument (argc, argv, "-help") >= 0)
150 |   {
151 |     printUsage (argv[0]);
152 |     return 0;
153 |   }
154 |   bool open_file(false),simple_vis(false), image_vis(false), edge_vis(false),point_vis(false),plane_vis(false),all(false);
155 |   if (find_argument (argc, argv, "-pcd") >= 0)
156 |   {
157 |     simple_vis = true;
158 |     open_file=true;
159 |     cout << "Simple visualisation of point cloud file\n";
160 |   }
161 |   else if (find_argument (argc, argv, "-rgb") >= 0)
162 |   {
163 |     image_vis = true;
164 |     cout << "Open a depth image\n";
165 |   }
166 |   else if (find_argument (argc, argv, "-point") >= 0)
167 |   {
168 |     point_vis = true;
169 |     open_file=true;
170 |     cout << "Simple visualisation: pointcloud + P\n";
171 |   }
172 |   else if (find_argument (argc, argv, "-plane") >= 0)
173 |   {
174 | 	open_file=true;
175 | 	plane_vis = true;
176 |     cout << "Simple visualisation: pointcloud + P + plane\n";
177 |   }
178 |   else if (find_argument (argc, argv, "-edge") >= 0)
179 |   {
180 | 	edge_vis = true;
181 |     cout << "EdgeDetection in the point cloud file (NOT YET)\n";
182 |   }
183 |   else if (find_argument (argc, argv, "-all") >= 0)
184 |   {
185 |     simple_vis = false;
186 |     point_vis = true;
187 |     plane_vis = true;
188 |     edge_vis = true;
189 |     cout << "All characteristics activated!\n";
190 |   }
191 |   else
192 |   {
193 |     printUsage (argv[0]);
194 |     return OK;
195 |   }
196 | 
197 |   // ------------------------------------
198 |   // -----Open a PCD file ---------------
199 | 
200 |   PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>);
201 |   PointCloud<PointXYZ>::Ptr point (new PointCloud<PointXYZ>);
202 | 
203 |   if (open_file) //TODO: delete hard code, implements args
204 |   {
205 |     if (loadPCDFile<PointXYZ> ("/home/ahestevenz/cloud.pcd", *cloud) == -1) //* load the file
206 |     {
207 |       PCL_ERROR ("Couldn't read file cloud.pcd \n");
208 |       return (FAILED);
209 |     }
210 |     if (loadPCDFile<PointXYZ> ("/home/ahestevenz/point.pcd", *point) == -1) //* load the file
211 |     {
212 |        PCL_ERROR ("Couldn't read file point.pcd \n");
213 |        return (FAILED);
214 |     }
215 |     cout << "Data points loaded!" << endl;
216 |   }
217 | 
218 |   // ------------------------------------
219 |   // -----Open the image ---------------
220 |   // ------------------------------------
221 |   Mat image;
222 |   if (image_vis) //TODO: delete hard code, implements args
223 |   {
224 |     image = imread("/home/ahestevenz/image.png", CV_LOAD_IMAGE_UNCHANGED ); // Read the file
225 |     image.convertTo(image, CV_32F); // convert the image data to float type
226 |   }
227 | 
228 |   // -----Build the plane ---------------
229 |   // ------------------------------------
230 | 
231 |   ModelCoefficients plane_coeff;
232 |   plane_coeff.values.resize(4);    // We need 4 values
233 |   plane_coeff.values[0] = -0.314149; //TODO: delete hard code, implements args.
234 |   plane_coeff.values[1] = 0.0466992;
235 |   plane_coeff.values[2] = -0.948224;
236 |   plane_coeff.values[3] = 1.11784;
237 | 
238 |   // ------------------------------------
239 | 
240 |   // ------------------------------------
241 |   // -----UV -> XYZ ---------------------
242 |   // ------------------------------------
243 |   pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud_out(new pcl::PointCloud<pcl::PointXYZRGBA>);
244 | 
245 |   cloud_out->width = image.cols;
246 |   cloud_out->height = image.rows;
247 |   PointXYZRGBA inserted_point;
248 | 
249 |   for(int i = 0; i < image.rows; i++)
250 |   {
251 |     for(int j = 0; j < image.cols; j++)
252 |     {
253 |       cv::Vec3b& bgr = image.at<cv::Vec3b>(j,i);
254 |       inserted_point.r = bgr[2];
255 |       inserted_point.g = bgr[1];
256 |       inserted_point.b = bgr[0];
257 |       inserted_point.x = cloud->points[i*image.cols + j].x;
258 |       inserted_point.y = cloud->points[i*image.cols + j].y;
259 |       inserted_point.z = cloud->points[i*image.cols + j].z;
260 |       cloud_out->points.push_back(inserted_point);
261 |     }
262 |   }
263 |   // ------------------------------------
264 | 
265 |   boost::shared_ptr<visualization::PCLVisualizer> viewer;
266 |   if (simple_vis)
267 |   {
268 | 	  viewer = simpleVisualisation(cloud);
269 |   }
270 |   else if (image_vis)
271 |   {
272 | 	  namedWindow( "Image", WINDOW_AUTOSIZE );// Create a window for display.
273 | 	  imshow( "Image", image);
274 | 	  waitKey(0);
275 | 	  return OK;
276 |   }
277 |   else if (point_vis)
278 |   {
279 | 	  viewer = simpleVisualisation(cloud);
280 | 	  viewer->addPointCloud<PointXYZ> (point, "Point");
281 | 	  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, 5, "Point");
282 | 	  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 0.0, 1.0, 0.0, "Point");
283 |   }
284 |   else if (plane_vis)
285 |   {
286 | 	  viewer = simpleVisualisation(cloud);
287 | 	  viewer->addPointCloud<PointXYZ> (point, "Point");
288 | 	  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_POINT_SIZE, 5, "Point");
289 | 	  viewer->setPointCloudRenderingProperties (visualization::PCL_VISUALIZER_COLOR, 0.0, 1.0, 0.0, "Point");
290 | 	  viewer->addPlane(plane_coeff, "plane",0);
291 |   }
292 | 
293 |   //--------------------
294 |   // -----Main loop-----
295 |   //--------------------
296 |   while (!viewer->wasStopped ())
297 |   {
298 |     viewer->spinOnce (100);
299 |     boost::this_thread::sleep(boost::posix_time::microseconds (100000));
300 |   }
301 | }
302 | 


--------------------------------------------------------------------------------