Added colorfulness sorting

Author: Avid29

components/Extensions.AccentExtractor/samples/Extensions.AccentExtractorCustomSample.xaml

@@ -13,6 +13,15 @@
             <ColumnDefinition Width="*" />
             <ColumnDefinition Width="*" />
         </Grid.ColumnDefinitions>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="auto"/>
+            <RowDefinition/>
+        </Grid.RowDefinitions>
+
+        <StackPanel Orientation="Horizontal" Grid.ColumnSpan="2">
+            <TextBox x:Name="UrlTextbox" PlaceholderText="Enter a url"/>
+            <Button Content="Set Image" Click="Button_Click"/>
+        </StackPanel>
 
         <Image x:Name="AccentedImage"
                Source="/Extensions.AccentExtractorExperiment.Samples/Assets/icon.png"
@@ -22,16 +31,17 @@
                Width="200"
                Height="200"
                Margin="20"
+               Grid.Row="1"
                extensions:AccentExtractor.CalculateAccent="True"/>
 
-        <Rectangle Grid.Column="1"
+        <Rectangle Grid.Column="1" Grid.Row="1"
                    HorizontalAlignment="Center"
                    VerticalAlignment="Center"
                    Width="200"
                    Height="200"
                    Margin="20">
             <Rectangle.Fill>
-                <SolidColorBrush Color="{Binding Path=(extensions:AccentExtractor.AccentColor), ElementName=AccentedImage, Mode=OneWay}"/>
+                <SolidColorBrush Color="{x:Bind AccentedImage.(extensions:AccentExtractor.AccentColor), Mode=OneWay}"/>
             </Rectangle.Fill>
         </Rectangle>
     </Grid>

components/Extensions.AccentExtractor/samples/Extensions.AccentExtractorCustomSample.xaml.cs

@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using CommunityToolkit.WinUI.Controls;
+using Microsoft.UI.Xaml.Media.Imaging;
 
 namespace Extensions.AccentExtractorExperiment.Samples;
 
@@ -16,4 +16,9 @@ public AccentExtractorCustomSample()
     {
         this.InitializeComponent();
     }
+
+    private void Button_Click(object sender, RoutedEventArgs e)
+    {
+        AccentedImage.Source = new BitmapImage(new Uri(UrlTextbox.Text));
+    }
 }

components/Extensions.AccentExtractor/src/AccentExtractor.Clustering.cs

