Merged changes in the trunk up to revision 53146.
[blender.git] / source / blender / freestyle / intern / view_map / ViewMap.h
1 //
2 //  Filename         : ViewMap.h
3 //  Author(s)        : Stephane Grabli
4 //  Purpose          : Classes to define a View Map (ViewVertex, ViewEdge, etc.)
5 //  Date of creation : 03/09/2002
6 //
7 ///////////////////////////////////////////////////////////////////////////////
8
9
10 //
11 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
12 //   with this source distribution. 
13 //
14 //  This program is free software; you can redistribute it and/or
15 //  modify it under the terms of the GNU General Public License
16 //  as published by the Free Software Foundation; either version 2
17 //  of the License, or (at your option) any later version.
18 //
19 //  This program is distributed in the hope that it will be useful,
20 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
21 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22 //  GNU General Public License for more details.
23 //
24 //  You should have received a copy of the GNU General Public License
25 //  along with this program; if not, write to the Free Software
26 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
27 //
28 ///////////////////////////////////////////////////////////////////////////////
29
30 #ifndef  VIEWMAP_H
31 # define VIEWMAP_H
32
33 # include "Interface0D.h"
34 # include "Interface1D.h"
35 # include "Silhouette.h" // defines the embedding
36 # include "../system/BaseIterator.h"
37 # include "../system/FreestyleConfig.h"
38 # include "../geometry/GeomUtils.h"
39 # include <map>
40
41                   /**********************************/
42                   /*                                */
43                   /*                                */
44                   /*             ViewMap            */
45                   /*                                */
46                   /*                                */
47                   /**********************************/
48
49
50 /*  Density
51     Mean area depth value
52     distance to a point
53     */
54
55 class ViewVertex;
56 class ViewEdge;
57 class ViewShape;
58 class TVertex;
59
60 /*! Class defining the ViewMap.*/
61 class LIB_VIEW_MAP_EXPORT ViewMap 
62 {
63 public:
64
65   typedef vector<ViewEdge*> viewedges_container;
66   typedef vector<ViewVertex*> viewvertices_container;
67   typedef vector<ViewShape*> viewshapes_container;
68   typedef vector<SVertex*> svertices_container;
69   typedef vector<FEdge*> fedges_container;
70   typedef map<int,int> id_to_index_map;
71
72 private:
73
74   static ViewMap *_pInstance;
75   viewshapes_container _VShapes; // view shapes
76   viewedges_container _VEdges; // view edges
77   viewvertices_container _VVertices; // view vertices
78   fedges_container _FEdges; // feature edges (embedded edges)
79   svertices_container _SVertices; // embedded vertices
80   BBox<Vec3r> _scene3DBBox;
81   id_to_index_map _shapeIdToIndex; // Mapping between the WShape or VShape id to the VShape index in the 
82                                 // _VShapes vector. Used in the method viewShape(int id) to access a shape from its id.
83
84 public:
85
86   /*! A field that can be used by the user to store any data.
87    *  This field must be reseted afterwards using ResetUserData().
88    */
89   void* userdata;
90
91   /*! Default constructor. */
92   ViewMap() {
93     _pInstance = this;
94     userdata = 0;
95   }
96   /*! Destructor. */
97   virtual ~ViewMap();
98
99   /*! Gets the viewedge the nearest to the 
100    *  2D position specified as argument
101    */
102   const ViewEdge * getClosestViewEdge(real x, real y) const ;
103
104   /*! Gets the Fedge the nearest to the 
105    *  2D position specified as argument
106    */
107   const FEdge * getClosestFEdge(real x, real y) const ;
108
109   /* accessors */
110   /*! The ViewMap is a singleton class. This static method
111    * returns the instance of the ViewMap.
112    */
113   static inline ViewMap * getInstance() {return _pInstance;}
114   /* Returns the list of ViewShapes of the scene. */
115   inline viewshapes_container& ViewShapes() {return _VShapes;}
116   /* Returns the list of ViewEdges of the scene. */
117   inline viewedges_container& ViewEdges() {return _VEdges;}
118   /* Returns the list of ViewVertices of the scene. */
119   inline viewvertices_container& ViewVertices() {return _VVertices;}
120   /* Returns the list of FEdges of the scene. */
121   inline fedges_container& FEdges() {return _FEdges;}
122   /* Returns the list of SVertices of the scene. */
123   inline svertices_container& SVertices() {return _SVertices;}
124   /* Returns an iterator pointing onto the first ViewEdge of the list. */
125   inline viewedges_container::iterator viewedges_begin() {return _VEdges.begin();}
126   inline viewedges_container::iterator viewedges_end() {return _VEdges.end();}
127   inline int viewedges_size() {return _VEdges.size();}
128   ViewShape * viewShape(unsigned index);
129   id_to_index_map& shapeIdToIndexMap() {return _shapeIdToIndex;}
130
131   /*! Returns the scene 3D bounding box. */
132   inline BBox<Vec3r> getScene3dBBox() const {return _scene3DBBox;}
133
134   /* modifiers */
135   void AddViewShape(ViewShape *iVShape);
136   inline void AddViewEdge(ViewEdge *iVEdge) {_VEdges.push_back(iVEdge);}
137   inline void AddViewVertex(ViewVertex *iVVertex) {_VVertices.push_back(iVVertex);}
138   inline void AddFEdge(FEdge *iFEdge) {_FEdges.push_back(iFEdge);}
139   inline void AddSVertex(SVertex *iSVertex) {_SVertices.push_back(iSVertex);}
140   /*! Sets the scene 3D bounding box. */
141   inline void setScene3dBBox(const BBox<Vec3r>& bbox) {_scene3DBBox=bbox;}
142
143   /* Creates a T vertex in the view map.
144    *  A T vertex is the intersection between 2
145    *  FEdges (before these ones are splitted).
146    *  The TVertex is a 2D intersection but it 
147    *  corresponds to a 3D point on each of the 2 FEdges.
148    *    iA3D
149    *      The 3D coordinates of the point corresponding 
150    *      to the intersection on the first edge.
151    *    iA2D
152    *      The x,y,z 2D coordinates of the projection 
153    *      of iA3D
154    *    iFEdgeA
155    *      The first FEdge
156    *    iB3D
157    *      The 3D coordinates of the point corresponding 
158    *      to the intersection on the second edge.
159    *    iB2D
160    *      The x,y,z 2D coordinates of the projection 
161    *      of iB3D
162    *    iFEdgeB
163    *      The second FEdge   
164    *    id
165    *      The id that must be given to that TVertex
166    */
167   TVertex* CreateTVertex(const Vec3r& iA3D, const Vec3r& iA2D, FEdge *iFEdgeA,
168                          const Vec3r& iB3D, const Vec3r& iB2D, FEdge *iFEdgeB,
169                          const Id& id);
170
171   /* Updates the structures to take into account the fact 
172    *  that a SVertex must now be considered as a ViewVertex 
173    *    iVertex
174    *      The SVertex on top of which the ViewVertex is built (it is necessarily
175    *      a NonTVertex because it is a SVertex)
176    *    newViewEdges
177    *      The new ViewEdges that must be add to the ViewMap
178    */
179   ViewVertex * InsertViewVertex(SVertex *iVertex, vector<ViewEdge*>& newViewEdges);
180
181   /* connects a FEdge to the graph trough a SVertex */
182   //FEdge * Connect(FEdge *ioEdge, SVertex *ioVertex);
183 };
184
185                   /**********************************/
186                   /*                                */
187                   /*                                */
188                   /*             ViewVertex         */
189                   /*                                */
190                   /*                                */
191                   /**********************************/
192
193 class ViewEdge;
194 class SShape;
195
196 namespace ViewVertexInternal {
197   class edge_const_traits;
198   class edge_nonconst_traits;
199   template<class Traits> class edge_iterator_base ;
200   class orientedViewEdgeIterator;
201 } // end of namespace ViewEdgeInternal
202 /*! Class to define a view vertex 
203  *  A view vertex is a feature vertex corresponding 
204  *  to a point of the image graph, where the characteristics of an 
205  *  edge might change (nature, visibility, ...).
206  *  A ViewVertex can be of two kinds: a TVertex when
207  *  it corresponds to the intersection between two
208  *  ViewEdges or a NonTVertex when it corresponds to a
209  *  vertex of the initial input mesh (it is the case
210  *  for vertices such as corners for example).
211  *  Thus, this class can be specialized into two classes,
212  *  the TVertex class and the NonTVertex class.
213  */
214 class LIB_VIEW_MAP_EXPORT ViewVertex : public Interface0D
215 {
216 public: // Implementation of Interface0D
217
218   /*! Returns the string "ViewVertex" .*/
219   virtual string getExactTypeName() const {
220     return "ViewVertex";
221   }
222
223 public:  
224   friend class ViewShape;
225   typedef pair<ViewEdge*, bool> directedViewEdge; // if bool = true, the ViewEdge is incoming
226
227   typedef vector<directedViewEdge> edges_container;
228
229   typedef ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_nonconst_traits> edge_iterator;
230   typedef ViewVertexInternal::edge_iterator_base<ViewVertexInternal::edge_const_traits> const_edge_iterator;
231
232 private:
233
234   Nature::VertexNature _Nature;
235
236 public:
237   /*! A field that can be used by the user to store any data.
238    *  This field must be reseted afterwards using ResetUserData().
239    */
240   void * userdata;
241   /*! Default constructor.*/
242   inline ViewVertex() {userdata = 0;_Nature = Nature::VIEW_VERTEX; }
243   inline ViewVertex(Nature::VertexNature nature) {
244     userdata = 0;
245     _Nature = Nature::VIEW_VERTEX | nature;
246   }
247
248 protected:
249   /*! Copy constructor. */
250   inline ViewVertex(ViewVertex& iBrother)
251   {
252     _Nature = iBrother._Nature;
253     iBrother.userdata = this;
254     userdata = 0;
255   }
256   /*! Cloning method. */
257   virtual ViewVertex * duplicate() = 0;
258   
259 public:
260   /*! Destructor. */
261   virtual ~ViewVertex() {}
262
263   /* accessors */
264   /*! Returns the nature of the vertex .*/
265   virtual Nature::VertexNature getNature() const {
266     return _Nature;
267   }
268
269   /* modifiers */
270   /*! Sets the nature of the vertex. */
271   inline void setNature(Nature::VertexNature iNature) {_Nature = iNature;}
272   
273   /* Replaces old edge by new edge */
274   virtual void Replace(ViewEdge *, ViewEdge *) {}
275
276 public:
277   
278   /* iterators access */
279   // allows iteration on the edges that comes from/goes to 
280   // this vertex in CCW order (order defined in 2D in the image plan)
281   virtual edge_iterator edges_begin() = 0;
282   virtual const_edge_iterator edges_begin() const = 0;
283   virtual edge_iterator edges_end() = 0;
284   virtual const_edge_iterator edges_end() const = 0;
285   virtual edge_iterator edges_iterator(ViewEdge *iEdge) = 0;
286   virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const  = 0;
287
288
289   // Iterator access
290   /*! Returns an iterator over the ViewEdges that goes to or comes from
291    *  this ViewVertex pointing to the first ViewEdge of the list.
292    *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
293    *  and to get the orientation for each ViewEdge (incoming/outgoing).
294    */
295   virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() = 0;
296
297   /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
298    *  pointing after the last ViewEdge.
299    */
300         virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() = 0;
301
302   /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
303    *  given as argument.
304    */
305         virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) = 0;
306   
307 };
308
309                   /**********************************/
310                   /*                                */
311                   /*                                */
312                   /*             TVertex            */
313                   /*                                */
314                   /*                                */
315                   /**********************************/
316
317 /*! class to define a T vertex, i.e. an intersection between 
318  *  two edges. 
319  *  It points towards 2 SVertex and 4 View edges.
320  *  Among these ViewEdges, 2 are front and 2 are back.
321  *  Basically the front edge hides part of the back edge.
322  *  So, among the back edges, 1 is of invisibility n
323  *  and the other of visibility n+1
324  */
325 class LIB_VIEW_MAP_EXPORT TVertex : public ViewVertex
326 {
327 public:
328   typedef vector<directedViewEdge*> edge_pointers_container;
329 public: // Implementation of Interface0D
330
331   /*! Returns the string "TVertex" .*/
332   virtual string getExactTypeName() const {
333     return "TVertex";
334   }
335
336   // Data access methods
337   /* Returns the 3D x coordinate of the vertex .
338    * Ambiguous in this case.
339    */
340   virtual real getX() const {
341     cerr << "Warning: getX() undefined for this point" << endl;
342     return _FrontSVertex->point3D().x();
343   }
344
345   virtual real getY() const {
346     cerr << "Warning: getX() undefined for this point" << endl;
347     return _FrontSVertex->point3D().y();
348   }
349
350   virtual real getZ() const {
351     cerr << "Warning: getX() undefined for this point" << endl;
352     return _FrontSVertex->point3D().z();
353   }
354
355   /*!  Returns the 3D point. */ 
356   virtual Vec3f getPoint3D() const {
357     cerr << "Warning: getPoint3D() undefined for this point" << endl;
358     return _FrontSVertex->getPoint3D();
359   }
360
361   /*! Returns the projected 3D  x coordinate of the vertex .*/
362   virtual real getProjectedX() const {
363     return _FrontSVertex->point2D().x();
364   }
365
366   /*! Returns the projected 3D  y coordinate of the vertex .*/
367   virtual real getProjectedY() const {
368     return _FrontSVertex->point2D().y();
369   }
370
371   virtual real getProjectedZ() const {
372     return _FrontSVertex->point2D().z();
373   }
374
375   /*!  Returns the 2D point. */ 
376   virtual Vec2f getPoint2D() const {
377     return _FrontSVertex->getPoint2D();
378   }
379
380   /*! Returns the Id of the TVertex .*/
381   virtual Id getId() const {
382     return _Id;
383   }
384
385   /*! Cast the Interface0D in SVertex if it can be. */ 
386   // it can't
387   /*! Cast the Interface0D in ViewVertex if it can be. */ 
388   virtual ViewVertex * castToViewVertex(){
389     return this;
390   }
391
392   /*! Cast the Interface0D in TVertex if it can be. */ 
393   virtual TVertex * castToTVertex(){
394     return this;
395   }
396
397 private:
398   SVertex  *_FrontSVertex;
399   SVertex  *_BackSVertex;
400   directedViewEdge _FrontEdgeA;
401   directedViewEdge _FrontEdgeB;
402   directedViewEdge _BackEdgeA;
403   directedViewEdge _BackEdgeB;
404   Id _Id; // id to identify t vertices . these id will be negative in order not to be mixed with NonTVertex ids.
405   edge_pointers_container _sortedEdges; // the list of the four ViewEdges, ordered in CCW order (in the image plan)
406
407
408 public:
409   /*! Default constructor.*/
410   inline TVertex() : ViewVertex(Nature::T_VERTEX) 
411   {
412     _FrontSVertex = 0;
413     _BackSVertex = 0;
414     _FrontEdgeA.first = 0;
415     _FrontEdgeB.first = 0;
416     _BackEdgeA.first = 0;
417     _BackEdgeB.first = 0;
418
419   }
420
421   inline TVertex(SVertex *svFront, SVertex *svBack)
422     : ViewVertex(Nature::T_VERTEX)
423   {
424     _FrontSVertex = svFront;
425     _BackSVertex = svBack;
426     _FrontEdgeA.first = 0;
427     _FrontEdgeB.first = 0;
428     _BackEdgeA.first = 0;
429     _BackEdgeB.first = 0;
430     svFront->setViewVertex(this);
431     svBack->setViewVertex(this);
432   }
433
434 protected:
435   /*! Copy constructor. */
436   inline TVertex(TVertex& iBrother)
437     : ViewVertex(iBrother)
438   {
439     _FrontSVertex = iBrother._FrontSVertex;
440     _BackSVertex = iBrother._BackSVertex;
441     _FrontEdgeA = iBrother._FrontEdgeA;
442     _FrontEdgeB = iBrother._FrontEdgeB;
443     _BackEdgeA = iBrother._BackEdgeA;
444     _BackEdgeB = iBrother._BackEdgeB;
445     _sortedEdges = iBrother._sortedEdges;
446   }
447
448   /*! Cloning method. */
449   virtual ViewVertex * duplicate()
450   {
451     TVertex *clone = new TVertex(*this);
452     return clone;
453   }
454
455 public:
456   /* accessors */
457   /*! Returns the SVertex that is closer to the viewpoint. */
458   inline SVertex  *frontSVertex() {return _FrontSVertex;}
459   /*! Returns the SVertex that is further away from the viewpoint. */
460   inline SVertex  *backSVertex() {return _BackSVertex;}
461   inline directedViewEdge& frontEdgeA() {return _FrontEdgeA;}
462   inline directedViewEdge& frontEdgeB() {return _FrontEdgeB;}
463   inline directedViewEdge& backEdgeA() {return _BackEdgeA;}
464   inline directedViewEdge& backEdgeB() {return _BackEdgeB;}
465   
466   /* modifiers */
467   /*! Sets the SVertex that is closer to the viewpoint. */
468   inline void setFrontSVertex(SVertex  *iFrontSVertex) {_FrontSVertex = iFrontSVertex;_FrontSVertex->setViewVertex(this);}
469   /*! Sets the SVertex that is further away from the viewpoint. */
470   inline void setBackSVertex(SVertex  *iBackSVertex) {_BackSVertex = iBackSVertex;_BackSVertex->setViewVertex(this);}
471   void setFrontEdgeA(ViewEdge *iFrontEdgeA, bool incoming=true);
472   void setFrontEdgeB(ViewEdge *iFrontEdgeB, bool incoming=true) ;
473   void setBackEdgeA(ViewEdge *iBackEdgeA, bool incoming=true);
474   void setBackEdgeB(ViewEdge *iBackEdgeB, bool incoming=true) ;
475   /*! Sets the Id. */
476   inline void setId(const Id& iId) {_Id = iId;}
477   
478   /*! Returns the SVertex (among the 2) belonging to the FEdge iFEdge */
479   inline SVertex * getSVertex(FEdge *iFEdge)
480   {
481     const vector<FEdge*>& vfEdges = _FrontSVertex->fedges();
482     vector<FEdge*>::const_iterator fe,fend;
483     for(fe=vfEdges.begin(),fend=vfEdges.end();
484     fe!=fend;
485     fe++)
486     {
487       if((*fe) == iFEdge)
488         return _FrontSVertex;
489     }
490
491     const vector<FEdge*>& vbEdges = _BackSVertex->fedges();
492     for(fe=vbEdges.begin(),fend=vbEdges.end();
493     fe!=fend;
494     fe++)
495     {
496       if((*fe) == iFEdge)
497         return _BackSVertex;
498     }
499     return 0;
500   }
501
502   virtual void Replace(ViewEdge *iOld, ViewEdge *iNew);
503   
504   /*! returns the mate edge of iEdgeA.
505    *  For example, if iEdgeA is frontEdgeA, 
506    *  then frontEdgeB is returned. If iEdgeA is 
507    *  frontEdgeB then frontEdgeA is returned.
508    *  Same for back edges
509    */
510   virtual ViewEdge * mate(ViewEdge* iEdgeA)
511   {
512     if(iEdgeA == _FrontEdgeA.first)
513       return _FrontEdgeB.first;
514     if(iEdgeA == _FrontEdgeB.first)
515       return _FrontEdgeA.first;
516     if(iEdgeA == _BackEdgeA.first)
517       return _BackEdgeB.first;
518     if(iEdgeA == _BackEdgeB.first)
519       return _BackEdgeA.first;
520     return 0;
521   }
522   
523   /* iterators access */
524   virtual edge_iterator edges_begin();
525   virtual const_edge_iterator edges_begin() const;
526   virtual edge_iterator edges_end();
527   virtual const_edge_iterator edges_end() const;
528   virtual edge_iterator edges_iterator(ViewEdge *iEdge);
529   virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const;
530
531   /*! Returns an iterator over the ViewEdges that goes to or comes from
532    *  this ViewVertex pointing to the first ViewEdge of the list.
533    *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
534    *  and to get the orientation for each ViewEdge (incoming/outgoing).
535    */
536   virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() ;
537   /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
538    *  pointing after the last ViewEdge.
539    */
540   virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() ;
541   /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
542    *  given as argument.
543    */
544   virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) ;
545 };
546
547
548                   /**********************************/
549                   /*                                */
550                   /*                                */
551                   /*             NonTVertex         */ 
552                   /*                                */
553                   /*                                */
554                   /**********************************/
555
556
557 // (non T vertex)
558 /*! View vertex for corners, cusps, etc...
559  *  Associated to a single SVertex.
560  *  Can be associated to 2 or several view edges
561  */
562 class LIB_VIEW_MAP_EXPORT NonTVertex : public ViewVertex
563 {
564 public:
565   typedef vector<directedViewEdge> edges_container;
566
567 public: // Implementation of Interface0D
568
569   /*! Returns the string "ViewVertex" .*/
570   virtual string getExactTypeName() const {
571     return "NonTVertex";
572   }
573
574   // Data access methods
575   /*! Returns the 3D x coordinate of the vertex .*/
576   virtual real getX() const {
577     return _SVertex->point3D().x();
578   }
579   /*! Returns the 3D y coordinate of the vertex .*/
580   virtual real getY() const {
581     return _SVertex->point3D().y();
582   }
583
584   /*! Returns the 3D z coordinate of the vertex .*/
585   virtual real getZ() const {
586     return _SVertex->point3D().z();
587   }
588
589   /*!  Returns the 3D point. */ 
590   virtual Vec3f getPoint3D() const {
591     return _SVertex->getPoint3D();
592   }
593
594   /*! Returns the projected 3D  x coordinate of the vertex .*/
595   virtual real getProjectedX() const {
596     return _SVertex->point2D().x();
597   }
598
599   /*! Returns the projected 3D  y coordinate of the vertex .*/
600   virtual real getProjectedY() const {
601     return _SVertex->point2D().y();
602   }
603
604   /*! Returns the projected 3D  z coordinate of the vertex .*/
605   virtual real getProjectedZ() const {
606     return _SVertex->point2D().z();
607   }
608
609   /*!  Returns the 2D point. */ 
610   virtual Vec2f getPoint2D() const {
611     return _SVertex->getPoint2D();
612   }
613
614   /*! Returns the Id of the vertex .*/
615   virtual Id getId() const {
616     return _SVertex->getId();
617   }
618
619   /*! Cast the Interface0D in SVertex if it can be. */ 
620   virtual SVertex * castToSVertex(){
621     return _SVertex;
622   }
623
624   /*! Cast the Interface0D in ViewVertex if it can be. */ 
625   virtual ViewVertex * castToViewVertex(){
626     return this;
627   }
628
629   /*! Cast the Interface0D in NonTVertex if it can be. */ 
630   virtual NonTVertex * castToNonTVertex(){
631     return this;
632   }
633
634 private:
635   SVertex *_SVertex;
636   edges_container _ViewEdges; 
637 public:
638   /*! Default constructor.*/
639   inline NonTVertex() : ViewVertex(Nature::NON_T_VERTEX) { _SVertex = 0; }
640   /*! Builds a NonTVertex from a SVertex. */
641   inline NonTVertex(SVertex* iSVertex) : ViewVertex(Nature::NON_T_VERTEX)
642   {
643     _SVertex = iSVertex;
644     _SVertex->setViewVertex(this);
645   }
646 protected:
647   /*! Copy constructor. */
648   inline NonTVertex(NonTVertex& iBrother)
649     : ViewVertex(iBrother)
650   {
651     _SVertex = iBrother._SVertex;
652     _SVertex->setViewVertex(this);
653     _ViewEdges = iBrother._ViewEdges;
654   }
655   /*! Cloning method. */
656   virtual ViewVertex * duplicate()
657   {
658     NonTVertex *clone = new NonTVertex(*this);
659     return clone;
660   }
661 public:
662   /*! destructor. */
663   virtual ~NonTVertex() {}
664   
665   /* accessors */
666   /*! Returns the SVertex on top of which this NonTVertex is built. */
667   inline SVertex * svertex() {return _SVertex;}
668   inline edges_container& viewedges() {return _ViewEdges;}
669   
670   /* modifiers */
671   /*! Sets the SVertex on top of which this NonTVertex is built. */
672   inline void setSVertex(SVertex *iSVertex) {_SVertex = iSVertex;_SVertex->setViewVertex(this);}
673   inline void setViewEdges(const vector<directedViewEdge>& iViewEdges) {_ViewEdges = iViewEdges;}
674   void AddIncomingViewEdge(ViewEdge * iVEdge) ;
675   void AddOutgoingViewEdge(ViewEdge * iVEdge) ;
676   inline void AddViewEdge(ViewEdge * iVEdge, bool incoming=true) {
677     if(incoming)
678       AddIncomingViewEdge(iVEdge);
679     else
680       AddOutgoingViewEdge(iVEdge);
681   }
682   /* Replaces old edge by new edge */
683   virtual void Replace(ViewEdge *iOld, ViewEdge *iNew)
684   {
685     
686       edges_container::iterator insertedve;
687       for(edges_container::iterator ve=_ViewEdges.begin(),vend=_ViewEdges.end();
688       ve!=vend;
689       ve++)
690       {
691         if((ve)->first == iOld)
692         {
693           insertedve = _ViewEdges.insert(ve, directedViewEdge(iNew, ve->second));// inserts e2 before ve.
694                                               // returns an iterator pointing toward e2. ve is invalidated.
695           // we want to remove e1, but we can't use ve anymore:
696           insertedve++; // insertedve points now to e1
697           _ViewEdges.erase(insertedve);
698           return;
699         }
700       } 
701   }    
702
703   
704   /* iterators access */
705   virtual edge_iterator edges_begin();
706   virtual const_edge_iterator edges_begin() const;
707   virtual edge_iterator edges_end();
708   virtual const_edge_iterator edges_end() const;
709   virtual edge_iterator edges_iterator(ViewEdge *iEdge);
710   virtual const_edge_iterator edges_iterator(ViewEdge *iEdge) const;
711
712   /*! Returns an iterator over the ViewEdges that goes to or comes from
713    *  this ViewVertex pointing to the first ViewEdge of the list.
714    *  The orientedViewEdgeIterator allows to iterate in CCW order over these ViewEdges
715    *  and to get the orientation for each ViewEdge (incoming/outgoing).
716    */
717   virtual ViewVertexInternal::orientedViewEdgeIterator edgesBegin() ;
718   /*! Returns an orientedViewEdgeIterator over the ViewEdges around this ViewVertex,
719    *  pointing after the last ViewEdge.
720    */
721   virtual ViewVertexInternal::orientedViewEdgeIterator edgesEnd() ;
722   /*! Returns an orientedViewEdgeIterator pointing to the ViewEdge
723    *  given as argument.
724    */
725   virtual ViewVertexInternal::orientedViewEdgeIterator edgesIterator(ViewEdge *iEdge) ;
726 };
727
728                   /**********************************/
729                   /*                                */
730                   /*                                */
731                   /*             ViewEdge           */
732                   /*                                */
733                   /*                                */
734                   /**********************************/
735
736 /* Geometry(normals...)
737   Nature of edges
738   2D spaces (1or2, material, z...)
739   Parent Shape
740   3D Shading, material
741   Importance
742   Occluders
743   */
744 class ViewShape;
745
746 namespace ViewEdgeInternal {
747   template<class Traits> class edge_iterator_base ;
748   template<class Traits> class fedge_iterator_base ;
749   template<class Traits> class vertex_iterator_base ;
750 } // end of namespace ViewEdgeInternal
751
752 /*! Class defining a ViewEdge. A ViewEdge in an edge
753  *  of the image graph. it connnects two ViewVertex.
754  *  It is made by connecting a set of FEdges.
755  */
756 class LIB_VIEW_MAP_EXPORT ViewEdge : public Interface1D
757 {
758 public: // Implementation of Interface0D
759
760   /*! Returns the string "ViewEdge" .*/
761   virtual string getExactTypeName() const {
762     return "ViewEdge";
763   }
764
765   // Data access methods
766   /*! Returns the Id of the vertex .*/
767   virtual Id getId() const {
768     return _Id;
769   }
770
771   /*! Returns the nature of the ViewEdge. */
772   virtual Nature::EdgeNature getNature() const {
773     return _Nature;
774   }
775
776 public:
777   
778   typedef SVertex vertex_type;
779   friend class ViewShape;
780   // for ViewEdge iterator
781   typedef ViewEdgeInternal::edge_iterator_base<Nonconst_traits<ViewEdge*> > edge_iterator;
782   typedef ViewEdgeInternal::edge_iterator_base<Const_traits<ViewEdge*> > const_edge_iterator;
783   // for fedge iterator
784   typedef ViewEdgeInternal::fedge_iterator_base<Nonconst_traits<FEdge*> > fedge_iterator;
785   typedef ViewEdgeInternal::fedge_iterator_base<Const_traits<FEdge*> > const_fedge_iterator;
786   // for svertex iterator
787   typedef ViewEdgeInternal::vertex_iterator_base<Nonconst_traits<SVertex*> > vertex_iterator;
788   typedef ViewEdgeInternal::vertex_iterator_base<Const_traits<SVertex*> > const_vertex_iterator;
789 private:
790
791   ViewVertex * __A; // edge starting vertex
792   ViewVertex * __B; // edge ending vertex
793   Nature::EdgeNature _Nature; // nature of view edge
794   ViewShape *_Shape; // shape to which the view edge belongs
795   FEdge * _FEdgeA; // first edge of the embedded fedges chain
796   FEdge * _FEdgeB; // last edge of the embedded fedges chain
797   Id _Id;
798   unsigned _ChainingTimeStamp;
799   ViewShape *_aShape; // The silhouette view edge separates 2 2D spaces. The one on the left is 
800   // necessarly the Shape _Shape (the one to which this edge belongs to)
801   // and _aShape is the one on its right // NON GERE PAR LE COPY CONSTRUCTEUR
802   int _qi;
803   vector<ViewShape*> _Occluders;
804   bool _isInImage;
805
806   // tmp
807   Id * _splittingId;
808
809 public:
810   /*! A field that can be used by the user to store any data.
811    *  This field must be reseted afterwards using ResetUserData().
812    */
813   void * userdata;
814   /*! Default constructor.*/
815   inline ViewEdge() {
816     __A=0;
817     __B=0;
818     _FEdgeA = 0;
819     _FEdgeB = 0;
820     _ChainingTimeStamp = 0;
821     _qi = 0;
822     _aShape=0;
823     userdata = 0;
824     _splittingId = 0;
825     _isInImage = true;
826   }
827   inline ViewEdge(ViewVertex* iA, ViewVertex *iB)
828   {
829     __A = iA;
830     __B = iB;
831     _FEdgeA = 0;
832     _FEdgeB = 0;
833     _Shape = 0;
834     _ChainingTimeStamp = 0;
835     _aShape = 0;
836     _qi = 0;
837     userdata = 0;
838     _splittingId = 0;
839     _isInImage = true;
840   }
841   inline ViewEdge(ViewVertex* iA, ViewVertex *iB, FEdge *iFEdgeA)
842   {
843     __A = iA;
844     __B = iB;
845     _FEdgeA = iFEdgeA;
846     _FEdgeB = 0;
847     _Shape = 0;
848     _ChainingTimeStamp = 0;
849     _aShape = 0;
850     _qi = 0;
851     userdata = 0;
852     _splittingId = 0;
853     _isInImage = true;
854   }
855   inline ViewEdge(ViewVertex* iA, ViewVertex *iB, FEdge *iFEdgeA, FEdge *iFEdgeB, ViewShape *iShape)
856   {
857     __A = iA;
858     __B = iB;
859     _FEdgeA = iFEdgeA;
860     _FEdgeB = iFEdgeB;
861     _Shape = iShape;
862     _ChainingTimeStamp = 0;
863     _aShape = 0;
864     _qi = 0;
865     userdata = 0;
866     _splittingId = 0;
867     _isInImage = true;
868     UpdateFEdges(); // tells every FEdge between iFEdgeA and iFEdgeB that this is theit ViewEdge
869   }
870
871 //soc protected:
872
873   /*! Copy constructor. */
874   inline ViewEdge(ViewEdge& iBrother)
875   {
876     __A = iBrother.__A;
877     __B = iBrother.__B;
878     _FEdgeA = iBrother._FEdgeA;
879     _FEdgeB = iBrother._FEdgeB;
880     _Nature = iBrother._Nature;
881     _Shape = 0;
882     _Id = iBrother._Id;
883     _ChainingTimeStamp = iBrother._ChainingTimeStamp;
884     _aShape = iBrother._aShape;
885     _qi = iBrother._qi;
886     _splittingId = 0;
887     _isInImage = iBrother._isInImage;
888     iBrother.userdata = this;
889     userdata = 0;
890   }
891   /*! Cloning method. */
892   virtual ViewEdge * duplicate()
893   {
894     ViewEdge *clone = new ViewEdge(*this);
895     return clone;
896   }
897
898 public:
899   /*! Destructor. */
900   virtual ~ViewEdge()
901   {
902     //    if(0 != _aFace)
903     //    {
904     //      delete _aFace;
905     //      _aFace = 0;
906     //    }
907     // only the last splitted deletes this id
908     if(_splittingId){
909       if(*_splittingId == _Id)
910         delete _splittingId;
911     }
912   }
913
914   /* accessors */
915   /*! Returns the first ViewVertex. */
916   inline  ViewVertex* A()  {return __A;}
917   /*! Returns the second ViewVertex. */
918   inline  ViewVertex* B()  {return __B;}
919   /*! Returns the first FEdge that constitues this ViewEdge. */
920   inline  FEdge* fedgeA()  {return _FEdgeA;}
921   /*! Returns the last FEdge that constitues this ViewEdge. */
922   inline  FEdge* fedgeB()  {return _FEdgeB;}
923   /*! Returns the ViewShape to which this ViewEdge belongs to .*/
924   inline ViewShape * viewShape() {return _Shape;}
925   /*! Returns the shape that is occluded by the ViewShape
926    *  to which this ViewEdge belongs to. If no object is occluded,
927    *  0 is returned.
928    *  \return The occluded ViewShape.
929    */
930   inline ViewShape * aShape() {return _aShape;}
931   /*! Tells whether this ViewEdge forms a closed loop
932    *  or not.
933    */
934   inline bool isClosed() 
935   {
936     if(__B == 0)
937       return true;
938     return false;
939   }
940   /*! Returns the time stamp of this ViewEdge. */
941   inline unsigned getChainingTimeStamp() {return _ChainingTimeStamp;}
942   inline const ViewShape * aShape() const {return _aShape;}
943   inline const ViewShape * bShape() const {return _Shape;}
944   inline vector<ViewShape*>& occluders() {return _Occluders;}
945   inline Id * splittingId() {return _splittingId;}
946   inline bool isInImage() const { return _isInImage; }
947   
948   /* modifiers */
949   /*! Sets the first ViewVertex of the ViewEdge. */
950   inline void setA(ViewVertex* iA) { __A = iA; }
951   /*! Sets the last ViewVertex of the ViewEdge. */
952   inline void setB(ViewVertex* iB) { __B = iB; }
953   /*! Sets the nature of the ViewEdge. */
954   inline void setNature(Nature::EdgeNature iNature) { _Nature = iNature; }
955   /*! Sets the first FEdge of the ViewEdge. */
956   inline void setFEdgeA(FEdge* iFEdge) { _FEdgeA = iFEdge; }
957   /*! Sets the last FEdge of the ViewEdge. */
958   inline void setFEdgeB(FEdge* iFEdge) { _FEdgeB = iFEdge; }
959   /*! Sets the ViewShape to which this ViewEdge belongs to.*/
960   inline void setShape(ViewShape *iVShape) 
961   {
962     _Shape = iVShape;
963   }
964   /*! Sets the ViewEdge id. */
965   inline void setId(const Id& id) {_Id = id;}
966   /*! Sets Viewedge to this for all embedded fedges */
967   void UpdateFEdges();
968   /*! Sets the occluded ViewShape */
969   inline void setaShape(ViewShape * iShape) {_aShape = iShape;}
970   /*! Sets the quantitative invisibility value. */
971   inline void setQI(int qi) {_qi = qi;}
972   /*! Sets the time stamp value. */
973   inline void setChainingTimeStamp(unsigned ts) {_ChainingTimeStamp = ts;}
974   inline void AddOccluder(ViewShape *iShape) {_Occluders.push_back(iShape);}
975   inline void setSplittingId(Id * id) {_splittingId = id;}
976   inline void setIsInImage(bool iFlag) { _isInImage = iFlag; }
977
978   /* stroke interface definition */
979   inline bool intersect_2d_area(const Vec2r& iMin, const Vec2r& iMax) const
980   {
981     // parse edges to check if one of them is intersection the region:
982     FEdge * current = _FEdgeA;
983     do
984     {
985       if(GeomUtils::intersect2dSeg2dArea(iMin,iMax, 
986                                          Vec2r(current->vertexA()->point2D()[0],current->vertexA()->point2D()[1]),
987                                          Vec2r(current->vertexB()->point2D()[0],current->vertexB()->point2D()[1])))
988       
989         return true;
990       current = current->nextEdge();
991     }while((current != 0) && (current != _FEdgeA));
992
993     return false;
994   }
995   inline bool include_in_2d_area(const Vec2r& iMin, const Vec2r& iMax) const
996   {
997     // parse edges to check if all of them are intersection the region:
998     FEdge * current = _FEdgeA;
999     
1000     do
1001     {
1002       if(!GeomUtils::include2dSeg2dArea(iMin,iMax, 
1003                                         Vec2r(current->vertexA()->point2D()[0],current->vertexA()->point2D()[1]),
1004                                         Vec2r(current->vertexB()->point2D()[0],current->vertexB()->point2D()[1])))
1005         return false;
1006       current = current->nextEdge();
1007     }while((current != 0) && (current != _FEdgeA));
1008     
1009     return true;
1010   }
1011
1012   /* Information access interface */
1013   
1014   //inline Nature::EdgeNature viewedge_nature() const {return getNature();}
1015   //float viewedge_length() const ;
1016   /*! Returns the 2D length of the Viewedge. */
1017   real getLength2D() const;
1018   //inline Material material() const {return _FEdgeA->vertexA()->shape()->material();}
1019   inline int qi() const {return _qi;}
1020   inline occluder_container::const_iterator occluders_begin() const {return _Occluders.begin();}
1021   inline occluder_container::const_iterator occluders_end() const {return _Occluders.end();}
1022   inline int occluders_size() const {return _Occluders.size();}
1023   inline bool occluders_empty() const {return _Occluders.empty();}
1024   inline const Polygon3r& occludee() const {return (_FEdgeA->aFace());}
1025   inline const SShape * occluded_shape() const ;
1026   inline const bool occludee_empty() const {if(_aShape == 0) return true; return false;}
1027   //inline real z_discontinuity(int iCombination = 0) const ;
1028   inline Id shape_id() const {return _FEdgeA->vertexA()->shape()->getId();}
1029   inline const SShape * shape() const {return _FEdgeA->vertexA()->shape();}
1030   inline float shape_importance() const {return _FEdgeA->shape_importance();} 
1031
1032   /* iterators access */
1033   // view edge iterator
1034   edge_iterator ViewEdge_iterator();
1035   const_edge_iterator ViewEdge_iterator() const;
1036   // feature edge iterator
1037   fedge_iterator fedge_iterator_begin();
1038   const_fedge_iterator fedge_iterator_begin() const;
1039   fedge_iterator fedge_iterator_last();
1040   const_fedge_iterator fedge_iterator_last() const;
1041   fedge_iterator fedge_iterator_end();
1042   const_fedge_iterator fedge_iterator_end() const;
1043   // embedding vertex iterator
1044   const_vertex_iterator vertices_begin() const;
1045   vertex_iterator vertices_begin();
1046   const_vertex_iterator vertices_last() const;
1047   vertex_iterator vertices_last();
1048   const_vertex_iterator vertices_end() const;
1049   vertex_iterator vertices_end();
1050
1051   // Iterator access (Interface1D)
1052   /*! Returns an Interface0DIterator to iterate over
1053    *  the SVertex constituing the embedding of this ViewEdge.
1054    *  The returned Interface0DIterator points to the first
1055    *  SVertex of the ViewEdge.
1056    */
1057   virtual Interface0DIterator verticesBegin();
1058   /*! Returns an Interface0DIterator to iterate over
1059    *  the SVertex constituing the embedding of this ViewEdge.
1060    *  The returned Interface0DIterator points after the last
1061    *  SVertex of the ViewEdge.
1062    */
1063   virtual Interface0DIterator verticesEnd();
1064
1065   /*! Returns an Interface0DIterator to iterate over
1066    *  the points of this ViewEdge at a given resolution.
1067    *  The returned Interface0DIterator points on the first
1068    *  Point of the ViewEdge.
1069    *  \param t
1070    *    the sampling value.
1071    */
1072   virtual Interface0DIterator pointsBegin(float t=0.f);
1073   /*! Returns an Interface0DIterator to iterate over
1074    *  the points of this ViewEdge at a given resolution.
1075    *  The returned Interface0DIterator points after the last
1076    *  Point of the ViewEdge.
1077    *  \param t
1078    *    the sampling value.
1079    */
1080   virtual Interface0DIterator pointsEnd(float t=0.f);
1081 };
1082
1083   
1084
1085                   /**********************************/
1086                   /*                                */
1087                   /*                                */
1088                   /*             ViewShape          */
1089                   /*                                */
1090                   /*                                */
1091                   /**********************************/
1092
1093 /*! Class gathering the elements of the ViewMap (ViewVertex, ViewEdge)
1094  *  that are issued from the same input shape.
1095  */
1096 class LIB_VIEW_MAP_EXPORT ViewShape
1097 {
1098 private:
1099   vector<ViewVertex*> _Vertices;
1100   vector<ViewEdge*> _Edges;
1101   SShape * _SShape;
1102   
1103
1104 public:
1105   /*! A field that can be used by the user to store any data.
1106    *  This field must be reseted afterwards using ResetUserData().
1107    */
1108   void* userdata;
1109   /*! Default constructor.*/
1110   inline ViewShape() { userdata = 0; _SShape = 0;}
1111   /*! Builds a ViewShape from a SShape. */
1112   inline ViewShape(SShape *iSShape) {userdata = 0; _SShape = iSShape;}//_SShape->setViewShape(this);}
1113   /*! Copy constructor. */
1114   inline ViewShape(ViewShape& iBrother)
1115   {
1116     userdata = 0;
1117     vector<ViewVertex*>::iterator vv,vvend;
1118     vector<ViewEdge*>::iterator ve, veend;
1119
1120     _SShape = iBrother._SShape;
1121
1122     vector<ViewVertex*>& vvertices = iBrother.vertices();
1123     // duplicate vertices
1124     for(vv=vvertices.begin(), vvend=vvertices.end();
1125     vv!=vvend;
1126     vv++)
1127     {
1128       ViewVertex * newVertex = (*vv)->duplicate();
1129       AddVertex(newVertex);
1130     }
1131
1132     vector<ViewEdge*>& vvedges = iBrother.edges();
1133     // duplicate edges
1134     for(ve=vvedges.begin(), veend=vvedges.end();
1135     ve!=veend;
1136     ve++)
1137     {
1138       ViewEdge * newEdge = (*ve)->duplicate();
1139       AddEdge(newEdge); // here the shape is set as the edge's shape
1140     }
1141
1142     //-------------------------
1143     // remap edges in vertices:
1144     //-------------------------
1145     for(vv=_Vertices.begin(), vvend=_Vertices.end();
1146     vv!=vvend;
1147     vv++)
1148     {
1149       switch((*vv)->getNature())
1150       {  
1151       case Nature::T_VERTEX:
1152         {
1153           TVertex *v = (TVertex*)(*vv);
1154           ViewEdge *veFrontA = (ViewEdge*)(v)->frontEdgeA().first->userdata;
1155           ViewEdge *veFrontB = (ViewEdge*)(v)->frontEdgeB().first->userdata;
1156           ViewEdge *veBackA = (ViewEdge*)(v)->backEdgeA().first->userdata;
1157           ViewEdge *veBackB = (ViewEdge*)(v)->backEdgeB().first->userdata;
1158
1159           v->setFrontEdgeA(veFrontA, v->frontEdgeA().second);
1160           v->setFrontEdgeB(veFrontB, v->frontEdgeB().second);
1161           v->setBackEdgeA(veBackA, v->backEdgeA().second);
1162           v->setBackEdgeB(veBackB, v->backEdgeB().second);
1163         }
1164         break;
1165       case Nature::NON_T_VERTEX:
1166         {
1167           NonTVertex * v = (NonTVertex*)(*vv);
1168           vector<ViewVertex::directedViewEdge>& vedges = (v)->viewedges();
1169           vector<ViewVertex::directedViewEdge> newEdges;
1170           for(vector<ViewVertex::directedViewEdge>::iterator ve=vedges.begin(), veend=vedges.end();
1171           ve!=veend;
1172           ve++)
1173           {
1174             ViewEdge *current = (ViewEdge*)((ve)->first)->userdata;
1175             newEdges.push_back(ViewVertex::directedViewEdge(current, ve->second));
1176           }
1177           (v)->setViewEdges(newEdges);
1178         }
1179         break;
1180       default:
1181         ;
1182       }
1183     }
1184     
1185     //-------------------------------------
1186     // remap vertices in edges:
1187     //-------------------------------------
1188     for(ve=_Edges.begin(),veend=_Edges.end();
1189         ve!=veend;
1190         ve++)
1191       {
1192         (*ve)->setA((ViewVertex*)((*ve)->A()->userdata));
1193         (*ve)->setB((ViewVertex*)((*ve)->B()->userdata));
1194         //---------------------------------------
1195         // Update all embedded FEdges
1196         //---------------------------------------
1197         (*ve)->UpdateFEdges();
1198       }
1199     
1200     
1201     // reset all brothers userdata to NULL:
1202     //-------------------------------------
1203     //---------
1204     // vertices
1205     //---------
1206     for(vv=vvertices.begin(),vvend=vvertices.end();
1207         vv!=vvend;
1208         vv++)
1209       {
1210         (*vv)->userdata = NULL;
1211       }
1212
1213     //------
1214     // edges
1215     //------
1216     for(ve=vvedges.begin(),veend=vvedges.end();
1217         ve!=veend;
1218         ve++)
1219       {
1220         (*ve)->userdata = NULL;
1221       }  
1222   }
1223
1224   /*! Cloning method. */
1225   virtual ViewShape * duplicate()
1226   {
1227     ViewShape *clone = new ViewShape(*this);
1228     return clone;
1229   }
1230
1231   /*! Destructor. */
1232   virtual ~ViewShape();
1233
1234   /* splits a view edge into several view edges. 
1235    *    fe
1236    *      The FEdge that gets splitted
1237    *    iViewVertices
1238    *      The view vertices corresponding to the different intersections for the edge fe.
1239    *      This list need to be sorted such as the first view vertex is the 
1240    *      farther away from fe->vertexA.
1241    *    ioNewEdges
1242    *      The feature edges that are newly created (the initial edges are not 
1243    *      included) are added to this list.
1244    *    ioNewViewEdges
1245    *      The view edges that are newly created (the initial edges are not 
1246    *      included) are added to this list.  
1247    */
1248   inline void SplitEdge(FEdge *fe, 
1249                         const vector<TVertex*>& iViewVertices, 
1250                         vector<FEdge*>& ioNewEdges,
1251                         vector<ViewEdge*>& ioNewViewEdges);
1252   /* accessors */
1253   /*! Returns the SShape on top of which this ViewShape is built. */
1254   inline  SShape * sshape()  {return _SShape;}
1255     /*! Returns the SShape on top of which this ViewShape is built. */
1256   inline  const SShape * sshape() const {return _SShape;}
1257   /*! Returns the list of ViewVertex contained in this ViewShape. */
1258   inline  vector<ViewVertex*>& vertices() {return _Vertices;}
1259   /*! Returns the list of ViewEdge contained in this ViewShape. */
1260   inline  vector<ViewEdge*>& edges() {return _Edges;}
1261   /*! Returns the ViewShape id. */
1262   inline  Id getId() const {return _SShape->getId();}
1263   /*! Returns the ViewShape id. */
1264   inline  const string& getName() const {return _SShape->getName();}
1265
1266   /* modifiers */
1267   /*! Sets the SShape on top of which the ViewShape is built. */
1268   inline void setSShape(SShape* iSShape) {_SShape = iSShape;}
1269   /*! Sets the list of ViewVertex contained in this ViewShape. */
1270   inline void setVertices(const vector<ViewVertex*>& iVertices) {_Vertices = iVertices;}
1271   /*! Sets the list of ViewEdge contained in this ViewShape. */
1272   inline void setEdges(const vector<ViewEdge*>& iEdges) {_Edges = iEdges;}
1273   /*! Adds a ViewVertex to the list. */
1274   inline void AddVertex(ViewVertex *iVertex) 
1275   {
1276     _Vertices.push_back(iVertex);
1277     //_SShape->AddNewVertex(iVertex->svertex());
1278   }
1279   /*! Adds a ViewEdge to the list */
1280   inline void AddEdge(ViewEdge *iEdge) 
1281   {
1282     _Edges.push_back(iEdge);
1283     iEdge->setShape(this);
1284     //_SShape->AddNewEdge(iEdge->fedge());
1285   }
1286
1287   /* removes the view edge iViewEdge in the 
1288    *  View Shape and the associated FEdge chain entry
1289    *  in the underlying SShape 
1290    */
1291   void RemoveEdge(ViewEdge * iViewEdge);
1292
1293   /* removes the view vertex iViewVertex in the 
1294    *  View Shape.
1295    */
1296   void RemoveVertex(ViewVertex * iViewVertex);
1297 };
1298
1299
1300
1301 /*
1302   
1303   #############################################
1304   #############################################
1305   #############################################
1306   ######                                 ######
1307   ######   I M P L E M E N T A T I O N   ######
1308   ######                                 ######
1309   #############################################
1310   #############################################
1311   #############################################
1312   
1313 */
1314 /* for inline functions */
1315
1316 void ViewShape::SplitEdge(FEdge *fe, 
1317                         const vector<TVertex*>& iViewVertices, 
1318                         vector<FEdge*>& ioNewEdges,
1319                         vector<ViewEdge*>& ioNewViewEdges)
1320
1321     ViewEdge *vEdge = fe->viewedge();
1322
1323     
1324     // We first need to sort the view vertices from farther to closer to fe->vertexA
1325     
1326     SVertex *sv, *sv2; 
1327     ViewVertex *vva, *vvb;
1328     vector<TVertex*>::const_iterator vv, vvend;
1329     for(vv=iViewVertices.begin(), vvend = iViewVertices.end();
1330     vv!=vvend;
1331     vv++)
1332     {
1333       // Add the viewvertices to the ViewShape
1334       AddVertex((*vv));
1335       
1336       // retrieve the correct SVertex from the view vertex
1337       //--------------------------------------------------
1338       sv = (*vv)->frontSVertex();
1339       sv2 = (*vv)->backSVertex();
1340
1341       if(sv->shape() != sv2->shape())
1342       {
1343         if(sv->shape() != _SShape)
1344           sv = sv2;
1345       }
1346       else
1347       {
1348         // if the shape is the same we can safely differ 
1349         // the two vertices using their ids:
1350         if(sv->getId() != fe->vertexA()->getId())
1351           sv = sv2;
1352       }
1353       
1354       vva = vEdge->A();
1355       vvb = vEdge->B();
1356       
1357       // We split Fedge AB into AA' and A'B. A' and A'B are created.
1358       // AB becomes (address speaking) AA'. B is updated.
1359       //--------------------------------------------------
1360       SShape * shape = fe->shape();
1361       
1362       // a new edge, A'B is created.
1363       FEdge *newEdge = shape->SplitEdgeIn2(fe, sv);
1364           /*
1365            * One of the two FEdges (fe and newEdge) may have a 2D length less than M_EPSILON.
1366            * (22 Feb 2011, T.K.)
1367            */
1368
1369       ioNewEdges.push_back(newEdge);
1370       ViewEdge *newVEdge;
1371
1372       if((vva == 0) || (vvb == 0)) // that means we're dealing with a closed viewedge (loop)
1373       {
1374         // remove the chain that was starting by the fedge A of vEdge (which is different from fe !!!!)
1375         shape->RemoveEdgeFromChain(vEdge->fedgeA());
1376         // we set 
1377         vEdge->setA(*vv);
1378         vEdge->setB(*vv);
1379         vEdge->setFEdgeA(newEdge);
1380         //FEdge *previousEdge = newEdge->previousEdge();  
1381         vEdge->setFEdgeB(fe);
1382         newVEdge = vEdge;
1383         vEdge->fedgeA()->setViewEdge(newVEdge);
1384       }
1385       else
1386       {
1387         
1388         // while we create the view edge, it updates the "ViewEdge" pointer 
1389         // of every underlying FEdges to this.
1390         newVEdge = new ViewEdge((*vv),vvb);//, newEdge, vEdge->fedgeB());
1391         newVEdge->setNature((fe)->getNature());
1392         newVEdge->setFEdgeA(newEdge);
1393         //newVEdge->setFEdgeB(fe);
1394         // If our original viewedge is made of one FEdge, 
1395         // then 
1396         if((vEdge->fedgeA() == vEdge->fedgeB()) || (fe == vEdge->fedgeB()))
1397           newVEdge->setFEdgeB(newEdge);
1398         else
1399           newVEdge->setFEdgeB(vEdge->fedgeB()); //MODIF
1400
1401         Id * newId = vEdge->splittingId();
1402         if(newId == 0){
1403           newId = new Id(vEdge->getId());
1404           vEdge->setSplittingId(newId);
1405         }
1406         newId->setSecond(newId->getSecond()+1);
1407         newVEdge->setId(*newId);
1408         newVEdge->setSplittingId(newId);
1409         //        Id id(vEdge->getId().getFirst(), vEdge->getId().getSecond()+1);
1410         //        newVEdge->setId(vEdge->getId());
1411         //        vEdge->setId(id);
1412         
1413         AddEdge(newVEdge); // here this shape is set as the edge's shape
1414       
1415         // add new edge to the list of new edges passed as argument:
1416         ioNewViewEdges.push_back(newVEdge);
1417
1418       
1419         
1420         if(0 != vvb) 
1421           vvb->Replace((vEdge), newVEdge);
1422
1423         // we split the view edge:
1424         vEdge->setB((*vv));
1425         vEdge->setFEdgeB(fe); //MODIF
1426       
1427         // Update fedges so that they point to the new viewedge:
1428         newVEdge->UpdateFEdges();
1429
1430       }
1431       // check whether this vertex is a front vertex or a back
1432       // one
1433       
1434       if(sv == (*vv)->frontSVertex())
1435       { 
1436         // -- View Vertex A' --
1437         (*vv)->setFrontEdgeA(vEdge, true);
1438         (*vv)->setFrontEdgeB(newVEdge, false);
1439       }
1440       else
1441       {
1442         // -- View Vertex A' --
1443         (*vv)->setBackEdgeA(vEdge, true);
1444         (*vv)->setBackEdgeB(newVEdge, false);
1445       }
1446     }
1447
1448     
1449                   /**********************************/
1450                   /*                                */
1451                   /*                                */
1452                   /*             ViewEdge           */
1453                   /*                                */
1454                   /*                                */
1455                   /**********************************/
1456
1457                   
1458 // inline Vec3r ViewEdge::orientation2d(int iCombination) const
1459 // {
1460 //  return edge_orientation2d_function<ViewEdge>(*this, iCombination);
1461 // }
1462
1463 // inline Vec3r  ViewEdge::orientation3d(int iCombination) const
1464 // {
1465 //  return edge_orientation3d_function<ViewEdge>(*this, iCombination);
1466 // }
1467
1468 // inline real ViewEdge::z_discontinuity(int iCombination) const 
1469 // {
1470 //   return z_discontinuity_edge_function<ViewEdge>(*this, iCombination);
1471 // }
1472
1473 // inline float ViewEdge::local_average_depth(int iCombination ) const
1474 // {
1475 //   return local_average_depth_edge_function<ViewEdge>(*this, iCombination);
1476 // }
1477
1478 // inline float ViewEdge::local_depth_variance(int iCombination) const 
1479 // {
1480 //   return local_depth_variance_edge_function<ViewEdge>(*this, iCombination);
1481 // }
1482
1483 // inline real ViewEdge::local_average_density(float sigma, int iCombination) const 
1484 // {
1485 //   return density_edge_function<ViewEdge>(*this, iCombination);
1486 // }
1487
1488 inline const SShape * ViewEdge::occluded_shape() const 
1489 {
1490   if(0 == _aShape)
1491     return 0;
1492   return _aShape->sshape();
1493 }  
1494
1495 // inline Vec3r ViewEdge::curvature2d_as_vector(int iCombination) const 
1496 // {
1497 //   return curvature2d_as_vector_edge_function<ViewEdge>(*this, iCombination);
1498 // }
1499
1500 // inline real ViewEdge::curvature2d_as_angle(int iCombination) const 
1501 // {
1502 //   return curvature2d_as_angle_edge_function<ViewEdge>(*this, iCombination);
1503 // }
1504
1505
1506 #endif // VIEWMAP_H