/usr/include/pcl-1.7/pcl/surface/reconstruction.h is in libpcl-dev 1.7.2-14build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 | /*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2010-2012, Willow Garage, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*
*/
#ifndef PCL_SURFACE_RECONSTRUCTION_H_
#define PCL_SURFACE_RECONSTRUCTION_H_
#include <pcl/pcl_base.h>
#include <pcl/PolygonMesh.h>
#include <pcl/search/pcl_search.h>
#include <pcl/conversions.h>
#include <pcl/surface/boost.h>
namespace pcl
{
/** \brief Pure abstract class. All types of meshing/reconstruction
* algorithms in \b libpcl_surface must inherit from this, in order to make
* sure we have a consistent API. The methods that we care about here are:
*
* - \b setSearchMethod(&SearchPtr): passes a search locator
* - \b reconstruct(&PolygonMesh): creates a PolygonMesh object from the input data
*
* \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
*/
template <typename PointInT>
class PCLSurfaceBase: public PCLBase<PointInT>
{
public:
typedef boost::shared_ptr<PCLSurfaceBase<PointInT> > Ptr;
typedef boost::shared_ptr<const PCLSurfaceBase<PointInT> > ConstPtr;
typedef typename pcl::search::Search<PointInT> KdTree;
typedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
/** \brief Empty constructor. */
PCLSurfaceBase () : tree_ () {}
/** \brief Empty destructor */
virtual ~PCLSurfaceBase () {}
/** \brief Provide an optional pointer to a search object.
* \param[in] tree a pointer to the spatial search object.
*/
inline void
setSearchMethod (const KdTreePtr &tree)
{
tree_ = tree;
}
/** \brief Get a pointer to the search method used. */
inline KdTreePtr
getSearchMethod () { return (tree_); }
/** \brief Base method for surface reconstruction for all points given in
* <setInputCloud (), setIndices ()>
* \param[out] output the resultant reconstructed surface model
*/
virtual void
reconstruct (pcl::PolygonMesh &output) = 0;
protected:
/** \brief A pointer to the spatial search object. */
KdTreePtr tree_;
/** \brief Abstract class get name method. */
virtual std::string
getClassName () const { return (""); }
};
/** \brief SurfaceReconstruction represents a base surface reconstruction
* class. All \b surface reconstruction methods take in a point cloud and
* generate a new surface from it, by either re-sampling the data or
* generating new data altogether. These methods are thus \b not preserving
* the topology of the original data.
*
* \note Reconstruction methods that always preserve the original input
* point cloud data as the surface vertices and simply construct the mesh on
* top should inherit from \ref MeshConstruction.
*
* \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
* \ingroup surface
*/
template <typename PointInT>
class SurfaceReconstruction: public PCLSurfaceBase<PointInT>
{
public:
typedef boost::shared_ptr<SurfaceReconstruction<PointInT> > Ptr;
typedef boost::shared_ptr<const SurfaceReconstruction<PointInT> > ConstPtr;
using PCLSurfaceBase<PointInT>::input_;
using PCLSurfaceBase<PointInT>::indices_;
using PCLSurfaceBase<PointInT>::initCompute;
using PCLSurfaceBase<PointInT>::deinitCompute;
using PCLSurfaceBase<PointInT>::tree_;
using PCLSurfaceBase<PointInT>::getClassName;
/** \brief Constructor. */
SurfaceReconstruction () : check_tree_ (true) {}
/** \brief Destructor. */
virtual ~SurfaceReconstruction () {}
/** \brief Base method for surface reconstruction for all points given in
* <setInputCloud (), setIndices ()>
* \param[out] output the resultant reconstructed surface model
*/
virtual void
reconstruct (pcl::PolygonMesh &output);
/** \brief Base method for surface reconstruction for all points given in
* <setInputCloud (), setIndices ()>
* \param[out] points the resultant points lying on the new surface
* \param[out] polygons the resultant polygons, as a set of
* vertices. The Vertices structure contains an array of point indices.
*/
virtual void
reconstruct (pcl::PointCloud<PointInT> &points,
std::vector<pcl::Vertices> &polygons);
protected:
/** \brief A flag specifying whether or not the derived reconstruction
* algorithm needs the search object \a tree.*/
bool check_tree_;
/** \brief Abstract surface reconstruction method.
* \param[out] output the output polygonal mesh
*/
virtual void
performReconstruction (pcl::PolygonMesh &output) = 0;
/** \brief Abstract surface reconstruction method.
* \param[out] points the resultant points lying on the surface
* \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
*/
virtual void
performReconstruction (pcl::PointCloud<PointInT> &points,
std::vector<pcl::Vertices> &polygons) = 0;
};
/** \brief MeshConstruction represents a base surface reconstruction
* class. All \b mesh constructing methods that take in a point cloud and
* generate a surface that uses the original data as vertices should inherit
* from this class.
*
* \note Reconstruction methods that generate a new surface or create new
* vertices in locations different than the input data should inherit from
* \ref SurfaceReconstruction.
*
* \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
* \ingroup surface
*/
template <typename PointInT>
class MeshConstruction: public PCLSurfaceBase<PointInT>
{
public:
typedef boost::shared_ptr<MeshConstruction<PointInT> > Ptr;
typedef boost::shared_ptr<const MeshConstruction<PointInT> > ConstPtr;
using PCLSurfaceBase<PointInT>::input_;
using PCLSurfaceBase<PointInT>::indices_;
using PCLSurfaceBase<PointInT>::initCompute;
using PCLSurfaceBase<PointInT>::deinitCompute;
using PCLSurfaceBase<PointInT>::tree_;
using PCLSurfaceBase<PointInT>::getClassName;
/** \brief Constructor. */
MeshConstruction () : check_tree_ (true) {}
/** \brief Destructor. */
virtual ~MeshConstruction () {}
/** \brief Base method for surface reconstruction for all points given in
* <setInputCloud (), setIndices ()>
* \param[out] output the resultant reconstructed surface model
*
* \note This method copies the input point cloud data from
* PointCloud<T> to PCLPointCloud2, and is implemented here for backwards
* compatibility only!
*
*/
virtual void
reconstruct (pcl::PolygonMesh &output);
/** \brief Base method for mesh construction for all points given in
* <setInputCloud (), setIndices ()>
* \param[out] polygons the resultant polygons, as a set of
* vertices. The Vertices structure contains an array of point indices.
*/
virtual void
reconstruct (std::vector<pcl::Vertices> &polygons);
protected:
/** \brief A flag specifying whether or not the derived reconstruction
* algorithm needs the search object \a tree.*/
bool check_tree_;
/** \brief Abstract surface reconstruction method.
* \param[out] output the output polygonal mesh
*/
virtual void
performReconstruction (pcl::PolygonMesh &output) = 0;
/** \brief Abstract surface reconstruction method.
* \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
*/
virtual void
performReconstruction (std::vector<pcl::Vertices> &polygons) = 0;
};
}
#include <pcl/surface/impl/reconstruction.hpp>
#endif // PCL_SURFACE_RECONSTRUCTION_H_
|