estar/Facade.hpp

Go to the documentation of this file.

/* 
 * Copyright (C) 2006 Roland Philippsen <roland dot philippsen at gmx net>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */


#ifndef ESTAR_FACADE_HPP
#define ESTAR_FACADE_HPP


#include <estar/FacadeWriteInterface.hpp>
#include <estar/FacadeReadInterface.hpp>
#include <estar/CSpace.hpp>
#include <estar/Grid.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
#include <iosfwd>


namespace pnf {                 // rfct
  class Flow;
}


namespace estar {
  
  
  class Region;
  
  
  class GridOptions
  {
  public:
    GridOptions(ssize_t xbegin, ssize_t xend,
                ssize_t ybegin, ssize_t yend,
                double init_meta = 0,
                Grid::neighborhood_t neighborhood = Grid::FOUR);
    
    ssize_t xbegin, xend, ybegin, yend;
    double init_meta;
    
    Grid::neighborhood_t neighborhood;
  };
  
  
  class AlgorithmOptions
  {
  public:
    AlgorithmOptions();
    
    AlgorithmOptions(bool check_upwind,
                     bool check_local_consistency,
                     bool check_queue_key,
                     bool auto_reset,
                     bool auto_flush);
    
    bool check_upwind;
    
    bool check_local_consistency;
    
    bool check_queue_key;
    
    bool auto_reset;
    
    bool auto_flush;
  };
  
  
  class Facade
    : public FacadeWriteInterface,
      public FacadeReadInterface
  {
  public:
    typedef FacadeReadInterface::node_status_t node_status_t;
    
    
    const double scale; 
    
    
    static Facade *
    Create(
           const std::string & kernel_name,
           double scale,
           GridOptions const & grid_options,
           AlgorithmOptions const & algo_options,
           FILE * dbgstream);
    
    static Facade *
    CreateDefault(ssize_t xsize, ssize_t ysize, double scale);
    
    
    Facade(boost::shared_ptr<Algorithm> algo,
           boost::shared_ptr<Grid> grid,
           boost::shared_ptr<Kernel> kernel);
    
    
    virtual double GetScale() const { return scale; }
    
    virtual double GetFreespaceMeta() const;
    
    virtual double GetObstacleMeta() const;
    
    virtual double GetValue(ssize_t ix, ssize_t iy) const;
    
    virtual double GetMeta(ssize_t ix, ssize_t iy) const;
    
    virtual bool SetMeta(ssize_t ix, ssize_t iy, double meta);
    
    virtual bool AddGoal(ssize_t ix, ssize_t iy, double value);
    
    void AddGoal(const Region & goal);
    
    void RemoveGoal(ssize_t ix, ssize_t iy);
    
    void RemoveGoal(const Region & goal);
    
    virtual void RemoveAllGoals();
    
    virtual bool IsGoal(ssize_t ix, ssize_t iy) const;
    
    virtual bool HaveWork() const;
    
    virtual void ComputeOne();
    
    virtual void Reset();
    
    virtual node_status_t GetStatus(ssize_t ix, ssize_t iy) const;
        
    virtual node_status_t GetStatus(vertex_t vertex) const;
    
    virtual bool IsValidIndex(ssize_t ix, ssize_t iy) const;
    
    virtual bool GetLowestInconsistentValue(double & value) const;
    
    void DumpGrid(FILE * stream) const;
    
    void DumpQueue(FILE * stream,
                   size_t limit) const;
    
    void DumpPointers(FILE * stream) const;
    
    virtual const Algorithm & GetAlgorithm() const { return * m_algo; }
    
  protected:
    friend class pnf::Flow;
    
    virtual boost::shared_ptr<Grid const> GetGrid() const;
  public:
    
    virtual const Kernel & GetKernel() const { return * m_kernel; }
    
    virtual int TraceCarrot(double robot_x, double robot_y,
                            double distance, double stepsize,
                            size_t maxsteps,
                            carrot_trace & trace) const;
    
    virtual boost::shared_ptr<GridCSpace const> GetCSpace() const;
    
    
    Algorithm & GetAlgorithm() { return * m_algo; }
    
    Kernel & GetKernel() { return * m_kernel; }
    
  private:
    boost::shared_ptr<GridCSpace const> m_cspace;
    boost::shared_ptr<Algorithm> m_algo;
    boost::shared_ptr<Grid> m_grid;
    boost::shared_ptr<Kernel> m_kernel;
    
    node_status_t DoGetStatus(ssize_t ix, ssize_t iy, vertex_t vertex) const;
  };
  
} // namespace estar

#endif // ESTAR_FACADE_HPP

---

E* Interpolated Graph Replanner Wed Dec 12 18:55:40 2007