738 lines
25 KiB
C#
738 lines
25 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Windows.Forms;
|
|
|
|
namespace Matrix_App
|
|
{
|
|
partial class ColorWheel
|
|
{
|
|
/// <summary>
|
|
/// Erforderliche Designervariable.
|
|
/// </summary>
|
|
private System.ComponentModel.IContainer components = null;
|
|
|
|
private static readonly int WHEEL_PIXEL_RESOLUTION = 256;
|
|
private static readonly int WHEEL_BORDER_SUBDIVISIONS = 6;
|
|
private static readonly float RADIUS = WHEEL_PIXEL_RESOLUTION / (float) WHEEL_BORDER_SUBDIVISIONS * 4 * 0.5f;
|
|
|
|
private Bitmap wheel;
|
|
|
|
/// transformed triangle vertices in screen space
|
|
private PointF[] transformed = new PointF[3];
|
|
/// triangle verticies in object "local" space
|
|
private PointF[] vertices = {
|
|
new PointF(RADIUS * fcos(0), RADIUS * fsin(0) ),
|
|
new PointF(RADIUS * fcos(120), RADIUS * fsin(120)),
|
|
new PointF(RADIUS * fcos(240), RADIUS * fsin(240))
|
|
};
|
|
|
|
/// gradient between the fully saturated and brightned tone color and white (desaturated)
|
|
private LinearGradientBrush whiteGradient;
|
|
/// gradient between black and transparent, darkens the corner in which value = 0
|
|
private LinearGradientBrush colorGradient;
|
|
/// gradient between transparent and gray
|
|
private LinearGradientBrush grayGradient;
|
|
|
|
// stored HSV values
|
|
private float angle = 180;
|
|
private float saturation = 1f;
|
|
private float value = 1f;
|
|
|
|
// current cursor position
|
|
private Point cursor = new Point();
|
|
private Point origCursor = new Point();
|
|
|
|
public EventHandler handler;
|
|
|
|
private int sRGB = 0;
|
|
|
|
private Boolean entered = false;
|
|
private Boolean release = true;
|
|
|
|
/// <summary>
|
|
/// Slider types:
|
|
/// <ul>
|
|
/// <li>TRIANGLE: for the center triangle</li>
|
|
/// <li>WHEEL: for the outside "wheel" controlling the tone</li>
|
|
/// </ul>
|
|
/// </summary>
|
|
private enum Slider
|
|
{
|
|
TRIANGLE,
|
|
WHEEL
|
|
}
|
|
|
|
private Slider selection = Slider.TRIANGLE;
|
|
private System.Drawing.Drawing2D.Matrix transform;
|
|
|
|
private float ctheta;
|
|
|
|
#region Math-utils
|
|
/// convert degrees to radians
|
|
/// by mapping [0, 360] to [0, 2pi]
|
|
private static float ToRadians(float degree)
|
|
{
|
|
// about equal to pi / 180
|
|
const float PI_OVER_180 = 0.0174532925199f;
|
|
|
|
return degree * PI_OVER_180;
|
|
}
|
|
|
|
/// convert radians to degrees
|
|
/// by mapping [0, 2pi] to [0, 360]
|
|
private static float ToDegree(float radians)
|
|
{
|
|
// about equal to 180 / pi
|
|
const float HUNDERETEIGTHY_OVER_PI = 57.2957795131f;
|
|
|
|
return radians * HUNDERETEIGTHY_OVER_PI;
|
|
}
|
|
|
|
/// Calculates the cosine of degrees as a float
|
|
private static float fcos(float degree)
|
|
{
|
|
return MathF.Cos(ToRadians(degree));
|
|
}
|
|
|
|
/// Calculates the sine of degrees as a float
|
|
private static float fsin(float degree)
|
|
{
|
|
return MathF.Sin(ToRadians(degree));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dotproduct of a and b
|
|
/// </summary>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <returns></returns>
|
|
private float dot(in PointF a, in PointF b)
|
|
{
|
|
return a.X * b.X + a.Y + b.Y;
|
|
}
|
|
|
|
/// Calculates the hypotenuse of a and b
|
|
/// as sqrt(a² + b²)
|
|
private static float hypot(float a, float b)
|
|
{
|
|
return MathF.Sqrt(a * a + b * b);
|
|
}
|
|
|
|
/// Divides the floor of the sum of a and b by 2
|
|
private static int floorMiddle(float a, float b)
|
|
{
|
|
return (int)(a + b) >> 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Computes the traingle area of the pointes a,b,(x | y)
|
|
/// </summary>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
/// <returns></returns>
|
|
private float triangleArea(PointF a, PointF b, float x, float y)
|
|
{
|
|
return MathF.Abs((a.X - x) * (b.Y - y)
|
|
- (b.X - x) * (a.Y - y));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests if the point (x | y) lies inside of the transformed triangle
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
/// <returns></returns>
|
|
private bool triangleIntersect(double x, double y)
|
|
{
|
|
int originalArea = (int)triangleArea(transformed[1], transformed[2], transformed[0].X, transformed[0].Y);
|
|
|
|
int area1 = (int)triangleArea(transformed[0], transformed[1], (float)x, (float)y);
|
|
|
|
int area2 = (int)triangleArea(transformed[1], transformed[2], (float)x, (float)y);
|
|
|
|
int area3 = (int)triangleArea(transformed[2], transformed[0], (float)x, (float)y);
|
|
|
|
return Math.Abs(area1 + area2 + area3 - originalArea) < 3;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert cartesian coordinates (point p) to barycentric coordinates (u,v,w) relative to triangle with verticies a,b,c
|
|
/// </summary>
|
|
/// <param name="p"></param>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <param name="c"></param>
|
|
/// <param name="u"></param>
|
|
/// <param name="v"></param>
|
|
/// <param name="w"></param>
|
|
private void cartesianToBarycnetric(in PointF p, in PointF a, in PointF b, in PointF c, out float u, out float v, out float w)
|
|
{
|
|
var v0 = subtract(b, a);
|
|
var v1 = subtract(c, a);
|
|
var v2 = subtract(p, a);
|
|
|
|
float denom = v0.X * v1.Y - v1.X * v0.Y;
|
|
|
|
v = (v2.X * v1.Y - v1.X * v2.Y) / denom;
|
|
w = (v0.X * v2.Y - v2.X * v0.Y) / denom;
|
|
u = 1.0f - v - w;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clamp barycentric coordinates of toClamp to the triangle specified by a,b,c, so that for every barycenttric coordinates is:
|
|
/// u + v + w == 0 and none of u,v,w is greater than 1 or less than zero.
|
|
/// </summary>
|
|
/// <param name="toClamp"></param>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <param name="c"></param>
|
|
private void clampToBarycentricCoordinates(ref PointF toClamp, in PointF a, in PointF b, in PointF c)
|
|
{
|
|
cartesianToBarycnetric(toClamp, a, b, c, out float u, out float v, out float w);
|
|
|
|
clampBarycentric(ref u, ref v, ref w);
|
|
|
|
barycentricToCartesian(ref toClamp, a, b, c, u, v, w);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert barycentric coordinates u,v,w relative to triangle with verticies a,b,c to cartesian coordinates.
|
|
/// </summary>
|
|
/// <param name="toClamp"></param>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <param name="c"></param>
|
|
/// <param name="u"></param>
|
|
/// <param name="v"></param>
|
|
/// <param name="w"></param>
|
|
private void barycentricToCartesian(ref PointF toClamp, PointF a, PointF b, PointF c, float u, float v, float w)
|
|
{
|
|
toClamp.X = a.X * u + b.X * v + c.X * w;
|
|
toClamp.Y = a.Y * u + b.Y * v + c.Y * w;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clamp x to the range [0, 1]
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <returns></returns>
|
|
private float saturate(float x)
|
|
{
|
|
return MathF.Max(MathF.Min(x, 1.0f), 0.0f);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clamp the barycentric coordinates, so that
|
|
/// u + v + w == 1
|
|
/// without any of u,v,w being greater than 1 or less than zero.
|
|
/// </summary>
|
|
/// <param name="u"></param>
|
|
/// <param name="v"></param>
|
|
/// <param name="w"></param>
|
|
private void clampBarycentric(ref float u, ref float v, ref float w)
|
|
{
|
|
u = saturate(u);
|
|
v = saturate(v);
|
|
w = 1 - u - v;
|
|
|
|
u = saturate(u);
|
|
w = saturate(w);
|
|
v = 1 - u - w;
|
|
|
|
v = saturate(v);
|
|
w = saturate(w);
|
|
u = 1 - v - w;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Linearlly interpolate between x and y by factor k
|
|
/// If k == 0 then 100% of x and 0% of y
|
|
/// If k == 1 then 0% of x and 100% of y
|
|
/// </summary>
|
|
/// <param name="x"></param>
|
|
/// <param name="y"></param>
|
|
/// <param name="k"></param>
|
|
/// <returns></returns>
|
|
private float lerp(float x, float y, float k)
|
|
{
|
|
return x * (1 - k) + y * k;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Normalize point f, so that its length is 1
|
|
/// </summary>
|
|
/// <param name="b"></param>
|
|
private void normalize(ref PointF b)
|
|
{
|
|
float length = hypot(b.X, b.Y);
|
|
|
|
b.X = b.X / length;
|
|
b.Y = b.Y / length;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Subtract point a from b, so that the result is (x0 - x1 | y0 - y1)
|
|
/// </summary>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <returns></returns>
|
|
private PointF subtract(in PointF a, in PointF b)
|
|
{
|
|
var result = new PointF();
|
|
|
|
result.X = a.X - b.X;
|
|
result.Y = a.Y - b.Y;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert from HSV color space to sRGB.
|
|
/// s,v are expected to be in range [0, 1].
|
|
/// h is expected to be in range [0, 1].
|
|
/// Any other values results in undefiened behavior
|
|
/// </summary>
|
|
/// <param name="h"></param>
|
|
/// <param name="s"></param>
|
|
/// <param name="v"></param>
|
|
/// <returns></returns>
|
|
private int sRGBfromHSV(float h, float s, float v)
|
|
{
|
|
float c = v * s;
|
|
float x = c * (1.0f - Math.Abs((h / 60.0f) % 2.0f - 1.0f));
|
|
float m = v - c;
|
|
|
|
float r = 0, g = 0, b = 0;
|
|
|
|
if (h < 60) { r = c; g = x; b = 0; }
|
|
else if (h < 120) { r = x; g = c; b = 0; }
|
|
else if (h < 180) { r = 0; g = c; b = x; }
|
|
else if (h < 240) { r = 0; g = x; b = c; }
|
|
else if (h < 300) { r = x; g = 0; b = c; }
|
|
else { r = c; g = 0; b = x; }
|
|
|
|
return 0xFF << 24 |
|
|
(int)((r + m) * 255.0f) << 16 |
|
|
(int)((g + m) * 255.0f) << 8 |
|
|
(int)((b + m) * 255.0f);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert sRGB color space to HSV
|
|
/// </summary>
|
|
/// <param name="r"></param>
|
|
/// <param name="g"></param>
|
|
/// <param name="b"></param>
|
|
private void HSVfromRGB(byte r, byte g, byte b)
|
|
{
|
|
const float INV_255 = 0.00392156862745f;
|
|
|
|
float R = r * INV_255;
|
|
float G = g * INV_255;
|
|
float B = b * INV_255;
|
|
|
|
byte Cmax = Math.Max(Math.Max(r, g), b);
|
|
byte Cmin = Math.Min(Math.Min(r, g), b);
|
|
|
|
float delta = (Cmax - Cmin) * INV_255;
|
|
|
|
if (delta < 1e-2)
|
|
{
|
|
angle = 0;
|
|
}
|
|
else if (Cmax == r)
|
|
{
|
|
if (G < B)
|
|
{
|
|
angle = 360 - MathF.Abs(60 * ((G - B) / delta));
|
|
}
|
|
else
|
|
{
|
|
angle = 60 * ((G - B) / delta + 0f);
|
|
}
|
|
}
|
|
else if (Cmax == g)
|
|
{
|
|
angle = 60 * ((B - R) / delta + 2f);
|
|
}
|
|
else if (Cmax == b)
|
|
{
|
|
angle = 60 * ((R - G) / delta + 4f);
|
|
}
|
|
|
|
saturation = delta / Cmax * 255.0f;
|
|
if (Cmax == 0)
|
|
{
|
|
saturation = 0;
|
|
}
|
|
value = Cmax * INV_255;
|
|
}
|
|
|
|
#endregion
|
|
|
|
protected override void OnCreateControl()
|
|
{
|
|
base.OnCreateControl();
|
|
|
|
BackColorChanged += (a, b) => generateWheel();
|
|
|
|
grayGradient = new LinearGradientBrush(
|
|
// point A
|
|
new Point((int)vertices[0].X,
|
|
(int)vertices[0].Y),
|
|
// point B
|
|
new Point(floorMiddle(vertices[2].X, vertices[1].X),
|
|
floorMiddle(vertices[2].Y, vertices[1].Y)),
|
|
Color.Red,
|
|
Color.Gray
|
|
);
|
|
whiteGradient = new LinearGradientBrush(
|
|
// point A
|
|
new Point((int)vertices[2].X,
|
|
(int)vertices[2].Y),
|
|
// point B
|
|
new Point(floorMiddle(vertices[0].X, vertices[1].X),
|
|
floorMiddle(vertices[0].Y, vertices[1].Y)),
|
|
Color.White,
|
|
Color.Transparent
|
|
);
|
|
colorGradient = new LinearGradientBrush(
|
|
// point A
|
|
new Point((int)vertices[1].X,
|
|
(int)vertices[1].Y),
|
|
// point B
|
|
new Point(floorMiddle(vertices[2].X, vertices[0].X),
|
|
floorMiddle(vertices[2].Y, vertices[0].Y)),
|
|
Color.Black,
|
|
Color.Transparent
|
|
);
|
|
|
|
this.SetStyle(ControlStyles.AllPaintingInWmPaint |
|
|
ControlStyles.UserPaint |
|
|
ControlStyles.DoubleBuffer,
|
|
true);
|
|
|
|
this.MouseMove += new System.Windows.Forms.MouseEventHandler(OnMouseMove);
|
|
this.MouseDown += new System.Windows.Forms.MouseEventHandler(OnMouseDown);
|
|
this.MouseUp += new System.Windows.Forms.MouseEventHandler(OnMouseUp);
|
|
|
|
generateWheel();
|
|
|
|
setRGB(0, 0, 0);
|
|
}
|
|
|
|
private void OnMouseUp(object sender, System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
release = true;
|
|
}
|
|
|
|
private void OnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
release = false;
|
|
entered = true;
|
|
}
|
|
|
|
private void OnMouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
|
|
{
|
|
double u = e.X / (double)this.Width * 2.0 - 1.0;
|
|
double v = e.Y / (double)this.Height * 2.0 - 1.0;
|
|
|
|
double theta = Math.Atan2(v, u);
|
|
double radius = Math.Sqrt(u * u + v * v);
|
|
|
|
if (entered)
|
|
{
|
|
selection = Slider.WHEEL;
|
|
if (radius < 0.6)
|
|
{
|
|
selection = Slider.TRIANGLE;
|
|
}
|
|
|
|
entered = false;
|
|
}
|
|
else if (!release)
|
|
{
|
|
if (selection == Slider.TRIANGLE)
|
|
{
|
|
if (transform != null)
|
|
{
|
|
PointF tempCursor = new PointF(e.X, e.Y);
|
|
|
|
clampToBarycentricCoordinates(ref tempCursor, transformed[0], transformed[1], transformed[2]);
|
|
|
|
if (true)
|
|
{
|
|
cursor.X = (int)tempCursor.X;
|
|
cursor.Y = (int)tempCursor.Y;
|
|
|
|
origCursor.X = cursor.X;
|
|
origCursor.Y = cursor.Y;
|
|
|
|
ctheta = angle;
|
|
|
|
cartesianToBarycnetric(cursor, transformed[0], transformed[1], transformed[2], out float bu, out float bv, out float bw);
|
|
|
|
value = MathF.Round(MathF.Max(MathF.Min(1.0f - bv, 1.0f), 0.0f) * 1e2f) / 1e2f;
|
|
|
|
saturation = MathF.Round(MathF.Max(MathF.Min(bu, 1.0f), 0.0f) * 1e2f) / 1e2f;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
angle = ToDegree((float)theta);
|
|
grayGradient = new LinearGradientBrush(
|
|
new Point((int)vertices[0].X,
|
|
(int)vertices[0].Y),
|
|
new Point(floorMiddle(vertices[2].X, vertices[1].X),
|
|
floorMiddle(vertices[2].Y, vertices[1].Y)
|
|
),
|
|
Color.FromArgb(sRGBfromHSV(180 + angle, 1, 1)),
|
|
Color.Gray
|
|
);
|
|
|
|
PointF[] c = { new PointF(origCursor.X, origCursor.Y) };
|
|
|
|
transform.Reset();
|
|
transform.RotateAt(angle - ctheta, new Point(this.Width >> 1, this.Height >> 1));
|
|
transform.TransformPoints(c);
|
|
|
|
cursor.X = (int)c[0].X;
|
|
cursor.Y = (int)c[0].Y;
|
|
}
|
|
|
|
sRGB = sRGBfromHSV(angle + 180, saturation, value);
|
|
this.Refresh();
|
|
handler.Invoke(this, null);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generate the color wheel "wheel" texture
|
|
/// </summary>
|
|
private void generateWheel()
|
|
{
|
|
wheel = new Bitmap(WHEEL_PIXEL_RESOLUTION, WHEEL_PIXEL_RESOLUTION);
|
|
wheel.MakeTransparent(); // make transparent
|
|
|
|
var g = Graphics.FromImage(wheel);
|
|
|
|
// draw tone gradient by varying hue by the current angle of the pixel relative to the origin
|
|
for (int x = wheel.Width; x-- > -1;)
|
|
{
|
|
float u = x / (float)wheel.Width * 2.0f - 1.0f;
|
|
|
|
for (int y = wheel.Height; y-- > -1;)
|
|
{
|
|
float v = y / (float)wheel.Height * 2.0f - 1.0f;
|
|
|
|
// cartesian to polar
|
|
float theta = ToDegree(MathF.Atan2(v, u) + MathF.PI);
|
|
|
|
int rgb = sRGBfromHSV(theta, 1.0f, 1.0f);
|
|
// draw pixel
|
|
g.FillRectangle(new SolidBrush(Color.FromArgb(rgb)), x, y, 1, 1);
|
|
}
|
|
}
|
|
var step = wheel.Width / WHEEL_BORDER_SUBDIVISIONS;
|
|
|
|
var strip = (int)Math.Sqrt(wheel.Width * wheel.Width + wheel.Height * wheel.Height) - wheel.Width;
|
|
// cut out center circle
|
|
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
|
|
g.FillEllipse(new SolidBrush(this.BackColor), new Rectangle(step, step, step * (WHEEL_BORDER_SUBDIVISIONS - 2), step * (WHEEL_BORDER_SUBDIVISIONS - 2)));
|
|
g.DrawEllipse(new Pen(new SolidBrush(this.BackColor), strip), new Rectangle(-strip / 2, -strip / 2, wheel.Width + strip, wheel.Height + strip));
|
|
|
|
g.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verwendete Ressourcen bereinigen.
|
|
/// </summary>
|
|
/// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing && (components != null))
|
|
{
|
|
components.Dispose();
|
|
}
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
|
|
{
|
|
base.OnPaint(e);
|
|
var g = e.Graphics;
|
|
|
|
// adjust for arbitrary component scale
|
|
float scaleX = this.Width / (float) wheel.Width;
|
|
float scaleY = this.Height / (float) wheel.Height;
|
|
|
|
// transform local verticies to screen space
|
|
g.ScaleTransform(scaleX, scaleY);
|
|
g.DrawImage(wheel, new Point(0, 0));
|
|
g.ResetTransform();
|
|
|
|
g.RotateTransform(angle);
|
|
|
|
float step = (wheel.Width / (float) WHEEL_BORDER_SUBDIVISIONS * (WHEEL_BORDER_SUBDIVISIONS - 3));
|
|
float off = WHEEL_PIXEL_RESOLUTION / (float)(WHEEL_BORDER_SUBDIVISIONS - 2) * scaleX;
|
|
|
|
g.ScaleTransform(wheel.Width / (float) Width * 4 / 6, wheel.Width / (float) Width * 4 / 6);
|
|
g.TranslateTransform(wheel.Width * scaleX * 0.5f, wheel.Width * scaleX * 0.5f, MatrixOrder.Append);
|
|
|
|
transformed[0].X = vertices[0].X;
|
|
transformed[0].Y = vertices[0].Y;
|
|
transformed[1].X = vertices[1].X;
|
|
transformed[1].Y = vertices[1].Y;
|
|
transformed[2].X = vertices[2].X;
|
|
transformed[2].Y = vertices[2].Y;
|
|
g.Transform.TransformPoints(transformed);
|
|
|
|
// draw triangle
|
|
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
|
|
g.FillPolygon(grayGradient, vertices);
|
|
g.FillPolygon(whiteGradient, vertices);
|
|
g.FillPolygon(colorGradient, vertices);
|
|
|
|
// paint hue line
|
|
g.DrawLine(new Pen(new SolidBrush(Color.Black), 2.0f), vertices[0].X, vertices[0].Y, vertices[0].X + RADIUS / 2, vertices[0].Y);
|
|
|
|
// paint bordered shadowed cursor
|
|
g.ResetTransform();
|
|
transform = g.Transform;
|
|
g.FillEllipse(new SolidBrush(Color.FromArgb(-2013265920)), new Rectangle(cursor.X - 10, cursor.Y - 10, 22, 22));
|
|
g.FillEllipse(new SolidBrush(Color.White), new Rectangle(cursor.X - 10, cursor.Y - 10, 20, 20));
|
|
g.FillEllipse(new SolidBrush(Color.FromArgb(sRGB)), new Rectangle(cursor.X - 8, cursor.Y - 8, 16, 16));
|
|
}
|
|
|
|
#region Getter-Setter
|
|
public int getRGB()
|
|
{
|
|
return sRGB;
|
|
}
|
|
|
|
public int getRed()
|
|
{
|
|
return sRGB >> 16 & 0xFF;
|
|
}
|
|
public int getGreen()
|
|
{
|
|
return sRGB >> 8 & 0xFF;
|
|
}
|
|
public int getBlue()
|
|
{
|
|
return sRGB & 0xFF;
|
|
}
|
|
|
|
public float getHue()
|
|
{
|
|
return angle;
|
|
}
|
|
public float getSaturation()
|
|
{
|
|
return saturation;
|
|
}
|
|
public float getValue()
|
|
{
|
|
return value;
|
|
}
|
|
|
|
public void setHue(float hue)
|
|
{
|
|
angle = hue;
|
|
showHSV();
|
|
}
|
|
public void setSaturation(float s)
|
|
{
|
|
saturation = s;
|
|
showHSV();
|
|
}
|
|
public void setValue(float v)
|
|
{
|
|
value = v;
|
|
showHSV();
|
|
}
|
|
|
|
public void setRGB(byte red, byte green, byte blue)
|
|
{
|
|
HSVfromRGB(red, green, blue);
|
|
|
|
showHSV();
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Show the color wheel and recompute triangle gradient
|
|
/// and calculate new cursor position
|
|
/// </summary>
|
|
private void showHSV()
|
|
{
|
|
// get sRGB color
|
|
sRGB = sRGBfromHSV(angle, saturation, value);
|
|
|
|
// recompute correct triangle vertex transformation
|
|
// to screen space
|
|
System.Drawing.Drawing2D.Matrix m = new System.Drawing.Drawing2D.Matrix();
|
|
|
|
transformed[0].X = vertices[0].X;
|
|
transformed[0].Y = vertices[0].Y;
|
|
transformed[1].X = vertices[1].X;
|
|
transformed[1].Y = vertices[1].Y;
|
|
transformed[2].X = vertices[2].X;
|
|
transformed[2].Y = vertices[2].Y;
|
|
|
|
// adjust for custom component width
|
|
float scaleX = this.Width / (float)wheel.Width;
|
|
float scaleY = this.Height / (float)wheel.Height;
|
|
|
|
m.Rotate(angle - 180);
|
|
|
|
float step = (wheel.Width / (float)WHEEL_BORDER_SUBDIVISIONS * (WHEEL_BORDER_SUBDIVISIONS - 3));
|
|
float off = WHEEL_PIXEL_RESOLUTION / (float)(WHEEL_BORDER_SUBDIVISIONS - 2) * scaleX;
|
|
|
|
m.Scale(wheel.Width / (float)Width * 4 / 6, wheel.Width / (float)Width * 4 / 6);
|
|
m.Translate(wheel.Width * scaleX * 0.5f, wheel.Width * scaleX * 0.5f, MatrixOrder.Append);
|
|
|
|
transformed[0].X = vertices[0].X;
|
|
transformed[0].Y = vertices[0].Y;
|
|
transformed[1].X = vertices[1].X;
|
|
transformed[1].Y = vertices[1].Y;
|
|
transformed[2].X = vertices[2].X;
|
|
transformed[2].Y = vertices[2].Y;
|
|
m.TransformPoints(transformed);
|
|
|
|
// linearly interpolate cursor location according to saturation
|
|
origCursor.X = (int)lerp(transformed[2].X, transformed[0].X, saturation);
|
|
origCursor.Y = (int)lerp(transformed[2].Y, transformed[0].Y, saturation);
|
|
// linearly interpolate cursor location according to value
|
|
origCursor.X = (int)lerp(transformed[1].X, origCursor.X, value);
|
|
origCursor.Y = (int)lerp(transformed[1].Y, origCursor.Y, value);
|
|
// apply cursor location
|
|
cursor.X = origCursor.X;
|
|
cursor.Y = origCursor.Y;
|
|
|
|
// recompute new gradient for mixing fully saturated color with gray
|
|
sRGB = sRGBfromHSV(angle, saturation, value);
|
|
grayGradient = new LinearGradientBrush(new Point((int)vertices[0].X, (int)vertices[0].Y), new Point((int)(vertices[2].X + vertices[1].X) / 2, (int)(vertices[2].Y + vertices[1].Y) / 2), Color.FromArgb(sRGBfromHSV(angle, 1f, 1f)), Color.Gray);
|
|
|
|
// adjust angle values
|
|
angle -= 180;
|
|
ctheta = angle;
|
|
// repaint
|
|
this.Refresh();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Erforderliche Methode für die Designerunterstützung.
|
|
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
|
|
/// </summary>
|
|
private void InitializeComponent()
|
|
{
|
|
components = new System.ComponentModel.Container();
|
|
}
|
|
}
|
|
}
|