Actually it must be
points = pixels * 96 / 72
Height lines converted into points and pixel (my own formula). Here is an example with a manual entry of 213.67 points in the Row Height field:
213.67 Manual Entry
0.45 Add 0.45
214.12 Subtotal
213.75 Round to a multiple of 0.75
213.00 Subtract 0.75 provides manual entry converted by Excel
284.00 Divide by 0.75 gives the number of pixels of height
Here the manual entry of 213.67 points gives 284 pixels.
Here the manual entry of 213.68 points gives 285 pixels.
(Why 0.45? I do not know but it works.)
Assuming 96dpi is a huge mistake. Even if the assumption is right, there's also an option to scale fonts. So a font set for 10pts may actually be shown as if it's 12.5pt (125%).
points = (pixels / 96) * 72 on a standard XP/Vista/7 machine (factory defaults)
points = (pixels / 72) * 72 on a standard Mac running OSX (Factory defaults)
Windows runs as default at 96dpi (display) Macs run as default at 72 dpi (display)
72 POSTSCRIPT Points = 1 inch 12 POSTSCRIPT Points = 1 POSTSCRIPT Pica 6 POSTSCRIPT Picas = 72 Points = 1 inch
1 point = 1/72 inches = 25.4/72 mm = 0.3527 mm
DPI = Dots Per Inch PPI = Pixels Per Inch LPI = Lines per inch
More info if using em as measuring
16px = 1em (default for normal text) 8em = 16px * 8 Pixels/16 = em
This works:
int pixels = (int)((dp) * Resources.System.DisplayMetrics.Density + 0.5f);
WPF converts points to pixels with the System.Windows.FontSizeConverter. The FontSizeConverter uses the System.Windows.LengthConverter. The LengthConverter uses the factor 1.333333333333333333 to convert from points (p) to pixels (x): x = p * 1.3333333333333333
Starting with the given:
If you want to find points (pt) based on pixels (px):
72 pt x pt
------ = ----- (1) for 150dpi system
150 px y px
Rearranging:
x = (y/150) * 72 (2) for 150dpi system
so:
points = (pixels / 150) * 72 (3) for 150dpi system
Try this if your code lies in a form:
Graphics g = this.CreateGraphics();
points = pixels * 72 / g.DpiX;
g.Dispose();
Using wxPython on Mac to get the correct DPI as follows:
from wx import ScreenDC
from wx import Size
size: Size = ScreenDC().GetPPI()
print(f'x-DPI: {size.GetWidth()} y-DPI: {size.GetHeight()}')
This yields:
x-DPI: 72 y-DPI: 72
Thus, the formula is:
points: int = (pixelNumber * 72) // 72
Surely this whole question should be:
"How do I obtain the horizontal and vertical PPI (Pixels Per Inch) of the monitor?"
There are 72 points in an inch (by definition, a "point" is defined as 1/72nd of an inch, likewise a "pica" is defined as 1/72nd of a foot). With these two bits of information you can convert from px to pt and back very easily.
System.Drawing.Graphics has DpiX and DpiY properties. DpiX is pixels per inch horizontally. DpiY is pixels per inch vertically. Use those to convert from points (72 points per inch) to pixels.
Ex: 14 horizontal points = (14 * DpiX) / 72 pixels
Source: Stackoverflow.com