h o m e

d o c u m e n t a t i o n

c l a s s h i e r a r c h y

---

Curve.h

//
//  Filename         : Curve.h
//  Author(s)        : Stephane Grabli
//  Purpose          : Class to define a container for curves
//  Date of creation : 11/01/2003
//


//
//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
//   with this source distribution. 
//
//  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  CURVE_H
# define CURVE_H

# include <deque>
# include "../system/BaseIterator.h"
# include "../geometry/Geom.h"
//# include "../scene_graph/Material.h"
# include "../view_map/Silhouette.h"
# include "../view_map/SilhouetteGeomEngine.h"
# include "../view_map/Interface0D.h"
# include "../view_map/Interface1D.h"

using namespace std;
using namespace Geometry;

                  /**********************************/
                  /*                                */
                  /*                                */
                  /*             CurvePoint         */
                  /*                                */
                  /*                                */
                  /**********************************/

class LIB_STROKE_EXPORT CurvePoint : public Interface0D
{
public: // Implementation of Interface0D
  virtual string getExactTypeName() const {
    return "CurvePoint";
  }

  // Data access methods
  virtual real getX() const {
    return _Point3d.x();
  }
  virtual real getY() const {
    return _Point3d.y();
  }
  virtual real getZ() const {
    return _Point3d.z();
  }
  virtual Vec3f getPoint3D() const {
    return _Point3d;
  }
  virtual real getProjectedX() const {
    return _Point2d.x();
  }
  virtual real getProjectedY() const {
    return _Point2d.y();
  }
  virtual real getProjectedZ() const {
    return _Point2d.z();
  }
  virtual Vec2f getPoint2D() const {
    return Vec2f((float)_Point2d.x(),(float)_Point2d.y());
  }

  virtual FEdge* getFEdge(Interface0D& inter);
  virtual Id getId() const {
    Id id;
    if(_t2d == 0)
      return __A->getId();
    else if(_t2d == 1)
      return __B->getId();
    return id;
  }
  virtual Nature::VertexNature getNature() const {
    Nature::VertexNature nature = Nature::POINT;
    if(_t2d == 0)
      nature |= __A->getNature();
    else if(_t2d == 1)
      nature |= __B->getNature();
    return nature;
  }

  virtual SVertex * castToSVertex(){
    if(_t2d == 0)
      return __A;
    else if(_t2d == 1)
      return __B;
    return Interface0D::castToSVertex();
  }

  virtual ViewVertex * castToViewVertex(){
    if(_t2d == 0)
      return __A->castToViewVertex();
    else if(_t2d == 1)
      return __B->castToViewVertex();
    return Interface0D::castToViewVertex();
  }

  virtual NonTVertex * castToNonTVertex(){
    if(_t2d == 0)
      return __A->castToNonTVertex();
    else if(_t2d == 1)
      return __B->castToNonTVertex();
    return Interface0D::castToNonTVertex();
  }

  virtual TVertex * castToTVertex(){
    if(_t2d == 0)
      return __A->castToTVertex();
    else if(_t2d == 1)
      return __B->castToTVertex();
    return Interface0D::castToTVertex();
  }
public:
  typedef SVertex vertex_type;
protected:
  SVertex *__A;
  SVertex *__B;
  float _t2d;
  //float _t3d;
  Vec3r _Point2d;
  Vec3r _Point3d;
public:
   CurvePoint();
   CurvePoint(SVertex *iA, SVertex *iB, float t2d) ;
   CurvePoint(CurvePoint *iA, CurvePoint *iB, float t2d) ;
  // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d) ;
   CurvePoint(const CurvePoint& iBrother) ;
   CurvePoint& operator=(const CurvePoint& iBrother) ;
  virtual ~CurvePoint() {}
  bool operator==(const CurvePoint& b){
    return ((__A==b.__A) && (__B==b.__B) && (_t2d==b._t2d));
  }

  /* accessors */
  inline SVertex * A() {return __A;}
  inline SVertex * B() {return __B;}
  inline float t2d() const {return _t2d;}
  //inline const float t3d() const {return _t3d;}

  /* modifiers */
  inline void SetA(SVertex *iA) {__A = iA;}
  inline void SetB(SVertex *iB) {__B = iB;}
  inline void SetT2d(float t) {_t2d = t;}
  //inline void SetT3d(float t) {_t3d = t;}

  /* Information access interface */

  FEdge *fedge() ;
  inline const Vec3r& point2d() const {return _Point2d;}
  inline const Vec3r& point3d() const {return _Point3d;}
   Vec3r normal() const ;
   //Material material() const ;
  // Id shape_id() const ;
   const SShape * shape() const ;
  // float shape_importance() const ;
  
   //const unsigned qi() const ;
   occluder_container::const_iterator occluders_begin() const ;
   occluder_container::const_iterator occluders_end() const ;
   bool occluders_empty() const ;
   int occluders_size() const ;
   const Polygon3r& occludee() const ;
   const SShape * occluded_shape() const ;
   const bool  occludee_empty() const ;
   real z_discontinuity() const ;
  //   float local_average_depth() const ;
  //   float local_depth_variance() const ;
  //   real local_average_density(float sigma = 2.3f) const ;
  // Vec3r shaded_color() const ;
//    Vec3r orientation2d() const ; 
//    Vec3r orientation3d() const ;
  //  // real curvature2d() const {return viewedge()->curvature2d((_VertexA->point2d()+_VertexB->point2d())/2.0);}  
  //   Vec3r curvature2d_as_vector() const ;
  //  /*! angle in radians */
  //   real curvature2d_as_angle() const ;

