¿Cómo puedo obtener el tamaño del monitor de mi computadora portátil?

¿Cuál es el comando Ubuntu Linux para encontrar el tamaño del monitor de la computadora portátil? Quiero saber en pulgadas si es posible.

Gracias

Otra opción, usando xrandr, es el comando:

xrandr | grep ' connected'

Salida:

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

(Cuidado con el espacio anterior connected, de lo contrario disconnectedse incluirá)

Diferencias importantes entre xdpyinfoyxrandr

• Mientras xrandrenumera las pantallas por separado (en el caso de varios monitores), xdpyinfogenera un único conjunto de dimensiones para todas las pantallas juntas ("tamaño de escritorio" en lugar de tamaño de pantalla)

• Como notó @agold, hay (bastante) una diferencia entre los dos, que parece demasiado grande para ser una simple diferencia de redondeo:

  xrandr: 473mm x 296mm
  xdpyinfo: 445x278
  

Parece relacionado con un error en xdpyinfo. Ver también aquí .

Si insistes en pulgadas

Use el pequeño script a continuación; genera el tamaño de su (s) pantalla (s) en pulgadas; ancho / alto / diagonal (pulgadas)

#!/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]])

Para usarlo:

Copie el script en un archivo vacío, guárdelo como get_dimensions.py, ejecútelo con el comando:

python3 /path/to/get_dimensions.py

Salida en mis dos pantallas:

width - height - diagonal (inches)

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

Editar

Versión elegante del mismo script (con algunas mejoras y una salida más agradable), que se ve así:

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

La secuencia de comandos:

#!/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 (mayo de 2019)

"Tipo de" a petición (en un comentario), una versión modernizada / más avanzada / mejorada (sin llamadas al sistema, sin análisis pero usando Gdk.Display), haciendo exactamente lo mismo:

#!/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]]))

Salida:

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

Dejaré la respuesta original, ya que parece inapropiado eliminar la respuesta después de tanto tiempo, que generó los votos existentes.

En caso de que quieras una respuesta más general, puedes cortar el nudo gordiano y usar una regla física no geek para eso. Según esta wiki , el "tamaño de una pantalla generalmente se describe por la longitud de su diagonal ":

Si tiene una regla que solo muestra centímetros , puede usar la conversión simple :

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

Entonces, si su regla mide 30 centímetros , su pantalla es de 11.811 pulgadas. También puede usar google con una consulta del formulario 30 cm to in.

Créditos de imagen: https://en.wikipedia.org/wiki/File:Display_size_measurements.png

Xdpyinfoes una utilidad para mostrar información sobre un servidor X. Se utiliza para examinar las capacidades de un servidor, los valores predefinidos para varios parámetros utilizados en la comunicación entre clientes y el servidor, y los diferentes tipos de pantallas y elementos visuales disponibles.

El comando para obtener el tamaño del monitor es:

xdpyinfo | grep dimensions

Resultado

dimensions:    1366x768 pixels (361x203 millimeters)

Esto era algo con lo que yo también estaba luchando (cuando quería actualizarme a un nuevo monitor y quería saber qué tamaño tenía mi monitor anterior), así que escribí un script de shell que encuentra el tamaño del monitor para usted.

Utilicé el xdpyinfode la primera respuesta para obtener las dimensiones de la pantalla y desarrollé con anticipación. El script esencialmente calcula la diagonal de las dimensiones de la pantalla, la conversión de milímetros a pulgadas y muestra el resultado.

URL del repositorio: https://github.com/abhishekvp/WhatsMyScreenSize

¡Espero que esto ayude!