cbdff4ed96c01a9319116a56d59d9f47a19c535c
[blender.git] / source / blender / freestyle / intern / stroke / AdvancedFunctions1D.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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 #ifndef __FREESTYLE_ADVANCED_FUNCTIONS_1D_H__
22 #define __FREESTYLE_ADVANCED_FUNCTIONS_1D_H__
23
24 /** \file blender/freestyle/intern/stroke/AdvancedFunctions1D.h
25  *  \ingroup freestyle
26  *  \brief Functions taking 1D input
27  *  \author Stephane Grabli
28  *  \author Emmanuel Turquin
29  *  \date 01/07/2003
30  */
31
32 #include "AdvancedFunctions0D.h"
33
34 #include "../view_map/Functions1D.h"
35
36 //
37 // Functions definitions
38 //
39 ///////////////////////////////////////////////////////////
40
41 namespace Freestyle {
42
43 namespace Functions1D {
44
45 // DensityF1D
46 /*! Returns the density evaluated for an Interface1D.
47  *  The density is evaluated for a set of points along the Interface1D (using the DensityF0D functor) with a
48  *  user-defined sampling and then integrated into a single value using a user-defined integration method.
49  */
50 class DensityF1D : public UnaryFunction1D<double>
51 {
52 private:
53         float _sampling;
54
55 public:
56         /*! Builds the functor.
57          *  \param sigma
58          *    Thesigma used in DensityF0D and determining the window size used in each density query.
59          *  \param iType
60          *    The integration method used to compute a single value from a set of values.
61          *  \param sampling
62          *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
63          *    the result is obtained by combining the resulting values into a single one, following the method specified
64          *    by iType.
65          */
66         DensityF1D(double sigma = 2, IntegrationType iType = MEAN, float sampling = 2.0f)
67         : UnaryFunction1D<double>(iType), _fun(sigma)
68         {
69                 _sampling = sampling;
70         }
71
72         /*! Destructor */
73         virtual ~DensityF1D() {}
74
75         /*! Returns the string "DensityF1D"*/
76         string getName() const
77         {
78                 return "DensityF1D";
79         }
80
81         /*! the () operator.*/
82         int operator()(Interface1D& inter)
83         {
84                 result = integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
85                 return 0;
86         }
87
88 private:
89         Functions0D::DensityF0D _fun;
90 };
91
92 // LocalAverageDepthF1D
93 /*! Returns the average depth evaluated for an Interface1D.
94  *  The average depth is evaluated for a set of points along the Interface1D (using the LocalAverageDepthF0D functor)
95  *  with a user-defined sampling and then integrated into a single value using a user-defined integration method.
96  */
97 class LocalAverageDepthF1D : public UnaryFunction1D<double>
98 {
99 public:
100         /*! Builds the functor.
101          *  \param sigma
102          *    The sigma used in DensityF0D and determining the window size used in each density query.
103          *  \param iType
104          *    The integration method used to compute a single value from a set of values.
105          */
106         LocalAverageDepthF1D(real sigma, IntegrationType iType = MEAN)
107         : UnaryFunction1D<double>(iType), _fun(sigma)
108         {
109         }
110
111         /*! Returns the string "LocalAverageDepthF1D" */
112         string getName() const
113         {
114                 return "LocalAverageDepthF1D";
115         }
116
117         /*! the () operator. */
118         int operator()(Interface1D& inter)
119         {
120                 result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
121                 return 0;
122         }
123
124 private:
125         Functions0D::LocalAverageDepthF0D _fun;
126 };
127
128 // GetCompleteViewMapDensity
129 /*! Returns the density evaluated for an Interface1D in the complete viewmap image.
130  *  The density is evaluated for a set of points along the Interface1D (using the ReadCompleteViewMapPixelF0D functor)
131  *  and then integrated into a single value using a user-defined integration method.
132  */
133 class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double>
134 {
135 public:
136         /*! Builds the functor.
137          *  \param level
138          *    The level of the pyramid from which 
139          *    the pixel must be read.
140          *  \param iType
141          *    The integration method used to compute
142          *    a single value from a set of values.
143          *  \param sampling
144          *    The resolution used to sample the chain: the corresponding 0D function
145          *    is evaluated at each sample point and the result is obtained by
146          *    combining the resulting values into a single one, following the
147          *    method specified by iType.
148          */
149         GetCompleteViewMapDensityF1D(unsigned level, IntegrationType iType = MEAN, float sampling = 2.0f)
150         : UnaryFunction1D<double>(iType), _fun(level)
151         {
152                 _sampling = sampling;
153         }
154
155         /*! Returns the string "GetCompleteViewMapDensityF1D" */
156         string getName() const
157         {
158                 return "GetCompleteViewMapDensityF1D";
159         }
160
161         /*! the () operator. */
162         int operator()(Interface1D& inter);
163
164 private:
165         Functions0D::ReadCompleteViewMapPixelF0D _fun;
166         float _sampling;
167 };
168
169 // GetDirectionalViewMapDensity
170 /*! Returns the density evaluated for an Interface1D in of the steerable viewmaps image.
171  *  The direction telling which Directional map to choose is explicitely specified by the user.
172  *  The density is evaluated for a set of points along the Interface1D (using the ReadSteerableViewMapPixelF0D functor)
173  *  and then integrated into a single value using a user-defined integration method.
174  */
175 class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double>
176 {
177 public:
178         /*! Builds the functor.
179          *  \param iOrientation
180          *    The number of the directional map we must work with.
181          *  \param level
182          *    The level of the pyramid from which the pixel must be read.
183          *  \param iType
184          *    The integration method used to compute a single value from a set of values.
185          *  \param sampling
186          *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
187          *    the result is obtained by combining the resulting values into a single one, following the method specified
188          *    by iType.
189          */
190         GetDirectionalViewMapDensityF1D(unsigned iOrientation, unsigned level, IntegrationType iType = MEAN,
191                                         float sampling = 2.0f)
192         : UnaryFunction1D<double>(iType), _fun(iOrientation, level)
193         {
194                 _sampling = sampling;
195         }
196
197         /*! Returns the string "GetDirectionalViewMapDensityF1D" */
198         string getName() const
199         {
200                 return "GetDirectionalViewMapDensityF1D";
201         }
202
203         /*! the () operator. */
204         int operator()(Interface1D& inter);
205
206 private:
207         Functions0D::ReadSteerableViewMapPixelF0D _fun;
208         float _sampling;
209 };
210
211 // GetSteerableViewMapDensityF1D
212 /*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is evaluated
213  *  in the proper steerable ViewMap depending on its oorientation.
214  */
215 class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double>
216 {
217 private:
218         int _level;
219         float _sampling;
220
221 public:
222         /*! Builds the functor from the level of the pyramid from which the pixel must be read.
223          *  \param level
224          *    The level of the pyramid from which the pixel must be read.
225          *  \param iType
226          *    The integration method used to compute a single value from a set of values.
227          *  \param sampling
228          *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
229          *    the result is obtained by combining the resulting values into a single one, following the method specified
230          *    by iType.
231          */
232         GetSteerableViewMapDensityF1D(int level, IntegrationType iType = MEAN, float sampling = 2.0f)
233         : UnaryFunction1D<double>(iType)
234         {
235                 _level = level;
236                 _sampling = sampling;
237         }
238
239         /*! Destructor */
240         virtual ~GetSteerableViewMapDensityF1D() {}
241
242         /*! Returns the string "GetSteerableViewMapDensityF1D" */
243         string getName() const
244         {
245                 return "GetSteerableViewMapDensityF1D";
246         }
247
248         /*! the () operator. */
249         int operator()(Interface1D& inter);
250 };
251
252 // GetViewMapGradientNormF1D
253 /*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is evaluated in
254  *  the proper steerable ViewMap depending on its oorientation.
255  */
256 class GetViewMapGradientNormF1D : public UnaryFunction1D<double>
257 {
258 private:
259         int _level;
260         float _sampling;
261         Functions0D::GetViewMapGradientNormF0D _func;
262
263 public:
264         /*! Builds the functor from the level of the pyramid from which the pixel must be read.
265          *  \param level
266          *    The level of the pyramid from which the pixel must be read.
267          *  \param iType
268          *    The integration method used to compute a single value from a set of values.
269          *  \param sampling
270          *    The resolution used to sample the chain: the corresponding 0D function is evaluated at each sample point and
271          *    the result is obtained by combining the resulting values into a single one, following the method specified
272          *    by iType.
273          */
274         GetViewMapGradientNormF1D(int level, IntegrationType iType = MEAN, float sampling = 2.0f)
275         : UnaryFunction1D<double>(iType), _func(level)
276         {
277                 _level = level;
278                 _sampling = sampling;
279         }
280
281         /*! Returns the string "GetSteerableViewMapDensityF1D" */
282         string getName() const
283         {
284                 return "GetViewMapGradientNormF1D";
285         }
286
287         /*! the () operator. */
288         int operator()(Interface1D& inter);
289 };
290
291 } // end of namespace Functions1D
292
293 } /* namespace Freestyle */
294
295 #endif // __FREESTYLE_ADVANCED_FUNCTIONS_1D_H__