La compresión de imágenes es una tecnología fundamental en la visión por computadora que nos permite almacenar y transmitir imágenes de manera más eficiente manteniendo la calidad visual. Lo ideal es que nos encantaría tener archivos pequeños y con la mejor calidad. Sin embargo, debemos hacer una compensación y decidir qué es más importante.

Este tutorial enseñará la compresión de imágenes con OpenCV, cubriendo teoría y aplicaciones prácticas. Al final, comprenderá cómo comprimir fotografías con éxito para proyectos de visión por computadora (o cualquier otro proyecto que pueda tener).

¿Qué es la compresión de imágenes?

La compresión de imágenes consiste en reducir el tamaño del archivo de una imagen manteniendo un nivel aceptable de calidad visual. Hay dos tipos principales de compresión:

1. Compresión sin pérdidas: Conserva todos los datos originales, lo que permite una reconstrucción exacta de la imagen.
2. Compresión con pérdida: Descarta algunos datos para lograr tamaños de archivo más pequeños, lo que potencialmente reduce la calidad de la imagen.

¿Por qué comprimir imágenes?

Si "el espacio en disco es barato", como escuchamos a menudo, ¿por qué comprimir imágenes? A pequeña escala, la compresión de imágenes no importa mucho, pero a gran escala es crucial.

Por ejemplo, si tienes algunas imágenes en tu disco duro, puedes comprimirlas y guardar algunos megabytes de datos. Esto no tiene mucho impacto cuando los discos duros se miden en Terabytes. Pero ¿qué pasaría si tuvieras 100.000 imágenes en tu disco duro? Un poco de compresión básica ahorra tiempo y dinero reales. Desde una perspectiva de rendimiento, es lo mismo. Si tiene un sitio web con muchas imágenes y 10.000 personas lo visitan al día, la compresión es importante.

Este es el motivo por el que lo hacemos:

• Requisitos de almacenamiento reducidos: almacena más imágenes en el mismo espacio
• Transmisión más rápida: Ideal para aplicaciones web y escenarios con ancho de banda limitado
• Velocidad de procesamiento mejorada: las imágenes más pequeñas se cargan y procesan más rápido

Teoría detrás de la compresión de imágenes

Las técnicas de compresión de imágenes explotan dos tipos de redundancias:

1. Redundancia espacial: Correlación entre píxeles vecinos
2. Redundancia de color: Similitud de valores de color en regiones adyacentes

La redundancia espacial aprovecha el hecho de que los píxeles vecinos tienden a tener valores similares en la mayoría de las imágenes naturales. Esto crea transiciones suaves. Muchas fotos "parecen reales" porque hay un flujo natural de un área a otra. Cuando los píxeles vecinos tienen valores muy diferentes, se obtienen imágenes "ruidosas". Los píxeles cambiaron para hacer esas transiciones menos "suaves" agrupando los píxeles en un solo color, haciendo la imagen más pequeña.

Redundancia de color, por otro lado, se centra en cómo las áreas adyacentes en una imagen a menudo comparten colores similares. Piense en un cielo azul o un campo verde: grandes porciones de la imagen pueden tener valores de color muy similares. También se pueden agrupar y hacer de un solo color para ahorrar espacio.

OpenCV ofrece herramientas sólidas para trabajar con estas ideas. Utilizando redundancia espacial, la función cv2.inpaint() de OpenCV, por ejemplo, rellena áreas faltantes o dañadas de una imagen utilizando información de píxeles cercanos. OpenCV permite a los desarrolladores usar cv2.cvtColor() para traducir imágenes entre varios espacios de color con respecto a la redundancia de color. Esto puede resultar algo útil como paso de preprocesamiento en muchas técnicas de compresión, ya que algunos espacios de color son más efectivos que otros para codificar tipos particulares de imágenes.

Ahora probaremos parte de esta teoría. Juguemos con eso.

Compresión práctica de imágenes

Exploremos cómo comprimir imágenes usando los enlaces Python de OpenCV. Escribe este código o cópialo:

También puedes obtener el código fuente aquí

import cv2
import numpy as np

def compress_image(image_path, quality=90):
    # Read the image
 img = cv2.imread(image_path)
    
    # Encode the image with JPEG compression
 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
 _, encoded_img = cv2.imencode('.jpg', img, encode_param)
    
    # Decode the compressed image
 decoded_img = cv2.imdecode(encoded_img, cv2.IMREAD_COLOR)
    
    return decoded_img

# Example usage
original_img = cv2.imread('original_image.jpg')
compressed_img = compress_image('original_image.jpg', quality=50)

