Programa el Recorte Perfecto de Imágenes a 1080x1920

Automatiza el redimensionado de imágenes para stories, reels y TikTok con soluciones de código.

Programa el Recorte Perfecto de Imágenes a 1080x1920

Por Jose Luis Rueda · 12 min lectura · 2026-07-19

Las pantallas de los smartphones han cambiado la manera de consumir contenido. Las historias de Instagram, los reels de Facebook, los videos de TikTok y YouTube Shorts imponen un formato vertical que ya es estándar. Esto obliga a reutilizar imágenes horizontales o cuadradas adaptándolas a una resolución específica: 1080x1920 píxeles. Para un profesional del desarrollo de contenido o un emprendedor que maneja cientos de assets diarios, el recorte manual se vuelve inviable. La automatización a través de código es la única salida.

En este artículo explorarás múltiples enfoques para recortar imágenes exactamente a 1080x1920 píxeles. Veremos desde scripts simples en Python usando Pillow, pasando por detección facial con OpenCV para recortes inteligentes, hasta implementaciones en el frontend con JavaScript. Además, conocerás cómo integrar estas soluciones en tu flujo de trabajo y cómo HolaGPT puede ayudarte a generar el código necesario en segundos.

No importa si eres un desarrollador que necesita implementar esta funcionalidad en una aplicación o un creador de contenido que quiere automatizar la producción de imágenes para redes: aquí tienes todas las herramientas. Vamos al código.

Por qué el formato vertical domina el contenido digital

El 92% de los usuarios de redes sociales accede desde dispositivos móviles. Un smartphone se sostiene de forma natural en posición vertical, lo que ha llevado a plataformas como Instagram, TikTok y YouTube a priorizar el video en formato 9:16. Las imágenes también se consumen en este formato: las stories tienen una duración de visualización un 35% mayor que las publicaciones cuadradas, según datos de Metricool. Esta tendencia no se limita al entretenimiento; marcas de todos los tamaños están adaptando su comunicación visual al vertical porque impacta directamente en las métricas de engagement.

Para un emprendedor, cada imagen publicada en el feed necesita también su versión vertical para stories o destacados. Un community manager puede llegar a procesar 50 imágenes diarias. El recorte a mano en Photoshop o Canva, aunque viable, no escala. La solución es programar un flujo de trabajo que tome la imagen original y la adapte automáticamente a 1080x1920 píxeles, manteniendo el foco en el elemento principal. Implementar esta automatización reduce errores humanos y libera horas de trabajo repetitivo.

Entendiendo las dimensiones: 1080x1920 píxeles

El formato 1080x1920 corresponde a una relación de aspecto de 9:16. Es decir, por cada 9 unidades de ancho, hay 16 de alto. Esta es la resolución Full HD en orientación vertical. Aunque puede variar según la plataforma (algunas aceptan 720x1280 o 1440x2560), 1080x1920 es el estándar de facto para contenido de alta calidad en stories y reels. Entender esta proporción es fundamental para cualquier sistema de recorte, porque define la región exacta que se conservará de la imagen original.

Cuando recortas una imagen, no solo cambias las dimensiones: también la composición. Una foto horizontal de 3840x2160 píxeles (4K) contiene mucha información a los lados que debes eliminar para encajar en un encuadre vertical. El desafío está en no cortar elementos importantes. Por eso, el recorte programático puede centrarse en el objeto principal mediante detección de rostros o análisis de saliencia. Un simple recorte central funciona en fotos con el sujeto al centro, pero falla en composiciones descentradas.

Recorte manual: atajos para tareas puntuales

Antes de sumergirnos en código, conviene reconocer que para trabajos puntuales las herramientas gráficas son útiles. Adobe Photoshop permite crear un lienzo de 1080x1920 y arrastrar la imagen, ajustando el encuadre con guías de composición. Canva ofrece plantillas prediseñadas para stories. Incluso el editor de fotos del teléfono recorta rápidamente. Un diseñador puede exportar hasta 10 imágenes por sesión con buena calidad.

