Point Cloud Library (PCL) 1.13.0
Loading...
Searching...
No Matches
model_library.h
1/*
2 * Software License Agreement (BSD License)
3 *
4 * Point Cloud Library (PCL) - www.pointclouds.org
5 * Copyright (c) 2010-2012, Willow Garage, Inc.
6 *
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
19 * * Neither the name of Willow Garage, Inc. nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 *
36 *
37 */
38
39#pragma once
40
41#include "auxiliary.h"
42#include <pcl/recognition/ransac_based/voxel_structure.h>
43#include <pcl/recognition/ransac_based/orr_octree.h>
44#include <pcl/common/random.h>
45#include <pcl/pcl_exports.h>
46#include <pcl/point_cloud.h>
47#include <pcl/point_types.h>
48#include <ctime>
49#include <string>
50#include <list>
51#include <map>
52
53namespace pcl
54{
55 namespace recognition
56 {
57 class PCL_EXPORTS ModelLibrary
58 {
59 public:
62
63 /** \brief Stores some information about the model. */
64 class Model
65 {
66 public:
67 Model (const PointCloudIn& points, const PointCloudN& normals, float voxel_size, const std::string& object_name,
68 float frac_of_points_for_registration, void* user_data = nullptr)
69 : obj_name_(object_name),
70 user_data_ (user_data)
71 {
72 octree_.build (points, voxel_size, &normals);
73
74 const std::vector<ORROctree::Node*>& full_leaves = octree_.getFullLeaves ();
75 if ( full_leaves.empty () )
76 return;
77
78 // Initialize
79 auto it = full_leaves.begin ();
80 const float *p = (*it)->getData ()->getPoint ();
81 aux::copy3 (p, octree_center_of_mass_);
82 bounds_of_octree_points_[0] = bounds_of_octree_points_[1] = p[0];
83 bounds_of_octree_points_[2] = bounds_of_octree_points_[3] = p[1];
84 bounds_of_octree_points_[4] = bounds_of_octree_points_[5] = p[2];
85
86 // Compute both the bounds and the center of mass of the octree points
87 for ( ++it ; it != full_leaves.end () ; ++it )
88 {
89 aux::add3 (octree_center_of_mass_, (*it)->getData ()->getPoint ());
90 aux::expandBoundingBoxToContainPoint (bounds_of_octree_points_, (*it)->getData ()->getPoint ());
91 }
92
93 int num_octree_points = static_cast<int> (full_leaves.size ());
94 // Finalize the center of mass computation
95 aux::mult3 (octree_center_of_mass_, 1.0f/static_cast<float> (num_octree_points));
96
97 int num_points_for_registration = static_cast<int> (static_cast<float> (num_octree_points)*frac_of_points_for_registration);
98 points_for_registration_.resize (static_cast<std::size_t> (num_points_for_registration));
99
100 // Prepare for random point sampling
101 std::vector<int> ids (num_octree_points);
102 for ( int i = 0 ; i < num_octree_points ; ++i )
103 ids[i] = i;
104
105 // The random generator
106 pcl::common::UniformGenerator<int> randgen (0, num_octree_points - 1, static_cast<std::uint32_t> (time (nullptr)));
107
108 // Randomly sample some points from the octree
109 for ( int i = 0 ; i < num_points_for_registration ; ++i )
110 {
111 // Choose a random position within the array of ids
112 randgen.setParameters (0, static_cast<int> (ids.size ()) - 1);
113 int rand_pos = randgen.run ();
114
115 // Copy the randomly selected octree point
116 aux::copy3 (octree_.getFullLeaves ()[ids[rand_pos]]->getData ()->getPoint (), points_for_registration_[i]);
117
118 // Delete the selected id
119 ids.erase (ids.begin() + rand_pos);
120 }
121 }
122
123 virtual ~Model () = default;
124
125 inline const std::string&
127 {
128 return (obj_name_);
129 }
130
131 inline const ORROctree&
132 getOctree () const
133 {
134 return (octree_);
135 }
136
137 inline void*
138 getUserData () const
139 {
140 return (user_data_);
141 }
142
143 inline const float*
145 {
146 return (octree_center_of_mass_);
147 }
148
149 inline const float*
151 {
152 return (bounds_of_octree_points_);
153 }
154
155 inline const PointCloudIn&
157 {
158 return (points_for_registration_);
159 }
160
161 protected:
162 const std::string obj_name_;
164 float octree_center_of_mass_[3];
165 float bounds_of_octree_points_[6];
168 };
169
170 using node_data_pair_list = std::list<std::pair<const ORROctree::Node::Data*, const ORROctree::Node::Data*> >;
171 using HashTableCell = std::map<const Model*, node_data_pair_list>;
173
174 public:
175 /** \brief This class is used by 'ObjRecRANSAC' to maintain the object models to be recognized. Normally, you do not need to use
176 * this class directly. */
177 ModelLibrary (float pair_width, float voxel_size, float max_coplanarity_angle = 3.0f*AUX_DEG_TO_RADIANS/*3 degrees*/);
178 virtual ~ModelLibrary ()
179 {
180 this->clear();
181 }
182
183 /** \brief Removes all models from the library and clears the hash table. */
184 void
186
187 /** \brief This is a threshold. The larger the value the more point pairs will be considered as co-planar and will
188 * be ignored in the off-line model pre-processing and in the online recognition phases. This makes sense only if
189 * "ignore co-planar points" is on. Call this method before calling addModel. */
190 inline void
191 setMaxCoplanarityAngleDegrees (float max_coplanarity_angle_degrees)
192 {
193 max_coplanarity_angle_ = max_coplanarity_angle_degrees*AUX_DEG_TO_RADIANS;
194 }
195
196 /** \brief Call this method in order NOT to add co-planar point pairs to the hash table. The default behavior
197 * is ignoring co-planar points on. */
198 inline void
200 {
201 ignore_coplanar_opps_ = true;
202 }
203
204 /** \brief Call this method in order to add all point pairs (co-planar as well) to the hash table. The default
205 * behavior is ignoring co-planar points on. */
206 inline void
208 {
209 ignore_coplanar_opps_ = false;
210 }
211
212 /** \brief Adds a model to the hash table.
213 *
214 * \param[in] points represents the model to be added.
215 * \param[in] normals are the normals at the model points.
216 * \param[in] object_name is the unique name of the object to be added.
217 * \param[in] frac_of_points_for_registration is the number of points used for fast ICP registration prior to hypothesis testing
218 * \param[in] user_data is a pointer to some data (can be NULL)
219 *
220 * Returns true if model successfully added and false otherwise (e.g., if object_name is not unique). */
221 bool
222 addModel (const PointCloudIn& points, const PointCloudN& normals, const std::string& object_name,
223 float frac_of_points_for_registration, void* user_data = nullptr);
224
225 /** \brief Returns the hash table built by this instance. */
226 inline const HashTable&
228 {
229 return (hash_table_);
230 }
231
232 inline const Model*
233 getModel (const std::string& name) const
234 {
235 auto it = models_.find (name);
236 if ( it != models_.end () )
237 return (it->second);
238
239 return (nullptr);
240 }
241
242 inline const std::map<std::string,Model*>&
243 getModels () const
244 {
245 return (models_);
246 }
247
248 protected:
249 /** \brief Removes all models from the library and destroys the hash table. This method should be called upon destroying this object. */
250 void
252
253 /** \brief Returns true if the oriented point pair was added to the hash table and false otherwise. */
254 bool
256
257 protected:
262
263 std::map<std::string,Model*> models_;
265 int num_of_cells_[3];
266 };
267 } // namespace recognition
268} // namespace pcl
UniformGenerator class generates a random number from range [min, max] at each run picked according t...
Definition random.h:79
void setParameters(T min, T max, std::uint32_t seed=-1)
Set the uniform number generator parameters.
Definition random.hpp:84
Stores some information about the model.
const PointCloudIn & getPointsForRegistration() const
const std::string & getObjectName() const
const float * getBoundsOfOctreePoints() const
Model(const PointCloudIn &points, const PointCloudN &normals, float voxel_size, const std::string &object_name, float frac_of_points_for_registration, void *user_data=nullptr)
const float * getOctreeCenterOfMass() const
const ORROctree & getOctree() const
const std::map< std::string, Model * > & getModels() const
void clear()
Removes all models from the library and destroys the hash table.
void removeAllModels()
Removes all models from the library and clears the hash table.
bool addModel(const PointCloudIn &points, const PointCloudN &normals, const std::string &object_name, float frac_of_points_for_registration, void *user_data=nullptr)
Adds a model to the hash table.
ModelLibrary(float pair_width, float voxel_size, float max_coplanarity_angle=3.0f *AUX_DEG_TO_RADIANS)
This class is used by 'ObjRecRANSAC' to maintain the object models to be recognized.
void setMaxCoplanarityAngleDegrees(float max_coplanarity_angle_degrees)
This is a threshold.
const Model * getModel(const std::string &name) const
void ignoreCoplanarPointPairsOff()
Call this method in order to add all point pairs (co-planar as well) to the hash table.
bool addToHashTable(Model *model, const ORROctree::Node::Data *data1, const ORROctree::Node::Data *data2)
Returns true if the oriented point pair was added to the hash table and false otherwise.
std::map< const Model *, node_data_pair_list > HashTableCell
std::list< std::pair< const ORROctree::Node::Data *, const ORROctree::Node::Data * > > node_data_pair_list
void ignoreCoplanarPointPairsOn()
Call this method in order NOT to add co-planar point pairs to the hash table.
std::map< std::string, Model * > models_
const HashTable & getHashTable() const
Returns the hash table built by this instance.
That's a very specialized and simple octree class.
Definition orr_octree.h:69
Defines all the PCL implemented PointT point type structures.
CloudGenerator class generates a point cloud using some randoom number generator.