.. _program_listing_file_src_ompl_geometric_PathSimplifier.h:

Program Listing for File PathSimplifier.h
=========================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_ompl_geometric_PathSimplifier.h>` (``src/ompl/geometric/PathSimplifier.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*********************************************************************
    * Software License Agreement (BSD License)
    *
    *  Copyright (c) 2008, 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 the Willow Garage 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.
    *********************************************************************/
   
   /* Author: Ioan Sucan, Ryan Luna */
   
   #ifndef OMPL_GEOMETRIC_PATH_SIMPLIFIER_
   #define OMPL_GEOMETRIC_PATH_SIMPLIFIER_
   
   #include "ompl/base/SpaceInformation.h"
   #include "ompl/geometric/PathGeometric.h"
   #include "ompl/base/PlannerTerminationCondition.h"
   #include "ompl/base/OptimizationObjective.h"
   #include "ompl/base/goals/GoalSampleableRegion.h"
   #include "ompl/util/ClassForward.h"
   #include "ompl/util/RandomNumbers.h"
   #include "ompl/util/Console.h"
   #include <limits>
   
   namespace ompl
   {
       namespace geometric
       {
   
           OMPL_CLASS_FORWARD(PathSimplifier);
   
           class PathSimplifier
           {
           public:
               PathSimplifier(base::SpaceInformationPtr si, const base::GoalPtr &goal = ompl::base::GoalPtr(),
                              const base::OptimizationObjectivePtr &obj = nullptr);
   
               virtual ~PathSimplifier() = default;
   
               bool reduceVertices(PathGeometric &path, unsigned int maxSteps = 0, unsigned int maxEmptySteps = 0,
                                   double rangeRatio = 0.33);
   
               bool ropeShortcutPath(PathGeometric &path, double delta = 1.0, double equivalenceTolerance = 0.1);
   
               bool partialShortcutPath(PathGeometric &path, unsigned int maxSteps = 0, unsigned int maxEmptySteps = 0,
                                        double rangeRatio = 0.33, double snapToVertex = 0.005);
   
               bool perturbPath(PathGeometric &path, double stepSize, unsigned int maxSteps = 0,
                                unsigned int maxEmptySteps = 0, double snapToVertex = 0.005);
   
               bool collapseCloseVertices(PathGeometric &path, unsigned int maxSteps = 0, unsigned int maxEmptySteps = 0);
   
               void smoothBSpline(PathGeometric &path, unsigned int maxSteps = 5,
                                  double minChange = std::numeric_limits<double>::epsilon());
   
               bool simplifyMax(PathGeometric &path);
   
               bool simplify(PathGeometric &path, double maxTime, bool atLeastOnce = true);
   
               bool simplify(PathGeometric &path, const base::PlannerTerminationCondition &ptc, bool atLeastOnce = true);
   
               bool findBetterGoal(PathGeometric &path, double maxTime, unsigned int samplingAttempts = 10,
                                   double rangeRatio = 0.33, double snapToVertex = 0.005);
   
               bool findBetterGoal(PathGeometric &path, const base::PlannerTerminationCondition &ptc,
                                   unsigned int samplingAttempts = 10, double rangeRatio = 0.33,
                                   double snapToVertex = 0.005);
   
               void freeStates(bool flag);
   
               bool freeStates() const;
   
           protected:
               int selectAlongPath(std::vector<double> dists, std::vector<base::State *> states, double distTo,
                                   double threshold, base::State *select_state, int &pos);
   
               base::SpaceInformationPtr si_;
   
               std::shared_ptr<base::GoalSampleableRegion> gsr_;
   
               base::OptimizationObjectivePtr obj_;
   
               bool freeStates_;
   
               RNG rng_;
           };
       }  // namespace geometric
   }  // namespace ompl
   
   #endif