Debian Codegraph @

src/python/PyImath/PyImathFunOperators.h

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 // clang-format off
7
8 #ifndef _PyImathFunOperators_h_
9 #define _PyImathFunOperators_h_
10
11 #include <ImathVec.h>
12 #include <ImathMatrixAlgo.h>
13 #include <ImathColorAlgo.h>
14 #include <ImathFun.h>
15 #include <cmath>
16
17 namespace PyImath {
18
19 template <class T>
20 struct rotationXYZWithUpDir_op
21 {
22 static IMATH_NAMESPACE::Vec3<T>
23 apply(const IMATH_NAMESPACE::Vec3<T> &from, const IMATH_NAMESPACE::Vec3<T> &to,
24 const IMATH_NAMESPACE::Vec3<T> &up)
25 {
26 IMATH_NAMESPACE::Vec3<T> retval;
27 IMATH_NAMESPACE::extractEulerXYZ(IMATH_NAMESPACE::rotationMatrixWithUpDir(from,to,up),retval);
28 return retval;
29 }
30 };
31
32 template <class T>
33 struct abs_op
34 {
35 static T
36 apply(T value)
37 {
38 return IMATH_NAMESPACE::abs<T>(value);
39 }
40 };
41
42 template <class T>
43 struct sign_op
44 {
45 static T
46 apply(T value)
47 {
48 return IMATH_NAMESPACE::sign<T>(value);
49 }
50 };
51
52 template <class T>
53 struct log_op
54 {
55 static T
56 apply(T value)
57 {
58 return ::log(value);
59 }
60 };
61
62 template <class T>
63 struct log10_op
64 {
65 static T
66 apply(T value)
67 {
68 return ::log10(value);
69 }
70 };
71
72 template <class T>
73 struct lerp_op
74 {
75 static T
76 apply(T a, T b, T t)
77 {
78 return IMATH_NAMESPACE::lerp<T>(a,b,t);
79 }
80 };
81
82 template <class T>
83 struct ulerp_op
84 {
85 static T
86 apply(T a, T b, T t)
87 {
88 return IMATH_NAMESPACE::ulerp<T>(a,b,t);
89 }
90 };
91
92 template <class T>
93 struct lerpfactor_op
94 {
95 static T
96 apply(T a, T b, T t)
97 {
98 return IMATH_NAMESPACE::lerpfactor<T>(a,b,t);
99 }
100 };
101
102 template <class T>
103 struct clamp_op
104 {
105 static T
106 apply(T value, T low, T high)
107 {
108 return IMATH_NAMESPACE::clamp<T>(value,low,high);
109 }
110 };
111
112 template <class T>
113 struct cmp_op
114 {
115 static T
116 apply(T value)
117 {
118 return IMATH_NAMESPACE::cmp<T>(value);
119 }
120 };
121
122 template <class T>
123 struct cmpt_op
124 {
125 static T
126 apply(T value)
127 {
128 return IMATH_NAMESPACE::cmpt<T>(value);
129 }
130 };
131
132 template <class T>
133 struct iszero_op
134 {
135 static T
136 apply(T value)
137 {
138 return IMATH_NAMESPACE::iszero<T>(value);
139 }
140 };
141
142 template <class T>
143 struct equal_op
144 {
145 static T
146 apply(T value)
147 {
148 return IMATH_NAMESPACE::equal<T>(value);
149 }
150 };
151
152 template <class T>
153 struct floor_op
154 {
155 static int
156 apply(T value)
157 {
158 return IMATH_NAMESPACE::floor<T>(value);
159 }
160 };
161
162 template <class T>
163 struct ceil_op
164 {
165 static int
166 apply(T value)
167 {
168 return IMATH_NAMESPACE::ceil<T>(value);
169 }
170 };
171
172 template <class T>
173 struct trunc_op
174 {
175 static int
176 apply(T value)
177 {
178 return IMATH_NAMESPACE::trunc<T>(value);
179 }
180 };
181
182 struct divs_op
183 {
184 static int
185 apply(int x, int y)
186 {
187 return IMATH_NAMESPACE::divs(x,y);
188 }
189 };
190
191 struct mods_op
192 {
193 static int
194 apply(int x, int y)
195 {
196 return IMATH_NAMESPACE::mods(x,y);
197 }
198 };
199
200 struct divp_op
201 {
202 static int
203 apply(int x, int y)
204 {
205 return IMATH_NAMESPACE::divp(x,y);
206 }
207 };
208
209 struct modp_op
210 {
211 static int
212 apply(int x, int y)
213 {
214 return IMATH_NAMESPACE::modp(x,y);
215 }
216 };
217
218 struct bias_op
219 {
220 static inline float
221 apply(float x, float b)
222 {
223 if (b != 0.5f)
224 {
225 static const float inverse_log_half = 1.0f / std::log(0.5f);
226 const float biasPow = std::log(b)*inverse_log_half;
227 return std::pow(x, biasPow);
228 }
229 return x;
230 }
231 };
232
233 struct gain_op
234 {
235 static inline float
236 apply(float x, float g)
237 {
238 if (x < 0.5f)
239 return 0.5f*bias_op::apply(2.0f*x, 1.0f - g);
240 else
241 return 1.0f - 0.5f*bias_op::apply(2.0f - 2.0f*x, 1.0f - g);
242 }
243 };
244
245 template <class T>
246 struct rgb2hsv_op
247 {
248 static inline IMATH_NAMESPACE::Vec3<T>
249 apply(const IMATH_NAMESPACE::Vec3<T> &rgb)
250 {
251 return IMATH_NAMESPACE::rgb2hsv(rgb);
252 }
253 };
254
255 template <class T>
256 struct hsv2rgb_op
257 {
258 static inline IMATH_NAMESPACE::Vec3<T>
259 apply(const IMATH_NAMESPACE::Vec3<T> &rgb)
260 {
261 return IMATH_NAMESPACE::hsv2rgb(rgb);
262 }
263 };
264
265 template <class T>
266 struct min_op
267 {
268 static inline T
269 apply(T x, T y)
270 {
271 return std::min(x,y);
272 }
273 };
274
275 template <class T>
276 struct max_op
277 {
278 static inline T
279 apply(T x, T y)
280 {
281 return std::max(x,y);
282 }
283 };
284
285 template <class T>
286 struct sin_op {
287 static inline T
288 apply(T theta)
289 {
290 return std::sin(theta);
291 }
292 };
293
294 template <class T>
295 struct cos_op {
296 static inline T
297 apply(T theta)
298 {
299 return std::cos(theta);
300 }
301 };
302
303 template <class T>
304 struct tan_op {
305 static inline T
306 apply(T theta)
307 {
308 return std::tan(theta);
309 }
310 };
311
312 template <class T>
313 struct asin_op {
314 static inline T
315 apply(T x)
316 {
317 return std::asin(x);
318 }
319 };
320
321 template <class T>
322 struct acos_op {
323 static inline T
324 apply(T x)
325 {
326 return std::acos(x);
327 }
328 };
329
330 template <class T>
331 struct atan_op {
332 static inline float
333 apply(T x)
334 {
335 return std::atan(x);
336 }
337 };
338
339 template <class T>
340 struct atan2_op {
341 static inline T
342 apply(T y, T x)
343 {
344 return std::atan2(y,x);
345 }
346 };
347
348 template <class T>
349 struct sqrt_op {
350 static inline T
351 apply(T x)
352 {
353 return std::sqrt(x);
354 }
355 };
356
357 template <class T>
358 struct pow_op {
359 static inline T
360 apply(T x, T y)
361 {
362 return std::pow(x,y);
363 }
364 };
365
366 template <class T>
367 struct exp_op
368 {
369 static inline T
370 apply(T x)
371 {
372 return std::exp(x);
373 }
374 };
375
376 template <class T>
377 struct sinh_op
378 {
379 static inline T
380 apply(T x)
381 {
382 return std::sinh(x);
383 }
384 };
385
386 template <class T>
387 struct cosh_op
388 {
389 static inline T
390 apply(T x)
391 {
392 return std::cosh(x);
393 }
394 };
395
396 } // namespace PyImath
397
398 #endif // _PyImathFunOperators_h_