It is likely in any rich image that most of your colors will be unique in some way. It would follow, then, that fetching distinct colors will likely not help you accomplish your goal.
I recommend inspecting the HSV values for each pixel in your image. I'll leave you to countless online examples of retrieving images as arrays of HSV values.
With your HSV values, you can calculate clusters of prominent hues by create an integer array of 256 hue counts, computing a histogram of hues in your image data. You can determine prominent hues by finding clusters of 4-6 sequential hues with a high count sum.
After picking several prominent hues, subdivide pixels of those hues into another histogram measuring saturation, and pick out prominent clusters, and so on.
Rough Example
The code below makes some attempt to help identify prominent hues. There are most likely other awesome ways to do this; however, this may provide some ideas.
First, I get all the image colors as an array of Color objects, like so:
private static Color[] GetImageData(Image image)
{
using (var b = new Bitmap(image))
{
var bd = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
byte[] arr = new byte[bd.Width * bd.Height * 3];
Color[] colors = new Color[bd.Width * bd.Height];
Marshal.Copy(bd.Scan0, arr, 0, arr.Length);
b.UnlockBits(bd);
for (int i = 0; i < colors.Length; i++)
{
var start = i*3;
colors[i] = Color.FromArgb(arr[start], arr[start + 1], arr[start + 2]);
}
return colors;
}
}
You might consider validating that I got the order of RGB in the Color.FromArgb method call in the correct order.
Next, I stash aside a utility method for converting to HSV. In my example, I'll only work with hues, but here's a full working example of the conversion:
private static void ColorToHSV(Color color, out int hue, out int saturation, out int value)
{
int max = Math.Max(color.R, Math.Max(color.G, color.B));
int min = Math.Min(color.R, Math.Min(color.G, color.B));
hue = (int)(color.GetHue() * 256f / 360f);
saturation = (max == 0) ? 0 : (int)(1d - (1d * min / max));
value = (int)(max / 255d);
}
Finally, I build the hue histogram, define a width of hues (say, 9 hues) in which to aggregate counts together, and then I report the counts to the console.
private static void ProcessImage(Color[] imagecolors)
{
var hues = new int[256];
var hueclusters = new int[256];
int hue, saturation, value;
// build hue histogram.
foreach (var color in imagecolors) {
ColorToHSV(color, out hue, out saturation, out value);
hues[hue]++;
}
// calculate counts for clusters of colors.
for (int i = 0; i < 256; i++) {
int huecluster = 0;
for (int count = 0, j = i; count < 9; count++, j++) {
huecluster += hues[j % 256];
}
hueclusters[(i + 5) % 256] = huecluster;
}
// Print clusters on the console
for (int i = 0; i < 256; i++) {
Console.WriteLine("Hue {0}, Score {1}.", i, hueclusters[i]);
}
}
I've made no attempt to filter down to which hues to choose. You may need to consider some heuristics rather than blindly picking the top so-many counts, because you probably want to pick hues that are somewhat separated on the color spectrum. I haven't time to explore this any further, but I hope this provides some insight into a strategy you can consider.
