private void DrawLine(SolidBrush brush, PointF[][] polygon)
{
Graphics formGraphics;
formGraphics = this.drawPanel.CreateGraphics();
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
path.AddCurve(polygon[0], tension: 4.5f);
path.AddLine(polygon[1][0], polygon[1][1]);
path.AddCurve(polygon[2], tension: 4.5f);
path.AddLine(polygon[3][0], polygon[3][1]);
formGraphics.FillPath(brush, path);
brush.Dispose();
formGraphics.Dispose();
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------- DRAWING CURVE ------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------------
public void DrawCurve(List <System.Drawing.Point> points, Color color, float thickness, float worldScale)
{
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath(System.Drawing.Drawing2D.FillMode.Winding);
path.AddCurve(points.ToArray());
path.Flatten();
PointF[] finalPoints = path.PathPoints;
path.Dispose();
//Convert point to vector2
if (finalPoints.Length < 2)
{
return;
}
float finalThickness = thickness * worldScale;
if (finalThickness < 1)
{
finalThickness = 1;
}
Vector2D vectorThickNess = new Vector2D(finalThickness, finalThickness);
for (int i = 1; i < finalPoints.Length; i++)
{
Gorgon.CurrentRenderTarget.Line((int)((float)finalPoints[i - 1].X * worldScale), (int)((float)finalPoints[i - 1].Y * worldScale),
(int)(((float)finalPoints[i].X - (float)finalPoints[i - 1].X) * worldScale),
(int)(((float)finalPoints[i].Y - (float)finalPoints[i - 1].Y) * worldScale), color, vectorThickNess);
}
}
public override void CloseCurve(GraphPane pane, CurveItem curve, PointF[] arrPoints, int count, double yMin, System.Drawing.Drawing2D.GraphicsPath path)
{
if (pane.LineType == LineType.Stack)
{
throw new NotSupportedException("Filled lines cannot be stacked");
}
FilledLineItem filledCurve = curve as FilledLineItem;
if (filledCurve == null)
{
throw new ArgumentException("Curve was of the wrong type. Expected FilledLineItem but was " + curve.GetType(), "curve");
}
// Build another points array consisting of the low points (It gets these from the LowerPoints property of the curve)
PointF[] arrPoints2;
int count2;
BuildLowPointsArray(pane, curve, out arrPoints2, out count2);
// Add the new points to the GraphicsPath
float tension = _isSmooth ? _smoothTension : 0f;
path.AddCurve(arrPoints2, 0, count2 - 2, tension);
}
/// <summary>
/// Overrides <see cref="CADability.Curve2D.GeneralCurve2D.AddToGraphicsPath (System.Drawing.Drawing2D.GraphicsPath, bool)"/>
/// </summary>
/// <param name="path"></param>
/// <param name="forward"></param>
public override void AddToGraphicsPath(System.Drawing.Drawing2D.GraphicsPath path, bool forward)
{ // es wird ein Spline erzeugt in 10° Schritten
// hier sollte man überlegen, ob man nicht mit einer Kreisbogenannäherung
// arbeiten sollte
int n = (int)Math.Round(Math.Abs(sweepPar) / Math.PI * 18);
if (n < 2)
{
n = 2;
}
PointF[] pnts = new PointF[n + 1];
double step = 1.0 / n;
for (int i = 0; i < n; ++i)
{
GeoPoint2D p = this.PointAt(i * step);
pnts[i] = new PointF((float)p.x, (float)p.y);
}
pnts[n] = new PointF((float)endPoint.x, (float)endPoint.y);
if (!forward)
{
Array.Reverse(pnts);
}
path.AddCurve(pnts);
// path.AddLines(pnts); // DEBUG!!!
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
if (!started)
{
for (Int32 i = 0; i < MainFile.preloadbodies.Count; i++)
{
e.Graphics.FillEllipse(Palette[MainFile.preloadbodies[i].color], Convert.ToSingle(MainFile.preloadbodies[i].x - MainFile.preloadbodies[i].d / 2) / 100, Convert.ToSingle(MainFile.preloadbodies[i].y - MainFile.preloadbodies[i].d / 2) / 100, Convert.ToSingle(MainFile.preloadbodies[i].d / 100), Convert.ToSingle(MainFile.preloadbodies[i].d / 100));
}
}
else
{
for (Int32 i = 0; i < MainFile.Calculator.bodies.Count; i++)
{
e.Graphics.FillEllipse(Palette[MainFile.Calculator.bodies[i].color], Convert.ToSingle(MainFile.Calculator.bodies[i].x - MainFile.Calculator.bodies[i].d / 2) / 100, Convert.ToSingle(MainFile.Calculator.bodies[i].y - MainFile.Calculator.bodies[i].d / 2) / 100, Convert.ToSingle(MainFile.Calculator.bodies[i].d / 100), Convert.ToSingle(MainFile.Calculator.bodies[i].d / 100));
System.Drawing.Drawing2D.GraphicsPath trail = new System.Drawing.Drawing2D.GraphicsPath();
trail.AddCurve(MainFile.Calculator.bodies[i].trail.ToArray());
e.Graphics.DrawPath(Ink[MainFile.Calculator.bodies[i].color], trail);
}
}
}
private void SpecifyGroupVisualy(SKarnaughGroup group, Graphics g)
{
Point[] points1;
Point[] points2;
Point[] points3;
Point[] points4;
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
Rectangle[] drawRegions = GetGroupRegions(group);
int drawRegionsCount = drawRegions.GetLength(0);
int Spc_HOR = 20;
int Spc_VER = 15;
int Dest_To_Reg = m_innerTableRegion.Left / 2;
if (drawRegionsCount == 1)
{
points1 = new Point[2];
int middle_X = (drawRegions[0].Left + drawRegions[0].Right) / 2;
Spc_HOR = 10;
Spc_VER = 10;
#region Set rectangular shape points (for around a cell)
points1[0].X = drawRegions[0].Left + Spc_HOR;
points1[0].Y = drawRegions[0].Top + Spc_VER;
points1[1].X = drawRegions[0].Right - Spc_HOR;
points1[1].Y = drawRegions[0].Bottom - Spc_VER;
#endregion
path.AddEllipse(points1[0].X, points1[0].Y, points1[1].X - points1[0].X, points1[1].Y - points1[0].Y);
path.StartFigure();
}
else if (drawRegionsCount == 2)
{
points1 = new Point[4];
points2 = new Point[4];
#region Set curve points (for around two groups)
if (drawRegions[0].Left == drawRegions[1].Left)
{
// We have two HORIZONTAL group
#region Set top group points
points1[0].X = drawRegions[0].Left + Spc_HOR;
points1[0].Y = m_innerTableRegion.Top - Dest_To_Reg;
points1[1].X = (int)(drawRegions[0].Left + Spc_HOR);
points1[1].Y = (int)(drawRegions[0].Bottom - Spc_VER);
points1[2].X = (int)(drawRegions[0].Right - Spc_HOR);
points1[2].Y = points1[1].Y;
points1[3].X = points1[2].X;
points1[3].Y = points1[0].Y;
#endregion
#region Set bottom group points
points2[0].X = points1[0].X;
points2[0].Y = drawRegions[1].Bottom + Dest_To_Reg;
points2[1].X = points1[1].X;
points2[1].Y = (int)(drawRegions[1].Top + Spc_VER);
points2[2].X = points1[2].X;
points2[2].Y = points2[1].Y;
points2[3].X = points1[3].X;
points2[3].Y = points2[0].Y;
#endregion
}
else
{
// We have two VERTICAL group
#region Set left group points
points1[0].X = m_innerTableRegion.Left - Dest_To_Reg;
points1[0].Y = drawRegions[0].Top + Spc_VER;
points1[1].X = (int)(drawRegions[0].Right - Spc_HOR);
points1[1].Y = (int)(drawRegions[0].Top + Spc_VER);
points1[2].X = points1[1].X;
points1[2].Y = (int)(drawRegions[0].Bottom - Spc_VER);
points1[3].X = points1[0].X;
points1[3].Y = drawRegions[0].Bottom - Spc_VER;
#endregion
#region Set right group points
points2[0].X = m_innerTableRegion.Right + Dest_To_Reg;
points2[0].Y = points1[0].Y;
points2[1].X = (int)(drawRegions[1].Left + Spc_HOR);
points2[1].Y = points1[1].Y;
points2[2].X = points2[1].X;
points2[2].Y = points1[2].Y;
points2[3].X = points2[0].X;
points2[3].Y = points1[2].Y;
#endregion
}
#endregion
path.AddCurve(points1, 0.2f);
path.StartFigure();
path.AddCurve(points2, 0.2f);
}
else
{
points1 = new Point[3];
points2 = new Point[3];
points3 = new Point[3];
points4 = new Point[3];
#region Set curve points (for around four groups)
// Group 1
points1[0].X = m_innerTableRegion.Left - Dest_To_Reg;
points1[0].Y = drawRegions[0].Bottom - Spc_VER;
points1[1].X = drawRegions[0].Right - Spc_HOR; //drawRegions[0].Right- Spc_HOR ;
points1[1].Y = drawRegions[0].Bottom - Spc_VER; //points1[0].Y;
points1[2].X = drawRegions[0].Right - Spc_HOR;
points1[2].Y = m_innerTableRegion.Top - Dest_To_Reg;
// Group 2
points2[0].X = drawRegions[1].Right + Dest_To_Reg;
points2[0].Y = points1[0].Y;
points2[1].X = drawRegions[1].Left + Spc_HOR;
points2[1].Y = points1[1].Y;
points2[2].X = drawRegions[1].Left + Spc_HOR;
points2[2].Y = points1[2].Y;
// Group 3
points3[0].X = points1[0].X;
points3[0].Y = drawRegions[2].Top + Spc_VER;
points3[1].X = points1[1].X;
points3[1].Y = drawRegions[2].Top + Spc_VER;
points3[2].X = points1[2].X;
points3[2].Y = drawRegions[2].Bottom + Dest_To_Reg;
// Group 4
points4[0].X = points2[0].X;
points4[0].Y = points3[0].Y;
points4[1].X = points2[1].X;
points4[1].Y = points3[1].Y;
points4[2].X = points2[2].X;
points4[2].Y = points3[2].Y;
#endregion
path.AddCurve(points1);
path.StartFigure();
path.AddCurve(points2);
path.StartFigure();
path.AddCurve(points3);
path.StartFigure();
path.AddCurve(points4);
}
// Draw with high quality
g.DrawPath(m_groupSpecifyerPen, path);
//
}
private static void DrawMarker()
{
var di = new DirectoryInfo(@"C:\Users\alexh\Source\Repos\alexhiggins732\CsharpMouseKeyboardDesktopLibrary\GlobalMacroRecorder\bin\Debug\ouA-2021-02-05_06-49-38");
var target1 = Color.FromArgb(255, 54, 11, 164);
var target2 = Color.FromArgb(255, 58, 16, 169);
var target3 = Color.FromArgb(255, 65, 22, 175);
var target4 = Color.FromArgb(255, 73, 30, 183);
var target5 = Color.FromArgb(255, 62, 22, 167);
var targets = new[] { target1, target2, target3, target4, target5 };
var pics = di.GetFiles("*-movie.png");
List <Point> points = (new Point[]
{
new Point(252, 365),
new Point(305, 393),
new Point(390, 420),
new Point(486, 452),
}).ToList();
foreach (var pic in pics)
{
var bmp = (Bitmap)Bitmap.FromFile(pic.FullName);
var minDiff = int.MaxValue;
var minPoint = new Point(0, 0);
bool done = false;
var l = points.Last();
for (var x = 0; !done && x < bmp.Height; x++)
{
for (var y = 0; !done && y < bmp.Height; y++)
{
var last = points.Last();
var endpoint = new Point(x, y);
var xroot = last.X - endpoint.X;
var yroot = last.Y - endpoint.Y;
var distance = Math.Sqrt(xroot * xroot + yroot * yroot);
if (distance > 20)
{
continue;
}
var c = bmp.GetPixel(x, y);
//var t = target.GetHue();
//var h = (int)c.GetHue();
//if (h >= 289 && h <= 291)
//{
// string bp = "";
//}
var diff = targets.Min(cx => ColorDiff(c, cx));
if (diff < 10 || targets.Contains(c))
{
string bp = "";
if (!points.Contains(endpoint))
{
points.Add(endpoint);
}
var penColor1 = Color.FromArgb(120, 98, 67, 146);
var b = new Pen(penColor1, 8);
var p = new System.Drawing.Drawing2D.GraphicsPath();
var pts = points.ToArray();
p.AddCurve(pts);
var penColor2 = Color.FromArgb(150, 98, 67, 146);
var pen2 = new Pen(penColor2, 3);
using (var g = Graphics.FromImage(bmp))
{
g.DrawPath(b, p);
g.DrawPath(pen2, p);
}
//bmp.Save(@"C:\Users\alexh\OneDrive\Pictures\AOC Face Scan\aoc-face-line-scene-1-test.png");
var dest = pic.FullName.Replace("-movie.png", "-movie-final.png");
bmp.Save(dest);
//points.Remove(endpoint);
done = true;
}
else
{
//var diff = Math.Abs(c.ToArgb() - argb);
if (diff < minDiff)
{
minPoint = new Point(x, y);
minDiff = diff;
}
}
}
}
if (!done)
{
string bp = "not found";
points.Add(minPoint);
var penColor1 = Color.FromArgb(120, 98, 67, 146);
var b = new Pen(penColor1, 8);
var p = new System.Drawing.Drawing2D.GraphicsPath();
var pts = points.ToArray();
p.AddCurve(pts);
var penColor2 = Color.FromArgb(150, 98, 67, 146);
var pen2 = new Pen(penColor2, 3);
using (var g = Graphics.FromImage(bmp))
{
g.DrawPath(b, p);
g.DrawPath(pen2, p);
}
//bmp.Save(@"C:\Users\alexh\OneDrive\Pictures\AOC Face Scan\aoc-face-line-scene-1-test.png");
var dest = pic.FullName.Replace("-movie.png", "-movie-final.png");
bmp.Save(dest);
done = true;
//points.Remove(minPoint);
}
bmp.Dispose();
}
}
protected override void LoadContent()
{
SpriteBatch = new SpriteBatch(GraphicsDevice);
Canvas2 = new Canvas(this, new Point(480, 640));
Canvas2.Graphics.Clear(System.Drawing.Color.Transparent);
var bgtexture = Content.Load <Texture2D>("Images/Loading");
var pen = new System.Drawing.Pen(System.Drawing.Brushes.OrangeRed, 2)
.With(p => { p.DashPattern = new float[] { 2.0f, 2.0f }; });
Canvas2.Graphics.DrawLine(pen, new System.Drawing.Point(120 - 80, 120), new System.Drawing.Point(120 + 80, 120));
Canvas2.Graphics.DrawLine(pen, new System.Drawing.Point(120, 120 - 80), new System.Drawing.Point(120, 120 + 80));
Canvas2.Save();
var texture0 = Content.Load <Texture2D>("Images/Compas");
image = Image(texture0, Color.White * 0.2f, Align.Center, new Vector2(480 / 2, 480 / 2), 0f, new Vector2(1f, 1f), Vector2.Zero);
var texture = Content.Load <Texture2D>("Images/Wind");
sp = SpriteSheet(texture, Color.White * 0.6f, Align.Center, new Vector2(480 / 2, 480 / 2), 0.0f, 0.4f, new Vector2(texture.Width / 14 / 2, texture.Height / 2), 14)[13];
panel = Panel(bgtexture, Color.White * 0.5f, Align.Left | Align.Top, Vector2.Zero, Panel(texture0, Color.White * 0.3f, Align.Left | Align.Top, Vector2.Zero, Spacer(new Vector2(480 / 2, 480 / 2))));
sp.UpdateEvent += Sp_UpdateEvent;
Canvas1 = new Canvas(this, new Point(480, 270));
//Canvas1.Graphics.Clear(System.Drawing.Color.FromArgb(255, 30, 16, 18));
Canvas1.Graphics.Clear(System.Drawing.Color.Transparent);
Canvas1.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
// XY Grid
Canvas1.Graphics.DrawLine(new System.Drawing.Pen(System.Drawing.Brushes.White, 3), 20, 20, 20, 50 * 5 + 1);
Canvas1.Graphics.DrawLine(new System.Drawing.Pen(System.Drawing.Brushes.White, 3), 20 - 1, 50 * 5, 460, 50 * 5);
for (var i = 5; i < 50; i += 5)
{
Canvas1.Graphics.DrawLine(new System.Drawing.Pen(System.Drawing.Brushes.White, 1), 15, i * 5, 20, i * 5);
}
for (var i = 50; i <= 450; i += 30)
{
Canvas1.Graphics.DrawLine(new System.Drawing.Pen(System.Drawing.Brushes.White, 1), i, 50 * 5, i, 50 * 5 + 5);
}
var xs = List(50, 80, 110, 140, 170, 200, 230, 270, 300);
var ys = List(8, 16, 32, 21, 19, 16, 25, 33, 15);
var points = xs.Zip(ys, (x, y) => new System.Drawing.PointF(x, 50 * 5 - y * 5)).ToArray();
// Curved Line
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
path.AddCurve(points);
Canvas1.Graphics.DrawPath(new System.Drawing.Pen(System.Drawing.Brushes.IndianRed, 2), path);
path.Reset();
// Circle Points
points.ForEach(p => path.AddEllipse(p.X - 6, p.Y - 6, 12, 12));
Canvas1.Graphics.FillPath(new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 30, 16, 18)), path);
Canvas1.Graphics.DrawPath(new System.Drawing.Pen(System.Drawing.Brushes.White, 2), path);
path.Reset();
points.ForEach(p => path.AddEllipse(p.X - 8, p.Y - 8, 16, 16));
Canvas1.Graphics.DrawPath(new System.Drawing.Pen(new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 30, 16, 18)), 3), path);
path.Reset();
//points.ForEach(p => {
// path.AddString($"{p.Y / 10}°", System.Drawing.FontFamily.GenericSansSerif, 1, 15, new System.Drawing.PointF(p.X - 20, p.Y + 20), System.Drawing.StringFormat.GenericDefault);
//});
Canvas1.Graphics.DrawPath(new System.Drawing.Pen(System.Drawing.Brushes.Black, 1), path);
Canvas1.Save();
PreviousState.Init();
}
public void ToPNG(string filename)
{
ReadData();
// start at byte 512
int startIndex = 512;
int stitchCount = 0;
double pixelWidth = ((Math.Abs(extentPosX) + Math.Abs(extentNegX)));
double pixelHeight = ((Math.Abs(extentPosY) + Math.Abs(extentNegY)));
Bitmap b = new Bitmap(Convert.ToInt32(pixelWidth) + 100, Convert.ToInt32(pixelHeight) + 120);
Graphics g = Graphics.FromImage(b);
g.FillRectangle(new SolidBrush(Color.WhiteSmoke), new Rectangle(new Point(0, 0), b.Size));
Pen p = new Pen(Color.Black);
int canvasStartX = extentNegX + 50;
int canvasStartY = extentNegY + 50;
System.Drawing.Drawing2D.GraphicsPath gPath = new System.Drawing.Drawing2D.GraphicsPath();
List <Point> points = new List <Point>();
int totalJumps = 0;
for (int i = startIndex; i < dstData.Length; i += 3)
{
if (stitchCount == totalStitches)
{
break;
}
byte b0 = dstData[i];
byte b1 = dstData[i + 1];
byte b2 = dstData[i + 2];
stitchCount++;
bool jump = IsJump(b2);
int deltaY = GetDeltaY(b0, b1, b2);
int deltaX = GetDeltaX(b0, b1, b2);
canvasStartX += deltaX;
canvasStartY += deltaY;
// draw shit
int x0 = canvasStartX;
int x1 = x0 + deltaX;
int y0 = canvasStartY;
int y1 = y0 + deltaY;
Point p1 = new Point(x0, y0);
Point p2 = new Point(x1, y1);
if (IsColorChange(b2))
{
p = new Pen(GetRandomColor(), 1.0f);
}
points.Add(p1);
points.Add(p2);
//gPath.AddLine(p1, p2);
//g.DrawLine(p, p1, p2);
if (jump)
{
if (points.Count > 0)
{
gPath.AddCurve(points.ToArray());
g.DrawPath(p, gPath);
}
totalJumps++;
}
}
b.RotateFlip(RotateFlipType.Rotate180FlipX);
b.Save(filename);
g.Dispose();
}
private void DrawSeries(Graphics g, int _catsToCount, float _pixelsPerPoint, int axisIndex, float _widthPerCat, int x_offset, RectangleF _drawArea)
{
int columnscount = Series.Count(x => x.Type == cSeries.eType.Column);
float columnwidth = ((_widthPerCat - 8) / columnscount) / _catSkipFactor[axisIndex];
int columnindex = 0;
for (int k = 0; k < _seriesSorted.Count; k++)
{
if (_seriesSorted[k].Data != null && axisIndex == _seriesSorted[k].xAxis)
{
List<cSeries.Point> _serPoints = new List<cSeries.Point>();
for (int i = (int)x_offset; i < _seriesSorted[k].Data.Length && i < _catsToCount + x_offset; i++)
{
double _datavalue = 0;
if (double.TryParse(_seriesSorted[k].Data[i], out _datavalue))
_serPoints.Add(new cSeries.Point(
_drawArea.X + (_drawArea.Width / (float)_catsToCount) / 2 + (_drawArea.Width / (float)_catsToCount) * (i - x_offset),
_drawArea.Y - ((float)_datavalue - _lowerLimit) * _pixelsPerPoint, _seriesSorted[k].Data[i]));
else
_serPoints.Add(null);
}
SolidBrush _serEllipseBrush = new SolidBrush(_seriesSorted[k].Color);
int ar = _seriesSorted[k].Color.R;
int ag = _seriesSorted[k].Color.G;
int ab = _seriesSorted[k].Color.B;
int aa = 100;
SolidBrush _areaBrush = new SolidBrush(Color.FromArgb(aa, ar, ag, ab));
// Slow.
Bitmap _texForBrush = new Bitmap(1, 1);
TextureBrush _tbrush = new TextureBrush(_texForBrush);
if (_seriesSorted[k].FillGradient &&
(_seriesSorted[k].Type == cSeries.eType.Area ||
_seriesSorted[k].Type == cSeries.eType.AreaSolid ||
_seriesSorted[k].Type == cSeries.eType.Column ||
_seriesSorted[k].Type == cSeries.eType.AreaSpline))
{
_texForBrush = new Bitmap(1, (int)(_drawArea.Height));
for (int _tfbx = 0; _tfbx < _texForBrush.Width; _tfbx++)
for (int _tfby = 0; _tfby < _texForBrush.Height; _tfby++)
{
int _tfba = 255 - (int)(((float)255 / (_texForBrush.Height)) * _tfby);
_tfba = _tfba < 0 ? 0 : _tfba;
_tfba = _tfba > 255 ? 255 : _tfba;
_texForBrush.SetPixel(_tfbx, _tfby,
Color.FromArgb(_tfba, _serEllipseBrush.Color.R, _serEllipseBrush.Color.G, _serEllipseBrush.Color.B));
}
_tbrush = new TextureBrush(_texForBrush, System.Drawing.Drawing2D.WrapMode.Tile);
_tbrush.TranslateTransform(_drawArea.X, _drawArea.Y);
}
Pen _serLinePen = new Pen(_seriesSorted[k].Color);
_serLinePen.Width = 2 / _catSkipFactor[axisIndex];
if (_serLinePen.Width == 0)
_serLinePen.Width = 1;
for (int i = 0; i < _serPoints.Count; i++)
{
if (_serPoints[i] != null)
{
if (_serPoints[i].X > _pointBottomRight.X)
continue; // dunno.
switch (_seriesSorted[k].Type)
{
case cSeries.eType.Point:
g.FillEllipse(_serEllipseBrush, _serPoints[i].X - 4 / _catSkipFactor[axisIndex], _serPoints[i].Y - 4 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex]);
break;
case cSeries.eType.PointLine:
g.FillEllipse(_serEllipseBrush, _serPoints[i].X - 4 / _catSkipFactor[axisIndex], _serPoints[i].Y - 4 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex]);
if (i + 1 < _serPoints.Count && _serPoints[i + 1] != null)
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
g.DrawLine(_serLinePen, _serPoints[i].X, _serPoints[i].Y, _serPoints[i + 1].X, _serPoints[i + 1].Y);
}
break;
case cSeries.eType.Line:
if (i + 1 < _serPoints.Count && _serPoints[i + 1] != null)
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
g.DrawLine(_serLinePen, _serPoints[i].X, _serPoints[i].Y, _serPoints[i + 1].X, _serPoints[i + 1].Y);
}
break;
case cSeries.eType.LineShadowed:
if (i + 1 < _serPoints.Count && _serPoints[i + 1] != null)
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
Pen pline = new Pen(Color.LightGray);
pline.Width = 2 * _serScale[axisIndex];
g.DrawLine(pline, _serPoints[i].X + 1f * _serScale[axisIndex], _serPoints[i].Y + 1f * _serScale[axisIndex], _serPoints[i + 1].X + 1f * _serScale[axisIndex], _serPoints[i + 1].Y + 1f * _serScale[axisIndex]);
g.DrawLine(_serLinePen, _serPoints[i].X, _serPoints[i].Y, _serPoints[i + 1].X, _serPoints[i + 1].Y);
}
break;
case cSeries.eType.LineSolid:
if (i + 1 < _serPoints.Count && i < _catsToCount)
{
if (_serPoints[i + 1] == null)
g.FillEllipse(_serEllipseBrush, _serPoints[i].X - 4 / _catSkipFactor[axisIndex], _serPoints[i].Y - 4 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex]);
else
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
float half_dis = (_serPoints[i + 1].X - _serPoints[i].X) / 2;
g.DrawLine(_serLinePen, _serPoints[i].X - half_dis, _serPoints[i].Y, _serPoints[i].X + half_dis, _serPoints[i].Y);
g.DrawLine(_serLinePen, _serPoints[i].X + half_dis, _serPoints[i].Y, _serPoints[i].X + half_dis, _serPoints[i + 1].Y);
g.DrawLine(_serLinePen, _serPoints[i].X + half_dis, _serPoints[i + 1].Y, _serPoints[i + 1].X + half_dis, _serPoints[i + 1].Y);
}
}
break;
case cSeries.eType.Spline:
{
List<PointF> _curvePoints = new List<PointF>();
foreach (var p in _serPoints)
if (p != null && p.X <= _pointBottomRight.X)
_curvePoints.Add(new PointF(p.X, p.Y));
g.DrawCurve(_serLinePen, _curvePoints.ToArray());
i = _serPoints.Count;
}
break;
case cSeries.eType.Column:
if (!_seriesSorted[k].FillGradient)
g.FillRectangle(_serEllipseBrush, _serPoints[i].X + (columnscount > 1 ? -columnwidth * columnscount / 2 + columnwidth * columnindex : -columnwidth / 2), _serPoints[i].Y, columnwidth, _drawArea.Y - _serPoints[i].Y);
else
g.FillRectangle(_tbrush, _serPoints[i].X + (columnscount > 1 ? -columnwidth * columnscount / 2 + columnwidth * columnindex : -columnwidth / 2), _serPoints[i].Y, columnwidth, _drawArea.Y - _serPoints[i].Y);
if (_seriesSorted[k].Outline)
g.DrawRectangle(_serLinePen, _serPoints[i].X + (columnscount > 1 ? -columnwidth * columnscount / 2 + columnwidth * columnindex : -columnwidth / 2), _serPoints[i].Y, columnwidth, _drawArea.Y - _serPoints[i].Y);
//g.DrawString(_serPoints[i].Data, xAxis[axisIndex].CategoriesFont, Brushes.DarkGray, _serPoints[i].X, _serPoints[i].Y);
break;
case cSeries.eType.Area:
//if (i == 0)
// g.FillEllipse(_serEllipseBrush, _serPoints[i].X - 4 / _catSkipFactor[axisIndex], _serPoints[i].Y - 4 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex]);
if (i + 1 < _serPoints.Count && _serPoints[i + 1] != null && i < _catsToCount)
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
List<PointF> _areaPoints = new List<PointF>();
_areaPoints.Add(new PointF(_serPoints[i].X, _serPoints[i].Y));
_areaPoints.Add(new PointF(_serPoints[i + 1].X, _serPoints[i + 1].Y));
_areaPoints.Add(new PointF(_serPoints[i + 1].X, _drawArea.Y));
_areaPoints.Add(new PointF(_serPoints[i].X, _drawArea.Y));
if (!_seriesSorted[k].FillGradient)
g.FillPolygon(_areaBrush, _areaPoints.ToArray());
else
g.FillPolygon(_tbrush, _areaPoints.ToArray());
if (_seriesSorted[k].Outline)
g.DrawLine(_serLinePen, _serPoints[i].X, _serPoints[i].Y, _serPoints[i + 1].X, _serPoints[i + 1].Y);
}
//else
// g.FillEllipse(_serEllipseBrush, _serPoints[i].X - 4 / _catSkipFactor[axisIndex], _serPoints[i].Y - 4 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex], 8 / _catSkipFactor[axisIndex]);
break;
case cSeries.eType.AreaSolid:
if (i + 1 < _serPoints.Count && _serPoints[i + 1] != null && i < _catsToCount)
{
if (_serPoints[i + 1].X > _pointBottomRight.X)
continue; // dunno.
float half_dis = (_serPoints[i + 1].X - _serPoints[i].X) / 2;
List<PointF> _areaPoints = new List<PointF>();
_areaPoints.Add(new PointF(_serPoints[i].X - (i == 0 ? half_dis : 0), _serPoints[i].Y));
_areaPoints.Add(new PointF(_serPoints[i].X + half_dis, _serPoints[i].Y));
_areaPoints.Add(new PointF(_serPoints[i].X + half_dis, _serPoints[i + 1].Y));
_areaPoints.Add(new PointF(_serPoints[i + 1].X + (i + 2 == _serPoints.Count ? half_dis : 0) + .05f, _serPoints[i + 1].Y));
_areaPoints.Add(new PointF(_serPoints[i + 1].X + (i + 2 == _serPoints.Count ? half_dis : 0) + .05f, _drawArea.Y));
_areaPoints.Add(new PointF(_serPoints[i].X - (i == 0 ? half_dis : 0), _drawArea.Y));
if (!_seriesSorted[k].FillGradient)
g.FillPolygon(_areaBrush, _areaPoints.ToArray());
else
g.FillPolygon(_tbrush, _areaPoints.ToArray());
if (_seriesSorted[k].Outline)
{
g.DrawLine(_serLinePen, _serPoints[i].X - (i == 0 ? half_dis : 0), _serPoints[i].Y, _serPoints[i].X + half_dis, _serPoints[i].Y);
g.DrawLine(_serLinePen, _serPoints[i].X + half_dis, _serPoints[i].Y, _serPoints[i].X + half_dis, _serPoints[i + 1].Y);
g.DrawLine(_serLinePen, _serPoints[i].X + half_dis, _serPoints[i + 1].Y, _serPoints[i + 1].X + (i + 2 == _serPoints.Count ? half_dis : 0), _serPoints[i + 1].Y);
}
}
break;
case cSeries.eType.AreaSpline:
{
List<PointF> _curvePoints = new List<PointF>();
foreach (var p in _serPoints)
if (p != null && p.X <= _pointBottomRight.X)
_curvePoints.Add(new PointF(p.X, p.Y));
i = _serPoints.Count;
System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
path.AddCurve(_curvePoints.ToArray());
if (_curvePoints.Count > 0)
{
PointF firstPoint = new PointF(_curvePoints[0].X, _curvePoints[0].Y);
PointF lastPoint = new PointF(_curvePoints[_curvePoints.Count - 1].X, _curvePoints[_curvePoints.Count - 1].Y);
path.AddLine(lastPoint.X, lastPoint.Y, lastPoint.X, _drawArea.Y);
path.AddLine(lastPoint.X, _drawArea.Y, firstPoint.X, _drawArea.Y);
path.AddLine(firstPoint.X, _drawArea.Y, firstPoint.X, firstPoint.Y);
if (!_seriesSorted[k].FillGradient)
g.FillPath(_areaBrush, path);
else
g.FillPath(_tbrush, path);
if (_seriesSorted[k].Outline)
g.DrawCurve(_serLinePen, _curvePoints.ToArray());
//g.DrawLine(_serLinePen, lastPoint.X, lastPoint.Y, lastPoint.X, _plotLowerPoint.Y);
//g.DrawLine(_serLinePen, firstPoint.X, _plotLowerPoint.Y, firstPoint.X, firstPoint.Y);
}
}
break;
}
}
}
if (_seriesSorted[k].Type == cSeries.eType.Column)
columnindex++;
}
}
}
private void doRender(object sender, DoWorkEventArgs e)
{
var polygons = this.Polygons;
if (!(polygons?.Any() ?? false))
{
_image.Source = null;
return;
}
_width = _layer.Map.Size.Width;
_height = _layer.Map.Size.Height;
initialize();
if (this.IsDirty || _paths == null)
{
var paths = new Dictionary <PolygonObject, IEnumerable <System.Drawing.Drawing2D.GraphicsPath> >();
foreach (var item in polygons)
{
var polygonPaths = new List <System.Drawing.Drawing2D.GraphicsPath>();
foreach (var pixelPoints in item.Value.PixelPoints)
{
var path = new System.Drawing.Drawing2D.GraphicsPath()
{
FillMode = System.Drawing.Drawing2D.FillMode.Alternate
};
var points = pixelPoints.Select(p => p.AsGdiPointF()).ToArray();
if (_layer.UseCurvedLines)
{
path.AddCurve(points);
}
else
{
path.AddLines(points);
}
polygonPaths.Add(path);
}
paths[item.Value] = polygonPaths;
}
_paths = paths;
this.IsDirty = false;
}
var pen = _layer.StrokeColor != null && _layer.StrokeColor != Colors.Transparent && _layer.StrokeThickness > 0
? new System.Drawing.Pen(_layer.StrokeColor.AsGdiBrush(), (float)_layer.StrokeThickness)
: null;
foreach (var item in _paths)
{
foreach (var path in item.Value)
{
try
{
var fill = item.Key.Fill != null && item.Key.Fill != Colors.Transparent ? item.Key.Fill.AsGdiBrush() : null;
if (fill != null)
{
_gdiGraphics.FillPath(fill, path);
}
if (pen != null)
{
_gdiGraphics.DrawPath(pen, path);
}
}
catch { }
}
}
_interopBitmap.Invalidate();
_interopBitmap.Freeze();
e.Result = _interopBitmap;
}
public override void AddToGraphicsPath(System.Drawing.Drawing2D.GraphicsPath path)
{
path.AddCurve(Points);
}
