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

---

Stroke.h

//
//  Filename         : Stroke.h
//  Author(s)        : Stephane Grabli
//  Purpose          : Classes to define a stroke
//  Date of creation : 09/09/2002
//


//
//  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  STROKE_H
# define STROKE_H

# include <vector>
# include <map>
# include "../system/FreestyleConfig.h"
# include "../view_map/Silhouette.h"
# include "Curve.h"
# include "../view_map/Interface1D.h"
# include "../system/StringUtils.h"

//
//  StrokeAttribute
//

class LIB_STROKE_EXPORT StrokeAttribute
{
public:

  StrokeAttribute();
  StrokeAttribute(const StrokeAttribute& iBrother);
  StrokeAttribute(float iRColor, float iGColor, float iBColor,
                  float iAlpha,
                  float iRThickness, float iLThickness);

  StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t);

  virtual ~StrokeAttribute();

  /* operators */
  StrokeAttribute& operator=(const StrokeAttribute& iBrother);
  
  /* accessors */
  inline const float* getColor()  const { return _color; }
  inline const float  getColorR() const { return _color[0]; }
  inline const float  getColorG() const { return _color[1]; }
  inline const float  getColorB() const { return _color[2]; }
  inline Vec3f  getColorRGB() const { return Vec3f(_color[0], _color[1], _color[2]); }
  inline float getAlpha() const { return _alpha; }
  inline const float* getThickness() const { return _thickness; }
  inline const float  getThicknessR() const { return _thickness[0]; }
  inline const float  getThicknessL() const { return _thickness[1]; }
  inline Vec2f getThicknessRL() const { return Vec2f(_thickness[0], _thickness[1]); }

  inline bool isVisible() const {return _visible;}

  float getAttributeReal(const char *iName) const;
  Vec2f getAttributeVec2f(const char *iName) const;
  Vec3f getAttributeVec3f(const char *iName) const;

  bool isAttributeAvailableReal(const char *iName) const ;
  bool isAttributeAvailableVec2f(const char *iName) const ;
  bool isAttributeAvailableVec3f(const char *iName) const ;
  
  /* modifiers */
  inline void setColor(float r, float g, float b) { _color[0]=r; _color[1]=g; _color[2]=b; }
  inline void setColor(const Vec3f& iRGB) { _color[0]=iRGB[0]; _color[1]=iRGB[1]; _color[2]=iRGB[2]; }
  inline void setAlpha(float alpha) { _alpha = alpha; }
  inline void setThickness(float tr, float tl) { _thickness[0]=tr; _thickness[1]=tl; }
  inline void setThickness(const Vec2f& tRL) { _thickness[0]=tRL[0]; _thickness[1]=tRL[1]; }

  inline void SetVisible(bool iVisible){ _visible = iVisible; }

  void setAttributeReal(const char *iName, float att);
  void setAttributeVec2f(const char *iName, const Vec2f& att);
  void setAttributeVec3f(const char *iName, const Vec3f& att);

private:

  typedef std::map<const char*, float, StringUtils::ltstr> realMap ;
  typedef std::map<const char*, Vec2f, StringUtils::ltstr> Vec2fMap ;
  typedef std::map<const char*, Vec3f, StringUtils::ltstr> Vec3fMap ;

  float _color[3];      
  float _alpha;         
  float _thickness[2];  
  bool _visible;
  realMap *_userAttributesReal;
  Vec2fMap *_userAttributesVec2f;
  Vec3fMap *_userAttributesVec3f;
};


//
//  StrokeVertex
//

class LIB_STROKE_EXPORT StrokeVertex : public CurvePoint
{
public: // Implementation of Interface0D

  virtual string getExactTypeName() const {
    return "StrokeVertex";
  }

private:

  StrokeAttribute _Attribute; 
  float _CurvilignAbscissa; 
  float _StrokeLength; // stroke length
  
public:

  StrokeVertex();
  StrokeVertex(const StrokeVertex& iBrother);
  StrokeVertex(SVertex *iSVertex);
  StrokeVertex(CurvePoint *iPoint);
  StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);
  StrokeVertex(SVertex *iSVertex, const StrokeAttribute& iAttribute);
  virtual ~StrokeVertex();
  
  /* operators */
  StrokeVertex& operator=(const StrokeVertex& iBrother);
  
  /* accessors */
  inline real x() const { return _Point2d[0]; }
  inline real y() const { return _Point2d[1]; }
  Vec2f getPoint () {return Vec2f((float)point2d()[0], (float)point2d()[1]);}
  inline real  operator[](const int i) const { return _Point2d[i]; }
  inline const StrokeAttribute& attribute() const { return _Attribute; }
  inline StrokeAttribute& attribute() {return _Attribute;}
  inline float curvilinearAbscissa() const {return _CurvilignAbscissa;}
  inline float strokeLength() const {return _StrokeLength;}
  inline float u() const {return _CurvilignAbscissa/_StrokeLength;}

  /* modifiers */
  inline void SetX(real x) { _Point2d[0]=x; }
  inline void SetY(real y) { _Point2d[1]=y; }
  inline void SetPoint(real x, real y) { _Point2d[0]=x; _Point2d[1]=y;}
  inline void SetPoint(const Vec2f& p) { _Point2d[0] = p[0];_Point2d[1] = p[1];}
  inline real& operator[](const int i) { return _Point2d[i]; }
  inline void SetAttribute(const StrokeAttribute& iAttribute) { _Attribute = iAttribute; }
  inline void SetCurvilinearAbscissa(float iAbscissa) {_CurvilignAbscissa = iAbscissa;}
  inline void SetStrokeLength(float iLength) {_StrokeLength = iLength;}
  
  /* interface definition */
  /* inherited */  
  
};


