/// <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); } } }
public virtual void CopyData() { 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.AddRectangle (new Rectangle (10, 20, 300, 400)); path.StartFigure (); path.SetMarkers (); path.AddLine (new Point (400, 400), new Point (400, 10)); GraphicsPathIterator pathIterator = new GraphicsPathIterator(path); pathIterator.Rewind (); PointF [] actualPoints = new PointF [10]; byte [] actualTypes = new byte [10]; pathIterator.CopyData (ref actualPoints, ref actualTypes, 0, 9); PointF [] expectedPoints = new PointF [] { new PointF(100f, 100f), new PointF(400f, 100f), new PointF(400f, 200f), new PointF(10f, 100f), new PointF(10f, 20f), new PointF(310f, 20f), new PointF(310f, 420f), new PointF(10f, 420f), new PointF(400f, 400f), new PointF(400f, 10f)}; 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), (byte) PathPointType.Start, (byte) PathPointType.Line, (byte) PathPointType.Line, (byte) (PathPointType.Line | PathPointType.CloseSubpath | PathPointType.PathMarker), (byte) PathPointType.Start, (byte) PathPointType.Line}; for (int i=0; i < expectedTypes.Length; i++) { Assert.AreEqual (expectedTypes [i], actualTypes [i]); } }
public virtual void Rewind() { 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.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 i; int j; iterator.NextMarker (out i, out j); iterator.NextMarker (out i, out j); iterator.Rewind (); iterator.NextMarker (out i, out j); Assert.AreEqual (0, i); Assert.AreEqual (3, j); }
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 PathIterator5(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 the values 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 for all of path points and types to // the left side of 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. GraphicsPathIterator myPathIterator = new GraphicsPathIterator(myPath); // Rewind the iterator. myPathIterator.Rewind(); // Create a GraphicsPath to receive a section of myPath. GraphicsPath myPathSection = new GraphicsPath(); // Retrieve and list the number of points contained in // the first marker to the right side of the screen. int markerPoints; markerPoints = myPathIterator.NextMarker(myPathSection); g.DrawString("Marker: 1" + " Num Points: " + markerPoints.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 PathIterator2(Graphics g) { 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); myPath.AddLines(myPoints); myPath.AddRectangle(myRect); myPath.AddEllipse(220, 220, 100, 100); // Get the total number of points for the path, and arrays of // the points and types. int myPathPointCount = myPath.PointCount; PointF[] myPathPoints = myPath.PathPoints; byte[] myPathTypes = myPath.PathTypes; // Set up variables for listing the array of points on the left // side of the screen. int i; float j = 20; Font myFont = new Font("Arial", 8); SolidBrush myBrush = new SolidBrush(Color.Black); // List the set of points and types and types to the left side // of the screen. g.DrawString("Original Data", myFont, myBrush, 20, j); j += 20; 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); myPathIterator.Rewind(); PointF[] points = new PointF[myPathIterator.Count]; byte[] types = new byte[myPathIterator.Count]; int numPoints = myPathIterator.Enumerate(ref points, ref types); // Draw the set of copied points and types to the screen. j = 20; g.DrawString("Copied Data", myFont, myBrush, 200, j); j += 20; for(i=0; i<points.Length; i++) { g.DrawString("Point: " + i + ", " + "Value: " + points[i].ToString() + ", " + "Type: " + types[i].ToString(), myFont, myBrush, 200, j); j+=20; } }
public void PathIterator1(Graphics g) { // Create a graphics path. GraphicsPath myPath = new GraphicsPath (); // Set up a points array. Point[] myPoints = { new Point(20, 20), new Point(120, 120), new Point(20, 120), new Point(20, 20) }; // Create a rectangle. Rectangle myRect = new Rectangle(120, 120, 100, 100); // Add the points, rectangle, and an ellipse to the path. 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 arrays of // the points and types. int myPathPointCount = myPath.PointCount; PointF[] myPathPoints = myPath.PathPoints; byte[] myPathTypes = myPath.PathTypes; // Set up variables for listing the array of points on the left // side of the screen. int i; float j = 20; Font myFont = new Font("Arial", 8); SolidBrush myBrush = new SolidBrush(Color.Black); // List the set of points and types and types to the left side // of 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 and rewind it. GraphicsPathIterator myPathIterator = new GraphicsPathIterator(myPath); myPathIterator.Rewind(); // Set up the arrays to receive the copied data. PointF[] points = new PointF[myPathIterator.Count]; byte[] types = new byte[myPathIterator.Count]; int myStartIndex; int myEndIndex; // Increment the starting index to the second marker in the // path. myPathIterator.NextMarker(out myStartIndex, out myEndIndex); myPathIterator.NextMarker(out myStartIndex, out myEndIndex); // Copy all the points and types from the starting index to the // ending index to the points array and the types array // respectively. int numPointsCopied = myPathIterator.CopyData( ref points, ref types, myStartIndex, myEndIndex); // List the copied points to the right side of the screen. j = 20; int copiedStartIndex = 0; for(i=0; i<numPointsCopied; i++) { copiedStartIndex = myStartIndex + i; g.DrawString( "Point: " + copiedStartIndex.ToString() + ", Value: " + points[i].ToString() + ", Type: " + types[i].ToString(), myFont, myBrush, 200, j); j+=20; } }
private void PathIterator6(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, 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 drawing the array // of points to the screen. int i; float j = 20; Font myFont = new Font("Arial", 8); SolidBrush myBrush = new SolidBrush(Color.Black); // Draw the set of 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. GraphicsPathIterator myPathIterator = new GraphicsPathIterator(myPath); int myStartIndex; int myEndIndex; // Rewind the Iterator. myPathIterator.Rewind(); // Draw the Markers and their start and end points // to the screen. j=20; for(i=0;i<3;i++) { myPathIterator.NextMarker(out myStartIndex, out myEndIndex); g.DrawString("Marker " + i.ToString() + ": Start: " + myStartIndex.ToString()+ " End: " + myEndIndex.ToString(), myFont, myBrush, 200, j); j += 20; } // Draw the total number of points to the screen. j += 20; int myPathTotalPoints = myPathIterator.Count; g.DrawString("Total Points = " + myPathTotalPoints.ToString(), myFont, myBrush, 200, j); }
/// <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; } } } }
public void Clone() { path = new GraphicsPath (); path.AddEllipse (0, 0, 100, 200); path.SetMarkers (); path.AddLine (new Point (100, 100), new Point (200, 100)); Rectangle rect = new Rectangle (200, 0, 100, 200); path.AddRectangle (rect); path.SetMarkers (); path.AddLine (new Point (250, 200), new Point (250, 300)); path.SetMarkers (); GraphicsPath cloned = (GraphicsPath) path.Clone (); Assert.AreEqual (path.PointCount, cloned.PointCount); for ( int i = 0; i < path.PointCount; i++) { DrawingTest.AssertAlmostEqual(path.PathPoints [i], cloned.PathPoints [i]); Assert.AreEqual (path.PathTypes [i], cloned.PathTypes [i]); } GraphicsPathIterator pathIterator = new GraphicsPathIterator(path); pathIterator.Rewind (); GraphicsPathIterator clonedIterator = new GraphicsPathIterator(cloned); clonedIterator.Rewind (); for (int i=0; i < 4; i ++) { Assert.AreEqual (pathIterator.NextMarker (path), clonedIterator.NextMarker (cloned)); } //t.AssertCompare (); }
public void ClearMarkers() { path = new GraphicsPath (); path.AddEllipse (0, 0, 100, 200); path.SetMarkers (); path.AddLine (new Point (100, 100), new Point (200, 100)); Rectangle rect = new Rectangle (200, 0, 100, 200); path.AddRectangle (rect); path.SetMarkers (); path.AddLine (new Point (250, 200), new Point (250, 300)); path.SetMarkers (); path.ClearMarkers(); GraphicsPathIterator pathIterator = new GraphicsPathIterator(path); pathIterator.Rewind (); int [] pointsNumber = new int [] {21, 0, 0, 0}; for (int i=0; i < 4; i ++) { Assert.AreEqual (pointsNumber [i], pathIterator.NextMarker (path)); } //t.AssertCompare (); }
/// <summary> /// This is used to get the image area at the specified point (if any) /// </summary> /// <returns>The image area index if the point is in an image area or negative one (-1) if it is not in /// any of the image areas.</returns> private int ImageAreaAtPoint(Point pt) { int idx; if(pt.X > this.ImageMapWidth || pt.Y > this.ImageMapHeight) return -1; // Set the image area paths if they need recalculating if(pathData.PointCount == 0) this.SetImageAreaPaths(); using(GraphicsPath p = new GraphicsPath()) using(GraphicsPathIterator i = new GraphicsPathIterator(pathData)) { i.Rewind(); for(idx = 0; idx < i.SubpathCount; idx++) { i.NextMarker(p); if(p.IsVisible(pt, gPanel) && this.Areas[idx].Enabled) break; } return (idx < i.SubpathCount) ? idx : -1; } }