private void Form1_Paint(object sender, PaintEventArgs e)
{
using (Graphics g = e.Graphics)
{
GraphicsPath path = new GraphicsPath();
path.AddLine(20, 20, 170, 20);
path.AddLine(20, 20, 20, 100);
// рисуем новую фигуру
path.StartFigure();
path.AddLine(240, 140, 240, 50);
path.AddLine(240, 140, 80, 140);
path.AddRectangle(new Rectangle(30, 30, 200, 100));
// локальное преобразование траектории
//Matrix X = new Matrix();
//X.RotateAt(45, new PointF(60.0f, 100.0f));
//path.Transform(X);
// рисуем path
Pen redPen = new Pen(Color.Red, 2);
g.FillPath(new SolidBrush(Color.Bisque), path);
g.DrawPath(redPen, path);
}
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
//Создаем массив точек
Point[] points = {
new Point(5, 10),
new Point(23, 130),
new Point(130, 57)};
GraphicsPath path = new GraphicsPath();
//рисуем первую траекторию
path.StartFigure();
path.AddEllipse(170, 170, 100, 50);
// заливаем траекторию цветом
g.FillPath(Brushes.Aqua, path);
//рисуем вторую траекторию
path.StartFigure();
path.AddCurve(points, 0.5F);
path.AddArc(100, 50, 100, 100, 0, 120);
path.AddLine(50, 150, 50, 220);
// Закрываем траекторию
path.CloseFigure();
//рисуем четвертую траекторию
path.StartFigure();
path.AddArc(180, 30, 60, 60, 0, -170);
g.DrawPath(new Pen(Color.Blue, 3), path);
g.Dispose();
}
public override void DrawRegionRepresentation(Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
{
if (m_Param.Path.PointCount > 0)
{
GraphicsPath fill = new GraphicsPath();
RectangleF rect = m_Param.Path.GetBounds();
PointD refPt = (PointD)rect.Location + ((PointD)rect.Size.ToPointF()) / 2;
// this will draw beyond the shape's location
for (double i = -rect.Height; i < rect.Height; i++)
{
PointD orth = PointD.Orthogonal(m_Param.V);
PointD pt1 = refPt + orth * i * drawMethods.Spacing(m_Param.C);
PointD pt2 = pt1 + m_Param.V * rect.Width * rect.Height;
PointD pt3 = pt1 - m_Param.V * rect.Width * rect.Height;
PointD pt4 = refPt + m_Param.V * i * drawMethods.Spacing(m_Param.C);
PointD pt5 = pt4 + orth * rect.Width * rect.Height;
PointD pt6 = pt4 - orth * rect.Width * rect.Height;
fill.StartFigure();
fill.AddLine((Point)pt2, (Point)pt3);
fill.StartFigure();
fill.AddLine((Point)pt5, (Point)pt6);
}
GraphicsContainer c = gc.BeginContainer();
gc.SetClip( (Tools.Model.VectorPath) m_Param.Path);
gc.DrawPath(r.RegionGuides, fill);
gc.EndContainer(c);
}
}
public override void DrawYourSelf(Graphics graphics)
{
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddLine(Location.X, Location.Y + ModelSize.Height / 3, Location.X + ModelSize.Width, Location.Y + ModelSize.Height / 3);
path.CloseFigure();
path.StartFigure();
path.AddLine(Location.X, Location.Y + (ModelSize.Height / 3) * 2, Location.X + ModelSize.Width, Location.Y + (ModelSize.Height * 2) / 3);
path.CloseFigure();
path.AddEllipse(new RectangleF(Location, ModelSize));
path.CloseFigure();
path.Transform(this.TMatrix.TransformationMatrix);
Pen pen = new Pen(this.BorderColor, this.BorderWidth);
if (IS_FILLED)
{
SolidBrush brush = new SolidBrush(this.FillColor);
graphics.FillPath(brush, path);
}
graphics.DrawPath(pen, path);
if (this.Selected)
{
this.selectionUnit = new CoveringRectangle(Rectangle.Round(ReturnBounds()));
this.selectionUnit.DrawYourSelf(graphics);
}
}
/// <summary>
/// Изчертава елипсите.
/// </summary>
/// <param name="graphics"></param>
public override void DrawYourSelf(Graphics graphics)
{
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddEllipse(Location.X + ModelSize.Width / 3, Location.Y + ModelSize.Height / 3, ModelSize.Width / 3, ModelSize.Height / 3);
path.CloseFigure();
path.StartFigure();
path.AddLine(Location.X + (ModelSize.Width * 2) / 3, Location.Y + ModelSize.Height / 2, Location.X + ModelSize.Width, Location.Y + ModelSize.Height / 2);
path.CloseFigure();
path.AddEllipse(new RectangleF(Location, ModelSize));
path.CloseFigure();
path.Transform(this.TMatrix.TransformationMatrix);
/*
* Създава се Pen, който изчертава контура, като използва
* цвят и дебелина (определят се от конструктора)
*/
Pen pen = new Pen(this.BorderColor, this.BorderWidth);
// Правим същото, но за запълването
if (IS_FILLED)
{
SolidBrush brush = new SolidBrush(this.FillColor);
graphics.FillPath(brush, path);
}
graphics.DrawPath(pen, path);
if (this.Selected)
{
this.selectionUnit = new CoveringRectangle(Rectangle.Round(ReturnBounds()));
this.selectionUnit.DrawYourSelf(graphics);
}
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
Point[] points = {
new Point(5,10) ,
new Point(23 , 130),
new Point(130 , 57)
};
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddEllipse(170 , 170 , 100 , 50);
g.FillPath(Brushes.Black, path);
path.CloseFigure();
path.StartFigure();
path.AddCurve(points , 0.5F);
g.FillPath(Brushes.Blue, path);
//coords
g.TranslateTransform(40, 40);
Point A = new Point(0, 0);
Point B = new Point(150 , 150);
g.DrawLine(new Pen(Brushes.Black, 3), A, B);
g.Dispose();
}
public virtual void NextSubpath_Int_Int_Bool()
{
GraphicsPath path = new GraphicsPath ();
path.AddLine (new Point (100, 100), new Point (400, 100));
path.AddLine (new Point (400, 200), new Point (10, 100));
path.StartFigure ();
path.SetMarkers ();
path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280);
path.CloseFigure ();
path.StartFigure ();
path.SetMarkers ();
path.AddRectangle (new Rectangle (10, 20, 300, 400));
path.StartFigure ();
path.SetMarkers ();
path.AddLine (new Point (400, 400), new Point (400, 10));
GraphicsPathIterator iterator = new GraphicsPathIterator (path);
int start;
int end;
bool isClosed;
int count = iterator.NextSubpath (out start, out end, out isClosed);
Assert.AreEqual (4, count);
Assert.AreEqual (0, start);
Assert.AreEqual (3, end);
Assert.IsFalse (isClosed);
count = iterator.NextSubpath (out start, out end, out isClosed);
Assert.AreEqual (4, count);
Assert.AreEqual (4, start);
Assert.AreEqual (7, end);
Assert.IsTrue (isClosed);
count = iterator.NextSubpath (out start, out end, out isClosed);
Assert.AreEqual (4, count);
Assert.AreEqual (8, start);
Assert.AreEqual (11, end);
Assert.IsTrue (isClosed);
count = iterator.NextSubpath (out start, out end, out isClosed);
Assert.AreEqual (2, count);
Assert.AreEqual (12, start);
Assert.AreEqual (13, end);
Assert.IsFalse (isClosed);
count = iterator.NextSubpath (out start, out end, out isClosed);
Assert.AreEqual (0, count);
Assert.AreEqual (0, start);
Assert.AreEqual (0, end);
Assert.IsTrue (isClosed);
}
public override RectangleF ReturnBounds()
{
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddLine(Location.X, Location.Y + ModelSize.Height / 3, Location.X + ModelSize.Width, Location.Y + ModelSize.Height / 3);
path.CloseFigure();
path.StartFigure();
path.AddLine(Location.X, Location.Y + (ModelSize.Height / 3) * 2, Location.X + ModelSize.Width, Location.Y + (ModelSize.Height * 2) / 3);
path.CloseFigure();
path.AddEllipse(new RectangleF(Location, ModelSize));
path.CloseFigure();
path.Transform(this.TMatrix.TransformationMatrix);
return path.GetBounds();
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
if (BorderRadius == 0)
{
Rectangle rc = ClientRectangle;
rc.Inflate(-(int)Math.Round(BorderWidth / 2.0 + .5), -(int)Math.Round(BorderWidth / 2.0 + .5));
rc.Y = rc.Y - 1;
rc.Height = rc.Height + 1;
e.Graphics.DrawRectangle(new Pen(BorderColor, BorderWidth), rc);
}
else
{
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
GraphicsPath gp = Extensions.Create(0, 0, Width - 2, Height - 2, BorderRadius);
Pen p = new Pen(BorderColor, BorderWidth);
e.Graphics.DrawPath(p, gp);
e.Graphics.FillPath(p.Brush, gp);
StringFormat formatting = (StringFormat)StringFormat.GenericTypographic.Clone();
formatting.Alignment = StringAlignment.Center;
formatting.LineAlignment = StringAlignment.Center;
float emsize = e.Graphics.DpiY * Font.Size / 72;
gp = new GraphicsPath();
gp.StartFigure();
gp.AddString(Text, Font.FontFamily, (int)Font.Style, emsize, new Point(Width / 2, Height / 2), formatting);
gp.CloseFigure();
e.Graphics.FillPath(new Pen(ForeColor, 1).Brush, gp);
}
}
//------------------------------------------------------------------------------
private static void DrawBezierCtrlLines(Graphics graphics,
MultiPathSegment mps, uint color)
{
int cnt = mps.Count;
if (cnt < 2) return;
Pen pen = new Pen(MakeColor(color));
GraphicsPath gpath = new GraphicsPath();
PointF[] pts = new PointF[2];
pts[0] = PathToPointF(mps[0]);
pts[1] = PathToPointF(mps[1]);
gpath.StartFigure();
gpath.AddLines(pts);
if (mps.IsValid())
if (mps.curvetype == CurveType.CubicBezier)
{
pts[0] = PathToPointF(mps[2]);
pts[1] = PathToPointF(mps[3]);
gpath.StartFigure();
gpath.AddLines(pts);
}
else
{
pts[0] = PathToPointF(mps[2]);
gpath.StartFigure();
gpath.AddLines(pts);
}
graphics.DrawPath(pen, gpath);
pen.Dispose();
gpath.Dispose();
}
private GraphicsPath createRoundedRectangles(int x, int y, int width, int height, int radius)
{
int xw = x + width;
int yh = y + height;
int xwr = xw - radius;
int yhr = yh - radius;
int xr = x + radius;
int yr = y + radius;
int r2 = radius * 2;
int xwr2 = xw - r2;
int yhr2 = yh - r2;
GraphicsPath p = new GraphicsPath();
p.StartFigure();
p.AddArc(x, y, r2, r2, 180, 90);
p.AddLine(xr, y, xwr, y);
p.AddArc(xwr2, y, r2, r2, 270, 90);
p.AddLine(xw, yr, xw, yhr);
p.AddArc(xwr2, yhr2, r2, r2, 0, 90);
p.AddLine(xwr, yh, xr, yh);
p.AddArc(x, yhr2, r2, r2, 90, 90);
p.AddLine(x, yhr, x, yr);
p.CloseFigure();
return p;
}
/// <summary>
/// creates a grid according to the loaded image
/// </summary>
private void CreateGrid()
{
if (_grid!=null){_grid.Dispose(); _grid=null;}
if (_element==null) return;
//create graphicspath
_grid=new GraphicsPath();
//create columns
for (int x=0; x<=_element.Width; x++)
{
_grid.StartFigure();
_grid.AddLine(x,0,x,_element.Height);
}
//create rows
for (int y=0; y<=_element.Height; y++)
{
_grid.StartFigure();
_grid.AddLine(0,y,_element.Width,y);
}
}
public static System.Drawing.Drawing2D.GraphicsPath CreateGraphicsPath(VertexStoreSnap vxsSnap)
{
VertexSnapIter vxsIter = vxsSnap.GetVertexSnapIter();
double prevX = 0;
double prevY = 0;
double prevMoveToX = 0;
double prevMoveToY = 0;
var brush_path = new System.Drawing.Drawing2D.GraphicsPath(FillMode.Winding);//*** winding for overlapped path
for (;;)
{
double x, y;
VertexCmd cmd = vxsIter.GetNextVertex(out x, out y);
switch (cmd)
{
case PixelFarm.Agg.VertexCmd.MoveTo:
prevMoveToX = prevX = x;
prevMoveToY = prevY = y;
brush_path.StartFigure();
break;
case PixelFarm.Agg.VertexCmd.LineTo:
brush_path.AddLine((float)prevX, (float)prevY, (float)x, (float)y);
prevX = x;
prevY = y;
break;
case PixelFarm.Agg.VertexCmd.CloseAndEndFigure:
//from current point
//
brush_path.AddLine((float)prevX, (float)prevY, (float)prevMoveToX, (float)prevMoveToY);
prevX = prevMoveToX;
prevY = prevMoveToY;
brush_path.CloseFigure();
break;
case PixelFarm.Agg.VertexCmd.EndFigure:
goto EXIT_LOOP;
break;
case PixelFarm.Agg.VertexCmd.HasMore:
break;
case PixelFarm.Agg.VertexCmd.Stop:
goto EXIT_LOOP;
default:
throw new NotSupportedException();
}
}
EXIT_LOOP:
return(brush_path);
}
public static GraphicsPath GetRectangleRegion(Rectangle rect)
{
GraphicsPath gp = new GraphicsPath();
gp.StartFigure();
gp.AddLine(rect.Left, rect.Top, rect.Right, rect.Top);
gp.AddLine(rect.Right, rect.Top, rect.Right, rect.Bottom);
gp.AddLine(rect.Right, rect.Bottom, rect.Left, rect.Bottom);
gp.AddLine(rect.Left, rect.Bottom, rect.Left, rect.Top);
gp.CloseFigure();
return gp;
}
///<summary>
/// Creates a <see cref="GraphicsPath"/> representing a polygon ring
/// having the given coordinate sequence.
///</summary>
/// <remarks>
/// Uses <see cref="FillMode.Alternate"/> winding rule
/// </remarks>
/// <param name="coordinates">A coordinate sequence</param>
/// <returns>The path for the coordinate sequence</returns>
private static GraphicsPath ToPath(Coordinate[] coordinates)
{
var path = new GraphicsPath(FillMode.Alternate);
path.StartFigure();
if (coordinates.Length > 0)
path.AddLines(ToPointF(coordinates));
path.CloseFigure();
return path;
}
public new bool ContainsPoint(float X, float Y)
{
GraphicsPath Path = new GraphicsPath();
Path.StartFigure();
if (TypeShape == Nows.Ellip)
Path.AddEllipse(Rectan);
else
Path.AddPie(Rectan.X, Rectan.Y, Rectan.Width, Rectan.Height, startAngle, sweepAngle);
Path.CloseFigure();
return Path.IsVisible(X, Y);
}
public static System.Drawing.Drawing2D.GraphicsPath CreateGraphicsPath(VertexStore vxs)
{
//render vertice in store
int vcount = vxs.Count;
double prevX = 0;
double prevY = 0;
double prevMoveToX = 0;
double prevMoveToY = 0;
var brush_path = new System.Drawing.Drawing2D.GraphicsPath(FillMode.Winding);//*** winding for overlapped path
for (int i = 0; i < vcount; ++i)
{
double x, y;
PixelFarm.Agg.VertexCmd cmd = vxs.GetVertex(i, out x, out y);
switch (cmd)
{
case PixelFarm.Agg.VertexCmd.MoveTo:
prevMoveToX = prevX = x;
prevMoveToY = prevY = y;
brush_path.StartFigure();
break;
case PixelFarm.Agg.VertexCmd.LineTo:
brush_path.AddLine((float)prevX, (float)prevY, (float)x, (float)y);
prevX = x;
prevY = y;
break;
case PixelFarm.Agg.VertexCmd.CloseAndEndFigure:
brush_path.AddLine((float)prevX, (float)prevY, (float)prevMoveToX, (float)prevMoveToY);
prevMoveToX = prevX = x;
prevMoveToY = prevY = y;
brush_path.CloseFigure();
break;
case PixelFarm.Agg.VertexCmd.EndFigure:
break;
case PixelFarm.Agg.VertexCmd.HasMore:
break;
case PixelFarm.Agg.VertexCmd.Stop:
i = vcount + 1; //exit from loop
break;
default:
throw new NotSupportedException();
break;
}
}
return(brush_path);
}
/// <summary>
/// Creates the leaf shape path
/// </summary>
/// <param name="rec">The boundary of leaf shape</param>
/// <param name="round">The round edge of leaf</param>
/// <returns>Then GraphicsPath of leaf shape</returns>
public static GraphicsPath CreateLeaf(Rectangle rec, float round)
{
var path = new GraphicsPath();
path.StartFigure();
path.AddLine(rec.X, rec.Y + rec.Height, rec.X, rec.Y + round);
path.AddArc(rec.X, rec.Y, round, round, 180F, 90F);
path.AddLine(rec.X + round, rec.Y, rec.X + rec.Width, rec.Y);
path.AddLine(rec.X + rec.Width, rec.Y, rec.X + rec.Width, rec.Y + rec.Height - round);
path.AddArc(rec.X + rec.Width - round, rec.Y + rec.Height - round, round, round, 0F, 90F);
path.CloseFigure();
return path;
}
internal void AddToRing(PointF p, ref GraphicsPath ringPath)
{
if (ringPath == null)
{
ringPath = new GraphicsPath(FillMode.Alternate);
ringPath.StartFigure();
}
else
{
ringPath.AddLine(_lastPoint, p);
}
_lastPoint = p;
}
private void Form1_Paint(object sender, PaintEventArgs e)
{
GraphicsPath Path = new GraphicsPath();
Path.AddLine(10, 10, 50, 50);
Path.AddLine(100, 50, 140, 10);
Path.CloseFigure();
Path.StartFigure();
Path.AddLine(140, 80, 100, 120);
Path.AddLine(100, 150, 140, 190);
Path.CloseFigure();
e.Graphics.DrawPath(Pens.Black, Path);
}
static GraphicsPath InitializePath ()
{
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddPolygon(new PointF[]{
new PointF(0.0f, 1.9f),
new PointF(2.0f, 1.9f),
new PointF(2.0f, 1.0f),
new PointF(3.0f, 2.0f),
new PointF(2.0f, 3.0f),
new PointF(2.0f, 2.1f),
new PointF(0.0f, 2.1f)
});
path.CloseFigure();
path.StartFigure();
path.AddPolygon(new PointF[]{
new PointF(2.2f, 1.4f),
new PointF(2.7f, 2.0f),
new PointF(2.2f, 2.6f)
});
path.FillMode = FillMode.Alternate;
path.CloseFigure();
return path;
}
public static GraphicsPath CreateRoundedRectanglePath(int x, int y, int width, int height, int radius)
{
if (radius < 0)
throw new ArgumentOutOfRangeException("radius", "radius cannot be negative");
else if (radius > int.MaxValue / 2)
throw new ArgumentOutOfRangeException(
"radius",
"radius cannot be greater than " + (int.MaxValue / 2).ToDataString());
if (width < 0) throw new ArgumentOutOfRangeException("width", "width cannot be negative");
if (height < 0) throw new ArgumentOutOfRangeException("height", "height cannot be negative");
GraphicsPath path = new GraphicsPath();
path.StartFigure();
int cornerSize = 2 * radius;
// top left corner
if (radius > 0)
path.AddArc(x, y, cornerSize, cornerSize, 180, 90);
// top edge
path.AddLine(x + radius, y, x + width - radius, y);
// top right corner
if (radius > 0)
path.AddArc(x + width - cornerSize, y, cornerSize, cornerSize, 290, 90);
// right edge
path.AddLine(x + width, y + radius, x + width, y + height - radius);
// bottom right corner
if (radius > 0)
path.AddArc(x + width - cornerSize, y + height - cornerSize, cornerSize, cornerSize, 0, 90);
// bottom edge
path.AddLine(x + width - radius, y + height, x + radius, y + height);
// bottom left corner
if (radius > 0)
path.AddArc(x, y + height - cornerSize, cornerSize, cornerSize, 90, 90);
// left edge
path.AddLine(x, y + height - radius, x, y + radius);
path.CloseFigure();
return path;
}
public void DrawPath(System.Windows.Point start, IList<IPathCommand> commands, double thickness, bool fill = false)
{
m_pen.Width = (float)thickness;
GraphicsPath path = new GraphicsPath();
System.Windows.Point previous = start;
foreach (var command in commands)
{
switch (command.Type)
{
case CommandType.MoveTo:
{
path.StartFigure();
break;
}
case CommandType.LineTo:
{
LineTo line = command as LineTo;
path.AddLine((float)previous.X, (float)previous.Y, (float)line.X + (float)start.X, (float)line.Y + (float)start.Y);
break;
}
case CommandType.CurveTo:
{
CurveTo curveTo = command as CurveTo;
break;
}
case CommandType.EllipticalArcTo:
{
EllipticalArcTo ellipticalArcTo = command as EllipticalArcTo;
//path.AddArc((float)previous.X, (float)previous.Y, (float)ellipticalArcTo.Size.Width, (float)ellipticalArcTo.Size.Height, (float)ellipticalArcTo.RotationAngle, (float)ellipticalArcTo.RotationAngle);
break;
}
case CommandType.QuadraticBeizerCurveTo:
{
QuadraticBeizerCurveTo qbCurveTo = command as QuadraticBeizerCurveTo;
//path.AddBezier((float)previous.X, (float)previous.Y, (float)qbCurveTo.Control.X, (float)qbCurveTo.Control.Y, (float)qbCurveTo.Control.X, (float)qbCurveTo.Control.Y, (float)qbCurveTo.End.X, (float)qbCurveTo.End.Y);
break;
}
}
previous = new System.Windows.Point(start.X + command.End.X, start.Y + command.End.Y);
}
if (fill)
m_graphics.FillPath(Brushes.Black, path);
m_graphics.DrawPath(m_pen, path);
}
// The CreateClipRegion method creates a Region from an
// elliptical GraphicsPath.
private Region CreateClipRegion()
{
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddEllipse(new System.Drawing.Rectangle(
0,
0,
(int)wfHost.ActualWidth,
(int)wfHost.ActualHeight ) );
path.CloseFigure();
return( new Region(path) );
}
private void DrawEllipse(Ellipse ellipse, Graphics graphs)
{
var path = new GraphicsPath();
path.StartFigure();
path.AddEllipse(Util.GetShapeBound(ellipse));
path.CloseFigure();
using (var b = new SolidBrush(ellipse.FillColor))
using (var p = new Pen(ellipse.OutlineColor, ellipse.OutlineWidth))
{
p.DashStyle = ellipse.OutlineDash;
graphs.FillPath(b, path);
//_filler.FillByScanline(graphs, ellipse, ellipse.FillColor);
graphs.DrawPath(p, path);
}
}
private static GraphicsPath CreateRoundRectangle(int w, int h, int r)
{
int d = r << 1;
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddArc(new Rectangle(0, 0, d, d), 180, 90);
path.AddLine(r, 0, w - r, 0);
path.AddArc(new Rectangle(w - d, 0, d, d), 270, 90);
path.AddLine(w + 1, r, w + 1, h - r);
path.AddArc(new Rectangle(w - d, h - d, d, d), 0, 90);
path.AddLine(w - r, h + 1, r, h + 1);
path.AddArc(new Rectangle(0, h - d, d, d), 90, 90);
path.AddLine(0, h - r, 0, r);
path.CloseFigure();
return path;
}
public static GraphicsPath Convert(Path2D path)
{
GdiPath gdiPath = new GdiPath(FillMode.Winding);
foreach (Figure2D figure in path.Figures)
{
gdiPath.StartFigure();
gdiPath.AddLines(Convert(figure.Points));
if (figure.IsClosed)
{
gdiPath.CloseFigure();
}
}
return(gdiPath);
}
/// <summary>
/// The get rounded rectangle path.
/// </summary>
/// <param name="rect">
/// The rect.
/// </param>
/// <param name="radius">
/// The radius.
/// </param>
/// <param name="borderWidth">
/// The border width.
/// </param>
/// <returns>
/// The <see cref="GraphicsPath"/>.
/// </returns>
internal static GraphicsPath GetRoundedRectanglePath(Rectangle rect, int radius, int borderWidth)
{
int x = rect.X, y = rect.Y, h = rect.Height - borderWidth, w = rect.Width - borderWidth;
var p = new GraphicsPath();
p.StartFigure();
p.AddArc(x, y, 2 * radius, 2 * radius, 180, 90);
p.AddLine(x + radius, y, x + w - radius, y);
p.AddArc(x + w - 2 * radius, y, 2 * radius, 2 * radius, 270, 90);
p.AddLine(x + w, y + radius, x + w, y + h - radius);
p.AddArc(x + w - 2 * radius, y + h - 2 * radius, 2 * radius, 2 * radius, 0, 90);
p.AddLine(x + w - radius, y + h, x + radius, y + h);
p.AddArc(x, y + h - 2 * radius, 2 * radius, 2 * radius, 90, 90);
p.AddLine(x, y + h - radius, x, y + radius);
p.CloseFigure();
return p;
}
public static GraphicsPath GetCornerlessRectangleRegionFill(Rectangle rect, int drawOffset, bool roundLeft, bool roundRight)
{
int offset = 0;
GraphicsPath gp = new GraphicsPath();
gp.StartFigure();
offset = roundRight ? drawOffset : 0;
gp.AddLine(rect.Right - offset, rect.Top, rect.Right, rect.Top + offset);
gp.AddLine(rect.Right, rect.Bottom - offset, rect.Right - offset - 1, rect.Bottom + 1);
offset = roundLeft ? drawOffset : 0;
gp.AddLine(rect.Left + offset + 1, rect.Bottom + 1, rect.Left, rect.Bottom - offset);
gp.AddLine(rect.Left, rect.Top + offset, rect.Left + offset, rect.Top);
gp.CloseFigure();
return gp;
}
//------------------------------------------------------------------------------
private static void DoublePointsToGraphicsPath(List<DoublePoint> path, GraphicsPath gp, bool closed)
{
if (closed && path.Count < 2) return;
else if (!closed && path.Count < 3) return;
PointF[] pts = new PointF[path.Count];
for (int i = 0; i < path.Count; ++i)
{
pts[i] = new PointF((float)(path[i].X / scale), (float)(path[i].Y / scale));
}
if (closed)
gp.AddPolygon(pts);
else
{
gp.StartFigure();
gp.AddLines(pts);
}
}
protected void DrawFilledPath(List <SeriesFigure> figures, System.Drawing.Pen gdiPen, System.Drawing.SolidBrush gdiBrush)
{
var path = new System.Drawing.Drawing2D.GraphicsPath();
foreach (var figure in figures) // could do parallel For loop here...
{
path.StartFigure();
var points = figure.Points;
var pointCount = figure.Points.Count;
for (int i = 0; i < pointCount - 1; i++)
{
path.AddLine(points[i], points[i + 1]);
}
}
path.CloseAllFigures();
GdiGraphics.FillPath(gdiBrush, path);
GdiGraphics.DrawPath(gdiPen, path);
}
private void DrawPolygon(PolygonBase polygon, Graphics graphs)
{
if (polygon.Vertices.Count < 2)
return;
var path = new GraphicsPath();
if (polygon.IsClosedFigure) path.StartFigure();
path.AddLines(polygon.Vertices.ToPoints());
if (polygon.IsClosedFigure) path.CloseFigure();
using (var b = new SolidBrush(polygon.FillColor))
using (var p = new Pen(polygon.OutlineColor, polygon.OutlineWidth))
{
p.DashStyle = polygon.OutlineDash;
if (polygon.GetShapeType() != ShapeType.FreePencil) graphs.FillPath(b, path);
//_filler.FillByScanline(graphs, polygon, polygon.FillColor);
graphs.DrawPath(p, path);
}
}
/// <summary>
/// we do NOT store vxsSnap
/// </summary>
/// <param name="vxsSnap"></param>
/// <returns></returns>
public static System.Drawing.Drawing2D.GraphicsPath CreateGraphicsPath(VertexStoreSnap vxsSnap)
{
VertexSnapIter vxsIter = vxsSnap.GetVertexSnapIter();
double prevX = 0;
double prevY = 0;
double prevMoveToX = 0;
double prevMoveToY = 0;
var brush_path = new System.Drawing.Drawing2D.GraphicsPath(FillMode.Winding);//*** winding for overlapped path
for (; ; )
{
double x, y;
VertexCmd cmd = vxsIter.GetNextVertex(out x, out y);
switch (cmd)
{
case PixelFarm.Agg.VertexCmd.MoveTo:
prevMoveToX = prevX = x;
prevMoveToY = prevY = y;
brush_path.StartFigure();
break;
case PixelFarm.Agg.VertexCmd.LineTo:
brush_path.AddLine((float)prevX, (float)prevY, (float)x, (float)y);
prevX = x;
prevY = y;
break;
case PixelFarm.Agg.VertexCmd.CloseAndEndFigure:
//from current point
brush_path.AddLine((float)prevX, (float)prevY, (float)prevMoveToX, (float)prevMoveToY);
prevX = prevMoveToX;
prevY = prevMoveToY;
brush_path.CloseFigure();
break;
case PixelFarm.Agg.VertexCmd.EndFigure:
goto EXIT_LOOP;
case PixelFarm.Agg.VertexCmd.Stop:
goto EXIT_LOOP;
default:
throw new NotSupportedException();
}
}
EXIT_LOOP:
return brush_path;
}
/// <summary>
/// Bygger og returnerer en et rektangel, med eventuelle avrundede hjørner
/// </summary>
/// <param name="x">Startpunktets x-koordinat</param>
/// <param name="y">Startpunktet y-koordinat</param>
/// <param name="width">Bredden på rektangelet</param>
/// <param name="height">Høyden på rektangelet</param>
/// <param name="leftTopRadius">Avrundingsverdi for hjørne oppe til venstre</param>
/// <param name="rightTopRadius">Avrundingsverdi for hjørne oppe til høyre</param>
/// <param name="rightBottomRadius">Avrundingsverdi for hjørne nede til høyre</param>
/// <param name="leftBottomRadius">Avrundingsverdi for hjørne nede til venstre</param>
/// <returns>Et GraphicsPath-objekt som representerer rektangelet</returns>
public static GraphicsPath Rectangle(int x, int y, int width, int height, int leftTopRadius, int rightTopRadius, int rightBottomRadius, int leftBottomRadius)
{
GraphicsPath p = new GraphicsPath();
//Punkter for øvre venstre hjørne
Point leftTopStart = new Point(x, y + leftTopRadius);
Point leftTopStop = new Point(x + leftTopRadius, y);
Point topLeftControlPoint = new Point(x, y);
//Punkter for øvre høyre hjørne
Point rightTopStart = new Point(x + width- rightTopRadius, y);
Point rightTopStop = new Point(x + width, y + rightTopRadius);
Point topRightControlPoint = new Point(x + width, y);
//Punkter for nedre høyre hjørne
Point rightBottomStart = new Point(x + width, y + height - rightBottomRadius);
Point rightBottomStop = new Point(x + width - rightBottomRadius, y + height);
Point bottomRightControlPoint = new Point(x + width, y + height);
//Punkter for nedre venstre hjørne
Point leftBottomStart = new Point(x + leftBottomRadius, y + height);
Point leftBottomStop = new Point(x, y + height - leftBottomRadius);
Point bottomLeftControlPoint = new Point(x, y + height);
p.StartFigure();
p.AddBezier(leftTopStart, topLeftControlPoint, topLeftControlPoint, leftTopStop); //Top left corner
p.AddLine(x + leftTopRadius, y, x + width - rightTopRadius, y); //Top edge
p.AddBezier(rightTopStart, topRightControlPoint, topRightControlPoint, rightTopStop); //Top right corner
p.AddLine(x + width, y + rightTopRadius, x + width, y + height - rightBottomRadius); //Right edge
p.AddBezier(rightBottomStart, bottomRightControlPoint, bottomRightControlPoint, rightBottomStop); // Bottom right corner
p.AddLine(x + width - rightBottomRadius, y + height, x + leftBottomRadius, y + height); //Bottom edge
p.AddBezier(leftBottomStart, bottomLeftControlPoint, bottomLeftControlPoint, leftBottomStop); // Bottom right corner
p.CloseFigure();
return p;
}
public static SD2D.GraphicsPath RoundRect(RectangleF rectangle, float roundRadius)
{
var path = new SD2D.GraphicsPath();
roundRadius = Math.Min(roundRadius, Math.Min(rectangle.Width / 2, rectangle.Height / 2));
if (roundRadius <= 1)
{
path.AddRectangle(rectangle.ToSystemDrawingObject());
return(path);
}
RectangleF innerRect = RectangleF.Inflate(rectangle, -roundRadius, -roundRadius);
path.StartFigure();
path.AddArc(RoundBounds(innerRect.Right - 1, innerRect.Bottom - 1, roundRadius), 0, 90);
path.AddArc(RoundBounds(innerRect.Left, innerRect.Bottom - 1, roundRadius), 90, 90);
path.AddArc(RoundBounds(innerRect.Left, innerRect.Top, roundRadius), 180, 90);
path.AddArc(RoundBounds(innerRect.Right - 1, innerRect.Top, roundRadius), 270, 90);
path.CloseFigure();
return(path);
}
public static System.Drawing.Drawing2D.GraphicsPath Create(Rectangle bounds,
int topoffset, int bottomoffset, int shrink)
{
System.Drawing.Drawing2D.GraphicsPath p = new System.Drawing.Drawing2D.GraphicsPath();
p.StartFigure();
//____
p.AddLine(bounds.X + topoffset + shrink, bounds.Y + shrink, bounds.Width - bottomoffset - shrink, bounds.Y + shrink);
// \
p.AddLine(bounds.Width - bottomoffset - shrink, bounds.Y + shrink, bounds.Width - shrink, bounds.Y + bottomoffset + shrink);
// |
p.AddLine(bounds.Width - shrink, bounds.Y + bottomoffset + shrink, bounds.Width - topoffset - shrink, bounds.Height - shrink);
// /
p.AddLine(bounds.Width - topoffset - shrink, bounds.Height - shrink, bounds.X + bottomoffset + shrink, bounds.Height - shrink);
//____
p.AddLine(bounds.X + bottomoffset + shrink, bounds.Height - shrink, bounds.X + shrink, bounds.Height - bottomoffset - shrink);
// \
p.AddLine(bounds.X + shrink, bounds.Height - bottomoffset - shrink, bounds.X + topoffset + shrink, bounds.Y + shrink);
p.CloseFigure();
return(p);
}
public static System.Drawing.Drawing2D.GraphicsPath RoundedRect(RectangleF rect, int cornerradius, int margin, Corner roundedcorners)
{
System.Drawing.Drawing2D.GraphicsPath p = new System.Drawing.Drawing2D.GraphicsPath();
float x = rect.X;
float y = rect.Y;
float w = rect.Width;
float h = rect.Height;
int m = margin;
int r = cornerradius;
p.StartFigure();
//top left arc
if (System.Convert.ToBoolean(roundedcorners & Corner.TopLeft))
{
p.AddArc(CtrlHelper.CheckedRectangleF(x + m, y + m, 2 * r, 2 * r), 180, 90);
}
else
{
p.AddLine(new PointF(x + m, y + m + r), new PointF(x + m, y + m));
p.AddLine(new PointF(x + m, y + m), new PointF(x + m + r, y + m));
}
//top line
p.AddLine(new PointF(x + m + r, y + m), new PointF(x + w - m - r, y + m));
//top right arc
if (System.Convert.ToBoolean(roundedcorners & Corner.TopRight))
{
p.AddArc(CtrlHelper.CheckedRectangleF(x + w - m - 2 * r, y + m, 2 * r, 2 * r), 270, 90);
}
else
{
p.AddLine(new PointF(x + w - m - r, y + m), new PointF(x + w - m, y + m));
p.AddLine(new PointF(x + w - m, y + m), new PointF(x + w - m, y + m + r));
}
//right line
p.AddLine(new PointF(x + w - m, y + m + r), new PointF(x + w - m, y + h - m - r));
//bottom right arc
if (System.Convert.ToBoolean(roundedcorners & Corner.BottomRight))
{
p.AddArc(CtrlHelper.CheckedRectangleF(x + w - m - 2 * r, y + h - m - 2 * r, 2 * r, 2 * r), 0, 90);
}
else
{
p.AddLine(new PointF(x + w - m, y + h - m - r), new PointF(x + w - m, y + h - m));
p.AddLine(new PointF(x + w - m, y + h - m), new PointF(x + w - m - r, y + h - m));
}
//bottom line
p.AddLine(new PointF(x + w - m - r, y + h - m), new PointF(x + m + r, y + h - m));
//bottom left arc
if (System.Convert.ToBoolean(roundedcorners & Corner.BottomLeft))
{
p.AddArc(CtrlHelper.CheckedRectangleF(x + m, y + h - m - 2 * r, 2 * r, 2 * r), 90, 90);
}
else
{
p.AddLine(new PointF(x + m + r, y + h - m), new PointF(x + m, y + h - m));
p.AddLine(new PointF(x + m, y + h - m), new PointF(x + m, y + h - m - r));
}
//left line
p.AddLine(new PointF(x + m, y + h - m - r), new PointF(x + m, y + m + r));
//close figure...
p.CloseFigure();
return(p);
}
public static D2D.GraphicsPath ToGraphicsPath(this PathGeometryViewModel pg, Func <double, float> scale)
{
var gp = new D2D.GraphicsPath
{
FillMode = pg.FillRule == FillRule.EvenOdd ? D2D.FillMode.Alternate : D2D.FillMode.Winding
};
foreach (var pf in pg.Figures)
{
var startPoint = pf.StartPoint;
foreach (var segment in pf.Segments)
{
if (segment is ArcSegmentViewModel arcSegment)
{
// TODO: Convert WPF/SVG elliptical arc segment format to GDI+ bezier curves.
startPoint = arcSegment.Point;
}
else if (segment is CubicBezierSegmentViewModel cubicBezierSegment)
{
gp.AddBezier(
scale(startPoint.X),
scale(startPoint.Y),
scale(cubicBezierSegment.Point1.X),
scale(cubicBezierSegment.Point1.Y),
scale(cubicBezierSegment.Point2.X),
scale(cubicBezierSegment.Point2.Y),
scale(cubicBezierSegment.Point3.X),
scale(cubicBezierSegment.Point3.Y));
startPoint = cubicBezierSegment.Point3;
}
else if (segment is LineSegmentViewModel lineSegment)
{
gp.AddLine(
scale(startPoint.X),
scale(startPoint.Y),
scale(lineSegment.Point.X),
scale(lineSegment.Point.Y));
startPoint = lineSegment.Point;
}
else if (segment is QuadraticBezierSegmentViewModel quadraticBezierSegment)
{
var p1 = startPoint;
var p2 = quadraticBezierSegment.Point1;
var p3 = quadraticBezierSegment.Point2;
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1),
scale(y1),
scale(x2),
scale(y2),
scale(x3),
scale(y3),
scale(x4),
scale(y4));
startPoint = quadraticBezierSegment.Point2;
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
if (pf.IsClosed)
{
gp.CloseFigure();
}
else
{
gp.StartFigure();
}
}
return(gp);
}
public void StartFigure()
{
Control.StartFigure();
}
/// <summary>
///
/// </summary>
/// <param name="pg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static D2D.GraphicsPath ToGraphicsPath(this IPathGeometry pg, double dx, double dy, Func <double, float> scale)
{
var gp = new D2D.GraphicsPath
{
FillMode = pg.FillRule == FillRule.EvenOdd ? D2D.FillMode.Alternate : D2D.FillMode.Winding
};
foreach (var pf in pg.Figures)
{
var startPoint = pf.StartPoint;
foreach (var segment in pf.Segments)
{
if (segment is IArcSegment arcSegment)
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
// TODO: Convert WPF/SVG elliptical arc segment format to GDI+ bezier curves.
//startPoint = arcSegment.Point;
}
else if (segment is ICubicBezierSegment cubicBezierSegment)
{
gp.AddBezier(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(cubicBezierSegment.Point1.X + dx),
scale(cubicBezierSegment.Point1.Y + dy),
scale(cubicBezierSegment.Point2.X + dx),
scale(cubicBezierSegment.Point2.Y + dy),
scale(cubicBezierSegment.Point3.X + dx),
scale(cubicBezierSegment.Point3.Y + dy));
startPoint = cubicBezierSegment.Point3;
}
else if (segment is ILineSegment lineSegment)
{
gp.AddLine(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(lineSegment.Point.X + dx),
scale(lineSegment.Point.Y + dy));
startPoint = lineSegment.Point;
}
else if (segment is IPolyCubicBezierSegment polyCubicBezierSegment)
{
if (polyCubicBezierSegment.Points.Length >= 3)
{
gp.AddBezier(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(polyCubicBezierSegment.Points[0].X + dx),
scale(polyCubicBezierSegment.Points[0].Y + dy),
scale(polyCubicBezierSegment.Points[1].X + dx),
scale(polyCubicBezierSegment.Points[1].Y + dy),
scale(polyCubicBezierSegment.Points[2].X + dx),
scale(polyCubicBezierSegment.Points[2].Y + dy));
}
if (polyCubicBezierSegment.Points.Length > 3 &&
polyCubicBezierSegment.Points.Length % 3 == 0)
{
for (int i = 3; i < polyCubicBezierSegment.Points.Length; i += 3)
{
gp.AddBezier(
scale(polyCubicBezierSegment.Points[i - 1].X + dx),
scale(polyCubicBezierSegment.Points[i - 1].Y + dy),
scale(polyCubicBezierSegment.Points[i].X + dx),
scale(polyCubicBezierSegment.Points[i].Y + dy),
scale(polyCubicBezierSegment.Points[i + 1].X + dx),
scale(polyCubicBezierSegment.Points[i + 1].Y + dy),
scale(polyCubicBezierSegment.Points[i + 2].X + dx),
scale(polyCubicBezierSegment.Points[i + 2].Y + dy));
}
}
startPoint = polyCubicBezierSegment.Points.Last();
}
else if (segment is IPolyLineSegment polyLineSegment)
{
if (polyLineSegment.Points.Length >= 1)
{
gp.AddLine(
scale(startPoint.X + dx),
scale(startPoint.Y + dy),
scale(polyLineSegment.Points[0].X + dx),
scale(polyLineSegment.Points[0].Y + dy));
}
if (polyLineSegment.Points.Length > 1)
{
for (int i = 1; i < polyLineSegment.Points.Length; i++)
{
gp.AddLine(
scale(polyLineSegment.Points[i - 1].X + dx),
scale(polyLineSegment.Points[i - 1].Y + dy),
scale(polyLineSegment.Points[i].X + dx),
scale(polyLineSegment.Points[i].Y + dy));
}
}
startPoint = polyLineSegment.Points.Last();
}
else if (segment is IPolyQuadraticBezierSegment polyQuadraticSegment)
{
if (polyQuadraticSegment.Points.Length >= 2)
{
var p1 = startPoint;
var p2 = polyQuadraticSegment.Points[0];
var p3 = polyQuadraticSegment.Points[1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
if (polyQuadraticSegment.Points.Length > 2 &&
polyQuadraticSegment.Points.Length % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Length; i += 3)
{
var p1 = polyQuadraticSegment.Points[i - 1];
var p2 = polyQuadraticSegment.Points[i];
var p3 = polyQuadraticSegment.Points[i + 1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
}
startPoint = polyQuadraticSegment.Points.Last();
}
else if (segment is IQuadraticBezierSegment quadraticBezierSegment)
{
var p1 = startPoint;
var p2 = quadraticBezierSegment.Point1;
var p3 = quadraticBezierSegment.Point2;
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
startPoint = quadraticBezierSegment.Point2;
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
if (pf.IsClosed)
{
gp.CloseFigure();
}
else
{
gp.StartFigure();
}
}
return(gp);
}