@@ -2,9 +2,122 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace CommunityToolkit.WinUI.Controls.Extensions;
+using System.Numerics;
+
+namespace CommunityToolkit.WinUI.Extensions;
 
 public static partial class AccentExtractor
 {
+    private static Vector3[] KMeansCluster(Span<Vector3> points, int k)
+    {
+        // Track the assigned cluster of each point
+        int[] clusterIds = new int[points.Length];
+
+        // Track the centroids of each cluster and its member count
+        // TODO: stackalloc is great here, but pooling should be thresholded
+        // just in case
+        Span<Vector3> centroids = stackalloc Vector3[k];
+        Span<int> counts = stackalloc int[k];
+
+        // Split the points into arbitrary clusters
+        // NOTE: Can this be rearranged to converge faster?
+        var offset = Random.Shared.Next(k); // Mathematically true random sampling
+        for (int i = 0; i < clusterIds.Length; i++)
+            clusterIds[i] = (i + offset) % k;
+
+        bool converged = false;
+        while (!converged)
+        {
+            // Assume we've converged. If we haven't, we'll assign converged
+            // to false when adjust the clusters
+            converged = true;
+
+            // KMeans Loop Step 1:
+            // Calculate/Recalculate the centroids of each cluster
+
+            // Clear centroids and counts before recalculation
+            for(int i = 0; i < centroids.Length; i++)
+            {
+                centroids[i] = Vector3.Zero;
+                counts[i] = 0;
+            }
+
+            // Accumlate step in centroid calculation
+            for(int i = 0; i < clusterIds.Length; i++)
+            {
+                int id = clusterIds[i];
+                centroids[id] += points[i];
+                counts[id]++;
+            }
+
+            // Prune empty clusters
+            // All empty clusters are swapped to the end of the span
+            // then a slice is taken with only the remaining populated clusters
+            int pivot = counts.Length;
+            for (int i = 0; i < pivot;)
+            {
+                // Increment and continue if populated
+                if (counts[i] != 0)
+                {
+                    i++;
+                    continue;
+                }
+
+                // The item is not populated. Swap to end and move pivot
+                // NOTE: This is a oneway swap. We're discarding the 0 anyways.
+                pivot--;
+                counts[i] = counts[pivot];
+            }
+            counts = counts[..pivot];
+            centroids = centroids[..pivot];
+
+            // Division step in centroid calculation
+            for (int i = 0; i < centroids.Length; i++)
+                centroids[i] /= counts[i];
+            
+            // KMeans Loop Step 2:
+            // Move each point's clusterId to the nearest cluster centroid
+            for (int i = 0; i < points.Length; i++)
+            {
+                Vector3 point = points[i];
+                var oldId = clusterIds[i];
+
+                // Track the nearest centroid's distance and the index of that centroid
+                float nearestDistance = float.PositiveInfinity;
+                int nearestIndex = -1;
+
+                for (int j = 0; j < centroids.Length; j++)
+                {
+                    // Compare the point to the jth centroid
+                    float distance = Vector3.DistanceSquared(point, centroids[j]);
+
+                    // Skip the cluster if further than the nearest seen cluster 
+                    if (nearestDistance < distance)
+                        continue;
+
+                    // This is the nearest cluster
+                    // Update the distance and index
+                    nearestDistance = distance;
+                    nearestIndex = j;
+                }
+
+                // The nearest cluster hasn't changed. Do nothing
+                if (oldId == nearestIndex)
+                    continue;
+
+                // Update the cluster id and note that we have not converged
+                clusterIds[i] = nearestIndex;
+                converged = false;
+            }
+        }
+
+        return centroids.ToArray();
+    }
 
+    private static float FindColorfulness(Vector3 color)
+    {
+        var rg = color.X - color.Y;
+        var yb = ((color.X + color.Y) / 2) - color.Z;
+        return 0.3f * new Vector2(rg, yb).Length();
+    }
 }

components/Extensions.AccentExtractor/src/AccentExtractor.cs

@@ -5,8 +5,7 @@
 using Microsoft.UI;
 using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml.Media.Imaging;
-using System.Buffers;
-using Windows.Graphics.Imaging;
+using System.Numerics;
 using Windows.UI;
 
 namespace CommunityToolkit.WinUI.Extensions;
@@ -76,13 +75,12 @@ public static async Task UpdateAccentAsync(this UIElement sender)
         var pixels = await bitmap.GetPixelsAsync();
         var stream = pixels.AsStream();
 
-        // 
         if (stream.Length == 0)
             return;
 
         // Read the stream into a a color array
         int pos = 0;
-        Span<Color> colors = new Color[(int)stream.Length / 4]; // This should be 4096 (64x64), but it's good to be safe.
+        Span<Vector3> colors = new Vector3[(int)stream.Length / 4]; // This should be 4096 (64x64), but it's good to be safe.
         Span<byte> bytes = stackalloc byte[4];
         while (stream.Read(bytes) > 0)
         {
@@ -91,15 +89,21 @@ public static async Task UpdateAccentAsync(this UIElement sender)
             if (pos >= colors.Length)
                 break;
 
-            colors[pos] = Color.FromArgb(bytes[3], bytes[2], bytes[1], bytes[0]);
+            colors[pos] = new Vector3(bytes[2], bytes[1], bytes[0])/255;
             pos++;
         }
 
-        var rand = Random.Shared.Next(colors.Length - 1);
-        var accent = colors[rand];
+        // Determine most prominent colors and assess colorfulness
+        var clusters = KMeansCluster(colors, 5);
+        var colorfulness = clusters.Select(color => (color, FindColorfulness(color)));
+        var mostColorful = colorfulness.MaxBy(x => x.Item2);
+
+        // Select the accent color and convert to color
+        var accent = mostColorful.color * 255;
+        var color = Color.FromArgb(255, (byte)accent.X, (byte)accent.Y, (byte)accent.Z);
 
         // Set the accent color on the UI thread
-        DispatcherQueue.GetForCurrentThread().TryEnqueue(() => SetAccentColor(sender, accent));
+        DispatcherQueue.GetForCurrentThread().TryEnqueue(() => SetAccentColor(sender, color));
 #endif
     }