Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add: progressive morphological filter to extract ground returns #574

Merged
merged 1 commit into from
Mar 26, 2014
Merged

Add: progressive morphological filter to extract ground returns #574

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions segmentation/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@ if(build)
src/conditional_euclidean_clustering.cpp
src/supervoxel_clustering.cpp
src/grabcut_segmentation.cpp
src/progressive_morphological_filter.cpp
)
# NOTE: boost/graph/boykov_kolmogorov_max_flow.hpp only exists for versions > 1.43
if(Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 43)
Expand Down Expand Up @@ -63,6 +64,7 @@ if(build)
"include/pcl/${SUBSYS_NAME}/conditional_euclidean_clustering.h"
"include/pcl/${SUBSYS_NAME}/supervoxel_clustering.h"
"include/pcl/${SUBSYS_NAME}/grabcut_segmentation.h"
"include/pcl/${SUBSYS_NAME}/progressive_morphological_filter.h"
)
# NOTE: boost/graph/boykov_kolmogorov_max_flow.hpp only exists for versions > 1.43
if(Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 43)
Expand Down Expand Up @@ -95,6 +97,7 @@ if(build)
"include/pcl/${SUBSYS_NAME}/impl/conditional_euclidean_clustering.hpp"
"include/pcl/${SUBSYS_NAME}/impl/supervoxel_clustering.hpp"
"include/pcl/${SUBSYS_NAME}/impl/grabcut_segmentation.hpp"
"include/pcl/${SUBSYS_NAME}/impl/progressive_morphological_filter.hpp"
)
# NOTE: boost/graph/boykov_kolmogorov_max_flow.hpp only exists for versions > 1.43
if(Boost_MAJOR_VERSION GREATER 1 OR Boost_MINOR_VERSION GREATER 43)
Expand Down
152 changes: 152 additions & 0 deletions segmentation/include/pcl/segmentation/impl/progressive_morphological_filter.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,152 @@
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2009-2012, Willow Garage, Inc.
* Copyright (c) 2012-, Open Perception, Inc.
* Copyright (c) 2014, RadiantBlue Technologies, 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 the copyright holder(s) 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.
*/

#ifndef PCL_SEGMENTATION_PROGRESSIVE_MORPHOLOGICAL_FILTER_HPP_
#define PCL_SEGMENTATION_PROGRESSIVE_MORPHOLOGICAL_FILTER_HPP_

