/// <summary>
/// Template to get a fill path.
/// </summary>
/// <param name="gp">Graphics path to fill with data.</param>
/// <param name="pdata">The plot data. Don't use the Range property of the pdata, since it is overriden by the next argument.</param>
/// <param name="range">The plot range to use.</param>
/// <param name="layer">Graphics layer.</param>
/// <param name="fillDirection">Designates a bound to fill to.</param>
/// <param name="linePoints">The points that mark the line.</param>
/// <param name="connectCircular">If true, a circular connection is drawn.</param>
private void FillOneRange_PreprocessedPoints(
GraphicsPath gp,
Processed2DPlotData pdata,
IPlotRange range,
IPlotArea layer,
CSPlaneID fillDirection,
PointF[] linePoints,
bool connectCircular,
double logicalShiftX,
double logicalShiftY
)
{
if (connectCircular)
{
gp.AddBeziers(linePoints);
gp.CloseFigure();
}
else
{
Logical3D r0 = layer.GetLogical3D(pdata, range.OriginalFirstPoint);
r0.RX += logicalShiftX;
r0.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPlaneToPoint(gp, fillDirection, r0);
gp.AddBeziers(linePoints);
Logical3D r1 = layer.GetLogical3D(pdata, range.GetOriginalRowIndexFromPlotPointIndex(range.LowerBound + linePoints.Length - 1));
r1.RX += logicalShiftX;
r1.RY += logicalShiftY;
layer.CoordinateSystem.GetIsolineFromPointToPlane(gp, r1, fillDirection);
layer.CoordinateSystem.GetIsolineOnPlane(gp, fillDirection, r1, r0);
gp.CloseFigure();
}
}
protected override void GenerateNodePath(ref GraphicsPath path)
{
if (NodeDatas.Count > 1)
{
path.AddBeziers(MyTools.ConvertBeziers(NodeDatas, false).ToArray());
}
}
/// <summary>
//3次ベジェ曲線描画
/// <summary>
public void BezierPaint(PaintEventArgs e)
{
m_path.Reset();
m_path2.Reset();
//パス追加
foreach (BezierPoint item in m_list)
{
//曲線パス
Point[] p = new Point[4];
p[0] = item.startPoint;
p[1] = item.controlPoint1;
p[2] = item.controlPoint2;
p[3] = item.endPoint;
m_path.AddBeziers(p);
}
//描画
e.Graphics.DrawPath(m_pen, m_path);
//制御点は開始点を選択しているときだけ描画する
if (m_SelectMode != SelectMode.SelectStart)
{
return;
}
//直線パス
m_path2.AddLine(m_list[m_SelectPoint].startPoint, m_list[m_SelectPoint].controlPoint1);
m_path2.AddLine(m_list[m_SelectPoint].startPoint, m_list[m_SelectPoint].controlPoint2);
e.Graphics.DrawPath(m_pen2, m_path2);
}
private GraphicsPath DrawWire(Graphics g, Pen pen, float xFrom, float yFrom, float xTo, float yTo)
{
var from = new PointF(xFrom, yFrom);
var to = new PointF(xTo, yTo);
var path = new GraphicsPath(FillMode.Winding);
if (_wireStyle == EWireStyle.Line)
{
path.AddLine(from, to);
}
else
{
var distance = to.X - from.X;
var spreadDistance = ((distance / 2f) / 100f) * _wireMiddlePointsSpread;
var fromHalf = new PointF(from.X + distance / 2 - spreadDistance, from.Y);
var toHalf = new PointF(from.X + distance / 2 + spreadDistance, to.Y);
PointF[] pathPoints = { from, fromHalf, toHalf, to };
if (_wireStyle == EWireStyle.StepLine)
{
path.AddLines(pathPoints);
}
if (_wireStyle == EWireStyle.Bezier)
{
path.AddBeziers(pathPoints);
}
}
g.DrawPath(pen, path);
return(path);
}
/// <summary>
/// Repaints the form with cool background and stuff.
/// </summary>
/// <param name="graph">The graphics object to paint to, the element will be drawn to 0, 0.</param>
public override void Paint(Graphics graph)
{
// Draws Rectangular Shapes
if (Shape == ModelShape.Arrow)
{
_arrowPath = new GraphicsPath();
// Draws the basic shape
Pen arrowPen = Highlight < 1 ? new Pen(Color.Cyan, 3F) : new Pen(Color.Black, 3F);
// Draws the curved arrow
Point[] lineArray = new Point[4];
lineArray[0] = new Point(StartPoint.X, StartPoint.Y);
lineArray[1] = new Point(StartPoint.X - ((StartPoint.X - StopPoint.X) / 3), StartPoint.Y);
lineArray[2] = new Point(StopPoint.X - ((StopPoint.X - StartPoint.X) / 3), StopPoint.Y);
lineArray[3] = new Point(StopPoint.X, StopPoint.Y);
graph.DrawBeziers(arrowPen, lineArray);
_arrowPath.AddBeziers(lineArray);
_arrowPath.Flatten();
// Draws the arrow head
Point[] arrowArray = new Point[3];
arrowArray[0] = StopPoint;
arrowArray[1] = new Point(StopPoint.X - (5 * Math.Sign(StopPoint.X - StartPoint.X)), StopPoint.Y - 2);
arrowArray[2] = new Point(StopPoint.X - (5 * Math.Sign(StopPoint.X - StartPoint.X)), StopPoint.Y + 2);
graph.DrawPolygon(arrowPen, arrowArray);
// Garbage collection
arrowPen.Dispose();
}
}
private static void RenderPathPolygon(IGraphics ig)
{
var myPath = new GraphicsPath();
ig.SmoothingMode = SmoothingMode.AntiAlias;
// Add polygon closed path.
Point[] starPoints = { new Point(45, 133), new Point(117, 125), new Point(150, 60), new Point(183, 125), new Point(252, 133),
new Point(200, 186), new Point(211, 258), new Point(150, 223), new Point(83, 258), new Point(97, 186) };
myPath.AddLines(starPoints);
myPath.CloseFigure();
// Add bezier-line combination path
Point[] pathPoints1 = { new Point(24, 60), new Point(60, -16), new Point(48, 96), new Point(84, 20) };
Point[] pathPoints2 = { new Point(84, 20), new Point(104, 60) };
myPath.AddBeziers(pathPoints1);
myPath.AddLines(pathPoints2);
// Add path closed interior test
myPath.AddEllipse(190, 15, 50, 50);
myPath.AddEllipse(225, 30, 30, 30);
ig.FillPath(new SolidBrush(Color.Aqua), myPath);
ig.DrawPath(new Pen(Color.Black, 5f), myPath);
}
/// <summary>
/// Here we recalculate the freehand path by smoothing out the lines with Beziers.
/// </summary>
private void RecalculatePath()
{
isRecalculated = true;
// Dispose the previous path, if we have one
if (freehandPath != null)
{
freehandPath.Dispose();
}
freehandPath = new GraphicsPath();
// Here we can put some cleanup... like losing all the uninteresting points.
if (capturePoints.Count >= 3)
{
int index = 0;
while ((capturePoints.Count - 1) % 3 != 0)
{
// duplicate points, first at 50% than 25% than 75%
capturePoints.Insert((int)(capturePoints.Count * POINT_OFFSET[index]), capturePoints[(int)(capturePoints.Count * POINT_OFFSET[index++])]);
}
freehandPath.AddBeziers(capturePoints.ToArray());
}
else if (capturePoints.Count == 2)
{
freehandPath.AddLine(capturePoints[0], capturePoints[1]);
}
// Recalculate the bounds
myBounds = Rectangle.Round(freehandPath.GetBounds());
}
private void EvaluateGrass()
{
GraphicsPath gp = new GraphicsPath();
PointF[] pt = new PointF[10];
int width = PenWidth + 9;
pt[0] = pt[7] = new PointF(0.5f * width, 0.1f * width);
pt[1] = pt[8] = new PointF(0.35f * width, 0.3f * width);
pt[2] = pt[9] = new PointF(0.2f * width, 0.55f * width);
pt[3] = new PointF(0.18f * width, 0.9f * width);
pt[4] = new PointF(0.15f * width, 0.875f * width);
pt[5] = new PointF(0.177f * width, 0.55f * width);
pt[6] = new PointF(0.34f * width, 0.3f * width);
gp.AddBeziers(pt);
Bitmap bmp = new Bitmap(width, width);
Graphics g = Graphics.FromImage(bmp);
g.Clear(Color.Transparent);
Pen mainPen = new Pen(Color.FromArgb(128, CurrentColor), PenWidth / 10);
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.FillPath(mainPen.Brush, gp);
g.Dispose();
texBrsuh = new TextureBrush(bmp);
}
/// <summary>
/// Returns a <c>GraphicsPath</c> representation of what will be drawn.
/// </summary>
/// <returns></returns>
public override GraphicsPath MakePath()
{
GraphicsPath graphicsPath = new GraphicsPath(FillMode.Winding);
int pointsCount = PointsCount;
PointF[] array = new PointF[pointsCount];
for (int i = 0; i < pointsCount; i = checked (i + 1))
{
array[i] = GetPoint(i);
}
bool flag = Style == GoPolygonStyle.Bezier;
if (flag && pointsCount % 3 != 1)
{
GoObject.Trace("Polygon has wrong number of points: " + pointsCount.ToString(NumberFormatInfo.InvariantInfo) + "; should have 3n+1 points");
flag = false;
}
if (flag)
{
graphicsPath.AddBeziers(array);
}
else
{
graphicsPath.AddLines(array);
}
graphicsPath.CloseAllFigures();
return(graphicsPath);
}
/// <summary>
/// Gets the path.
/// </summary>
/// <param name="shape">The shape.</param>
/// <param name="points">The points.</param>
/// <returns>GraphicsPath.</returns>
/// <exception cref="ArgumentException">For Beziers, the points array must include the starting point, and three extra points for each segment</exception>
private GraphicsPath GetPath(Shapes shape, PointF[] points)
{
GraphicsPath path = new GraphicsPath();
switch (shape)
{
case Shapes.Line:
path.AddLines(points);
break;
case Shapes.Curve:
path.AddCurve(points, 1, points.Length - 3, _Tension / 100f);
break;
case Shapes.Bezier:
if (points.Length < 4 || points.Length % 3 != 1)
{
throw new ArgumentException("For Beziers, the points array must include the starting point, and three extra points for each segment");
}
path.AddBeziers(points);
break;
default:
Debug.Assert(false);
break;
}
return(path);
}
/// <summary>
/// Here we recalculate the freehand path by smoothing out the lines with Beziers.
/// </summary>
private void RecalculatePath()
{
lock (_freehandPathLock)
{
isRecalculated = true;
// Dispose the previous path, if we have one
freehandPath?.Dispose();
freehandPath = new GraphicsPath();
// Here we can put some cleanup... like losing all the uninteresting points.
if (capturePoints.Count >= 3)
{
int index = 0;
while ((capturePoints.Count - 1) % 3 != 0)
{
// duplicate points, first at 50% than 25% than 75%
capturePoints.Insert((int)(capturePoints.Count * PointOffset[index]), capturePoints[(int)(capturePoints.Count * PointOffset[index++])]);
}
freehandPath.AddBeziers(capturePoints.Cast <PointF>().ToArray());
}
else if (capturePoints.Count == 2)
{
freehandPath.AddLine(capturePoints[0], capturePoints[1]);
}
// Recalculate the bounds
NativeRectFloat rect = freehandPath.GetBounds();
myBounds = rect.Round();
}
}
/// <summary>
/// 随机生成贝塞尔曲线
/// </summary>
/// <param name="bmp">一个图片的实例</param>
/// <param name="lineNum">线条数量</param>
/// <returns></returns>
public Bitmap DrawRandomBezier(Int32 lineNum)
{
Bitmap b = new Bitmap(Width, Height);
b.MakeTransparent();
Graphics g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.SmoothingMode = SmoothingMode.HighQuality;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
GraphicsPath gPath1 = new GraphicsPath();
Int32 lineRandNum = random.Next(lineNum);
for (int i = 0; i < (lineNum - lineRandNum); i++)
{
Pen p = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(random.Next(1, (b.Width / 10)), random.Next(1, (b.Height))),
new Point(random.Next((b.Width / 10) * 2, (b.Width / 10) * 4), random.Next(1, (b.Height))),
new Point(random.Next((b.Width / 10) * 4, (b.Width / 10) * 6), random.Next(1, (b.Height))),
new Point(random.Next((b.Width / 10) * 8, b.Width), random.Next(1, (b.Height)))
};
gPath1.AddBeziers(point);
g.DrawPath(p, gPath1);
p.Dispose();
}
for (int i = 0; i < lineRandNum; i++)
{
Pen p = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(random.Next(1, b.Width), random.Next(1, b.Height)),
new Point(random.Next((b.Width / 10) * 2, b.Width), random.Next(1, b.Height)),
new Point(random.Next((b.Width / 10) * 4, b.Width), random.Next(1, b.Height)),
new Point(random.Next(1, b.Width), random.Next(1, b.Height))
};
gPath1.AddBeziers(point);
g.DrawPath(p, gPath1);
p.Dispose();
}
return(b);
}
/// <summary>
/// 随机生成贝塞尔曲线
/// </summary>
/// <param name="lineNum">线条数量</param>
/// <returns>图片</returns>
private Bitmap DrawRandomBezier(int lineNum)
{
var b = new Bitmap(_bgWidth, _bgHeight);
b.MakeTransparent();
var g = Graphics.FromImage(b);
g.Clear(Color.Transparent);
g.SmoothingMode = SmoothingMode.HighQuality;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
var graphicsPath = new GraphicsPath();
var lineRandNum = _random.Next(lineNum);
for (var i = 0; i < lineNum - lineRandNum; i++)
{
var p = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(_random.Next(1, b.Width / 10), _random.Next(1, b.Height)),
new Point(_random.Next((b.Width / 10) * 2, (b.Width / 10) * 4), _random.Next(1, b.Height)),
new Point(_random.Next((b.Width / 10) * 4, (b.Width / 10) * 6), _random.Next(1, b.Height)),
new Point(_random.Next((b.Width / 10) * 8, b.Width), _random.Next(1, b.Height))
};
graphicsPath.AddBeziers(point);
g.DrawPath(p, graphicsPath);
p.Dispose();
}
for (var i = 0; i < lineRandNum; i++)
{
var p = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(_random.Next(1, b.Width), _random.Next(1, b.Height)),
new Point(_random.Next((b.Width / 10) * 2, b.Width), _random.Next(1, b.Height)),
new Point(_random.Next((b.Width / 10) * 4, b.Width), _random.Next(1, b.Height)),
new Point(_random.Next(1, b.Width), _random.Next(1, b.Height))
};
graphicsPath.AddBeziers(point);
g.DrawPath(p, graphicsPath);
p.Dispose();
}
return(b);
}
/// <summary>
/// 随机生成贝塞尔曲线
/// </summary>
/// <param name="lineNum"></param>
/// <returns></returns>
private Bitmap DrawRandomBezier(int lineNum)
{
Bitmap bitmap = new Bitmap(this._imageWidth, this._imageHeight);
bitmap.MakeTransparent();
using (Graphics graphics = Graphics.FromImage(bitmap))
{
graphics.Clear(Color.Transparent);
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
GraphicsPath graphicsPath = new GraphicsPath();
int tempNum = this._random.Next(lineNum);
for (int i = 0; i < (lineNum - tempNum); i++)
{
Pen pen = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(this._random.Next(1, (bitmap.Width / 10)), this._random.Next(1, (bitmap.Height))),
new Point(this._random.Next((bitmap.Width / 10) * 2, (bitmap.Width / 10) * 4), this._random.Next(1, (bitmap.Height))),
new Point(this._random.Next((bitmap.Width / 10) * 4, (bitmap.Width / 10) * 6), this._random.Next(1, (bitmap.Height))),
new Point(this._random.Next((bitmap.Width / 10) * 8, bitmap.Width), this._random.Next(1, (bitmap.Height)))
};
graphicsPath.AddBeziers(point);
graphics.DrawPath(pen, graphicsPath);
pen.Dispose();
}
for (int i = 0; i < tempNum; i++)
{
Pen pen = new Pen(GetRandomDeepColor());
Point[] point =
{
new Point(this._random.Next(1, bitmap.Width), this._random.Next(1, bitmap.Height)),
new Point(this._random.Next((bitmap.Width / 10) * 2, bitmap.Width), this._random.Next(1, bitmap.Height)),
new Point(this._random.Next((bitmap.Width / 10) * 4, bitmap.Width), this._random.Next(1, bitmap.Height)),
new Point(this._random.Next(1, bitmap.Width), this._random.Next(1, bitmap.Height))
};
graphicsPath.AddBeziers(point);
graphics.DrawPath(pen, graphicsPath);
pen.Dispose();
}
}
return(bitmap);
}
static void AddBeziers(GraphicsPath path, List <PointF> points)
{
if (points.Count > 3)
{
path.AddBeziers(points.ToArray());
}
points.Clear();
}
public override bool isPointBelongPrecisely(Point p)
{
using (GraphicsPath path = new GraphicsPath())
using (Pen pen = new Pen(penAttr.color, penAttr.width))
{
path.AddBeziers(points.ToArray());
pen.DashStyle = penAttr.dashStyle;
return(path.IsOutlineVisible(pointBeforeScaleRotate(p), pen));
}
}
protected override void OnMouseUp(MouseEventArgs e)
{
base.OnMouseUp(e);
Capture = false;
path.Clear();
path.AddBeziers(allPoints.ToArray());
allPaths.Add(path);
allPoints.Clear();
path = new GraphicsPath();
}
static private GraphicsPath Beziers()
{
GraphicsPath path = new GraphicsPath();
path.AddBeziers(new Point[7] {
new Point(20, 100), new Point(70, 10),
new Point(130, 200), new Point(180, 100),
new Point(200, 100), new Point(240, 240),
new Point(20, 100)
});
return(path);
}
public static void DrawBezierLine(this RenderTarget renderTarget, PointF[] points, Color color, float strokeWidth, StrokeStyle strokeStyle, bool disposeStrokeStyle = true)
{
if (points.Length >= 2)
{
PointF[] pathPoints;
int num;
using (GraphicsPath path = new GraphicsPath())
{
List <PointF> list = new List <PointF> {
points.First <PointF>()
};
for (num = 1; num < points.Length; num++)
{
PointF tf;
PointF tf2;
GetBezierCtrlPoint(points, num - 1, 0.15f, 0.15f, out tf, out tf2);
list.Add(tf);
list.Add(tf2);
list.Add(points[num]);
}
path.AddBeziers(list.ToArray());
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (num = 1; num < pathPoints.Length; num++)
{
sink.AddLine(new RawVector2(pathPoints[num].X, pathPoints[num].Y));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.DrawGeometry(geometry, brush, strokeWidth, strokeStyle);
brush.Dispose();
geometry.Dispose();
}
if (disposeStrokeStyle && (strokeStyle != null))
{
strokeStyle.Dispose();
}
}
}
private void AddStrokeSteam(GraphicsPath graphicsPath)
{
graphicsPath.StartFigure();
PointF[] points = new PointF[]
{
new PointF(252, 258),
new PointF(213, 163),
new PointF(305, 160),
new PointF(246, 50),
};
graphicsPath.AddBeziers(points);
}
/// <summary>
/// Renders a LineString to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="line">LineString to render</param>
/// <param name="pen">Pen style used for rendering</param>
/// <param name="map">Map reference</param>
public static void DrawBezierString(System.Drawing.Graphics g, ILineString line, System.Drawing.Pen pen, IMap map)
{
if (line.Coordinates.Length > 1)
{
var gp = new GraphicsPath();
var points = Transform.TransformToImage(line, map);
if (points.Length > 0)
{
gp.AddBeziers(points);
g.DrawPath(pen, gp);
}
}
}
public bool Contains(PointF point, Edge edge)
{
if (edge.EdgeConfig.LinePoints.Count == 0)
{
return(false);
}
var path = new GraphicsPath();
path.AddBeziers(DrawingAlghoritms.GetBezierCurveNodes(edge.EdgeConfig.Start, edge.EdgeConfig.CenterS, edge.EdgeConfig.CenterE, edge.EdgeConfig.End, 100 * 3 + 1).ToArray());
Pen pen = edge.EdgeConfig.Selected ? edge.EdgeConfig.SelectedEdgePen : edge.EdgeConfig.EdgePen;
return(path.IsOutlineVisible(point, new Pen(pen.Color, pen.Width + 15)));
}
public void DrawAndFillBeziers(Pen pen, Brush brush, TPointF[] points, TClippingStyle clippingStyle)
{
if (points.Length < 4 || (points.Length - 4) % 3 != 0)
{
int TotalPoints = 4;
if (points.Length > TotalPoints)
{
TotalPoints = 7 + ((points.Length - 5) / 3) * 3;
}
TPointF[] newpoints = new TPointF[TotalPoints];
Array.Copy(points, newpoints, points.Length);
for (int i = points.Length; i < TotalPoints; i++)
{
newpoints[i] = points[points.Length - 1];
}
points = newpoints;
}
PointF[] fpoints = ToPointF(points);
if (fpoints == null)
{
return;
}
if (brush != null)
{
using (GraphicsPath gp = new GraphicsPath())
{
gp.AddBeziers(fpoints);
switch (clippingStyle)
{
case TClippingStyle.Exclude:
Canvas.SetClip(gp, CombineMode.Exclude);
break;
case TClippingStyle.Include:
Canvas.SetClip(gp, CombineMode.Intersect);
break;
default:
Canvas.FillPath(brush, gp);
break;
}
}
}
if (pen != null && clippingStyle == TClippingStyle.None)
{
Canvas.DrawBeziers(pen, fpoints);
}
}
private void AddFilledSteam(GraphicsPath graphicsPath)
{
PointF[] points = new PointF[]
{
new PointF(92, 258),
new PointF(53, 163),
new PointF(145, 160),
new PointF(86, 50),
new PointF(138, 194),
new PointF(45, 145),
new PointF(92, 258),
};
graphicsPath.AddBeziers(points);
}
public override void Draw(Graphics g)
{
Point[] p = { new Point()
{
X = 30, Y = 30
},
new Point()
{
X = 60, Y = 90
},
new Point()
{
X = 160, Y = 230
},
new Point()
{
X = 190, Y = 150
},
new Point()
{
X = 210, Y = 230
},
new Point()
{
X = 350, Y = 120
},
new Point()
{
X = 430, Y = 60
} };
GraphicsPath gp = new GraphicsPath();
gp.AddBeziers(p);
if (Gr.isFilled)
{
gp.CloseFigure();
Region r = new Region(gp);
g.FillRegion(Gr.brush, r);
return;
}
g.DrawPath(Gr.pen, gp);
}
public override void CreatingPaint(Graphics g)
{
List <PointF> ds = NodeDatas;
if (ds != null && ds.Count > 1)
{
Pen p = PenData.CreatePen(Rect, Path);
Brush br = BrushData.CreateBrush(Rect, Path);
List <PointF> list = MyTools.ConvertBeziers(ds, true);
if (list.Count > 0)
{
GraphicsPath path = new GraphicsPath();
path.AddBeziers(list.ToArray());
g.FillPath(br, path);
g.DrawPath(p, path);
}
p.Dispose();
br.Dispose();
}
}
public List <Point> ToPixels()
{
var temp = new List <Point>();
GraphicsPath gp = new GraphicsPath();
gp.AddBeziers(ToPointArray());
gp.Flatten(null, 0.1f);
for (int i = 0; i < gp.PointCount - 1; i++)
{
var xsss = Utils.GetPointsOnLine((int)gp.PathPoints[i].X, (int)gp.PathPoints[i].Y, (int)gp.PathPoints[i + 1].X, (int)gp.PathPoints[i + 1].Y);
temp.AddRange(xsss);
if (i != gp.PointCount - 1)
{
temp.RemoveAt(temp.Count - 1);
}
}
return(temp);
}
/// <summary>
/// Returns a GDI+ <see cref="GraphicsPath"/> for the current <see cref="Polar"/>.
/// </summary>
public GraphicsPath GetGdiPath()
{
var path = new GraphicsPath();
var current = this.First;
var points = new List <PointF>()
{
current.Value.Point.ToPointF()
};
do
{
points.AddRange(new PointF[] {
current.Value.NextHandle.ToPointF(),
current.Next.Value.PreviousHandle.ToPointF(),
current.Next.Value.Point.ToPointF()
});
} while ((current = current.Next).Next != null);
path.AddBeziers(points.ToArray());
return(path);
}
public static void DrawBezierLine(this MusicCanvasControl canvas, PointF[] points, Color color, float strokeWidth, StrokeStyle strokeStyle, bool disposeStrokeStyle = true)
{
PointF[] pathPoints;
RenderTarget renderTarget = canvas.RenderTarget2D;
using (GraphicsPath path = new GraphicsPath())
{
path.AddBeziers(points);
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
PathGeometry geometry = new PathGeometry(renderTarget.Factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.DrawGeometry(geometry, brush, strokeWidth, strokeStyle);
brush.Dispose();
geometry.Dispose();
if (disposeStrokeStyle && (strokeStyle != null))
{
strokeStyle.Dispose();
}
}
// </snippet2>
// Snippet for: M:System.Drawing.Drawing2D.GraphicsPath.AddBeziers(System.Drawing.Point[])
// <snippet3>
private void AddBeziersExample(PaintEventArgs e)
{
// Adds two Bezier curves.
Point[] myArray =
{
new Point(20, 100),
new Point(40, 75),
new Point(60, 125),
new Point(80, 100),
new Point(100, 50),
new Point(120, 150),
new Point(140, 100)
};
// Create the path and add the curves.
GraphicsPath myPath = new GraphicsPath();
myPath.AddBeziers(myArray);
// Draw the path to the screen.
Pen myPen = new Pen(Color.Black, 2);
e.Graphics.DrawPath(myPen, myPath);
}
public static List<PointF> GetArrowLinePoints(float x1, float y1, float x2, float y2, float extra_thickness = 0)
{
var widthX = (x2 - x1);
var lengthX = Math.Max(60, Math.Abs(widthX / 2))
//+ Math.Max(0, -widthX / 2)
;
var lengthY = 0;// Math.Max(-170, Math.Min(-120.0f, widthX - 120.0f)) + 120.0f;
if (widthX < 120)
lengthX = 60;
var yB = ((y1 + y2) / 2) + lengthY;// (y2 + ((y1 - y2) / 2) * 0.75f) + lengthY;
var yC = y2 + yB;
var xC = (x1 + x2) / 2;
var xA = x1 + lengthX;
var xB = x2 - lengthX;
/*
if (widthX >= 120)
{
xA = xB = xC = x2 - 60;
}
//*/
var points = new List<PointF>
{
new PointF(x1, y1),
new PointF(xA, y1),
new PointF(xB, y2),
new PointF(x2 - GraphConstants.ConnectorSize - extra_thickness, y2)
};
var t = 1.0f;//Math.Min(1, Math.Max(0, (widthX - 30) / 60.0f));
var yA = (yB * t) + (yC * (1 - t));
if (widthX <= 120)
{
points.Insert(2, new PointF(xB, yA));
points.Insert(2, new PointF(xC, yA));
points.Insert(2, new PointF(xA, yA));
}
//*
using (var tempPath = new GraphicsPath())
{
tempPath.AddBeziers(points.ToArray());
tempPath.Flatten();
points = tempPath.PathPoints.ToList();
}
return points;
}
