C# Color.GetSaturation方法代码示例

		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 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;
            }
        }

 /// <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();
 }

        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 HSLColor(Color color)
 {
     RGB = color;
     H = (byte)((color.GetHue() / 360.0f) * 255);
     S = (byte)(color.GetSaturation() * 255);
     L = (byte)(color.GetBrightness() * 255);
 }

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

 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>
 /// Uses the saturation of the specified values to set the left and right values for this slider.
 /// </summary>
 /// <param name="startColor">The color that specifies the left saturation</param>
 /// <param name="endColor">The color that specifies the right saturation</param>
 public void SetSaturation(Color startColor, Color endColor)
 {
     float sStart = startColor.GetSaturation();
     float sEnd = endColor.GetSaturation();
     _inverted = sEnd < sStart;
     LeftValue = sStart;
     RightValue = sEnd;
 }

        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>
        /// Initializes a new instance of the <see cref="DistinctColorInfo"/> struct.
        /// </summary>
        public DistinctColorInfo(Color color)
        {
            Color = color.ToArgb();
            Count = 1;

            Hue = Convert.ToInt32(color.GetHue()*Factor);
            Saturation = Convert.ToInt32(color.GetSaturation()*Factor);
            Brightness = Convert.ToInt32(color.GetBrightness()*Factor);
        }

        //
        /// <summary> 
        /// Converts RGB to HSL 
        /// </summary> 
        /// <remarks>Takes advantage of whats already built in to .NET by using the Color.GetHue, Color.GetSaturation and Color.GetBrightness methods</remarks> 
        /// <param name="c">A Color to convert</param> 
        /// <returns>An HSL value</returns> 
        public static HSL GetHSL(Color c)
        {
            HSL hsl = new HSL();

            hsl.H = c.GetHue() / 360.0; // we store hue as 0-1 as opposed to 0-360
            hsl.L = c.GetBrightness();
            hsl.S = c.GetSaturation();

            return hsl;
        }

 /// <summary>
 /// Constructor with ARGB color
 /// </summary>
 /// <param name="color">System.Drawing.Color value</param>
 public HSL(Color color)
 {
     try
     {
         this.HSLHelper(color.GetHue() / 360.0, color.GetSaturation(), color.GetBrightness());
     }
     catch (Exception ee)
     {
         throw new GFXConversionException("HSL Constructor Error", ee);
     }
 }

        public Tone GetTone(Color pixel)
        {
            float hue = pixel.GetHue();
            float brightness = pixel.GetBrightness();
            float saturation = pixel.GetSaturation();

            var frequency = ConvertToFrequency(hue);
            var duration = ConvertToDuration(brightness);
            var volume = ConvertToVolume(saturation);
            //var duration = ConvertToDuration(saturation);
            //var volume = ConvertToVolume(brightness);

            return new Tone {Frequency = frequency, Duration = duration, Volume = volume};
        }