PolyLine.hpp

/* $Id$ */

#ifndef _POLY_LINE_HPP_
#define _POLY_LINE_HPP_

#include <geom/Atom.hpp>

namespace jafar {
  namespace geom {
    template<int dimension>
    class Segment;
    template<int dimension>
    class Repere;
    template<int dimension>
    class PolyLine : public Atom<dimension> {
        typedef typename Atom<dimension>::HomogenousVecD HomogenousVecD;
        typedef typename Atom<dimension>::HomogenousMatrixD HomogenousMatrixD;
        typedef typename Atom<dimension>::VecD VecD;
        typedef Repere<dimension> RepereD;
        typedef Segment<dimension> SegmentD;
      public:
        class Driver : public Atom<dimension>::Driver {
          public:
            Driver( ) : Atom<dimension>::Driver()
            {
            }
            virtual std::vector< SegmentD > segments() const =0;
            virtual std::vector< HomogenousVecD > points() const =0;
            virtual Driver* clone() const = 0;
        };
      public:
        class PolyLineNM1Driver :  public Driver {
          typedef typename Atom<dimension-1>::HomogenousVecD HomogenousVecNM1;
          typedef typename ublas::vector_range< HomogenousVecD > homogenous_vec_range; 
          public:
            PolyLineNM1Driver( const PolyLine<dimension-1>*, const RepereD* reference);
            virtual std::vector< SegmentD > segments() const;
            virtual std::vector< HomogenousVecD > points() const;
            virtual Driver* clone() const;
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const;
          private:
            const PolyLine<dimension-1>* m_polyLine;
            const RepereD* m_reference;
        };
        class PointsPointerDriver : public Driver {
          public:
            PointsPointerDriver( const std::vector< const Point<dimension>* >& _points);
            virtual std::vector< SegmentD > segments() const;
            virtual std::vector< HomogenousVecD > points() const;
            virtual Driver* clone() const ;
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const;
          private:
            std::vector< const Point<dimension>* > m_points;
        };
        
        class PointsDriver : public Driver, public Transferrable<dimension> {
          public:
            PointsDriver( const std::vector< HomogenousVecD >& points, const RepereD* reference = RepereD::global() );
            virtual void changeReference( const RepereD* reference );
            virtual std::vector< SegmentD > segments() const;
            virtual std::vector< HomogenousVecD > points() const;
            virtual Driver* clone() const ;
            virtual const RepereD* reference( ) const;
            virtual bool hasCov() const { return false; }
          private:
            std::vector< HomogenousVecD > m_points;
            const RepereD* m_reference;
        };
        class PolyLineNP1Driver : public Driver, public Transferrable<dimension> {
          public:
          PolyLineNP1Driver( const PolyLine<dimension>& polyLine );
        };
      public:
        PolyLine( Driver* driver );
        PolyLine(const PolyLine&);
        PolyLine& operator=(const PolyLine&);
        ~PolyLine();
        virtual typename Atom<dimension>::Type type() const { return Atom<dimension>::T_PolyLine; }
        virtual BoundingBox<dimension> boundingBox() const;
        std::vector< SegmentD > segments() const;
        std::vector< HomogenousVecD > points() const;
        inline double perimeter() const;
      public:
        GEN_DISTANCE_FUNCTIONS
        GEN_ANGLE_FUNCTIONS
        GEN_VISITOR_FUNCTIONS
      private:
        Driver* m_driver;
    };
  }
}

#include "geom/PolyLineImpl.hpp"

#endif