Point Cloud Library (PCL)  1.7.0
/tmp/buildd/pcl-1.7-1.7.0/registration/include/pcl/registration/correspondence_rejection_distance.h
00001 /*
00002  * Software License Agreement (BSD License)
00003  *
00004  *  Point Cloud Library (PCL) - www.pointclouds.org
00005  *  Copyright (c) 2010-2011, Willow Garage, Inc.
00006  *  Copyright (c) 2012-, Open Perception, Inc.
00007  *
00008  *  All rights reserved.
00009  *
00010  *  Redistribution and use in source and binary forms, with or without
00011  *  modification, are permitted provided that the following conditions
00012  *  are met:
00013  *
00014  *   * Redistributions of source code must retain the above copyright
00015  *     notice, this list of conditions and the following disclaimer.
00016  *   * Redistributions in binary form must reproduce the above
00017  *     copyright notice, this list of conditions and the following
00018  *     disclaimer in the documentation and/or other materials provided
00019  *     with the distribution.
00020  *   * Neither the name of the copyright holder(s) nor the names of its
00021  *     contributors may be used to endorse or promote products derived
00022  *     from this software without specific prior written permission.
00023  *
00024  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00025  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00026  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00027  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
00028  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00029  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00030  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00031  *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00032  *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00033  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
00034  *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00035  *  POSSIBILITY OF SUCH DAMAGE.
00036  *
00037  * $Id$
00038  *
00039  */
00040 #ifndef PCL_REGISTRATION_CORRESPONDENCE_REJECTION_DISTANCE_H_
00041 #define PCL_REGISTRATION_CORRESPONDENCE_REJECTION_DISTANCE_H_
00042 
00043 #include <pcl/registration/correspondence_rejection.h>
00044 
00045 namespace pcl
00046 {
00047   namespace registration
00048   {
00049     /**
00050       * @b CorrespondenceRejectorDistance implements a simple correspondence
00051       * rejection method based on thresholding the distances between the
00052       * correspondences.
00053       *
00054       * \note If \ref setInputCloud and \ref setInputTarget are given, then the
00055       * distances between correspondences will be estimated using the given XYZ
00056       * data, and not read from the set of input correspondences.
00057       *
00058       * \author Dirk Holz, Radu B. Rusu
00059       * \ingroup registration
00060       */
00061     class PCL_EXPORTS CorrespondenceRejectorDistance: public CorrespondenceRejector
00062     {
00063       using CorrespondenceRejector::input_correspondences_;
00064       using CorrespondenceRejector::rejection_name_;
00065       using CorrespondenceRejector::getClassName;
00066 
00067       public:
00068         typedef boost::shared_ptr<CorrespondenceRejectorDistance> Ptr;
00069         typedef boost::shared_ptr<const CorrespondenceRejectorDistance> ConstPtr;
00070 
00071         /** \brief Empty constructor. */
00072         CorrespondenceRejectorDistance () : max_distance_(std::numeric_limits<float>::max ()),
00073                                             data_container_ ()
00074         {
00075           rejection_name_ = "CorrespondenceRejectorDistance";
00076         }
00077       
00078         /** \brief Empty destructor */
00079         virtual ~CorrespondenceRejectorDistance () {}
00080 
00081         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
00082           * \param[in] original_correspondences the set of initial correspondences given
00083           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
00084           */
00085         void
00086         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
00087                                      pcl::Correspondences& remaining_correspondences);
00088 
00089         /** \brief Set the maximum distance used for thresholding in correspondence rejection.
00090           * \param[in] distance Distance to be used as maximum distance between correspondences. 
00091           * Correspondences with larger distances are rejected.
00092           * \note Internally, the distance will be stored squared.
00093           */
00094         virtual inline void 
00095         setMaximumDistance (float distance) { max_distance_ = distance * distance; };
00096 
00097         /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
00098         inline float 
00099         getMaximumDistance () { return std::sqrt (max_distance_); };
00100 
00101         /** \brief Provide a source point cloud dataset (must contain XYZ
00102           * data!), used to compute the correspondence distance.  
00103           * \param[in] cloud a cloud containing XYZ data
00104           */
00105         template <typename PointT> inline void 
00106         setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
00107         {
00108           PCL_WARN ("[pcl::registration::%s::setInputCloud] setInputCloud is deprecated. Please use setInputSource instead.\n", getClassName ().c_str ());
00109           if (!data_container_)
00110             data_container_.reset (new DataContainer<PointT>);
00111           boost::static_pointer_cast<DataContainer<PointT> > (data_container_)->setInputSource (cloud);
00112         }
00113 
00114         /** \brief Provide a source point cloud dataset (must contain XYZ
00115           * data!), used to compute the correspondence distance.  
00116           * \param[in] cloud a cloud containing XYZ data
00117           */
00118         template <typename PointT> inline void 
00119         setInputSource (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
00120         {
00121           if (!data_container_)
00122             data_container_.reset (new DataContainer<PointT>);
00123           boost::static_pointer_cast<DataContainer<PointT> > (data_container_)->setInputSource (cloud);
00124         }
00125 
00126         /** \brief Provide a target point cloud dataset (must contain XYZ
00127           * data!), used to compute the correspondence distance.  
00128           * \param[in] target a cloud containing XYZ data
00129           */
00130         template <typename PointT> inline void 
00131         setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
00132         {
00133           if (!data_container_)
00134             data_container_.reset (new DataContainer<PointT>);
00135           boost::static_pointer_cast<DataContainer<PointT> > (data_container_)->setInputTarget (target);
00136         }
00137 
00138         /** \brief Provide a pointer to the search object used to find correspondences in
00139           * the target cloud.
00140           * \param[in] tree a pointer to the spatial search object.
00141           * \param[in] force_no_recompute If set to true, this tree will NEVER be 
00142           * recomputed, regardless of calls to setInputTarget. Only use if you are 
00143           * confident that the tree will be set correctly.
00144           */
00145         template <typename PointT> inline void
00146         setSearchMethodTarget (const boost::shared_ptr<pcl::search::KdTree<PointT> > &tree, 
00147                                bool force_no_recompute = false) 
00148         { 
00149           boost::static_pointer_cast< DataContainer<PointT> > 
00150             (data_container_)->setSearchMethodTarget (tree, force_no_recompute );
00151         }
00152 
00153 
00154       protected:
00155 
00156         /** \brief Apply the rejection algorithm.
00157           * \param[out] correspondences the set of resultant correspondences.
00158           */
00159         inline void 
00160         applyRejection (pcl::Correspondences &correspondences)
00161         {
00162           getRemainingCorrespondences (*input_correspondences_, correspondences);
00163         }
00164 
00165         /** \brief The maximum distance threshold between two correspondent points in source <-> target. If the
00166           * distance is larger than this threshold, the points will not be ignored in the alignment process.
00167           */
00168         float max_distance_;
00169 
00170         typedef boost::shared_ptr<DataContainerInterface> DataContainerPtr;
00171 
00172         /** \brief A pointer to the DataContainer object containing the input and target point clouds */
00173         DataContainerPtr data_container_;
00174     };
00175 
00176   }
00177 }
00178 
00179 #include <pcl/registration/impl/correspondence_rejection_distance.hpp>
00180 
00181 #endif /* PCL_REGISTRATION_CORRESPONDENCE_REJECTION_DISTANCE_H_ */