Merged changes in the trunk up to revision 53146.
[blender.git] / source / blender / freestyle / intern / view_map / Interface1D.h
1 //
2 //  Filename         : Interface1D.h
3 //  Author(s)        : Emmanuel Turquin
4 //  Purpose          : Interface to 1D elts
5 //  Date of creation : 01/07/2003
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  INTERFACE1D_H
31 # define INTERFACE1D_H
32
33 # include <Python.h>
34 # include <string>
35 # include <iostream>
36 # include <float.h>
37 # include "../system/Id.h"
38 # include "../system/Precision.h"
39 # include "../winged_edge/Nature.h"
40 # include "Functions0D.h"
41
42 using namespace std;
43 /*! \file Interface1D.h
44  *  Interface1D and related tools definitions
45  */
46 // Integration method
47 /*! The different integration
48  *  methods that can be invoked
49  *  to integrate into a single value the set of values obtained
50  *  from each 0D element of a 1D element.
51  */
52 typedef enum {
53   MEAN,/*!< The value computed for the 1D element is the mean of the values obtained for the 0D elements.*/
54   MIN,/*!< The value computed for the 1D element is the minimum of the values obtained for the 0D elements.*/
55   MAX,/*!< The value computed for the 1D element is the maximum of the values obtained for the 0D elements.*/
56   FIRST,/*!< The value computed for the 1D element is the first of the values obtained for the 0D elements.*/
57   LAST/*!< The value computed for the 1D element is the last of the values obtained for the 0D elements.*/
58 } IntegrationType;
59
60 /*! Returns a single
61  *  value from a set of values evaluated at each 0D element
62  *  of this 1D element.
63  *  \param fun
64  *    The UnaryFunction0D used to compute a value at each Interface0D.
65  *  \param it
66  *    The Interface0DIterator used to iterate over the 0D elements of
67  *    this 1D element. The integration will occur over the 0D elements
68  *    starting from the one pointed by it.
69  *  \param it_end
70  *    The Interface0DIterator pointing the end of the 0D elements of the
71  *    1D element.
72  *  \param integration_type
73  *    The integration method used to compute a single value from
74  *    a set of values.
75  *  \return the single value obtained for the 1D element.
76  */
77 template <class T>
78 T integrate(UnaryFunction0D<T>& fun,
79             Interface0DIterator it,
80             Interface0DIterator it_end,
81             IntegrationType integration_type = MEAN) {
82   T res;
83   unsigned size;
84   switch (integration_type) {
85   case MIN:
86         fun(it);
87         res = fun.result;++it;
88     for (; !it.isEnd(); ++it) {
89           fun(it);
90       if (fun.result < res)
91                 res = fun.result;
92     }
93     break;
94   case MAX:
95         fun(it);
96         res = fun.result;++it;
97     for (; !it.isEnd(); ++it) {
98           fun(it);
99       if (fun.result > res)
100             res = fun.result;
101     }
102     break;
103   case FIRST:
104         fun(it);
105         res = fun.result;
106     break;
107   case LAST:
108         fun(--it_end);
109         res = fun.result;
110     break;
111   case MEAN:
112   default:
113         fun(it);
114         res = fun.result;++it;
115         for (size = 1; !it.isEnd(); ++it, ++size) {
116           fun(it);
117           res += fun.result;
118         }
119     res /= (size ? size : 1);
120     break;
121   }
122   return res;
123 }
124
125 //
126 // Interface1D
127 //
128 //////////////////////////////////////////////////
129
130 /*! Base class for any 1D element. */
131 class Interface1D
132 {
133 public:
134
135   /*! Default constructor */
136   Interface1D() {_timeStamp=0;}
137   virtual ~Interface1D() {}; //soc
138
139   /*! Returns the string "Interface1D" .*/
140   virtual string getExactTypeName() const {
141     return "Interface1D";
142   }
143
144   // Iterator access
145
146   /*! Returns an iterator over the Interface1D vertices,
147    *  pointing to the first vertex.
148    */
149   virtual Interface0DIterator verticesBegin() {
150           PyErr_SetString(PyExc_TypeError, "method verticesBegin() not properly overridden");
151           return Interface0DIterator();
152   }
153         
154   /*! Returns an iterator over the Interface1D vertices,
155    *  pointing after the last vertex.
156    */
157   virtual Interface0DIterator verticesEnd(){
158           PyErr_SetString(PyExc_TypeError, "method verticesEnd() not properly overridden");
159           return Interface0DIterator();
160   }
161
162   /*! Returns an iterator over the Interface1D points,
163    *  pointing to the first point. The difference with
164    *  verticesBegin() is that here we can iterate over
165    *  points of the 1D element at a any given sampling.
166    *  Indeed, for each iteration, a virtual point is created.
167    *  \param t
168    *    The sampling with which we want to iterate over points of
169    *    this 1D element.
170    */
171   virtual Interface0DIterator pointsBegin(float t=0.f) {
172           PyErr_SetString(PyExc_TypeError, "method pointsBegin() not properly overridden");
173           return Interface0DIterator();
174   }
175
176   /*! Returns an iterator over the Interface1D points,
177    *  pointing after the last point. The difference with
178    *  verticesEnd() is that here we can iterate over
179    *  points of the 1D element at a any given sampling.
180    *  Indeed, for each iteration, a virtual point is created.
181    *  \param t
182    *    The sampling with which we want to iterate over points of
183    *    this 1D element.
184    */
185   virtual Interface0DIterator pointsEnd(float t=0.f) {
186           PyErr_SetString(PyExc_TypeError, "method pointsEnd() not properly overridden");
187           return Interface0DIterator();
188   }
189
190   // Data access methods
191
192   /*! Returns the 2D length of the 1D element. */
193   virtual real getLength2D() const {
194           PyErr_SetString(PyExc_TypeError, "method getLength2D() not properly overridden");
195           return 0;
196   }
197
198   /*! Returns the Id of the 1D element .*/
199   virtual Id getId() const {
200           PyErr_SetString(PyExc_TypeError, "method getId() not properly overridden");
201           return Id(0, 0);
202   }     
203
204
205   // FIXME: ce truc n'a rien a faire la...(c une requete complexe qui doit etre ds les Function1D)
206   /*! Returns the nature of the 1D element. */
207   virtual Nature::EdgeNature getNature() const {
208           PyErr_SetString(PyExc_TypeError, "method getNature() not properly overridden");
209           return Nature::NO_FEATURE;
210   }     
211   
212   /*! Returns the time stamp of the 1D element. Mainly used for selection. */
213   virtual unsigned getTimeStamp() const {
214     return _timeStamp;
215   }
216   
217   /*! Sets the time stamp for the 1D element. */
218   inline void setTimeStamp(unsigned iTimeStamp){
219     _timeStamp = iTimeStamp;
220   }
221
222 protected:
223   unsigned _timeStamp;
224 };
225
226 #endif // INTERFACE1D_H