How can I get my laptop's monitor size?

Question

What is the Ubuntu linux command to find laptop monitor size? I want to know in inches if possible.

Thanks

Answer 1

Another option, using xrandr, is the command:

xrandr | grep ' connected'

Output:

DVI-I-1 connected primary 1680x1050+0+0 (normal left inverted right x axis y axis) 473mm x 296mm
VGA-1 connected 1280x1024+1680+0 (normal left inverted right x axis y axis) 376mm x 301mm

(mind the space before connected, else disconnected will be included)

Important differences between xdpyinfo and xrandr

• While xrandr lists screens separately (in case of multiple monitors), xdpyinfo outputs one single set of dimensions for all screens together ("desktop size" instead of screen size)

• As noticed by @agold there is (quite) a difference between the two, which seems too big to be a simple rounding difference:

  xrandr: 473mm x 296mm
  xdpyinfo: 445x278
  

It seems related to a bug in xdpyinfo. See also here.

If you'd insist on inches

Use the small script below; it outputs the size of your screen(s) in inches; width / height / diagonal (inches)

#!/usr/bin/env python3
import subprocess
# change the round factor if you like
r = 1

screens = [l.split()[-3:] for l in subprocess.check_output(
    ["xrandr"]).decode("utf-8").strip().splitlines() if " connected" in l]

for s in screens:
    w = float(s[0].replace("mm", "")); h = float(s[2].replace("mm", "")); d = ((w**2)+(h**2))**(0.5)
    print([round(n/25.4, r) for n in [w, h, d]])

To use it:

Copy the script into an empty file, save it as get_dimensions.py, run it by the command:

python3 /path/to/get_dimensions.py

Output on my two screens:

width - height - diagonal (inches)

[18.6, 11.7, 22.0]
[14.8, 11.9, 19.0]

---

Edit

Fancy version of the same script (with a few improvements and a nicer output), looking like:

Screen  width   height  diagonal
--------------------------------
DVI-I-1 18.6    11.7    22.0
VGA-1   14.8    11.9    19.0

The script:

#!/usr/bin/env python3
import subprocess
# change the round factor if you like
r = 1

screens = [l.split() for l in subprocess.check_output(
    ["xrandr"]).decode("utf-8").strip().splitlines() if " connected" in l]

scr_data = []
for s in screens:
    try:
        scr_data.append((
            s[0],
            float(s[-3].replace("mm", "")),
            float(s[-1].replace("mm", ""))
            ))
    except ValueError:
        pass

print(("\t").join(["Screen", "width", "height", "diagonal\n"+32*"-"]))
for s in scr_data:
    scr = s[0]; w = s[1]/25.4; h = s[2]/25.4; d = ((w**2)+(h**2))**(0.5)
    print(("\t").join([scr]+[str(round(n, 1)) for n in [w, h, d]]))

---

EDIT 2 (May 2019)

"Kind of" on request (in a comment), a modernized / more advanced / improved (no system calls, no parsing but using Gdk.Display) version, doing pretty much exactly the same:

#!/usr/bin/env python3
import gi
gi.require_version('Gdk', '3.0')
from gi.repository import Gdk

dsp = Gdk.Display.get_default()
n_mons = dsp.get_n_monitors()

print(("\t").join(["Screen", "width", "height", "diagonal\n"+32*"-"]))

for i in range(n_mons):
    mon = dsp.get_monitor(i)
    mon_name = mon.get_model()
    w = mon.get_width_mm()/25.4
    h = mon.get_height_mm()/25.4
    d = ((w**2)+(h**2))**(0.5)
    print(("\t").join([mon_name]+[str(round(n, 1)) for n in [w, h, d]]))

Output:

Screen  width   height  diagonal
--------------------------------
eDP-1   20.0    11.3    23.0
HDMI-1  18.6    11.7    22.0

I will leave the original answer, since it seems inappropriate to remove the answer after such a long time, that generated the existing votes.

Answer 2

How'bout this :

xrandr | awk '/ connected/{print sqrt( ($(NF-2)/10)^2 + ($NF/10)^2 )/2.54" inches"}'

and through SSH :

ssh server DISPLAY=:0 xrandr | awk '/ connected/{print sqrt( ($(NF-2)/10)^2 + ($NF/10)^2 )/2.54" inches"}'

Answer 3

Just in case you want a more general answer, you can cut the the gordian knot, and use a non-geeky physical ruler for that. As per this wiki, the "size of a screen is usually described by the length of its diagonal":

If you have a ruler that only displays centimeters, you can use the simple conversion:

1 cm = 0.393701 in
(or 2.54 cm = 1 in)

So if your ruler measures 30 centimeters, your screen is 11.811 inches. You can also use google with a query of the form 30 cm to in.

---

Image credits: https://en.wikipedia.org/wiki/File:Display_size_measurements.png

Answer 4

Xdpyinfo is a utility for displaying information about an X server. It is used to examine the capabilities of a server, the predefined values for various parameters used in communicating between clients and the server, and the different types of screens and visuals that are available.

The command to get the monitor size is:

xdpyinfo | grep dimensions

Result

dimensions:    1366x768 pixels (361x203 millimeters)

Answer 5

This was something that I too was struggling with(when I wanted to upgrade to a new monitor for myself and wanted to know what size my old monitor was), so I wrote a shell script that finds the monitor size for you.

I used the xdpyinfo from the first answer to get the screen dimensions and built ahead on it. The script essentially computes the diagonal from the screen dimensions, converting from millimeters to inches and displays the result.

Repository URL: https://github.com/abhishekvp/WhatsMyScreenSize

Hope this helps!