zoukankan      html  css  js  c++  java
  • 图片分色算法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;
            }
        }
    }
    

      

  • 相关阅读:
    深入理解Java内存模型(JMM)
    Java基础知识①
    Java自旋锁的几种实现
    ConcurrentHashMap的CAS操作
    Java集合对比总结
    python模块--os模块
    python模块--random
    Datafactory 学习笔记
    Datafactory 实际使用案例
    Oracle三种排名函数使用
  • 原文地址:https://www.cnblogs.com/xinglizhenchu/p/5164814.html
Copyright © 2011-2022 走看看