Calculates the complementary color - CSharp System.Drawing

Description

Calculates the complementary color
Demo Code


using System.Windows.Media;
using System.Globalization;
using System;/*w  w  w .j a v a  2 s .  c o  m*/

public class Main{
        /// <summary>
        /// Calculates the complementary color
        /// </summary>
        /// <param name="c">
        /// </param>
        /// <returns>
        /// </returns>
        public static Color Complementary(Color c)
        {
            // http://en.wikipedia.org/wiki/Complementary_color
            // todo...
            double[] hsv = ColorToHsv(c);
            double newHue = hsv[0] - 0.5;

            // clamp to [0,1]
            if (newHue < 0)
            {
                newHue += 1.0;
            }

            return HsvToColor(newHue, hsv[1], hsv[2]);
        }
        /// <summary>
        /// Convert from HSV to <see cref="Color"/>
        /// http://en.wikipedia.org/wiki/HSL_color_space
        /// </summary>
        /// <param name="hue">
        /// Hue [0,1]
        /// </param>
        /// <param name="sat">
        /// Saturation [0,1]
        /// </param>
        /// <param name="val">
        /// Value [0,1]
        /// </param>
        /// <returns>
        /// </returns>
        public static Color HsvToColor(double hue, double sat, double val)
        {
            int i;
            double aa, bb, cc, f;
            double r, g, b;
            r = g = b = 0;

            if (sat == 0)
            {
                // Gray scale
                r = g = b = val;
            }
            else
            {
                if (hue == 1.0)
                {
                    hue = 0;
                }

                hue *= 6.0;
                i = (int)Math.Floor(hue);
                f = hue - i;
                aa = val * (1 - sat);
                bb = val * (1 - (sat * f));
                cc = val * (1 - (sat * (1 - f)));
                switch (i)
                {
                    case 0:
                        r = val;
                        g = cc;
                        b = aa;
                        break;

                    case 1:
                        r = bb;
                        g = val;
                        b = aa;
                        break;

                    case 2:
                        r = aa;
                        g = val;
                        b = cc;
                        break;

                    case 3:
                        r = aa;
                        g = bb;
                        b = val;
                        break;

                    case 4:
                        r = cc;
                        g = aa;
                        b = val;
                        break;

                    case 5:
                        r = val;
                        g = aa;
                        b = bb;
                        break;
                }
            }

            return Color.FromRgb((byte)(r * 255), (byte)(g * 255), (byte)(b * 255));
        }
        /// <summary>
        /// Create a color from the specified HSV.
        /// </summary>
        /// <param name="hsv">
        /// The HSV.
        /// </param>
        /// <returns>
        /// A color.
        /// </returns>
        public static Color HsvToColor(double[] hsv)
        {
            if (hsv.Length != 3)
            {
                throw new InvalidOperationException("Wrong length of hsv array.");
            }

            return HsvToColor(hsv[0], hsv[1], hsv[2]);
        }
        /// <summary>
        /// Converts from HSV to a RGB <see cref="Color"/>
        /// </summary>
        /// <param name="hue">
        /// The hue.
        /// </param>
        /// <param name="saturation">
        /// The saturation.
        /// </param>
        /// <param name="value">
        /// The value.
        /// </param>
        /// <returns>
        /// </returns>
        public static Color HsvToColor(byte hue, byte saturation, byte value)
        {
            double r, g, b;
            double h = hue * 360.0 / 255;
            double s = saturation / 255.0;
            double v = value / 255.0;

            if (s == 0)
            {
                r = v;
                g = v;
                b = v;
            }
            else
            {
                int i;
                double f, p, q, t;

                if (h == 360)
                {
                    h = 0;
                }
                else
                {
                    h = h / 60;
                }

                i = (int)Math.Truncate(h);
                f = h - i;

                p = v * (1.0 - s);
                q = v * (1.0 - (s * f));
                t = v * (1.0 - (s * (1.0 - f)));

                switch (i)
                {
                    case 0:
                        r = v;
                        g = t;
                        b = p;
                        break;

                    case 1:
                        r = q;
                        g = v;
                        b = p;
                        break;

                    case 2:
                        r = p;
                        g = v;
                        b = t;
                        break;

                    case 3:
                        r = p;
                        g = q;
                        b = v;
                        break;

                    case 4:
                        r = t;
                        g = p;
                        b = v;
                        break;

                    default:
                        r = v;
                        g = p;
                        b = q;
                        break;
                }
            }

            return Color.FromArgb(255, (byte)(r * 255), (byte)(g * 255), (byte)(b * 255));
        }
}
Calculates the complementary color - CSharp System.Drawing

Description

Demo Code

Related Tutorials
