Identifying the most dominant color in an image

Hi,
I developed an algorithm that identifies the most dominant color in an image.
The input is a URL to the target image and the output is the dominant color.
The algorithm reads all the pixels of the bitmap and maps them into a dictionary.
Then, it builds a graph of similar colors by a pre-defined threshold.
While building the graph, the algorithm maintains the most dominant color by the node that has the largest amount of pixels combined with its' adjacent nodes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
public class ColorsGraph
{
    private const int _similarityThreshhold = 30;
    private readonly Dictionary<Color, int> _colorsMapping;
    private Dictionary<ColorNode, List<ColorNode>> _colorsGraph;
    private KeyValuePair<ColorNode, List<ColorNode>> _mostDominantColor;
 
    public ColorsGraph(string imageUrl)
    {
        _colorsMapping = new Dictionary<Color, int>();
 
        var request = WebRequest.Create(imageUrl);
        using (var response = request.GetResponse())
        using (var stream = response.GetResponseStream())
        using (var image = Bitmap.FromStream(stream) as Bitmap)
        {
            BuildColorsMapping(image);
        }
 
        BuildColorsGraph();
    }
 
    public Color GetMostDominantColor()
    {
        return _mostDominantColor.Key.Color;
    }
 
    public Color GetMostDominantColorAverage()
    {
        var nodes = new[] { _mostDominantColor.Key }.Union(_mostDominantColor.Value).ToList();
        return Color.FromArgb(
            nodes.Sum(x => x.Color.A) / nodes.Count,
            nodes.Sum(x => x.Color.R) / nodes.Count,
            nodes.Sum(x => x.Color.G) / nodes.Count,
            nodes.Sum(x => x.Color.B) / nodes.Count);
    }
 
    private void BuildColorsMapping(Bitmap aBitmap)
    {
        for (var x = 0; x < aBitmap.Height; ++x)
        {
            for (var y = 0; y < aBitmap.Width; ++y)
            {
                var color = aBitmap.GetPixel(x, y);
                if (_colorsMapping.ContainsKey(color))
                {
                    ++_colorsMapping[color];
                }
                else
                {
                    _colorsMapping.Add(color, 1);
                }
            }
        }
    }
 
    private void BuildColorsGraph()
    {
        _colorsGraph = _colorsMapping.ToDictionary(x => new ColorNode(x.Key, x.Value), x => new List<ColorNode>());
        _mostDominantColor = _colorsGraph.OrderByDescending(x => x.Key.TotalPixelsCount).First();
 
        foreach (var sourceColor in _colorsGraph.Keys)
        {
            foreach (var targetColor in _colorsGraph)
            {
                if (sourceColor != targetColor.Key && AreSimilar(sourceColor.Color, targetColor.Key.Color))
                {
                    targetColor.Value.Add(sourceColor);
                    targetColor.Key.TotalPixelsCount += sourceColor.PixelsCount;
                    if (targetColor.Key.TotalPixelsCount > _mostDominantColor.Key.TotalPixelsCount)
                    {
                        _mostDominantColor = targetColor;
                    }
                }
            }
        }
    }
 
    private bool AreSimilar(Color aSource, Color aTarget)
    {
        return
            Math.Abs(aSource.B - aTarget.B) < _similarityThreshhold &&
            Math.Abs(aSource.R - aTarget.R) < _similarityThreshhold &&
            Math.Abs(aSource.G - aTarget.G) < _similarityThreshhold;
    }
 
    private class ColorNode
    {
        public ColorNode(Color color, int pixelsCount)
        {
            Color = color;
            PixelsCount = pixelsCount;
            TotalPixelsCount = pixelsCount;
        }
 
        public Color Color { get; private set; }
        public int PixelsCount { get; private set; }
        public int TotalPixelsCount { get; set; }
        public override bool Equals(object obj)
        {
            return ((ColorNode)obj).Color == Color;
        }
 
        public override int GetHashCode()
        {
            return Color.GetHashCode();
        }
    }
}
Feel free to play with the threshold to optimize your results!

Good luck!

Comments

Post a Comment

Popular posts from this blog

Impersonating CurrentUser from SYSTEM

Hey all, I've been searching for a very long time an easy way to impersonate current user while running in a "SYSTEM" user credentials. I haven't found any code that does it and actually works. So I managed to combine pieces of code from several places, and added some of my own. This helper class exposes 2 functions: 1. Get current user impersonated scope - in this scope you can do pretty much whatever you want in the current user credentials. 2. Start a process as current user. public static class ImpersonationUtils { private const int SW_SHOW = 5; private const int TOKEN_QUERY = 0x0008; private const int TOKEN_DUPLICATE = 0x0002; private const int TOKEN_ASSIGN_PRIMARY = 0x0001; private const int STARTF_USESHOWWINDOW = 0x00000001; private const int STARTF_FORCEONFEEDBACK = 0x00000040; private const int CREATE_UNICODE_ENVIRONMENT = 0x00000400; private const int TOKEN_IMPERSONATE = 0x0004; private const int TOKEN_...
Read more

Add Styles & Scripts Dynamically to head tag in ASP .NET MVC

Hey, I wanted to be able to create partial views in asp .net mvc in a way that every partial will declare its own styles and scripts. So the naive solution is to define a section in the layout, and in the partial view just put everything inside. The problem is, it's working only for one level deep. What happens if your partial view uses another partial views ? What happens if your layout is dynamic, and uses partial views as well? So I created the following solution: public class DynamicHeaderHandler : ActionFilterAttribute { private static readonly byte[] _headClosingTagBuffer = Encoding.UTF8.GetBytes("</head>"); private static readonly byte[] _placeholderBuffer = Encoding.UTF8.GetBytes(DynamicHeader.SectionPlaceholder); public override void OnActionExecuted(ActionExecutedContext filterContext) { if (filterContext.Result is ViewResult) { filterContext.HttpContext.Response.Filter = new ResponseFilter(filterContext...
Read more

Extending cshtml with functions and properties

Hey, Lately I've been building many infrastructures for my company's website and I wanted to expose those infrastructures in the most natural way that coders are used to. One of the problems I spent time on was exposing the infrastructures on *.cshtml files. I didn't want to use static classes - because it's not a natural way, and not very trivial. So I managed to extend the class that represents the view, and by that add more properties and functions to it. public abstract class ViewBase<TModel> : WebViewPage<TModel> where TModel : class { public LayoutConfiguration LayoutConfiguration { get; private set; } public ViewBase() { LayoutConfiguration = LayoutConfiguration.GetInstance(); } public void DoWork() { } } And now on your Web.config (in the Views folder) replace this line: <pages pageBaseType="System.Web.Mvc.WebViewPage"> With this one: <pages pageBaseType="namespace.ViewBase...
Read more