Fix for a static variable in BlenderStrokeRenderer::RenderStrokeRep() left after
[blender.git] / source / blender / freestyle / intern / view_map / Functions1D.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2010 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __FREESTYLE_FUNCTIONS_1D_H__
29 #define __FREESTYLE_FUNCTIONS_1D_H__
30
31 /** \file blender/freestyle/intern/view_map/Functions1D.h
32  *  \ingroup freestyle
33  *  \brief Functions taking 1D input
34  *  \author Stephane Grabli
35  *  \author Emmanuel Turquin
36  *  \date 01/07/2003
37  */
38
39 #include "Functions0D.h"
40 #include "Interface1D.h"
41 #include "ViewMap.h"
42
43 #include "../system/FreestyleConfig.h"
44 #include "../system/Precision.h"
45 #include "../system/TimeStamp.h"
46
47 #include "../python/Director.h"
48
49 //
50 // UnaryFunction1D (base class for functions in 1D)
51 //
52 ///////////////////////////////////////////////////////////
53
54 /*! Base class for Unary Functions (functors) working on Interface1D.
55  *  A unary function will be used by calling its operator() on an Interface1D.
56  *  \attention In the scripting language, there exists several prototypes depending on the returned value type.
57  *  For example, you would inherit from a UnaryFunction1DDouble if you wish to define a function that returns a double.
58  *  The different existing prototypes are:
59  *    - UnaryFunction1DVoid
60  *    - UnaryFunction1DUnsigned
61  *    - UnaryFunction1DReal
62  *    - UnaryFunction1DFloat
63  *    - UnaryFunction1DDouble
64  *    - UnaryFunction1DVec2f
65  *    - UnaryFunction1DVec3f
66  */
67 template <class T>
68 class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D
69 {
70 public:
71         T result;
72         PyObject *py_uf1D;
73
74         /*! The type of the value returned by the functor. */
75         typedef T ReturnedValueType;
76
77         /*! Default constructor */
78         UnaryFunction1D()
79         {
80                 _integration = MEAN;
81         }
82
83         /*! Builds a UnaryFunction1D from an integration type.
84          *  \param iType
85          *    In case the result for the Interface1D would be obtained by evaluating a 0D function over the different
86          *    Interface0D of the Interface1D, \a iType tells which integration method to use.
87          *    The default integration method is the MEAN.
88          */
89         UnaryFunction1D(IntegrationType iType)
90         {
91                 _integration = iType;
92         }
93
94         /*! destructor. */
95         virtual ~UnaryFunction1D() {}
96
97         /*! returns the string "UnaryFunction1D". */
98         virtual string getName() const
99         {
100                 return "UnaryFunction1D";
101         }
102
103         /*! The operator ().
104          *  \param inter 
105          *    The Interface1D on which we wish to evaluate the function.
106          *  \return the result of the function of type T.
107          */
108         virtual int operator()(Interface1D& inter)
109         {
110                 return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inter);
111         }
112
113         /*! Sets the integration method */
114         void setIntegrationType(IntegrationType integration)
115         {
116                 _integration = integration;
117         }
118
119         /*! Returns the integration method. */
120         IntegrationType getIntegrationType() const
121         {
122                 return _integration;
123         }
124
125 protected:
126         IntegrationType _integration;
127 };
128
129
130 class  UnaryFunction1D_void
131 {
132 public:
133         PyObject *py_uf1D;
134
135         UnaryFunction1D_void()
136         {
137                 _integration = MEAN;
138         }
139
140         UnaryFunction1D_void(IntegrationType iType)
141         {
142                 _integration = iType;
143         }
144
145         virtual ~UnaryFunction1D_void() {}
146
147         virtual string getName() const
148         {
149                 return "UnaryFunction1D_void";
150         }
151
152         int operator()(Interface1D& inter)
153         {
154                 return Director_BPy_UnaryFunction1D___call__(this, py_uf1D, inter);
155         }
156
157         void setIntegrationType(IntegrationType integration)
158         {
159                 _integration = integration;
160         }
161
162         IntegrationType getIntegrationType() const
163         {
164                 return _integration;
165         }
166
167 protected:
168         IntegrationType _integration;
169 };
170
171
172 //
173 // Functions definitions
174 //
175 ///////////////////////////////////////////////////////////
176
177 namespace Functions1D {
178
179 // GetXF1D
180 /*! Returns the X 3D coordinate of an Interface1D. */
181 class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
182 {
183 private:
184         Functions0D::GetXF0D _func;
185
186 public:
187         /*! Builds the functor.
188          *  \param iType
189          *    The integration method used to compute a single value from a set of values.
190          */
191         GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType) {}
192
193         /*! Returns the string "GetXF1D" */
194         string getName() const
195         {
196                 return "GetXF1D";
197         }
198
199         /*! the () operator. */
200         int operator()(Interface1D& inter);
201 };
202
203 // GetYF1D
204 /*! Returns the Y 3D coordinate of an Interface1D. */
205 class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
206 {
207 private:
208 Functions0D::GetYF0D _func;
209
210 public:
211         /*! Builds the functor.
212          *  \param iType
213          *    The integration method used to compute a single value from a set of values.
214          */
215         GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
216
217         /*! Returns the string "GetYF1D" */
218         string getName() const
219         {
220                 return "GetYF1D";
221         }
222
223         /*! the () operator. */
224         int operator()(Interface1D& inter);
225 };
226
227 // GetZF1D
228 /*! Returns the Z 3D coordinate of an Interface1D. */
229 class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
230 {
231 private:
232         Functions0D::GetZF0D _func;
233
234 public:
235         /*! Builds the functor.
236          *  \param iType
237          *    The integration method used to compute a single value from a set of values.
238          */
239         GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
240
241         /*! Returns the string "GetZF1D" */
242         string getName() const
243         {
244                 return "GetZF1D";
245         }
246
247         /*! the () operator. */
248         int operator()(Interface1D& inter);
249 };
250
251 // GetProjectedXF1D
252 /*! Returns the projected X 3D coordinate of an Interface1D. */
253 class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
254 {
255 private:
256         Functions0D::GetProjectedXF0D _func;
257
258 public:
259         /*! Builds the functor.
260          *  \param iType
261          *    The integration method used to compute a single value from a set of values.
262          */
263         GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
264
265         /*! Returns the string "GetProjectedXF1D" */
266         string getName() const
267         {
268                 return "GetProjectedXF1D";
269         }
270
271         /*! the () operator. */
272         int operator()(Interface1D& inter);
273 };
274
275 // GetProjectedYF1D
276 /*! Returns the projected Y 3D coordinate of an Interface1D. */
277 class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
278 {
279 private:
280         Functions0D::GetProjectedYF0D _func;
281
282 public:
283         /*! Builds the functor.
284          *  \param iType
285          *    The integration method used to compute a single value from a set of values.
286          */
287         GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
288
289         /*! Returns the string "GetProjectedYF1D" */
290         string getName() const
291         {
292                 return "GetProjectedYF1D";
293         }
294
295         /*! the () operator. */
296         int operator()(Interface1D& inter);
297 };
298
299 // GetProjectedZF1D
300 /*! Returns the projected Z 3D coordinate of an Interface1D. */
301 class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
302 {
303 private:
304         Functions0D::GetProjectedZF0D _func;
305
306 public:
307         /*! Builds the functor.
308          *  \param iType
309          *    The integration method used to compute a single value from a set of values.
310          */
311         GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
312
313         /*! Returns the string "GetProjectedZF1D" */
314         string getName() const
315         {
316                 return "GetProjectedZF1D";
317         }
318
319         /*! the () operator. */
320         int operator()(Interface1D& inter);
321 };
322
323 // Orientation2DF1D
324 /*! Returns the 2D orientation as a Vec2f*/
325 class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
326 {
327 private:
328         Functions0D::VertexOrientation2DF0D _func;
329
330 public:
331         /*! Builds the functor.
332          *  \param iType
333          *    The integration method used to compute a single value from a set of values.
334          */
335         Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
336
337         /*! Returns the string "Orientation2DF1D" */
338         string getName() const
339         {
340                 return "Orientation2DF1D";
341         }
342
343         /*! the () operator. */
344         int operator()(Interface1D& inter);
345 };
346
347 // Orientation3DF1D
348 /*! Returns the 3D orientation as a Vec3f. */
349 class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
350 {
351 private:
352         Functions0D::VertexOrientation3DF0D _func;
353
354 public:
355         /*! Builds the functor.
356          *  \param iType
357          *    The integration method used to compute a single value from a set of values.
358          */
359         Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType) {}
360
361         /*! Returns the string "Orientation3DF1D" */
362         string getName() const
363         {
364                 return "Orientation3DF1D";
365         }
366
367         /*! the () operator. */
368         int operator()(Interface1D& inter);
369 };
370
371 // ZDiscontinuityF1D
372 /*! Returns a real giving the distance between and Interface1D and the shape that lies behind (occludee).
373  *  This distance is evaluated in the camera space and normalized between 0 and 1. Therefore, if no oject is occluded
374  *  by the shape to which the Interface1D belongs to, 1 is returned.
375  */
376 class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
377 {
378 private:
379         Functions0D::ZDiscontinuityF0D _func;
380
381 public:
382         /*! Builds the functor.
383          *  \param iType
384          *    The integration method used to compute a single value from a set of values.
385          */
386         ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
387
388         /*! Returns the string "ZDiscontinuityF1D" */
389         string getName() const
390         {
391                 return "ZDiscontinuityF1D";
392         }
393
394         /*! the () operator. */
395         int operator()(Interface1D& inter);
396 };
397
398 // QuantitativeInvisibilityF1D
399 /*! Returns the Quantitative Invisibility of an Interface1D element.
400  *  If the Interface1D is a ViewEdge, then there is no ambiguity concerning the result. But, if the Interface1D
401  *  results of a chaining (chain, stroke), then it might be made of several 1D elements of different
402  *  Quantitative Invisibilities.
403  */
404 class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
405 {
406 private:
407         Functions0D::QuantitativeInvisibilityF0D _func;
408
409 public:
410         /*! Builds the functor.
411          *  \param iType
412          *    The integration method used to compute a single value from a set of values.
413          */
414         QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
415
416         /*! Returns the string "QuantitativeInvisibilityF1D" */
417         string getName() const
418         {
419                 return "QuantitativeInvisibilityF1D";
420         }
421
422         /*! the () operator. */
423         int operator()(Interface1D& inter);
424 };
425
426 // CurveNatureF1D
427 /*! Returns the nature of the Interface1D (silhouette, ridge, crease...).
428  *  Except if the Interface1D is a ViewEdge, this result might be ambiguous.
429  *  Indeed, the Interface1D might result from the gathering of several 1D elements, each one being of a different
430  *  nature. An integration method, such as the MEAN, might give, in this case, irrelevant results.
431  */
432 class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
433 {
434 private:
435         Functions0D::CurveNatureF0D _func;
436
437 public:
438         /*! Builds the functor.
439          *  \param iType
440          *    The integration method used to compute a single value from a set of values.
441          */
442         CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
443
444         /*! Returns the string "CurveNatureF1D" */
445         string getName() const
446         {
447                 return "CurveNatureF1D";
448         }
449
450         /*! the () operator. */
451         int operator()(Interface1D& inter);
452 };
453
454 // TimeStampF1D
455 /*! Returns the time stamp of the Interface1D. */
456 class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D_void
457 {
458 public:
459         /*! Returns the string "TimeStampF1D" */
460         string getName() const
461         {
462                 return "TimeStampF1D";
463         }
464
465         /*! the () operator. */
466         int operator()(Interface1D& inter);
467 };
468
469 // IncrementChainingTimeStampF1D
470 /*! Increments the chaining time stamp of the Interface1D. */
471 class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D_void
472 {
473 public:
474         /*! Returns the string "IncrementChainingTimeStampF1D" */
475         string getName() const
476         {
477                 return "IncrementChainingTimeStampF1D";
478         }
479
480         /*! the () operator. */
481         int operator()(Interface1D& inter);
482 };
483
484 // ChainingTimeStampF1D
485 /*! Sets the chaining time stamp of the Interface1D. */
486 class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D_void
487 {
488 public:
489         /*! Returns the string "ChainingTimeStampF1D" */
490         string getName() const
491         {
492                 return "ChainingTimeStampF1D";
493         }
494
495         /*! the () operator. */
496         int operator()(Interface1D& inter);
497 };
498
499
500 // Curvature2DAngleF1D
501 /*! Returns the 2D curvature as an angle for an Interface1D. */
502 class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
503 {
504 public:
505         /*! Builds the functor.
506          *  \param iType
507          *    The integration method used to compute a single value from a set of values.
508          */
509         Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
510
511         /*! Returns the string "Curvature2DAngleF1D" */
512         string getName() const
513         {
514                 return "Curvature2DAngleF1D";
515         }
516
517         /*! the () operator.*/
518         int operator()(Interface1D& inter)
519         {
520                 result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
521                 return 0;
522         }
523
524 private:
525         Functions0D::Curvature2DAngleF0D _fun;
526 };
527
528 // Normal2DF1D
529 /*! Returns the 2D normal for an interface 1D. */
530 class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
531 {
532 public:
533         /*! Builds the functor.
534          *  \param iType
535          *    The integration method used to compute a single value from a set of values.
536          */
537         Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
538
539         /*! Returns the string "Normal2DF1D" */
540         string getName() const
541         {
542                 return "Normal2DF1D";
543         }
544
545         /*! the () operator.*/
546         int operator()(Interface1D& inter)
547         {
548                 result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
549                 return 0;
550         }
551
552 private:
553         Functions0D::Normal2DF0D _fun;
554 };
555
556 // GetShapeF1D
557 /*! Returns list of shapes covered by this Interface1D. */
558 class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
559 {
560 public:
561         /*! Builds the functor. */
562         GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
563
564         /*! Returns the string "GetShapeF1D" */
565         string getName() const
566         {
567                 return "GetShapeF1D";
568         }
569
570         /*! the () operator. */
571         int operator()(Interface1D& inter);
572 };
573
574 // GetOccludersF1D
575 /*! Returns list of occluding shapes covered by this Interface1D. */
576 class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
577 {
578 public:
579         /*! Builds the functor. */
580         GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
581
582         /*! Returns the string "GetOccludersF1D" */
583         string getName() const
584         {
585                 return "GetOccludersF1D";
586         }
587
588         /*! the () operator. */
589         int operator()(Interface1D& inter);
590 };
591
592 // GetOccludeeF1D
593 /*! Returns list of occluded shapes covered by this Interface1D. */
594 class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
595 {
596 public:
597         /*! Builds the functor. */
598         GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
599
600         /*! Returns the string "GetOccludeeF1D" */
601         string getName() const
602         {
603                 return "GetOccludeeF1D";
604         }
605
606         /*! the () operator. */
607         int operator()(Interface1D& inter);
608 };
609
610 // internal
611 ////////////
612
613 // getOccludeeF1D
614 LIB_VIEW_MAP_EXPORT
615 void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
616
617 // getOccludersF1D
618 LIB_VIEW_MAP_EXPORT
619 void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);
620
621 // getShapeF1D
622 LIB_VIEW_MAP_EXPORT
623 void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
624
625 } // end of namespace Functions1D
626
627 #endif // __FREESTYLE_FUNCTIONS_1D_H__