/// <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; }