PathFigure CalculateArrow(PathFigure pathfig, Point pt1, Point pt2) { Matrix matx = new Matrix(); Vector vect = pt1 - pt2; vect.Normalize(); vect *= ArrowLength; PolyLineSegment polyseg = pathfig.Segments[0] as PolyLineSegment; polyseg.Points.Clear(); matx.Rotate(ArrowAngle / 2); //added code starts //places the position of the arrow on the midpoint pt2.X = (pt2.X + pt1.X) / 2; pt2.Y = (pt2.Y + pt1.Y) / 2; MiddlePoint = new Point(pt2.X + 5, pt2.Y); //added code ends pathfig.StartPoint = pt2 + vect * matx; polyseg.Points.Add(pt2); matx.Rotate(-ArrowAngle); polyseg.Points.Add(pt2 + vect * matx); pathfig.IsClosed = IsArrowClosed; return(pathfig); }
private static Geometry CreateUnitGeometry() { double x = 0.15; PathGeometry geometry = new PathGeometry(); PathFigure item = new PathFigure { IsClosed = true, StartPoint = new PointDouble(x, 0.0) }; PolyLineSegment segment = new PolyLineSegment { IsSmoothJoin = false }; segment.Points.Add(new PointDouble(0.5, 0.5 - x)); segment.Points.Add(new PointDouble(1.0 - x, 0.0)); segment.Points.Add(new PointDouble(1.0, x)); segment.Points.Add(new PointDouble(0.5 + x, 0.5)); segment.Points.Add(new PointDouble(1.0, 1.0 - x)); segment.Points.Add(new PointDouble(1.0 - x, 1.0)); segment.Points.Add(new PointDouble(0.5, 0.5 + x)); segment.Points.Add(new PointDouble(x, 1.0)); segment.Points.Add(new PointDouble(0.0, 1.0 - x)); segment.Points.Add(new PointDouble(0.5 - x, 0.5)); segment.Points.Add(new PointDouble(0.0, x)); segment.Points.Add(new PointDouble(x, 0.0)); item.Segments.Add(segment); geometry.Figures.Add(item); return(geometry); }
/// <summary> /// Altes original, sicherheitshalber noch behalten (zurzeit ungenutzt) /// </summary> /// <param name="allPointsContainer"></param> /// <returns></returns> private List <PolyLineSegment> OldPathGeometryToPlsList(PathGeometry allPointsContainer) { allPointsContainer = allPointsContainer.GetFlattenedPathGeometry(1.0, ToleranceType.Absolute); List <PolyLineSegment> allPolyLineSegments = new List <PolyLineSegment>(); allPointsContainer = allPointsContainer.GetFlattenedPathGeometry(1.0, ToleranceType.Absolute); foreach (PathFigure figures in allPointsContainer.Figures) { List <Point> allPoints = new List <Point>(); //allPoints.Add(figures.StartPoint); //isFirst = false; PolyLineSegment segment = (PolyLineSegment)figures.Segments[0]; allPoints.Add(segment.Points[0]); foreach (PathSegment segments in figures.Segments) { foreach (Point point in ((PolyLineSegment)segments).Points) { allPoints.Add(point); } } allPoints.Add(segment.Points[0]); // fügt startpunkt hinzu damit der kreis geschlossen ist allPolyLineSegments.Add(new PolyLineSegment(allPoints, true)); } return(allPolyLineSegments); }
/// <summary> /// Writes the specified ArcSegment to the content stream. /// </summary> internal void WriteSegment(ArcSegment seg) { if (!DevHelper.FlattenArcSegments) { int pieces; System.Windows.Media.PointCollection points = GeometryHelper.ArcToBezier(this.currentPoint.X, this.currentPoint.Y, seg.Size.Width, seg.Size.Height, seg.RotationAngle, seg.IsLargeArc, seg.SweepDirection == SweepDirection.Clockwise, seg.Point.X, seg.Point.Y, out pieces); if (pieces == 0) { // just draw single line WriteLiteral("{0:0.####} {1:0.####} l\n", seg.Point.X, seg.Point.Y); this.currentPoint = seg.Point; return; } else if (pieces < 0) { return; } int count = points.Count; Debug.Assert(count % 3 == 0); for (int idx = 0; idx < count - 2; idx += 3) { WriteLiteral("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n", points[idx].X, points[idx].Y, points[idx + 1].X, points[idx + 1].Y, points[idx + 2].X, points[idx + 2].Y); this.currentPoint = new Point(points[idx + 2].X, points[idx + 2].Y); } } else { PolyLineSegment lseg = WpfUtils.FlattenSegment(this.currentPoint, seg); WriteSegment(lseg); } }
/// <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(); }
/// <summary> /// If the path is a single line with different start and end caps, convert the line into an area. /// </summary> private bool WriteSingleLineStrokeWithSpecialCaps(Path path) { if (path.StrokeStartLineCap == path.StrokeEndLineCap && path.StrokeStartLineCap != LineCap.Triangle) { return(false); } if (path.Data.Figures.Count != 1) { return(false); } PathFigure figure = path.Data.Figures[0]; if (figure.Segments.Count != 1) { return(false); } PolyLineSegment polyLineSegment = figure.Segments[0] as PolyLineSegment; if (polyLineSegment.Points.Count != 1) { return(false); } // TODO: Create a new path that draws the line path.GetType(); return(false); }
/// <summary> /// Writes the specified PolyQuadraticBezierSegment to the content stream. /// </summary> internal void WriteSegment(PolyQuadraticBezierSegment seg) { if (!DevHelper.FlattenPolyQuadraticBezierSegment) { int count = seg.Points.Count; PointStopCollection points = seg.Points; Point pt0 = this.currentPoint; for (int idx = 0; idx < count - 1;) { Point pt1 = points[idx++]; Point pt2 = points[idx++]; // Cannot believe it: I just guessed the formula and it works! WriteLiteral("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n", pt1.X - (pt1.X - pt0.X) / 3, pt1.Y - (pt1.Y - pt0.Y) / 3, pt1.X + (pt2.X - pt1.X) / 3, pt1.Y + (pt2.Y - pt1.Y) / 3, pt2.X, pt2.Y); this.currentPoint = pt0 = pt2; } } else { PolyLineSegment lseg = WpfUtils.FlattenSegment(this.currentPoint, seg); WriteSegment(lseg); } }
public void Load(byte[] audioData, AudioFormat format) { this.ClearGraph(); this.format = format; this.audioData = audioData; var graph = new PolyLineSegment(); int step = this.GetSampleStep(); int index = 0; int count = 0; double yScale = (this.audioCanvas.Height / 2) / short.MaxValue; int leftSampleCount = audioData.Length / 4; //assume 2 channels int actualLeftSampleCount = leftSampleCount / (step / 4); while (index < audioData.Length) { short sample = BitConverter.ToInt16(new byte[2] { audioData[index], audioData[index + 1] }, 0); double yPoint = sample * yScale + (this.audioCanvas.Height / 2); double xPoint = count * this.audioCanvas.Width / actualLeftSampleCount; graph.Points.Add(new Point() { X = xPoint, Y = yPoint }); index += step; count++; } this.figure.Segments.Add(graph); }
private void draw_calibration() { Point[] currentWorkoutPoints = new Point[62]; currentWorkoutPoints[0] = new Point(0, 1); for (int i = 0; i < 30; i++) { currentWorkoutPoints[i * 2 + 1] = new Point((double)i / 30, 1 - speedData[i] / 30); currentWorkoutPoints[i * 2 + 2] = new Point((double)(i + 1) / 30, 1 - speedData[i] / 30); } currentWorkoutPoints[61] = new Point(1, 1); var figure = new PathFigure { StartPoint = currentWorkoutPoints[0], IsClosed = true }; var segment = new PolyLineSegment(currentWorkoutPoints.Skip(1), true); figure.Segments.Add(segment); polyline.Figures.Clear(); polyline.Figures.Add(figure); }
private void AddPolylineInternal(Point[] points, IFeature f, Brush fill, Brush stroke, double strokeWeight, bool addToFeatureList = true) { if (points.Length == 0) // newly 20131015 { return; } PathGeometry geometry = new PathGeometry(); PathFigure figure = new PathFigure { StartPoint = points.First() }; PolyLineSegment segment = new PolyLineSegment(points, true); figure.Segments.Add(segment); geometry.Figures.Add(figure); GeometryDrawing drawing = new GeometryDrawing(fill, new Pen(stroke, strokeWeight) { LineJoin = PenLineJoin.Bevel }, geometry); _drawingGroup.Children.Add(drawing); if (addToFeatureList) { Features.Add(f, drawing); } }
public static PathGeometry MakeLines(List <Point> allPoints) { PathGeometry myPathGeometry = new PathGeometry(); bool nextIsStartpoint = true; Point startPoint = new Point(); PathFigure pFigure = new PathFigure(); foreach (Point point in allPoints) { if (nextIsStartpoint) { startPoint = point; } else { //pFigure.Segments.Add(new LineSegment(point, true)); List <PathSegment> endPoint = new List <PathSegment>(); PolyLineSegment myPls = new PolyLineSegment(); myPls.Points.Add(point); endPoint.Add(myPls); myPathGeometry.Figures.Add(new PathFigure(startPoint, endPoint, false)); //line.Segments.RemoveAt(0); } nextIsStartpoint = !nextIsStartpoint; } return(myPathGeometry); }
protected override void ConnectFirstLastDataPoints() { IChartView view = this.model.GetChartArea().view; double scaleFactor = Math.Abs(view.ZoomWidth - view.ZoomHeight) / 2; PathFigure figure = null; PolyLineSegment lineSegment = null; foreach (Point point in SplineHelper.GetSplinePointsConnectingAbsoluteFirstLastDataPoints(this.renderPoints, scaleFactor)) { if (lineSegment == null) { figure = new PathFigure(); figure.StartPoint = point; lineSegment = new PolyLineSegment(); continue; } lineSegment.Points.Add(point); } if (lineSegment != null) { figure.Segments.Add(lineSegment); this.shapeGeometry.Figures.Add(figure); } }
private static Geometry Clip(Vector2 midpoint, Vector2 dir, Size size) { dir = (Vector2)((dir.Normalized * Math.Max(size.Width, size.Height)) * 2.0); Vector2 vector = new Vector2(-dir.Y, dir.X); PathGeometry geometry = new PathGeometry(); PathFigureCollection figures = new PathFigureCollection(); PathFigure figure = new PathFigure(); figure.IsClosed = (true); figure.StartPoint = ((Point)midpoint); PathSegmentCollection segments = new PathSegmentCollection(); PolyLineSegment segment = new PolyLineSegment(); PointCollection points = new PointCollection(); points.Add((Point)(midpoint + vector)); points.Add((Point)((midpoint + vector) + dir)); points.Add((Point)((midpoint - vector) + dir)); points.Add((Point)(midpoint - vector)); segment.Points = (points); segments.Add(segment); figure.Segments = (segments); figures.Add(figure); geometry.Figures = (figures); return(geometry); }
protected override void UpdateData() { var geometry = (PathGeometry)Data; geometry.Figures.Clear(); if (ParentMap != null && Locations != null && Locations.Any()) { var points = Locations.Select(l => ParentMap.MapTransform.Transform(l)); var figure = new PathFigure { StartPoint = points.First(), IsClosed = IsClosed, IsFilled = IsClosed }; var segment = new PolyLineSegment(); foreach (var point in points.Skip(1)) { segment.Points.Add(point); } figure.Segments.Add(segment); geometry.Figures.Add(figure); geometry.Transform = ParentMap.ViewportTransform; } else { geometry.ClearValue(Geometry.TransformProperty); } }
public static PathFigure DrawArrowHead(Point startPoint, Point endPoint, double arrowLength = 10) { PathFigure pathFigure = new PathFigure() { StartPoint = endPoint, }; double cos30 = 0.866; double sin30 = 0.5; double w = arrowLength * cos30; double h = arrowLength * sin30; double d = Utility.DrawingAids.Distance(startPoint, endPoint); double Xn = (endPoint.X - startPoint.X) / d; double Yn = (endPoint.Y - startPoint.Y) / d; double X3 = endPoint.X - w * Xn - h * Yn; double Y3 = endPoint.Y - w * Yn + h * Xn; double X4 = endPoint.X - w * Xn + h * Yn; double Y4 = endPoint.Y - w * Yn - h * Xn; PolyLineSegment segment = new PolyLineSegment(); pathFigure.Segments.Add(segment); segment.Points.Add(new Point(X3, Y3)); segment.Points.Add(endPoint); segment.Points.Add(new Point(X4, Y4)); segment.Points.Add(endPoint); return(pathFigure); }
private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { PointListPair plp = (PointListPair)e.UserState; List <Point> points1 = plp.points1; List <Point> points2 = plp.points2; GeometryGroup geomGroup = new GeometryGroup(); Point startPoint1 = points1[0]; points1.RemoveAt(0); PolyLineSegment polyLnSeg1 = new PolyLineSegment(points1, true); PathFigure pathFig1 = new PathFigure(startPoint1, new PathSegment[] { polyLnSeg1 }, false); PathGeometry pathGeom1 = new PathGeometry(new PathFigure[] { pathFig1 }); geomGroup.Children.Add(pathGeom1); if (points2 != null && points2.Count > 1) { Point startPoint2 = points2[0]; points2.RemoveAt(0); PolyLineSegment polyLnSeg2 = new PolyLineSegment(points2, true); PathFigure pathFig2 = new PathFigure(startPoint2, new PathSegment[] { polyLnSeg2 }, false); PathGeometry pathGeom2 = new PathGeometry(new PathFigure[] { pathFig2 }); geomGroup.Children.Add(pathGeom2); } GeometryDrawing geomDrawing = new GeometryDrawing(null, OscilloscopePen, geomGroup); host.DrawDrawing(geomDrawing); }
private void DrawPass() { bezie = new PolyLineSegment(); if (start == finish) { return; } List <Station> currentLine = map[start.Line]; int GoFrom, GoTo; if (start.Line == finish.Line) { GoFrom = currentLine.IndexOf(start); GoTo = currentLine.IndexOf(finish); MoveByLine(currentLine, GoFrom, GoTo, bezie); } else { string passLine = start.Line + '_' + finish.Line; string point = passStations.Find(s => s.Line == passLine).Name; //Name of passage station in starting Line GoFrom = currentLine.IndexOf(start); GoTo = currentLine.FindIndex(s => s.Name == point); MoveByLine(currentLine, GoFrom, GoTo, bezie); currentLine = map[finish.Line]; passLine = finish.Line + '_' + start.Line; point = passStations.Find(s => s.Line == passLine).Name; GoFrom = currentLine.FindIndex(s => s.Name == point); GoTo = currentLine.IndexOf(finish); MoveByLine(currentLine, GoFrom, GoTo, bezie); } }
/// <summary> /// Creates the geometry for the path from the given GeneralPath. /// </summary> private Geometry CreateGeometry(GeneralPath gp) { PolyLineSegment pl = new PolyLineSegment(); PathFigure figure = new PathFigure { Segments = { pl } }; // create path if (gp != null) { var cursor = gp.CreateCursor(); if (cursor.MoveNext()) { figure.StartPoint = cursor.CurrentEndPoint; } // loop all bends of the edge while (cursor.MoveNext()) { pl.Points.Add(cursor.CurrentEndPoint); } } return(new PathGeometry { Figures = { figure } }); }
/// <summary> /// Creates a brush to paint half-filled mod annotations, to denote mod localization ambiguity /// </summary> private static TileBrush GetPatternedTileBrush(SolidColorBrush brushColor) { PolyLineSegment triangleLinesSegment = new PolyLineSegment(); triangleLinesSegment.Points.Add(new Point(50, 0)); triangleLinesSegment.Points.Add(new Point(0, 50)); PathFigure triangleFigure = new PathFigure(); triangleFigure.IsClosed = true; triangleFigure.StartPoint = new Point(0, 0); triangleFigure.Segments.Add(triangleLinesSegment); PathGeometry triangleGeometry = new PathGeometry(); triangleGeometry.Figures.Add(triangleFigure); GeometryDrawing triangleDrawing = new GeometryDrawing(); triangleDrawing.Geometry = triangleGeometry; triangleDrawing.Brush = brushColor; Pen trianglePen = new Pen(Brushes.Black, 2); triangleDrawing.Pen = trianglePen; trianglePen.MiterLimit = 0; triangleDrawing.Freeze(); DrawingBrush tileBrushWithTiling = new DrawingBrush(); tileBrushWithTiling.Drawing = triangleDrawing; tileBrushWithTiling.TileMode = TileMode.None; //tileBrushWithTiling.Viewport = new Rect(0, 0, 0.5, 0.5); return(tileBrushWithTiling); }
public Visual Draw(Curve item, Axis xAxis, Axis yAxis, string side) { var dv = new DrawingVisual(); var dc = dv.RenderOpen(); var pointXs = xAxis.Map(item.F); var pointYs = yAxis.Map(item.V); var pathFigure = new PathFigure { StartPoint = new Point(pointXs[0], pointYs[0]), IsClosed = false, IsFilled = false }; var polyLine = new PolyLineSegment(); for (int i = 0; i < pointXs.Length; i++) { polyLine.Points.Add(new Point(pointXs[i], pointYs[i])); } pathFigure.Segments.Add(polyLine); var pathGeometry = new PathGeometry(); pathGeometry.Figures.Add(pathFigure); var brush = this.resourceProvider.GetCurveBrush(item, side); var thickness = this.resourceProvider.GetCurveThickness(item, side); dc.DrawGeometry(brush, new Pen(brush, thickness), pathGeometry); dc.Close(); return(dv); }
private DrawingVisual Create() { countCreate++; var square = new DrawingVisualFx(); using (DrawingContext dc = square.RenderOpen()) { dc.DrawEllipse(null, Stroke, new Point(Width / 2, Height / 2), Width / 2 + Stroke.Thickness / 2, Height / 2 + Stroke.Thickness / 2); if (Angle.HasValue) { dc.PushTransform(new RotateTransform(Angle.Value, Width / 2, Height / 2)); { PolyLineSegment polySeg = new PolyLineSegment(new Point[] { new Point(Width * 0.2, Height * 0.3), new Point(Width * 0.8, Height * 0.3) }, true); PathFigure pathFig = new PathFigure(new Point(Width * 0.5, -Height * 0.22), new PathSegment[] { polySeg }, true); PathGeometry pathGeo = new PathGeometry(new PathFigure[] { pathFig }); dc.DrawGeometry(Brushes.AliceBlue, StrokeArrow, pathGeo); } dc.Pop(); } dc.DrawEllipse(Background, null, new Point(Width / 2, Height / 2), Width / 2, Height / 2); dc.DrawText(FText, new Point(Width / 2 - FText.Width / 2, Height / 2 - FText.Height / 2)); } return(square); }
private void CreateProgressIndicator() { if (progressCanvas == null) { return; } const double xLocation = 0.0d; progressLine.X1 = xLocation; progressLine.X2 = xLocation; progressLine.Y1 = timelineCanvas.RenderSize.Height; progressLine.Y2 = progressCanvas.RenderSize.Height; PolyLineSegment indicatorPolySegment = new PolyLineSegment(); indicatorPolySegment.Points.Add(new Point(xLocation, timelineCanvas.RenderSize.Height)); indicatorPolySegment.Points.Add(new Point(xLocation - indicatorTriangleWidth, timelineCanvas.RenderSize.Height - indicatorTriangleWidth)); indicatorPolySegment.Points.Add(new Point(xLocation + indicatorTriangleWidth, timelineCanvas.RenderSize.Height - indicatorTriangleWidth)); indicatorPolySegment.Points.Add(new Point(xLocation, timelineCanvas.RenderSize.Height)); PathGeometry indicatorGeometry = new PathGeometry(); PathFigure indicatorFigure = new PathFigure(); indicatorFigure.Segments.Add(indicatorPolySegment); indicatorGeometry.Figures.Add(indicatorFigure); progressIndicator.Data = indicatorGeometry; UpdateProgressIndicator(); }
/// <summary> /// Creates List of geometries for underline /// </summary> /// <returns>List of Geometries</returns> public Geometry BottomEdgeRectangleGeometry() { PathGeometry pg = (PathGeometry)mOrginalGeometry; GeometryGroup gg = new GeometryGroup(); foreach (PathFigure fg in pg.Figures) { PolyLineSegment pls = (PolyLineSegment)fg.Segments[0]; PointCollectionHelper pch = new PointCollectionHelper(pls.Points, fg.StartPoint); List <double> distinctY = pch.DistinctY; for (int i = 0; i < distinctY.Count - 1; i++) { double bottom = distinctY[i + 1] - 3; double top = bottom + 2; // ordered values of X that are present for both Y values List <double> rlMatches = pch.XAtY(distinctY[i], distinctY[i + 1]); double left = rlMatches[0]; double right = rlMatches[rlMatches.Count - 1]; PathGeometry rpg = CreateGeometry(top, bottom, left, right); gg.Children.Add(rpg); } } return(gg); }
private void ReadLines(string pathAsString, ref int currentIndex, ref Point lastAbsolutePosition, PathFigure currentFigure, bool relative) { PointCollection points = new PointCollection(); while (true) { while (currentIndex < pathAsString.Length && pathAsString[currentIndex] == ' ') { ++currentIndex; } if (currentIndex < pathAsString.Length && !_commandCharacters.Contains(pathAsString[currentIndex])) { Point point = GetPoint(pathAsString, currentIndex, out currentIndex); if (relative) { point.X = point.X + lastAbsolutePosition.X; point.Y = point.Y + lastAbsolutePosition.Y; } points.Add(point); lastAbsolutePosition.X = point.X; lastAbsolutePosition.Y = point.Y; } else { break; } } if (points.Count > 0) { PolyLineSegment polyLineSegment = new PolyLineSegment(); polyLineSegment.Points = new PointCollection(); polyLineSegment.Points = points; currentFigure.Segments.Add(polyLineSegment); } }
protected override void UpdateData() { var geometry = (PathGeometry)Data; geometry.Figures.Clear(); if (ParentMap != null && Locations != null && Locations.Any()) { var points = Locations.Select(l => ParentMap.MapProjection.LocationToPoint(l)); var figure = new PathFigure { StartPoint = points.First(), IsClosed = IsClosed, IsFilled = IsClosed }; var segment = new PolyLineSegment(); foreach (var point in points.Skip(1)) { segment.Points.Add(point); } figure.Segments.Add(segment); geometry.Figures.Add(figure); } }
private static void ProcessFigure(List <Point> points, GeneralTransform transform, PathGeometry geometry) { if (points.Count == 0) { return; } var result = new PolyLineSegment(); var prev = points[0]; for (int i = 1; i < points.Count; ++i) { var current = points[i]; if (current == prev) { continue; } result.Points.Add(transform.Transform(current)); prev = current; } if (result.Points.Count == 0) { return; } geometry.Figures.Add(new PathFigure(transform.Transform(points[0]), new PathSegment[] { result }, true)); }
public Star() { pg = new PathGeometry(); pf = new PathFigure(); pls = new PolyLineSegment(); pg.Figures.Add(pf); }
private static List <Point> GetOrdinateOnPathFigureByAbscissa(PathFigure figure, double abscissa) { List <Point> outputPoints = new List <Point>(); Point current = figure.StartPoint; foreach (PathSegment s in figure.Segments) { PolyLineSegment segment = s as PolyLineSegment; LineSegment line = s as LineSegment; Point[] points; if (segment != null) { points = segment.Points.ToArray(); } else if (line != null) { points = new[] { line.Point }; } else { throw new InvalidOperationException(); } foreach (Point next in points) { if (TryGetOrdinateOnVectorByAbscissa(current, next, abscissa, out double ordinate)) { outputPoints.Add(new Point(abscissa, ordinate)); } current = next; } } return(outputPoints); }
private static Tuple <Point, double> GetClosestPointOnPathFigure(PathFigure figure, Point p) { List <Tuple <Point, double> > closePoints = new List <Tuple <Point, double> >(); Point current = figure.StartPoint; foreach (PathSegment s in figure.Segments) { PolyLineSegment segment = s as PolyLineSegment; LineSegment line = s as LineSegment; Point[] points; if (segment != null) { points = segment.Points.ToArray(); } else if (line != null) { points = new[] { line.Point }; } else { throw new InvalidOperationException(); } foreach (Point next in points) { Point closestPoint = GetClosestPointOnLine(current, next, p); double d = (closestPoint - p).LengthSquared; closePoints.Add(new Tuple <Point, double>(closestPoint, d)); current = next; } } return(closePoints.OrderBy(t => t.Item2).First()); }
protected virtual void DrawLine(Canvas canvas) { Path path = new Path(); path.Style = this.PathStyle; PolyLineSegment pls = new PolyLineSegment(); for (int i = 0; i < this.xAxis.Count; i++) { double x = this.xAxis[i]; double y = this.Data[i]; y = this.GetMapY(i, y); // Do :添加曲线 pls.Points.Add(new Point(this.GetX(x), this.GetY(y))); } PathFigure pf = new PathFigure(); pf.StartPoint = pls.Points.FirstOrDefault(); pf.Segments.Add(pls); PathGeometry pg = new PathGeometry(new List <PathFigure>() { pf }); path.Data = pg; this.Children.Add(path); }
/// <summary> /// Converts a PolyQuadraticBezierSegment into a PolyLineSegment because I currently have no muse to calculate /// the correct Bézier curves. /// </summary> public static PolyLineSegment FlattenSegment( Point startPoint, PolyQuadraticBezierSegment seg) { var geo = new PathGeometry(); var fig = new PathFigure(); geo.Figures.Add(fig); fig.StartPoint = new Point(startPoint.X, startPoint.Y); int count = seg.Points.Count; var points = new Point[count]; for (int idx = 0; idx < count - 1; idx += 2) { var qbseg = new QuadraticBezierSegment( new Point(seg.Points[idx].X, seg.Points[idx].Y), new Point(seg.Points[idx + 1].X, seg.Points[idx + 1].Y), seg.IsStroked); fig.Segments.Add(qbseg); } geo = geo.GetFlattenedPathGeometry(); fig = geo.Figures[0]; var lineSeg = (PolyLineSegment)fig.Segments[0]; var resultSeg = new PolyLineSegment(); foreach (var point in lineSeg.Points) { resultSeg.Points.Add(new Point(point.X, point.Y)); } return(resultSeg); }
/// <summary> /// Generate PathGeometry object with curved Path using supplied route points /// </summary> /// <param name="points">Route points</param> /// <param name="tension"></param> /// <param name="tolerance"></param> /// <returns></returns> public static PolyLineSegment GetCurveThroughPoints(Point[] points, Double tension, Double tolerance) { Debug.Assert(points != null); Debug.Assert(points.Length >= 2); Debug.Assert(tolerance > 0); var oPolyLineSegment = new PolyLineSegment(); if (points.Length == 2) { AddPointsToPolyLineSegment(oPolyLineSegment, points[0], points[0], points[1], points[1], tension, tolerance); } else { var iPoints = points.Length; for (var i = 0; i < iPoints; i++) { if (i == 0) { AddPointsToPolyLineSegment(oPolyLineSegment, points[0], points[0], points[1], points[2], tension, tolerance); } else if (i == iPoints - 2) { AddPointsToPolyLineSegment(oPolyLineSegment, points[i - 1], points[i], points[i + 1], points[i + 1], tension, tolerance); } else if (i != iPoints - 1) { AddPointsToPolyLineSegment(oPolyLineSegment, points[i - 1], points[i], points[i + 1], points[i + 2], tension, tolerance); } } oPolyLineSegment.Points.Insert(0, points[0]); } return oPolyLineSegment; }
protected override void UpdateData() { var geometry = (PathGeometry)Data; var locations = Locations; Location first; if (ParentMap != null && locations != null && (first = locations.FirstOrDefault()) != null) { var figure = new PathFigure { StartPoint = ParentMap.MapTransform.Transform(first), IsClosed = IsClosed, IsFilled = IsClosed }; var segment = new PolyLineSegment(); foreach (var location in locations.Skip(1)) { segment.Points.Add(ParentMap.MapTransform.Transform(location)); } if (segment.Points.Count > 0) { figure.Segments.Add(segment); } geometry.Figures.Clear(); geometry.Figures.Add(figure); geometry.Transform = ParentMap.ViewportTransform; } else { geometry.Figures.Clear(); geometry.ClearValue(Geometry.TransformProperty); } }
/// <summary> /// Adds a polygon to this path. /// </summary> public void AddPolygon(XPoint[] points) { #if CORE int count = points.Length; if (count == 0) return; _corePath.MoveTo(points[0].X, points[0].Y); for (int idx = 0; idx < count - 1; idx++) _corePath.LineTo(points[idx].X, points[idx].Y, false); _corePath.LineTo(points[count - 1].X, points[count - 1].Y, true); _corePath.CloseSubpath(); #endif #if GDI try { Lock.EnterGdiPlus(); _gdipPath.AddPolygon(XGraphics.MakePointFArray(points)); } finally { Lock.ExitGdiPlus(); } #endif #if WPF || NETFX_CORE #if !SILVERLIGHT && !NETFX_CORE _pathGeometry.AddGeometry(GeometryHelper.CreatePolygonGeometry(XGraphics.MakePointArray(points), XFillMode.Alternate, true)); #else var figure = new PathFigure(); figure.StartPoint = new SysPoint(points[0].X, points[0].Y); figure.IsClosed = true; PolyLineSegment segment = new PolyLineSegment(); int count = points.Length; // For correct drawing the start point of the segment must not be the same as the first point. for (int idx = 1; idx < count; idx++) segment.Points.Add(new SysPoint(points[idx].X, points[idx].Y)); #if !SILVERLIGHT && !NETFX_CORE seg.IsStroked = true; #endif figure.Segments.Add(segment); _pathGeometry.Figures.Add(figure); #endif // TODO: NOT NEEDED //CloseFigure(); // StartFigure() isn't needed because AddGeometry() implicitly starts a new figure, but CloseFigure() is needed for the next adding not to continue this figure. #endif }
/// <summary> /// Returns new PolyLineSegment by easing startValue to endValue using a time percentage 0 -> 1. /// </summary> /// <example>XAML: Points="50,100 50,150"</example> /// <seealso cref="http://msdn.microsoft.com/en-us/library/system.windows.media.polylinesegment.aspx"/> public static PolyLineSegment EaseValue(PolyLineSegment startValue, PolyLineSegment endValue, double percent) { return new PolyLineSegment { Points = EaseValue(startValue.Points, endValue.Points, percent), }; }
/// <summary> /// Creates a path geometry from a polygon. /// </summary> public static PathGeometry CreatePolygonGeometry(SysPoint[] points, XFillMode fillMode, bool closed) { PolyLineSegment seg = new PolyLineSegment(); int count = points.Length; // For correct drawing the start point of the segment must not be the same as the first point. for (int idx = 1; idx < count; idx++) seg.Points.Add(new SysPoint(points[idx].X, points[idx].Y)); #if !SILVERLIGHT && !NETFX_CORE seg.IsStroked = true; #endif PathFigure fig = new PathFigure(); fig.StartPoint = new SysPoint(points[0].X, points[0].Y); fig.Segments.Add(seg); fig.IsClosed = closed; PathGeometry geo = new PathGeometry(); geo.FillRule = fillMode == XFillMode.Winding ? FillRule.Nonzero : FillRule.EvenOdd; geo.Figures.Add(fig); return geo; }
/// <summary> /// Creates a path geometry from a polygon. /// </summary> public static PolyLineSegment CreatePolyLineSegment(SysPoint[] points, XFillMode fillMode, bool closed) { PolyLineSegment seg = new PolyLineSegment(); int count = points.Length; // For correct drawing the start point of the segment must not be the same as the first point. for (int idx = 1; idx < count; idx++) seg.Points.Add(new SysPoint(points[idx].X, points[idx].Y)); #if !SILVERLIGHT && !NETFX_CORE seg.IsStroked = true; #endif return seg; }
private static void AddPointsToPolyLineSegment(PolyLineSegment oPolyLineSegment, Point oPoint0, Point oPoint1, Point oPoint2, Point oPoint3, Double dTension, Double dTolerance) { Debug.Assert(oPolyLineSegment != null); Debug.Assert(dTolerance > 0); var iPoints = (Int32)((Math.Abs(oPoint1.X - oPoint2.X) + Math.Abs(oPoint1.Y - oPoint2.Y)) / dTolerance); var oPolyLineSegmentPoints = oPolyLineSegment.Points; if (iPoints <= 2) { oPolyLineSegmentPoints.Add(oPoint2); } else { var dSx1 = dTension * (oPoint2.X - oPoint0.X); var dSy1 = dTension * (oPoint2.Y - oPoint0.Y); var dSx2 = dTension * (oPoint3.X - oPoint1.X); var dSy2 = dTension * (oPoint3.Y - oPoint1.Y); var dAx = dSx1 + dSx2 + 2 * oPoint1.X - 2 * oPoint2.X; var dAy = dSy1 + dSy2 + 2 * oPoint1.Y - 2 * oPoint2.Y; var dBx = -2 * dSx1 - dSx2 - 3 * oPoint1.X + 3 * oPoint2.X; var dBy = -2 * dSy1 - dSy2 - 3 * oPoint1.Y + 3 * oPoint2.Y; var dCx = dSx1; var dCy = dSy1; var dDx = oPoint1.X; var dDy = oPoint1.Y; // Note that this starts at 1, not 0. for (var i = 1; i < iPoints; i++) { var t = (Double)i / (iPoints - 1); var oPoint = new Point( dAx * t * t * t + dBx * t * t + dCx * t + dDx, dAy * t * t * t + dBy * t * t + dCy * t + dDy ); oPolyLineSegmentPoints.Add(oPoint); } } }
public PathGeometry CloneDeep(PathGeometry pathGeometry) { var newPathGeometry = new PathGeometry(); foreach (var figure in pathGeometry.Figures) { var newFigure = new PathFigure(); newFigure.StartPoint = figure.StartPoint; // Even figures have to be deep cloned. Assigning them directly will result in // an InvalidOperationException being thrown with the message "Element is already the child of another element." foreach (var segment in figure.Segments) { // I only impemented cloning the abstract PathSegments to one implementation, // the PolyLineSegment class. If your paths use other kinds of segments, you'll need // to implement that kind of coding yourself. var segmentAsPolyLineSegment = segment as PolyLineSegment; if (segmentAsPolyLineSegment != null) { var newSegment = new PolyLineSegment(); foreach (var point in segmentAsPolyLineSegment.Points) { newSegment.Points.Add(point); } newFigure.Segments.Add(newSegment); } var segmentAsLineSegment = segment as LineSegment; if (segmentAsLineSegment != null) { var newSegment = new LineSegment(); newSegment.Point = segmentAsLineSegment.Point; newFigure.Segments.Add(newSegment); } var segmentAsArcSegment = segment as ArcSegment; if (segmentAsArcSegment != null) { var newSegment = new ArcSegment(); newSegment.Point = segmentAsArcSegment.Point; newSegment.SweepDirection = segmentAsArcSegment.SweepDirection; newSegment.RotationAngle = segmentAsArcSegment.RotationAngle; newSegment.IsLargeArc = segmentAsArcSegment.IsLargeArc; newSegment.Size = segmentAsArcSegment.Size; newFigure.Segments.Add(newSegment); } } newPathGeometry.Figures.Add(newFigure); } return newPathGeometry; }