Crop en python que genera una imágen cuadrada de 2000 x 2000 pixeles

README.md

Aquí tienes un script en Python que realiza todas las tareas que has descrito:

import os
import sys
import datetime
from PIL import Image
import zipfile

def process_image(image_path, my_image_width):
    with Image.open(image_path) as img:
        # Calcular el recorte centrado
        width, height = img.size
        min_dim = min(width, height)
        crop_dim = min(min_dim, my_image_width)
        
        left = (width - crop_dim) // 2
        top = (height - crop_dim) // 2
        right = (width + crop_dim) // 2
        bottom = (height + crop_dim) // 2
        
        img_cropped = img.crop((left, top, right, bottom))
        img_cropped = img_cropped.resize((my_image_width, my_image_width), Image.ANTIALIAS)
        
        # Generar nombre para la imagen recortada
        base_name, ext = os.path.splitext(os.path.basename(image_path))
        new_name = f"{base_name}_crop_{my_image_width}.png"
        
        return img_cropped, new_name

def save_image(img, new_name, output_dir):
    output_path = os.path.join(output_dir, new_name)
    img.save(output_path)

def process_directory(directory_path, my_image_width, output_dir):
    for filename in os.listdir(directory_path):
        if filename.lower().endswith('.png'):
            image_path = os.path.join(directory_path, filename)
            img_cropped, new_name = process_image(image_path, my_image_width)
            save_image(img_cropped, new_name, output_dir)

def create_zip_file(output_dir):
    zip_filename = f"{output_dir}.zip"
    with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for root, dirs, files in os.walk(output_dir):
            for file in files:
                zipf.write(os.path.join(root, file), 
                           os.path.relpath(os.path.join(root, file), 
                           os.path.join(output_dir, '..')))

def main():
    if len(sys.argv) < 3:
        print("Uso: python script.py <ruta_imagen_o_directorio> <my_image_width> [z]")
        sys.exit(1)
    
    path = sys.argv[1]
    my_image_width = int(sys.argv[2])
    
    # Crear nombre para el directorio de salida
    timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
    output_dir = f"images_{timestamp}"
    os.makedirs(output_dir, exist_ok=True)
    
    # Procesar imagen o directorio
    if os.path.isfile(path):
        img_cropped, new_name = process_image(path, my_image_width)
        save_image(img_cropped, new_name, output_dir)
    elif os.path.isdir(path):
        process_directory(path, my_image_width, output_dir)
    else:
        print(f"{path} no es un archivo o directorio válido.")
        sys.exit(1)
    
    # Crear archivo ZIP si se proporciona el argumento 'z'
    if len(sys.argv) == 4 and sys.argv[3] == 'z':
        create_zip_file(output_dir)

if __name__ == "__main__":
    main()

Instrucciones para ejecutar el script:

1. Guardar el script: Copia y guarda el código en un archivo Python, por ejemplo crop_images.py.
2. Ejecutar el script desde la línea de comandos:

   python crop_images.py <ruta_imagen_o_directorio> <my_image_width> [z]

   • <ruta_imagen_o_directorio>: Ruta de la imagen PNG o directorio a procesar.
   • <my_image_width>: Longitud deseada para el recorte en píxeles.
   • [z]: Argumento opcional para crear un archivo ZIP.

Ejemplo de uso:

python crop_images.py mi_imagen.png 1500

Esto procesará la imagen mi_imagen.png, recortándola y redimensionándola a 1500x1500 píxeles, y guardará el resultado en un nuevo directorio.

python crop_images.py mi_carpeta 2000 z

Esto procesará todas las imágenes PNG dentro de mi_carpeta, las recortará y redimensionará a 2000x2000 píxeles, y comprimirá las imágenes resultantes en un archivo ZIP.

crop_2000px.py

import os
import sys
from PIL import Image
from datetime import datetime

def crop_image(image_path, crop_size):
    img = Image.open(image_path)
    width, height = img.size

    if width < crop_size or height < crop_size:
        print(f"Advertencia: La imagen '{image_path}' mide menos de {crop_size}x{crop_size} píxeles y no se recortará.")
        return None

    left = (width - crop_size) / 2
    top = (height - crop_size) / 2
    right = (width + crop_size) / 2
    bottom = (height + crop_size) / 2

    img_cropped = img.crop((left, top, right, bottom))
    return img_cropped

def process_image(image_path, crop_size, output_dir):
    img_cropped = crop_image(image_path, crop_size)
    base_name = os.path.basename(image_path)
    name, ext = os.path.splitext(base_name)
    new_name = f"{name}_crop_{crop_size}x{crop_size}{ext}"
    output_path = os.path.join(output_dir, new_name)
    img_cropped.save(output_path)
    print(f"Imagen guardada: {output_path}")

def process_directory(directory, crop_size, output_dir):
    for filename in os.listdir(directory):
        if filename.endswith('.png'):
            process_image(os.path.join(directory, filename), crop_size, output_dir)

def main():
    if len(sys.argv) < 2:
        print(f"\nUso: python {sys.argv[0]} <imagen|directorio> [tamaño_crop]")
        sys.exit(1)

    path = sys.argv[1]
    crop_size = int(sys.argv[2]) if len(sys.argv) > 2 else 2000

    if not os.path.exists(path):
        print(f"Error: {path} no existe.")
        sys.exit(1)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    output_dir = f"images_{timestamp}"
    os.makedirs(output_dir, exist_ok=True)

    if os.path.isfile(path):
        process_image(path, crop_size, output_dir)
    elif os.path.isdir(path):
        process_directory(path, crop_size, output_dir)
    else:
        print(f"Error: {path} no es un archivo ni un directorio válido.")
        sys.exit(1)

if __name__ == "__main__":
    main()

requerimientos.md

---

Desarrolla un script en Python que realice las siguientes tareas:

1. Ejecución desde la línea de comandos.

2. Recepción de argumentos:

   • Primer argumento: El nombre de un archivo de imagen en formato PNG, por ejemplo: mi_imagen.png.
   • Segundo argumento: La longitud deseada para el recorte en píxeles, almacenada en la variable my_image_width.

3. Recorte y redimensionamiento de la imagen:

   • Realiza un recorte centrado de la imagen, creando una versión cuadrada de 2000x2000 píxeles.
   • Si se proporciona un valor como segundo argumento, reemplaza los 2000 píxeles por la longitud especificada.

4. Modificación del nombre del archivo:

   • Guarda la imagen recortada con el mismo nombre original, añadiendo al final _crop_<tamaño>.png, donde <tamaño> corresponde a la longitud en píxeles del recorte aplicado.

5. Procesamiento de directorios:

   • Si el primer argumento es un archivo, se aplica el recorte descrito anteriormente.
   • Si el primer argumento es un directorio, se procesa de la misma manera cada imagen PNG dentro del directorio.

6. Guardado de imágenes:

   • Las imágenes recortadas se guardan en la misma ubicación de origen, pero dentro de un nuevo directorio denominado images_YYYYMMDD_HHMMSS, donde:
     • YYYY: Año en formato de cuatro dígitos (ej. 2024).
     • MM: Mes en formato de dos dígitos (ej. 08 para agosto).
     • DD: Día en formato de dos dígitos (ej. 04).
     • HH: Hora en formato de 24 horas (ej. 14).
     • MM: Minutos en formato de dos dígitos (ej. 30).
     • SS: Segundos en formato de dos dígitos (ej. 15).

7. Creación de archivo comprimido (opcional):

   • Si se proporciona un argumento adicional z, el directorio con las imágenes procesadas deberá comprimirse en un archivo .zip.