Changeset 2715Tweet

Timestamp:

Aug 14, 2008, 8:34:44 PM (14 years ago)

Author:

Sam Hocevar

Message:

• blur.c: add an argument to the gaussian convolution to specify an angle. Of course since the kernel is no longer separable, it becomes awfully slow with large images. Here is a tileable brushed metal texture: # pipi pipi:random512x512 --wrap --blur 20x0r25 -o image.png

Location:

libpipi/trunk

Files:

• examples/edd.c (modified) (2 diffs)
• pipi/context.c (modified) (2 diffs)
• pipi/filter/blur.c (modified) (3 diffs)
• pipi/pipi.h (modified) (1 diff)

libpipi/trunk/examples/edd.c

@@ -62 +62 @@
 
     /* Compute the fast error */
-    tmp = pipi_gaussian_blur_ext(dither, sigma, sigma, 0.16, 0.26);
+    tmp = pipi_gaussian_blur_ext(dither, sigma, sigma, 0.0, 0.16, 0.26);
     e1 = pipi_measure_msd(gauss, tmp);
     pipi_free(tmp);
@@ -72 +72 @@
             for(dx = 0; dx <= Z; dx++)
             {
-                tmp = pipi_gaussian_blur_ext(dither, sigma, sigma,
+                tmp = pipi_gaussian_blur_ext(dither, sigma, sigma, 0.0,
                                              fx + step * dx / Z,
                                              fy + step * dy / Z);

libpipi/trunk/pipi/context.c

@@ -119 +119 @@
         char const *arg;
         va_list ap;
-        double w, h;
+        double w, h, a = 0.0;
 
         if(ctx->nimages < 1)
@@ -129 +129 @@
         arg = strchr(arg, 'x');
         if(arg)
+        {
             h = atof(arg + 1);
+            arg = strchr(arg, 'r');
+            if(arg)
+                a = atof(arg + 1);
+        }
         src = ctx->images[ctx->nimages - 1];
-        dst = pipi_gaussian_blur_ext(src, w, h, 0.0, 0.0);
+        dst = pipi_gaussian_blur_ext(src, w, h, a, 0.0, 0.0);
         if(dst == NULL)
             return -1;

libpipi/trunk/pipi/filter/blur.c

@@ -35 +35 @@
 pipi_image_t *pipi_gaussian_blur(pipi_image_t *src, float radius)
 {
-    return pipi_gaussian_blur_ext(src, radius, radius, 0.0, 0.0);
+    return pipi_gaussian_blur_ext(src, radius, radius, 0.0, 0.0, 0.0);
 }
 
 pipi_image_t *pipi_gaussian_blur_ext(pipi_image_t *src, float rx, float ry,
-                                     float dx, float dy)
+                                     float angle, float dx, float dy)
 {
     pipi_image_t *ret;
     double *kernel;
-    double Kx, Ky, t = 0.0;
+    double Kx, Ky, t = 0.0, sint, cost, bbx, bby;
     int i, j, krx, kry, m, n;
 
@@ -49 +49 @@
     if(ry < BLUR_EPSILON) ry = BLUR_EPSILON;
 
+    sint = sin(angle * M_PI / 180.);
+    cost = cos(angle * M_PI / 180.);
+
+    /* Compute the final ellipse's bounding box */
+    bbx = sqrt(rx * rx * cost * cost + ry * ry * sint * sint);
+    bby = sqrt(ry * ry * cost * cost + rx * rx * sint * sint);
+
     /* FIXME: the kernel becomes far too big with large values of dx, because
      * we grow both left and right. Fix the growing direction. */
-    krx = (int)(3. * rx + .99999 + ceil(abs(dx)));
+    krx = (int)(3. * bbx + .99999 + ceil(abs(dx)));
     m = 2 * krx + 1;
     Kx = -1. / (2. * rx * rx);
 
-    kry = (int)(3. * ry + .99999 + ceil(abs(dy)));
+    kry = (int)(3. * bby + .99999 + ceil(abs(dy)));
     n = 2 * kry + 1;
     Ky = -1. / (2. * ry * ry);
@@ -63 +70 @@
     for(j = -kry; j <= kry; j++)
     {
-        double ey = Ky * ((double)j + dy) * ((double)j + dy);
-
         for(i = -krx; i <= krx; i++)
         {
-            double ex = Kx * ((double)i + dx) * ((double)i + dx);
+            double u = (double)i * cost - (double)j * sint + dx;
+            double v = (double)j * cost + (double)i * sint + dy;
+            double ex = Kx * u * u;
+            double ey = Ky * v * v;
             double d = exp(ex + ey);
 

libpipi/trunk/pipi/pipi.h

@@ -100 +100 @@
 extern pipi_image_t *pipi_gaussian_blur(pipi_image_t *, float);
 extern pipi_image_t *pipi_gaussian_blur_ext(pipi_image_t *,
-                                            float, float, float, float);
+                                            float, float, float, float, float);
 extern pipi_image_t *pipi_box_blur(pipi_image_t *, int);
 extern pipi_image_t *pipi_box_blur_ext(pipi_image_t *, int, int);