All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator
PathControl.h
00001 /*********************************************************************
00002 * Software License Agreement (BSD License)
00003 *
00004 *  Copyright (c) 2010, Rice University
00005 *  All rights reserved.
00006 *
00007 *  Redistribution and use in source and binary forms, with or without
00008 *  modification, are permitted provided that the following conditions
00009 *  are met:
00010 *
00011 *   * Redistributions of source code must retain the above copyright
00012 *     notice, this list of conditions and the following disclaimer.
00013 *   * Redistributions in binary form must reproduce the above
00014 *     copyright notice, this list of conditions and the following
00015 *     disclaimer in the documentation and/or other materials provided
00016 *     with the distribution.
00017 *   * Neither the name of the Rice University nor the names of its
00018 *     contributors may be used to endorse or promote products derived
00019 *     from this software without specific prior written permission.
00020 *
00021 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00022 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00023 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00024 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
00025 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00026 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00027 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00028 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00029 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00030 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
00031 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00032 *  POSSIBILITY OF SUCH DAMAGE.
00033 *********************************************************************/
00034 
00035 /* Author: Ioan Sucan */
00036 
00037 #ifndef OMPL_CONTROL_PATH_CONTROL_
00038 #define OMPL_CONTROL_PATH_CONTROL_
00039 
00040 #include "ompl/control/SpaceInformation.h"
00041 #include "ompl/base/Path.h"
00042 #include "ompl/geometric/PathGeometric.h"
00043 #include <vector>
00044 
00045 namespace ompl
00046 {
00047     namespace control
00048     {
00049 
00054         class PathControl : public base::Path
00055         {
00056         public:
00057 
00059             PathControl(const base::SpaceInformationPtr &si);
00060 
00062             PathControl(const PathControl &path);
00063 
00064             virtual ~PathControl(void)
00065             {
00066                 freeMemory();
00067             }
00068 
00070             PathControl& operator=(const PathControl& other);
00071 
00073             virtual double length(void) const;
00074 
00076             virtual bool check(void) const;
00077 
00079             virtual void print(std::ostream &out) const;
00080 
00082             geometric::PathGeometric asGeometric(void) const;
00083 
00089             void append(const base::State *state);
00090 
00093             void append(const base::State *state, const Control *control, double duration);
00094 
00096             void interpolate(void);
00097 
00099             void random(void);
00100 
00102             bool randomValid(unsigned int attempts);
00103 
00110             std::vector<base::State*>& getStates(void)
00111             {
00112                 return states_;
00113             }
00114 
00116             std::vector<Control*>& getControls(void)
00117             {
00118                 return controls_;
00119             }
00120 
00122             std::vector<double>& getControlDurations(void)
00123             {
00124                 return controlDurations_;
00125             }
00126 
00128             base::State* getState(unsigned int index)
00129             {
00130                 return states_[index];
00131             }
00132 
00134             const base::State* getState(unsigned int index) const
00135             {
00136                 return states_[index];
00137             }
00138 
00140             Control* getControl(unsigned int index)
00141             {
00142                 return controls_[index];
00143             }
00144 
00146             const Control* getControl(unsigned int index) const
00147             {
00148                 return controls_[index];
00149             }
00150 
00152             double getControlDuration(unsigned int index) const
00153             {
00154                 return controlDurations_[index];
00155             }
00156 
00158             std::size_t getStateCount(void) const
00159             {
00160                 return states_.size();
00161             }
00162 
00164             std::size_t getControlCount(void) const
00165             {
00166                 return controls_.size();
00167             }
00168 
00171         protected:
00172 
00174             std::vector<base::State*>   states_;
00175 
00177             std::vector<Control*>       controls_;
00178 
00180             std::vector<double>         controlDurations_;
00181 
00183             void freeMemory(void);
00184 
00186             void copyFrom(const PathControl& other);
00187 
00188         };
00189 
00190     }
00191 }
00192 
00193 #endif
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends