Merged changes in the trunk up to revision 48505.
[blender.git] / source / blender / freestyle / intern / view_map / ViewMapAdvancedIterators.h
1 //
2 //  Filename         : ViewMapAdvancedIterators.h
3 //  Author(s)        : Stephane Grabli
4 //  Purpose          : Iterators used to iterate over the various elements of the ViewMap
5 //                     These iterators can't be exported to python.
6 //  Date of creation : 01/07/2003
7 //
8 ///////////////////////////////////////////////////////////////////////////////
9
10
11 //
12 //  Copyright (C) : Please refer to the COPYRIGHT file distributed 
13 //   with this source distribution. 
14 //
15 //  This program is free software; you can redistribute it and/or
16 //  modify it under the terms of the GNU General Public License
17 //  as published by the Free Software Foundation; either version 2
18 //  of the License, or (at your option) any later version.
19 //
20 //  This program is distributed in the hope that it will be useful,
21 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
22 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23 //  GNU General Public License for more details.
24 //
25 //  You should have received a copy of the GNU General Public License
26 //  along with this program; if not, write to the Free Software
27 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
28 //
29 ///////////////////////////////////////////////////////////////////////////////
30
31 #ifndef  VIEWMAPADVANCEDITERATORS_H
32 # define VIEWMAPADVANCEDITERATORS_H
33
34 #include "ViewMap.h"
35 #include "../system/Iterator.h" //soc 
36
37                   /**********************************/
38                   /*                                */
39                   /*                                */
40                   /*             ViewMap            */
41                   /*                                */
42                   /*                                */
43                   /**********************************/
44
45                   /**********************************/
46                   /*                                */
47                   /*                                */
48                   /*             ViewVertex         */
49                   /*                                */
50                   /*                                */
51                   /**********************************/
52
53 namespace ViewVertexInternal{
54
55   class edge_const_traits : public Const_traits< ::ViewVertex::directedViewEdge> {
56   public:
57      typedef vector< ::ViewVertex::directedViewEdge> edges_container;
58     typedef edges_container::const_iterator edges_container_iterator ;
59     typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container;
60     typedef edge_pointers_container::const_iterator edge_pointers_container_iterator ;
61   }; 
62   class edge_nonconst_traits : public Nonconst_traits< ::ViewVertex::directedViewEdge> {
63   public:
64     typedef vector< ::ViewVertex::directedViewEdge> edges_container;
65     typedef edges_container::iterator edges_container_iterator ;
66     typedef vector< ::ViewVertex::directedViewEdge*> edge_pointers_container;
67     typedef edge_pointers_container::iterator edge_pointers_container_iterator ;
68   };
69   
70 template<class Traits>
71   class edge_iterator_base : public IteratorBase<Traits,InputIteratorTag_Traits>
72   {
73   public:
74     typedef typename Traits::value_type                       value_type;
75     typedef typename Traits::difference_type                  difference_type;
76     typedef typename Traits::pointer                          pointer;
77     typedef typename Traits::reference                        reference;
78     typedef edge_iterator_base<Traits>  Self;
79     typedef typename Traits::edges_container_iterator  edges_container_iterator;
80     typedef typename Traits::edge_pointers_container_iterator  edge_pointers_container_iterator;
81     typedef edge_iterator_base<edge_nonconst_traits> iterator;
82     typedef edge_iterator_base<edge_const_traits> const_iterator;
83   public:
84     friend class ViewVertex;
85     friend class TVertex;
86     friend class NonTVertex;
87     friend class ViewEdge;
88     friend class edge_iterator;
89   protected:
90     Nature::VertexNature _Nature; // the nature of the underlying vertex
91     // T vertex attributes
92     edge_pointers_container_iterator _tbegin;
93     edge_pointers_container_iterator _tend;
94     edge_pointers_container_iterator _tvertex_iter;
95
96     //    mutable value_type _tvertex_iter;
97     //    value_type _feA;
98     //    value_type _feB;
99     //    value_type _beA;
100     //    value_type _beB;
101
102     // Non TVertex attributes
103     edges_container_iterator _begin;
104     edges_container_iterator _end;
105     edges_container_iterator _nontvertex_iter;
106
107     typedef IteratorBase<Traits,InputIteratorTag_Traits> parent_class;
108
109   public:
110     inline edge_iterator_base() : parent_class() {}
111     inline edge_iterator_base(Nature::VertexNature iNature)
112       : parent_class()
113     {_Nature = iNature;}
114     edge_iterator_base(const edge_iterator_base<edge_nonconst_traits>& iBrother)
115     : parent_class(iBrother)
116     {
117       _Nature = iBrother._Nature;
118       if(_Nature & Nature::T_VERTEX)
119       {
120         //        _feA = iBrother._feA;
121         //        _feB = iBrother._feB;
122         //        _beA = iBrother._beA;
123         //        _beB = iBrother._beB;
124         //        _tvertex_iter = iBrother._tvertex_iter;
125         _tbegin = iBrother._tbegin;
126         _tend = iBrother._tend;
127         _tvertex_iter = iBrother._tvertex_iter;
128       }
129       else
130       {
131         _begin = iBrother._begin;
132         _end = iBrother._end;
133         _nontvertex_iter = iBrother._nontvertex_iter;
134       }
135     }
136     edge_iterator_base(const edge_iterator_base<edge_const_traits>& iBrother)
137       : parent_class(iBrother)
138     {
139       _Nature = iBrother._Nature;
140       if(_Nature & Nature::T_VERTEX)
141       {
142         //        _feA = iBrother._feA;
143         //        _feB = iBrother._feB;
144         //        _beA = iBrother._beA;
145         //        _beB = iBrother._beB;
146         //        _tvertex_iter = iBrother._tvertex_iter;
147         _tbegin = iBrother._tbegin;
148         _tend = iBrother._tend;
149         _tvertex_iter = iBrother._tvertex_iter;
150       }
151       else
152       {
153         _begin = iBrother._begin;
154         _end = iBrother._end;
155         _nontvertex_iter = iBrother._nontvertex_iter;
156       }
157     }
158     virtual ~edge_iterator_base() {}
159   //protected://FIXME
160   public:
161     //    inline edge_iterator_base(value_type ifeA, 
162     //                         value_type ifeB, 
163     //                         value_type ibeA, 
164     //                         value_type ibeB,
165     //                         value_type iter)
166     //      : parent_class()
167     //    {
168     //      _Nature = Nature::T_VERTEX;
169     //      _feA = ifeA;
170     //      _feB = ifeB;
171     //      _beA = ibeA;
172     //      _beB = ibeB;
173     //      _tvertex_iter = iter;
174     //    }
175     inline edge_iterator_base(edge_pointers_container_iterator begin, 
176                          edge_pointers_container_iterator end,
177                          edge_pointers_container_iterator iter)
178                          : parent_class()
179     {
180       _Nature = Nature::T_VERTEX;
181       _tbegin = begin;
182       _tend = end;
183       _tvertex_iter = iter;
184     } 
185     inline edge_iterator_base(edges_container_iterator begin, 
186                          edges_container_iterator end,
187                          edges_container_iterator iter)
188                          : parent_class()
189     {
190       _Nature = Nature::NON_T_VERTEX;
191       _begin = begin;
192       _end = end;
193       _nontvertex_iter = iter;
194     } 
195
196   public:
197
198     
199     virtual bool begin() const 
200     {
201       if(_Nature & Nature::T_VERTEX)
202         return (_tvertex_iter == _tbegin);
203         //return (_tvertex_iter == _feA);
204       else
205         return (_nontvertex_iter == _begin);
206     }
207     virtual bool end() const 
208     {
209       if(_Nature & Nature::T_VERTEX)
210         //return (_tvertex_iter.first == 0);
211         return (_tvertex_iter == _tend);
212       else
213         return (_nontvertex_iter == _end);
214     }
215
216     // operators
217     virtual Self& operator++()  // operator corresponding to ++i
218     { 
219       increment();
220       return *this;
221     }
222     virtual Self operator++(int)  // opérateur correspondant à i++ 
223     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
224       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
225       increment();                    // dans un temporaire. 
226       return tmp;
227     } 
228   
229     // comparibility
230     virtual bool operator!=(const Self& b) const
231     {
232       if(_Nature & Nature::T_VERTEX)
233         return (_tvertex_iter != b._tvertex_iter);
234       else
235         return (_nontvertex_iter != b._nontvertex_iter);
236     }
237     
238     virtual bool operator==(const Self& b) const
239     {return !(*this != b);}
240     
241     // dereferencing
242     virtual reference operator*() const
243     {
244       if(_Nature & Nature::T_VERTEX)
245         //return _tvertex_iter;
246         return **_tvertex_iter;
247       else
248         return (*_nontvertex_iter);
249     }
250     virtual pointer operator->() const { return &(operator*());}
251
252   protected:
253     inline void increment()
254     {
255       if(_Nature & Nature::T_VERTEX)
256         {
257         value_type tmp = (**_tvertex_iter);
258         ++_tvertex_iter;
259         value_type tmp2 = (**_tvertex_iter);
260         if(tmp2.first == tmp.first)
261           ++_tvertex_iter;
262         //          // Hack to deal with cusp. the result of a cusp
263         //          // is a TVertex having two identical viewedges.
264         //          // In order to iterate properly, we chose to 
265         //          // to skip these last ones.
266         //          if(_feB.first == _beA.first)
267         //          {
268         //            if(_feA.first == _beB.first)
269         //            {
270         //              _tvertex_iter.first = 0;
271         //              return;
272         //            }
273         //            
274         //            if(_tvertex_iter.first == _feA.first)
275         //              _tvertex_iter.first = _beB.first;
276         //            else if(_tvertex_iter.first == _beB.first)
277         //              _tvertex_iter.first = 0;
278         //            else
279         //              _tvertex_iter.first = _feA.first;
280         //            return;
281         //          }
282         //          if(_feA.first == _beB.first)
283         //          {
284         //            if(_feB.first == _beA.first)
285         //            {
286         //              _tvertex_iter.first = 0;
287         //              return;
288         //            }
289         //            
290         //            if(_tvertex_iter.first == _feB.first)
291         //              _tvertex_iter.first = _beA.first;
292         //            else if(_tvertex_iter.first == _beA.first)
293         //              _tvertex_iter.first = 0;
294         //            else
295         //              _tvertex_iter.first = _feB.first;
296         //            return;
297         //          }
298         //          // End of hack
299         //
300         //          if(_tvertex_iter.first == _feA.first){
301         //            // we return bea or beb 
302         //            
303         //
304         //            // choose one of them
305         //            
306         //              _tvertex_iter.first = _feB.first;
307         //              return;
308         //            }
309         //          if(_tvertex_iter.first == _feB.first)
310         //            {
311         //              _tvertex_iter.first = _beA.first;
312         //              return;
313         //            }
314         //          if(_tvertex_iter.first == _beA.first)
315         //            {
316         //              _tvertex_iter.first = _beB.first;
317         //              return;
318         //            }
319         //          if(_tvertex_iter.first == _beB.first)
320         //            {
321         //              _tvertex_iter.first = 0;
322         //              return;
323         //            }
324         }
325       else
326         ++_nontvertex_iter;
327     }
328   };
329
330   }
331                   /**********************************/
332                   /*                                */
333                   /*                                */
334                   /*             ViewEdge           */
335                   /*                                */
336                   /*                                */
337                   /**********************************/
338
339 namespace ViewEdgeInternal {
340
341   /*!----------------------*/
342   /*! Iterators definition */
343   /*!----------------------*/
344   template<class Traits>
345   class edge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
346   {
347   public:
348     typedef typename Traits::value_type                       value_type;
349     typedef typename Traits::difference_type                  difference_type;
350     typedef typename Traits::pointer                          pointer;
351     typedef typename Traits::reference                        reference;
352     typedef edge_iterator_base<Traits>  Self;
353   public:
354     mutable value_type _ViewEdge;
355     //friend class edge_iterator_base<Nonconst_traits<ViewEdge*> >;
356     //friend class edge_iterator_base<Const_traits<ViewEdge*> >;
357     value_type _first;
358     bool _orientation;
359     typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
360
361   public:
362     friend class ViewEdge;
363     inline edge_iterator_base()
364       : parent_class()
365     {_orientation=true;_first=0;}
366
367     inline edge_iterator_base(const edge_iterator_base<Nonconst_traits< ::ViewEdge*> >& iBrother)
368       : parent_class()
369     {
370       _ViewEdge = iBrother._ViewEdge;
371       _first = iBrother._first;
372       _orientation = iBrother._orientation;
373     }
374
375     inline edge_iterator_base(const edge_iterator_base<Const_traits< ::ViewEdge*> >& iBrother)
376       : parent_class()
377     {
378       _ViewEdge = iBrother._ViewEdge;
379       _first = iBrother._first;
380       _orientation = iBrother._orientation;
381     }
382
383   //protected://FIXME
384   public:
385     inline edge_iterator_base(value_type iEdge, bool orientation = true)
386       : parent_class()
387     {
388       _ViewEdge = iEdge;
389       _first = iEdge;
390       _orientation = orientation;
391     }
392   
393     
394   public:
395     virtual Self* clone() const 
396     {
397       return new edge_iterator_base(*this);
398     }
399     virtual ~edge_iterator_base() {}
400
401   public:
402     
403     virtual bool orientation() {return _orientation;}
404     virtual void set_edge(value_type iVE) {_ViewEdge=iVE;}
405     virtual void set_orientation(bool iOrientation) {_orientation = iOrientation;}
406     virtual void change_orientation() {_orientation = !_orientation;}
407     
408     // operators
409     inline Self& operator++()  // operator corresponding to ++i
410     { 
411       //++_ViewEdge->getTimeStamp();
412       increment();
413       return *this;
414     }
415     inline Self operator++(int)  // opérateur correspondant à i++ 
416     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
417       //++_ViewEdge->getTimeStamp();
418       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
419       increment();                    // dans un temporaire. 
420       return tmp;
421     }
422     inline Self& operator--()  // operator corresponding to ++i
423     { 
424       //++_ViewEdge->getTimeStamp();
425       decrement();
426       return *this;
427     }
428     inline Self operator--(int)  // opérateur correspondant à i++ 
429     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
430       //++_ViewEdge->getTimeStamp();
431       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
432       decrement();                    // dans un temporaire. 
433       return tmp;
434     }
435
436     // comparibility
437     virtual bool operator!=(const Self& b) const
438     {
439       return (_ViewEdge != b._ViewEdge);
440     }
441     virtual bool operator==(const Self& b) const
442     {
443       return !(*this != b);
444     }
445     
446     // dereferencing
447     virtual reference operator*() const  {return (_ViewEdge);}
448     virtual pointer operator->() const { return &(operator*());}
449     
450   public:
451     virtual bool begin() const {return _ViewEdge==_first ? true : false;}
452     virtual bool end() const {return _ViewEdge==0 ? true : false;}
453
454   protected:
455     virtual void increment() {}
456     virtual void decrement() {}
457   };
458   
459   template<class Traits>
460   class fedge_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
461   {
462   public:
463     typedef typename Traits::value_type                       value_type;
464     typedef typename Traits::difference_type                  difference_type;
465     typedef typename Traits::pointer                          pointer;
466     typedef typename Traits::reference                        reference;
467     typedef fedge_iterator_base<Traits>  Self;
468   public:
469     typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
470     mutable value_type _FEdge;
471     value_type _first;
472     value_type _FEdgeB; // last fedge of the view edge
473  
474   public:
475     friend class ::ViewEdge;
476     friend class fedge_iterator;
477     inline fedge_iterator_base()
478       : parent_class()
479     {}
480     inline fedge_iterator_base(const fedge_iterator_base<Nonconst_traits<FEdge*> >& iBrother)
481       : parent_class()
482     {
483       _FEdge = iBrother._FEdge;
484       _first = iBrother._first;
485       _FEdgeB = iBrother._FEdgeB;
486     }
487     inline fedge_iterator_base(const fedge_iterator_base<Const_traits<FEdge*> >& iBrother)
488       : parent_class()
489     {
490       _FEdge = iBrother._FEdge;
491       _first = iBrother._first;
492       _FEdgeB = iBrother._FEdgeB;
493     }
494   //protected://FIXME
495     public:
496     inline fedge_iterator_base(value_type iEdge, value_type iFEdgeB)
497       : parent_class()
498     {
499       _FEdge = iEdge;
500       _first = iEdge;
501       _FEdgeB = iFEdgeB;
502     }
503     
504   public:
505     virtual ~fedge_iterator_base() {}
506     // operators
507     inline Self& operator++()  // operator corresponding to ++i
508     { 
509       increment();
510       return *this;
511     }
512     inline Self operator++(int)  // opérateur correspondant à i++ 
513     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
514       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
515       increment();                    // dans un temporaire. 
516       return tmp;
517     }
518     inline Self& operator--()  // operator corresponding to ++i
519     { 
520       decrement();
521       return *this;
522     }
523     inline Self operator--(int)  // opérateur correspondant à i++ 
524     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
525       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
526       decrement();                    // dans un temporaire. 
527       return tmp;
528     }
529
530     // comparibility
531     virtual bool operator!=(const Self& b) const
532     {
533       return (_FEdge != b._FEdge);
534     }
535     virtual bool operator==(const Self& b) const
536     {
537       return !(*this != b);
538     }
539     
540     // dereferencing
541     virtual reference operator*() const  {return (_FEdge);}
542     virtual pointer operator->() const { return &(operator*());}
543
544
545   public:
546     virtual bool begin() const {return _FEdge==_first ? true : false;}
547     virtual bool end() const {return _FEdge==0 ? true : false;}
548   protected:
549     virtual void increment() 
550     {
551       _FEdge = _FEdge->nextEdge(); // we don't change or
552     }
553     
554     virtual void decrement() 
555     {
556       if(0 == _FEdge)
557         {
558           _FEdge = _FEdgeB;
559           return;
560         }
561       _FEdge = _FEdge->previousEdge(); // we don't change or
562     }
563   };
564   
565   template<class Traits>
566   class vertex_iterator_base : public IteratorBase<Traits,BidirectionalIteratorTag_Traits>
567   {
568   public:
569     typedef typename Traits::value_type                       value_type;
570     typedef typename Traits::difference_type                  difference_type;
571     typedef typename Traits::pointer                          pointer;
572     typedef typename Traits::reference                        reference;
573     typedef vertex_iterator_base<Traits>  Self;
574   protected:
575     typedef IteratorBase<Traits,BidirectionalIteratorTag_Traits> parent_class;
576   public:
577     mutable value_type _SVertex;
578     FEdge *_NextFEdge;
579     FEdge *_PreviousFEdge;
580   public:
581     friend class ViewEdge;
582     friend class vertex_iterator;
583     inline vertex_iterator_base()
584       : parent_class()
585     {}
586     inline vertex_iterator_base(const vertex_iterator_base<Const_traits<SVertex*> >& iBrother)
587       : parent_class()
588     {
589       _SVertex = iBrother._SVertex;
590       _NextFEdge = iBrother._NextFEdge;
591       _PreviousFEdge = iBrother._PreviousFEdge;
592     }
593     inline vertex_iterator_base(const vertex_iterator_base<Nonconst_traits<SVertex*> >& iBrother)
594       : parent_class()
595     {
596       _SVertex = iBrother._SVertex;
597       _NextFEdge = iBrother._NextFEdge;
598       _PreviousFEdge = iBrother._PreviousFEdge;
599     }
600     
601   //protected://FIXME
602   public:
603    
604     inline vertex_iterator_base(value_type iVertex, FEdge *iPreviousFEdge, FEdge *iNextFEdge)
605       : parent_class()
606     {
607       _SVertex = iVertex;
608       _NextFEdge = iNextFEdge;
609       _PreviousFEdge = iPreviousFEdge;
610     }
611     
612   public:
613     virtual ~vertex_iterator_base() {}
614
615     virtual bool begin() const {return _PreviousFEdge==0? true : false;}
616     virtual bool end() const {return _SVertex==0 ? true : false;}
617
618     // operators
619     inline Self& operator++()  // operator corresponding to ++i
620     { 
621       increment();
622       return *this;
623     }
624     inline Self operator++(int)  // opérateur correspondant à i++ 
625     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
626       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
627       increment();                    // dans un temporaire. 
628       return tmp;
629     }
630     inline Self& operator--()  // operator corresponding to ++i
631     { 
632       decrement();
633       return *this;
634     }
635     inline Self operator--(int)  // opérateur correspondant à i++ 
636     {                                  // c.a.d qui renvoie la valeur *puis* incrémente.
637       Self tmp = *this;        // C'est pour cela qu'on stocke la valeur
638       decrement();                    // dans un temporaire. 
639       return tmp;
640     }
641
642     // comparibility
643     virtual bool operator!=(const Self& b) const
644     {
645       return (_SVertex != b._SVertex);
646     }
647     virtual bool operator==(const Self& b) const
648     {
649       return !(*this != b);
650     }
651     
652     // dereferencing
653     virtual reference operator*() const   {return (_SVertex);}
654     virtual pointer operator->() const { return &(operator*());}
655     
656   protected:
657     virtual void increment() 
658     {
659       if(0 == _NextFEdge)
660         {
661           _SVertex = 0;
662           return;
663         }
664
665       _SVertex = _NextFEdge->vertexB();
666       _PreviousFEdge = _NextFEdge;
667       _NextFEdge = _NextFEdge->nextEdge();
668        
669     }
670     virtual void decrement() 
671     {
672       //      if(0 == _SVertex)
673       //      {
674       //        _SVertex = _PreviousFEdge->vertexB();
675       //        return;
676       //      }
677       if(0 == _PreviousFEdge)
678         {
679           _SVertex = 0;
680           return;
681         }
682       _SVertex = _PreviousFEdge->vertexA();
683       _NextFEdge = _PreviousFEdge;
684       _PreviousFEdge = _PreviousFEdge->previousEdge();
685     }
686   };
687
688   
689 } // end of namespace ViewEdgeInternal
690
691 #endif // VIEWMAPADVANCEDITERATORS_H