//
//  Stroke
//

class StrokeRenderer;
class StrokeRep;

namespace StrokeInternal {
  class vertex_const_traits ;
  class vertex_nonconst_traits ;
  template<class Traits> class vertex_iterator_base;
  class StrokeVertexIterator;
} // end of namespace StrokeInternal

class LIB_STROKE_EXPORT Stroke : public Interface1D
{
public: // Implementation of Interface1D

  virtual string getExactTypeName() const {
    return "Stroke";
  }

  // Data access methods

  virtual Id getId() const {
    return _id;
  }
  typedef enum{
    DRY_MEDIUM,
    HUMID_MEDIUM,
    OPAQUE_MEDIUM,  
  } MediumType;

  
public:
  typedef std::deque<StrokeVertex*> vertex_container; // the vertices container
  typedef std::vector<ViewEdge*> viewedge_container; // the viewedges container
  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_nonconst_traits > vertex_iterator;
  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_const_traits> const_vertex_iterator;

public:
  //typedef StrokeVertex                                        vertex_type;
private:
  vertex_container _Vertices; 
  Id _id;
  float _Length; // The stroke length
  viewedge_container _ViewEdges;
  float _sampling;
  StrokeRenderer *_renderer; // mark implementation OpenGL renderer
  MediumType _mediumType;
  unsigned int _textureId;
  bool _tips;
  Vec2r _extremityOrientations[2]; // the orientations of the first and last extermity
  StrokeRep *_rep;

public:
  Stroke();
  Stroke(const Stroke& iBrother);
  template<class InputVertexIterator>
  Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);

  virtual ~Stroke();
  
  /* operators */
  Stroke& operator=(const Stroke& iBrother);

  float ComputeSampling(int iNVertices);
  
  void Resample(int iNPoints);

  void Resample(float iSampling);

  void RemoveVertex(StrokeVertex *iVertex);

  void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);

  /* Render method */
  void Render(const StrokeRenderer *iRenderer );
  void RenderBasic(const StrokeRenderer *iRenderer );

  /* Iterator definition */
  
  /* accessors */
  inline real getLength2D() const {return _Length;}
  inline MediumType getMediumType() const {return _mediumType;}
  inline unsigned int getTextureId() {return _textureId;}
  inline bool hasTips() const {return _tips;}
  /* these advanced iterators are used only in C++ */
  inline int vertices_size() const {return _Vertices.size();}
  inline viewedge_container::const_iterator viewedges_begin() const {return _ViewEdges.begin();}
  inline viewedge_container::iterator viewedges_begin()  {return _ViewEdges.begin();}
  inline viewedge_container::const_iterator viewedges_end() const {return _ViewEdges.end();}
  inline viewedge_container::iterator viewedges_end()  {return _ViewEdges.end();}
  inline int viewedges_size() const {return _ViewEdges.size();}
  
  inline Vec2r getBeginningOrientation() const {return _extremityOrientations[0];}
  inline real getBeginningOrientationX() const {return _extremityOrientations[0].x();}
  inline real getBeginningOrientationY() const {return _extremityOrientations[0].y();}
  inline Vec2r getEndingOrientation() const {return _extremityOrientations[1];}
  inline real getEndingOrientationX() const {return _extremityOrientations[1].x();}
  inline real getEndingOrientationY() const {return _extremityOrientations[1].y();}


  /* modifiers */
  inline void SetId(const Id& id) {_id = id;}
  void SetLength(float iLength);
  inline void SetMediumType(MediumType iType) {_mediumType = iType;}
  inline void SetTextureId(unsigned int id) {_textureId = id;}
  inline void SetTips(bool iTips) {_tips = iTips;}
  
  inline void push_back(StrokeVertex* iVertex) { _Vertices.push_back(iVertex); }
  inline void push_front(StrokeVertex* iVertex) { _Vertices.push_front(iVertex); }
  inline void AddViewEdge(ViewEdge *iViewEdge) {_ViewEdges.push_back(iViewEdge);}
  inline void SetBeginningOrientation(const Vec2r& iOrientation) {_extremityOrientations[0] = iOrientation;}
  inline void SetBeginningOrientation(real x, real y) {_extremityOrientations[0] = Vec2r(x,y);}
  inline void SetEndingOrientation(const Vec2r& iOrientation) {_extremityOrientations[1] = iOrientation;}
  inline void SetEndingOrientation(real x, real y) {_extremityOrientations[1] = Vec2r(x,y);}

  /* Information access interface */
  
  // embedding vertex iterator
  const_vertex_iterator vertices_begin() const;
  vertex_iterator vertices_begin(float t=0.f);
  const_vertex_iterator vertices_end() const;
  vertex_iterator vertices_end();

  StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t=0.f);
  StrokeInternal::StrokeVertexIterator strokeVerticesEnd();
  inline unsigned int strokeVerticesSize() const {return _Vertices.size();}
  
  // Iterator access (Interface1D)
  virtual Interface0DIterator verticesBegin();
  virtual Interface0DIterator verticesEnd();

  virtual Interface0DIterator pointsBegin(float t=0.f);
  virtual Interface0DIterator pointsEnd(float t=0.f);
};



//
//  Implementation
//


template<class InputVertexIterator>
Stroke::Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd)
{
  for(InputVertexIterator v=iBegin, vend=iEnd;
  v!=vend;
  v++)
  {
    _Vertices.push_back(*v);
  }
  _Length = 0;
  _id = 0;
}

#endif // STROKE_H

---

Last modified 3 Mar 2008

© Stephane Grabli