private void Flattener_Paint(object sender, PaintEventArgs e) { GraphicsPath path = Samples.Common.Shapes.GetShape(shapeComboBox.SelectedIndex); if (path == null) { return; } e.Graphics.DrawPath(default_pen, path); int pcount = path.PointCount; if ((translateX != 0f) || (translateY != 0f)) { Matrix translateMatrix = new Matrix(); translateMatrix.Translate(translateX, translateY); path.Flatten(translateMatrix, flat); } else { path.Flatten(null, flat); } e.Graphics.DrawPath(flat_pen, path); int fcount = path.PointCount; path.Dispose(); infoLabel.Text = System.String.Format("Path Points: {0}, Flat Points: {1}", pcount, fcount); }
public List <Point> ToPolyline() { var temp = new List <Point>(); gp.Flatten(null, 0.1f); for (int i = 0; i < this.Count; i++) { temp.Add(this[i].Coord); } return(temp); }
public static RectangleF GetBounds(GraphicsPath path, Matrix matrix) { GraphicsPath path1 = (GraphicsPath)path.Clone(); path1.Flatten(matrix, 0.5f); return(path1.GetBounds()); }
private static BitmapSource Create() { BitmapSource image; using (Bitmap bitmap = new Bitmap(10, 10)) { using (Graphics graphics = Graphics.FromImage(bitmap)) { Rectangle rect = new Rectangle(0, 0, 10, 10); GraphicsPath wheel_path = new GraphicsPath(); wheel_path.AddEllipse(rect); wheel_path.Flatten(); using (PathGradientBrush path_brush = new PathGradientBrush(wheel_path)) { using (Pen pen = new Pen(path_brush, 3)) { graphics.DrawPath(pen, wheel_path); } } image = CreateBitmapSourceFromGdiBitmap(bitmap); } return(image); } }
/// <summary> /// Creates a new instance of a Distortion Service /// </summary> /// <param name="distortion">The distortion to be performed</param> /// <param name="source">The graphics path to be distorted</param> /// <param name="flatness">The precision of the flattening operation (smaller = more points = slower)</param> public DistortionService(IDistortion distortion, GraphicsPath source, float flatness = .2f) { _distortion = distortion; _source = source; _flatness = flatness; _source.Flatten(null, flatness); }
public Rectangle Draw(char c) { var text = c.ToString(); var path = new GraphicsPath(); path.AddString(text, font.FontFamily, (int)font.Style, font.Size, new Point(0, 0), StringFormat.GenericTypographic); path.Flatten(); var contures = getContures(path).ToList(); var measuredSize = new SizeF( this.fakeCanvas.MeasureString(text, this.font, int.MaxValue, StringFormat.GenericTypographic).Width + Padding * 2, TextRenderer.MeasureText(this.fakeCanvas, text, this.font, new Size(int.MaxValue, int.MaxValue)).Height + Padding * 2 ); var rect = this.atlas.Add(measuredSize); int width = rect.Size.Width; int height = rect.Size.Height; var distField = genSdf(contures, width, height); for (int y = 0; y < height; y++) { var rgbValues = new byte[4 * width]; for (int x = 0; x < width; x++) { rgbValues[4 * x] = (byte)(distField[y, x] * 255); rgbValues[4 * x + 1] = rgbValues[4 * x]; rgbValues[4 * x + 2] = rgbValues[4 * x]; rgbValues[4 * x + 3] = rgbValues[4 * x]; } Marshal.Copy(rgbValues, 0, this.bmpPtr + (rect.Y + y) * bmpData.Stride + rect.X * 4, rgbValues.Length); } return(new Rectangle(rect.X + Padding, rect.Y + Padding, width - 2 * Padding, height - 2 * Padding)); }
public MapArea(string toolTip, string url, string attributes, string postBackValue, GraphicsPath path, object tag) : base() { if (path.PointCount == 0) { throw new ArgumentException(SR.ExceptionImageMapPolygonShapeInvalid); } // Flatten all curved lines path.Flatten(); // Allocate array of floats PointF[] pathPoints = path.PathPoints; float[] coord = new float[pathPoints.Length * 2]; // Transfer path points int index = 0; foreach (PointF point in pathPoints) { coord[index++] = point.X; coord[index++] = point.Y; } // Initiazize area Initialize(MapAreaShape.Polygon, toolTip, url, attributes, postBackValue, coord, tag); }
private void InsertSubpath(int index, string toolTip, string href, string attr, GraphicsPath path, bool absCoordinates, ChartGraphics graph) { if (path.PointCount > 0) { path.Flatten(); PointF[] pathPoints = path.PathPoints; float[] array = new float[pathPoints.Length * 2]; if (absCoordinates) { for (int i = 0; i < pathPoints.Length; i++) { pathPoints[i] = graph.GetRelativePoint(pathPoints[i]); } } int num = 0; PointF[] array2 = pathPoints; for (int j = 0; j < array2.Length; j++) { PointF pointF = array2[j]; array[num++] = pointF.X; array[num++] = pointF.Y; } this.Insert(index, MapAreaShape.Polygon, toolTip, href, attr, array, null); } }
private static void DrawRestDotPart(RenderTarget renderTarget, RawVector2 pos, Color color) { PointF[] pathPoints; using (GraphicsPath path = new GraphicsPath()) { path.AddBezier(pos.X, pos.Y + 3f, pos.X - 2f, pos.Y + 6f, pos.X - 8f, pos.Y + 8f, pos.X - 12f, pos.Y + 2f); path.AddBezier((float)(pos.X - 12f), (float)(pos.Y + 2f), (float)(pos.X - 8f), (float)(pos.Y + 6.5f), (float)(pos.X - 2f), (float)(pos.Y + 5f), (float)(pos.X + 1f), (float)(pos.Y - 1f)); 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 (int i = 1; i < pathPoints.Length; i++) { sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y)); } sink.EndFigure(FigureEnd.Closed); sink.Close(); sink.Dispose(); } SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f)); renderTarget.FillGeometry(geometry, brush); brush.Dispose(); geometry.Dispose(); } renderTarget.FillCircle(new RawVector2(pos.X - 8f, pos.Y + 2f), 3f, color); }
/// <summary> /// ћетод, позвол¤ющий перемещать указатель мыши /// по заданной траектории (например, вдоль окружности) /// </summary> /// <param name="times"> оличество повторов</param> public void MoveMouse(int times) { GraphicsPath gp = new GraphicsPath(); // –азмеры экрана Rectangle screensize = Screen.GetBounds(new Point(0, 0)); // ¬ыберем произвольный пр¤моугольник в области экрана Rectangle rect = new Rectangle((int)screensize.Width / 2 - 100, (int)screensize.Height / 2 - 100, 200, 200); // ƒобавим в траекторию окружность gp.AddEllipse(rect); // –азобьем окружность на серию линий gp.Flatten(); // цикл повторений движени¤ указател¤ мыши for (int repeat = 0; repeat <= times - 1; repeat++) { // проходим через все точки траектории for (int i = 0; i <= gp.PathData.Points.Length - 1; i++) { // организуем небольшую задержку System.Threading.Thread.Sleep(10); // выводим в заголовке формы число витков this.Text = (repeat + 1).ToString(); // перемещаем указатель мыши Cursor.Position = new Point((int)gp.PathData.Points[i].X, (int)gp.PathData.Points[i].Y); } } gp.Dispose(); }
public static GraphicsPath Shrink(this GraphicsPath originalPath, float width) { originalPath.CloseAllFigures(); originalPath.Flatten(); var parts = originalPath.SplitFigures(); var shrunkPaths = new List <GraphicsPath>(); foreach (var part in parts) { using (var widePath = new GraphicsPath(part.PathPoints, part.PathTypes)) { // widen the figure widePath.Widen(new Pen(Color.Black, width * 2)); // pick the inner edge var innerEdge = widePath.SplitFigures()[1]; var fixedPath = CleanPath(innerEdge, part, width); if (fixedPath.PointCount > 0) { shrunkPaths.Add(fixedPath); } } } // build the result originalPath.Reset(); foreach (var p in shrunkPaths) { originalPath.AddPath(p, false); } return(originalPath); }
// Draw some text along a GraphicsPath. private void DrawTextOnPath(Graphics gr, Brush brush, Font font, string txt, GraphicsPath path, ContentAlignment alignment, GraphicsPath resultPath = null) { if (resultPath != null) { resultPath.Reset(); } // Make a copy so we don't mess up the original. path = (GraphicsPath)path.Clone(); // Flatten the path into segments. path.Flatten(new Matrix(), 0.005f); var points = path.PathPoints; gr.Transform.TransformPoints(points); // Draw characters. int start_ch = 0; PointF start_point = points[0]; for (int i = 1; i < points.Length; i++) { PointF end_point = points[i]; DrawTextOnSegment(gr, brush, font, txt, ref start_ch, ref start_point, end_point, alignment, resultPath); if (start_ch >= txt.Length) { break; } } }
/// <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(); } }
/// <summary> /// Tesselate and cache the contours of the path. /// </summary> protected virtual void CacheStroke() { // Tesselate stroke. TEMP_PATH.Reset(); TEMP_PATH.AddPath(path, false); Tesselate(TEMP_PATH, pen.Color.ToArgb(), true, false); // Set the start index of the flattened path this.flattenedStartIndex = renderListTypes.Count; // Add flattened path. TEMP_PATH.Reset(); TEMP_PATH.AddPath(path, false); TEMP_PATH.Flatten(new Matrix(), this.flatness); CacheFlatPath(TEMP_PATH); }
private void DrawColorWheel(Graphics gr, Color outline_color, int xmin, int ymin, int wid, int hgt) { GraphicsPath RoundPath = new GraphicsPath(); RoundPath.AddEllipse(new Rectangle(xmin, ymin, wid, hgt)); RoundPath.Flatten(new Matrix(), 0.1f); float num_pts = (RoundPath.PointCount - 1) / 6; Color[] surround_colors = new Color[RoundPath.PointCount]; int index = 0; InterpolateColors(surround_colors, ref index, 1 * num_pts, 255, 255, 0, 0, 255, 255, 0, 255); InterpolateColors(surround_colors, ref index, 2 * num_pts, 255, 255, 0, 255, 255, 0, 0, 255); InterpolateColors(surround_colors, ref index, 3 * num_pts, 255, 0, 0, 255, 255, 0, 255, 255); InterpolateColors(surround_colors, ref index, 4 * num_pts, 255, 0, 255, 255, 255, 0, 255, 0); InterpolateColors(surround_colors, ref index, 5 * num_pts, 255, 0, 255, 0, 255, 255, 255, 0); InterpolateColors(surround_colors, ref index, RoundPath.PointCount, 255, 255, 255, 0, 255, 255, 0, 0); using (PathGradientBrush path_brush = new PathGradientBrush(RoundPath)) { path_brush.CenterColor = Color.White; path_brush.SurroundColors = surround_colors; gr.FillPath(path_brush, RoundPath); using (Pen thick_pen = new Pen(outline_color, 2)) gr.DrawPath(thick_pen, RoundPath); } }
public Analyzer(double meanX, double meanY, GraphicsPath path) { Counters = new RunningCount[Enum.GetValues(typeof(AnalysisMetric)).Length]; foreach (AnalysisMetric metric in Enum.GetValues(typeof(AnalysisMetric))) { Counters[(int)metric] = new RunningCount(metric); } MeanX = meanX; MeanY = meanY; path.Flatten(); using (GraphicsPathIterator PathIterator = new GraphicsPathIterator(path)) { using (GraphicsPath Subpath = new GraphicsPath()) { Paths = new List <PointF[]>(); bool Closed; while (PathIterator.NextSubpath(Subpath, out Closed) > 0) { Paths.Add(Subpath.PathPoints); Subpath.Reset(); } } } }
public static GraphicsPath BuildPathPoints(Track track) { var path = new GraphicsPath(); if (track.ControlPoints.Count < 2) { return(path); } var points = track.ControlPoints.Select(cp => cp.Point.ToPointF()).ToArray(); path.AddCurve(points, Tension); path.Flatten(new Matrix(), Flatness); points = path.PathPoints; track.Points.Clear(); for (var i = 0; i < points.Length; i++) { var p = points[i]; track.Points.Add(new PathPoint { Point = p, Width = 1 }); } return(path); }
/// <summary> /// Get the desired Rounded Rectangle path. /// </summary> private GraphicsPath GetLine(RectangleF baseRect) { float x1 = (float)X1; float y1 = (float)Y1; float x2 = (float)X2; float y2 = (float)Y2; float w = (float)Math.Sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); float ang = (y2 - y1) / (x2 - x1); ang = (float)Math.Atan(ang); ang *= (float)(180.0f / Math.PI); GraphicsPath mPath = new GraphicsPath(); System.Drawing.Rectangle r = new System.Drawing.Rectangle((int)x1, (int)y1, (int)w, (int)StrokeThickness); mPath.AddRectangle(r); mPath.CloseFigure(); using (Matrix matrix = new Matrix()) { matrix.RotateAt(ang, new PointF(x1, y1), MatrixOrder.Append); matrix.Translate(baseRect.X, baseRect.Y, MatrixOrder.Append); RectangleF bounds = mPath.GetBounds(matrix); matrix.Scale(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); mPath.Transform(matrix); } mPath.Flatten(); return(mPath); }
private PathGradientBrush GetSpecialCapBrush(GaugeGraphics g, GraphicsPath path, PointF pointOrigin, float angle, Color fillColor, GradientType fillGradientType, Color fillGradientEndColor, GaugeHatchStyle fillHatchStyle) { using (GraphicsPath graphicsPath = (GraphicsPath)path.Clone()) { graphicsPath.Flatten(null, 0.3f); graphicsPath.Reset(); RectangleF bounds = path.GetBounds(); bounds.Inflate(-20f, -20f); PointF[] points = new PointF[4] { new PointF(bounds.Left, bounds.Top), new PointF(bounds.Right, bounds.Top), new PointF(bounds.Right, bounds.Bottom), new PointF(bounds.Left, bounds.Bottom) }; graphicsPath.AddLines(points); PathGradientBrush pathGradientBrush = new PathGradientBrush(graphicsPath); pathGradientBrush.SurroundColors = new Color[4] { Color.Red, Color.Green, Color.Blue, Color.Green }; pathGradientBrush.CenterColor = Color.Transparent; pathGradientBrush.CenterPoint = new PointF(bounds.Left, bounds.Top); pathGradientBrush.RotateTransform(angle, MatrixOrder.Append); pathGradientBrush.TranslateTransform(pointOrigin.X, pointOrigin.Y, MatrixOrder.Append); return(pathGradientBrush); } }
public static void DrawString(this WavefrontFormat wf, string color, Point2d pt, FontFamily family, FontStyle style, float sizeInPoints, string text) { float dpiY = 1; float emSize = dpiY * sizeInPoints / 72; using (GraphicsPath path = new GraphicsPath()) { //float dpiY = 1; path.AddString(text, family, (int)style, emSize, new PointF(0, 0), StringFormat.GenericTypographic); float pathheight = path.GetBounds().Height; path.Transform(new Matrix(1, 0, 0, -1, 0, pathheight)); path.Transform(new Matrix(1, 0, 0, 1, (float)pt.X, (float)pt.Y)); path.Flatten(new Matrix(), 0.01f); DrawPath(wf, path); } }
public void Round(System.Drawing.Region region) { GraphicsPath gPath = new GraphicsPath(); int x = 2, y = 2; int thisWidth = this.Width; int thisHeight = this.Height; if (radius) { //var g=CreateGraphics(); //var pen = new System.Drawing.Pen(System.Drawing.Color.Black,10); //g.SmoothingMode = SmoothingMode.AntiAlias; //g.DrawEllipse(pen,x,y,this.Width,this.Height); //g.PixelOffsetMode = PixelOffsetMode.HighQuality; gPath.AddEllipse(x, y, this.Width - 3f, this.Height - 3f); gPath.Flatten(); gPath.ClearMarkers(); gPath.CloseAllFigures(); Region = new System.Drawing.Region(gPath); } else { gPath.AddLine(x, y, thisWidth, y); gPath.AddLine(thisWidth, y, thisWidth, thisHeight); gPath.AddLine(thisWidth, thisHeight, x, thisHeight); gPath.AddLine(x, y, x, thisHeight); Region = new System.Drawing.Region(gPath); } }
public virtual RectangleF GetBounds() { GraphicsPath path1 = (GraphicsPath)this.GPath.Clone(); path1.Flatten(); return(path1.GetBounds()); }
static void Main(string[] args) { /* some test data */ var pointss = new Point[] { new Point(5, 20), new Point(17, 63), new Point(2, 9) }; /* instead of to the picture box, draw to a path */ using (var path = new GraphicsPath()) { path.AddCurve(pointss, 1.0F); /* use a unit matrix to get points per pixel */ using (var mx = new Matrix(1, 0, 0, 1, 0, 0)) { path.Flatten(mx, 0.1f); } /* store points in a list */ var list_of_points = new List <PointF>(path.PathPoints); /* show them */ int i = 0; foreach (var point in list_of_points) { Debug.WriteLine($"Point #{ ++i }: X={ point.X }, Y={point.Y}"); } } }
private void BuildDistortion(GraphicsPath source) { _sourceBounds = source.GetBounds(); _distortionPath = new GraphicsPath(source.FillMode); _lowerLeft = new PointF(_sourceBounds.Left, _sourceBounds.Bottom); _lowerRight = new PointF(_sourceBounds.Right, _sourceBounds.Bottom); _upperLeft = new PointF(_sourceBounds.Left, _sourceBounds.Top); _upperRight = new PointF(_sourceBounds.Right, _sourceBounds.Top); _distortionPath.AddLine(_lowerLeft, _upperLeft); _distortionPath.AddBezier(_upperLeft, new PointF(_sourceBounds.Left, _sourceBounds.Top + ((_sourceBounds.Height * (float)Intensity)) * -1), new PointF(_sourceBounds.Right, _sourceBounds.Top + ((_sourceBounds.Height * (float)Intensity)) * -1), _upperRight); _distortionPath.AddLine(_upperRight, _lowerRight); _distortionPath.AddBezier(_lowerRight, new PointF(_sourceBounds.Right, _sourceBounds.Bottom + (_sourceBounds.Height * (float)Intensity)), new PointF(_sourceBounds.Left, _sourceBounds.Bottom + (_sourceBounds.Height * (float)Intensity)), _lowerLeft); _distortionPath.Flatten(); _distortionPoints = ClipperUtility.ConvertToClipperPolygons(_distortionPath); _distortionBounds = _distortionPath.GetBounds(); }
public static void FillSector(this RenderTarget renderTarget, RawVector2 pos, float radius, Color color, float angleStart, float angleEnd) { PointF[] pathPoints; using (GraphicsPath path = new GraphicsPath()) { radius *= 2f; path.AddPie(pos.X - (radius / 2f), pos.Y - (radius / 2f), radius, radius, angleStart, angleEnd); 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 (int i = 1; i < pathPoints.Length; i++) { sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y)); } sink.EndFigure(FigureEnd.Closed); sink.Close(); sink.Dispose(); } SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f)); renderTarget.FillGeometry(geometry, brush); brush.Dispose(); geometry.Dispose(); } }
public GraphicsPath GetTempPath(IGraph graph, PointF offset) { GraphicsPath path = base.graphPath.Clone() as GraphicsPath; if (path.PointCount == 0) { return(path); } GraphicsPath path2 = new GraphicsPath(); path.Flatten(base.GraphTransform.Matrix); PointF[] points = new PointF[] { offset }; graph.GraphTransform.Matrix.TransformVectors(points); offset = points[0]; if (graph == startGraph) { path2.AddLine(new PointF(path.PathPoints[0].X + offset.X, path.PathPoints[0].Y + offset.Y), path.PathPoints[path.PointCount - 1]); } else { path2.AddLine(path.PathPoints[0], new PointF(path.PathPoints[path.PointCount - 1].X + offset.X, path.PathPoints[path.PointCount - 1].Y + offset.Y)); } return(path2); }
protected GraphicsPath CalculateTransformedPath(GraphicsPath path, SharpDX.RectangleF baseRect) { GraphicsPath result = path; using (Matrix m = new Matrix()) { RectangleF bounds = result.GetBounds(); _fillDisabled = bounds.Width < StrokeThickness || bounds.Height < StrokeThickness; if (Width > 0) { baseRect.Width = (float)Width; } if (Height > 0) { baseRect.Height = (float)Height; } float scaleW; float scaleH; if (Stretch == Stretch.Fill) { scaleW = baseRect.Width / bounds.Width; scaleH = baseRect.Height / bounds.Height; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else if (Stretch == Stretch.Uniform) { scaleW = Math.Min(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); scaleH = scaleW; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else if (Stretch == Stretch.UniformToFill) { scaleW = Math.Max(baseRect.Width / bounds.Width, baseRect.Height / bounds.Height); scaleH = scaleW; m.Translate(-bounds.X, -bounds.Y, MatrixOrder.Append); } else { // Stretch == Stretch.None scaleW = 1; scaleH = 1; } // In case bounds.Width or bounds.Height or baseRect.Width or baseRect.Height were 0 if (scaleW == 0 || float.IsNaN(scaleW) || float.IsInfinity(scaleW)) { scaleW = 1; } if (scaleH == 0 || float.IsNaN(scaleH) || float.IsInfinity(scaleH)) { scaleH = 1; } m.Scale(scaleW, scaleH, MatrixOrder.Append); m.Translate(baseRect.X, baseRect.Y, MatrixOrder.Append); result.Transform(m); result.Flatten(); } return(result); }
/// <summary> /// Method to draw the text on the <see cref="GraphicsPath"/> /// </summary> /// <returns>The area covered by the rendering process</returns> public RectangleF DrawTextOnPathEx() { var affectedArea = new RectangleF(); var points = new PointF[25001]; var count = 0; var gp = new GraphicsPath(_pathdata.Points, _pathdata.Types) { FillMode = FillMode.Winding }; _regionList.Clear(); _angles.Clear(); _pointText.Clear(); _pointTextUp.Clear(); gp.Flatten(null, 1); try { var tmpPoint = gp.PathPoints[0]; int i; PointF[] tmpPoints; for (i = 0; i <= gp.PathPoints.Length - 2; i++) { if (gp.PathTypes[i + 1] == (byte)PathPointType.Start | (gp.PathTypes[i] & (byte)PathPointType.CloseSubpath) == (byte)PathPointType.CloseSubpath) { tmpPoints = GetLinePoints(gp.PathPoints[i], tmpPoint, 1); Array.ConstrainedCopy(tmpPoints, 0, points, count, tmpPoints.Length); count += 1; tmpPoint = gp.PathPoints[i + 1]; } else { tmpPoints = GetLinePoints(gp.PathPoints[i], gp.PathPoints[i + 1], 1); Array.ConstrainedCopy(tmpPoints, 0, points, count, tmpPoints.Length); count += tmpPoints.Length - 1; } } tmpPoints = new PointF[count]; Array.Copy(points, tmpPoints, count); points = CleanPoints(tmpPoints); count = points.Length - 1; if (IsVisible(points, count)) { // if can show all letter DrawText(Graphics, points, count); } affectedArea = gp.GetBounds(); gp.Dispose(); //DrawText(points, count); } catch (Exception ex) { LastError = ex; } return(affectedArea); }
public RectangleF GetRectangle() { GraphicsPath path1 = (GraphicsPath)this.GPath.Clone(); //path1.Transform(Transform.Matrix); path1.Flatten(new Matrix(), 0.5f); return(path1.GetBounds()); }
private static void DrawTie(this RenderTarget renderTarget, SharpDX.DirectWrite.Factory writeFactory, RawVector2 startPos, RawVector2 endPos, Color color, bool flipVertical = false, bool isTriplet = false) { PointF[] pathPoints; RawVector2 vector; RawVector2 vector2; using (GraphicsPath path = new GraphicsPath()) { float num = 45f; float num2 = 0.3f; float num3 = startPos.GetDistanceByRawVector2(endPos).Clamp(64f, 256f); float num4 = startPos.GetAngleByRawVector2(endPos); float num5 = endPos.GetAngleByRawVector2(startPos); if (flipVertical) { vector = startPos.GetRawVector2ByPolarCoordinates(num4 + num, num3 * num2); vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 - num, num3 * num2); path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y); path.AddBezier(endPos.X, endPos.Y + 1f, vector2.X, vector2.Y + 2f, vector.X, vector.Y + 2f, startPos.X, startPos.Y + 1f); } else { vector = startPos.GetRawVector2ByPolarCoordinates(num4 - num, num3 * num2); vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 + num, num3 * num2); path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y); path.AddBezier(endPos.X, endPos.Y - 1f, vector2.X, vector2.Y - 2f, vector.X, vector.Y - 2f, startPos.X, startPos.Y - 1f); } 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 (int i = 1; i < pathPoints.Length; i++) { sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y)); } sink.EndFigure(FigureEnd.Closed); sink.Close(); sink.Dispose(); } SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f)); renderTarget.FillGeometry(geometry, brush); brush.Dispose(); geometry.Dispose(); if (isTriplet) { RawVector2 pos = new RawVector2(vector.X + ((vector2.X - vector.X) / 2f), vector.Y + ((vector2.Y - vector.Y) / 2f)); renderTarget.DrawTextLayout(writeFactory, "3", pos, "Consolas", 16f, Color.FromArgb((int)(color.A * 0.75f), color), TextAlignment.Center, ParagraphAlignment.Center, SharpDX.DirectWrite.FontStyle.Normal, FontWeight.ExtraBlack); } } }
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; }