soc-2008-mxcurioni: made considerable changes to support cross-language polymorphism...
[blender-staging.git] / source / blender / freestyle / intern / view_map / Functions0D.h
1 //
2 //  Filename         : Functions0D.h
3 //  Author(s)        : Stephane Grabli, Emmanuel Turquin
4 //  Purpose          : Functions taking 0D input
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  FUNCTIONS0D_H
31 # define FUNCTIONS0D_H
32
33 # include "../system/Precision.h"
34 # include "Interface0D.h"
35 # include "../geometry/Geom.h"
36 # include "../system/Exception.h"
37 # include "../scene_graph/Material.h"
38 # include <set>
39 # include <vector>
40 class FEdge;
41 class ViewEdge;
42 class SShape;
43
44 using namespace Geometry;
45
46 #include "../python/Director.h"
47
48 //
49 // UnaryFunction0D (base class for functions in 0D)
50 //
51 ///////////////////////////////////////////////////////////
52
53 template <class T>
54 /*! Base class for Unary Functions (functors) working
55  *  on Interface0DIterator.
56  *  A unary function will be used by calling
57  *  its operator() on an Interface0DIterator.
58  *  \attention In the scripting language, there exists
59  *  several prototypes depending on the returned value type.
60  *  For example, you would inherit from a UnaryFunction0DDouble
61  *  if you wish to define a function that returns a double.
62  *  The different existing prototypes are:
63  *    - UnaryFunction0DVoid
64  *    - UnaryFunction0DUnsigned
65  *    - UnaryFunction0DReal
66  *    - UnaryFunction0DFloat
67  *    - UnaryFunction0DDouble
68  *    - UnaryFunction0DVec2f
69  *    - UnaryFunction0DVec3f
70  */
71 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction0D
72 {
73 public:
74
75         T result;
76         PyObject *py_uf0D;
77
78   /*! The type of the value
79    *  returned by the functor.
80    */
81   typedef T ReturnedValueType;
82   /*! Default constructor. */
83 UnaryFunction0D() { py_uf0D  = 0;}
84   /*! Destructor; */
85   virtual ~UnaryFunction0D() {}
86   /*! Returns the string "UnaryFunction0D" */
87   virtual string getName() const {
88     return "UnaryFunction0D";
89   }
90   /*! The operator ().
91    *  \param iter 
92    *    An Interface0DIterator pointing onto
93    *    the point at which we wish to evaluate
94    *    the function.
95    *  \return the result of the function of type T.
96    */
97   virtual T operator()(Interface0DIterator& iter) {
98         string name( py_uf0D ? PyString_AsString(PyObject_CallMethod(py_uf0D, "getName", "")) : getName() );
99         
100         if( py_uf0D && PyObject_HasAttrString(py_uf0D, "__call__") ) {
101                 Director_BPy_UnaryFunction0D___call__( this, py_uf0D, iter);
102                 return result;
103         } else {
104                 cerr << "Warning: " << name << " operator() not implemented" << endl;
105             return T();
106         }
107   }
108
109 };
110
111 # ifdef SWIG
112 %feature("director")                    UnaryFunction0D<void>;
113 %feature("director")                    UnaryFunction0D<unsigned>;
114 %feature("director")                    UnaryFunction0D<float>;
115 %feature("director")                    UnaryFunction0D<double>;
116 %feature("director")                    UnaryFunction0D<Vec2f>;
117 %feature("director")                    UnaryFunction0D<Vec3f>;
118 %feature("director")                    UnaryFunction0D<Id>;
119
120 %template(UnaryFunction0DVoid)          UnaryFunction0D<void>;
121 %template(UnaryFunction0DUnsigned)      UnaryFunction0D<unsigned>;
122 %template(UnaryFunction0DFloat)         UnaryFunction0D<float>;
123 %template(UnaryFunction0DDouble)        UnaryFunction0D<double>;
124 %template(UnaryFunction0DVec2f)         UnaryFunction0D<Vec2f>;
125 %template(UnaryFunction0DVec3f)         UnaryFunction0D<Vec3f>;
126 %template(UnaryFunction0DId)            UnaryFunction0D<Id>;
127 %template(UnaryFunction0DViewShape)             UnaryFunction0D<ViewShape*>;
128 %template(UnaryFunction0DVectorViewShape)               UnaryFunction0D<std::vector<ViewShape*> >;
129 # endif // SWIG
130
131
132 //
133 // Functions definitions
134 //
135 ///////////////////////////////////////////////////////////
136 class ViewShape;
137 namespace Functions0D {
138
139   // GetXF0D
140   /*! Returns the X 3D coordinate of an Interface0D. */
141   class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
142   {
143   public:
144     /*! Returns the string "GetXF0D"*/
145     string getName() const {
146       return "GetXF0D";
147     }
148     /*! the () operator.*/
149     real operator()(Interface0DIterator& iter) {
150       return iter->getX();
151     }
152   };
153
154   // GetYF0D
155   /*! Returns the Y 3D coordinate of an Interface0D. */
156   class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
157   {
158   public:
159     /*! Returns the string "GetYF0D"*/
160     string getName() const {
161       return "GetYF0D";
162     }
163     /*! the () operator.*/
164     real operator()(Interface0DIterator& iter) {
165       return iter->getY();
166     }
167   };
168
169   // GetZF0D
170   /*! Returns the Z 3D coordinate of an Interface0D. */
171   class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
172   {
173   public:
174     /*! Returns the string "GetZF0D"*/
175     string getName() const {
176       return "GetZF0D";
177     }
178     /*! the () operator.*/
179     real operator()(Interface0DIterator& iter) {
180       return iter->getZ();
181     }
182   };
183
184   // GetProjectedXF0D
185   /*! Returns the X 3D projected coordinate of an Interface0D. */
186   class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
187   {
188   public:
189     /*! Returns the string "GetProjectedXF0D"*/
190     string getName() const {
191       return "GetProjectedXF0D";
192     }
193     /*! the () operator.*/
194     real operator()(Interface0DIterator& iter) {
195       return iter->getProjectedX();
196     }
197   };
198
199   // GetProjectedYF0D
200   /*! Returns the Y projected 3D coordinate of an Interface0D. */
201   class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
202   {
203   public:
204     /*! Returns the string "GetProjectedYF0D"*/
205     string getName() const {
206       return "GetProjectedYF0D";
207     }
208     /*! the () operator.*/
209     real operator()(Interface0DIterator& iter) {
210       return iter->getProjectedY();
211     }
212   };
213
214   // GetProjectedZF0D
215   /*! Returns the Z projected 3D coordinate of an Interface0D. */
216   class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
217   {
218   public:
219     /*! Returns the string "GetProjectedZF0D"*/
220     string getName() const {
221       return "GetProjectedZF0D";
222     }
223     /*! the () operator.*/
224     real operator()(Interface0DIterator& iter) {
225       return iter->getProjectedZ();
226     }
227   };
228
229   // GetCurvilinearAbscissaF0D
230   /*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
231   class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
232   {
233   public:
234     /*! Returns the string "GetCurvilinearAbscissaF0D"*/
235     string getName() const {
236       return "GetCurvilinearAbscissaF0D";
237     }
238     /*! the () operator.*/
239     float operator()(Interface0DIterator& iter) {
240       return iter.t();
241     }
242   };
243
244   // GetParameterF0D
245   /*! Returns the parameter of an Interface0D in the context of its 1D element. */
246   class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
247   {
248   public:
249     /*! Returns the string "GetCurvilinearAbscissaF0D"*/
250     string getName() const {
251       return "GetParameterF0D";
252     }
253     /*! the () operator.*/
254     float operator()(Interface0DIterator& iter) {
255       return iter.u();
256     }
257   };
258
259   // VertexOrientation2DF0D
260   /*! Returns a Vec2r giving the 2D oriented tangent to the 1D element
261    *  to which the Interface0DIterator& belongs to and
262    *  evaluated at the Interface0D pointed by this Interface0DIterator&.
263    */
264   class LIB_VIEW_MAP_EXPORT VertexOrientation2DF0D : public UnaryFunction0D<Vec2f>
265   {
266   public:
267     /*! Returns the string "VertexOrientation2DF0D"*/
268     string getName() const {
269       return "VertexOrientation2DF0D";
270     }
271     /*! the () operator.*/
272     Vec2f operator()(Interface0DIterator& iter);
273   };
274
275   // VertexOrientation3DF0D
276   /*! Returns a Vec3r giving the 3D oriented tangent to the 1D element
277    *  to which the Interface0DIterator& belongs to and
278    *  evaluated at the Interface0D pointed by this Interface0DIterator&.
279    */
280   class LIB_VIEW_MAP_EXPORT VertexOrientation3DF0D : public UnaryFunction0D<Vec3f>
281   {
282   public:
283     /*! Returns the string "VertexOrientation3DF0D"*/
284     string getName() const {
285       return "VertexOrientation3DF0D";
286     }
287     /*! the () operator.*/
288     Vec3f operator()(Interface0DIterator& iter);
289   };
290
291   // Curvature2DAngleF0D
292   /*! Returns a real giving the 2D curvature (as an angle) of the 1D element
293    *  to which the Interface0DIterator& belongs to and
294    *  evaluated at the Interface0D pointed by this Interface0DIterator&.
295    */
296   class LIB_VIEW_MAP_EXPORT Curvature2DAngleF0D : public UnaryFunction0D<real>
297   {
298   public:
299     /*! Returns the string "Curvature2DAngleF0D"*/
300     string getName() const {
301       return "Curvature2DAngleF0D";
302     }
303     /*! the () operator.*/
304     real operator()(Interface0DIterator& iter);
305   };
306
307   // ZDiscontinuity
308   /*! Returns a real giving the distance between
309    *  and Interface0D and the shape that lies behind (occludee).
310    *  This distance is evaluated in the camera space and normalized
311    *  between 0 and 1. Therefore, if no oject is occluded by the
312    *  shape to which the Interface0D belongs to, 1 is returned.
313    */
314   class LIB_VIEW_MAP_EXPORT ZDiscontinuityF0D : public UnaryFunction0D<real>
315   {
316   public:
317     /*! Returns the string "ZDiscontinuityF0D"*/
318     string getName() const {
319       return "ZDiscontinuityF0D";
320     }
321     /*! the () operator.*/
322     real operator()(Interface0DIterator& iter);
323   };
324
325   // Normal2DF0D
326   /*! Returns a Vec2f giving the normalized 2D normal to the 1D element
327    *  to which the Interface0DIterator& belongs to and
328    *  evaluated at the Interface0D pointed by this Interface0DIterator&.
329    */
330   class LIB_VIEW_MAP_EXPORT Normal2DF0D : public UnaryFunction0D<Vec2f>
331   {
332   public:
333     /*! Returns the string "Normal2DF0D"*/
334     string getName() const {
335       return "Normal2DF0D";
336     }
337     /*! the () operator.*/
338     Vec2f operator()(Interface0DIterator& iter);
339   };
340
341   // MaterialF0D
342   /*! Returns the material of the object evaluated at the Interface0D.
343    *  This evaluation can be ambiguous (in the case of a TVertex for example.
344    *  This functor tries to remove this ambiguity using the context
345    *  offered by the 1D element to which the Interface0DIterator& belongs
346    *  to and by arbitrary chosing the material of the face
347    *  that lies on its left when following the 1D element if there
348    *  are two different materials on each side of the point.
349    *  However, there still can be problematic cases, and the user willing
350    *  to deal with this cases in a specific way should implement
351    *  its own getMaterial functor.
352    */
353   class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<Material>
354   {
355   public:
356     /*! Returns the string "MaterialF0D"*/
357     string getName() const {
358       return "MaterialF0D";
359     }
360     /*! the () operator.*/
361     Material operator()(Interface0DIterator& iter);
362   };
363
364   // ShapeIdF0D
365   /*! Returns the Id of the Shape the Interface0D belongs to.
366    *  This evaluation can be ambiguous (in the case of a TVertex for example).
367    *  This functor tries to remove this ambiguity using the context
368    *  offered by the 1D element to which the Interface0DIterator& belongs
369    *  to.
370    *  However, there still can be problematic cases, and the user willing
371    *  to deal with this cases in a specific way should implement
372    *  its own getShapeIdF0D functor.
373    */
374   class LIB_VIEW_MAP_EXPORT ShapeIdF0D : public UnaryFunction0D<Id>
375   {
376   public:
377     /*! Returns the string "ShapeIdF0D"*/
378     string getName() const {
379       return "ShapeIdF0D";
380     }
381     /*! the () operator.*/
382     Id operator()(Interface0DIterator& iter);
383   };
384
385   // QiF0D
386   /*! Returns the quantitative invisibility of this Interface0D.
387    *  This evaluation can be ambiguous (in the case of a TVertex for example).
388    *  This functor tries to remove this ambiguity using the context
389    *  offered by the 1D element to which the Interface0DIterator& belongs
390    *  to.
391    *  However, there still can be problematic cases, and the user willing
392    *  to deal with this cases in a specific way should implement
393    *  its own getQIF0D functor.
394    */
395   class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF0D : public UnaryFunction0D<unsigned int>
396   {
397   public:
398     /*! Returns the string "QuantitativeInvisibilityF0D"*/
399     string getName() const {
400       return "QuantitativeInvisibilityF0D";
401     }
402     /*! the () operator.*/
403     unsigned int operator()(Interface0DIterator& iter);
404   };
405
406   // CurveNatureF0D
407   /*! Returns the Nature::EdgeNature of the 1D element the
408    *  Interface0DIterator& belongs to.
409    */
410   class LIB_VIEW_MAP_EXPORT CurveNatureF0D : public UnaryFunction0D<Nature::EdgeNature>
411   {
412   public:
413     /*! Returns the string "QuantitativeInvisibilityF0D"*/
414     string getName() const {
415       return "CurveNatureF0D";
416     }
417     /*! the () operator.*/
418     Nature::EdgeNature operator()(Interface0DIterator& iter);
419   };
420   
421   // GetShapeF0D
422   /*! Returns the ViewShape* 
423    *  containing the Interface0D
424    */
425   class LIB_VIEW_MAP_EXPORT GetShapeF0D : public UnaryFunction0D< ViewShape*>
426   {
427   public:
428     /*! Returns the string "GetShapeF0D"*/
429     string getName() const {
430       return "GetShapeF0D";
431     }
432     /*! the () operator.*/
433     ViewShape* operator()(Interface0DIterator& iter);
434   };
435
436   // GetOccludersF0D
437   /*! Returns a vector containing the ViewShape* 
438    *  occluding the Interface0D
439    */
440   class LIB_VIEW_MAP_EXPORT GetOccludersF0D : public UnaryFunction0D< std::vector<ViewShape*> >
441   {
442   public:
443     /*! Returns the string "GetOccludersF0D"*/
444     string getName() const {
445       return "GetOccludersF0D";
446     }
447     /*! the () operator.*/
448     std::vector<ViewShape*> operator()(Interface0DIterator& iter);
449   };
450
451   // GetOccludeeF0D
452   /*! Returns the ViewShape* 
453    *  "occluded" by the Interface0D
454    */
455   class LIB_VIEW_MAP_EXPORT GetOccludeeF0D: public UnaryFunction0D< ViewShape*>
456   {
457   public:
458     /*! Returns the string "GetOccludeeF0D"*/
459     string getName() const {
460       return "GetOccludeeF0D";
461     }
462     /*! the () operator.*/
463     ViewShape* operator()(Interface0DIterator& iter);
464   };
465
466   
467
468   /////////////////////////// Internal ////////////////////////////
469
470   // getFEdge
471   LIB_VIEW_MAP_EXPORT
472   FEdge* getFEdge(Interface0D& it1, Interface0D& it2);
473
474   // getFEdges
475   LIB_VIEW_MAP_EXPORT
476   void  getFEdges(Interface0DIterator& it,
477                  FEdge*& fe1,
478                  FEdge*& fe2);
479
480   // getViewEdges
481   LIB_VIEW_MAP_EXPORT
482   void  getViewEdges(Interface0DIterator& it,
483                     ViewEdge *&ve1,
484                     ViewEdge *&ve2);
485
486   // getShapeF0D
487   LIB_VIEW_MAP_EXPORT
488   ViewShape* getShapeF0D(Interface0DIterator& it);
489
490   // getOccludersF0D
491   LIB_VIEW_MAP_EXPORT
492   void getOccludersF0D(Interface0DIterator& it, std::set<ViewShape*>& oOccluders);
493
494   // getOccludeeF0D
495   LIB_VIEW_MAP_EXPORT
496   ViewShape* getOccludeeF0D(Interface0DIterator& it);
497
498 } // end of namespace Functions0D
499
500 #endif // FUNCTIONS0D_H