Monitor Simulator

How we calculate

All results follow from simple geometry and the hold time of each frame. This page lists the formulas, the assumptions behind them and where the approximations reach their limits.

All results on this site follow from geometry and the hold time of each frame. There is no measured data of individual products, only class values. The formulas are implemented as pure functions in the source code and tested against hand-calculated examples.

Assumptions for all calculations

We calculate lengths in centimetres, diagonals in inches (1″ = 2.54 cm) and angles in degrees. The screen is flat, pixels are square, and your eye sits centred in front of the screen.

Sharpness: pixels per degree

An eye with 20/20 vision resolves one arcminute, which equals 60 pixels per degree. Good young eyes reach 75 to 100 PPD. The eye still sees edges and jaggies above that (hyperacuity), so we do not claim a hard limit.

The simple formula holds in the screen centre. Towards the edges the value rises, because the edges are farther away and seen at an angle.

  • p = diagonal / √(width_px² + height_px²)
  • PPI = 2.54 / p[cm]
  • θ = 2 · atan(p / 2d), PPD = 1° / θ
  • PPD at offset x = (d² + x²) / (d · p) · π/180
  • Field of view = 2 · atan(width / 2d)
  • Distance for target PPD: d = p / (2 · tan(θ/2)) with θ = 1° / PPD

Motion blur

We assume your eye tracks the object perfectly. Each frame stands still for the hold time and smears on the retina by the distance your gaze travels in that time. Measured in visual angle, resolution cancels out.

We model LCD response time as a linear ramp: the usual GtG figure only covers 10 to 90 percent of the transition, so the full ramp is 1/0.8 times as long. Class values: IPS 5 ms, VA 9 ms, OLED 0.1 ms. We do not model overdrive overshoot or different transitions (bright→dark, dark→bright).

With strobing, each frame lights up for only about 1 ms. The pixel transition happens in the dark phase and adds no blur. If fps are below the refresh rate, each frame flashes several times. That causes double images, which we only flag.

The comparison images are blurred in linear light (sRGB → linear → convolution → sRGB), because the eye sums up light, not sRGB values. The blur kernel is a trapezoid: hold time convolved with the response ramp.

  • Hold time = 1 / min(fps, Hz), with strobing: pulse width
  • Blur [px] = v [px/s] · hold time
  • Blur [°] = ω [°/s] · hold time
  • Ramp = GtG(10–90 %) / 0.8
  • Camera turn: v = f · ω with f = (width_px / 2) / tan(game FOV / 2)

Viewing distance and size

A horizontal field of view of 40 to 50 degrees counts as comfortable, based on 16:9. A 27-inch screen at 70 cm (28 in) sits right in the middle at 46 degrees. 21:9 and 32:9 keep the height of the 16:9 screen and only get wider.

We recommend the smallest common resolution of the format that reaches the sharpness target in the screen centre at the middle size.

  • Width = 2 · d · tan(field of view / 2)
  • Diagonal = width · √(1 + 1/r²) with r = width / height
  • Pixels needed = width / p with p = 2 · d · tan(θ/2)