Sin embargo, si necesitas procesar cientos de imágenes, aplicar el mismo criterio de recorte a todas, o integrar esta funcionalidad en un sistema más grande (por ejemplo, una plataforma de e-commerce que genera automáticamente imágenes para redes), el camino manual es una pesadilla. Ahí la programación se vuelve indispensable. Además, los scripts permiten auditar cada paso y replicar el proceso consistentemente.

Python y Pillow: recorte básico en segundos

Pillow es la librería más popular de manipulación de imágenes en Python. Te permite cargar, recortar y redimensionar imágenes con pocas líneas de código. Para instalar, ejecuta pip install pillow en tu entorno. Con ella puedes crear un script que reciba la imagen original y entregue la versión vertical sin intervención manual.

El siguiente script toma una imagen cualquiera, la recorta centrando el encuadre vertical y la guarda con resolución 1080x1920. Si la imagen original es más pequeña, primero la escala proporcionalmente usando el método LANCZOS, que mantiene una calidad óptima.

from PIL import Image

def crop_to_vertical(input_path, output_path, target_width=1080, target_height=1920):
    img = Image.open(input_path)
    original_width, original_height = img.size
    target_ratio = target_width / target_height
    original_ratio = original_width / original_height

    if original_ratio > target_ratio:
        # Imagen más ancha que la proporción objetivo: recortar los lados
        new_width = int(original_height * target_ratio)
        left = (original_width - new_width) // 2
        top = 0
        right = left + new_width
        bottom = original_height
    else:
        # Imagen más alta o igual: recortar arriba y abajo
        new_height = int(original_width / target_ratio)
        top = (original_height - new_height) // 2
        left = 0
        bottom = top + new_height
        right = original_width

    cropped = img.crop((left, top, right, bottom))
    resized = cropped.resize((target_width, target_height), Image.Resampling.LANCZOS)
    resized.save(output_path)
    print(f'Imagen guardada en {output_path}')

# Uso
crop_to_vertical('foto_horizontal.jpg', 'foto_vertical.jpg')

El código primero compara la relación de aspecto. Si la imagen original es más ancha que 9:16, recorta los laterales para ajustar el ancho y luego redimensiona. Si la imagen es más alta, recorta arriba y abajo. El resultado siempre es una imagen centrada y con las dimensiones exactas. Esta lógica cubre la mayoría de casos sencillos y se ejecuta en milisegundos.

Este enfoque funciona bien cuando el sujeto está centrado en la foto original. Pero, ¿qué pasa si el rostro de una persona queda a la izquierda o si el producto está descentrado? Ahí necesitamos inteligencia adicional.

Detección inteligente con OpenCV: centrar el objeto de interés

Para un recorte más profesional, podemos usar OpenCV con un clasificador en cascada de Haar para detectar rostros. Así, en lugar de cortar ciegamente el centro, el script buscará la cara y centrará el recorte en ella. Esto es clave en fotos de personas y le da un acabado mucho más cuidado a las imágenes de perfil o stories.

Instala OpenCV con pip install opencv-python. El siguiente código amplía el ejemplo anterior, detectando el primer rostro encontrado y ajustando el recorte para que la cara quede en el tercio superior (composición fotográfica), que es donde el ojo humano busca naturalmente.

import cv2
from PIL import Image

