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