fs_path.h

Go to the documentation of this file.

#ifndef REACHABILITY_H
#define REACHABILITY_H

#include <freespace.h>
#include <boundary.h>
#include <poly/types.h>


namespace frechet { namespace reach {

using namespace data;
using namespace fs;
using namespace poly;

class FSPath {

protected:
    FreeSpace::ptr fs;
    bool wrapTop;
    bool wrapRight;
    Array2D<Interval> LR,BR;
    Curve fix;
    Curve path[2];
public:
    static const double PRECISION;

public:
    typedef boost::shared_ptr<FSPath> ptr;

    FSPath(FreeSpace::ptr afs);
    virtual ~FSPath() {}

    bool empty() const {
        return path[0].empty() && path[1].empty();
    }
    Curve getPath(int i) const;

    void mapFromP(Segment pseg, Curve result[2]) const;
    void mapFromQ(Segment pseg, Curve result[2]) const;

    void mapToP(Curve path[2]) const;
    void mapToQ(Curve path[2]) const;

    Point mapFromP(int p) const;
    Point mapFromQ(int q) const;

    double mapFromPToQ(int p) const;
    double mapFromQToP(int q) const;

    const frechet::data::Interval& left(int i, int j) const {
        return LR.at(i,j);
    }

    const frechet::data::Interval& bottom(int i, int j) const {
        return BR.at(i,j);
    }

    const Curve& fixPoints() const { return fix; }

    void clearReachability();

    virtual void clear();

    void calculateReachability(Point start, Point end, bool allow_wrap, double prec=PRECISION);

    void update(Point start, double epsilon);

    Point toPoint(Pointer segment);

    bool isReachable(int i, int j, double prec=PRECISION) const;
    bool isReachable(Point a, double prec=PRECISION) const;
    Point startPoint() const { return fix.first(); }

    static Interval opposite(const Interval& LR, const Interval& RF);

public:
    static void propagate(const Interval& RF, const Interval& TF,
                           const Interval& LR, const Interval& BR,
                           Interval& RR, Interval& TR);
protected:
    FSPath();

    void calculatePath();

    void findPathSegment(Point a, Point b, Curve curve[2], int& cc);
    bool propagateHorizontalEdge(Point a, double bx, double prec=PRECISION);
    bool propagateVerticalEdge(Point a, double by, double prec=PRECISION);
    void propagateInner(int i, int j, double bx, double by);
    void propagateBottom(int i, int j, double bx, double by);
    int next_hor(int i);
    int next_vert(int j);
    bool left_contains(int i, int j, double y, double prec=PRECISION) const;
    bool bottom_contains(int i, int j, double x, double prec=PRECISION) const;

    void propagateColumn(int i, int j0, double bx, double by, bool allow_wrap);
    void propagateBottom(int i, int j0, double bx, double by, bool allow_wrap);
    static double mapToSegment(double a, Point p1, Point p2);
    static void append(std::vector<double>& map, double x);

    static int binSearchX(const Curve& curve, int x);
    static int binSearchY(const Curve& curve, int y);
    static void copy(Curve& dest, const Curve& source, int i, int j);
    static bool are_consistent(Curve path0, Curve path1, int n, int m);
    //void copy2Sections(Curve dest[2], int i1, int j1,  int i2, int j2) const;
};


} }  //  namespace frechet::reach

#endif // REACHABILITY_H