# Useful Extension Methods for Points and friends in WPF

Every once in a while you may be down to low-level element calculation and placement of elements in WPF. For this situation, I have found the following extension methods quite useful:

### Translating a point

public static Point Translate(this Point p, Func<Point,Tuple<double,double>> translateFunction) { var points = translateFunction(p); return new Point(p.X + points.Item1, p.Y + points.Item2); } public static Point Translate(this Point p, Vector translation) { return p.Translate(po => Tuple.Create(translation.X, translation.Y)); } public static Point Translate(this Point p, double xOffset, double yOffset) { return p.Translate(po=>Tuple.Create(xOffset, yOffset)); } public static Point TranslateX(this Point p, double xOffset) { return p.Translate(xOffset, 0); } public static Point TranslateY(this Point p, double yOffset) { return p.Translate(0, yOffset); }

The first method is a low level application of a double-tuple as offset to a given point. All others use this method to create a new point from an old point and some additional info. Some examples:

var p = new Point(0,0); p2 = p.TranslateY(10); //10 pixels to the right p3 = p2.Translate(10); //New point at 10,10 p4 = p3.Translate(new Vector(10,10)); //New point at 20,20

### Point Sources

A point source is an object that implements IEnumerable<Point>. One type of Poiint Source I have used is one that takes a seed point and to which you can provide a function how to get from previous to the next point. the following example uses this class to be able to iterate over equal-spaced points along the vertical axis:

var psource = new PointSource(new Point(10, 10), p => p.TranslateY(10)); var points = psource.Take(5).ToArray() // 10,10 ; 10,20 ; 10,30 ...

By entering the IEnumerable realm, you open your code to all the shiny LINQiness there is out there.

### Arcs and the like

In WPF you can work with vectors and matrices. That gives you a nice base to implement a “Rotate” method:

public static Vector Rotate(this Vector origin, double angle) { var cos = Math.Cos(angle); var sin = Math.Sin(angle); var rotationMatrix = new Matrix(cos, -sin, sin, cos, 0, 0); return origin * rotationMatrix; }

In combination with a different point source that takes an IEnumerable<T> and provides a conversion to an IEnumerable<Point> you can create arcs and circles of points quite easily:

var radius = new Vector(0.0, 10.0); var angleToRadians = Math.PI / 180.0; var midpoint = new Point(20,20); var translationVectors = from step in Enumerable.Range(0, 360) let angle = step * angleToRadians select radius.Rotate(angle); var ps = new PointSource<Vector>(translationVectors, v => midpoint.Translate(v)); ps.Take(45); // Gives 45 points over 45 degrees, each with a radius of 10

Note that above, you could also get the functionality by using the LINQ-Select on the list of vectors. Also note the lazy nature of all involved items. If you only need 45 items, that’s all that is calculated.

I am just thinking of putting this kind of stuff into a small library to help dealing with that low-level stuff, which can be useful for Custom arrangers and the like. I am wondering what else could be in that library…or maybe there is already one?