Resolución de pantalla vs coordenadas: cómo cambia el número de píxeles tu posición X/Y
Tu pantalla — detectada automáticamente:
Mueve el ratón a la coordenada (960, 540) en un monitor de 1080p y estarás justo en el centro. Haz lo mismo en una pantalla 4K y aterrizarás en el cuadrante superior izquierdo, apenas a un cuarto del recorrido. Mismos números, punto completamente distinto de la pantalla.
La mayoría de comparativas de resolución hablan de cantidades de píxeles y relaciones de aspecto. Esta es diferente: vamos a examinar cómo cambia el sistema de coordenadas en sí al pasar de 720p a 4K — qué se desplaza, qué se rompe y por qué tus scripts de automatización dejan de funcionar. Los valores reales de tu pantalla están detectados arriba.
Abrir herramienta gratuita de coordenadas de pantallaEl sistema de coordenadas de tu pantalla — en vivo
Cada pantalla es una cuadrícula de píxeles, y cada píxel tiene una dirección única (X, Y). La esquina superior izquierda siempre es (0, 0). La esquina inferior derecha es (anchura − 1, altura − 1). A continuación se muestran las coordenadas lógicas que tu navegador reporta (pueden diferir de los píxeles físicos si el escalado DPI está activo — consulta la caja superior para ver ambos):
Estos números son las coordenadas en vivo de tu pantalla. Mueve esta página a otro monitor, o cambia tu resolución, y los valores se actualizarán. Pruébalo — la diferencia entre la teoría y tu pantalla real es lo que hace que trabajar con coordenadas sea complicado. Usa nuestra herramienta de coordenadas de pantalla para rastrear la posición de tu ratón en todo este espacio de coordenadas en tiempo real.
Tabla comparativa de resoluciones: píxeles, coordenadas y precisión
Aquí tienes la tabla de referencia para cada resolución habitual — cantidad de píxeles, rango de coordenadas, punto central y PPI típico. Guárdala si escribes scripts de automatización, configuras overlays en OBS o preparas layouts de juegos.
| Resolución | Nombre | Total de píxeles | Rango de coordenadas | Centro | PPI típico |
|---|---|---|---|---|---|
| 1280×720 | 720p (HD) | 921.600 | (0,0) – (1279,719) | (640, 360) | ~60 |
| 1366×768 | — | 1.049.088 | (0,0) – (1365,767) | (683, 384) | ~100 |
| 1920×1080 | 1080p (Full HD) | 2.073.600 | (0,0) – (1919,1079) | (960, 540) | ~92 |
| 2560×1440 | 1440p (QHD) | 3.686.400 | (0,0) – (2559,1439) | (1280, 720) | ~109 |
| 3440×1440 | Ultrawide QHD | 4.953.600 | (0,0) – (3439,1439) | (1720, 720) | ~109 |
| 3840×2160 | 4K (UHD) | 8.294.400 | (0,0) – (3839,2159) | (1920, 1080) | ~140 |
Dato a tener en cuenta: Si duplicas la resolución en ambas direcciones (1080p a 4K), cuadruplicas el total de píxeles. El punto central también se duplica — (960, 540) pasa a ser (1920, 1080).
Mismo punto, coordenadas distintas: cómo se mueve (960, 540)
La coordenada (960, 540) es el centro exacto de una pantalla de 1080p. Pero, ¿qué le pasa a esa misma posición física cuando cambias la resolución?
| Resolución | Qué significa (960, 540) | Posición en pantalla |
|---|---|---|
| 1280×720 | 75 % de ancho, 75 % de alto | Zona inferior derecha — nada cerca del centro |
| 1920×1080 | 50 % de ancho, 50 % de alto | Centro exacto |
| 2560×1440 | 37,5 % de ancho, 37,5 % de alto | Cuadrante superior izquierdo |
| 3840×2160 | 25 % de ancho, 25 % de alto | Lejos en la zona superior izquierda — solo a un cuarto del recorrido |
Esto sorprende a mucha gente. Si codificas (960, 540) como "centro" en tu script, fallará en cualquier resolución que no sea 1080p. La solución es sencilla: calcula las coordenadas relativas a la resolución actual:
// En lugar de codificar valores fijos:
click(960, 540); // solo funciona en 1080p!
// Calcula el centro dinámicamente:
centerX = screen.width / 2;
centerY = screen.height / 2;
click(centerX, centerY); // funciona en cualquier resoluciónEl mismo principio aplica a las configuraciones multimonitor, donde el sistema de coordenadas se extiende a través de varias pantallas — el "centro" depende del monitor que estés usando.
Cuánto espacio de coordenadas roba la barra de tareas
La barra de tareas de Windows tiene entre 40 y 48 píxeles de alto, según el escalado. Parece poco, pero en una pantalla de baja resolución es un buen trozo de tu espacio útil:
| Resolución | Altura de pantalla | Píxeles de la barra | Altura perdida | Rango de coordenadas útil |
|---|---|---|---|---|
| 1280×720 | 720px | ~40px | 5,6 % | Y: 0 – 679 |
| 1920×1080 | 1080px | ~40px | 3,7 % | Y: 0 – 1039 |
| 2560×1440 | 1440px | ~48px | 3,3 % | Y: 0 – 1391 |
| 3840×2160 | 2160px | ~48px | 2,2 % | Y: 0 – 2111 |
Qué significa esto en la práctica: En una pantalla de 720p con la barra de tareas abajo, el centro útil se desplaza unos 20 píxeles hacia arriba — de (640, 360) a aproximadamente (640, 340). Si necesitas clics con precisión de píxel, no te olvides de restar la barra de tareas.
macOS tiene su propio enfoque: la barra de menú ocupa permanentemente entre 25 y 30 píxeles en la parte superior (a menos que la ocultes automáticamente). En un MacBook con notch, la barra de menú es aún más alta. Todos estos son coordenadas que pierdes del espacio útil.
Precisión de coordenadas: por qué 4K te da precisión submilimétrica
En un monitor de 24 pulgadas a 1080p, cada píxel mide aproximadamente 0,28 mm de ancho. Cuando haces clic en la coordenada (500, 300), tu cursor aterriza en algún punto dentro de un cuadrado de 0,28 mm. Pasa a un monitor de 27 pulgadas a 4K y cada píxel se reduce a unos 0,16 mm — casi la mitad. (En un 4K de 24 pulgadas, más pequeño pero más denso, los píxeles son aún más diminutos: ~0,14 mm.)
| Resolución | Tamaño del monitor | Tamaño del píxel (aprox.) | Error de 1 píxel = |
|---|---|---|---|
| 1280×720 | 24" | 0,42 mm | Visible a simple vista |
| 1920×1080 | 24" | 0,28 mm | Apenas visible |
| 2560×1440 | 27" | 0,23 mm | Detalle subpíxel |
| 3840×2160 | 24" | 0,14 mm | Invisible sin aumento |
| 3840×2160 | 27" | 0,16 mm | Invisible sin aumento |
| 3840×2160 | 32" | 0,18 mm | Casi calidad de impresión |
Para la mayoría de tareas, 1080p es suficientemente preciso. Pero si estás calibrando un eye tracker, trabajando con pantallas médicas o escribiendo automatización pixel-perfect, la resolución extra marca una diferencia real. El problema es que no todos los píxeles son iguales: algunos son "físicos" y otros son "lógicos", y confundirlos es lo que rompe tus scripts. Más sobre esto en nuestra guía de píxeles físicos vs lógicos.
Qué significa esto para la automatización y la precisión de los clics
Si escribes scripts que hacen clic en posiciones específicas de la pantalla — PyAutoGUI, AutoHotkey, Selenium, lo que sea — la resolución es el factor más importante para que tu script funcione realmente:
- Las coordenadas fijas se rompen en resoluciones diferentes. Un clic en (960, 540) acierta en el centro a 1080p pero falla en todo lo demás.
- El escalado DPI añade una segunda capa de confusión. Un monitor 4K al 150 % de escalado, por ejemplo, reporta 2560×1440 a la mayoría de aplicaciones — tu script ve un espacio de coordenadas, el sistema operativo usa otro. Consulta nuestra guía de escalado DPI y coordenadas para la solución.
- Las configuraciones multimonitor lo complican aún más. Si tu monitor secundario tiene una resolución distinta al principal, la misma coordenada se mapea a un punto físico diferente en cada pantalla. La guía de coordenadas multimonitor tiene los cálculos.
Regla de oro: nunca codifiques coordenadas de píxel fijas. Consulta el tamaño de pantalla en tiempo de ejecución y calcula las posiciones como porcentajes. Tus scripts funcionarán en cualquier resolución.
# Ejemplo en Python: clic independiente de la resolución
import ctypes, pyautogui
# Hacer que PyAutoGUI vea los píxeles reales (consciente del DPI)
ctypes.windll.user32.SetProcessDPIAware()
# Calcular el centro de la pantalla actual
w, h = pyautogui.size()
center_x, center_y = w // 2, h // 2
pyautogui.click(center_x, center_y)Para la solución completa de PyAutoGUI que cubre escalado DPI, multimonitor y offsets de región de captura, consulta nuestra guía de coordenadas con PyAutoGUI.
Preguntas frecuentes
¿Un monitor más grande cambia mis coordenadas?
No. Las coordenadas las determina la resolución, no el tamaño físico. Un monitor de 24 pulgadas a 1080p y uno de 32 pulgadas a 1080p tienen el mismo rango de coordenadas: (0, 0) a (1919, 1079). Simplemente los píxeles son físicamente más grandes en la pantalla de 32 pulgadas.
¿Por qué mi script hace clic en el sitio equivocado después de cambiar la resolución?
Porque tu script usa coordenadas calibradas para una resolución en una resolución diferente. La coordenada (960, 540) es el centro de una pantalla de 1080p pero solo el 25 % del recorrido en una pantalla 4K. Siempre recalcula las posiciones relativas a la resolución actual.
¿Qué resolución debo usar para testing de automatización?
Usa la resolución que tus usuarios objetivo tengan más probabilidad de usar. Eso sigue siendo 1920×1080 para la mayoría de usuarios de escritorio. Si testas para diseñadores o desarrolladores, 2560×1440 es la siguiente más común. Siempre prueba en al menos dos resoluciones para detectar coordenadas fijas problemáticas.
¿Los juegos usan coordenadas de pantalla igual que el escritorio?
En su mayoría, sí. Los juegos en pantalla completa usan el sistema de coordenadas de la resolución completa. Pero los juegos en ventana sin bordes pueden usar la resolución del escritorio, y algunos motores aplican su propio escalado interno. Por eso los overlays de juegos (puntos de mira, minimapas) a veces aparecen desplazados — el overlay y el juego usan sistemas de coordenadas diferentes.
¿Cómo obtengo mi resolución de pantalla actual programáticamente?
En JavaScript: screen.width y screen.height. En Python: pyautogui.size(). En AutoHotkey v2: A_ScreenWidth y A_ScreenHeight. Ten en cuenta que todos estos pueden devolver la resolución lógica (escalada) si no tienes activada la conciencia de DPI — consulta nuestra guía de escalado DPI para más detalles.