C# Color.GetHue方法代码示例

 public bool IsOldStar(Color pixelColor)
 {
     return ((pixelColor.GetHue() >= 150) &&
         (pixelColor.GetHue() <= 258) &&
         (pixelColor.GetSaturation() >= 0.10) &&
         (pixelColor.GetBrightness() <= 0.90));
 }

		private static String FormatColor(String format, Color arg)
		{
			if (String.IsNullOrWhiteSpace(format))
			{
				return arg.ToString();
			}

			var numberFormatInfo =
				new NumberFormatInfo
				{
					NumberDecimalDigits = 1,
					PercentDecimalDigits = 0,
					PercentNegativePattern = 1,
					PercentPositivePattern = 1
				};
			switch (format)
			{
				case "hex":
					{
						return String.Format(numberFormatInfo, "#{0:x2}{1:x2}{2:x2}", arg.R, arg.G, arg.B);
					}
				case "HEX":
					{
						return String.Format(numberFormatInfo, "#{0:X2}{1:X2}{2:X2}", arg.R, arg.G, arg.B);
					}
				case "rgb":
					{
						return String.Format(numberFormatInfo, "rgb({0}, {1}, {2})", arg.R, arg.G, arg.B);
					}
				case "rgb%":
					{
						return String.Format(numberFormatInfo, "rgb({0:P}, {1:P}, {2:P})", arg.R / 255d, arg.G / 255d, arg.B / 255d);
					}
				case "rgba":
					{
						return String.Format(numberFormatInfo, "rgba({0}, {1}, {2}, {3:0.#})", arg.R, arg.G, arg.B, arg.A / 255d);
					}
				case "rgba%":
					{
						return String.Format(numberFormatInfo, "rgba({0:P}, {1:P}, {2:P}, {3:0.#})", arg.R / 255d, arg.G / 255d, arg.B / 255d, arg.A / 255d);
					}
				case "hsl":
					{
						return String.Format(numberFormatInfo, "hsl({0:F0}, {1:P}, {2:P})", arg.GetHue(), arg.GetSaturation(), arg.GetBrightness());
					}
				case "hsla":
					{
						return String.Format(numberFormatInfo, "hsla({0:F0}, {1:P}, {2:P}, {3:0.#})", arg.GetHue(), arg.GetSaturation(), arg.GetBrightness(), arg.A / 255d);
					}
				default:
					{
						throw new FormatException(String.Format("Invalid format specified: \"{0}\".", format));
					}
			}
		}

 /// <summary>
 /// Gets a cool Highlight brush for highlighting things
 /// </summary>
 /// <param name="box">The rectangle in the box</param>
 /// <param name="selectionHighlight">The color to use for the higlight</param>
 /// <returns></returns>
 public static Brush HighlightBrush(Rectangle box, Color selectionHighlight)
 {
     float med = selectionHighlight.GetBrightness();
     float bright = med + 0.05f;
     if (bright > 1f) bright = 1f;
     float dark = med - 0.05f;
     if (dark < 0f) dark = 0f;
     Color brtCol = ColorFromHsl(selectionHighlight.GetHue(), selectionHighlight.GetSaturation(), bright);
     Color drkCol = ColorFromHsl(selectionHighlight.GetHue(), selectionHighlight.GetSaturation(), dark);
     return new LinearGradientBrush(box, brtCol, drkCol, LinearGradientMode.Vertical);
 }

 public HSLColor(Color color)
 {
     RGB = color;
     H = (byte)((color.GetHue() / 360.0f) * 255);
     S = (byte)(color.GetSaturation() * 255);
     L = (byte)(color.GetBrightness() * 255);
 }

        public static ColorSlider Saturation(VisualDirection direction, float knobWidth, float minVisualLength, 
			Color color, Reaction<float> changed)
        {
            return new ColorSlider (direction, knobWidth, minVisualLength, 0f, 1f, color.GetSaturation (),
                new [] { Color.White, VisualHelpers.ColorFromHSB (color.GetHue (), 1f, color.GetBrightness ()) },
                changed);
        }

        public static void GetColorComponents(ColorModel colorModel, Color color, out Single componentA, out Single componentB, out Single componentC)
        {
            componentA = 0.0f;
            componentB = 0.0f;
            componentC = 0.0f;

            switch (colorModel)
            {
                case ColorModel.RedGreenBlue:
                    componentA = color.R;
                    componentB = color.G;
                    componentC = color.B;
                    break;

                case ColorModel.HueSaturationBrightness:
                    componentA = color.GetHue();
                    componentB = color.GetSaturation();
                    componentC = color.GetBrightness();
                    break;

                case ColorModel.LabColorSpace:
                    RGBtoLab(color.R, color.G, color.B, out componentA, out componentB, out componentC);
                    break;

                case ColorModel.XYZ:
                    RGBtoXYZ(color.R, color.G, color.B, out componentA, out componentB, out componentC);
                    break;
            }
        }

 private void getColour()
 {
     int r, g, b = 0;
     DialogResult result = GUI.colorDialog.ShowDialog();
     if (result != DialogResult.Cancel)
     {
         color = GUI.colorDialog.Color;
         r = color.R;
         g = color.G;
         b = color.B;
         GUI.txtColourRGBdecimal.Text = r + ", " + g + ", " + b;
         GUI.txtColourRGB.Text = String.Format("{0:X2}", r) + String.Format("{0:X2}", g) + String.Format("{0:X2}", b);
         GUI.txtColourRGBcss.Text = "#" + String.Format("{0:X2}", r) + String.Format("{0:X2}", g) + String.Format("{0:X2}", b);
         GUI.txtColourRdec.Text = r.ToString();
         GUI.txtColourGdec.Text = g.ToString();
         GUI.txtColourBdec.Text = b.ToString();
         GUI.txtColourRhex.Text = String.Format("{0:X2}", r);
         GUI.txtColourGhex.Text = String.Format("{0:X2}", g);
         GUI.txtColourBhex.Text = String.Format("{0:X2}", b);
         GUI.lblColourSample.BackColor = color;
         GUI.lblColourSample.Image = null;
         // RGB ->HSL conversion
         decimal h = decimal.Round(((decimal)(color.GetHue() / 360) * 240), MidpointRounding.AwayFromZero);
         decimal s = decimal.Round(((decimal)color.GetSaturation() * 240), MidpointRounding.AwayFromZero);
         decimal l = decimal.Round(((decimal)color.GetBrightness() * 240), MidpointRounding.AwayFromZero);
         GUI.txtColourH.Text = h.ToString();
         GUI.txtColourS.Text = s.ToString();
         GUI.txtColourL.Text = l.ToString();
     }
 }

 /// <summary>
 /// Initialize a new instance of the ColorHSL class.
 /// </summary>
 /// <param name="c">Initialize from an existing Color.</param>
 public ColorHSL(Color c)
 {
     // Initialize from the color instance
     _hue = c.GetHue() / 360f;
     _saturation = c.GetBrightness();
     _luminance = c.GetSaturation();
 }

        private static double CalculateColorDifference(Color lhs, Color rhs)
        {
            double hue = lhs.GetHue() - rhs.GetHue();
            double brightness = lhs.GetBrightness() - rhs.GetBrightness();
            double saturation = lhs.GetSaturation() - rhs.GetSaturation();

            return Math.Sqrt(hue * hue + brightness * brightness + saturation * saturation);
        }

 public HslColor(Color color)
 {
   _alpha = color.A;
   _hue = color.GetHue();
   _saturation = color.GetSaturation();
   _lightness = color.GetBrightness();
   _isEmpty = false;
 }

 /// <summary>
 /// Uses the hue values from the specified start and end color to set the handle positions.
 /// </summary>
 /// <param name="startColor">The start color that represents the left hue</param>
 /// <param name="endColor">The start color that represents the right hue</param>
 public void SetRange(Color startColor, Color endColor)
 {
     int hStart = (int)startColor.GetHue();
     int hEnd = (int)endColor.GetHue();
     _inverted = (hStart > hEnd);
     LeftValue = hStart;
     RightValue = hEnd;
 }

        // Normalised so that h is 0..1, not 0..360
        public static void ColorToHSV(Color color, out float hue, out float saturation, out float 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 = color.GetHue() / 360.0f;
            saturation = (float) (max == 0 ? 0 : 1d - 1d * min / max);
            value = (float) (max / 255d);
        }

        public HSV(Color color)
        {
            int max = Math.Max(color.R, Math.Max(color.G, color.B));
            int min = Math.Min(color.R, Math.Min(color.G, color.B));

            this.Hue = color.GetHue();
            this.Saturation = (max == 0) ? 0 : 1d - (1d * min / max);
            this.Value = max / 255d;
        }

        public static ColorSlider Hue(VisualDirection direction, float knobWidth, float minVisualLength, 
			Color color, Reaction<float> changed)
        {
            return new ColorSlider (direction, knobWidth, minVisualLength, 0f, 1f, color.GetHue (),
                new [] {
                    Color.Red, Color.Orange, Color.Yellow, Color.Green, Color.Blue, Color.Indigo,
                    Color.Violet, Color.Red
                }, changed);
        }

        public static void ColorToHSV(Color color, out double hue, out double saturation, out double 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 = color.GetHue();
            saturation = (max == 0) ? 0 : 1d - (1d * min / max);
            value = max / 255d;
        }