protected virtual void OnColorChanged(bool hsvToRgb)
{
_updating = true;
if (hsvToRgb)
{
_rgba = (ARGBPixel)_hsv;
_rgba.A = (byte)numA.Value;
}
else
{
_hsv = (HSVPixel)_rgba;
}
numH.Value = _hsv.H;
numS.Value = _hsv.S;
numV.Value = _hsv.V;
numR.Value = _rgba.R;
numG.Value = _rgba.G;
numB.Value = _rgba.B;
numA.Value = _rgba.A;
txtColorCode.Text = _rgba.ToRGBAColorCode();
_updating = false;
pnlColorBox.Invalidate();
pnlColorBar.Invalidate();
if (ColorChanged != null)
{
ColorChanged(this, null);
}
}
public Task <RGBPixel[, ]> GenPattern(ulong frame)
{
// Male nächste Iteration ins malbild.
ulong schritt = frame % 100;
float f = schritt / 100f;
// Bild mit modulo wiederholen (immer Quadratisch)
int d = _startbild.GetLength(0);
// Recycle deinen Puffer und übertrage das Bild dahin.
for (int x = 0; x < sizex; x++)
{
for (int y = 0; y < sizey; y++)
{
var pxl = (_zielbild[x % d, y % d] * (f)) + _startbild[x % d, y % d] * (1.0f - f);
pbuf[x, y] = new HSVPixel(pxl, 1, 1);
}
}
// Wechsle Bilder durch alle x frames
if (schritt == 0)
{
_startbild = _zielbild;
_zielbild = DiamondBrick(N);
}
return(Task.FromResult(pbuf));
}
protected void OnBoxChanged(object sender, EventArgs e)
{
if (_updating)
{
return;
}
NumericUpDown box = sender as NumericUpDown;
int value = (int)box.Value;
int index = (int)box.Tag;
switch (index)
{
case 0: { _hsv.H = (ushort)value; break; }
case 1: { _hsv.S = (byte)value; break; }
case 2: { _hsv.V = (byte)value; break; }
case 3: { _rgb.R = (byte)value; break; }
case 4: { _rgb.G = (byte)value; break; }
case 5: { _rgb.B = (byte)value; break; }
case 6: { pnlAlpha.Invalidate(); break; }
}
if ((index > 2) && (index < 6))
{
_hsv = (HSVPixel)_rgb;
}
OnColorChanged();
}
private void huePanel_Paint(object sender, PaintEventArgs e)
{
const float numHueColors = 6.0f;
Rectangle r = colorSquare.ClientRectangle;
//Draw the hue slider
var g = e.Graphics;
//Split the hue colors
float p = r.Height / numHueColors / r.Height;
_hueBrush = new LinearGradientBrush(new Rectangle(0, 0, r.Width, r.Height), Color.Red, Color.Red, LinearGradientMode.Vertical);
//Create the hue list
ColorBlend blend = new ColorBlend();
blend.Colors = new Color[]
{
Color.Red,
Color.Yellow,
Color.Lime,
Color.Cyan,
Color.Blue,
Color.Magenta,
Color.Red
};
if (!huePanel.Enabled)
{
for (int i = 0; i < blend.Colors.Length; i++)
{
blend.Colors[i] = blend.Colors[i].Darken(190);
}
}
blend.Positions = new float[] { 0, p, p * 2, p * 3, p * 4, p * 5, 1.0f };
_hueBrush.InterpolationColors = blend;
g.FillRectangle(_hueBrush, r);
Color pixel = new HSVPixel(_hsv.H, 100, 100).ToRGBA().Inverse();
int y = (int)(_hsv.H / 360.0f * (huePanel.Height - 1));
Rectangle c = new Rectangle(-1, y - 2, huePanel.Width + 1, 4);
using (Pen pen = new Pen(pixel))
g.DrawRectangle(pen, c);
c.Y += 1;
c.Height -= 2;
pixel = pixel.Lighten(64);
using (Pen pen = new Pen(pixel))
g.DrawRectangle(pen, c);
}
private void colorSquare_Paint(object sender, PaintEventArgs e)
{
var g = e.Graphics;
Rectangle r = colorSquare.ClientRectangle;
float p = r.Height / 6.0f / r.Height;
_mainBrush = new PathGradientBrush(new PointF[] {
new PointF(r.Width, 0),
new PointF(r.Width, r.Height),
new PointF(0, r.Height),
new PointF(0, 0),
new PointF(r.Width, 0)
});
_boxColors[0] = _boxColors[4] = new HSVPixel(_hsv.H, 100, 100).ToRGBA();
_mainBrush.SurroundColors = _boxColors;
_mainBrush.CenterColor = new HSVPixel(_hsv.H, 50, 50).ToRGBA();
_mainBrush.CenterPoint = new PointF(r.Width / 2, r.Height / 2);
if (!huePanel.Enabled)
{
for (int i = 0; i < _mainBrush.SurroundColors.Length; i++)
{
_mainBrush.SurroundColors[i] = _mainBrush.SurroundColors[i].Darken(190);
}
}
g.FillRectangle(_mainBrush, r);
//Draw indicator
int x = (int)(_hsv.V / 100.0f * colorSquare.Width);
int y = (int)((100 - _hsv.S) / 100.0f * colorSquare.Height);
Rectangle c = new Rectangle(x - 3, y - 3, 6, 6);
Color pixel = _color.Inverse();
pixel.WhiteAlpha();
using (Pen pen = new Pen(pixel))
g.DrawEllipse(pen, c);
c.X -= 1;
c.Y -= 1;
c.Width += 2;
c.Height += 2;
pixel = pixel.Lighten(64);
using (Pen pen = new Pen(pixel))
g.DrawEllipse(pen, c);
}
public void Farbtests()
{
RGBPixel schwarz = RGBPixel.P0;
RGBPixel weiß = RGBPixel.P1;
RGBPixel braun = new RGBPixel(.36f, .18f, .09f);
RGBPixel blau = new RGBPixel(0, 0, 1);
RGBPixel rot = new RGBPixel(1, 0, 0);
RGBPixel grün = new RGBPixel(0, 1, 0);
RGBPixel magenta = new RGBPixel(1, 0, 1);
RGBPixel cyan = new RGBPixel(0, 1, 1);
RGBPixel orange = new RGBPixel(1, .5f, 0);
RGBPixel violett = new RGBPixel(.5f, 0, 1);
RGBPixel zinober = new RGBPixel(1, 0.25f, 0);
RGBPixel safran = new RGBPixel(1, 0.75f, 0);
HSVPixel schwarz1 = HSVPixel.P0;
HSVPixel weiß1 = new HSVPixel(0, 0, 1);
HSVPixel braun1 = new HSVPixel(20, 0.75f, 0.36f);
HSVPixel blau1 = new HSVPixel(240, 1, 1);
HSVPixel rot1 = new HSVPixel(0, 1, 1);
HSVPixel grün1 = new HSVPixel(120, 1, 1);
HSVPixel magenta1 = new HSVPixel(300, 1, 1);
HSVPixel cyan1 = new HSVPixel(180, 1, 1);
HSVPixel orange1 = new HSVPixel(30, 1, 1);
HSVPixel violett1 = new HSVPixel(270, 1, 1);
HSVPixel zinober1 = new HSVPixel(15, 1, 1);
HSVPixel safran1 = new HSVPixel(45, 1, 1);
Assert.Equal(schwarz1.V, HSVPixel.FromRGB(schwarz).V);
Assert.Equal(schwarz, (RGBPixel)schwarz1);
Assert.Equal(weiß1.V, HSVPixel.FromRGB(weiß).V);
Assert.Equal(weiß1.S, HSVPixel.FromRGB(weiß).S);
Assert.Equal(weiß, (RGBPixel)weiß1);
Assert.Equal(braun1, HSVPixel.FromRGB(braun));
Assert.Equal(braun, (RGBPixel)braun1);
Assert.Equal(blau1, HSVPixel.FromRGB(blau));
Assert.Equal(blau, (RGBPixel)blau1);
Assert.Equal(rot1, HSVPixel.FromRGB(rot));
Assert.Equal(rot, (RGBPixel)rot1);
Assert.Equal(grün1, HSVPixel.FromRGB(grün));
Assert.Equal(grün, (RGBPixel)grün1);
Assert.Equal(magenta1, HSVPixel.FromRGB(magenta));
Assert.Equal(magenta, (RGBPixel)magenta1);
Assert.Equal(cyan1, HSVPixel.FromRGB(cyan));
Assert.Equal(cyan, (RGBPixel)cyan1);
Assert.Equal(orange1, HSVPixel.FromRGB(orange));
Assert.Equal(orange, (RGBPixel)orange1);
Assert.Equal(violett1, HSVPixel.FromRGB(violett));
Assert.Equal(violett, (RGBPixel)violett1);
Assert.Equal(zinober1, HSVPixel.FromRGB(zinober));
Assert.Equal(zinober, (RGBPixel)zinober1);
Assert.Equal(safran1, HSVPixel.FromRGB(safran));
Assert.Equal(safran, (RGBPixel)safran1);
}
public void Grautests()
{
var px1 = new HSVPixel(32, 1, 0.4f);
Assert.Equal(new HSVPixel(32, 0, 0.4f), px1.Grau());
var px2 = new HSVPixel(75, 1, 0);
Assert.Equal(new HSVPixel(75, 0, 0), px2.Grau());
var px3 = new HSVPixel(0, 1, 1.4f);
Assert.Equal(new HSVPixel(0, 0, 1.4f), px3.Grau());
}
public Task <RGBPixel[, ]> Filter(RGBPixel[,] pixels, ulong frame)
{
(int w, int h) = pixels.EnsureArray2D(ref _res);
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
HSVPixel hsv = pixels[x, y];
_res[x, y] = hsv.Grau();
}
}
return(Task.FromResult(_res));
}
protected virtual void OnColorChanged(bool hsvToRgb)
{
colorSquare.Invalidate();
huePanel.Invalidate();
if (hsvToRgb)
{
_color = _hsv.ToRGBA();
}
else
{
_hsv = HSVPixel.FromRGBA(_color);
}
if (ColorChanged != null)
{
ColorChanged(this, null);
}
}
/// <summary>
/// Algorithmus verwendet keine Partikeltechnik.
/// Stattdessen wird einfach nur in der untersten Y-Zeile mit random
/// verschiedene Rot+Gelbtöne gezündelt. Diese werden dann von oben her
/// nach oben vererbt und ausgeblendet mit f*f, f<1.
/// </summary>
public Task <RGBPixel[, ]> GenPattern(ulong frame)
{
// Vererbe alle Zeilen von oben kommend eins hoch mal Ausblendfaktor
for (int x = 0; x < sizex; x++)
{
for (int y = 0; y < sizey - 1; y++)
{
pbuf[x, y] = pbuf[x, y + 1] * _f;
}
}
// Jetzt unterste Zeile neu befeuern:
for (int x = 0; x < sizex; x++)
{
// nehme die farben rot (0°) bis gelb (60°) und intensitäten 0.3-1
pbuf[x, sizey - 1] = new HSVPixel((float)rnd.NextDouble() * 60f, 1, (float)rnd.NextDouble() * .3f + .7f);
}
return(Task.FromResult(pbuf));
}
public Task <RGBPixel[, ]> GenPattern(ulong frame)
{
// Recycle deinen Puffer
// Winkel berechnen in rad
double wr = (this.Winkel + (frame * this.RotRate)) / 180d * Math.PI;
double sinwr = Math.Sin(wr);
double coswr = Math.Cos(wr);
for (int x = 0; x < sizex; x++)
{
for (int y = 0; y < sizey; y++)
{
float fb = (frame * Geschwindigkeit) +
((float)(y * sinwr + x * coswr) * 360f / Lambda);
pbuf[x, y] = new HSVPixel(fb, .9f, .9f);
}
}
return(Task.FromResult(pbuf));
}
public Task <RGBPixel[, ]> GenPattern(ulong frame)
{
Color fb = this.Farbe;
// Male nächste Iteration ins malbild.
switch (this.Art)
{
case LinienTyp.Kreuz:
{
ulong w = (ulong)(frame * Geschwindigkeit) % 100;
double wr = w / 100d * Math.PI;
double ph = 2 * Math.PI / Anzahl;
PointF mp = new PointF(sizex / 2f, sizey / 2f);
_malbild.Mutate((IImageProcessingContext i) =>
{
try
{
i.Fill(Color.Black);
for (int l = 0; l < this.Anzahl; l++)
{
PointF pointF = new PointF(mp.X + (float)Math.Cos(wr + ph * l) * sizex, mp.Y + (float)Math.Sin(wr + ph * l) * sizey);
i.DrawLines(new ShapeGraphicsOptions()
{
GraphicsOptions = { Antialias = false }
}, fb, this.N,
mp, pointF);
}
}
catch (Exception e)
{
//HACK, TODO, geht nicht, wegen Bug in Bib.
}
});
}
break;
case LinienTyp.Raute:
{
float w = 0.01f * ((ulong)(frame * Geschwindigkeit) % 100);
_malbild.Mutate(i =>
{
i.Clear(Color.Black);
i.DrawLines(new ShapeGraphicsOptions()
{
GraphicsOptions = { Antialias = false }
}, fb, this.N,
new PointF(sizex * w, 0),
new PointF(sizex, sizey * w),
new PointF(sizex * (1 - w), sizey),
new PointF(0, sizey * (1 - w)),
new PointF(sizex * w, 0));
});
}
break;
default:
case LinienTyp.RadarLR:
case LinienTyp.RadarRL:
{
ulong koo = (ulong)(frame * Geschwindigkeit) % sizex;
koo = (this.Art == LinienTyp.RadarRL)? sizex - koo - 1 : koo;
_malbild.Mutate(i =>
{
i.Clear(Color.Black);
i.DrawLines(new ShapeGraphicsOptions()
{
GraphicsOptions = { Antialias = false }
},
fb, this.N, new PointF((float)koo, 0), new PointF((float)koo, sizey - 1));
});
}
break;
case LinienTyp.RadarRLR:
{
ulong koo = (ulong)(frame * Geschwindigkeit) % (sizex * 2);
koo = (koo >= sizex)? sizex - (koo % sizex) - 1 : koo % sizex;
ILineSegment s = new LinearLineSegment(new PointF((float)koo, 0), new PointF((float)koo, sizey - 1));
IPath p = new SixLabors.ImageSharp.Drawing.Path(s);
_malbild.Mutate(i =>
{
i.Clear(Color.Black);
i.Draw(new ShapeGraphicsOptions()
{
GraphicsOptions = { Antialias = false }
},
fb, N, p);
});
}
break;
case LinienTyp.RadarVO:
case LinienTyp.RadarOV:
case LinienTyp.RadarVOV:
throw new NotImplementedException();
break;
}
// Recycle deinen Puffer und übertrage das Bild dahin.
for (int x = 0; x < sizex; x++)
{
for (int y = 0; y < sizey; y++)
{
var pxl = _malbild[x, y];
pbuf[x, y] = new RGBPixel(pxl.R, pxl.G, pxl.B);
}
}
if (this.Farbwechsel)
{
HSVPixel h = this.Farbe;
h.H += 1;
this.Farbe = h;
}
return(Task.FromResult(pbuf));
}
