图片分色算法1

演示地址：

http://codeman35.itongyin.com:19004/demo1.aspx

截图：

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

namespace demo_win_extractColor
{
    /// <summary>
    /// 用于图像分色
    /// </summary>
    public class ExtractImageColor
    {

        /// <summary>
        /// 定义分色的色块
        /// </summary>
        /// <param name="imgPath"></param>
        /// <param name="delta"></param>
        /// <param name="count">0代表</param>
        /// <param name="reduce_brightness"></param>
        /// <param name="reduce_gradients"></param>
        public Dictionary<Color, float> ParseColor(Bitmap map,
            int delta = 16,
            int count = 0,
            bool reduce_brightness = true,
            bool reduce_gradients = true
            )
        {
            int half_delta = 0;
            if (delta > 2)
                half_delta = delta / 2 - 1;

            var PREVIEW_WIDTH = 150f;
            var PREVIEW_HEIGHT = 150f;

            double width = map.Width;
            double height = map.Height;
            var scale = Math.Min(PREVIEW_WIDTH / map.Width, PREVIEW_HEIGHT / map.Height);
            if (scale < 1)
            {
                width = Math.Floor(scale * map.Width);
                height = Math.Floor(scale * map.Height);
            }
            var mapNew = new Bitmap(map, (int)width, (int)height);

            var hexarray = new Dictionary<Color, int>();
            var total_pixel_count = 0;
            for (int y = 0; y < mapNew.Height; y++)
            {
                for (int x = 0; x < mapNew.Width; x++)
                {
                    total_pixel_count++;
                    var color = mapNew.GetPixel(x, y);
                    var newcolor = new int[] { 0, 0, 0 };
                    if (delta > 1)
                    {
                        newcolor[0] = ((color.R + half_delta) / delta).toint32() * delta;
                        newcolor[1] = ((color.G + half_delta) / delta).toint32() * delta;
                        newcolor[2] = ((color.B + half_delta) / delta).toint32() * delta;
                        newcolor[0] = Math.Min(255, newcolor[0]);
                        newcolor[1] = Math.Min(255, newcolor[1]);
                        newcolor[2] = Math.Min(255, newcolor[2]);
                    }

                    var _color = Color.FromArgb(newcolor[0], newcolor[1], newcolor[2]);
                    if (!hexarray.ContainsKey(_color))
                    {
                        hexarray[_color] = 1;
                    }
                    else
                    {
                        hexarray[_color]++;
                    }
                }
            }
            if (mapNew != null) mapNew.Dispose();

            if (reduce_gradients)
            {
                // if you want to *eliminate* gradient variations use:
                // ksort( & hexarray );
                var arr = from o in hexarray orderby o.Value ascending select o;

                var gradients = new Dictionary<Color, Color>();
                foreach (var hex in arr)
                {
                    Color new_hex = new Color();
                    if (!gradients.ContainsKey(hex.Key))
                    {
                        new_hex = _find_adjacent(hex.Key, gradients, delta);
                        gradients[hex.Key] = new_hex;
                    }
                    else
                    {
                        new_hex = gradients[hex.Key];
                    }

                    if (hex.Key != new_hex)
                    {
                        hexarray[hex.Key] = 0;
                        hexarray[new_hex] += hex.Value;
                    }
                }
            }

            if (reduce_brightness)
            {
                // if you want to *eliminate* brightness variations use:
                // ksort( & hexarray );
                var arr = from o in hexarray orderby o.Value ascending select o;
                var brightness = new Dictionary<Color, Color>();
                foreach (var hex in arr)
                {
                    Color new_hex = new Color();
                    if (!brightness.ContainsKey(hex.Key))
                    {
                        new_hex = _normalize(hex.Key, brightness, delta);
                        brightness[hex.Key] = new_hex;
                    }
                    else
                    {
                        new_hex = brightness[hex.Key];
                    }
                    if (hex.Key != new_hex)
                    {
                        hexarray[hex.Key] = 0;
                        hexarray[new_hex] += hex.Value;
                    }
                }
            }

            var ARR = from o in hexarray orderby o.Value descending select o;

            var hexarrayP = new Dictionary<Color, float>();
            // convert counts to percentages
            foreach (var key in ARR)
            {
                hexarrayP[key.Key] = (float)key.Value / total_pixel_count;
            }

            if (count == 0) count = hexarrayP.Count;


            for (int i = 0; i < count; i++)
            {

            }

            return hexarrayP;
        }

        private Color _normalize(Color color, Dictionary<Color, Color> brightness, int delta)
        {
            var lowest = 255;
            var highest = 0;

            lowest = Math.Min(Math.Min(Math.Min(lowest, color.R), color.G), color.B);
            highest = Math.Max(Math.Max(Math.Max(highest, color.R), color.G), color.B);


            // Do not normalize white, black, or shades of grey unless low delta
            if (lowest == highest)
            {
                if (delta <= 32)
                {
                    if (lowest == 0 || highest >= (255 - delta))
                    {
                        return color;
                    }
                }
                else
                {
                    return color;
                }
            }

            for (; highest < 256; lowest += delta, highest += delta)
            {
                try
                {
                    if (color.R - lowest < 0) break;
                    if (color.G - lowest < 0) break;
                    if (color.B - lowest < 0) break;

                    Color new_hex = Color.FromArgb(color.R - lowest, color.G - lowest, color.B - lowest);
                    if (brightness.ContainsKey(new_hex))
                    {
                        // same color, different brightness - use it instead
                        return new_hex;
                    }
                }
                catch { }
            }
            return color;
        }

        private Color _find_adjacent(Color hex, Dictionary<Color, Color> gradients, int delta)
        {
            if (hex.R > delta)
            {
                Color tmp = Color.FromArgb(hex.R - delta, hex.G, hex.B);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }
            if (hex.G > delta)
            {
                Color tmp = Color.FromArgb(hex.R, hex.G - delta, hex.B);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }
            if (hex.B > delta)
            {
                Color tmp = Color.FromArgb(hex.R, hex.G, hex.B - delta);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }

            if (hex.R < (255 - delta))
            {
                Color tmp = Color.FromArgb(hex.R + delta, hex.G, hex.B);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }

            if (hex.G < (255 - delta))
            {
                Color tmp = Color.FromArgb(hex.R, hex.G + delta, hex.B);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }

            if (hex.B < (255 - delta))
            {
                Color tmp = Color.FromArgb(hex.R, hex.G, hex.B + delta);
                if (gradients.ContainsKey(tmp))
                    return gradients[tmp];
            }

            return hex;
        }
    }
}