def smart_crop_vertical(input_path, output_path):
    # Cargar con OpenCV para detección
    img_cv = cv2.imread(input_path)
    gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(100, 100))

    img_pil = Image.open(input_path)
    width, height = img_pil.size
    target_ratio = 1080 / 1920

    if len(faces) > 0:
        # Tomar la primera cara detectada
        (x, y, w, h) = faces[0]
        face_center_x = x + w // 2
        face_center_y = y + h // 2
        # Queremos recorte que contenga la cara en el tercio superior
        crop_height = int(width / target_ratio) if (width / target_ratio) <= height else height
        crop_width = int(crop_height * target_ratio)
        desired_face_y = crop_height // 3
        offset_y = face_center_y - desired_face_y
        top = max(0, offset_y)
        bottom = top + crop_height
        if bottom > height:
            top = height - crop_height
            bottom = height
        left = max(0, face_center_x - crop_width // 2)
        right = left + crop_width
        if right > width:
            left = width - crop_width
            right = width
        cropped = img_pil.crop((left, top, right, bottom))
    else:
        # Fallback a recorte centrado
        original_ratio = width / height
        if original_ratio > target_ratio:
            new_width = int(height * target_ratio)
            left = (width - new_width) // 2
            top = 0
            right = left + new_width
            bottom = height
        else:
            new_height = int(width / target_ratio)
            top = (height - new_height) // 2
            left = 0
            bottom = top + new_height
            right = width
        cropped = img_pil.crop((left, top, right, bottom))

    resized = cropped.resize((1080, 1920), Image.Resampling.LANCZOS)
    resized.save(output_path)
    print(f'Imagen recortada guardada en {output_path}')

# Uso
smart_crop_vertical('persona_foto.jpg', 'persona_vertical.jpg')

Esta versión es más robusta para retratos. Puedes extenderla con otros clasificadores (perfiles, cuerpo completo) o incluso usar modelos de deep learning como YOLO para detectar múltiples tipos de objetos (productos, mascotas). La idea es siempre conocer dónde está el punto de interés antes de recortar, para que la versión final luzca profesional.

Automatización masiva con scripts y servicios en la nube

Los scripts anteriores son perfectos para procesar una carpeta completa de imágenes. Con una simple iteración, puedes transformar un batch entero en minutos. Imagina tener un evento con 500 fotos y necesitar sus versiones verticales para una galería en stories: este enfoque lo resuelve sin tocar el mouse.

import os
from pathlib import Path

input_folder = '/ruta/a/imagenes'
output_folder = '/ruta/a/salida'

os.makedirs(output_folder, exist_ok=True)

for filename in os.listdir(input_folder):
    if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
        input_path = os.path.join(input_folder, filename)
        output_path = os.path.join(output_folder, f'vertical_{filename}')
        smart_crop_vertical(input_path, output_path)  # o crop_to_vertical

¿Necesitas ejecutar esto periódicamente? Súbelo a un servicio en la nube como AWS Lambda o Google Cloud Functions. Puedes activarlo mediante un trigger de S3 cuando se suba una nueva imagen, y el resultado guardarlo en otra carpeta. De esta forma, tu sistema de gestión de contenido (CMS) se integra completamente. También puedes usar Cloudinary que ofrece recorte inteligente mediante parámetros en la URL: https://res.cloudinary.com/demo/image/upload/w_1080,h_1920,c_fill,g_auto/ejemplo.jpg recorta automáticamente usando IA para elegir el punto de interés. Esta solución es ideal si no quieres mantener tu propia infraestructura y prefieres delegar en servicios probados.

Recorte en el navegador usando JavaScript y Canvas

Si tu aplicación es web y quieres ofrecer una vista previa del recorte antes de subir la imagen, puedes usar la API Canvas de HTML5. El siguiente código toma un archivo seleccionado por el usuario, dibuja un rectángulo de recorte con la proporción 9:16 sobre la imagen y genera un blob descargable. Todo ocurre del lado del cliente, sin enviar datos al servidor.

const input = document.getElementById('imageInput');
const canvas = document.getElementById('previewCanvas');
const ctx = canvas.getContext('2d');

input.addEventListener('change', function(e) {
  const file = e.target.files[0];
  const img = new Image();
  img.onload = function() {
    const targetRatio = 1080 / 1920;
    let cropWidth, cropHeight;
    const imgRatio = img.width / img.height;

    if (imgRatio > targetRatio) {
      cropHeight = img.height;
      cropWidth = cropHeight * targetRatio;
    } else {
      cropWidth = img.width;
      cropHeight = cropWidth / targetRatio;
    }

    const offsetX = (img.width - cropWidth) / 2;
    const offsetY = (img.height - cropHeight) / 2;

    canvas.width = 1080;
    canvas.height = 1920;
    ctx.drawImage(img, offsetX, offsetY, cropWidth, cropHeight, 0, 0, 1080, 1920);

    // Para guardar, convertir canvas a blob y descargar
    canvas.toBlob(blob => {
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'cropped_vertical.png';
      a.click();
    });
  };
  img.src = URL.createObjectURL(file);
});

Este enfoque es perfecto para herramientas web donde el usuario necesita recortar antes de compartir. Todo el procesamiento sucede en el cliente, sin sobrecargar el servidor. Puedes añadir funcionalidad para mover el área de recorte con el mouse y permitir recorte personalizado, dando control total al usuario sobre el encuadre final.

Casos de uso reales en la industria

El recorte vertical no es solo para influencers. En un e-commerce, cada producto necesita imágenes cuadradas para la tienda y versión vertical para stories de Instagram Shopping. Un sistema automatizado puede, al subir una foto de producto, generar al instante las dos resoluciones, ahorrando horas de diseño. Tiendas como Zara o Mercado Libre aplican estas técnicas para mantener consistencia visual en sus canales.

Los medios digitales también lo usan para adaptar portadas de artículos al formato de historias. Con plantillas predefinidas y un script de recorte, se puede publicar en segundos. Agencias de marketing que manejan múltiples marcas integran estos flujos en Zapier o Make, disparando el recorte cada vez que el cliente sube una imagen a Google Drive. Incluso los fotógrafos de eventos pueden entregar a sus clientes un disco con imágenes ya recortadas para compartir en redes sociales, lo que aporta valor añadido y profesionalismo.

HolaGPT: genera tu código de recorte conversando

No todos los profesionales tienen tiempo de escribir y probar código desde cero. Aquí entra HolaGPT, el asistente de IA orientado a profesionales hispanos. Puedes describir exactamente lo que necesitas: "Necesito un script en Python que recorte imágenes a 1080x1920 usando detección de rostros con OpenCV", y HolaGPT te devolverá el código completo, explicado y adaptado a tu caso. Además, te sugerirá mejoras y te guiará en la instalación de dependencias.

HolaGPT también ayuda a depurar errores, agregar soporte para múltiples clasificadores o integrar la solución con una API sin tener que leer documentación extensa. Imagina tener un compañero de programación disponible 24/7 que comprende tus prompts en español y te responde con fragmentos listos para copiar y pegar. Eso agiliza enormemente el desarrollo y reduce la curva de aprendizaje.

Puntos críticos y solución de errores comunes

Aunque los scripts anteriores parecen sencillos, en producción aparecen desafíos que requieren atención:

Siempre guarda una copia del original y prueba con un subconjunto de imágenes antes de ejecutar un lote grande. Logs detallados ayudan a identificar imágenes problemáticas y a ajustar los umbrales de detección.

Conclusión y próximos pasos

Recortar imágenes a 1080x1920 es una tarea repetitiva que puede automatizarse en horas con las herramientas adecuadas. Empezaste con un script básico de Pillow, mejoraste con detección de objetos y ahora puedes ejecutarlo en batch, en el navegador o en la nube. La clave es adaptar la solución al volumen y al contexto: un emprendedor con diez imágenes semanales quizás prefiera Canva, pero un equipo de contenido que maneja cientos se beneficiará enormemente de la automatización.

Te animo a implementar el script que mejor se ajuste a tu flujo. Si tienes dudas, HolaGPT está a un clic para asistirte en el desarrollo. El tiempo que ahorres en recortes manuales podrás invertirlo en estrategia y creatividad. A medida que incorpores estas técnicas, verás un aumento notable en tu productividad y en la coherencia visual de tu marca.