Cleanup: add trailing commas
[blender.git] / source / blender / blenlib / intern / math_interp.c
index 67850463fe212874b5350b488c2c8954b10dc779..27b26ede7934a2b586e67ee7696e57ce94d558e9 100644 (file)
@@ -44,7 +44,7 @@
  ***************************************************************************/
 
 /* BICUBIC Interpolation functions
- *  More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
+ * More info: http://wiki.blender.org/index.php/User:Damiles#Bicubic_pixel_interpolation
  * function assumes out to be zero'ed, only does RGBA */
 
 static float P(float k)
@@ -112,10 +112,10 @@ BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const fl
        /* sample area entirely outside image? */
        if (ceil(u) < 0 || floor(u) > width - 1 || ceil(v) < 0 || floor(v) > height - 1) {
                if (float_output) {
-                       fill_vn_fl(float_output, components, 0.0f);
+                       copy_vn_fl(float_output, components, 0.0f);
                }
                if (byte_output) {
-                       fill_vn_uchar(byte_output, components, 0);
+                       copy_vn_uchar(byte_output, components, 0);
                }
                return;
        }
@@ -146,7 +146,8 @@ BLI_INLINE void bicubic_interpolation(const unsigned char *byte_buffer, const fl
                        CLAMP(y1, 0, height - 1);
                        /* normally we could do this */
                        /* w = P(n-a) * P(b-m); */
-                       /* except that would call P() 16 times per pixel therefor pow() 64 times, better precalc these */
+                       /* except that would call P() 16 times per pixel therefor pow() 64 times,
+                        * better precalc these */
                        w = wx * wy[m + 1];
 
                        if (float_output) {
@@ -262,7 +263,7 @@ void BLI_bicubic_interpolation_char(const unsigned char *buffer, unsigned char *
 /* BILINEAR INTERPOLATION */
 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)
+                                       int components, float u, float v, bool wrap_x, bool wrap_y)
 {
        float a, b;
        float a_b, ma_b, a_mb, ma_mb;
@@ -279,9 +280,22 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                const float *row1, *row2, *row3, *row4;
                float empty[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 
-               /* sample area entirely outside image? */
-               if (x2 < 0 || x1 > width - 1 || y2 < 0 || y1 > height - 1) {
-                       fill_vn_fl(float_output, components, 0.0f);
+               /* pixel value must be already wrapped, however values at boundaries may flip */
+               if (wrap_x) {
+                       if (x1 < 0) x1 = width  - 1;
+                       if (x2 >= width) x2 = 0;
+               }
+               else if (x2 < 0 || x1 >= width) {
+                       copy_vn_fl(float_output, components, 0.0f);
+                       return;
+               }
+
+               if (wrap_y) {
+                       if (y1 < 0) y1 = height - 1;
+                       if (y2 >= height) y2 = 0;
+               }
+               else if (y2 < 0 || y1 >= height) {
+                       copy_vn_fl(float_output, components, 0.0f);
                        return;
                }
 
@@ -321,9 +335,22 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
                const unsigned char *row1, *row2, *row3, *row4;
                unsigned char empty[4] = {0, 0, 0, 0};
 
-               /* sample area entirely outside image? */
-               if (x2 < 0 || x1 > width - 1 || y2 < 0 || y1 > height - 1) {
-                       fill_vn_uchar(byte_output, components, 0);
+               /* pixel value must be already wrapped, however values at boundaries may flip */
+               if (wrap_x) {
+                       if (x1 < 0) x1 = width  - 1;
+                       if (x2 >= width) x2 = 0;
+               }
+               else if (x2 < 0 || x1 >= width) {
+                       copy_vn_uchar(byte_output, components, 0);
+                       return;
+               }
+
+               if (wrap_y) {
+                       if (y1 < 0) y1 = height - 1;
+                       if (y2 >= height) y2 = 0;
+               }
+               else if (y2 < 0 || y1 >= height) {
+                       copy_vn_uchar(byte_output, components, 0);
                        return;
                }
 
@@ -364,18 +391,32 @@ BLI_INLINE void bilinear_interpolation(const unsigned char *byte_buffer, const f
 void BLI_bilinear_interpolation_fl(const float *buffer, float *output, int width, int height,
                                    int components, float u, float v)
 {
-       bilinear_interpolation(NULL, buffer, NULL, output, width, height, components, u, v);
+       bilinear_interpolation(NULL, buffer, NULL, output, width, height, components, u, v, false, false);
 }
 
 void BLI_bilinear_interpolation_char(const unsigned char *buffer, unsigned char *output, int width, int height,
                                      int components, float u, float v)
 {
-       bilinear_interpolation(buffer, NULL, output, NULL, width, height, components, u, v);
+       bilinear_interpolation(buffer, NULL, output, NULL, width, height, components, u, v, false, false);
+}
+
+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)
+{
+       bilinear_interpolation(NULL, buffer, NULL, output, width, height, components, u, v, wrap_x, wrap_y);
 }
 
+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)
+{
+       bilinear_interpolation(buffer, NULL, output, NULL, width, height, components, u, v, wrap_x, wrap_y);
+}
+
+
 /**************************************************************************
  * Filtering method based on
- * "Creating raster omnimax images from multiple perspective views using the elliptical weighted average filter"
+ * "Creating raster omnimax images from multiple perspective views
+ * using the elliptical weighted average filter"
  * by Ned Greene and Paul S. Heckbert (1986)
  ***************************************************************************/
 
@@ -414,7 +455,7 @@ const float EWA_WTS[EWA_MAXIDX + 1] = {
        0.0415211f, 0.039974f, 0.0384389f, 0.0369158f, 0.0354046f, 0.0339052f, 0.0324175f, 0.0309415f,
        0.029477f, 0.0280239f, 0.0265822f, 0.0251517f, 0.0237324f, 0.0223242f, 0.020927f, 0.0195408f,
        0.0181653f, 0.0168006f, 0.0154466f, 0.0141031f, 0.0127701f, 0.0114476f, 0.0101354f, 0.00883339f,
-       0.00754159f, 0.00625989f, 0.00498819f, 0.00372644f, 0.00247454f, 0.00123242f, 0.f
+       0.00754159f, 0.00625989f, 0.00498819f, 0.00372644f, 0.00247454f, 0.00123242f, 0.f,
 };
 
 static void radangle2imp(float a2, float b2, float th, float *A, float *B, float *C, float *F)