ompl/control/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 base
00048     {
00050         OMPL_CLASS_FORWARD(OptimizationObjective);
00052     }
00053 
00054     namespace control
00055     {
00060         class PathControl : public base::Path
00061         {
00062         public:
00063 
00065             PathControl(const base::SpaceInformationPtr &si);
00066 
00068             PathControl(const PathControl &path);
00069 
00070             virtual ~PathControl()
00071             {
00072                 freeMemory();
00073             }
00074 
00076             PathControl& operator=(const PathControl &other);
00077 
00079             virtual base::Cost cost(const base::OptimizationObjectivePtr& obj) const;
00080 
00082             virtual double length() const;
00083 
00085             virtual bool check() const;
00086 
00088             virtual void print(std::ostream &out) const;
00098             virtual void printAsMatrix(std::ostream &out) const;
00099 
00101             geometric::PathGeometric asGeometric() const;
00102 
00108             void append(const base::State *state);
00109 
00112             void append(const base::State *state, const Control *control, double duration);
00113 
00115             void interpolate();
00116 
00118             void random();
00119 
00121             bool randomValid(unsigned int attempts);
00122 
00129             std::vector<base::State*>& getStates()
00130             {
00131                 return states_;
00132             }
00133 
00135             std::vector<Control*>& getControls()
00136             {
00137                 return controls_;
00138             }
00139 
00141             std::vector<double>& getControlDurations()
00142             {
00143                 return controlDurations_;
00144             }
00145 
00147             base::State* getState(unsigned int index)
00148             {
00149                 return states_[index];
00150             }
00151 
00153             const base::State* getState(unsigned int index) const
00154             {
00155                 return states_[index];
00156             }
00157 
00159             Control* getControl(unsigned int index)
00160             {
00161                 return controls_[index];
00162             }
00163 
00165             const Control* getControl(unsigned int index) const
00166             {
00167                 return controls_[index];
00168             }
00169 
00171             double getControlDuration(unsigned int index) const
00172             {
00173                 return controlDurations_[index];
00174             }
00175 
00177             std::size_t getStateCount() const
00178             {
00179                 return states_.size();
00180             }
00181 
00183             std::size_t getControlCount() const
00184             {
00185                 return controls_.size();
00186             }
00187 
00190         protected:
00191 
00193             std::vector<base::State*>   states_;
00194 
00196             std::vector<Control*>       controls_;
00197 
00199             std::vector<double>         controlDurations_;
00200 
00202             void freeMemory();
00203 
00205             void copyFrom(const PathControl &other);
00206 
00207         };
00208 
00209     }
00210 }
00211 
00212 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines