path.h

#ifndef PATH_H
#define PATH_H

#include <string>
#include <vector>
#include "ConMath.h"


#include "config.h"
#include "entity.h"
#include "LineContext.h"

class Path : public Entity{
public:

  typedef enum {
    INIT_ERROR,
    RESULT_PAST_PATH,
    RESULT_BEHIND_PATH,
    NOT_ON_PATH,
    PROTECTION_FAULT,
    INVALID_COORD
  } Error;

  class Point{
    static const double UNDEFINED_LENGTH;
    public:
      Point() : s(UNDEFINED_LENGTH){};
      Point(const Vector& position, const double d = UNDEFINED_LENGTH) : s(d), p(position){};
      ~Point(){};

      const Vector& getPosition() const { return p; };
      Point& operator =(const Point& i){
        p = i.p;
        s = i.s;
        index = i.index;
        return (*this);
      }
      double s;
      int index;
      Vector p;
  };

  /*****************************
   * TRAVERSAL
   ******************************/

  void Step(Point &in_pt, const double delta) const;
  
  virtual void Jump(Point &in_pt, const double dist) const;

  /*****************************
   GLOBAL MANIPULATION
   *****************************/

  void Reduce(const double dist, LineContext *lc_array);

  
  virtual void Splice(const double begin, const double end);

  static Path Combine(const Path& p1, const Path& p2);
    
  /*****************************
   GLOBAL PROPERTIES
   *****************************/

  virtual double Length(void) const;
  virtual double Curvature(void) const;

  virtual LineContext * ClosestDistance(LineContext *lc_array) const;

  virtual Intersection Collide(const double radius, LineContext *lc_array) const;

  virtual double GetDistance(const Path& path, Point &ret1, Point &ret2) const;

  void SetProtectedLength(const double len);


  /*****************************
   POINT ACQUISITION FUNCTIONS
   *****************************/
  
  virtual Point ProjectPoint(const Vector &p) const;

  virtual Point GetPoint(const Vector& p) const;

  virtual Point GetPoint(const double d) const;

  Point operator [](const double s) const;

  Point operator [](const Vector& v) const;


  /*****************************
   PROPERTIES OF PATH AT A POINT
   *****************************/

  virtual Vector Tangent(const Point& p) const;

  virtual Vector Tangent(const double d) const;

  /*****************************
   PATH CONSTRUCTION
   *****************************/

  void AddSample(const Vector& pos);

  Path& operator +=(const Vector& v);

  Path& operator +=(const Path& app);

  Path operator +(const Path& app) const;
  
  virtual Path Subsection(const double begin, const double end) const;

  /*****************************
   AUXILIARY
   *****************************/

  void Render(const double color[]) const;

  void Render(void) const;

  virtual ConStruct ToConstruct() const;

  void SetColor(const Vector& color, double opacity);

  virtual Path Clone(void) const;

  static const double BEGIN;

  static const double END;


  Path();

  Path(const Path& path);

  Path(const ConStruct& con);

  virtual ~Path();

protected:  
  double fixed_length;

  struct Samples{
    std::vector<Vector> points;
    std::vector<double> s;
    int refcount;
    double color[4];
  };

  Samples *samples;
  
private:
  int GetIndex(const double s) const;
};

//AbstractFactory for paths
//If you do not know what this is, stop working with this code
//read "Design Patterns" and come back later

class PathFactory{
public:
  virtual Path CreatePath(const ConStruct& con) const = 0;
protected:
  PathFactory();
  virtual ~PathFactory();
};
#endif

---