internal static HSB GetHSB(this RGBColor rgb) { var hsb = new HSB { Hue = (int)rgb.GetHue(), Saturation = (int)rgb.GetSaturation(), Brightness = (int)rgb.GetBrightness() }; return hsb; }
//------------------------------------------------------------------------- // TEXTURE METHODS //------------------------------------------------------------------------- public void Apply(Texture2D t) { HSB transformer = new HSB(); hue %= 360.0f; if (hue < 0.0f) { hue += 360.0f; } for (int i=0; i<t.mipmapCount; i++) { Color[] pixels = t.GetPixels(i); for (int j=0; j<pixels.Length; j++) { transformer.FromARGB(ref pixels[j]); transformer.hue += hue; transformer.brightness += brightness; transformer.saturation += saturation; transformer.hue = transformer.hue >= 360.0f ? transformer.hue-360.0f: transformer.hue; transformer.brightness = transformer.brightness < 0.0f ? 0.0f : transformer.brightness > 1.0f ? 1.0f: transformer.brightness; transformer.saturation = transformer.saturation < 0.0f ? 0.0f : transformer.saturation > 1.0f ? 1.0f : transformer.brightness; transformer.ToARGB(out pixels[j]); } t.SetPixels(pixels, i); } t.Apply(false); }
public static RGBColor ToRgb(this State state) { HSB hsb = new HSB(); hsb.Brightness = state.Brightness; if (state.Hue.HasValue) hsb.Hue = state.Hue.Value; if (state.Saturation.HasValue) hsb.Saturation = state.Saturation.Value; return hsb.GetRGB(); }
/// <summary> /// Apply filter. /// </summary> /// <param name="bmData">Bitmap data</param> /// <param name="bmMax">Bitmap data</param> /// <param name="bmMin">Bitmap data</param> private unsafe void ApplyHSB(BitmapData bmData, BitmapData bmMax, BitmapData bmMin) { byte *p = (byte *)bmData.Scan0.ToPointer(); byte *pMax = (byte *)bmMax.Scan0.ToPointer(); byte *pMin = (byte *)bmMin.Scan0.ToPointer(); int width = bmData.Width, height = bmData.Height, stride = bmData.Stride; float required = 1.0f - this.contrast; Parallel.For(0, height, j => { HSB imag; HSB imax; HSB imin; RGB rgb; int i, k, k1, k2, jstride = j * stride; float mag, max, min; float num1, num2, num3; for (i = 0; i < width; i++) { k = jstride + i * 4; k1 = k + 1; k2 = k + 2; imag = HSB.FromRGB(p[k2], p[k1], p[k]); imax = HSB.FromRGB(pMax[k2], pMax[k1], pMax[k]); imin = HSB.FromRGB(pMin[k2], pMin[k1], pMin[k]); mag = imag.Brightness; max = imax.Brightness; min = imin.Brightness; num1 = max - min; if (num1 < required) { num2 = min + (required - num1) * min / (num1 - 1f); min = Maths.Float(num2); max = Maths.Float(num2 + required); } num1 = max - min; num3 = mag - min; if (num1 > 0) { imag.Brightness = num3 / num1; rgb = imag.ToRGB; p[k2] = rgb.Red; p[k1] = rgb.Green; p[k] = rgb.Blue; } } } ); }
/// <summary> /// Converts to RGB. /// </summary> /// <param name="hsb">The HSB.</param> /// <returns></returns> internal static RGB ConvertToRGB(HSB hsb) { double chroma = hsb.S * hsb.B, hue2 = hsb.H / 60, x = chroma * (1 - Math.Abs(hue2 % 2 - 1)), r1 = 0d, g1 = 0d, b1 = 0d; if (hue2 >= 0 && hue2 < 1) { r1 = chroma; g1 = x; } else if (hue2 >= 1 && hue2 < 2) { r1 = x; g1 = chroma; } else if (hue2 >= 2 && hue2 < 3) { g1 = chroma; b1 = x; } else if (hue2 >= 3 && hue2 < 4) { g1 = x; b1 = chroma; } else if (hue2 >= 4 && hue2 < 5) { r1 = x; b1 = chroma; } else if (hue2 >= 5 && hue2 <= 6) { r1 = chroma; b1 = x; } double m = hsb.B - chroma; return(new RGB() { R = r1 + m, G = g1 + m, B = b1 + m }); }
internal static RGB ConvertToRGB(HSB hsb) { // Following code is taken as it is from MSDN. See link below. // By: <a href="http://blogs.msdn.com/b/codefx/archive/2012/02/09/create-a-color-picker-for-windows-phone.aspx" title="MSDN" target="_blank">Yi-Lun Luo</a> double chroma = hsb.S * hsb.B; double hue2 = hsb.H / 60; double x = chroma * (1 - Math.Abs(hue2 % 2 - 1)); double r1 = 0d; double g1 = 0d; double b1 = 0d; if (hue2 >= 0 && hue2 < 1) { r1 = chroma; g1 = x; } else if (hue2 >= 1 && hue2 < 2) { r1 = x; g1 = chroma; } else if (hue2 >= 2 && hue2 < 3) { g1 = chroma; b1 = x; } else if (hue2 >= 3 && hue2 < 4) { g1 = x; b1 = chroma; } else if (hue2 >= 4 && hue2 < 5) { r1 = x; b1 = chroma; } else if (hue2 >= 5 && hue2 <= 6) { r1 = chroma; b1 = x; } double m = hsb.B - chroma; return(new RGB() { R = r1 + m, G = g1 + m, B = b1 + m }); }
/// <summary> /// Apply filter. /// </summary> /// <param name="bmData">Bitmap data</param> public unsafe void Apply(BitmapData bmData) { byte *p = (byte *)bmData.Scan0.ToPointer(); int width = bmData.Width, height = bmData.Height, stride = bmData.Stride; Parallel.For(0, height, j => { HSB hsb; RGB rgb; int i, k, jstride = j * stride; for (i = 0; i < width; i++) { // This function modifies a given image in order to keep a specific hue // (given too) and to desaturate the rest of the image. This procedure // originates a image with black and white colormap, excluding the parts // colored with that hue. // Victor Martnez Cagigal, 23/02/2015 // // Designed for UMapx.NET by Valery Asiryan, 2018. k = jstride + i * 4; // Convert to hsb: hsb = HSB.FromRGB(p[k + 2], p[k + 1], p[k + 0]); // Getting hue and saturation parameters: float hue = hsb.Hue, saturation = hsb.Saturation; // Applying filter: if (min < max) { hsb.Saturation = (hue > min && hue < max) ? saturation : 0; } else { hsb.Saturation = ((hue > min && hue <= 360) || (hue < max && hue >= 0)) ? saturation : 0; } // Convert to rgb: rgb = hsb.ToRGB; p[k + 0] = rgb.Blue; p[k + 1] = rgb.Green; p[k + 2] = rgb.Red; } } ); return; }
private COLOR GetColor() { COLOR mycolor = Color.White; switch (this.colorFormat) { case ColorFormat.RGB: mycolor = new COLOR((short)values[0], (short)values[1], (short)values[2]); break; case ColorFormat.ARGB: mycolor = new COLOR((short)values[0], (short)values[1], (short)values[2], (short)values[3]); break; case ColorFormat.CMYK: CMYK c = new CMYK(0, 0, 0, 0); c.C100 = (float)values[0]; c.M100 = (float)values[1]; c.Y100 = (float)values[2]; c.K100 = (float)values[3]; mycolor = c.ToColor(); break; case ColorFormat.HSB: case ColorFormat.HSV: HSB hsb = new HSB(0, 0, 0); hsb.Hue360 = (float)values[0]; hsb.Saturation100 = (float)values[1]; hsb.Brightness100 = (float)values[2]; mycolor = hsb.ToColor(); break; case ColorFormat.HSL: HSL hsl = new HSL(0, 0, 0); hsl.Hue360 = (float)values[0]; hsl.Saturation100 = (float)values[1]; hsl.Lightness100 = (float)values[2]; mycolor = hsl.ToColor(); break; } return(mycolor); }
private static ColorResult ConvertCMYK(ColorSpace resultSpace, ColorSource source) { ColorResult color; double c = source.component0; double m = source.component1; double y = source.component2; double k = source.component3; switch (resultSpace) { case ColorSpace.RGBSpace: RGB rgb = ColorConverter.CMYKtoRGB(c, m, y, k); color = new ColorResult(rgb.Red, rgb.Green, rgb.Blue); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.CMYKtoHSB(c, m, y, k); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.HSLSpace: HSL hsl = ColorConverter.CMYKtoHSL(c, m, y, k); color = new ColorResult(hsl.Hue, hsl.Saturation, hsl.Luminance); break; case ColorSpace.LabSpace: Lab lab = ColorConverter.CMYKtoLab(c, m, y, k); color = ScaleCIELabOutputRange(lab); break; case ColorSpace.XYZSpace: XYZ xyz = ColorConverter.CMYKtoXYZ(c, m, y, k); color = new ColorResult(xyz.X, xyz.Y, xyz.Z); break; case ColorSpace.GraySpace: color = new ColorResult(ColorConverter.CMYKtoRGB(c, m, y, k).GetIntensity(source.maxChannelValue)); break; default: throw new InvalidEnumArgumentException("Unsupported color space conversion", (int)resultSpace, typeof(ColorSpace)); } return(color); }
protected override void DrawHSBHue() { using (Graphics g = Graphics.FromImage(bmp)) { HSB color = new HSB(0f, 100, 100, SelectedColor.ARGB.A); for (int y = 0; y < clientHeight; y++) { color.Hue = (float)(1.0 - ((double)y / clientHeight)); using (Pen pen = new Pen(color)) { g.DrawLine(pen, 0, y, clientWidth, y); } } } }
private static ColorResult ConvertXYZ(ColorSpace resultSpace, ColorSource source) { ColorResult color; double x = source.component0; double y = source.component1; double z = source.component2; switch (resultSpace) { case ColorSpace.RGBSpace: RGB rgb = ColorConverter.XYZtoRGB(x, y, z); color = new ColorResult(rgb.Red, rgb.Green, rgb.Blue); break; case ColorSpace.CMYKSpace: CMYK cmyk = ColorConverter.XYZtoCMYK(x, y, z); color = new ColorResult(cmyk.Cyan, cmyk.Magenta, cmyk.Yellow, cmyk.Black); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.XYZtoHSB(x, y, z); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.HSLSpace: HSL hsl = ColorConverter.XYZtoHSL(x, y, z); color = new ColorResult(hsl.Hue, hsl.Saturation, hsl.Luminance); break; case ColorSpace.LabSpace: Lab lab = ColorConverter.XYZtoLab(x, y, z); color = ScaleCIELabOutputRange(lab); break; case ColorSpace.GraySpace: color = new ColorResult(ColorConverter.XYZtoRGB(x, y, z).GetIntensity(source.maxChannelValue)); break; default: throw new InvalidEnumArgumentException("Unsupported color space conversion", (int)resultSpace, typeof(ColorSpace)); } return(color); }
private static ColorResult ConvertHSL(ColorSpace resultSpace, ColorSource source) { ColorResult color; double h = source.component0; double s = source.component1; double l = source.component2; switch (resultSpace) { case ColorSpace.RGBSpace: RGB rgb = ColorConverter.HSLtoRGB(h, s, l); color = new ColorResult(rgb.Red, rgb.Green, rgb.Blue); break; case ColorSpace.CMYKSpace: CMYK cmyk = ColorConverter.HSLtoCMYK(h, s, l); color = new ColorResult(cmyk.Cyan, cmyk.Magenta, cmyk.Yellow, cmyk.Black); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.HSLtoHSB(h, s, l); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.LabSpace: Lab lab = ColorConverter.HSLToLab(h, s, l); color = ScaleCIELabOutputRange(lab); break; case ColorSpace.XYZSpace: XYZ xyz = ColorConverter.HSLtoXYZ(h, s, l); color = new ColorResult(xyz.X, xyz.Y, xyz.Z); break; case ColorSpace.GraySpace: color = new ColorResult(ColorConverter.HSLtoRGB(h, s, l).GetIntensity(source.maxChannelValue)); break; default: throw new InvalidEnumArgumentException(nameof(resultSpace), (int)resultSpace, typeof(ColorSpace)); } return(color); }
private static ColorResult ConvertLAB(ColorSpace resultSpace, ColorSource source) { ColorResult color; double l = source.component0; double a = source.component1; double b = source.component2; switch (resultSpace) { case ColorSpace.RGBSpace: RGB rgb = ColorConverter.LabtoRGB(l, a, b); color = new ColorResult(rgb.Red, rgb.Green, rgb.Blue); break; case ColorSpace.CMYKSpace: CMYK cmyk = ColorConverter.LabtoCMYK(l, a, b); color = new ColorResult(cmyk.Cyan, cmyk.Magenta, cmyk.Yellow, cmyk.Black); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.LabtoHSB(l, a, b); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.HSLSpace: HSL hsl = ColorConverter.LabtoHSL(l, a, b); color = new ColorResult(hsl.Hue, hsl.Saturation, hsl.Luminance); break; case ColorSpace.XYZSpace: XYZ xyz = ColorConverter.LabtoXYZ(l, a, b); color = new ColorResult(xyz.X, xyz.Y, xyz.Z); break; case ColorSpace.GraySpace: color = new ColorResult(ColorConverter.LabtoRGB(l, a, b).GetIntensity(source.maxChannelValue)); break; default: throw new InvalidEnumArgumentException("Unsupported color space conversion", (int)resultSpace, typeof(ColorSpace)); } return(color); }
private static ColorResult ConvertRGB(ColorSpace resultSpace, ColorSource source) { ColorResult color; double red = source.component0; double green = source.component1; double blue = source.component2; switch (resultSpace) { case ColorSpace.CMYKSpace: CMYK cmyk = ColorConverter.RGBtoCMYK(red, green, blue); color = new ColorResult(cmyk.Cyan, cmyk.Magenta, cmyk.Yellow, cmyk.Black); break; case ColorSpace.GraySpace: color = new ColorResult(ColorConverter.GetRGBIntensity(red, green, blue, source.maxChannelValue)); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.RGBtoHSB(red, green, blue); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.HSLSpace: HSL hsl = ColorConverter.RGBtoHSL(red, green, blue); color = new ColorResult(hsl.Hue, hsl.Saturation, hsl.Luminance); break; case ColorSpace.LabSpace: Lab lab = ColorConverter.RGBtoLab(red, green, blue); color = ScaleCIELabOutputRange(lab); break; case ColorSpace.XYZSpace: XYZ xyz = ColorConverter.RGBtoXYZ(red, green, blue); color = new ColorResult(xyz.X, xyz.Y, xyz.Z); break; default: throw new InvalidEnumArgumentException("Unsupported color space conversion", (int)resultSpace, typeof(ColorSpace)); } return(color); }
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken) { HSB hsb = new HSB(0, 255, 255); while (!cancellationToken.IsCancellationRequested) { layer.SetState(cancellationToken, hsb.GetRGB(), 1); await Task.Delay(waitTime() / 10); hsb.Hue += 100; if (hsb.Hue >= HSB.HueMaxValue) { hsb.Hue = 0; } } }
public override Color BlendColor(Color l, Color r) { Color c = r; HSB hsv = ColorSpaceHelper.RGBtoHSB(c); hsv.Brightness += (((IsPreview ? _noise : _noise2).NextDouble() - 0.5f) * 2) * GlobalSettings.NoiseSaturation; if (hsv.Brightness < 0) { hsv.Brightness = 0; } if (hsv.Brightness > 1) { hsv.Brightness = 1; } return(Color.FromArgb(r.A, ColorSpaceHelper.HSBtoColor(hsv))); }
// slider controls hue // x = saturation 0 -> 100 // y = brightness 100 -> 0 protected override void DrawHSBHue() { using (Graphics g = Graphics.FromImage(bmp)) { HSB start = new HSB((int)selectedColor.HSB.Hue360, 0, 0, selectedColor.ARGB.A); HSB end = new HSB((int)selectedColor.HSB.Hue360, 100, 0, selectedColor.ARGB.A); for (int y = 0; y < clientHeight; y++) { start.Brightness = end.Brightness = (float)(1.0 - ((double)y / (clientHeight))); using (LinearGradientBrush brush = new LinearGradientBrush(new Rectangle(0, 0, clientWidth, 1), start, end, LinearGradientMode.Horizontal)) { g.FillRectangle(brush, new Rectangle(0, y, clientWidth, 1)); } } } }
// slider controls brightness // x = hue 0 -> 360 // y = saturation 100 -> 0 protected override void DrawHSBBrightness() { using (Graphics g = Graphics.FromImage(bmp)) { HSB start = new HSB(0, 100, (int)selectedColor.HSB.Brightness100, selectedColor.ARGB.A); HSB end = new HSB(0, 0, (int)selectedColor.HSB.Brightness100, selectedColor.ARGB.A); for (int x = 0; x < clientWidth; x++) { start.Hue = end.Hue = (float)((double)x / (clientHeight)); using (LinearGradientBrush brush = new LinearGradientBrush(new Rectangle(0, 0, 1, clientHeight), start, end, LinearGradientMode.Vertical)) { g.FillRectangle(brush, new Rectangle(x, 0, 1, clientHeight)); } } } }
/// <summary> /// Converts a colour from HSL to RGB /// </summary> /// <remarks>Adapted from the algoritm in Foley and Van-Dam</remarks> /// <param name="hsb">The HSL value</param> /// <returns>A Color structure containing the equivalent RGB values</returns> public static Color HSB_to_RGB(HSB hsb) { int Max, Mid, Min; double q; Max = (int)Math.Round(hsb.B * 255); Min = (int)Math.Round((1.0 - hsb.S) * (hsb.B / 1.0) * 255); q = (double)(Max - Min) / 255; if (hsb.H >= 0 && hsb.H <= (double)1 / 6) { Mid = (int)Math.Round(((hsb.H - 0) * q) * 1530 + Min); return(Color.FromArgb(Max, Mid, Min)); } else if (hsb.H <= (double)1 / 3) { Mid = (int)Math.Round(-((hsb.H - (double)1 / 6) * q) * 1530 + Max); return(Color.FromArgb(Mid, Max, Min)); } else if (hsb.H <= 0.5) { Mid = (int)Math.Round(((hsb.H - (double)1 / 3) * q) * 1530 + Min); return(Color.FromArgb(Min, Max, Mid)); } else if (hsb.H <= (double)2 / 3) { Mid = (int)Math.Round(-((hsb.H - 0.5) * q) * 1530 + Max); return(Color.FromArgb(Min, Mid, Max)); } else if (hsb.H <= (double)5 / 6) { Mid = (int)Math.Round(((hsb.H - (double)2 / 3) * q) * 1530 + Min); return(Color.FromArgb(Mid, Min, Max)); } else if (hsb.H <= 1.0) { Mid = (int)Math.Round(-((hsb.H - (double)5 / 6) * q) * 1530 + Max); return(Color.FromArgb(Max, Min, Mid)); } else { return(Color.FromArgb(0, 0, 0)); } }
public static Color GetContrast(this Color source, bool preserveOpacity) { Color inputColor = source; //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion) byte avgColorValue = (byte)((source.R + source.G + source.B) / 3); int diff_r = Math.Abs(source.R - avgColorValue); int diff_g = Math.Abs(source.G - avgColorValue); int diff_b = Math.Abs(source.B - avgColorValue); if (diff_r < 20 && diff_g < 20 && diff_b < 20) //The color is a shade of gray { if (avgColorValue < 123) //color is dark { inputColor = Color.FromArgb(50, 230, 220); //inputColor.B = 220; //inputColor.G = 230; //inputColor.R = 50; } else { inputColor = Color.FromArgb(255, 255, 50); //inputColor.R = 255; //inputColor.G = 255; //inputColor.B = 50; } } byte sourceAlphaValue = source.A; if (!preserveOpacity) { sourceAlphaValue = Math.Max(source.A, (byte)127); //We don't want contrast color to be more than 50% transparent ever. } RGB rgb = new RGB { R = inputColor.R, G = inputColor.G, B = inputColor.B }; HSB hsb = ConvertToHSB(rgb); hsb.H = hsb.H < 180? hsb.H + 180 : hsb.H - 180; //hsb.B = isColorDark ? 240 : 50; //Added to create dark on light, and light on dark rgb = ConvertToRGB(hsb); //return new Color { A = sourceAlphaValue, R = rgb.R, G = (byte)rgb.G, B = (byte)rgb.B }; return(Color.FromArgb(sourceAlphaValue, (int)rgb.R, (int)rgb.G, (int)rgb.B)); }
/// <summary> /// Retrieves the contrast colour. /// </summary> /// <param name="source">The source.</param> /// <param name="preserveOpacity">if set to <c>true</c> [preserve opacity].</param> /// <returns></returns> public static Color RetrieveContrastColour(this Color source, bool preserveOpacity = true) { Color inputColour = source; //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion) byte avgColourValue = (byte)((source.R + source.G + source.B) / 3); int diff_r = Math.Abs(source.R - avgColourValue), diff_g = Math.Abs(source.G - avgColourValue), diff_b = Math.Abs(source.B - avgColourValue); // Shade of gray if (diff_r < 20 && diff_g < 20 && diff_b < 20) { if (avgColourValue < 123) { inputColour = Color.FromArgb(source.A, 220, 230, 50); } else { inputColour = Color.FromArgb(source.A, 255, 225, 50); } } byte sourceAlphaValue = source.A; if (!preserveOpacity) { sourceAlphaValue = Math.Max(source.A, (byte)127); } RGB rgb = new RGB { R = inputColour.R, G = inputColour.G, B = inputColour.B }; HSB hsb = ConvertToHSB(rgb); hsb.H = hsb.H < 180 ? hsb.H + 180 : hsb.H - 180; //_hsb.B = _isColorDark ? 240 : 50; //Added to create dark on light, and light on dark rgb = ConvertToRGB(hsb); return(Color.FromArgb((int)sourceAlphaValue, (int)rgb.R, (int)rgb.G, (int)rgb.B)); }
private static ColorResult ConvertGray(ColorSpace resultSpace, ColorSource source) { ColorResult color; double gray = source.component0; switch (resultSpace) { case ColorSpace.RGBSpace: color = new ColorResult(gray, gray, gray); break; case ColorSpace.CMYKSpace: CMYK cmyk = ColorConverter.RGBtoCMYK(gray, gray, gray); color = new ColorResult(cmyk.Cyan, cmyk.Magenta, cmyk.Yellow, cmyk.Black); break; case ColorSpace.HSBSpace: HSB hsb = ColorConverter.RGBtoHSB(gray, gray, gray); color = new ColorResult(hsb.Hue, hsb.Saturation, hsb.Brightness); break; case ColorSpace.HSLSpace: HSL hsl = ColorConverter.RGBtoHSL(gray, gray, gray); color = new ColorResult(hsl.Hue, hsl.Saturation, hsl.Luminance); break; case ColorSpace.LabSpace: Lab lab = ColorConverter.RGBtoLab(gray, gray, gray); color = ScaleCIELabOutputRange(lab); break; case ColorSpace.XYZSpace: XYZ xyz = ColorConverter.RGBtoXYZ(gray, gray, gray); color = new ColorResult(xyz.X, xyz.Y, xyz.Z); break; default: throw new InvalidEnumArgumentException(nameof(resultSpace), (int)resultSpace, typeof(ColorSpace)); } return(color); }
public async Task Start(EntertainmentLayer layer, Func <TimeSpan> waitTime, RGBColor?color, CancellationToken cancellationToken) { Random r = new Random(); while (!cancellationToken.IsCancellationRequested) { var nextcolor = color ?? RGBColor.Random(); var hsb = nextcolor.GetHSB(); foreach (var light in layer) { var addHue = r.Next(-6000, 6000); var addBri = r.Next(-100, 100); var randomHsb = new HSB(hsb.Hue + addHue, hsb.Saturation, WrapValue(255, hsb.Brightness + addBri)); light.SetState(cancellationToken, randomHsb.GetRGB(), 1, UseTransition ? waitTime() / 2 : TimeSpan.Zero); } await Task.Delay(waitTime()); } }
/// <summary> /// Create a hue bitmap. Used to fabricate the png files used in the LightControl. I left it /// in, so you can generate new files easily (with different dimensions if you wish). /// </summary> public static void PaintHue() { Bitmap bmp = new Bitmap(290, 25); Graphics gr = Graphics.FromImage(bmp); RGBColor rgbC = new RGBColor(0, 0, 0); HSB hsb = new HSB(0, 255, 255); Color c; int hue; for (int h = 0; h < bmp.Width; h++) { hue = (int)(HSB.HueMaxValue * 1.0 * h / bmp.Width); hsb.Hue = hue; rgbC = hsb.GetRGB(); c = fromRGB(rgbC); using (Pen p = new Pen(c)) gr.DrawLine(p, h, 0, h, bmp.Height); } bmp.Save("hue.png"); }
public static Color GetContrast(this Color source, bool preserveOpacity = true) { byte averageColourValue = (byte)((source.R + source.G + source.B) / 3); Color inputColourSource = source; int diffR = Math.Abs(source.R - averageColourValue), diffG = Math.Abs(source.G - averageColourValue), diffB = Math.Abs(source.B - averageColourValue); if (diffR < 20 && diffG < 20 && diffB < 20) { // Colour is dark if (averageColourValue < 123) { inputColourSource = Color.FromArgb(source.A, 220, 230, 50); } else { inputColourSource = Color.FromArgb(source.A, 255, 255, 50); } } byte sourceAlphaValue = source.A; if (!preserveOpacity) { sourceAlphaValue = Math.Max(source.A, (byte)127); } RGB rgb = new RGB { R = inputColourSource.R, G = inputColourSource.G, B = inputColourSource.B }; HSB hsb = ConvertToHSB(rgb); hsb.H = hsb.H < 180 ? hsb.H + 180 : hsb.H - 180; rgb = ConvertToRGB(hsb); return(Color.FromArgb((int)sourceAlphaValue, (int)rgb.R, (int)rgb.G, (int)rgb.B)); }
private RGBColor ClampBrightness(string colorString, LightData lightData, int brightness) { var oColor = new RGBColor(colorString); // Clamp our brightness based on settings long bClamp = 255 * brightness / 100; if (lightData.OverrideBrightness) { var newB = lightData.Brightness; bClamp = 255 * newB / 100; } var hsb = new HSB((int)oColor.GetHue(), (int)oColor.GetSaturation(), (int)oColor.GetBrightness()); if (hsb.Brightness > bClamp) { hsb.Brightness = (int)bClamp; } oColor = hsb.GetRGB(); return(oColor); }
public static Color GetComplementaryColor(Color source) { Color inputColor = source; // If RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, // decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker // side, decrease yellow by about 50% (it will increase in conversion) byte avgColorValue = (byte)((source.R + source.G + source.B) / 3); int diff_r = Math.Abs(source.R - avgColorValue); int diff_g = Math.Abs(source.G - avgColorValue); int diff_b = Math.Abs(source.B - avgColorValue); if (diff_r < 20 && diff_g < 20 && diff_b < 20) //The color is a shade of gray { if (avgColorValue < 123) //color is dark { inputColor.B = 220; inputColor.G = 230; inputColor.R = 50; } else { inputColor.R = 255; inputColor.G = 255; inputColor.B = 50; } } RGB rgb = new RGB { R = inputColor.R, G = inputColor.G, B = inputColor.B }; HSB hsb = ConvertToHSB(rgb); hsb.H = hsb.H < 180 ? hsb.H + 180 : hsb.H - 180; //hsb.B = isColorDark ? 240 : 50; //Added to create dark on light, and light on dark rgb = ConvertToRGB(hsb); return(new Color { A = 255, R = (byte)rgb.R, G = (byte)rgb.G, B = (byte)rgb.B }); }
public static Color GetContrast(this Color source, bool preserveOpacity = true) { Color inputColor = source; //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion) /* * byte avgColorValue = (byte)((source.R + source.G + source.B) / 3); * int diff_r = Math.Abs(source.R - avgColorValue); * int diff_g = Math.Abs(source.G - avgColorValue); * int diff_b = Math.Abs(source.B - avgColorValue); * if (diff_r < 20 && diff_g < 20 && diff_b < 20) //The color is a shade of gray * { * if (avgColorValue < 123) //color is dark * { * inputColor.B = 220; * inputColor.G = 230; * inputColor.R = 50; * } * else * { * inputColor.R = 255; * inputColor.G = 255; * inputColor.B = 50; * } * }*/ byte sourceAlphaValue = preserveOpacity ? source.A : (byte)255; RGB rgb = new RGB { R = inputColor.R, G = inputColor.G, B = inputColor.B }; HSB hsb = ConvertToHSB(rgb); hsb.H = hsb.H < 180 ? hsb.H + 180 : hsb.H - 180; rgb = ConvertToRGB(hsb); return(new Color { A = sourceAlphaValue, R = (byte)rgb.R, G = (byte)rgb.G, B = (byte)rgb.B }); }
public static async Task SendCommandA(BeatmapEventData data, HSB hsbColor, double brightness, HSB inithsbColor, HSB endhsbColor, double time, bool gradient) { CancellationToken token = LightInfo.token; EntertainmentLayer entLayer = LightInfo.layer; if (gradient == true) { switch (data.value) { case 0: entLayer.SetState(token, null, brightness); break; case 1: entLayer.SetState(token, inithsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, endhsbColor.GetRGB(), 1, TimeSpan.FromSeconds(time)); break; case 5: entLayer.SetState(token, inithsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, endhsbColor.GetRGB(), 1, TimeSpan.FromSeconds(time)); break; } } else { switch (data.value) { case 0: entLayer.SetState(token, null, brightness); break; case 1: entLayer.SetState(token, hsbColor.GetRGB(), 1); break; case 2: entLayer.SetState(token, hsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, hsbColor.GetRGB(), brightness, TimeSpan.FromSeconds(1)); break; case 3: entLayer.SetState(token, hsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, hsbColor.GetRGB(), brightness, TimeSpan.FromSeconds(1)); break; case 5: entLayer.SetState(token, hsbColor.GetRGB(), 1); break; case 6: entLayer.SetState(token, hsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, hsbColor.GetRGB(), brightness, TimeSpan.FromSeconds(1)); break; case 7: entLayer.SetState(token, hsbColor.GetRGB(), 1); await Task.Delay(TimeSpan.FromMilliseconds(20), token); entLayer.SetState(token, hsbColor.GetRGB(), brightness, TimeSpan.FromSeconds(1)); break; } } }
internal static RGB ConvertToRGB(HSB hsb) { // Following code is taken as it is from MSDN. See link below. // By: <a href="http://blogs.msdn.com/b/codefx/archive/2012/02/09/create-a-color-picker-for-windows-phone.aspx" title="MSDN" target="_blank">Yi-Lun Luo</a> var chroma = hsb.S*hsb.B; var hue2 = hsb.H/60; var x = chroma*(1 - Math.Abs(hue2%2 - 1)); var r1 = 0d; var g1 = 0d; var b1 = 0d; if (hue2 >= 0 && hue2 < 1) { r1 = chroma; g1 = x; } else if (hue2 >= 1 && hue2 < 2) { r1 = x; g1 = chroma; } else if (hue2 >= 2 && hue2 < 3) { g1 = chroma; b1 = x; } else if (hue2 >= 3 && hue2 < 4) { g1 = x; b1 = chroma; } else if (hue2 >= 4 && hue2 < 5) { r1 = x; b1 = chroma; } else if (hue2 >= 5 && hue2 <= 6) { r1 = chroma; b1 = x; } var m = hsb.B - chroma; return new RGB { R = r1 + m, G = g1 + m, B = b1 + m }; }
private void cLogo_Draw(Graphics g) { g.SetHighQuality(); using (Matrix m = new Matrix()) { m.RotateAt(45, new PointF(mX, mY)); g.Transform = m; } using (Pen pen = new Pen(lineColor, 2)) { for (int i = 0; i <= mX; i += step) { g.DrawLine(pen, i, mY, mX, mY - i); // Left top g.DrawLine(pen, mX, i, mX + i, mY); // Right top g.DrawLine(pen, w - i, mY, mX, mY + i); // Right bottom g.DrawLine(pen, mX, h - i, mX - i, mY); // Left bottom /* * g.DrawLine(pen, i, mY, mX, mY - i); // Left top * g.DrawLine(pen, w - i, mY, mX, mY - i); // Right top * g.DrawLine(pen, w - i, mY, mX, mY + i); // Right bottom * g.DrawLine(pen, i, mY, mX, mY + i); // Left bottom */ /* * g.DrawLine(pen, mX, i, i, mY); // Left top * g.DrawLine(pen, mX, i, w - i, mY); // Right top * g.DrawLine(pen, mX, h - i, w - i, mY); // Right bottom * g.DrawLine(pen, mX, h - i, i, mY); // Left bottom */ } //g.DrawLine(pen, mX, 0, mX, h); } if (!isPaused) { if (step + speed > maxStep) { direction = -speed; } else if (step - speed < minStep) { direction = speed; } step += direction; HSB hsb = lineColor; if (hsb.Hue >= 1) { hsb.Hue = 0; } else { hsb.Hue += 0.01; } lineColor = hsb; } }
private static System.Drawing.Color generateColor(System.Drawing.Color source, bool isaShadeOfSource, HSB min, HSB max) { HSB hsbValues = ConvertToHSB(new RGB { R = source.R, G = source.G, B = source.B }); double h_double = randomizer.NextDouble(); double s_double = randomizer.NextDouble(); double b_double = randomizer.NextDouble(); if (max.B - min.B == 0) { b_double = 0; //do not change Brightness } if (isaShadeOfSource) { min.H = hsbValues.H; max.H = hsbValues.H; h_double = 0; } hsbValues = new HSB { H = Convert.ToDouble(randomizer.Next(Convert.ToInt32(min.H), Convert.ToInt32(max.H))) + h_double, S = Convert.ToDouble((randomizer.Next(Convert.ToInt32(min.S * 100), Convert.ToInt32(max.S * 100))) / 100d), B = Convert.ToDouble(randomizer.Next(Convert.ToInt32(min.B), Convert.ToInt32(max.B))) + b_double }; //Debug.WriteLine("H:{0} | S:{1} | B:{2} [Min_S:{3} | Max_S{4}]", hsbValues.H, _hsbValues.S, _hsbValues.B, min.S, max.S); RGB rgbvalues = ConvertToRGB(hsbValues); return(System.Drawing.Color.FromArgb(source.A, (int)rgbvalues.R, (int)rgbvalues.G, (int)rgbvalues.B)); }
public RGB Convert(HSB input) { var _color = input / HSB.Maximum; double _h = _color[0], _s = _color[1], _b = _color[2]; double r = 0, g = 0, b = 0; if (_s == 0) { r = g = b = _b; } else { _h *= HSB.Maximum[0]; //The color wheel consists of 6 sectors: Figure out which sector we're in... var SectorPosition = _h / 60.0; var SectorNumber = Math.Floor(SectorPosition).ToInt32(); //Get the fractional part of the sector var FractionalSector = SectorPosition - SectorNumber; //Calculate values for the three axes of the color. var p = _b * (1.0 - _s); var q = _b * (1.0 - (_s * FractionalSector)); var t = _b * (1.0 - (_s * (1.0 - FractionalSector))); //Assign the fractional colors to r, g, and b based on the sector the angle is in. switch (SectorNumber) { case 0: r = _b; g = t; b = p; break; case 1: r = q; g = _b; b = p; break; case 2: r = p; g = _b; b = t; break; case 3: r = p; g = q; b = _b; break; case 4: r = t; g = p; b = _b; break; case 5: r = _b; g = p; b = q; break; } } return(new RGB(r, g, b)); }
/// <summary> /// Process parameters and returns a color. /// </summary> /// <param name="source">Color source.</param> /// <param name="isaShadeOfSource">Should source be used to generate the new color.</param> /// <param name="min">Minimum range for HSB.</param> /// <param name="max">Maximum range for HSB.</param> /// <returns>The <see cref="Color" />.</returns> private static Color GenerateColor(Color source, bool isaShadeOfSource, HSB min, HSB max) { HSB hsbValues = ConvertToHSB(new RGB { R = source.R, G = source.G, B = source.B }); double hDouble = Randomizer.NextDouble(); double bDouble = Randomizer.NextDouble(); if (max.B - min.B == 0) { bDouble = 0; // do not change Brightness } if (isaShadeOfSource) { min.H = hsbValues.H; max.H = hsbValues.H; hDouble = 0; } hsbValues = new HSB { H = Convert.ToDouble(Randomizer.Next(Convert.ToInt32(min.H), Convert.ToInt32(max.H))) + hDouble, S = Convert.ToDouble(Randomizer.Next(Convert.ToInt32(min.S * 100), Convert.ToInt32(max.S * 100)) / 100d), B = Convert.ToDouble(Randomizer.Next(Convert.ToInt32(min.B), Convert.ToInt32(max.B))) + bDouble }; tracer.Debug(string.Format("H:{0} | S:{1} | B:{2} [Min_S:{3} | Max_S{4}]", hsbValues.H, hsbValues.S, hsbValues.B, min.S, max.S)); RGB rgbValues = ConvertToRGB(hsbValues); return Color.FromArgb(source.A, (byte)rgbValues.R, (byte)rgbValues.G, (byte)rgbValues.B); }
private void tsmiCopyHSB_Click(object sender, EventArgs e) { HSB hsb = colorPicker.SelectedColor.HSB; ClipboardHelpers.CopyText($"{hsb.Hue360:0.0}°, {hsb.Saturation100:0.0}%, {hsb.Brightness100:0.0}%"); }
public DynamicRectangle(CaptureType ct) { if (ct == CaptureType.CROP) { color = (Color)Engine.ConfigUI.CropBorderArgb; size = (float)Engine.ConfigUI.CropBorderSize; ruler = Engine.ConfigUI.CropShowRuler; changeColor = Engine.ConfigUI.CropDynamicBorderColor; interval = (int)Engine.ConfigUI.CropRegionInterval; step = (int)Engine.ConfigUI.CropRegionStep; colorDiff = (int)Engine.ConfigUI.CropHueRange; } else if (ct == CaptureType.SELECTED_WINDOW) { color = (Color)Engine.ConfigUI.SelectedWindowBorderArgb; size = (float)Engine.ConfigUI.SelectedWindowBorderSize; ruler = Engine.ConfigUI.SelectedWindowRuler; changeColor = Engine.ConfigUI.SelectedWindowDynamicBorderColor; interval = (int)Engine.ConfigUI.SelectedWindowRegionInterval; step = (int)Engine.ConfigUI.SelectedWindowRegionStep; colorDiff = (int)Engine.ConfigUI.SelectedWindowHueRange; } colorHue = color.Hue * 360; colorHueMin = color.Hue * 360 - colorDiff; colorHueMax = color.Hue * 360 + colorDiff; currentStep = step; timer = new Stopwatch(); timer.Start(); }
public DrawingBitmap (Size size) { bitmap = new Bitmap (size.Width, size.Height); float hueadd = 240.0f / (size.Width - 1); float satsub = 241.0f / (size.Height - 1); float satpos = 240.0f; // paint the matrix to the bitmap for (int height = 0; height < size.Height; height++) { float huepos = 0.0f; for (int width = 0; width < size.Width; width++) { HSB hsb = new HSB (); hsb.hue = (int)huepos; hsb.sat = (int)satpos; hsb.bri = 120; // paint it with 120 to get a nice bitmap bitmap.SetPixel (width, height, HSB.HSB2RGB (hsb.hue, hsb.sat, hsb.bri)); huepos += hueadd; } satpos -= satsub; } }
public static HSB RGB2HSB (Color color) { HSB hsb = new HSB (); hsb.hue = (int)((color.GetHue () / 360.0f) * 240); hsb.sat = (int)(color.GetSaturation () * 241); hsb.bri = (int)(color.GetBrightness () * 241); if (hsb.hue > 239) hsb.hue = 239; if (hsb.sat > 240) hsb.sat = 240; if (hsb.bri > 240) hsb.bri = 240; return hsb; }
internal static RGB ConvertToRGB(HSB hsb) { // By: <a href="http://blogs.msdn.com/b/codefx/archive/2012/02/09/create-a-color-picker-for-windows-phone.aspx" title="MSDN" target="_blank">Yi-Lun Luo</a> double chroma = hsb.S * hsb.B; double hue2 = hsb.H / 60; double x = chroma * (1 - Math.Abs(hue2 % 2 - 1)); double r1 = 0d; double g1 = 0d; double b1 = 0d; if (hue2 >= 0 && hue2 < 1) { r1 = chroma; g1 = x; } else if (hue2 >= 1 && hue2 < 2) { r1 = x; g1 = chroma; } else if (hue2 >= 2 && hue2 < 3) { g1 = chroma; b1 = x; } else if (hue2 >= 3 && hue2 < 4) { g1 = x; b1 = chroma; } else if (hue2 >= 4 && hue2 < 5) { r1 = x; b1 = chroma; } else if (hue2 >= 5 && hue2 <= 6) { r1 = chroma; b1 = x; } double m = hsb.B - chroma; return new RGB() { R = r1 + m, G = g1 + m, B = b1 + m }; }