Merged changes in the trunk up to revision 44266 (including BMesh).
[blender.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/FrsMaterial.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 int operator()(Interface0DIterator& iter) {
98         return Director_BPy_UnaryFunction0D___call__( this, py_uf0D, iter );
99   }
100
101 };
102
103 # ifdef SWIG
104 %feature("director")                    UnaryFunction0D<void>;
105 %feature("director")                    UnaryFunction0D<unsigned>;
106 %feature("director")                    UnaryFunction0D<float>;
107 %feature("director")                    UnaryFunction0D<double>;
108 %feature("director")                    UnaryFunction0D<Vec2f>;
109 %feature("director")                    UnaryFunction0D<Vec3f>;
110 %feature("director")                    UnaryFunction0D<Id>;
111
112 %template(UnaryFunction0DVoid)          UnaryFunction0D<void>;
113 %template(UnaryFunction0DUnsigned)      UnaryFunction0D<unsigned>;
114 %template(UnaryFunction0DFloat)         UnaryFunction0D<float>;
115 %template(UnaryFunction0DDouble)        UnaryFunction0D<double>;
116 %template(UnaryFunction0DVec2f)         UnaryFunction0D<Vec2f>;
117 %template(UnaryFunction0DVec3f)         UnaryFunction0D<Vec3f>;
118 %template(UnaryFunction0DId)            UnaryFunction0D<Id>;
119 %template(UnaryFunction0DViewShape)             UnaryFunction0D<ViewShape*>;
120 %template(UnaryFunction0DVectorViewShape)               UnaryFunction0D<std::vector<ViewShape*> >;
121 # endif // SWIG
122
123
124 //
125 // Functions definitions
126 //
127 ///////////////////////////////////////////////////////////
128 class ViewShape;
129 namespace Functions0D {
130
131   // GetXF0D
132   /*! Returns the X 3D coordinate of an Interface0D. */
133   class LIB_VIEW_MAP_EXPORT GetXF0D : public UnaryFunction0D<real>
134   {
135   public:
136     /*! Returns the string "GetXF0D"*/
137     string getName() const {
138       return "GetXF0D";
139     }
140     /*! the () operator.*/
141     int operator()(Interface0DIterator& iter) {
142       result = iter->getX();
143           return 0;
144     }
145   };
146
147   // GetYF0D
148   /*! Returns the Y 3D coordinate of an Interface0D. */
149   class LIB_VIEW_MAP_EXPORT GetYF0D : public UnaryFunction0D<real>
150   {
151   public:
152     /*! Returns the string "GetYF0D"*/
153     string getName() const {
154       return "GetYF0D";
155     }
156     /*! the () operator.*/
157     int operator()(Interface0DIterator& iter) {
158       result = iter->getY();
159           return 0;
160     }
161   };
162
163   // GetZF0D
164   /*! Returns the Z 3D coordinate of an Interface0D. */
165   class LIB_VIEW_MAP_EXPORT GetZF0D : public UnaryFunction0D<real>
166   {
167   public:
168     /*! Returns the string "GetZF0D"*/
169     string getName() const {
170       return "GetZF0D";
171     }
172     /*! the () operator.*/
173     int operator()(Interface0DIterator& iter) {
174       result = iter->getZ();
175           return 0;
176     }
177   };
178
179   // GetProjectedXF0D
180   /*! Returns the X 3D projected coordinate of an Interface0D. */
181   class LIB_VIEW_MAP_EXPORT GetProjectedXF0D : public UnaryFunction0D<real>
182   {
183   public:
184     /*! Returns the string "GetProjectedXF0D"*/
185     string getName() const {
186       return "GetProjectedXF0D";
187     }
188     /*! the () operator.*/
189     int operator()(Interface0DIterator& iter) {
190       result = iter->getProjectedX();
191           return 0;
192     }
193   };
194
195   // GetProjectedYF0D
196   /*! Returns the Y projected 3D coordinate of an Interface0D. */
197   class LIB_VIEW_MAP_EXPORT GetProjectedYF0D : public UnaryFunction0D<real>
198   {
199   public:
200     /*! Returns the string "GetProjectedYF0D"*/
201     string getName() const {
202       return "GetProjectedYF0D";
203     }
204     /*! the () operator.*/
205     int operator()(Interface0DIterator& iter) {
206       result = iter->getProjectedY();
207           return 0;
208     }
209   };
210
211   // GetProjectedZF0D
212   /*! Returns the Z projected 3D coordinate of an Interface0D. */
213   class LIB_VIEW_MAP_EXPORT GetProjectedZF0D : public UnaryFunction0D<real>
214   {
215   public:
216     /*! Returns the string "GetProjectedZF0D"*/
217     string getName() const {
218       return "GetProjectedZF0D";
219     }
220     /*! the () operator.*/
221     int operator()(Interface0DIterator& iter) {
222       result = iter->getProjectedZ();
223           return 0;
224     }
225   };
226
227   // GetCurvilinearAbscissaF0D
228   /*! Returns the curvilinear abscissa of an Interface0D in the context of its 1D element. */
229   class LIB_VIEW_MAP_EXPORT GetCurvilinearAbscissaF0D : public UnaryFunction0D<float>
230   {
231   public:
232     /*! Returns the string "GetCurvilinearAbscissaF0D"*/
233     string getName() const {
234       return "GetCurvilinearAbscissaF0D";
235     }
236     /*! the () operator.*/
237     int operator()(Interface0DIterator& iter) {
238       result = iter.t();
239           return 0;
240     }
241   };
242
243   // GetParameterF0D
244   /*! Returns the parameter of an Interface0D in the context of its 1D element. */
245   class LIB_VIEW_MAP_EXPORT GetParameterF0D : public UnaryFunction0D<float>
246   {
247   public:
248     /*! Returns the string "GetCurvilinearAbscissaF0D"*/
249     string getName() const {
250       return "GetParameterF0D";
251     }
252     /*! the () operator.*/
253     int operator()(Interface0DIterator& iter) {
254       result = iter.u();
255           return 0;
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     int 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     int 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     int 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     int 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     int 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<FrsMaterial>
354   {
355   public:
356     /*! Returns the string "MaterialF0D"*/
357     string getName() const {
358       return "MaterialF0D";
359     }
360     /*! the () operator.*/
361     int 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     int 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     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     int 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     int 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     int 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     int 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