#include <pcl/common/common.h>
#include <pcl/common/io.h>
#include <pcl/filters/morphological_filter.h>
#include <pcl/filters/extract_indices.h>
#include <pcl/segmentation/progressive_morphological_filter.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename PointT>
pcl::ProgressiveMorphologicalFilter<PointT>::ProgressiveMorphologicalFilter () :
max_window_size_ (33),
slope_ (0.7f),
max_distance_ (10.0f),
initial_distance_ (0.15f),
cell_size_ (1.0f),
base_ (2.0f),
exponential_ (true)
{
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename PointT>
pcl::ProgressiveMorphologicalFilter<PointT>::~ProgressiveMorphologicalFilter ()
{
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template <typename PointT> void
pcl::ProgressiveMorphologicalFilter<PointT>::extract (std::vector<int>& ground)
{
bool segmentation_is_possible = initCompute ();
if (!segmentation_is_possible)
{
deinitCompute ();
return;
}

// Compute the series of window sizes and height thresholds
std::vector<float> height_thresholds;
std::vector<float> window_sizes;
int iteration = 0;
float window_size = 0.0f;
float height_threshold = 0.0f;

while (window_size <= max_window_size_)
{
// Determine the initial window size.
if (exponential_)
window_size = cell_size_ * (2.0f * std::pow (base_, iteration) + 1.0f);
else
window_size = cell_size_ * (2.0f * (iteration+1) * base_ + 1.0f);

// Calculate the height threshold to be used in the next iteration.
if (iteration == 0)
height_threshold = initial_distance_;
else
height_threshold = slope_ * (window_size - window_sizes[iteration-1]) * cell_size_ + initial_distance_;

// Enforce max distance on height threshold
if (height_threshold > max_distance_)
height_threshold = max_distance_;

window_sizes.push_back (window_size);
height_thresholds.push_back (height_threshold);

iteration++;
}

// Ground indices are initially limited to those points in the input cloud we
// wish to process
ground = *indices_;

// Progressively filter ground returns using morphological open
for (int i = 0; i < window_sizes.size (); ++i)
{
PCL_DEBUG (" Iteration %d (height threshold = %f, window size = %f)...",
i, height_thresholds[i], window_sizes[i]);

// Limit filtering to those points currently considered ground returns
typename pcl::PointCloud<PointT>::Ptr cloud (new pcl::PointCloud<PointT>);
pcl::copyPointCloud<PointT> (*input_, ground, *cloud);

// Create new cloud to hold the filtered results. Apply the morphological
// opening operation at the current window size.
typename pcl::PointCloud<PointT>::Ptr cloud_f (new pcl::PointCloud<PointT>);
pcl::applyMorphologicalOperator<PointT> (cloud, window_sizes[i], MORPH_OPEN, *cloud_f);

// Find indices of the points whose difference between the source and
// filtered point clouds is less than the current height threshold.
std::vector<int> pt_indices;
for (boost::int32_t p_idx = 0; p_idx < ground.size (); ++p_idx)
{
float diff = cloud->points[p_idx].z - cloud_f->points[p_idx].z;
if (diff < height_thresholds[i])
pt_indices.push_back (ground[p_idx]);
}

// Ground is now limited to pt_indices
ground.swap (pt_indices);

PCL_DEBUG ("ground now has %d points\n", ground.size ());
}

deinitCompute ();
}

#define PCL_INSTANTIATE_ProgressiveMorphologicalFilter(T) template class pcl::ProgressiveMorphologicalFilter<T>;

#endif // PCL_SEGMENTATION_PROGRESSIVE_MORPHOLOGICAL_FILTER_HPP_

169 changes: 169 additions & 0 deletions segmentation/include/pcl/segmentation/progressive_morphological_filter.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,169 @@
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2009-2012, Willow Garage, Inc.
* Copyright (c) 2012-, Open Perception, Inc.
* Copyright (c) 2014, RadiantBlue Technologies, 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 the copyright holder(s) 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.
*/

#ifndef PCL_PROGRESSIVE_MORPHOLOGICAL_FILTER_H_
#define PCL_PROGRESSIVE_MORPHOLOGICAL_FILTER_H_

#include <pcl/pcl_base.h>
#include <pcl/search/search.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

namespace pcl
{
/** \brief
* Implements the Progressive Morphological Filter for segmentation of ground points.
* Description can be found in the article
* "A Progressive Morphological Filter for Removing Nonground Measurements from
* Airborne LIDAR Data"
* by K. Zhang, S. Chen, D. Whitman, M. Shyu, J. Yan, and C. Zhang.
*/
template <typename PointT>
class PCL_EXPORTS ProgressiveMorphologicalFilter : public pcl::PCLBase<PointT>
{
public:

typedef pcl::PointCloud <PointT> PointCloud;

using PCLBase <PointT>::input_;
using PCLBase <PointT>::indices_;
using PCLBase <PointT>::initCompute;
using PCLBase <PointT>::deinitCompute;

public:

/** \brief Constructor that sets default values for member variables. */
ProgressiveMorphologicalFilter ();

virtual
~ProgressiveMorphologicalFilter ();

/** \brief Get the maximum window size to be used in filtering ground returns. */
inline int
getMaxWindowSize () const { return (max_window_size_); }

/** \brief Set the maximum window size to be used in filtering ground returns. */
inline void
setMaxWindowSize (int max_window_size) { max_window_size_ = max_window_size; }

/** \brief Get the slope value to be used in computing the height threshold. */
inline float
getSlope () const { return (slope_); }

/** \brief Set the slope value to be used in computing the height threshold. */
inline void
setSlope (float slope) { slope_ = slope; }

/** \brief Get the maximum height above the parameterized ground surface to be considered a ground return. */
inline float
getMaxDistance () const { return (max_distance_); }

/** \brief Set the maximum height above the parameterized ground surface to be considered a ground return. */
inline void
setMaxDistance (float max_distance) { max_distance_ = max_distance; }

/** \brief Get the initial height above the parameterized ground surface to be considered a ground return. */
inline float
getInitialDistance () const { return (initial_distance_); }

/** \brief Set the initial height above the parameterized ground surface to be considered a ground return. */
inline void
setInitialDistance (float initial_distance) { initial_distance_ = initial_distance; }

/** \brief Get the cell size. */
inline float
getCellSize () const { return (cell_size_); }

/** \brief Set the cell size. */
inline void
setCellSize (float cell_size) { cell_size_ = cell_size; }

/** \brief Get the base to be used in computing progressive window sizes. */
inline float
getBase () const { return (base_); }

/** \brief Set the base to be used in computing progressive window sizes. */
inline void
setBase (float base) { base_ = base; }

/** \brief Get flag indicating whether or not to exponentially grow window sizes? */
inline bool
getExponential () const { return (exponential_); }

/** \brief Set flag indicating whether or not to exponentially grow window sizes? */
inline void
setExponential (bool exponential) { exponential_ = exponential; }

/** \brief This method launches the segmentation algorithm and returns indices of
* points determined to be ground returns.
* \param[out] ground indices of points determined to be ground returns.
*/
virtual void
extract (std::vector<int>& ground);

protected:

/** \brief Maximum window size to be used in filtering ground returns. */
int max_window_size_;

/** \brief Slope value to be used in computing the height threshold. */
float slope_;

/** \brief Maximum height above the parameterized ground surface to be considered a ground return. */
float max_distance_;

/** \brief Initial height above the parameterized ground surface to be considered a ground return. */
float initial_distance_;

/** \brief Cell size. */
float cell_size_;

/** \brief Base to be used in computing progressive window sizes. */
float base_;

/** \brief Exponentially grow window sizes? */
bool exponential_;
};
}

#ifdef PCL_NO_PRECOMPILE
#include <pcl/segmentation/impl/progressive_morphological_filter.hpp>
#endif

#endif

Loading