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

42

¿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

usuario111
fuente
Hola usuario111, mira esto: meta.askubuntu.com/q/15051/72216 . ¿Podría proporcionar al menos algunos comentarios?
Jacob Vlijm

Respuestas:

47

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.

Jacob Vlijm
fuente
Solo una nota al margen, pero ambas respuestas me dan resultados diferentes: xdpyinfome da "474x303 milímetros" y xrandr"473 mm x 296 mm".
Agold
1
@agold Ahora que es interesante. Una diferencia de redondeo. ¡Otra cosa interesante es que xdpyinfogenera el tamaño del escritorio (ambas pantallas), no el tamaño de la pantalla!
Jacob Vlijm
¡@agold la diferencia es demasiado grande para una diferencia de redondeo! Mira mi edición.
Jacob Vlijm
sí, es bastante grande, pero ¿cómo obtienen estos programas esta información? ¿Se trata de alguna metainformación proveniente del monitor o se estima en función de otros parámetros ...?
Agold
@agold Parece estar relacionado con un error en xdpyinfo: bugs.launchpad.net/ubuntu/+source/xorg-server/+bug/201491 AL Aunque el informe es bastante antiguo, no lo veo solucionado. Ver también: bbs.archlinux.org/viewtopic.php?id=204823
Jacob Vlijm
14

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 ":

ingrese la descripción de la imagen aquí

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

phresnel
fuente
Ask Ubuntu es un sitio para soluciones de software, por lo que su respuesta está un poco fuera de tema aquí ... Por otro lado, ¡es correcta, bien escrita, muy legible y divertida! :-) ¡ Tan votado!
Fabby
1
@ dn-ʞɔɐqɹW: En realidad, se basa en un error de mi parte. Leí la pregunta, "¿Cómo puedo obtener el tamaño del monitor de mi computadora portátil?", Y mi primer pensamiento fue "bueno, con una regla", y antes de leer la pregunta completa, obtuve mi respuesta tallada en el bloque de piedra.
phresnel
Como nota al margen, una pulgada equivale a 25,4 mm exactamente.
Paddy Landau
6

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)
Parto
fuente
1
Hola Parto, me gusta mucho tu respuesta +1, sin embargo, mira aquí: bbs.archlinux.org/viewtopic.php?id=204823 hay una gran diferencia en los xdpyinfoinformes de dimensiones y xrandr.
Jacob Vlijm
@Jacob Algo interesante - askubuntu.com/questions/378386/…
Parto
1
Cuando se mide con una buena calidad física vieja cinta métrica, recibo en mi pantalla casi exactamente la salida xrandr: 473mm, mientras que xdpyinfolos informes de manera demasiado corto ( 445mm). Esta pregunta resulta ser más interesante de lo que OP asumió, supongo :)
Jacob Vlijm
0

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!

Abhishek Potnis
fuente