Merge lp:~mterry/unity-greeter/average-color into lp:unity-greeter

[Michael Terry]

Canonical owns the copyright to the algorithm. It was originally written for Unity. Then it also got used in a patch for gnome-desktop3 by didrocks, to replace upstream's algorithm. Then I ported it here to Vala.

[Robert Ancell (robert-ancell)]

Looks good to me. Don't know if there's any performance hit but it works in Unity/GNOME desktop so guessing not. Either way we can cross that bridge later.

review: Approve

=== modified file 'src/background.vala'
--- src/background.vala	2012-08-27 22:30:33 +0000
+++ src/background.vala	2012-08-30 02:57:17 +0000
@@ -26,6 +26,7 @@
     public int[] widths;
     public int[] heights;
     public Cairo.Pattern[] patterns;
+    public Gdk.RGBA average_color;
 
     private Cairo.Surface target_surface;
     private bool draw_grid;
@@ -122,6 +123,8 @@
         for (var i = 0; i < widths.length; i++)
         {
             patterns[i] = create_pattern (images[i]);
+            if (i == 0)
+                pixbuf_average_value (images[i], out average_color);
             images[i] = null;
         }
 
@@ -201,6 +204,150 @@
 
         return pattern;
     }
+
+    /* The following color averaging algorithm was originally written for
+       Unity in C++, then patched into gnome-desktop3 in C.  I've taken it
+       and put it here in Vala.  It would be nice if we could get
+       gnome-desktop3 to expose this for our use instead of copying the
+       code... */
+
+    static const int QUAD_MAX_LEVEL_OF_RECURSION = 16;
+    static const int QUAD_MIN_LEVEL_OF_RECURSION = 2;
+    static const int QUAD_CORNER_WEIGHT_NW       = 3;
+    static const int QUAD_CORNER_WEIGHT_NE       = 1;
+    static const int QUAD_CORNER_WEIGHT_SE       = 1;
+    static const int QUAD_CORNER_WEIGHT_SW       = 3;
+    static const int QUAD_CORNER_WEIGHT_CENTER   = 2;
+    static const int QUAD_CORNER_WEIGHT_TOTAL    = (QUAD_CORNER_WEIGHT_NW + QUAD_CORNER_WEIGHT_NE + QUAD_CORNER_WEIGHT_SE + QUAD_CORNER_WEIGHT_SW + QUAD_CORNER_WEIGHT_CENTER);
+
+    /* Pixbuf utilities */
+    private Gdk.RGBA get_pixbuf_sample (uint8[]   pixels,
+                                        int       rowstride,
+                                        int       channels,
+                                        int       x,
+                                        int       y)
+    {
+	    var sample = Gdk.RGBA ();
+	    double dd = 0xFF;
+	    int offset = ((y * rowstride) + (x * channels));
+
+	    sample.red = pixels[offset++] / dd;
+	    sample.green = pixels[offset++] / dd;
+	    sample.blue = pixels[offset++] / dd;
+	    sample.alpha = 1.0f;
+
+	    return sample;
+    }
+
+    private bool is_color_different (Gdk.RGBA color_a,
+                                     Gdk.RGBA color_b)
+    {
+	    var diff = Gdk.RGBA ();
+
+	    diff.red   = color_a.red   - color_b.red;
+	    diff.green = color_a.green - color_b.green;
+	    diff.blue  = color_a.blue  - color_b.blue;
+	    diff.alpha = 1.0f;
+
+	    if (GLib.Math.fabs (diff.red) > 0.15 ||
+	        GLib.Math.fabs (diff.green) > 0.15 ||
+	        GLib.Math.fabs (diff.blue) > 0.15)
+		    return true;
+
+	    return false;
+    }
+
+    private Gdk.RGBA get_quad_average (int       x,
+                                       int       y,
+                                       int       width,
+                                       int       height,
+                                       int       level_of_recursion,
+                                       uint8[]   pixels,
+                                       int       rowstride,
+                                       int       channels)
+    {
+	    // samples four corners
+	    // c1-----c2
+	    // |       |
+	    // c3-----c4
+
+	    var average = Gdk.RGBA ();
+	    var corner1 = get_pixbuf_sample (pixels, rowstride, channels, x        , y         );
+	    var corner2 = get_pixbuf_sample (pixels, rowstride, channels, x + width, y         );
+	    var corner3 = get_pixbuf_sample (pixels, rowstride, channels, x        , y + height);
+	    var corner4 = get_pixbuf_sample (pixels, rowstride, channels, x + width, y + height);
+	    var centre  = get_pixbuf_sample (pixels, rowstride, channels, x + (width / 2), y + (height / 2));
+
+	    /* If we're over the max we want to just take the average and be happy
+	       with that value */
+	    if (level_of_recursion < QUAD_MAX_LEVEL_OF_RECURSION) {
+		    /* Otherwise we want to look at each value and check it's distance
+		       from the center color and take the average if they're far apart. */
+
+		    /* corner 1 */
+		    if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION ||
+				    is_color_different(corner1, centre)) {
+			    corner1 = get_quad_average (x, y, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels);
+		    }
+
+		    /* corner 2 */
+		    if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION ||
+				    is_color_different(corner2, centre)) {
+			    corner2 = get_quad_average (x + width/2, y, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels);
+		    }
+
+		    /* corner 3 */
+		    if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION ||
+				    is_color_different(corner3, centre)) {
+			    corner3 = get_quad_average (x, y + height/2, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels);
+		    }
+
+		    /* corner 4 */
+		    if (level_of_recursion < QUAD_MIN_LEVEL_OF_RECURSION ||
+				    is_color_different(corner4, centre)) {
+			    corner4 = get_quad_average (x + width/2, y + height/2, width/2, height/2, level_of_recursion + 1, pixels, rowstride, channels);
+		    }
+	    }
+
+	    average.red   = ((corner1.red * QUAD_CORNER_WEIGHT_NW)     +
+	                     (corner3.red * QUAD_CORNER_WEIGHT_SW)     +
+	                     (centre.red  * QUAD_CORNER_WEIGHT_CENTER) +
+	                     (corner2.red * QUAD_CORNER_WEIGHT_NE)     +
+	                     (corner4.red * QUAD_CORNER_WEIGHT_SE))
+	                    / QUAD_CORNER_WEIGHT_TOTAL;
+	    average.green = ((corner1.green * QUAD_CORNER_WEIGHT_NW)     +
+	                     (corner3.green * QUAD_CORNER_WEIGHT_SW)     +
+	                     (centre.green  * QUAD_CORNER_WEIGHT_CENTER) +
+	                     (corner2.green * QUAD_CORNER_WEIGHT_NE)     +
+	                     (corner4.green * QUAD_CORNER_WEIGHT_SE))
+	                    / QUAD_CORNER_WEIGHT_TOTAL;
+	    average.blue  = ((corner1.blue * QUAD_CORNER_WEIGHT_NW)     +
+	                     (corner3.blue * QUAD_CORNER_WEIGHT_SW)     +
+	                     (centre.blue  * QUAD_CORNER_WEIGHT_CENTER) +
+	                     (corner2.blue * QUAD_CORNER_WEIGHT_NE)     +
+	                     (corner4.blue * QUAD_CORNER_WEIGHT_SE))
+	                    / QUAD_CORNER_WEIGHT_TOTAL;
+	    average.alpha = 1.0f;
+
+	    return average;
+    }
+
+    private void pixbuf_average_value (Gdk.Pixbuf pixbuf,
+                                       out Gdk.RGBA result)
+    {
+	    var average = get_quad_average (0, 0,
+	                                    pixbuf.get_width () - 1, pixbuf.get_height () - 1,
+	                                    1,
+	                                    pixbuf.get_pixels (),
+	                                    pixbuf.get_rowstride (),
+	                                    pixbuf.get_n_channels ());
+
+	    result = Gdk.RGBA ();
+	    result.red = average.red;
+	    result.green = average.green;
+	    result.blue = average.blue;
+	    result.alpha = average.alpha;
+    }
 }
 
 public class Monitor
@@ -343,6 +490,7 @@
             if (old == current)
                 old = new_background;
             current = new_background;
+            publish_average_color ();
         }
 
         /* Fade to this background when loaded */
@@ -438,6 +586,7 @@
             }
 
             queue_draw ();
+            publish_average_color ();
         }
     }
 
@@ -518,4 +667,17 @@
         c.fill ();
         c.restore ();
     }
+
+    void publish_average_color ()
+    {
+        var rgba = current.average_color.to_string ();
+        var root = get_screen ().get_root_window ();
+
+        Gdk.property_change (root,
+                             Gdk.Atom.intern_static_string ("_GNOME_BACKGROUND_REPRESENTATIVE_COLORS"),
+                             Gdk.Atom.intern_static_string ("STRING"),
+                             8,
+                             Gdk.PropMode.REPLACE,
+                             rgba.data);
+    }
 }