Hi,

You could use the following method to find the shape points coordinates. You might also add some arguments to customize the result, e.g. to include additional points such as the middle points of line segments.

List<PointF> shapePoints = GetShapePoints(Shapes.Tape);
foreach (PointF p in shapePoints)
	Debug.WriteLine(p.ToString());

List<PointF> GetShapePoints(Shape shape)
{
	List<PointF> points = new List<PointF>();

	foreach (ElementTemplate element in shape.Outline)
	{
		LineTemplate line = element as LineTemplate;
		if (line != null)
		{
			AddPoint(points, line.Coordinates[0], line.Coordinates[1]);
			AddPoint(points, line.Coordinates[2], line.Coordinates[3]);
		}

		BezierTemplate bezier = element as BezierTemplate;
		if (bezier != null)
		{
			AddPoint(points, bezier.Coordinates[0], bezier.Coordinates[1]);
			AddPoint(points, bezier.Coordinates[6], bezier.Coordinates[7]);
		}

		ArcTemplate arc = element as ArcTemplate;
		if (arc != null)
		{
			if (arc.SweepAngle == 360)
			{
				AddRect(points, arc.Bounds);
			}
			else
			{
				GraphicsPath path = new GraphicsPath();
				path.AddArc(arc.Bounds, arc.StartAngle, arc.SweepAngle);
				AddPoint(points, path.PathPoints[0]);
				AddPoint(points, path.PathPoints[path.PathPoints.Length - 1]);
				path.Dispose();
			}
		}

		RoundRectangleTemplate roundRect = element as RoundRectangleTemplate;
		if (roundRect != null)
		{
			AddRect(points, roundRect.Bounds);
		}
	}

	if (points[0] == points[points.Count - 1])
		points.RemoveAt(points.Count - 1);
	return points;
}

void AddRect(List<PointF> points, RectangleF r)
{
	AddPoint(points, r.X + r.Width / 2, r.Top);
	AddPoint(points, r.Right, r.Y + r.Height / 2);
	AddPoint(points, r.X + r.Width / 2, r.Bottom);
	AddPoint(points, r.Left, r.Y + r.Height / 2);
}

void AddPoint(List<PointF> points, float x, float y)
{
	AddPoint(points, new PointF(x, y));
}

void AddPoint(List<PointF> points, PointF point)
{
	if (points.Count == 0 || points[points.Count - 1] != point)
		points.Add(point);
}
 

I hope that helps,
Stoyan

I just thought of something I might as well ask: what do you think would be the easiest way to figure out which element(s) in a Shape outline correspond to which 'sides' of the shape?

I haven't started coding this yet, but the obvious solution is to first loop through all the elements in the shape and sort/classify them (probably based on start and end points of each element), and then deriving the anchorpoints for each 'side' individually instead of doing a foreach loop over the entire shape.Outline collection.

'Sorting' the shape elements into 'sides' seems like a messy and potentially problematic solution, though, especially for things like ellipses. Can you think of a better way?

What I specifically need to do is have one incoming anchor in the (vertical) center of the left side; another incoming anchor in the (horizontal) middle of the top; one outgoing anchor in the (vertical) center of the right side; and a variable number of outgoing links evenly spaced along the bottom.

Another idea just occurred to me -- I could determine the center point of the shape, create imaginary lines out from that point in the directions I desire, and then find intersections between those lines and the elements in shape.Outline. Would that be a good solution? I just looked through the documentation a little and haven't found any easy way of finding the intersection point between a line and one of the shape outline elements, though I could just code that myself if necessary.

That sounds like it should work perfectly.

Thanks for your help!

It seems this method looks for the intersection point of the shape outline with the segment defined by the two points, and not the line defined by them. So one of the points should be from outside the shape and the other one should be inside for this to work. I suppose this might also fail if the segments coincide only at one end point, depending on some precision errors in the floating point operations used.

Instead of node.GetIntersection, try using the Utilities.LineIntersect method. It finds the intersection point of the lines defined by two pairs of points, so you will need to loop over the points that define the node outline and call it for each line segment.

I hope that helps,
Stoyan