/// <summary> /// Draws a collection of rectangles, where all have the same stroke and fill. /// This performs better than calling DrawRectangle multiple times. /// </summary> /// <param name="rectangles">The rectangles.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> public void DrawRectangles(IList <OxyRect> rectangles, OxyColor fill, OxyColor stroke, double thickness) { var path = new Path { CompositeMode = ElementCompositeMode.SourceOver }; this.SetStroke(path, stroke, thickness); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var gg = new GeometryGroup { FillRule = FillRule.Nonzero }; foreach (var rect in rectangles) { gg.Children.Add(new RectangleGeometry { Rect = rect.ToRect(true) }); } path.Data = gg; this.Add(path); }
/// <summary> /// Draws the collection of ellipses, where all have the same stroke and fill. /// This performs better than calling DrawEllipse multiple times. /// </summary> /// <param name="rectangles">The rectangles.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> public void DrawEllipses(IList <OxyRect> rectangles, OxyColor fill, OxyColor stroke, double thickness) { var path = new Path { CompositeMode = ElementCompositeMode.SourceOver }; this.SetStroke(path, stroke, thickness); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var gg = new GeometryGroup { FillRule = FillRule.Nonzero }; foreach (var rect in rectangles) { gg.Children.Add( new EllipseGeometry { Center = new Point(rect.Left + (rect.Width / 2), rect.Top + (rect.Height / 2)), RadiusX = rect.Width / 2, RadiusY = rect.Height / 2 }); } path.Data = gg; this.Add(path); }
/// <summary> /// Draws a collection of polygons, where all polygons have the same stroke and fill. /// This performs better than calling DrawPolygon multiple times. /// </summary> /// <param name="polygons">The polygons.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashArray">The dash array.</param> /// <param name="lineJoin">The line join type.</param> /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param> public void DrawPolygons( IList <IList <ScreenPoint> > polygons, OxyColor fill, OxyColor stroke, double thickness, double[] dashArray, LineJoin lineJoin, bool aliased) { var path = new Path { CompositeMode = ElementCompositeMode.SourceOver }; this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var pg = new PathGeometry { FillRule = FillRule.Nonzero }; foreach (var polygon in polygons) { var figure = new PathFigure { IsClosed = true }; bool first = true; foreach (var p in polygon) { if (first) { figure.StartPoint = p.ToPoint(aliased); first = false; } else { figure.Segments.Add(new LineSegment { Point = p.ToPoint(aliased) }); } } pg.Figures.Add(figure); } path.Data = pg; this.Add(path); }
/// <summary> /// Draws the multiple line segments defined by points (0,1) (2,3) (4,5) etc. /// This should have better performance than calling DrawLine for each segment. /// </summary> /// <param name="points">The points.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashArray">The dash array.</param> /// <param name="lineJoin">The line join type.</param> /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param> public void DrawLineSegments( IList <ScreenPoint> points, OxyColor stroke, double thickness, double[] dashArray, LineJoin lineJoin, bool aliased) { var path = new Path { CompositeMode = ElementCompositeMode.SourceOver }; this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased); var pg = new PathGeometry(); for (int i = 0; i + 1 < points.Count; i += 2) { // if (points[i].Y==points[i+1].Y) // { // var line = new Line(); // line.X1 = 0.5+(int)points[i].X; // line.X2 = 0.5+(int)points[i+1].X; // line.Y1 = 0.5+(int)points[i].Y; // line.Y2 = 0.5+(int)points[i+1].Y; // SetStroke(line, OxyColors.DarkRed, thickness, lineJoin, dashArray, aliased); // Add(line); // continue; // } var figure = new PathFigure { StartPoint = points[i].ToPoint(aliased), IsClosed = false }; figure.Segments.Add(new LineSegment { Point = points[i + 1].ToPoint(aliased) }); pg.Figures.Add(figure); } path.Data = pg; this.Add(path); }
/// <summary> /// Draws a collection of rectangles, where all have the same stroke and fill. /// This performs better than calling DrawRectangle multiple times. /// </summary> /// <param name="rectangles">The rectangles.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> public void DrawRectangles(IList<OxyRect> rectangles, OxyColor fill, OxyColor stroke, double thickness) { var path = new Path(); this.SetStroke(path, stroke, thickness); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var gg = new GeometryGroup { FillRule = FillRule.Nonzero }; foreach (var rect in rectangles) { gg.Children.Add(new RectangleGeometry { Rect = rect.ToRect(true) }); } path.Data = gg; this.Add(path); }
/// <summary> /// Draws a collection of polygons, where all polygons have the same stroke and fill. /// This performs better than calling DrawPolygon multiple times. /// </summary> /// <param name="polygons">The polygons.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashArray">The dash array.</param> /// <param name="lineJoin">The line join type.</param> /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param> public void DrawPolygons( IList<IList<ScreenPoint>> polygons, OxyColor fill, OxyColor stroke, double thickness, double[] dashArray, LineJoin lineJoin, bool aliased) { var path = new Path(); this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var pg = new PathGeometry { FillRule = FillRule.Nonzero }; foreach (var polygon in polygons) { var figure = new PathFigure { IsClosed = true }; bool first = true; foreach (var p in polygon) { if (first) { figure.StartPoint = p.ToPoint(aliased); first = false; } else { figure.Segments.Add(new LineSegment { Point = p.ToPoint(aliased) }); } } pg.Figures.Add(figure); } path.Data = pg; this.Add(path); }
/// <summary> /// Draws the multiple line segments defined by points (0,1) (2,3) (4,5) etc. /// This should have better performance than calling DrawLine for each segment. /// </summary> /// <param name="points">The points.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashArray">The dash array.</param> /// <param name="lineJoin">The line join type.</param> /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param> public void DrawLineSegments( IList<ScreenPoint> points, OxyColor stroke, double thickness, double[] dashArray, LineJoin lineJoin, bool aliased) { var path = new Path(); this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased); var pg = new PathGeometry(); for (int i = 0; i + 1 < points.Count; i += 2) { // if (points[i].Y==points[i+1].Y) // { // var line = new Line(); // line.X1 = 0.5+(int)points[i].X; // line.X2 = 0.5+(int)points[i+1].X; // line.Y1 = 0.5+(int)points[i].Y; // line.Y2 = 0.5+(int)points[i+1].Y; // SetStroke(line, OxyColors.DarkRed, thickness, lineJoin, dashArray, aliased); // Add(line); // continue; // } var figure = new PathFigure { StartPoint = points[i].ToPoint(aliased), IsClosed = false }; figure.Segments.Add(new LineSegment { Point = points[i + 1].ToPoint(aliased) }); pg.Figures.Add(figure); } path.Data = pg; this.Add(path); }
/// <summary> /// Draws the collection of ellipses, where all have the same stroke and fill. /// This performs better than calling DrawEllipse multiple times. /// </summary> /// <param name="rectangles">The rectangles.</param> /// <param name="fill">The fill color.</param> /// <param name="stroke">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> public void DrawEllipses(IList<OxyRect> rectangles, OxyColor fill, OxyColor stroke, double thickness) { var path = new Path(); this.SetStroke(path, stroke, thickness); if (fill.IsVisible()) { path.Fill = this.GetCachedBrush(fill); } var gg = new GeometryGroup { FillRule = FillRule.Nonzero }; foreach (var rect in rectangles) { gg.Children.Add( new EllipseGeometry { Center = new Point(rect.Left + (rect.Width / 2), rect.Top + (rect.Height / 2)), RadiusX = rect.Width / 2, RadiusY = rect.Height / 2 }); } path.Data = gg; this.Add(path); }