Merged changes in the trunk up to revision 44266 (including BMesh).
[blender.git] / source / blender / freestyle / intern / view_map / Functions1D.h
1 //
2 //  Filename         : Functions1D.h
3 //  Author(s)        : Stephane Grabli, Emmanuel Turquin
4 //  Purpose          : Functions taking 1D 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  FUNCTIONS1D_HPP
31 # define FUNCTIONS1D_HPP
32
33 # include "ViewMap.h"
34 # include "Functions0D.h"
35 # include "Interface1D.h"
36 # include "../system/Precision.h"
37 # include "../system/TimeStamp.h"
38 # include "../system/FreestyleConfig.h"
39
40 #include "../python/Director.h"
41
42 //
43 // UnaryFunction1D (base class for functions in 1D)
44 //
45 ///////////////////////////////////////////////////////////
46
47 /*! Base class for Unary Functions (functors) working
48  *  on Interface1D.
49  *  A unary function will be used by calling
50  *  its operator() on an Interface1D.
51  *  \attention In the scripting language, there exists
52  *  several prototypes depending on the returned value type.
53  *  For example, you would inherit from a UnaryFunction1DDouble
54  *  if you wish to define a function that returns a double.
55  *  The different existing prototypes are:
56  *    - UnaryFunction1DVoid
57  *    - UnaryFunction1DUnsigned
58  *    - UnaryFunction1DReal
59  *    - UnaryFunction1DFloat
60  *    - UnaryFunction1DDouble
61  *    - UnaryFunction1DVec2f
62  *    - UnaryFunction1DVec3f
63  */
64 template <class T>
65 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D
66 {
67 public:
68
69         T result;
70         PyObject *py_uf1D;
71
72   /*! The type of the value
73    *  returned by the functor.
74    */
75   typedef T ReturnedValueType;
76   
77   /*! Default constructor */
78   UnaryFunction1D(){_integration = MEAN;}
79   /*! Builds a UnaryFunction1D from an integration type.
80    *  \param iType
81    *    In case the result for the Interface1D would be
82    *    obtained by evaluating a 0D function over the different
83    *    Interface0D of the Interface1D, \a iType tells which
84    *    integration method to use.
85    *    The default integration method is the MEAN.
86    */
87   UnaryFunction1D(IntegrationType iType){_integration = iType;}
88   /*! destructor. */
89   virtual ~UnaryFunction1D() {}
90
91   /*! returns the string "UnaryFunction1D". */
92   virtual string getName() const {
93     return "UnaryFunction1D";
94   }
95   /*! The operator ().
96    *  \param inter 
97    *    The Interface1D on which we wish to evaluate
98    *    the function.
99    *  \return the result of the function of type T.
100    */
101   virtual int operator()(Interface1D& inter) {
102         return Director_BPy_UnaryFunction1D___call__( this, py_uf1D, inter );
103   }
104         
105   /*! Sets the integration method */
106   void setIntegrationType(IntegrationType integration) {
107     _integration = integration;
108   }
109   /*! Returns the integration method. */
110   IntegrationType getIntegrationType() const {
111     return _integration;
112   }
113
114 protected:
115
116   IntegrationType _integration;
117 };
118
119
120 class  UnaryFunction1D_void
121 {
122 public:
123
124         PyObject *py_uf1D;
125
126         UnaryFunction1D_void(){_integration = MEAN;}
127         UnaryFunction1D_void(IntegrationType iType){_integration = iType;}
128         virtual ~UnaryFunction1D_void() {}
129         
130         virtual string getName() const {
131                 return "UnaryFunction1D_void";
132         }
133         
134         int operator()(Interface1D& inter) {
135                 return Director_BPy_UnaryFunction1D___call__( this, py_uf1D, inter );
136         }
137         
138         void setIntegrationType(IntegrationType integration) { _integration = integration; }
139         IntegrationType getIntegrationType() const { return _integration; }
140         
141         protected:
142                 IntegrationType _integration;
143 };
144
145
146 //
147 // Functions definitions
148 //
149 ///////////////////////////////////////////////////////////
150
151 namespace Functions1D {
152
153   // GetXF1D
154   /*! Returns the X 3D coordinate of an Interface1D. */
155   class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
156   {
157   private:
158     Functions0D::GetXF0D _func;
159   public:
160     /*! Builds the functor.
161      *  \param iType
162      *    The integration method used to compute
163      *    a single value from a set of values.
164      */
165     GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType){}
166     /*! Returns the string "GetXF1D"*/
167     string getName() const {
168       return "GetXF1D";
169     }
170     /*! the () operator.*/
171     int operator()(Interface1D& inter) ;
172   };
173
174   // GetYF1D
175   /*! Returns the Y 3D coordinate of an Interface1D. */
176   class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
177   {
178   private:
179     Functions0D::GetYF0D _func;
180   public:
181     /*! Builds the functor.
182      *  \param iType
183      *    The integration method used to compute
184      *    a single value from a set of values.
185      */
186     GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
187     /*! Returns the string "GetYF1D"*/
188     string getName() const {
189       return "GetYF1D";
190     }
191     /*! the () operator.*/
192     int operator()(Interface1D& inter) ;
193   };
194
195   // GetZF1D
196   /*! Returns the Z 3D coordinate of an Interface1D. */
197   class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
198   {
199   private:
200     Functions0D::GetZF0D _func;
201   public:
202     /*! Builds the functor.
203      *  \param iType
204      *    The integration method used to compute
205      *    a single value from a set of values.
206      */
207     GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
208     /*! Returns the string "GetZF1D"*/
209     string getName() const {
210       return "GetZF1D";
211     }
212     /*! the () operator.*/
213     int operator()(Interface1D& inter) ;
214   };
215
216   // GetProjectedXF1D
217   /*! Returns the projected X 3D coordinate of an Interface1D. */
218   class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
219   {
220   private:
221     Functions0D::GetProjectedXF0D _func;
222   public:
223     /*! Builds the functor.
224      *  \param iType
225      *    The integration method used to compute
226      *    a single value from a set of values.
227      */
228     GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
229   public:
230     /*! Returns the string "GetProjectedXF1D"*/
231     string getName() const {
232       return "GetProjectedXF1D";
233     }
234     /*! the () operator.*/
235     int operator()(Interface1D& inter);
236   };
237   
238   // GetProjectedYF1D
239   /*! Returns the projected Y 3D coordinate of an Interface1D. */
240   class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
241   {
242   private:
243     Functions0D::GetProjectedYF0D _func;
244   public:
245     /*! Builds the functor.
246      *  \param iType
247      *    The integration method used to compute
248      *    a single value from a set of values.
249      */
250     GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
251   public:
252     /*! Returns the string "GetProjectedYF1D"*/
253     string getName() const {
254       return "GetProjectedYF1D";
255     }
256     /*! the () operator.*/
257     int operator()(Interface1D& inter);
258   };
259
260   // GetProjectedZF1D
261   /*! Returns the projected Z 3D coordinate of an Interface1D. */
262   class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
263   {
264   private:
265     Functions0D::GetProjectedZF0D _func;
266   public:
267     /*! Builds the functor.
268      *  \param iType
269      *    The integration method used to compute
270      *    a single value from a set of values.
271      */
272     GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
273   public:
274     /*! Returns the string "GetProjectedZF1D"*/
275     string getName() const {
276       return "GetProjectedZF1D";
277     }
278     /*! the () operator.*/
279     int operator()(Interface1D& inter);
280   };
281   
282   // Orientation2DF1D
283   /*! Returns the 2D orientation as a Vec2f*/
284   class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
285   {
286   private:
287     Functions0D::VertexOrientation2DF0D _func;
288   public:
289     /*! Builds the functor.
290      *  \param iType
291      *    The integration method used to compute
292      *    a single value from a set of values.
293      */
294     Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType){}
295     /*! Returns the string "Orientation2DF1D"*/
296     string getName() const {
297       return "Orientation2DF1D";
298     }
299     /*! the () operator.*/
300     int operator()(Interface1D& inter);
301   };
302
303   // Orientation3DF1D
304   /*! Returns the 3D orientation as a Vec3f. */
305   class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
306   {
307   private:
308     Functions0D::VertexOrientation3DF0D _func;
309   public:
310     /*! Builds the functor.
311      *  \param iType
312      *    The integration method used to compute
313      *    a single value from a set of values.
314      */
315     Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType){}
316     /*! Returns the string "Orientation3DF1D"*/
317     string getName() const {
318       return "Orientation3DF1D";
319     }
320     /*! the () operator.*/    
321     int operator()(Interface1D& inter);
322   };
323
324   // ZDiscontinuityF1D
325   /*! Returns a real giving the distance between
326    *  and Interface1D and the shape that lies behind (occludee).
327    *  This distance is evaluated in the camera space and normalized
328    *  between 0 and 1. Therefore, if no oject is occluded by the
329    *  shape to which the Interface1D belongs to, 1 is returned.
330    */
331   class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
332   {
333   private:
334     Functions0D::ZDiscontinuityF0D _func;
335   public:
336     /*! Builds the functor.
337      *  \param iType
338      *    The integration method used to compute
339      *    a single value from a set of values.
340      */
341     ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
342     /*! Returns the string "ZDiscontinuityF1D"*/
343     string getName() const {
344       return "ZDiscontinuityF1D";
345     }
346     /*! the () operator.*/        
347     int operator()(Interface1D& inter);
348   };
349   
350   // QuantitativeInvisibilityF1D
351   /*! Returns the Quantitative Invisibility of an Interface1D element.
352    *  If the Interface1D is a ViewEdge, then there is no ambiguity
353    *  concerning the result. But, if the Interface1D results of a chaining
354    *  (chain, stroke), then it might be made of several 1D elements
355    *  of different Quantitative Invisibilities.
356    */
357   class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
358   {
359   private:
360     Functions0D::QuantitativeInvisibilityF0D _func;
361   public:
362   /*! Builds the functor.
363      *  \param iType
364      *    The integration method used to compute
365      *    a single value from a set of values.
366      */
367     QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
368    /*! Returns the string "QuantitativeInvisibilityF1D"*/
369     string getName() const {
370       return "QuantitativeInvisibilityF1D";
371     }
372   /*! the () operator.*/        
373     int operator()(Interface1D& inter);
374   };
375
376   // CurveNatureF1D
377 /*! Returns the nature of the Interface1D (silhouette, ridge, crease...).
378  *  Except if the Interface1D is a ViewEdge, this result might be ambiguous.
379  *  Indeed, the Interface1D might result from the gathering of several 1D elements,
380  *  each one being of a different nature. An integration method, such as
381  *  the MEAN, might give, in this case, irrelevant results.
382  */
383   class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
384   {
385   private:
386     Functions0D::CurveNatureF0D _func;
387   public:
388     /*! Builds the functor.
389      *  \param iType
390      *    The integration method used to compute
391      *    a single value from a set of values.
392      */
393     CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
394     /*! Returns the string "CurveNatureF1D"*/
395     string getName() const {
396       return "CurveNatureF1D";
397     }
398     /*! the () operator.*/        
399     int operator()(Interface1D& inter);
400   };
401
402   // TimeStampF1D
403 /*! Returns the time stamp of the Interface1D. */
404   class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D_void
405   {
406   public:
407     /*! Returns the string "TimeStampF1D"*/
408     string getName() const {
409       return "TimeStampF1D";
410     }
411     /*! the () operator.*/        
412     int operator()(Interface1D& inter);
413   };
414
415   // IncrementChainingTimeStampF1D
416 /*! Increments the chaining time stamp of the Interface1D. */
417   class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D_void
418   {
419   public:
420     /*! Returns the string "IncrementChainingTimeStampF1D"*/
421     string getName() const {
422       return "IncrementChainingTimeStampF1D";
423     }
424     /*! the () operator.*/        
425     int operator()(Interface1D& inter);
426   };
427
428   // ChainingTimeStampF1D
429 /*! Sets the chaining time stamp of the Interface1D. */
430   class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D_void
431   {
432   public:
433     /*! Returns the string "ChainingTimeStampF1D"*/
434     string getName() const {
435       return "ChainingTimeStampF1D";
436     }
437     /*! the () operator.*/        
438     int operator()(Interface1D& inter);
439   };
440   
441
442   // Curvature2DAngleF1D
443 /*! Returns the 2D curvature as an angle for an Interface1D. */
444   class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
445   {
446   public:
447     /*! Builds the functor.
448      *  \param iType
449      *    The integration method used to compute
450      *    a single value from a set of values.
451      */
452     Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
453     /*! Returns the string "Curvature2DAngleF1D"*/
454     string getName() const {
455       return "Curvature2DAngleF1D";
456     }
457     /*! the () operator.*/        
458     int operator()(Interface1D& inter) {
459       result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
460           return 0;
461     }
462   private:
463     Functions0D::Curvature2DAngleF0D    _fun;
464   };
465
466   // Normal2DF1D
467   /*! Returns the 2D normal for an interface 1D. */
468   class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
469   {
470   public:
471     /*! Builds the functor.
472      *  \param iType
473      *    The integration method used to compute
474      *    a single value from a set of values.
475      */
476     Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
477     /*! Returns the string "Normal2DF1D"*/
478     string getName() const {
479       return "Normal2DF1D";
480     }
481     /*! the () operator.*/        
482     int operator()(Interface1D& inter) {
483       result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
484           return 0;
485     }
486   private:
487     Functions0D::Normal2DF0D    _fun;
488   };
489
490   // GetShapeF1D
491   /*! Returns list of shapes covered by this Interface1D. */
492   class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
493   {
494   public:
495     /*! Builds the functor.
496      */
497     GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
498     /*! Returns the string "GetShapeF1D"*/
499     string getName() const {
500       return "GetShapeF1D";
501     }
502     /*! the () operator.*/        
503     int operator()(Interface1D& inter);
504   };
505
506   // GetOccludersF1D
507   /*! Returns list of occluding shapes covered by this Interface1D. */
508   class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
509   {
510   public:
511     /*! Builds the functor.
512      */
513     GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
514     /*! Returns the string "GetOccludersF1D"*/
515     string getName() const {
516       return "GetOccludersF1D";
517     }
518     /*! the () operator.*/        
519     int operator()(Interface1D& inter);
520   };
521
522   // GetOccludeeF1D
523   /*! Returns list of occluded shapes covered by this Interface1D. */
524   class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
525   {
526   public:
527     /*! Builds the functor.
528      */
529     GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
530     /*! Returns the string "GetOccludeeF1D"*/
531     string getName() const {
532       return "GetOccludeeF1D";
533     }
534     /*! the () operator.*/        
535     int operator()(Interface1D& inter);
536   };
537
538   // internal
539   ////////////
540
541   // getOccludeeF1D
542   LIB_VIEW_MAP_EXPORT
543   void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
544
545   // getOccludersF1D
546   LIB_VIEW_MAP_EXPORT
547   void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);
548
549   // getShapeF1D
550   LIB_VIEW_MAP_EXPORT
551   void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
552   
553 } // end of namespace Functions1D
554
555 #endif // FUNCTIONS1D_HPP