public static void Draw(Canvas canvas, List<LinePoint> points, Brush stroke, bool clear = true) { if (clear) { canvas.Children.Clear(); } PathFigureCollection myPathFigureCollection = new PathFigureCollection(); PathGeometry myPathGeometry = new PathGeometry(); foreach (LinePoint p in points) { PathFigure myPathFigure = new PathFigure(); myPathFigure.StartPoint = p.StartPoint; LineSegment myLineSegment = new LineSegment(); myLineSegment.Point = p.EndPoint; PathSegmentCollection myPathSegmentCollection = new PathSegmentCollection(); myPathSegmentCollection.Add(myLineSegment); myPathFigure.Segments = myPathSegmentCollection; myPathFigureCollection.Add(myPathFigure); } myPathGeometry.Figures = myPathFigureCollection; Path myPath = new Path(); myPath.Stroke = stroke == null ? Brushes.Black : stroke; myPath.StrokeThickness = 1; myPath.Data = myPathGeometry; canvas.Children.Add(myPath); }
public override void OnApplyTemplate() { base.OnApplyTemplate(); var partPath = this.GetTemplateChild("PART_Path") as Path; if (partPath != null) { var pathGeometry = new PathGeometry(); var ellipsePathFigure = new PathFigure() { StartPoint = new Point(0, 20) }; ellipsePathFigure.Segments = new PathSegmentCollection(); ellipsePathFigure.Segments.Add(new ArcSegment() { Size = new Size(5.0 / 6.0 * this.Width, 25), Point = new Point(this.Width, 20), IsLargeArc = false, SweepDirection = SweepDirection.Counterclockwise }); pathGeometry.Figures.Add(ellipsePathFigure); var linePathFigure = new PathFigure(); linePathFigure.Segments = new PathSegmentCollection(); linePathFigure.Segments.Add(new LineSegment() { Point = new Point(this.Width, 0) }); linePathFigure.Segments.Add(new LineSegment() { Point = new Point(this.Width, 20) }); linePathFigure.Segments.Add(new LineSegment() { Point = new Point(0, 20) }); pathGeometry.Figures.Add(linePathFigure); partPath.Data = pathGeometry; } }
public WpfMultiChart() { InitializeComponent(); LoadImages(); //do not show no data label by default ShowNoDataLabel(false); dataSeries = new List<TimeSeriesData>(); plotSeries = new TimeSeriesData(); shapeTransform = new MatrixTransform(); chartClip = new PathGeometry(); optimalGridLineSpacing = new Point(100, 50); adorner = new AdornerCursor2(ChartInteractiveCanvas, shapeTransform); adorner.CanvasSize = new Size(ChartInteractiveCanvas.ActualWidth, ChartInteractiveCanvas.ActualHeight); adorner.PanCursorImage = panCursor; panZoomCalculator = new PanZoomCalculator(); ChartCanvas.SizeChanged += new SizeChangedEventHandler(ChartCanvas_SizeChanged); ChartCanvas.IsVisibleChanged += new DependencyPropertyChangedEventHandler(ChartCanvas_IsVisibleChanged); NoDataLabel.MouseMove += new MouseEventHandler(NoDataLabel_MouseMove); AttachEventsToCanvas(ChartInteractiveCanvas); ResizeChart(); }
public static XamlMedia.PathGeometry ToXaml(this IEnumerable<LinearRing> linearRings) { var pathGeometry = new XamlMedia.PathGeometry(); foreach (var linearRing in linearRings) pathGeometry.Figures.Add(CreatePathFigure(linearRing)); return pathGeometry; }
private void AddCircularArcGraph(Point startPoint, Point endPoint, Size size) { PathFigure pf = new PathFigure(); pf.StartPoint = new Point(startPoint.X, startPoint.Y); ArcSegment arcSegment = new ArcSegment(); arcSegment.Point = new Point(endPoint.X, endPoint.Y); arcSegment.Size = size; arcSegment.SweepDirection = SweepDirection.Counterclockwise; PathSegmentCollection psc = new PathSegmentCollection(); psc.Add(arcSegment); pf.Segments = psc; PathFigureCollection pfc = new PathFigureCollection(); pfc.Add(pf); PathGeometry pg = new PathGeometry(); pg.Figures = pfc; var path = new Path(); path.Stroke = Brushes.Black; path.StrokeThickness = 1; path.Data = pg; path.Fill = Brushes.Orange; path.Stretch = Stretch.Fill; var viewportPanel = new ViewportHostPanel(); ViewportPanel.SetViewportBounds(path, new DataRect(0, 0, 50, 50)); viewportPanel.Children.Add(path); plotter.Children.Add(viewportPanel); }
/// <summary> /// Returns a Windows Media Path Geometry from a Rhinocommon Arc /// </summary> /// <param name="input">Rhinocommon Arc</param> /// <returns>System Windows Media Path Geometry</returns> public static Sm.PathGeometry ToGeometry(this Rg.Arc input) { Sm.ArcSegment arc = new Sm.ArcSegment(); Sm.PathFigure figure = new Sm.PathFigure(); Sm.PathGeometry geometry = new Sm.PathGeometry(); Sm.PathFigureCollection figureCollection = new Sm.PathFigureCollection(); Sm.PathSegmentCollection segmentCollection = new Sm.PathSegmentCollection(); figure.StartPoint = input.StartPoint.ToWindowsPoint(); arc.Point = input.EndPoint.ToWindowsPoint(); arc.Size = new Sw.Size(input.Radius, input.Radius); if (Rg.Vector3d.VectorAngle(input.Plane.Normal, Rg.Vector3d.ZAxis) > 0) { arc.SweepDirection = Sm.SweepDirection.Counterclockwise; } else { arc.SweepDirection = Sm.SweepDirection.Clockwise; } arc.IsLargeArc = (input.Angle > Math.PI); segmentCollection.Add(arc); figure.Segments = segmentCollection; figureCollection.Add(figure); geometry.Figures = figureCollection; return(geometry); }
public void StartDrawItem(DesignItem clickedOn, Type createItemType, IDesignPanel panel, System.Windows.Input.MouseEventArgs e) { var createdItem = CreateItem(panel.Context, createItemType); var startPoint = e.GetPosition(clickedOn.View); var operation = PlacementOperation.TryStartInsertNewComponents(clickedOn, new DesignItem[] { createdItem }, new Rect[] { new Rect(startPoint.X, startPoint.Y, double.NaN, double.NaN) }, PlacementType.AddItem); if (operation != null) { createdItem.Services.Selection.SetSelectedComponents(new DesignItem[] { createdItem }); operation.Commit(); } createdItem.Properties[Shape.StrokeProperty].SetValue(Brushes.Black); createdItem.Properties[Shape.StrokeThicknessProperty].SetValue(2d); createdItem.Properties[Shape.StretchProperty].SetValue(Stretch.None); var figure = new PathFigure(); var geometry = new PathGeometry(); var geometryDesignItem = createdItem.Services.Component.RegisterComponentForDesigner(geometry); var figureDesignItem = createdItem.Services.Component.RegisterComponentForDesigner(figure); createdItem.Properties[Path.DataProperty].SetValue(geometry); //geometryDesignItem.Properties[PathGeometry.FiguresProperty].CollectionElements.Add(figureDesignItem); figureDesignItem.Properties[PathFigure.StartPointProperty].SetValue(new Point(0,0)); new DrawPathMouseGesture(figure, createdItem, clickedOn.View, changeGroup, this.ExtendedItem.GetCompleteAppliedTransformationToView()).Start(panel, (MouseButtonEventArgs) e); }
protected override void OnRender(System.Windows.Media.DrawingContext drawingContext) { base.OnRender(drawingContext); // allows the points to be rendered as an image that can be further manipulated PathGeometry geometry = new PathGeometry(); this.Siz // Add all points to the geometry foreach (Points pointXY in _points) { PathFigure figure = new PathFigure(); figure.StartPoint = pointXY.FromPoint; figure.Segments.Add(new LineSegment(pointXY.ToPoint, true)); geometry.Figures.Add(figure); } // Add the first point to close the gap from the graph's end point // to graph's start point PathFigure lastFigure = new PathFigure(); lastFigure.StartPoint = _points[_points.Count - 1].FromPoint; lastFigure.Segments.Add(new LineSegment(_firstPoint, true)); geometry.Figures.Add(lastFigure); // Create a new drawing and drawing group in order to apply // a custom drawing effect GeometryDrawing drawing = new GeometryDrawing(this.Pen.Brush, this.Pen, geometry); DrawingGroup drawingGroup = new DrawingGroup(); drawingGroup.Children.Add(drawing); }
/// <summary> /// Re-generate the path /// </summary> public void Draw() { if (Points.Count < 2) { pathGeometry = null; } else { PathFigure figure = new PathFigure(); figure.StartPoint = contentObject.SourcePosition; figure.IsFilled = false; figure.IsClosed = false; #if DEBUG_ON System.Console.WriteLine("{0} connection drawing lines ", System.DateTime.Now.Millisecond); foreach (Point p in contentObject.Stops) { System.Console.Write("{0} ", p.ToString()); } #endif figure.Segments.Add(new PolyLineSegment(contentObject.Stops, true)); PathGeometry geometry = new System.Windows.Media.PathGeometry(); geometry.Figures.Add(figure); // draw different head for different types geometry.Figures.Add(DrawHead()); geometry.Freeze(); // improve the performance pathGeometry = geometry; if (IsLoaded) { InvalidateVisual(); } } }
public geometryLine(Canvas cvs) { rootPanel = cvs; //myPathFigure = new PathFigure(); myPathGeometry = new PathGeometry(); //myPathGeometry.Figures.Add(myPathFigure); myPath = new Path(); myPath.Stroke = Brushes.Blue; myPath.StrokeThickness = 1; myPath.Data = myPathGeometry; rootPanel.Children.Add(myPath); myPathFigureOld = new PathFigure(); myPathGeometryOld = new PathGeometry(); myPathGeometryOld.Figures.Add(myPathFigureOld); myPathOld = new Path(); myPathOld.Stroke = Brushes.Blue; myPathOld.StrokeThickness = 1; myPathOld.Data = myPathGeometryOld; rootPanel.Children.Add(myPathOld); myPathFigureTest = new PathFigure(); myPathGeometry.Figures.Add(myPathFigureTest); isFirstPoint = true; }
public void MoveImage(TimeSpan interval, PathGeometry beeFlyHerePath) { var storyboard = new Storyboard { RepeatBehavior = RepeatBehavior.Forever }; var moveCircleAnimation = new DoubleAnimationUsingPath { PathGeometry = beeFlyHerePath, Source = PathAnimationSource.X, Duration = interval }; Storyboard.SetTarget(moveCircleAnimation, this); Storyboard.SetTargetProperty(moveCircleAnimation, new PropertyPath("(Canvas.Left)")); var moveCircleAnimation2 = new DoubleAnimationUsingPath { PathGeometry = beeFlyHerePath, Source = PathAnimationSource.Y, Duration = interval }; Storyboard.SetTarget(moveCircleAnimation2, this); Storyboard.SetTargetProperty(moveCircleAnimation2, new PropertyPath("(Canvas.Top)")); storyboard.Children.Add(moveCircleAnimation); storyboard.Children.Add(moveCircleAnimation2); storyboard.Begin(); }
// Constructor public SineCurve() { polyLineSegment = new PolyLineSegment(); PathFigure = new PathFigure(new Point(), new PathSegment[] { polyLineSegment }, false); pathGeometry = new PathGeometry(new PathFigure[] { PathFigure }); OnRedrawPropertyChanged(new DependencyPropertyChangedEventArgs()); }
internal static void DrawUnderlyingPolyline(PathGeometry pg, DEdge edge) { IEnumerable<WinPoint> points = edge.GeometryEdge.UnderlyingPolyline.Select(p => WinPoint(p)); PathFigure pf = new PathFigure() { IsFilled = false, IsClosed = false, StartPoint = points.First() }; foreach (WinPoint p in points) { if (p != points.First()) pf.Segments.Add(new WinLineSegment() { Point = p }); PathFigure circle = new PathFigure() { IsFilled = false, IsClosed = true, StartPoint = new WinPoint(p.X - edge.RadiusOfPolylineCorner, p.Y) }; circle.Segments.Add( new ArcSegment() { Size = new WinSize(edge.RadiusOfPolylineCorner, edge.RadiusOfPolylineCorner), SweepDirection = SweepDirection.Clockwise, Point = new WinPoint(p.X + edge.RadiusOfPolylineCorner, p.Y) }); circle.Segments.Add( new ArcSegment() { Size = new WinSize(edge.RadiusOfPolylineCorner, edge.RadiusOfPolylineCorner), SweepDirection = SweepDirection.Clockwise, Point = new WinPoint(p.X - edge.RadiusOfPolylineCorner, p.Y) }); pg.Figures.Add(circle); } pg.Figures.Add(pf); }
private void SetPlayShape() { play.Children.Clear (); Path p = new Path(); PathGeometry geometry = new PathGeometry (); PathFigure f = new PathFigure (); f.Segments = new PathSegmentCollection (); p.Data = geometry; p.Fill = new SolidColorBrush(Colors.Red); p.Stroke = new SolidColorBrush(Colors.Black); geometry.Figures = new PathFigureCollection (); geometry.Figures.Add(f); LineSegment m = new LineSegment(); m.Point = new Point(3, 2); f.Segments.Add(m); m = new LineSegment(); m.Point = new Point(14, 8.5); f.Segments.Add(m); m = new LineSegment(); m.Point = new Point(3, 15); f.Segments.Add(m); m = new LineSegment(); m.Point = new Point(3, 2); f.Segments.Add(m); play.Children.Add(p); }
public Superposition() { InitializeComponent(); PathGeometry pathGeometry = new PathGeometry(); PathFigure pathFigure = new PathFigure(); pathFigure.StartPoint = new Point(0,0); PathSegmentCollection pathSegmentCollection = new PathSegmentCollection(); int maxHeight = (int)this.Height; int maxWidth = (int)this.Width; Random rand = new Random(); for (int i = 0; i < 500; i++) { LineSegment newSegment = new LineSegment(); newSegment.Point = new Point(rand.Next(0, maxWidth), rand.Next(0, maxHeight)); pathSegmentCollection.Add(newSegment); } pathFigure.Segments = pathSegmentCollection; pathGeometry.Figures.Add(pathFigure); pathBackground.Data = pathGeometry; }
// Create the pen and triangle in a static constructor and freeze them to improve performance. static InsertionAdorner() { pen = new Pen { Brush = Brushes.Gray, Thickness = 2 }; pen.Freeze(); LineSegment firstLine = new LineSegment(new Point(0, -5), false); firstLine.Freeze(); LineSegment secondLine = new LineSegment(new Point(0, 5), false); secondLine.Freeze(); PathFigure figure = new PathFigure { StartPoint = new Point(5, 0) }; figure.Segments.Add(firstLine); figure.Segments.Add(secondLine); figure.Freeze(); triangle = new PathGeometry(); triangle.Figures.Add(figure); triangle.Freeze(); }
protected override Geometry GetOrCreateConnectorGeometry(Size renderSize) { var ellipse = Ellipse.CreateFromSize(renderSize); this.SetCurrentValue(EllipseProperty, ellipse); if (ellipse.IsZero) { return Geometry.Empty; } var direction = this.ConnectorOffset; var ip = ellipse.PointOnCircumference(direction); var vertexPoint = ip + this.ConnectorOffset; var ray = new Ray(vertexPoint, this.ConnectorOffset.Negated()); var p1 = ConnectorPoint.Find(ray, this.ConnectorAngle / 2, this.StrokeThickness, ellipse); var p2 = ConnectorPoint.Find(ray, -this.ConnectorAngle / 2, this.StrokeThickness, ellipse); this.SetCurrentValue(ConnectorVertexPointProperty, vertexPoint); this.SetCurrentValue(ConnectorPoint1Property, p1); this.SetCurrentValue(ConnectorPoint2Property, p2); if (this.ConnectorGeometry is PathGeometry) { return this.ConnectorGeometry; } var figure = this.CreatePathFigureStartingAt(ConnectorPoint1Property); figure.Segments.Add(this.CreateLineSegmentTo(ConnectorVertexPointProperty)); figure.Segments.Add(this.CreateLineSegmentTo(ConnectorPoint2Property)); var geometry = new PathGeometry(); geometry.Figures.Add(figure); return geometry; }
/// <summary> /// Main back conversion routine - converts PathGeometry object to its string equivalent /// </summary> /// <param name="geometry">Path Geometry object</param> /// <returns>String equivalent to PathGeometry contents</returns> public string ConvertBack(PathGeometry geometry) { if (null == geometry) throw new ArgumentException("Path Geometry cannot be null!"); return parseBack(geometry); }
private void DrawFormattedText(DpiScaleInfo dpiInfo) { FormattedText formattedText = new FormattedText( "FABLE", new System.Globalization.CultureInfo("en-US"), FlowDirection.LeftToRight, new Typeface( new System.Windows.Media.FontFamily("Segoe UI"), FontStyles.Normal, FontWeights.Bold, FontStretches.Normal), 120, System.Windows.Media.Brushes.Red, dpiInfo.PixelsPerDip); // Build a geometry out of the text. Geometry geometry = new PathGeometry(); geometry = formattedText.BuildGeometry(new System.Windows.Point(0, 0)); // Adjust the geometry to fit the aspect ration of the video by scaling it. ScaleTransform myScaleTransform = new ScaleTransform(); myScaleTransform.ScaleX = .85; myScaleTransform.ScaleY = 2.0; geometry.Transform = myScaleTransform; // Flatten the geometry and create a PathGeometry out of it. PathGeometry pathGeometry = new PathGeometry(); pathGeometry = geometry.GetFlattenedPathGeometry(); // Use the PathGeometry for the empty placeholder Path element in XAML. path.Data = pathGeometry; // Use the PathGeometry for the animated ball that follows the path of the text outline. matrixAnimation.PathGeometry = pathGeometry; }
//private WpfPoint _lastPoint; //internal void AddToRing(WpfPoint p, ref GraphicsPath ringPath) //{ // if (ringPath == null) // { // ringPath = new GraphicsPath(FillMode.Alternate); // ringPath.StartFigure(); // } // else // { // ringPath.AddLine(_lastPoint, p); // } // _lastPoint = p; //} //internal void EndRing(GraphicsPath ringPath) //{ // ringPath.CloseFigure(); // if (Path == null) // Path = ringPath; // else // Path.AddPath(ringPath, false); //} ///<summary> /// Adds a <see cref="PathFigure"/> representing a polygon ring /// having the given coordinate sequence to the supplied <see cref="pathGeometry"/> ///</summary> ///<param name="pathGeometry">The path geometry.</param> ///<param name="coordinates">A coordinate sequence</param> ///<returns>The path for the coordinate sequence</returns> private static void AddRing(PathGeometry pathGeometry, Coordinate[] coordinates) { if (coordinates.Length <= 0) return; var figure = new PathFigure(ToPoint(coordinates[0]), ToPathSegments(coordinates), true); pathGeometry.Figures.Add(figure); }
public Triangle() { InitializeComponent(); l1 = new LineSegment(); l2 = new LineSegment(); f = new PathFigure(); f.Segments.Add(l1); f.Segments.Add(l2); f.IsClosed = true; PathGeometry g = new PathGeometry(); g.Figures.Add(f); Path p = new Path(); this.SetBinding(FillProperty, new Binding("Fill") { Source = p, Mode = BindingMode.TwoWay }); this.SetBinding(StrokeProperty, new Binding("Stroke") { Source = p, Mode = BindingMode.TwoWay }); this.SetBinding(StrokeThicknessProperty, new Binding("StrokeThickness") { Source = p, Mode = BindingMode.TwoWay }); p.Data = g; this.Fill = new SolidColorBrush(Colors.White); this.Stroke = new SolidColorBrush(Colors.Black); this.LayoutRoot.Children.Add(p); }
/// <summary> /// Create the animation and add it to the master timeline /// </summary> protected override void CreateAnimation() { var geometry = new PathGeometry(); geometry.AddGeometry(Geometry.Parse("M 10,100 C 10,300 300,-200 300,100")); var animationX = new DoubleAnimationUsingPath { PathGeometry = geometry, Duration = new Duration(this.AnimationConfiguration.Duration), Source = PathAnimationSource.X }; var animationY = new DoubleAnimationUsingPath { PathGeometry = geometry, Duration = new Duration(this.AnimationConfiguration.Duration), Source = PathAnimationSource.Y }; Storyboard.SetTargetProperty(animationX, new PropertyPath(Canvas.LeftProperty)); Storyboard.SetTargetProperty(animationY, new PropertyPath(Canvas.TopProperty)); animationX.Freeze(); animationY.Freeze(); this.MasterStoryboard.Children.Add(animationX); this.MasterStoryboard.Children.Add(animationY); }
private void RenderPolygon(DrawingContext drawingContext) { var fillBrush = Brushes.LawnGreen; var borderPen = new Pen(Brushes.Black,1.0); PathFigure myPathFigure = new PathFigure(); myPathFigure.StartPoint = maxPoints[0]; //PolyLineSegment seg = new PolyLineSegment( PathSegmentCollection myPathSegmentCollection = new PathSegmentCollection(); for (int i = 1; i < maxPoints.Count; i++) { myPathSegmentCollection.Add(new LineSegment(maxPoints[i], true)); } for (int i = minPoints.Count - 1; i >= 0; i--) { myPathSegmentCollection.Add(new LineSegment(minPoints[i], true)); } myPathFigure.Segments = myPathSegmentCollection; PathGeometry myPathGeometry = new PathGeometry(); myPathGeometry.Figures.Add(myPathFigure); drawingContext.DrawGeometry(fillBrush, borderPen, myPathGeometry); }
public static void AddGeometries(WpfHexView hexView, Collection<VSTF.TextBounds> textBounds, bool isLineGeometry, bool clipToViewport, Thickness padding, double minWidth, ref PathGeometry geo, ref bool createOutlinedPath) { foreach (var bounds in textBounds) { double left = bounds.Left - padding.Left; double right = bounds.Right + padding.Right; double top, bottom; if (isLineGeometry) { top = bounds.Top - padding.Top; bottom = bounds.Bottom + padding.Bottom; } else { top = bounds.TextTop - padding.Top; bottom = bounds.TextBottom + padding.Bottom; } if (right - left < minWidth) right = left + minWidth; if (clipToViewport) { left = Math.Max(left, hexView.ViewportLeft); right = Math.Min(right, hexView.ViewportRight); } if (right <= left || bottom <= top) continue; const double MAX_HEIGHT = 1000000; const double MAX_WIDTH = 1000000; double width = Math.Min(right - left, MAX_WIDTH); double height = Math.Min(bottom - top, MAX_HEIGHT); if (geo == null) geo = new PathGeometry { FillRule = FillRule.Nonzero }; else createOutlinedPath = true; geo.AddGeometry(new RectangleGeometry(new Rect(left, top, width, height))); } }
private void AddShape(WpfPathGeometry sgc, IGeometryCollection gc) { foreach (IGeometry geometry in gc.Geometries) { AddShape(sgc, geometry); } }
internal static PathGeometry GetPathGeometry(ConnectorInfo source, ConnectorInfo sink) { var rectSource = GetRectWithMargin(source, 0); var rectSink = GetRectWithMargin(sink, 13); var startPoint = GetOffsetPoint(source, rectSource); var endPoint = GetOffsetPoint(sink, rectSink); var midpoint = CalculateMidpoint(startPoint, new Point(endPoint.X, startPoint.Y)); var distance = CalculateDistance(startPoint, midpoint); var p1 = CalculateEndpoint(startPoint, distance, GetAngel(source.Orientation)); var p2 = CalculateEndpoint(endPoint, distance, GetAngel(sink.Orientation)); var p3 = endPoint; var geometry = new PathGeometry(); var pathFigure = new PathFigure(); pathFigure.StartPoint = startPoint; geometry.Figures.Add(pathFigure); var bs = new BezierSegment(p1, p2, p3, true); pathFigure.Segments.Add(bs); return geometry; }
/// <summary> /// 页面加载 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Page_Loaded(object sender, RoutedEventArgs e) { IsVirtualMark = new SolidColorBrush(Properties.Settings.Default.MarkVirtualColor); NotVirtualMark = new SolidColorBrush(Properties.Settings.Default.MarkNotColor); MarkDiameter = Properties.Settings.Default.MarkDiameter; RouteColor = new SolidColorBrush(Properties.Settings.Default.RouteColor); EVirtualMark.Fill = IsVirtualMark; ENotVirtualMark.Fill = NotVirtualMark; RecRoute.Fill = RouteColor; // Create the animation path. path = new Path(); path.Stroke = RouteColor; path.StrokeThickness = 3; animationPath = new PathGeometry(); pFigure = new PathFigure(); route = new PolyLineSegment(); path.Data = animationPath; pFigure.Segments.Add(route); animationPath.Figures.Add(pFigure); MapInit(); //修改日期:2013-12-1 //修改日期:2013-12-30 BindWorkLineCombox(); BindLineCombox(cbRoute_WorkLine.Text.Trim()); LoadAllMark(); }
public static m.PathGeometry ScalingPathGeometryOld(m.PathGeometry toDownsize, double scaling) { toDownsize = toDownsize.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute); m.PathGeometry toReturn = new m.PathGeometry(); foreach (m.PathFigure olfPf in toDownsize.Figures) { m.PathFigure newPf = new m.PathFigure(); Point newStartPoint = olfPf.StartPoint; newStartPoint.X *= scaling; newStartPoint.Y *= scaling; newPf.StartPoint = newStartPoint; foreach (m.PathSegment oldPs in olfPf.Segments) { m.PathSegment newPs = new m.PolyLineSegment(); foreach (Point point in ((m.PolyLineSegment)oldPs).Points) { Point tmp = point; tmp.X *= scaling; tmp.Y *= scaling; ((m.PolyLineSegment)newPs).Points.Add(tmp); } newPf.Segments.Add(newPs); } toReturn.Figures.Add(newPf); } return(toReturn); }
/* 将相邻两点连线 protected override void OnRender(DrawingContext dc) { if (InternalChildren.Count < 2) { base.OnRender(dc); return; } Point? StartPoint = null; Point? EndPoint = null; for (int index = 0; index < InternalChildren.Count; index++) { UIElement CurChhild = this.Children[index]; Vector CurV = VisualTreeHelper.GetOffset(CurChhild); if (index == 0) StartPoint = new Point(CurV.X + CurChhild.RenderSize.Width / 2, CurV.Y + CurChhild.RenderSize.Height / 2); else EndPoint = new Point(CurV.X + CurChhild.RenderSize.Width / 2, CurV.Y + CurChhild.RenderSize.Height / 2); if (StartPoint != null && EndPoint != null) { dc.DrawLine(new Pen(LineBrush, 1.0), StartPoint.Value, EndPoint.Value); StartPoint = EndPoint; } } } */ // 由LineSegment连接相邻两点并最终构成Path protected override void OnRender(DrawingContext dc) { if (InternalChildren.Count < 2) { base.OnRender(dc); return; } PathSegmentCollection segmentCollection = new PathSegmentCollection(); PathFigure pathFigure = new PathFigure() { Segments = segmentCollection }; for (int index = 0; index < InternalChildren.Count; index++) { UIElement CurChhild = this.Children[index]; Vector CurV = VisualTreeHelper.GetOffset(CurChhild); if (index == 0) pathFigure.StartPoint = new Point(CurV.X + CurChhild.RenderSize.Width / 2, CurV.Y + CurChhild.RenderSize.Height / 2); else segmentCollection.Add(new LineSegment() { Point = new Point(CurV.X + CurChhild.RenderSize.Width / 2, CurV.Y + CurChhild.RenderSize.Height / 2) }); } PathGeometry pathGeometry = new PathGeometry() { Figures = new PathFigureCollection() { pathFigure } }; dc.DrawGeometry(Brushes.Transparent, new Pen(LineBrush, 1.0), pathGeometry); }
public BeautyFont(PathGeometry pathGeometry) { this._pathGeometry = pathGeometry; _pathGeometry.Figures.Clear(); apt[0] = new Point[]{new Point(3,2),new Point(39,2), new Point(31,10),new Point(11,10) }; apt[1] = new Point[]{new Point(2,3),new Point(10,11), new Point(10,31),new Point(2,35) }; apt[2] = new Point[]{new Point(40,3),new Point(40,35), new Point(32,31),new Point(32,11) }; apt[3] = new Point[]{new Point(3,36),new Point(11,32), new Point(31,32),new Point(39,36), new Point(31,40),new Point(11,40) }; apt[4] = new Point[]{new Point(2,37),new Point(10,41), new Point(10,61),new Point(2,69) }; apt[5] = new Point[]{new Point(40,37),new Point(40,69), new Point(32,61),new Point(32,41) }; apt[6] = new Point[]{new Point(11,62),new Point(31,62), new Point(39,70),new Point(3,70) }; }
public static m.PathGeometry CloseAllPathGeometries(m.PathGeometry toClose) { toClose = toClose.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute); m.PathGeometry toReturn = new m.PathGeometry(); foreach (m.PathFigure oldPf in toClose.Figures) { m.PathFigure newPf = new m.PathFigure { StartPoint = oldPf.StartPoint }; foreach (m.PathSegment oldPs in oldPf.Segments) { m.PathSegment newPs = new m.PolyLineSegment(); foreach (Point point in ((m.PolyLineSegment)oldPs).Points) { ((m.PolyLineSegment)newPs).Points.Add(point); } ((m.PolyLineSegment)newPs).Points.Add(((m.PolyLineSegment)newPs).Points[0]); newPf.Segments.Add(newPs); } toReturn.Figures.Add(newPf); } return(toReturn); }
void Click_ConvertToFigures(object sender, System.Windows.RoutedEventArgs e) { var path = this.designItem.Component as Path; if (path.Data is StreamGeometry) { var sg = path.Data as StreamGeometry; var pg = sg.GetFlattenedPathGeometry(); // foreach (var g in parts) { // // } var pgDes = designItem.Services.Component.RegisterComponentForDesigner(pg); designItem.Properties[Path.DataProperty].SetValue(pgDes); } else if (path.Data is PathGeometry) { var pg = path.Data as PathGeometry; var figs = pg.Figures; var newPg = new PathGeometry(); var newPgDes = designItem.Services.Component.RegisterComponentForDesigner(newPg); foreach (var fig in figs) { newPgDes.Properties[PathGeometry.FiguresProperty].CollectionElements.Add(FigureToDesignItem(fig)); } designItem.Properties[Path.DataProperty].SetValue(newPg); } }
internal void DrawBezier(double thickness, Color color, Point startPoint, Point controlPoint, Point endPoint) { PathFigure myPathFigure = new PathFigure(); myPathFigure.StartPoint = startPoint; BezierSegment myBezierSegment = new BezierSegment(startPoint, endPoint, controlPoint, true); PathSegmentCollection myPathSegmentCollection = new PathSegmentCollection(); myPathSegmentCollection.Add(myBezierSegment); myPathFigure.Segments = myPathSegmentCollection; PathFigureCollection myPathFigureCollection = new PathFigureCollection(); myPathFigureCollection.Add(myPathFigure); PathGeometry myPathGeometry = new PathGeometry(); myPathGeometry.Figures = myPathFigureCollection; DrawingContext drawingContext = drawingVisual.RenderOpen(); mySolidColorBrush.Color = color; //ApplyColortool(color.A); pen.Brush = mySolidColorBrush; pen.Thickness = thickness; drawingContext.DrawGeometry(null, pen, myPathGeometry); drawingContext.Close(); image.Render(drawingVisual); }
private void AddShape(WpfPathGeometry pathGeometry, IGeometry geometry) { if (geometry is IPolygon) { AddShape(pathGeometry, (IPolygon)geometry); } else if (geometry is ILinearRing) { AddShape(pathGeometry, (ILinearRing)geometry); } else if (geometry is ILineString) { AddShape(pathGeometry, (ILineString)geometry); } else if (geometry is IPoint) { AddShape(pathGeometry, (IPoint)geometry); } else if (geometry is IGeometryCollection) { AddShape(pathGeometry, (IGeometryCollection)geometry); } else { throw new ArgumentException( "Unrecognized Geometry class: " + geometry.GetType()); } }
/// <summary> /// 通过点的集合获取三次贝赛尔曲线 /// </summary> /// <param name="points"></param> /// <returns></returns> private SystemMedia.PathGeometry GetCurveGeometry(IEnumerable <Vector2D> points) { if (points == null) { throw new ArgumentNullException(nameof(points)); } var screenPoints = points.Select(x => ConvertVectorToScreenPoint(x)).ToArray(); var bezier = new SystemMedia.PolyBezierSegment(screenPoints, true); var pathFigure = new SystemMedia.PathFigure(); var pathGeometry = new SystemMedia.PathGeometry(); pathFigure.Segments.Add(bezier); pathGeometry.Figures.Add(pathFigure); if (screenPoints.Length >= 1) { pathFigure.StartPoint = screenPoints[0]; //因为此处使用的三次贝塞尔曲线要求点的数量为3的倍数,所以在未能正处情况下,重复最后一项至下一个三的倍数; var repeatCount = (3 - (screenPoints.Length % 3)) % 3; var lastScreenPoint = screenPoints[screenPoints.Length - 1]; for (int i = 0; i < repeatCount; i++) { bezier.Points.Add(lastScreenPoint); } } return(pathGeometry); }
public static m.PathGeometry InvertHorizontally(m.PathGeometry toInvert, double maxHeight) { toInvert = toInvert.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute); m.PathGeometry toReturn = new m.PathGeometry(); foreach (m.PathFigure oldPf in toInvert.Figures) { m.PathFigure newPf = new m.PathFigure(); Point newStartPoint = oldPf.StartPoint; newStartPoint.Y = maxHeight - newStartPoint.Y; newStartPoint.X = newStartPoint.X; newPf.StartPoint = newStartPoint; foreach (m.PathSegment oldPs in oldPf.Segments) { m.PathSegment newPs = new m.PolyLineSegment(); foreach (Point point in ((m.PolyLineSegment)oldPs).Points) { Point tmp = point; tmp.Y = maxHeight - tmp.Y; ((m.PolyLineSegment)newPs).Points.Add(tmp); } newPf.Segments.Add(newPs); } toReturn.Figures.Add(newPf); } return(toReturn); }
public Geometry GetShapeGeometry() { PathFigure outer = new PathFigure(); outer.IsClosed = true; outer.StartPoint = new Point(0, 2.5); outer.Segments.Add(new LineSegment() { Point = new Point(2.5, 0) }); outer.Segments.Add(new LineSegment() { Point = new Point(5, 2.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(7.5, 0) }); outer.Segments.Add(new LineSegment() { Point = new Point(10, 2.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(9, 3.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(7.5, 2) }); outer.Segments.Add(new LineSegment() { Point = new Point(6, 3.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(8.5, 6) }); outer.Segments.Add(new LineSegment() { Point = new Point(5, 9.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(1.5, 6) }); outer.Segments.Add(new LineSegment() { Point = new Point(4, 3.5) }); outer.Segments.Add(new LineSegment() { Point = new Point(2.5, 2) }); outer.Segments.Add(new LineSegment() { Point = new Point(1, 3.5) }); PathFigure inner = new PathFigure(); inner.StartPoint = new Point(3.5, 6); inner.IsClosed = true; inner.Segments.Add(new LineSegment() { Point = new Point(5, 7.5) }); inner.Segments.Add(new LineSegment() { Point = new Point(6.5, 6) }); inner.Segments.Add(new LineSegment() { Point = new Point(5, 4.5) }); PathGeometry logoGeometry = new PathGeometry(); logoGeometry.Figures.Add(inner); logoGeometry.Figures.Add(outer); return logoGeometry; }
private void Button_Click(object sender, RoutedEventArgs e) { PathGeometry oldPathGeometry = currentPathGeometry; currentPath.Data = currentPathGeometry = new PathGeometry(); if (timer == null) { int index = 0; timer = new DispatcherTimer(); timer.Interval = TimeSpan.FromMilliseconds(8); timer.Tick += delegate { var nextPoint = GetNextPoint(oldPathGeometry, index); if (nextPoint != null) { AddNewPosition(nextPoint.Item1, nextPoint.Item2); } else { timer.Stop(); timer = null; } index++; }; timer.Start(); } }
/// <summary> /// Draw WPF path constructor /// </summary> /// <param name="MediaPath">System.Windows.Media path geometry</param> /// <param name="PathYAxis">Y Axix direction</param> public DrawWPFPath ( SysMedia.PathGeometry MediaPath, YAxisDirection PathYAxis ) { // save media path this.MediaPath = MediaPath; // save path rectangle and y axis direction PathBBoxX = MediaPath.Bounds.X; PathBBoxY = MediaPath.Bounds.Y; PathBBoxWidth = MediaPath.Bounds.Width; PathBBoxHeight = MediaPath.Bounds.Height; this.PathYAxis = PathYAxis; // test arguments if (PathBBoxWidth == 0 && PathBBoxHeight == 0) { throw new ApplicationException("DrawWPFPath: Path bounding box is empty"); } // initialization values FillRule = MediaPath.FillRule == SysMedia.FillRule.EvenOdd ? FillRule.EvenOdd : FillRule.NonZero; BlendMode = BlendMode.Normal; BrushOpacity = 1.0; PenOpacity = 1.0; PenWidth = -1; LineCap = (PdfLineCap)(-1); LineJoin = (PdfLineJoin)(-1); MiterLimit = -1; return; }
public static IEnumerable <List <drawing.Point> > GeometryToListListPointsDrawing(m.Geometry toConvert, double resolution = 20, bool flattening = false) { m.PathGeometry allPointsContainer = GeometryToPathGeometry(toConvert, resolution, flattening); List <List <drawing.Point> > allPoints = new List <List <drawing.Point> >(); foreach (m.PathFigure figures in allPointsContainer.Figures) { List <drawing.Point> allSegmentPoints = new List <drawing.Point>(); foreach (m.PathSegment segment in figures.Segments) { foreach (Point point in ((m.PolyLineSegment)segment).Points) { int x = Convert.ToInt32(Math.Round(point.X)); int y = Convert.ToInt32(Math.Round(point.Y)); drawing.Point np = new drawing.Point(x, y); allSegmentPoints.Add(np); } Point tmp = ((m.PolyLineSegment)segment).Points[0]; //allSegmentPoints.Add(tmp); // fügt startpunkt hinzu damit der kreis geschlossen ist } allPoints.Add(allSegmentPoints); } return(allPoints); }
public static XamlMedia.Geometry ToXaml(this LineString lineString) { var pathGeometry = new XamlMedia.PathGeometry(); pathGeometry.Figures.Add(CreatePathFigure(lineString)); return(pathGeometry); }
void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { switch (connectionId) { case 1: this.MainGrid = ((System.Windows.Controls.Grid)(target)); return; case 2: this.Out = ((System.Windows.Controls.Label)(target)); return; case 3: this.Out1 = ((System.Windows.Controls.Label)(target)); return; case 4: this.MainPath = ((System.Windows.Shapes.Path)(target)); return; case 5: this.PerformaceStartPoint1 = ((System.Windows.Media.PathGeometry)(target)); return; case 6: this.PerformaceStartPoint = ((System.Windows.Media.PathFigure)(target)); return; } this._contentLoaded = true; }
public static void UserDrawRoutesWPF(Route Route, DrawingContext dc, System.Windows.Media.Color color) { System.Windows.Point[] m_ScreenPnts = null; int PixelX = 0; int PixelY = 0; if (Route == null) { return; } if (Route.Points.Count() == 0) { return; } System.Windows.Media.SolidColorBrush curBrush = new System.Windows.Media.SolidColorBrush(); curBrush.Color = color;// System.Windows.Media.Colors.Gold; System.Windows.Media.Pen pen = new System.Windows.Media.Pen(curBrush, 3); // m_ScreenPnts = new System.Windows.Point[Route.arr_legs.Length + 1]; m_ScreenPnts = new System.Windows.Point[Route.Points.Count()]; //VMMainViewModel.Instance.ConvertCoordGroundToPixel(Route.arr_legs[0].FromLongn, Route.arr_legs[0].FromLatn, ref PixelX, ref PixelY); //m_ScreenPnts[0].X = PixelX; //m_ScreenPnts[0].Y = PixelY; for (int i = 0; i < Route.Points.Count(); i++) { //VMMainViewModel.Instance.ConvertCoordGroundToPixel(Route.arr_legs[i].ToLongn, Route.arr_legs[i].ToLatn, ref PixelX, ref PixelY); //m_ScreenPnts[i + 1].X = PixelX; //m_ScreenPnts[i + 1].Y = PixelY; VMMainViewModel.Instance.ConvertCoordGroundToPixel(Route.Points[i].X, Route.Points[i].Y, ref PixelX, ref PixelY); m_ScreenPnts[i].X = PixelX; m_ScreenPnts[i].Y = PixelY; } System.Windows.Media.PathGeometry PathGmtr = new System.Windows.Media.PathGeometry(); System.Windows.Media.PathFigure pathFigure = new System.Windows.Media.PathFigure(); System.Windows.Media.PolyLineSegment myPolyLineSegment = new System.Windows.Media.PolyLineSegment(); System.Windows.Media.PointCollection pc = new System.Windows.Media.PointCollection(m_ScreenPnts); myPolyLineSegment.Points = pc; pathFigure.StartPoint = m_ScreenPnts[0]; pathFigure.Segments.Add(myPolyLineSegment); PathGmtr.Figures.Add(pathFigure); dc.DrawGeometry(null, pen, PathGmtr); }
public void ResetClip() { if (clipBounds != null) { Control.Pop(); clipBounds = null; clipPath = null; } }
public void SetClip(IGraphicsPath path) { TransformStack.PopAll(); ResetClip(); clipPath = path.Clone().ToWpf(); // require a clone so changes to path don't affect current clip clipBounds = clipPath.Bounds.ToEtoF(); ApplyClip(); TransformStack.PushAll(); }
public void SetClip(RectangleF rectangle) { TransformStack.PopAll(); ResetClip(); clipBounds = rectangle; clipPath = null; ApplyClip(); TransformStack.PushAll(); }
public static XamlMedia.PathGeometry ToXaml(this IEnumerable <LinearRing> linearRings) { var pathGeometry = new XamlMedia.PathGeometry(); foreach (var linearRing in linearRings) { pathGeometry.Figures.Add(CreatePathFigure(linearRing)); } return(pathGeometry); }
public void AddPath(IGraphicsPath path, bool connect = false) { if (path.IsEmpty) { return; } var wpfPath = path.ToWpf(); if (!wpfPath.Transform.Value.IsIdentity) { var newpath = new swm.PathGeometry(); newpath.AddGeometry(wpfPath); wpfPath = newpath; } var en = wpfPath.Figures.GetEnumerator(); if (connect) { // merge current figure (if any) and first figure of new path, if they are not closed paths if (figure != null && !figure.IsClosed && en.MoveNext()) { var firstFigure = en.Current; if (!firstFigure.IsClosed) { figure.Segments.Add(new swm.LineSegment(firstFigure.StartPoint, true)); foreach (var seg in firstFigure.Segments) { figure.Segments.Add(seg); } } else { Control.Figures.Add(firstFigure); } } } swm.PathFigure pathFigure = null; while (en.MoveNext()) { pathFigure = en.Current; Control.Figures.Add(pathFigure); } // continue with last figure of new path if not closed if (pathFigure != null && !pathFigure.IsClosed) { figure = pathFigure; } else { figure = null; } }
/// <summary> /// Extracts the the Coordinates out of a PathGeometry and puts them into a PolyLineSegment. /// </summary> /// <param name="allPointsContainer">The PathGeometry that Contains the all the Coordinates you want to convert</param> /// <returns></returns> public static List <m.PolyLineSegment> PathGeometryToPlsListOld(m.PathGeometry allPointsContainer) { allPointsContainer = allPointsContainer.GetFlattenedPathGeometry(1.0, m.ToleranceType.Absolute); return (allPointsContainer.Figures.Select( figures => figures.Segments.SelectMany(segments => ((m.PolyLineSegment)segments).Points).ToList()) .Select(allPoints => new m.PolyLineSegment(allPoints, true)) .ToList()); }
public void ResetClip() { if (clipBounds != null || clipPath != null) { RewindTransform(); RewindClip(); clipBounds = null; clipPath = null; ApplyTransform(); } }
void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) { switch (connectionId) { case 1: this.btnShow = ((System.Windows.Controls.Primitives.ToggleButton)(target)); #line 17 "..\..\MainWindow.xaml" this.btnShow.Click += new System.Windows.RoutedEventHandler(this.btnShow_Click); #line default #line hidden return; case 2: this.btnDraw = ((System.Windows.Controls.Button)(target)); #line 31 "..\..\MainWindow.xaml" this.btnDraw.Click += new System.Windows.RoutedEventHandler(this.BtnDraw_Click); #line default #line hidden return; case 3: this.CanvasPanel = ((System.Windows.Controls.Canvas)(target)); return; case 4: this.TwoDEllipse = ((System.Windows.Shapes.Ellipse)(target)); return; case 5: this.TwoDRectangle = ((System.Windows.Shapes.Rectangle)(target)); return; case 6: this.TwoDRectangle2 = ((System.Windows.Shapes.Rectangle)(target)); return; case 7: this.TwoDPath = ((System.Windows.Shapes.Path)(target)); return; case 8: this.PathGeoMetry = ((System.Windows.Media.PathGeometry)(target)); return; case 9: this.PathHeart = ((System.Windows.Shapes.Path)(target)); return; } this._contentLoaded = true; }
/// <summary> /// Returns the pure PathGeometry to easily display at the screen. /// </summary> /// <returns></returns> public static m.PathGeometry GeometryToPathGeometry(m.Geometry toConvert, double resolution = 20, bool wannaFlat = false) { m.PathGeometry myPathGeometry = toConvert.GetOutlinedPathGeometry(resolution, m.ToleranceType.Relative); if (wannaFlat) { myPathGeometry = myPathGeometry.GetFlattenedPathGeometry(resolution, m.ToleranceType.Relative); } return(myPathGeometry); }
private void DrawLineCurveInternal(DrawingContext dc, double half, Pen pen, LineShape line, ref Point pt1, ref Point pt2, double dx, double dy) { double p1x = pt1.X; double p1y = pt1.Y; double p2x = pt2.X; double p2y = pt2.Y; LineShapeExtensions.GetCurvedLineBezierControlPoints( line.Style.LineStyle.CurveOrientation, line.Style.LineStyle.Curvature, line.Start.Alignment, line.End.Alignment, ref p1x, ref p1y, ref p2x, ref p2y); System.Windows.Media.PathGeometry pg = _curvedLineCache.Get(line); if (pg != null) { var pf = pg.Figures[0]; pf.StartPoint = new Point(pt1.X + dx, pt1.Y + dy); pf.IsFilled = false; var bs = pf.Segments[0] as BezierSegment; bs.Point1 = new Point(p1x + dx, p1y + dy); bs.Point2 = new Point(p2x + dx, p2y + dy); bs.Point3 = new Point(pt2.X + dx, pt2.Y + dy); bs.IsStroked = line.IsStroked; } else { var pf = new System.Windows.Media.PathFigure() { StartPoint = new Point(pt1.X + dx, pt1.Y + dy), IsFilled = false }; var bs = new BezierSegment( new Point(p1x + dx, p1y + dy), new Point(p2x + dx, p2y + dy), new Point(pt2.X + dx, pt2.Y + dy), line.IsStroked); //bs.Freeze(); pf.Segments.Add(bs); //pf.Freeze(); pg = new System.Windows.Media.PathGeometry(); pg.Figures.Add(pf); //pg.Freeze(); _curvedLineCache.Set(line, pg); } DrawPathGeometryInternal(dc, half, null, pen, line.IsStroked, false, pg); }
public void SetClip(IGraphicsPath path) { RewindTransform(); RewindClip(); path = path.Clone(); if (transforms != null && transforms.Current != null) { path.Transform(transforms.Current); } clipPath = path.ToWpf(); // require a clone so changes to path don't affect current clip clipBounds = clipPath.Bounds.ToEtoF(); ApplyClip(); ApplyTransform(); }
///<summary> /// Creates a <see cref="WpfGeometry"/> representing a <see cref="IGeometry"/>, according to the specified PointTransformation and PointShapeFactory (if relevant). ///</summary> public WpfGeometry ToShape(IGeometry geometry) { if (geometry.IsEmpty) { return(new WpfPathGeometry()); } var p = new WpfPathGeometry(); AddShape(p, geometry); p.Freeze(); return(p); }
/// <summary> /// 直接根据视图位置,绘制WPF封闭区域; /// </summary> /// <param name="screenPoints"></param> /// <param name="brush"></param> /// <param name="pen"></param> private void NativeDrawFill(IEnumerable <Point> screenPoints, SystemMedia.Brush brush, SystemMedia.Pen pen) { if (screenPoints == null) { throw new ArgumentNullException(nameof(screenPoints)); } if (pen == null) { throw new ArgumentNullException(nameof(pen)); } ValidateDrawingContext(); pen.Freeze(); //操作SystemMedia.PathGeometry中的Figures以绘制(封闭)区域 var paths = new SystemMedia.PathGeometry(); var pfc = new SystemMedia.PathFigureCollection(); var pf = new SystemMedia.PathFigure(); pfc.Add(pf); //存储一个点表示当前的PathFigure的StartPoint是否被指定; var startPointSet = false; foreach (var p in screenPoints) { //若StartPoint未被设定(第一个节点),设定后继续下一次循环; if (!startPointSet) { pf.StartPoint = p; startPointSet = true; continue; } //若若StartPoint被设定,则加入线段; var ps = new SystemMedia.LineSegment(); ps.Point = p; pf.Segments.Add(ps); } pf.IsClosed = true; paths.Figures = pfc; DrawingContext.DrawGeometry(brush, pen, paths); }
private void AddShape(WpfPathGeometry pathGeometry, IPolygon p) { AddShape(pathGeometry, p.Shell, true); var holes = p.Holes; if (holes == null) { return; } foreach (var hole in holes) { AddShape(pathGeometry, hole, true); } }
public static m.PathGeometry ScalingPathGeometry(m.PathGeometry toScale, double scaling, bool scaleAtZero = false) { toScale = toScale.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute); Point pointToScale = new Point(); if (scaleAtZero) { pointToScale = new Point(0, 0); } else { Rect rect = GetMinimalMaxRect(toScale, 0); pointToScale = rect.BottomLeft; } m.PathGeometry toReturn = new m.PathGeometry(); foreach (m.PathFigure olfPf in toScale.Figures) { m.PathFigure newPf = new m.PathFigure(); Point newStartPoint = olfPf.StartPoint; newStartPoint.X = (newStartPoint.X - pointToScale.X) * scaling + pointToScale.X; newStartPoint.Y = (newStartPoint.Y - pointToScale.Y) * scaling + pointToScale.Y; newPf.StartPoint = newStartPoint; foreach (m.PathSegment oldPs in olfPf.Segments) { m.PathSegment newPs = new m.PolyLineSegment(); foreach (Point point in ((m.PolyLineSegment)oldPs).Points) { Point tmp = point; tmp.X = (tmp.X - pointToScale.X) * scaling + pointToScale.X; tmp.Y = (tmp.Y - pointToScale.Y) * scaling + pointToScale.Y; ((m.PolyLineSegment)newPs).Points.Add(tmp); } newPf.Segments.Add(newPs); } toReturn.Figures.Add(newPf); } return(toReturn); }
public void SetClip(RectangleF rectangle) { RewindTransform(); RewindClip(); if (transforms != null && transforms.Current != null) { clipBounds = transforms.Current.TransformRectangle(rectangle); } else { clipBounds = rectangle; } clipPath = null; ApplyClip(); ApplyTransform(); }
public void DrawPath(System.Windows.Media.PathGeometry seriesData, System.Drawing.Pen gdiPen, System.Drawing.Brush gdiBrush) { foreach (PathFigure figure in seriesData.Figures) { var points = figure.Segments.Cast <LineSegment>().Select(s => s.Point.AsDrawingPoint()); var nextPoint = points.First(); foreach (var point in points) { var lastPoint = nextPoint; nextPoint = point; GDIGraphics.DrawLine(gdiPen, lastPoint, nextPoint); } } }