How do I convert a WPF size to physical pixels?

Solution 1:

Transforming a known size to device pixels

If your visual element is already attached to a PresentationSource (for example, it is part of a window that is visible on screen), the transform is found this way:

var source = PresentationSource.FromVisual(element);
Matrix transformToDevice = source.CompositionTarget.TransformToDevice;

If not, use HwndSource to create a temporary hWnd:

Matrix transformToDevice;
using(var source = new HwndSource(new HwndSourceParameters()))
  transformToDevice = source.CompositionTarget.TransformToDevice;

Note that this is less efficient than constructing using a hWnd of IntPtr.Zero but I consider it more reliable because the hWnd created by HwndSource will be attached to the same display device as an actual newly-created Window would. That way, if different display devices have different DPIs you are sure to get the right DPI value.

Once you have the transform, you can convert any size from a WPF size to a pixel size:

var pixelSize = (Size)transformToDevice.Transform((Vector)wpfSize);

Converting the pixel size to integers

If you want to convert the pixel size to integers, you can simply do:

int pixelWidth = (int)pixelSize.Width;
int pixelHeight = (int)pixelSize.Height;

but a more robust solution would be the one used by ElementHost:

int pixelWidth = (int)Math.Max(int.MinValue, Math.Min(int.MaxValue, pixelSize.Width));
int pixelHeight = (int)Math.Max(int.MinValue, Math.Min(int.MaxValue, pixelSize.Height));

Getting the desired size of a UIElement

To get the desired size of a UIElement you need to make sure it is measured. In some circumstances it will already be measured, either because:

1. You measured it already
2. You measured one of its ancestors, or
3. It is part of a PresentationSource (eg it is in a visible Window) and you are executing below DispatcherPriority.Render so you know measurement has already happened automatically.

If your visual element has not been measured yet, you should call Measure on the control or one of its ancestors as appropriate, passing in the available size (or new Size(double.PositivieInfinity, double.PositiveInfinity) if you want to size to content:

element.Measure(availableSize);

Once the measuring is done, all that is necessary is to use the matrix to transform the DesiredSize:

var pixelSize = (Size)transformToDevice.Transform((Vector)element.DesiredSize);

Putting it all together

Here is a simple method that shows how to get the pixel size of an element:

public Size GetElementPixelSize(UIElement element)
{
  Matrix transformToDevice;
  var source = PresentationSource.FromVisual(element);
  if(source!=null)
    transformToDevice = source.CompositionTarget.TransformToDevice;
  else
    using(var source = new HwndSource(new HwndSourceParameters()))
      transformToDevice = source.CompositionTarget.TransformToDevice;

  if(element.DesiredSize == new Size())
    element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));

  return (Size)transformToDevice.Transform((Vector)element.DesiredSize);
}

Note that in this code I call Measure only if no DesiredSize is present. This provides a convenient method to do everything but has several deficiencies:

1. It may be that the element's parent would have passed in a smaller availableSize
2. It is inefficient if the actual DesiredSize is zero (it is remeasured repeatedly)
3. It may mask bugs in a way that causes the application to fail due to unexpected timing (eg. the code being called at or above DispatchPriority.Render)

Because of these reasons, I would be inclined to omit the Measure call in GetElementPixelSize and just let the client do it.

Solution 2:

Simple proportion between Screen.WorkingArea and SystemParameters.WorkArea:

private double PointsToPixels (double wpfPoints, LengthDirection direction)
{
    if (direction == LengthDirection.Horizontal)
    {
        return wpfPoints * Screen.PrimaryScreen.WorkingArea.Width / SystemParameters.WorkArea.Width;
    }
    else
    {
        return wpfPoints * Screen.PrimaryScreen.WorkingArea.Height / SystemParameters.WorkArea.Height;
    }
}

private double PixelsToPoints(int pixels, LengthDirection direction)
{
    if (direction == LengthDirection.Horizontal)
    {
        return pixels * SystemParameters.WorkArea.Width / Screen.PrimaryScreen.WorkingArea.Width;
    }
    else
    {
        return pixels * SystemParameters.WorkArea.Height / Screen.PrimaryScreen.WorkingArea.Height;
    }
}

public enum LengthDirection
{
    Vertical, // |
    Horizontal // ——
}

This works fine with multiple monitors as well.

Solution 3:

I found a way to do it, but I don't like it much:

using (var graphics = Graphics.FromHwnd(IntPtr.Zero))
{
    var pixelWidth = (int) (element.DesiredSize.Width * graphics.DpiX / 96.0);
    var pixelHeight = (int) (element.DesiredSize.Height * graphics.DpiY / 96.0);
    // ...
}

I don't like it because (a) it requires a reference to System.Drawing, rather than using WPF APIs; and (b) I have to do the math myself, which means I'm duplicating WPF's implementation details. In .NET 3.5, I have to truncate the result of the calculation to match what ElementHost does with AutoSize=true, but I don't know whether this will still be accurate in future versions of .NET.

This does seem to work, so I'm posting it in case it helps others. But if anyone has a better answer, please, post away.