Blender  V3.3
math_interp.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2012 Blender Foundation. All rights reserved. */
3 
8 #include <math.h>
9 
10 #include "BLI_math.h"
11 
12 #include "BLI_strict_flags.h"
13 
14 /**************************************************************************
15  * INTERPOLATIONS
16  *
17  * Reference and docs:
18  * http://wiki.blender.org/index.php/User:Damiles#Interpolations_Algorithms
19  ***************************************************************************/
20 
21 /* BICUBIC Interpolation functions
22  * More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
23  * function assumes out to be zero'ed, only does RGBA */
24 
25 static float P(float k)
26 {
27  float p1, p2, p3, p4;
28  p1 = max_ff(k + 2.0f, 0.0f);
29  p2 = max_ff(k + 1.0f, 0.0f);
30  p3 = max_ff(k, 0.0f);
31  p4 = max_ff(k - 1.0f, 0.0f);
32  return (float)(1.0f / 6.0f) *
33  (p1 * p1 * p1 - 4.0f * p2 * p2 * p2 + 6.0f * p3 * p3 * p3 - 4.0f * p4 * p4 * p4);
34 }
35 
36 #if 0
37 /* older, slower function, works the same as above */
38 static float P(float k)
39 {
40  return (float)(1.0f / 6.0f) *
41  (pow(MAX2(k + 2.0f, 0), 3.0f) - 4.0f * pow(MAX2(k + 1.0f, 0), 3.0f) +
42  6.0f * pow(MAX2(k, 0), 3.0f) - 4.0f * pow(MAX2(k - 1.0f, 0), 3.0f));
43 }
44 #endif
45 
46 static void vector_from_float(const float *data, float vector[4], int components)
47 {
48  if (components == 1) {
49  vector[0] = data[0];
50  }
51  else if (components == 3) {
53  }
54  else {
56  }
57 }
58 
59 static void vector_from_byte(const unsigned char *data, float vector[4], int components)
60 {
61  if (components == 1) {
62  vector[0] = data[0];
63  }
64  else if (components == 3) {
65  vector[0] = data[0];
66  vector[1] = data[1];
67  vector[2] = data[2];
68  }
69  else {
70  vector[0] = data[0];
71  vector[1] = data[1];
72  vector[2] = data[2];
73  vector[3] = data[3];
74  }
75 }
76 
77 /* BICUBIC INTERPOLATION */
78 BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer,
79  const float *float_buffer,
80  unsigned char *byte_output,
81  float *float_output,
82  int width,
83  int height,
84  int components,
85  float u,
86  float v)
87 {
88  int i, j, n, m, x1, y1;
89  float a, b, w, wx, wy[4], out[4];
90 
91  /* sample area entirely outside image? */
92  if (ceil(u) < 0 || floor(u) > width - 1 || ceil(v) < 0 || floor(v) > height - 1) {
93  if (float_output) {
94  copy_vn_fl(float_output, components, 0.0f);
95  }
96  if (byte_output) {
97  copy_vn_uchar(byte_output, components, 0);
98  }
99  return;
100  }
101 
102  i = (int)floor(u);
103  j = (int)floor(v);
104  a = u - (float)i;
105  b = v - (float)j;
106 
107  zero_v4(out);
108 
109  /* Optimized and not so easy to read */
110 
111  /* avoid calling multiple times */
112  wy[0] = P(b - (-1));
113  wy[1] = P(b - 0);
114  wy[2] = P(b - 1);
115  wy[3] = P(b - 2);
116 
117  for (n = -1; n <= 2; n++) {
118  x1 = i + n;
119  CLAMP(x1, 0, width - 1);
120  wx = P((float)n - a);
121  for (m = -1; m <= 2; m++) {
122  float data[4];
123 
124  y1 = j + m;
125  CLAMP(y1, 0, height - 1);
126  /* Normally we could do this:
127  * `w = P(n-a) * P(b-m);`
128  * except that would call `P()` 16 times per pixel therefor `pow()` 64 times,
129  * better pre-calculate these. */
130  w = wx * wy[m + 1];
131 
132  if (float_output) {
133  const float *float_data = float_buffer + width * y1 * components + components * x1;
134 
135  vector_from_float(float_data, data, components);
136  }
137  else {
138  const unsigned char *byte_data = byte_buffer + width * y1 * components + components * x1;
139 
140  vector_from_byte(byte_data, data, components);
141  }
142 
143  if (components == 1) {
144  out[0] += data[0] * w;
145  }
146  else if (components == 3) {
147  out[0] += data[0] * w;
148  out[1] += data[1] * w;
149  out[2] += data[2] * w;
150  }
151  else {
152  out[0] += data[0] * w;
153  out[1] += data[1] * w;
154  out[2] += data[2] * w;
155  out[3] += data[3] * w;
156  }
157  }
158  }
159 
160  /* Done with optimized part */
161 
162 #if 0
163  /* older, slower function, works the same as above */
164  for (n = -1; n <= 2; n++) {
165  for (m = -1; m <= 2; m++) {
166  x1 = i + n;
167  y1 = j + m;
168  if (x1 > 0 && x1 < width && y1 > 0 && y1 < height) {
169  float data[4];
170 
171  if (float_output) {
172  const float *float_data = float_buffer + width * y1 * components + components * x1;
173 
174  vector_from_float(float_data, data, components);
175  }
176  else {
177  const unsigned char *byte_data = byte_buffer + width * y1 * components + components * x1;
178 
179  vector_from_byte(byte_data, data, components);
180  }
181 
182  if (components == 1) {
183  out[0] += data[0] * P(n - a) * P(b - m);
184  }
185  else if (components == 3) {
186  out[0] += data[0] * P(n - a) * P(b - m);
187  out[1] += data[1] * P(n - a) * P(b - m);
188  out[2] += data[2] * P(n - a) * P(b - m);
189  }
190  else {
191  out[0] += data[0] * P(n - a) * P(b - m);
192  out[1] += data[1] * P(n - a) * P(b - m);
193  out[2] += data[2] * P(n - a) * P(b - m);
194  out[3] += data[3] * P(n - a) * P(b - m);
195  }
196  }
197  }
198  }
199 #endif
200 
201  if (float_output) {
202  if (components == 1) {
203  float_output[0] = out[0];
204  }
205  else if (components == 3) {
206  copy_v3_v3(float_output, out);
207  }
208  else {
209  copy_v4_v4(float_output, out);
210  }
211  }
212  else {
213  if (components == 1) {
214  byte_output[0] = (unsigned char)(out[0] + 0.5f);
215  }
216  else if (components == 3) {
217  byte_output[0] = (unsigned char)(out[0] + 0.5f);
218  byte_output[1] = (unsigned char)(out[1] + 0.5f);
219  byte_output[2] = (unsigned char)(out[2] + 0.5f);
220  }
221  else {
222  byte_output[0] = (unsigned char)(out[0] + 0.5f);
223  byte_output[1] = (unsigned char)(out[1] + 0.5f);
224  byte_output[2] = (unsigned char)(out[2] + 0.5f);
225  byte_output[3] = (unsigned char)(out[3] + 0.5f);
226  }
227  }
228 }
229 
231  const float *buffer, float *output, int width, int height, int components, float u, float v)
232 {
233  bicubic_interpolation(NULL, buffer, NULL, output, width, height, components, u, v);
234 }
235 
236 void BLI_bicubic_interpolation_char(const unsigned char *buffer,
237  unsigned char *output,
238  int width,
239  int height,
240  int components,
241  float u,
242  float v)
243 {
244  bicubic_interpolation(buffer, NULL, output, NULL, width, height, components, u, v);
245 }
246 
247 /* BILINEAR INTERPOLATION */
248 BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer,
249  const float *float_buffer,
250  unsigned char *byte_output,
251  float *float_output,
252  int width,
253  int height,
254  int components,
255  float u,
256  float v,
257  bool wrap_x,
258  bool wrap_y)
259 {
260  float a, b;
261  float a_b, ma_b, a_mb, ma_mb;
262  int y1, y2, x1, x2;
263 
264  /* ImBuf in must have a valid rect or rect_float, assume this is already checked */
265 
266  x1 = (int)floor(u);
267  x2 = (int)ceil(u);
268  y1 = (int)floor(v);
269  y2 = (int)ceil(v);
270 
271  if (float_output) {
272  const float *row1, *row2, *row3, *row4;
273  const float empty[4] = {0.0f, 0.0f, 0.0f, 0.0f};
274 
275  /* pixel value must be already wrapped, however values at boundaries may flip */
276  if (wrap_x) {
277  if (x1 < 0) {
278  x1 = width - 1;
279  }
280  if (x2 >= width) {
281  x2 = 0;
282  }
283  }
284  else if (x2 < 0 || x1 >= width) {
285  copy_vn_fl(float_output, components, 0.0f);
286  return;
287  }
288 
289  if (wrap_y) {
290  if (y1 < 0) {
291  y1 = height - 1;
292  }
293  if (y2 >= height) {
294  y2 = 0;
295  }
296  }
297  else if (y2 < 0 || y1 >= height) {
298  copy_vn_fl(float_output, components, 0.0f);
299  return;
300  }
301 
302  /* sample including outside of edges of image */
303  if (x1 < 0 || y1 < 0) {
304  row1 = empty;
305  }
306  else {
307  row1 = float_buffer + width * y1 * components + components * x1;
308  }
309 
310  if (x1 < 0 || y2 > height - 1) {
311  row2 = empty;
312  }
313  else {
314  row2 = float_buffer + width * y2 * components + components * x1;
315  }
316 
317  if (x2 > width - 1 || y1 < 0) {
318  row3 = empty;
319  }
320  else {
321  row3 = float_buffer + width * y1 * components + components * x2;
322  }
323 
324  if (x2 > width - 1 || y2 > height - 1) {
325  row4 = empty;
326  }
327  else {
328  row4 = float_buffer + width * y2 * components + components * x2;
329  }
330 
331  a = u - floorf(u);
332  b = v - floorf(v);
333  a_b = a * b;
334  ma_b = (1.0f - a) * b;
335  a_mb = a * (1.0f - b);
336  ma_mb = (1.0f - a) * (1.0f - b);
337 
338  if (components == 1) {
339  float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
340  }
341  else if (components == 3) {
342  float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
343  float_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
344  float_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
345  }
346  else {
347  float_output[0] = ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] + a_b * row4[0];
348  float_output[1] = ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] + a_b * row4[1];
349  float_output[2] = ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] + a_b * row4[2];
350  float_output[3] = ma_mb * row1[3] + a_mb * row3[3] + ma_b * row2[3] + a_b * row4[3];
351  }
352  }
353  else {
354  const unsigned char *row1, *row2, *row3, *row4;
355  unsigned char empty[4] = {0, 0, 0, 0};
356 
357  /* pixel value must be already wrapped, however values at boundaries may flip */
358  if (wrap_x) {
359  if (x1 < 0) {
360  x1 = width - 1;
361  }
362  if (x2 >= width) {
363  x2 = 0;
364  }
365  }
366  else if (x2 < 0 || x1 >= width) {
367  copy_vn_uchar(byte_output, components, 0);
368  return;
369  }
370 
371  if (wrap_y) {
372  if (y1 < 0) {
373  y1 = height - 1;
374  }
375  if (y2 >= height) {
376  y2 = 0;
377  }
378  }
379  else if (y2 < 0 || y1 >= height) {
380  copy_vn_uchar(byte_output, components, 0);
381  return;
382  }
383 
384  /* sample including outside of edges of image */
385  if (x1 < 0 || y1 < 0) {
386  row1 = empty;
387  }
388  else {
389  row1 = byte_buffer + width * y1 * components + components * x1;
390  }
391 
392  if (x1 < 0 || y2 > height - 1) {
393  row2 = empty;
394  }
395  else {
396  row2 = byte_buffer + width * y2 * components + components * x1;
397  }
398 
399  if (x2 > width - 1 || y1 < 0) {
400  row3 = empty;
401  }
402  else {
403  row3 = byte_buffer + width * y1 * components + components * x2;
404  }
405 
406  if (x2 > width - 1 || y2 > height - 1) {
407  row4 = empty;
408  }
409  else {
410  row4 = byte_buffer + width * y2 * components + components * x2;
411  }
412 
413  a = u - floorf(u);
414  b = v - floorf(v);
415  a_b = a * b;
416  ma_b = (1.0f - a) * b;
417  a_mb = a * (1.0f - b);
418  ma_mb = (1.0f - a) * (1.0f - b);
419 
420  if (components == 1) {
421  byte_output[0] = (unsigned char)(ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] +
422  a_b * row4[0] + 0.5f);
423  }
424  else if (components == 3) {
425  byte_output[0] = (unsigned char)(ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] +
426  a_b * row4[0] + 0.5f);
427  byte_output[1] = (unsigned char)(ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] +
428  a_b * row4[1] + 0.5f);
429  byte_output[2] = (unsigned char)(ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] +
430  a_b * row4[2] + 0.5f);
431  }
432  else {
433  byte_output[0] = (unsigned char)(ma_mb * row1[0] + a_mb * row3[0] + ma_b * row2[0] +
434  a_b * row4[0] + 0.5f);
435  byte_output[1] = (unsigned char)(ma_mb * row1[1] + a_mb * row3[1] + ma_b * row2[1] +
436  a_b * row4[1] + 0.5f);
437  byte_output[2] = (unsigned char)(ma_mb * row1[2] + a_mb * row3[2] + ma_b * row2[2] +
438  a_b * row4[2] + 0.5f);
439  byte_output[3] = (unsigned char)(ma_mb * row1[3] + a_mb * row3[3] + ma_b * row2[3] +
440  a_b * row4[3] + 0.5f);
441  }
442  }
443 }
444 
446  const float *buffer, float *output, int width, int height, int components, float u, float v)
447 {
449  NULL, buffer, NULL, output, width, height, components, u, v, false, false);
450 }
451 
452 void BLI_bilinear_interpolation_char(const unsigned char *buffer,
453  unsigned char *output,
454  int width,
455  int height,
456  int components,
457  float u,
458  float v)
459 {
461  buffer, NULL, output, NULL, width, height, components, u, v, false, false);
462 }
463 
465  float *output,
466  int width,
467  int height,
468  int components,
469  float u,
470  float v,
471  bool wrap_x,
472  bool wrap_y)
473 {
475  NULL, buffer, NULL, output, width, height, components, u, v, wrap_x, wrap_y);
476 }
477 
479  unsigned char *output,
480  int width,
481  int height,
482  int components,
483  float u,
484  float v,
485  bool wrap_x,
486  bool wrap_y)
487 {
489  buffer, NULL, output, NULL, width, height, components, u, v, wrap_x, wrap_y);
490 }
491 
492 /**************************************************************************
493  * Filtering method based on
494  * "Creating raster omnimax images from multiple perspective views
495  * using the elliptical weighted average filter"
496  * by Ned Greene and Paul S. Heckbert (1986)
497  ***************************************************************************/
498 
499 /* Table of (exp(ar) - exp(a)) / (1 - exp(a)) for r in range [0, 1] and a = -2
500  * used instead of actual gaussian,
501  * otherwise at high texture magnifications circular artifacts are visible. */
502 #define EWA_MAXIDX 255
503 const float EWA_WTS[EWA_MAXIDX + 1] = {
504  1.0f, 0.990965f, 0.982f, 0.973105f, 0.96428f, 0.955524f, 0.946836f,
505  0.938216f, 0.929664f, 0.921178f, 0.912759f, 0.904405f, 0.896117f, 0.887893f,
506  0.879734f, 0.871638f, 0.863605f, 0.855636f, 0.847728f, 0.839883f, 0.832098f,
507  0.824375f, 0.816712f, 0.809108f, 0.801564f, 0.794079f, 0.786653f, 0.779284f,
508  0.771974f, 0.76472f, 0.757523f, 0.750382f, 0.743297f, 0.736267f, 0.729292f,
509  0.722372f, 0.715505f, 0.708693f, 0.701933f, 0.695227f, 0.688572f, 0.68197f,
510  0.67542f, 0.66892f, 0.662471f, 0.656073f, 0.649725f, 0.643426f, 0.637176f,
511  0.630976f, 0.624824f, 0.618719f, 0.612663f, 0.606654f, 0.600691f, 0.594776f,
512  0.588906f, 0.583083f, 0.577305f, 0.571572f, 0.565883f, 0.56024f, 0.55464f,
513  0.549084f, 0.543572f, 0.538102f, 0.532676f, 0.527291f, 0.521949f, 0.516649f,
514  0.511389f, 0.506171f, 0.500994f, 0.495857f, 0.490761f, 0.485704f, 0.480687f,
515  0.475709f, 0.470769f, 0.465869f, 0.461006f, 0.456182f, 0.451395f, 0.446646f,
516  0.441934f, 0.437258f, 0.432619f, 0.428017f, 0.42345f, 0.418919f, 0.414424f,
517  0.409963f, 0.405538f, 0.401147f, 0.39679f, 0.392467f, 0.388178f, 0.383923f,
518  0.379701f, 0.375511f, 0.371355f, 0.367231f, 0.363139f, 0.359079f, 0.355051f,
519  0.351055f, 0.347089f, 0.343155f, 0.339251f, 0.335378f, 0.331535f, 0.327722f,
520  0.323939f, 0.320186f, 0.316461f, 0.312766f, 0.3091f, 0.305462f, 0.301853f,
521  0.298272f, 0.294719f, 0.291194f, 0.287696f, 0.284226f, 0.280782f, 0.277366f,
522  0.273976f, 0.270613f, 0.267276f, 0.263965f, 0.26068f, 0.257421f, 0.254187f,
523  0.250979f, 0.247795f, 0.244636f, 0.241502f, 0.238393f, 0.235308f, 0.232246f,
524  0.229209f, 0.226196f, 0.223206f, 0.220239f, 0.217296f, 0.214375f, 0.211478f,
525  0.208603f, 0.20575f, 0.20292f, 0.200112f, 0.197326f, 0.194562f, 0.191819f,
526  0.189097f, 0.186397f, 0.183718f, 0.18106f, 0.178423f, 0.175806f, 0.17321f,
527  0.170634f, 0.168078f, 0.165542f, 0.163026f, 0.16053f, 0.158053f, 0.155595f,
528  0.153157f, 0.150738f, 0.148337f, 0.145955f, 0.143592f, 0.141248f, 0.138921f,
529  0.136613f, 0.134323f, 0.132051f, 0.129797f, 0.12756f, 0.125341f, 0.123139f,
530  0.120954f, 0.118786f, 0.116635f, 0.114501f, 0.112384f, 0.110283f, 0.108199f,
531  0.106131f, 0.104079f, 0.102043f, 0.100023f, 0.0980186f, 0.09603f, 0.094057f,
532  0.0920994f, 0.0901571f, 0.08823f, 0.0863179f, 0.0844208f, 0.0825384f, 0.0806708f,
533  0.0788178f, 0.0769792f, 0.0751551f, 0.0733451f, 0.0715493f, 0.0697676f, 0.0679997f,
534  0.0662457f, 0.0645054f, 0.0627786f, 0.0610654f, 0.0593655f, 0.0576789f, 0.0560055f,
535  0.0543452f, 0.0526979f, 0.0510634f, 0.0494416f, 0.0478326f, 0.0462361f, 0.0446521f,
536  0.0430805f, 0.0415211f, 0.039974f, 0.0384389f, 0.0369158f, 0.0354046f, 0.0339052f,
537  0.0324175f, 0.0309415f, 0.029477f, 0.0280239f, 0.0265822f, 0.0251517f, 0.0237324f,
538  0.0223242f, 0.020927f, 0.0195408f, 0.0181653f, 0.0168006f, 0.0154466f, 0.0141031f,
539  0.0127701f, 0.0114476f, 0.0101354f, 0.00883339f, 0.00754159f, 0.00625989f, 0.00498819f,
540  0.00372644f, 0.00247454f, 0.00123242f, 0.0f,
541 };
542 
543 static void radangle2imp(float a2, float b2, float th, float *A, float *B, float *C, float *F)
544 {
545  float ct2 = cosf(th);
546  const float st2 = 1.0f - ct2 * ct2; /* <- sin(th)^2 */
547  ct2 *= ct2;
548  *A = a2 * st2 + b2 * ct2;
549  *B = (b2 - a2) * sinf(2.0f * th);
550  *C = a2 * ct2 + b2 * st2;
551  *F = a2 * b2;
552 }
553 
555  float A, float B, float C, float F, float *a, float *b, float *th, float *ecc)
556 {
557  /* NOTE: all tests here are done to make sure possible overflows are hopefully minimized. */
558 
559  if (F <= 1e-5f) { /* use arbitrary major radius, zero minor, infinite eccentricity */
560  *a = sqrtf(A > C ? A : C);
561  *b = 0.0f;
562  *ecc = 1e10f;
563  *th = 0.5f * (atan2f(B, A - C) + (float)M_PI);
564  }
565  else {
566  const float AmC = A - C, ApC = A + C, F2 = F * 2.0f;
567  const float r = sqrtf(AmC * AmC + B * B);
568  float d = ApC - r;
569  *a = (d <= 0.0f) ? sqrtf(A > C ? A : C) : sqrtf(F2 / d);
570  d = ApC + r;
571  if (d <= 0.0f) {
572  *b = 0.0f;
573  *ecc = 1e10f;
574  }
575  else {
576  *b = sqrtf(F2 / d);
577  *ecc = *a / *b;
578  }
579  /* incr theta by 0.5*pi (angle of major axis) */
580  *th = 0.5f * (atan2f(B, AmC) + (float)M_PI);
581  }
582 }
583 
584 void BLI_ewa_filter(const int width,
585  const int height,
586  const bool intpol,
587  const bool use_alpha,
588  const float uv[2],
589  const float du[2],
590  const float dv[2],
591  ewa_filter_read_pixel_cb read_pixel_cb,
592  void *userdata,
593  float result[4])
594 {
595  /* scaling dxt/dyt by full resolution can cause overflow because of huge A/B/C and esp. F values,
596  * scaling by aspect ratio alone does the opposite, so try something in between instead... */
597  const float ff2 = (float)width, ff = sqrtf(ff2), q = (float)height / ff;
598  const float Ux = du[0] * ff, Vx = du[1] * q, Uy = dv[0] * ff, Vy = dv[1] * q;
599  float A = Vx * Vx + Vy * Vy;
600  float B = -2.0f * (Ux * Vx + Uy * Vy);
601  float C = Ux * Ux + Uy * Uy;
602  float F = A * C - B * B * 0.25f;
603  float a, b, th, ecc, a2, b2, ue, ve, U0, V0, DDQ, U, ac1, ac2, BU, d;
604  int u, v, u1, u2, v1, v2;
605 
606  /* The so-called 'high' quality ewa method simply adds a constant of 1 to both A & C,
607  * so the ellipse always covers at least some texels. But since the filter is now always larger,
608  * it also means that everywhere else it's also more blurry then ideally should be the case.
609  * So instead here the ellipse radii are modified instead whenever either is too low.
610  * Use a different radius based on interpolation switch,
611  * just enough to anti-alias when interpolation is off,
612  * and slightly larger to make result a bit smoother than bilinear interpolation when
613  * interpolation is on (minimum values: `const float rmin = intpol ? 1.0f : 0.5f;`) */
614  const float rmin = (intpol ? 1.5625f : 0.765625f) / ff2;
615  BLI_ewa_imp2radangle(A, B, C, F, &a, &b, &th, &ecc);
616  if ((b2 = b * b) < rmin) {
617  if ((a2 = a * a) < rmin) {
618  B = 0.0f;
619  A = C = rmin;
620  F = A * C;
621  }
622  else {
623  b2 = rmin;
624  radangle2imp(a2, b2, th, &A, &B, &C, &F);
625  }
626  }
627 
628  ue = ff * sqrtf(C);
629  ve = ff * sqrtf(A);
630  d = (float)(EWA_MAXIDX + 1) / (F * ff2);
631  A *= d;
632  B *= d;
633  C *= d;
634 
635  U0 = uv[0] * (float)width;
636  V0 = uv[1] * (float)height;
637  u1 = (int)(floorf(U0 - ue));
638  u2 = (int)(ceilf(U0 + ue));
639  v1 = (int)(floorf(V0 - ve));
640  v2 = (int)(ceilf(V0 + ve));
641 
642  /* sane clamping to avoid unnecessarily huge loops */
643  /* NOTE: if eccentricity gets clamped (see above),
644  * the ue/ve limits can also be lowered accordingly
645  */
646  if (U0 - (float)u1 > EWA_MAXIDX) {
647  u1 = (int)U0 - EWA_MAXIDX;
648  }
649  if ((float)u2 - U0 > EWA_MAXIDX) {
650  u2 = (int)U0 + EWA_MAXIDX;
651  }
652  if (V0 - (float)v1 > EWA_MAXIDX) {
653  v1 = (int)V0 - EWA_MAXIDX;
654  }
655  if ((float)v2 - V0 > EWA_MAXIDX) {
656  v2 = (int)V0 + EWA_MAXIDX;
657  }
658 
659  /* Early output check for cases the whole region is outside of the buffer. */
660  if ((u2 < 0 || u1 >= width) || (v2 < 0 || v1 >= height)) {
661  zero_v4(result);
662  return;
663  }
664 
665  U0 -= 0.5f;
666  V0 -= 0.5f;
667  DDQ = 2.0f * A;
668  U = (float)u1 - U0;
669  ac1 = A * (2.0f * U + 1.0f);
670  ac2 = A * U * U;
671  BU = B * U;
672 
673  d = 0.0f;
674  zero_v4(result);
675  for (v = v1; v <= v2; v++) {
676  const float V = (float)v - V0;
677  float DQ = ac1 + B * V;
678  float Q = (C * V + BU) * V + ac2;
679  for (u = u1; u <= u2; u++) {
680  if (Q < (float)(EWA_MAXIDX + 1)) {
681  float tc[4];
682  const float wt = EWA_WTS[(Q < 0.0f) ? 0 : (unsigned int)Q];
683  read_pixel_cb(userdata, u, v, tc);
684  madd_v3_v3fl(result, tc, wt);
685  result[3] += use_alpha ? tc[3] * wt : 0.0f;
686  d += wt;
687  }
688  Q += DQ;
689  DQ += DDQ;
690  }
691  }
692 
693  /* `d` should hopefully never be zero anymore. */
694  d = 1.0f / d;
695  mul_v3_fl(result, d);
696  /* Clipping can be ignored if alpha used, `texr->trgba[3]` already includes filtered edge. */
697  result[3] = use_alpha ? result[3] * d : 1.0f;
698 }
typedef float(TangentPoint)[2]
#define BLI_INLINE
MINLINE float max_ff(float a, float b)
#define M_PI
Definition: BLI_math_base.h:20
void(* ewa_filter_read_pixel_cb)(void *userdata, int x, int y, float result[4])
MINLINE void copy_v4_v4(float r[4], const float a[4])
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void copy_vn_fl(float *array_tar, int size, float val)
Definition: math_vector.c:1259
MINLINE void zero_v4(float r[4])
void copy_vn_uchar(unsigned char *array_tar, int size, unsigned char val)
Definition: math_vector.c:1250
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
#define MAX2(a, b)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble y1
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble GLdouble r _GL_VOID_RET _GL_VOID GLfloat GLfloat r _GL_VOID_RET _GL_VOID GLint GLint r _GL_VOID_RET _GL_VOID GLshort GLshort r _GL_VOID_RET _GL_VOID GLdouble GLdouble r
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble u2
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble u1
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei height
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble x2
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei width
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP
#define C
Definition: RandGen.cpp:25
#define U
ATTR_WARN_UNUSED_RESULT const BMVert * v2
ATTR_WARN_UNUSED_RESULT const BMVert * v
#define A
unsigned int U
Definition: btGjkEpa3.h:78
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition: btQuadWord.h:119
#define sinf(x)
Definition: cuda/compat.h:102
#define cosf(x)
Definition: cuda/compat.h:101
ccl_global float * buffer
ccl_global KernelShaderEvalInput ccl_global float * output
ccl_device_inline float3 ceil(const float3 &a)
Definition: math_float3.h:363
ccl_device_inline float3 pow(float3 v, float e)
Definition: math_float3.h:533
static void vector_from_float(const float *data, float vector[4], int components)
Definition: math_interp.c:46
void BLI_bilinear_interpolation_fl(const float *buffer, float *output, int width, int height, int components, float u, float v)
Definition: math_interp.c:445
BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const float *float_buffer, unsigned char *byte_output, float *float_output, int width, int height, int components, float u, float v, bool wrap_x, bool wrap_y)
Definition: math_interp.c:248
static void vector_from_byte(const unsigned char *data, float vector[4], int components)
Definition: math_interp.c:59
void BLI_bilinear_interpolation_wrap_fl(const float *buffer, float *output, int width, int height, int components, float u, float v, bool wrap_x, bool wrap_y)
Definition: math_interp.c:464
BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const float *float_buffer, unsigned char *byte_output, float *float_output, int width, int height, int components, float u, float v)
Definition: math_interp.c:78
void BLI_bicubic_interpolation_fl(const float *buffer, float *output, int width, int height, int components, float u, float v)
Definition: math_interp.c:230
#define EWA_MAXIDX
Definition: math_interp.c:502
static void radangle2imp(float a2, float b2, float th, float *A, float *B, float *C, float *F)
Definition: math_interp.c:543
const float EWA_WTS[EWA_MAXIDX+1]
Definition: math_interp.c:503
void BLI_ewa_filter(const int width, const int height, const bool intpol, const bool use_alpha, const float uv[2], const float du[2], const float dv[2], ewa_filter_read_pixel_cb read_pixel_cb, void *userdata, float result[4])
Definition: math_interp.c:584
static float P(float k)
Definition: math_interp.c:25
void BLI_bilinear_interpolation_wrap_char(const unsigned char *buffer, unsigned char *output, int width, int height, int components, float u, float v, bool wrap_x, bool wrap_y)
Definition: math_interp.c:478
void BLI_bicubic_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height, int components, float u, float v)
Definition: math_interp.c:236
void BLI_bilinear_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height, int components, float u, float v)
Definition: math_interp.c:452
void BLI_ewa_imp2radangle(float A, float B, float C, float F, float *a, float *b, float *th, float *ecc)
Definition: math_interp.c:554
#define B
#define F
#define atan2f(x, y)
Definition: metal/compat.h:227
#define ceilf(x)
Definition: metal/compat.h:225
#define floorf(x)
Definition: metal/compat.h:224
#define sqrtf(x)
Definition: metal/compat.h:243
static unsigned a[3]
Definition: RandGen.cpp:78
T floor(const T &a)
static const pxr::TfToken out("out", pxr::TfToken::Immortal)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
CCL_NAMESPACE_BEGIN struct Window V