  real curvatureFredo () const;
  Vec2d directionFredo () const;
};


                  /**********************************/
                  /*                                */
                  /*                                */
                  /*             Curve              */
                  /*                                */
                  /*                                */
                  /**********************************/

namespace CurveInternal {
  class CurvePoint_const_traits;
  class CurvePoint_nonconst_traits;
  template<class Traits> class __point_iterator;
  class CurvePointIterator;
} // end of namespace CurveInternal

class LIB_STROKE_EXPORT Curve : public Interface1D
{
public:
  typedef CurvePoint Vertex;
  typedef CurvePoint Point;
  typedef Point point_type;
  typedef Vertex vertex_type;
  typedef deque<Vertex*> vertex_container;

  /* Iterator to iterate over a vertex edges */
  
  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_nonconst_traits > point_iterator;
  typedef CurveInternal::__point_iterator<CurveInternal::CurvePoint_const_traits > const_point_iterator;
  typedef point_iterator vertex_iterator ;
  typedef const_point_iterator const_vertex_iterator ;
  
protected:
  vertex_container _Vertices;
  double _Length;
  Id _Id;
  unsigned _nSegments; // number of segments

public:
  Curve() {_Length = 0;_Id = 0;_nSegments=0;}
  Curve(const Id& id) {_Length = 0;_Id = id;_nSegments=0;}
  Curve(const Curve& iBrother) {_Length = iBrother._Length;_Vertices = iBrother._Vertices;_Id=iBrother._Id;_nSegments=0;}
  virtual ~Curve() ;

  /*
        fredo's curvature storage
  */
  void computeCurvatureAndOrientation ();

  inline void push_vertex_back(Vertex *iVertex) 
  {
    if(!_Vertices.empty())
    {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex * new_vertex = new Vertex(*iVertex);
    _Vertices.push_back(new_vertex);
  }
  inline void push_vertex_back(SVertex *iVertex) 
  {
    if(!_Vertices.empty())
    {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.back()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(iVertex, 0,0);
    _Vertices.push_back(new_vertex);
  }
  inline void push_vertex_front(Vertex *iVertex) 
  {
    if(!_Vertices.empty())
    {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex * new_vertex = new Vertex(*iVertex);
    _Vertices.push_front(new_vertex);
  }
  inline void push_vertex_front(SVertex *iVertex) 
  {
    if(!_Vertices.empty())
    {
      Vec3r vec_tmp(iVertex->point2d() - _Vertices.front()->point2d());
      _Length += vec_tmp.norm();
      ++_nSegments;
    }
    Vertex *new_vertex = new Vertex(iVertex, 0,0);
    _Vertices.push_front(new_vertex);
  }
  inline bool empty() const {return _Vertices.empty();}
  inline real getLength2D() const {return _Length;}
  virtual Id getId() const {
    return _Id;
  }
  inline unsigned int nSegments() const {return _nSegments;}

  inline void setId(const Id& id){_Id = id;}
  /* Information access interface */
  
  
  //inline Vec3r shaded_color(int iCombination = 0) const ;
  //  inline Vec3r  orientation2d(point_iterator it) const ;
   //Vec3r  orientation2d(int iCombination = 0) const ;
  //   Vec3r  orientation3d(point_iterator it) const ;
   //Vec3r  orientation3d(int iCombination = 0) const ;
  // real curvature2d(point_iterator it) const {return (*it)->curvature2d();}
  // real curvature2d(int iCombination = 0) const ;
   //Material material() const ;
   //int qi() const ;
   //   occluder_container::const_iterator occluders_begin() const ;
   //   occluder_container::const_iterator occluders_end() const ;
   //int occluders_size() const;
   //bool occluders_empty() const ;
  // const Polygon3r& occludee() const {return *(_FEdgeA->aFace());}
   //const SShape * occluded_shape() const;
   //const bool occludee_empty() const ;
   //real z_discontinuity(int iCombination = 0) const ;
  // int shape_id() const ;
   //const SShape * shape() const ;
   //float shape_importance(int iCombination=0) const ;
   //float local_average_depth(int iCombination = 0) const;
   //float local_depth_variance(int iCombination = 0) const ;
   //real local_average_density(float sigma = 2.3f, int iCombination = 0) const ;
   //Vec3r curvature2d_as_vector(int iCombination=0) const ;
   //real curvature2d_as_angle(int iCombination=0) const ;  
  
  /* advanced iterators access */
  point_iterator points_begin(float step = 0);
  const_point_iterator points_begin(float step = 0) const;
  point_iterator points_end(float step = 0);
  const_point_iterator points_end(float step = 0) const;

  // methods given for convenience */
  point_iterator vertices_begin();
  const_point_iterator vertices_begin() const;
  point_iterator vertices_end();
  const_point_iterator vertices_end() const;

  // specialized iterators access
  CurveInternal::CurvePointIterator curvePointsBegin(float t=0.f);
  CurveInternal::CurvePointIterator curvePointsEnd(float t=0.f);

  CurveInternal::CurvePointIterator curveVerticesBegin();
  CurveInternal::CurvePointIterator curveVerticesEnd();

  // Iterators access
  virtual Interface0DIterator verticesBegin();
  virtual Interface0DIterator verticesEnd();
  virtual Interface0DIterator pointsBegin(float t=0.f);
  virtual Interface0DIterator pointsEnd(float t=0.f);
};

  

#endif

---

Last modified 3 Mar 2008

© Stephane Grabli