# Display results
cv2.imshow('Original', original_img)
cv2.imshow('Compressed', compressed_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Calculate compression ratio
original_size = original_img.nbytes
compressed_size = compressed_img.nbytes
compression_ratio = original_size / compressed_size
print(f"Compression ratio: {compression_ratio:.2f}")

Este ejemplo contiene una función compress_image que toma dos parámetros:

• Ruta de la imagen (donde se encuentra la imagen)
• Calidad (la calidad de la imagen deseada)

Luego, cargaremos la imagen original en original_img. Luego comprimimos esa misma imagen al 50% y la cargamos en una nueva instancia, imagen_comprimida.

Luego mostraremos las imágenes originales y comprimidas para que puedas verlas una al lado de la otra.

Luego calculamos y mostramos la relación de compresión.

Este ejemplo demuestra cómo comprimir una imagen usando compresión JPEG en OpenCV. El parámetro de calidad controla el tamaño del archivo y la calidad de la imagen.

Ejecutémoslo:

Al mirar las imágenes inicialmente, ves poca diferencia. Sin embargo, al hacer zoom se muestra la diferencia en la calidad:

Y después de cerrar las ventanas y mirar los archivos, podemos ver que el tamaño del archivo se redujo drásticamente:

Además, si lo reducimos más, podemos cambiar nuestra calidad al 10%

compressed_img = compress_image('sampleimage.jpg', quality=10)

Y los resultados son mucho más drásticos:

Y los resultados del tamaño del archivo también son más drásticos:

Puedes ajustar estos parámetros con bastante facilidad y lograr el equilibrio deseado entre calidad y tamaño de archivo.

Evaluación de la calidad de la compresión

Para evaluar el impacto de la compresión, podemos utilizar métricas como:

1. Error cuadrático medio (MSE)

El error cuadrático medio (MSE) mide qué tan diferentes son dos imágenes entre sí. Cuando comprime una imagen, MSE le ayuda a determinar cuánto ha cambiado la imagen comprimida en comparación con el original.

Lo hace muestreando las diferencias entre los colores de los píxeles correspondientes en las dos imágenes, elevando al cuadrado esas diferencias y promediandolas. El resultado es un único número: un MSE más bajo significa que la imagen comprimida está más cerca del original. En comparación, un MSE más alto significa que hay una pérdida de calidad más notable.

Aquí hay algo de código Python para medir eso:

def calculate_mse(img1, img2):
    return np.mean((img1 - img2) ** 2)

mse = calculate_mse(original_img, compressed_img)
print(f"Mean Squared Error: {mse:.2f}")

Así es como se ve nuestra compresión de imágenes de demostración:

1. Relación señal-ruido máxima (PSNR)

La relación señal-ruido máxima (PSNR) es una medida que muestra cuánto se ha degradado la calidad de una imagen después de la compresión. Esto suele ser visible a simple vista, pero asigna un valor establecido. Compara la imagen original con la comprimida y expresa la diferencia como una proporción.

Un valor PSNR más alto significa que la imagen comprimida tiene una calidad más cercana a la original, lo que indica una menor pérdida de calidad. Un PSNR más bajo significa una degradación más visible. PSNR se utiliza a menudo junto con MSE, y PSNR proporciona una escala más fácil de interpretar donde cuanto más alto, mejor.

Aquí hay un código Python que mide eso:

def calculate_psnr(img1, img2):
 mse = calculate_mse(img1, img2)
    if mse == 0:
        return float('inf')
 max_pixel = 255.0
    return 20 * np.log10(max_pixel / np.sqrt(mse))

psnr = calculate_psnr(original_img, compressed_img)
print(f"PSNR: {psnr:.2f} dB")

Así es como se ve nuestra compresión de imágenes de demostración:

Está bien "estudiar" las imágenes después de comprimirlas para determinar la calidad; sin embargo, a gran escala, hacer que los guiones hagan esto es una forma mucho más fácil de establecer estándares y garantizar que las imágenes los sigan.

Veamos un par de técnicas más:

Técnicas avanzadas de compresión

Para una compresión más avanzada, OpenCV admite varios algoritmos:

1. Compresión PNG:

Puedes convertir tus imágenes al formato PNG, lo que tiene muchas ventajas. Utilice la siguiente línea de código y podrá configurar la compresión de 0 a 9, según sus necesidades. 0 significa que no hay compresión alguna y 9 es el máximo. Tenga en cuenta que los PNG son un formato "sin pérdidas", por lo que incluso con la compresión máxima, la imagen debe permanecer intacta. La gran compensación es el tamaño del archivo y el tiempo de compresión.

Aquí está el código para usar la compresión PNG con OpenCV:

cv2.imwrite('compressed.png', img, [cv2.IMWRITE_PNG_COMPRESSION, 9])

Y aquí está nuestro resultado:

Nota: A veces puedes notar que los archivos PNG son en realidad de mayor tamaño, como en este caso. Depende del contenido de la imagen.

1. Compresión WebP:

También puedes convertir tus imágenes al formato .webp. Este es un método de compresión más nuevo que está ganando popularidad. He estado usando esta compresión en las imágenes de mi blog durante años.

En el siguiente código, podemos escribir nuestra imagen en un archivo webp y establecer el nivel de compresión de 0 a 100. Es lo opuesto a la escala de PNG porque es 0, porque estamos configurando calidad en lugar de compresión. Esta pequeña distinción es importante, porque una configuración de 0 es la calidad más baja posible, con un tamaño de archivo pequeño y una pérdida significativa. 100 es la calidad más alta, lo que significa archivos grandes con la mejor calidad de imagen.

Aquí está el código Python para que esto suceda:

cv2.imwrite('compressed.webp', img, [cv2.IMWRITE_WEBP_QUALITY, 80])

Y aquí está nuestro resultado:

Estas dos técnicas son excelentes para comprimir grandes cantidades de datos. Puede escribir scripts para comprimir miles o cientos de miles de imágenes automáticamente.

Conclusión

La compresión de imágenes es fantástica. Es esencial para las tareas de visión por computadora en muchos sentidos, especialmente cuando se ahorra espacio o se aumenta la velocidad de procesamiento. También hay muchos casos de uso fuera de la visión por computadora en cualquier momento en que desee reducir el espacio del disco duro o ahorrar ancho de banda. La compresión de imágenes puede ayudar mucho.

Al comprender la teoría detrás de esto y aplicarla, puedes hacer algunas cosas poderosas con tus proyectos.

Recuerde, la clave para una compresión efectiva es encontrar el punto óptimo entre la reducción del tamaño del archivo y mantener una calidad visual aceptable para su aplicación.

Gracias por leer y no dudes en comunicarte con nosotros si tienes algún comentario o pregunta.