public virtual void NextSubpath_Int_Int_Bool() { GraphicsPath path = new GraphicsPath (); path.AddLine (new Point (100, 100), new Point (400, 100)); path.AddLine (new Point (400, 200), new Point (10, 100)); path.StartFigure (); path.SetMarkers (); path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280); path.CloseFigure (); path.StartFigure (); path.SetMarkers (); path.AddRectangle (new Rectangle (10, 20, 300, 400)); path.StartFigure (); path.SetMarkers (); path.AddLine (new Point (400, 400), new Point (400, 10)); GraphicsPathIterator iterator = new GraphicsPathIterator (path); int start; int end; bool isClosed; int count = iterator.NextSubpath (out start, out end, out isClosed); Assert.AreEqual (4, count); Assert.AreEqual (0, start); Assert.AreEqual (3, end); Assert.IsFalse (isClosed); count = iterator.NextSubpath (out start, out end, out isClosed); Assert.AreEqual (4, count); Assert.AreEqual (4, start); Assert.AreEqual (7, end); Assert.IsTrue (isClosed); count = iterator.NextSubpath (out start, out end, out isClosed); Assert.AreEqual (4, count); Assert.AreEqual (8, start); Assert.AreEqual (11, end); Assert.IsTrue (isClosed); count = iterator.NextSubpath (out start, out end, out isClosed); Assert.AreEqual (2, count); Assert.AreEqual (12, start); Assert.AreEqual (13, end); Assert.IsFalse (isClosed); count = iterator.NextSubpath (out start, out end, out isClosed); Assert.AreEqual (0, count); Assert.AreEqual (0, start); Assert.AreEqual (0, end); Assert.IsTrue (isClosed); }
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 void NextSubpath_Null () { using (GraphicsPath gp = new GraphicsPath ()) { gp.AddLines (pts_2f); using (GraphicsPathIterator gpi = new GraphicsPathIterator (gp)) { bool closed; Assert.AreEqual (0, gpi.NextSubpath (null, out closed)); Assert.IsTrue (closed, "Closed"); } } }
public void PathIterator7(Graphics g) { // Create a graphics path. GraphicsPath myPath = new GraphicsPath(); // Set up primitives to add to myPath. Point[] myPoints = {new Point(20, 20), new Point(120, 120), new Point(20, 120),new Point(20, 20) }; Rectangle myRect = new Rectangle(120, 120, 100, 100); // Add 3 lines, a rectangle, an ellipse, and 2 markers. myPath.AddLines(myPoints); myPath.SetMarkers(); myPath.AddRectangle(myRect); myPath.SetMarkers(); myPath.AddEllipse(220, 220, 100, 100); // Get the total number of points for the path, // and the arrays of the points and types. int myPathPointCount = myPath.PointCount; PointF[] myPathPoints = myPath.PathPoints; byte[] myPathTypes = myPath.PathTypes; // Set up variables for listing all of the path's // points to the screen. int i; float j = 20; Font myFont = new Font("Arial", 8); SolidBrush myBrush = new SolidBrush(Color.Black); // List the values of all the path points and types to the screen. for(i=0; i<myPathPointCount; i++) { g.DrawString(myPathPoints[i].X.ToString()+ ", " + myPathPoints[i].Y.ToString() + ", " + myPathTypes[i].ToString(), myFont, myBrush, 20, j); j+=20; } // Create a GraphicsPathIterator for myPath. GraphicsPathIterator myPathIterator = new GraphicsPathIterator(myPath); // Rewind the iterator. myPathIterator.Rewind(); // Create the GraphicsPath section. GraphicsPath myPathSection = new GraphicsPath(); // Iterate to the 3rd subpath and list the number of points therein // to the screen. int subpathPoints; bool IsClosed2; // Iterate to the third subpath. subpathPoints = myPathIterator.NextSubpath( myPathSection, out IsClosed2); subpathPoints = myPathIterator.NextSubpath( myPathSection, out IsClosed2); subpathPoints = myPathIterator.NextSubpath( myPathSection, out IsClosed2); // Write the number of subpath points to the screen. g.DrawString("Subpath: 3" + " Num Points: " + subpathPoints.ToString(), myFont, myBrush, 200, 20); }
public void PathIterator3(Graphics g) { // Create the GraphicsPath. GraphicsPath myPath = new GraphicsPath(); Point[] myPoints = {new Point(20, 20), new Point(120, 120), new Point(20, 120),new Point(20, 20) }; Rectangle myRect = new Rectangle(120, 120, 100, 100); // Add 3 lines, a rectangle, and an ellipse. myPath.AddLines(myPoints); myPath.AddRectangle(myRect); myPath.AddEllipse(220, 220, 100, 100); // List all of the path points to the screen. ListPathPoints(g, myPath, null, 20, 1); // Create a GraphicsPathIterator. GraphicsPathIterator myPathIterator = new GraphicsPathIterator(myPath); // Rewind the Iterator. myPathIterator.Rewind(); // Iterate the subpaths and types, and list the results to // the screen. int i, j = 20; int mySubPaths, subPathStartIndex, subPathEndIndex; Boolean IsClosed; byte subPathPointType; int pointTypeStartIndex, pointTypeEndIndex, numPointsFound; Font myFont = new Font("Arial", 8); SolidBrush myBrush = new SolidBrush(Color.Black); j = 20; for(i = 0;i < 3; i++) { mySubPaths = myPathIterator.NextSubpath( out subPathStartIndex, out subPathEndIndex, out IsClosed); numPointsFound = myPathIterator.NextPathType( out subPathPointType, out pointTypeStartIndex, out pointTypeEndIndex); g.DrawString( "SubPath: " + i + " Points Found: " + numPointsFound.ToString() + " Type of Points: " + subPathPointType.ToString(), myFont, myBrush, 200, j); j+=20; } // List the total number of path points to the screen. ListPathPoints(g, myPath, myPathIterator, 200, 2); }
public void OutputPaths(string title, GraphicsPath myPath) { var iterator = new GraphicsPathIterator(myPath); int startIndex, endIndex; bool isClosed; int subPaths = iterator.SubpathCount; var pathData = myPath.PathData; Console.WriteLine("{0} - num paths {1}", title, subPaths); for (int sp = 0; sp < subPaths; sp++) { var numOfPoints = iterator.NextSubpath(out startIndex, out endIndex, out isClosed); Console.WriteLine("subPath {0} - from {1} to {2} closed {3}", sp + 1, startIndex, endIndex, isClosed); for (int pp = startIndex; pp <= endIndex; pp++) { Console.WriteLine(" {0} - {1}", pathData.Points[pp], (PathPointType)pathData.Types[pp]); } } }
protected override void DoPerformLayout(RenderContext context) { base.DoPerformLayout(context); // Setup brushes if (Fill != null || ((Stroke != null && StrokeThickness > 0))) { using (GraphicsPath path = CalculateTransformedPath(ParsePath(), _innerRect)) { if (Fill != null && !_fillDisabled) { using (GraphicsPathIterator gpi = new GraphicsPathIterator(path)) { PositionColoredTextured[][] subPathVerts = new PositionColoredTextured[gpi.SubpathCount][]; using (GraphicsPath subPath = new GraphicsPath()) { for (int i = 0; i < subPathVerts.Length; i++) { bool isClosed; gpi.NextSubpath(subPath, out isClosed); PointF[] pathPoints = subPath.PathPoints; TriangulateHelper.Triangulate(pathPoints, 1, out subPathVerts[i]); if (subPathVerts[i] == null) ServiceRegistration.Get<ILogger>().Warn("Failed to triangulate Path \"{0}\"!", Name); } } PositionColoredTextured[] verts; GraphicsPathHelper.Flatten(subPathVerts, out verts); if (verts != null) { Fill.SetupBrush(this, ref verts, context.ZOrder, true); PrimitiveBuffer.SetPrimitiveBuffer(ref _fillContext, ref verts, PrimitiveType.TriangleList); } } } else PrimitiveBuffer.DisposePrimitiveBuffer(ref _fillContext); if (Stroke != null && StrokeThickness > 0) { using (GraphicsPathIterator gpi = new GraphicsPathIterator(path)) { PositionColoredTextured[][] subPathVerts = new PositionColoredTextured[gpi.SubpathCount][]; using (GraphicsPath subPath = new GraphicsPath()) { for (int i = 0; i < subPathVerts.Length; i++) { bool isClosed; gpi.NextSubpath(subPath, out isClosed); PointF[] pathPoints = subPath.PathPoints; TriangulateHelper.TriangulateStroke_TriangleList(pathPoints, (float) StrokeThickness, isClosed, 1, StrokeLineJoin, out subPathVerts[i]); } } PositionColoredTextured[] verts; GraphicsPathHelper.Flatten(subPathVerts, out verts); if (verts != null) { Stroke.SetupBrush(this, ref verts, context.ZOrder, true); PrimitiveBuffer.SetPrimitiveBuffer(ref _strokeContext, ref verts, PrimitiveType.TriangleList); } } } else PrimitiveBuffer.DisposePrimitiveBuffer(ref _strokeContext); } } }
static void WidenPath(GraphicsPath path, Pen pen, out List<PointF> widePoints, out List<byte> wideTypes) { widePoints = new List<PointF> (); wideTypes = new List<byte> (); var pathData = path.PathData; var iterator = new GraphicsPathIterator(path); var subPaths = iterator.SubpathCount; int startIndex = 0; int endIndex = 0; bool isClosed = false; var flattenedSubpath = new Paths(); var offsetPaths = new Paths(); var width = (pen.Width / 2) * scale; var miterLimit = pen.MiterLimit * scale; var joinType = JoinType.jtMiter; switch (pen.LineJoin) { case LineJoin.Round: joinType = JoinType.jtRound; break; case LineJoin.Bevel: joinType = JoinType.jtSquare; break; } for (int sp = 0; sp < subPaths; sp++) { var numOfPoints = iterator.NextSubpath(out startIndex, out endIndex, out isClosed); //Console.WriteLine("subPath {0} - from {1} to {2} closed {3}", sp+1, startIndex, endIndex, isClosed); var subPoints = pathData.Points.Skip(startIndex).Take(numOfPoints).ToArray(); //for (int pp = startIndex; pp <= endIndex; pp++) //{ // Console.WriteLine(" {0} - {1}", pathData.Points[pp], (PathPointType)pathData.Types[pp]); //} // Load our Figure Subpath flattenedSubpath.Clear(); flattenedSubpath.Add(Region.PointFArrayToIntArray(subPoints, scale)); // Calculate the outter offset region var outerOffsets = Clipper.OffsetPaths(flattenedSubpath, width, joinType, EndType.etClosed, miterLimit); // Calculate the inner offset region var innerOffsets = Clipper.OffsetPaths(flattenedSubpath, -width, joinType, EndType.etClosed, miterLimit); // Add the offsets to our paths offsetPaths.AddRange(outerOffsets); // revers our innerOffsets so that they create a hole when filling Clipper.ReversePaths (innerOffsets); offsetPaths.AddRange(innerOffsets); } foreach (var offPath in offsetPaths) { if (offPath.Count < 1) continue; var pointArray = Region.PathToPointFArray(offPath, scale); var type = (byte)PathPointType.Start; widePoints.Add (pointArray [0]); wideTypes.Add (type); type = (byte)PathPointType.Line; for (int i = 1; i < offPath.Count; i++) { widePoints.Add (pointArray [i]); wideTypes.Add (type); } if (widePoints.Count > 0) wideTypes [wideTypes.Count-1] = (byte) (wideTypes [wideTypes.Count-1] | (byte) PathPointType.CloseSubpath); } }
public void NextSubpath_NextMarker() { GraphicsPath path = new GraphicsPath(); path.AddLine (10, 10, 50, 50); // figure #1 path.AddLine (50, 50, 80, 80); path.AddLine (90, 90, 100, 100); path.SetMarkers (); // marker #1 path.AddLine (150, 150, 180, 180); path.SetMarkers (); // marker #2 path.StartFigure (); // figure #2 path.SetMarkers (); // marker #3 is actually marker #2 path.AddRectangle (new Rectangle (200, 200, 200, 200)); path.SetMarkers (); // marker #4 path.AddLine (150, 150, 180, 180); path.StartFigure (); // figure #3 path.AddBezier (400, 400, 500, 500, 600, 600, 700, 700); path.AddBezier (450, 450, 550, 550, 650, 650, 750, 750); GraphicsPathIterator iterator = new GraphicsPathIterator (path); int start; int end; bool isClosed; int count = iterator.NextMarker (out start,out end); // marker #1 Assert.AreEqual (5, count); Assert.AreEqual (0, start); Assert.AreEqual (4, end); count = iterator.NextSubpath (out start,out end,out isClosed); // figure #1 Assert.AreEqual (7, count); Assert.AreEqual (0, start); Assert.AreEqual (6, end); Assert.AreEqual (false, isClosed); count = iterator.NextMarker (out start,out end); // marker #2 (and #3) Assert.AreEqual (2, count); Assert.AreEqual (5, start); Assert.AreEqual (6, end); count = iterator.NextSubpath (out start,out end,out isClosed); // figure #2 Assert.AreEqual (4, count); Assert.AreEqual (7, start); Assert.AreEqual (10, end); Assert.AreEqual (true, isClosed); count = iterator.NextSubpath (out start,out end,out isClosed); // figure #3 Assert.AreEqual (2, count); Assert.AreEqual (11, start); Assert.AreEqual (12, end); Assert.AreEqual (false, isClosed); count = iterator.NextMarker (out start,out end); // marker #5 (end) Assert.AreEqual (4, count); Assert.AreEqual (7, start); Assert.AreEqual (10, end); count = iterator.NextMarker (out start,out end); // marker #5 (end) Assert.AreEqual (10, count); Assert.AreEqual (11, start); Assert.AreEqual (20, end); // we dont want to be bug compliant with .net /* count = iterator.NextMarker (out start,out end); // no more markers Assert.AreEqual (0, count); Assert.AreEqual (11, start); Assert.AreEqual (20, end); */ count = iterator.NextSubpath (out start,out end,out isClosed); // figure #4 Assert.AreEqual (8, count); Assert.AreEqual (13, start); Assert.AreEqual (20, end); Assert.AreEqual (false, isClosed); // we dont want to be bug compliant with .net /* count = iterator.NextMarker (out start,out end); // no more markers Assert.AreEqual (0, count); Assert.AreEqual (13, start); Assert.AreEqual (20, end); */ count = iterator.NextSubpath (out start,out end,out isClosed); // no more figures Assert.AreEqual (0, count); Assert.AreEqual (0, start); Assert.AreEqual (0, end); Assert.AreEqual (true, isClosed); count = iterator.NextMarker (out start,out end); // no more markers Assert.AreEqual (0, count); Assert.AreEqual (0, start); Assert.AreEqual (0, end); }
public GraphicsPath RandomWarp(GraphicsPath path) { // Add line // int PsCount = 10; PointF[] curvePs = new PointF[PsCount * 2]; for (int u = 0; u < PsCount; u++) { curvePs[u].X = u * (Width / PsCount); curvePs[u].Y = Height / 2; } for (int u = PsCount; u < (PsCount * 2); u++) { curvePs[u].X = (u - PsCount) * (Width / PsCount); curvePs[u].Y = Height / 2 + 2; } double eps = Height * 0.05; double amp = rnd.NextDouble() * (double)(Height / 3); double size = rnd.NextDouble() * (double)(Width / 4) + Width / 8; double offset = (double)(Height / 3); PointF[] pn = new PointF[path.PointCount]; byte[] pt = new byte[path.PointCount]; GraphicsPath np2 = new GraphicsPath(); GraphicsPathIterator iter = new GraphicsPathIterator(path); for (int i = 0; i < iter.SubpathCount; i++) { GraphicsPath sp = new GraphicsPath(); bool closed; iter.NextSubpath(sp, out closed); Matrix m = new Matrix(); m.RotateAt(Convert.ToSingle(rnd.NextDouble() * 30 - 15), sp.PathPoints[0]); m.Translate(-1 * i, 0);//uncomment sp.Transform(m); np2.AddPath(sp, true); } for (int i = 0; i < np2.PointCount; i++) { //pn[i] = Noise( path.PathPoints[i] , eps); pn[i] = Wave(np2.PathPoints[i], amp, size); pt[i] = np2.PathTypes[i]; } GraphicsPath newpath = new GraphicsPath(pn, pt); return newpath; }
/// <summary> /// Warps one path to the flattened (<see cref="GraphicsPath.Flatten()"/>) version of another path. /// This comes in handy for /// <list type="Bullet"> /// <item>Linestyles that cannot be created with available <see cref="Pen"/>-properties</item> /// <item>Warping Text to curves</item> /// <item>...</item> /// </list> /// </summary> /// <param name="pathToWarpTo">The path to warp to. This path is flattened before being used, so there is no need to call <see cref="GraphicsPath.Flatten()"/> prior to this function call.</param> /// <param name="pathToWarp">The path to warp</param> /// <param name="isPattern">Defines whether <paramref name="pathToWarp"/> is a pattern or not. If <paramref name="pathToWarp"/> is a pattern, it is repeated until it has the total length of <see paramref="pathToWarpTo"/></param> /// <param name="interval">The interval in which the pattern should be repeated</param> /// <returns>Warped <see cref="GraphicsPath"/></returns> /// <exception cref="ArgumentNullException">If either pathToWarpTo or pathToWarp is null</exception> public static GraphicsPath Warp(GraphicsPath pathToWarpTo, GraphicsPath pathToWarp, bool isPattern, float interval) { //Test for valid arguments if (pathToWarpTo == null) throw new ArgumentNullException("pathToWarpTo"); if (pathToWarp == null) throw new ArgumentNullException("pathToWarp"); //Remove all curves from path to warp to, get total length. SortedList<float, GraphSegment> edges; pathToWarpTo.Flatten(); Double pathLength = GetPathLength(pathToWarpTo, out edges); if (pathLength == 0) return pathToWarp; //Prepare path to warp pathToWarp = PreparePathToWarp(pathToWarp, isPattern, pathLength, interval); if (pathToWarp == null || pathToWarp.PointCount == 0) return null; GraphicsPath warpedPath = new GraphicsPath(pathToWarp.FillMode); using (GraphicsPathIterator iter = new GraphicsPathIterator(pathToWarp)) { GraphicsPath subPath = new GraphicsPath(); int currentIndex = 0; if (iter.SubpathCount > 1) { bool isClosed; while (iter.NextSubpath(subPath, out isClosed) > 0) { GraphicsPath warpedSubPath = WarpSubpath(subPath, edges, ref currentIndex); if (isClosed) warpedSubPath.CloseFigure(); warpedPath.AddPath(warpedSubPath, true); warpedPath.SetMarkers(); } } else { warpedPath = WarpSubpath(pathToWarp, edges, ref currentIndex); } } return warpedPath; }
public void RenderingPolygonsWithGdiVectorRendererProducesCorrectGdiPaths() { using (GdiVectorRenderer vectorRenderer = new GdiVectorRenderer()) { BasicGeometryRenderer2D<GdiRenderObject> geometryRenderer = new BasicGeometryRenderer2D<GdiRenderObject>(vectorRenderer); FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_geoFactory); FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents()); foreach (IFeatureDataRecord record in provider.ExecuteFeatureQuery(query)) { IEnumerable<GdiRenderObject> renderedObjects = geometryRenderer.RenderFeature(record); foreach (GdiRenderObject ro in renderedObjects) { IGeometry g = record.Geometry; if (g is IPolygon) { IPolygon p = g as IPolygon; using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath)) { Int32 start, end; Boolean isClosed; iter.NextSubpath(out start, out end, out isClosed); Assert.IsTrue(isClosed); Assert.AreEqual(p.ExteriorRing.Coordinates.Count, end - start + 1); for (Int32 vertexIndex = 0; vertexIndex < p.ExteriorRing.Coordinates.Count; vertexIndex++) { ICoordinate v = (ICoordinate)p.ExteriorRing.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } foreach (ILineString interiorRing in p.InteriorRings) { iter.NextSubpath(out start, out end, out isClosed); Assert.IsTrue(isClosed); Assert.AreEqual(interiorRing.PointCount, end - start + 1); for (Int32 vertexIndex = 0; vertexIndex < interiorRing.PointCount; vertexIndex++) { ICoordinate v = interiorRing.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } } } } else if (g is IMultiPolygon) { IMultiPolygon mp = g as IMultiPolygon; using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath)) { foreach (IPolygon p in (IEnumerable<IPolygon>)mp) { Int32 start, end; Boolean isClosed; iter.NextSubpath(out start, out end, out isClosed); Assert.IsTrue(isClosed); Int32 exteriorPointCount = p.ExteriorRing.PointCount; Assert.AreEqual(exteriorPointCount, end - start + 1); for (Int32 vertexIndex = 0; vertexIndex < exteriorPointCount; vertexIndex++) { ICoordinate v = p.ExteriorRing.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } foreach (ILineString interiorRing in p.InteriorRings) { iter.NextSubpath(out start, out end, out isClosed); Assert.IsTrue(isClosed); Assert.AreEqual(interiorRing.PointCount, end - start + 1); for (Int32 vertexIndex = 0; vertexIndex < interiorRing.PointCount; vertexIndex++) { ICoordinate v = interiorRing.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } } } } } } } } }
public void RenderingLinesWithGdiVectorRendererProducesCorrectGdiPaths() { using (GdiVectorRenderer vectorRenderer = new GdiVectorRenderer()) { BasicGeometryRenderer2D<GdiRenderObject> geometryRenderer = new BasicGeometryRenderer2D<GdiRenderObject>(vectorRenderer); FeatureProvider provider = DataSourceHelper.CreateFeatureDatasource(_geoFactory); FeatureQueryExpression query = FeatureQueryExpression.Intersects(provider.GetExtents()); foreach (IFeatureDataRecord record in provider.ExecuteFeatureQuery(query)) { IEnumerable<GdiRenderObject> renderedObjects = geometryRenderer.RenderFeature(record); Int32 geoIndex = 0; IGeometry g = record.Geometry; foreach (GdiRenderObject ro in renderedObjects) { using (GraphicsPathIterator iter = new GraphicsPathIterator(ro.GdiPath)) { Int32 start, end; Boolean isClosed; iter.NextSubpath(out start, out end, out isClosed); if (g is ILineString) { Assert.IsFalse(isClosed); ILineString ls = g as ILineString; Assert.AreEqual(1, iter.SubpathCount); for (Int32 vertexIndex = 0; vertexIndex < ls.Coordinates.Count; vertexIndex++) { ICoordinate v = (ICoordinate)ls.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } } else if (g is IMultiLineString) { Assert.IsFalse(isClosed); IMultiLineString mls = g as IMultiLineString; Assert.AreEqual(mls.Count, iter.SubpathCount); foreach (ILineString lineString in (IEnumerable<ILineString>)mls) { for (Int32 vertexIndex = 0; vertexIndex < lineString.Coordinates.Count; vertexIndex++) { ICoordinate v = (ICoordinate)lineString.Coordinates[vertexIndex]; PointF gdiPoint = ro.GdiPath.PathPoints[vertexIndex + start]; Assert.AreEqual(v[Ordinates.X], gdiPoint.X); Assert.AreEqual(v[Ordinates.Y], gdiPoint.Y); } iter.NextSubpath(out start, out end, out isClosed); } } } } } } }
/// <summary> /// Renders the flattened path to the device using the specified color. /// </summary> /// <param name="device">The device to use for rendering the path.</param> /// <param name="color">The color to use for the vertices.</param> /// <param name="flattenedPath">The path to render.</param> protected virtual void Render(Device device, int color, GraphicsPath flattenedPath) { PointF[] points = flattenedPath.PathPoints; device.VertexFormat = CustomVertex.PositionColored.Format; bool isClosed; GraphicsPathIterator pi = new GraphicsPathIterator(flattenedPath); while(pi.NextSubpath(flattenedPath, out isClosed)!=0) { byte type; int start, end; while(pi.NextPathType(out type, out start, out end)!=0) { int numDistinctPoints = end-start+1; int totNumPoints = numDistinctPoints; if (isClosed) totNumPoints++; CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[totNumPoints]; P3Util.CreateColoredVertexList(colVerts, points, start, 0, numDistinctPoints, color); if (isClosed){ colVerts[numDistinctPoints] = colVerts[0]; } device.DrawUserPrimitives(PrimitiveType.LineStrip, totNumPoints-1, colVerts); } } }
/// <summary> /// Cache a flattened path. /// </summary> /// <param name="flattenedPath">The flattened path to cache.</param> protected virtual void CacheFlatPath(GraphicsPath flattenedPath) { bool isClosed; GraphicsPathIterator pi = new GraphicsPathIterator(flattenedPath); PointF[] points = flattenedPath.PathPoints; while(pi.NextSubpath(flattenedPath, out isClosed)!=0) { byte type; int start, end; int oldCount = renderList.Count; while(pi.NextPathType(out type, out start, out end)!=0) { for (int i = start; i <= end; i++) { renderList.Add(points[i]); } if (isClosed){ renderList.Add(points[start]); } renderListTypes.Add(new PrimitiveTypeInfo(oldCount, renderList.Count-1, pen.Color.ToArgb(), PrimitiveType.LineStrip)); } } }
/// <summary> /// Converts the GDI+ GraphicsPath to the MapScript shape object. /// </summary> /// <param name="path">The GraphicsPath object to convert.</param> /// <returns>The converted shapeObj</returns> public shapeObj GraphicsPathToShape(GraphicsPath path) { shapeObj feature = null; if (path != null) { using (GraphicsPathIterator myPathIterator = new GraphicsPathIterator(path)) { int myStartIndex; int myEndIndex; bool myIsClosed; // get the number of Subpaths. int numSubpaths = myPathIterator.SubpathCount; while (myPathIterator.NextSubpath(out myStartIndex, out myEndIndex, out myIsClosed) > 0) { lineObj line = new lineObj(); for (int i = myStartIndex; i <= myEndIndex; i++) { if (i == myStartIndex || (path.PathPoints[i].X != path.PathPoints[i - 1].X && path.PathPoints[i].Y != path.PathPoints[i - 1].Y)) line.add(new pointObj(Pixel2MapX(path.PathPoints[i].X), Pixel2MapY(path.PathPoints[i].Y), 0, 0)); } if (feature == null) { if (myIsClosed && line.numpoints > 2) feature = new shapeObj((int)MS_SHAPE_TYPE.MS_SHAPE_POLYGON); else feature = new shapeObj((int)MS_SHAPE_TYPE.MS_SHAPE_LINE); } if (line.numpoints >= 2) feature.add(line); } } } return feature; }
public virtual void NextPathType() { GraphicsPath path = new GraphicsPath (); path.AddLine (new Point (100, 100), new Point (400, 100)); path.AddBezier( 100, 100, 500, 250, 100, 50, 250, 280); path.AddLine (new Point (400, 200), new Point (10, 100)); path.StartFigure (); path.SetMarkers (); path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280); path.StartFigure (); path.SetMarkers (); path.AddRectangle (new Rectangle (10, 20, 300, 400)); path.StartFigure (); path.SetMarkers (); path.AddLine (new Point (400, 400), new Point (400, 10)); GraphicsPathIterator iterator = new GraphicsPathIterator (path); byte pathType; int start; int end; bool isClosed; int count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (0, count); Assert.AreEqual ((byte)PathPointType.Start, pathType); Assert.AreEqual (0, start); Assert.AreEqual (0, end); iterator.NextSubpath (out start, out end, out isClosed); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (3, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (0, start); Assert.AreEqual (2, end); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (4, count); Assert.AreEqual ((byte)PathPointType.Bezier3, pathType); Assert.AreEqual (2, start); Assert.AreEqual (5, end); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (3, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (5, start); Assert.AreEqual (7, end); // we don't want to be a bug compliant with .net /* count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (0, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (5, start); Assert.AreEqual (7, end); */ iterator.NextSubpath (out start, out end, out isClosed); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (4, count); Assert.AreEqual ((byte)PathPointType.Bezier3, pathType); Assert.AreEqual (8, start); Assert.AreEqual (11, end); iterator.NextSubpath (out start, out end, out isClosed); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (4, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (12, start); Assert.AreEqual (15, end); iterator.NextSubpath (out start, out end, out isClosed); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (2, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (16, start); Assert.AreEqual (17, end); iterator.NextSubpath (out start, out end, out isClosed); count = iterator.NextPathType (out pathType, out start, out end); Assert.AreEqual (0, count); Assert.AreEqual ((byte)PathPointType.Line, pathType); Assert.AreEqual (0, start); Assert.AreEqual (0, end); }
///<summary> /// Extracts the points of the paths in a flat {@link PathIterator} into /// a list of Coordinate arrays. ///</summary> /// <param name="pathIt">A path iterator</param> /// <returns>A list of coordinate arrays</returns> /// <exception cref="ArgumentException">If a non-linear segment type is encountered</exception> public static IList<Coordinate[]> ToCoordinates(GraphicsPathIterator pathIt) { if (pathIt.HasCurve()) throw new ArgumentException("Path must not have non-linear segments"); var coordArrays = new List<Coordinate[]>(); int startIndex, endIndex; bool isClosed; while (pathIt.NextSubpath(out startIndex, out endIndex, out isClosed) > 0) { Coordinate[] pts = NextCoordinateArray(pathIt, startIndex, endIndex, isClosed); coordArrays.Add(pts); if (endIndex == pathIt.Count - 1) break; } return coordArrays; }
public virtual void NextSubpath_GraphicsPath_Bool() { GraphicsPath path = new GraphicsPath (); path.AddLine (new Point (100, 100), new Point (400, 100)); path.AddLine (new Point (400, 200), new Point (10, 100)); path.StartFigure (); path.SetMarkers (); path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280); path.CloseFigure (); path.StartFigure (); path.SetMarkers (); path.AddRectangle (new Rectangle (10, 20, 300, 400)); path.StartFigure (); path.SetMarkers (); path.AddLine (new Point (400, 400), new Point (400, 10)); GraphicsPathIterator iterator = new GraphicsPathIterator (path); GraphicsPath path2 = new GraphicsPath (); bool isClosed; int count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (4, count); Assert.IsFalse (isClosed); PointF [] actualPoints = path2.PathPoints; byte [] actualTypes = path2.PathTypes; PointF [] expectedPoints = new PointF [] { new PointF(100f, 100f), new PointF(400f, 100f), new PointF(400f, 200f), new PointF(10f, 100f)}; for(int i = 0; i < expectedPoints.Length; i++) { DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]); } byte [] expectedTypes = new byte [] { (byte) PathPointType.Start, (byte) PathPointType.Line, (byte) PathPointType.Line, (byte) (PathPointType.Line | PathPointType.PathMarker)}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (4, count); Assert.IsTrue (isClosed); actualPoints = path2.PathPoints; actualTypes = path2.PathTypes; expectedPoints = new PointF [] {new PointF(10f, 10f), new PointF(50f, 250f), new PointF(100f, 5f), new PointF(200f, 280f)}; for(int i = 0; i < expectedPoints.Length; i++) { DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]); } expectedTypes = new byte [] { (byte) PathPointType.Start, (byte) PathPointType.Bezier3, (byte) PathPointType.Bezier3, (byte) (PathPointType.Bezier3 | PathPointType.CloseSubpath | PathPointType.PathMarker)}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (4, count); Assert.IsTrue (isClosed); actualPoints = path2.PathPoints; actualTypes = path2.PathTypes; expectedPoints = new PointF [] {new PointF(10f, 20f), new PointF(310f, 20f), new PointF(310f, 420f), new PointF(10f, 420f)}; for(int i = 0; i < expectedPoints.Length; i++) { DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]); } expectedTypes = new byte [] { (byte) PathPointType.Start, (byte) PathPointType.Line, (byte) PathPointType.Line, (byte) (PathPointType.Line | PathPointType.CloseSubpath | PathPointType.PathMarker)}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (2, count); Assert.IsFalse (isClosed); actualPoints = path2.PathPoints; actualTypes = path2.PathTypes; expectedPoints = new PointF [] {new PointF(400f, 400f), new PointF(400f, 10f)}; for(int i = 0; i < expectedPoints.Length; i++) { DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]); } expectedTypes = new byte [] { (byte) PathPointType.Start, (byte) PathPointType.Line}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (0, count); count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (0, count); Assert.IsTrue (isClosed); Assert.AreEqual (2, path2.PointCount); actualPoints = path2.PathPoints; actualTypes = path2.PathTypes; expectedPoints = new PointF [] {new PointF(400f, 400f), new PointF(400f, 10f)}; for(int i = 0; i < expectedPoints.Length; i++) { DrawingTest.AssertAlmostEqual(expectedPoints [i], actualPoints [i]); } expectedTypes = new byte [] { (byte) PathPointType.Start, (byte) PathPointType.Line}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } path = new GraphicsPath (); path.AddBezier( 10, 10, 50, 250, 100, 5, 200, 280); iterator = new GraphicsPathIterator (path); path2 = new GraphicsPath (); count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (4, count); Assert.IsFalse (isClosed); path2 = new GraphicsPath (); count = iterator.NextSubpath (path2, out isClosed); Assert.AreEqual (0, count); Assert.IsTrue (isClosed); }
/// <summary> /// Given the points on this line decoration, this will cycle through and handle /// the drawing as dictated by this decoration. /// </summary> /// <param name="g"></param> /// <param name="path"></param> /// <param name="scaleWidth">The double scale width for controling markers</param> public void Draw(Graphics g, GraphicsPath path, double scaleWidth) { if (NumSymbols == 0) return; GraphicsPathIterator myIterator = new GraphicsPathIterator(path); myIterator.Rewind(); int start, end; bool isClosed; Size2D symbolSize = _symbol.GetSize(); Bitmap symbol = new Bitmap((int)symbolSize.Width, (int)symbolSize.Height); Graphics sg = Graphics.FromImage(symbol); _symbol.Draw(sg, new Rectangle(0, 0, (int)symbolSize.Width, (int)symbolSize.Height)); sg.Dispose(); Matrix oldMat = g.Transform; PointF[] points; if (path.PointCount == 0) return; try { points = path.PathPoints; } catch { return; } PointF offset; int count = 0; while (myIterator.NextSubpath(out start, out end, out isClosed) > 0) { count = count + 1; // First marker PointF startPoint = points[start]; PointF stopPoint = points[start + 1]; float angle = 0F; if (_rotateWithLine) angle = GetAngle(startPoint, stopPoint); if (FlipFirst && !FlipAll) FlipAngle(ref angle); offset = GetOffset(startPoint, stopPoint); startPoint = new PointF(startPoint.X + offset.X, startPoint.Y + offset.Y); Matrix rotated = g.Transform; rotated.RotateAt(angle, startPoint); g.Transform = rotated; DrawImage(g, startPoint, symbol); g.Transform = oldMat; // Second marker if (NumSymbols > 1) { angle = 0F; if (_rotateWithLine) angle = GetAngle(points[end - 1], points[end]); if (FlipAll) FlipAngle(ref angle); offset = GetOffset(points[end - 1], points[end]); PointF endPoint = new PointF(points[end].X + offset.X, points[end].Y + offset.Y); rotated = g.Transform; rotated.RotateAt(angle, endPoint); g.Transform = rotated; DrawImage(g, endPoint, symbol); g.Transform = oldMat; } if (NumSymbols > 2) { double totalLength = GetLength(points, start, end); double span = totalLength / (NumSymbols - 1); for (int i = 1; i < NumSymbols - 1; i++) { DecorationSpot spot = GetPosition(points, span * i, start, end); angle = 0F; if (_rotateWithLine) angle = GetAngle(spot.Before, spot.After); offset = GetOffset(spot.Before, spot.After); PointF location = new PointF(spot.Position.X + offset.X, spot.Position.Y + offset.Y); if (FlipAll) FlipAngle(ref angle); rotated = g.Transform; rotated.RotateAt(angle, location); g.Transform = rotated; DrawImage(g, location, symbol); g.Transform = oldMat; } } } }
/// <summary> /// Tesselates the specified path, notifying the /// <see cref="UMD.HCIL.PiccoloDirect3D.Util.TesselationVisitor">TesselationVisitor</see> /// as each new triangle primitive is added. /// </summary> /// <param name="path">The path to tesselate.</param> /// <param name="visitor">The tesselation visitor to notify.</param> public virtual void Tesselate(GraphicsPath path, TesselationVisitor visitor) { this.visitor = visitor; switch (path.FillMode) { case FillMode.Alternate: //even/odd P3Util.SetWindingRule(tess, P3Util.GlTessWinding.WindingOdd); break; case FillMode.Winding: //nonzero P3Util.SetWindingRule(tess, P3Util.GlTessWinding.WindingNonzero); break; } P3Util.GluTessBeginPolygon(tess, IntPtr.Zero); bool isClosed; GraphicsPathIterator pi = new GraphicsPathIterator(path); PointF[] points = path.PathPoints; while(pi.NextSubpath(path, out isClosed)!=0) { byte type; int start, end; while(pi.NextPathType(out type, out start, out end)!=0) { PathPointType ppType = (PathPointType)type; P3Util.GluTessBeginContour(tess); for (int i = start; i <= end; i++) { PointF point = points[i]; double[] coords = new double[3]; coords[0] = point.X; coords[1] = point.Y; coords[2] = 0; GCHandle handle = GCHandle.Alloc(coords, GCHandleType.Pinned); P3Util.GluTessVertex(tess, coords, (IntPtr)handle); handles.Add(handle); } P3Util.GluTessEndContour(tess); } } P3Util.GluTessEndPolygon(tess); ClearHandles(); }
/// <summary> /// Given the points on this line decoration, this will cycle through and handle /// the drawing as dictated by this decoration. /// </summary> /// <param name="g"></param> /// <param name="path"></param> /// <param name="scaleWidth">The double scale width for controling markers</param> public void Draw(Graphics g, GraphicsPath path, double scaleWidth) { if (NumSymbols == 0) return; GraphicsPathIterator myIterator = new GraphicsPathIterator(path); myIterator.Rewind(); int start, end; bool isClosed; Size2D symbolSize = _symbol.GetSize(); Bitmap symbol = new Bitmap((int)symbolSize.Width, (int)symbolSize.Height); Graphics sg = Graphics.FromImage(symbol); _symbol.Draw(sg, new Rectangle(0, 0, (int)symbolSize.Width, (int)symbolSize.Height)); sg.Dispose(); Matrix oldMat = g.Transform; PointF[] points; if (path.PointCount == 0) return; try { points = path.PathPoints; } catch { return; } while (myIterator.NextSubpath(out start, out end, out isClosed) > 0) { if (NumSymbols == 1) //single decoration spot { if (_percentualPosition == 0) // at start of the line { DrawImage(g, points[start], points[start + 1], points[start], (FlipFirst ^ FlipAll), symbol, oldMat); } else if (_percentualPosition == 100) // at end of the line { DrawImage(g, points[end - 1], points[end], points[end], (FlipFirst ^ FlipAll), symbol, oldMat); } else //somewhere in between start and end { double totalLength = GetLength(points, start, end); double span = totalLength * (double)_percentualPosition / 100; List<DecorationSpot> spot = GetPosition(points, span, start, end); if (spot.Count > 1) DrawImage(g, spot[1].Before, spot[1].After, spot[1].Position, (FlipFirst ^ FlipAll), symbol, oldMat); } } else // more than one decoration spot { double totalLength = GetLength(points, start, end); double span = Math.Round(totalLength / (NumSymbols - 1), 4); List<DecorationSpot> spots = GetPosition(points, span, start, end); spots.Add(new DecorationSpot(points[end - 1], points[end], points[end])); //add the missing end point for (int i = 0; i < spots.Count; i++) DrawImage(g, spots[i].Before, spots[i].After, spots[i].Position, i == 0 ? (FlipFirst ^ FlipAll) : FlipAll, symbol, oldMat); } } }