Extracción de Colores de Imágenes en Python.

La extracción de colores de una imagen es una técnica fundamental en el procesamiento digital que permite identificar, cuantificar y analizar los tonos predominantes en una fotografía o en cualquier recurso gráfico. En un mundo cada vez más orientado al análisis visual —desde el diseño hasta la visión por computadora— comprender la paleta cromática de una imagen se ha vuelto una herramienta indispensable para múltiples disciplinas. Así, en nuestro artículo de esta semana, nos proponemos a realizar la extracción de los colores principales de la siguiente imagen:

En esta ocasión haremos uso de google colab, para nuestra practica, donde, como es natural, comenzaremos realizando las importaciones pertinentes:

Como se ve, realizamos la importación de varias librerías y recursos: ‘from PIL import Image‘ (Para cargar la imagen), ‘import numpy as np‘ (para manipular arrays y hacer reshape), ‘import matplotlib.pyplot as plt‘ (para mostrar la imagen y paleta resultante) y ‘from sklearn.cluster import KMeans‘ (que nos permitirá emplear el algoritmo K-Means de scikit-learn, para agrupa píxeles por similitud de color).

A continuación, pasaremos a abrir la imagen con image.open() y la convertimos inmediatamente a un array con np.array():

El resultado es un array de forma (ancho, alto, canales) (normalmente (w, h, 3) para RGB. Usar Pillow y convert(RGB) es recomendable si hay posibilidad de canal alfa; en ese caso conviene forzar Image.open(file_name).convert(«RGB») para garantizar 3 canales.

Tras ello, pasaremos a convertir nuestra imagen en una matriz de 2 dimensiones en donde cada fila es un pixel y cada columna viene representada por los canales (R. G . B.). De este modo, teniendo nuestra imagen 501 x 501 pixeles y 3 canales, el formato que pasaremos al algoritmo KMeans, será (251001, 3) que es el formato que espera para realizar la agrupación por colores.

El paso siguiente será el de seleccionar el número de colores dominantes que queremos extraer. Número que almacenaremos en la variable n_colors y que en nuestro caso será 15:

Por fin, en este paso se crea y entrena el modelo K-Means que identificará los colores dominantes de la imagen. Instanciando, primero, el algoritmo con KMeans(n_clusters=n_colors, random_state=42), donde n_clusters es el número de colores que queremos extraer (definidos antes) y random_state garantiza resultados reproducibles. Finalmente, con .fit(pixels), el modelo agrupa todos los píxeles de la imagen en clusters según la similitud de sus valores RGB; cada iteración ajusta los centroides para minimizar la distancia entre los píxeles y el centro del grupo al que pertenecen. Al finalizar, el modelo queda entrenado y listo para proporcionar los colores representativos de la imagen:

Una vez entrenado el modelo, K-Means almacena en kmeans.cluster_centers_ los centroides de cada grupo, que representan los colores dominantes encontrados en la imagen. Estos valores se obtienen como arreglos de tipo float, por lo que primero se convierten a enteros de 0 a 255 mediante np.uint8, generando así colores válidos en formato RGB. El resultado es un arreglo llamado palette, donde cada fila es un color característico detectado por el algoritmo. Esta paleta condensada es una representación compacta de los tonos predominantes de la imagen original y servirá para su visualización o para cualquier aplicación posterior, como diseño gráfico, clasificación o análisis cromático:

Obtenida nuestra paleta de colores principales, simplemente nos restará representarla con nuestra librería matplotlib, mediante el procedimiento habitual:

ORDENANDO COLORES POR IMPORTANCIA.

Como hemos dicho, tras todo el proceso hemos obtenido los 15 colores más representativos de nuestra imagen. No obstante, tal y como está presentado el resultado, quizás no nos diga gran cosa, al no estar estos ordenados ni contar con el porcentaje que cada uno representa en el conjunto. Por ello, vamos a añadir algunas líneas justo después de la definición de la paleta extraída (variable palette):

Aquí, partiendo del resultado antes obtenido por K-Means, cada píxel de la imagen recibe una etiqueta numérica que indica a qué cluster (o color) pertenece. Etiqueta, la cual, se almacena una a una en kmeans.labels_. Para saber qué colores aparecen más en la imagen, primero contamos cuántas veces aparece cada etiqueta usando np.unique(labels, return_counts=True), lo que devuelve los identificadores de los clusters y cuántos píxeles corresponden a cada uno. Luego, para convertir esas cantidades absolutas en proporciones, dividimos cada conteo entre el número total de píxeles (len(labels)) y lo multiplicamos por 100 para obtener el porcentaje que representa cada color sobre el total.

Una vez obtenidas las proporciones, podemos ordenar los colores según su presencia en la imagen. Para ello usamos np.argsort(-frequencies), que devuelve los índices que ordenarían el array de frecuencias de mayor a menor; el signo negativo se usa para invertir el orden, ya que argsort normalmente ordena de menor a mayor:

Así, al aplicar estos índices tanto al array de colores (palette) como al array de frecuencias, generamos una paleta reordenada (palette_sorted) donde el primer color es el más predominante y el último el menos frecuente. Esta ordenación es especialmente útil para representar la paleta de manera más intuitiva, ya que los colores principales aparecen primero.

Ahora ya lo único que deberemos hacer es volver a la parte del código que usamos para mostrar la paleta. Solo que usando en esta ocasión, la variable palette_sorted para la representación:

Finalmente, si lo deseamos, podemos mostrar el porcentaje de cada color (esta vez redondeado a dos decimales con .2f) valiéndonos de un ciclo for que recorra la paleta y frecuencias ordenadas:

Así, lo que esta salida nos está diciendo es que el 23,13% de los pixeles de la imagen tienen un color que vendría determinado por los valores RGB, 12 para el canal rojo, 4 para el verde y 11 para el azul y así con el resto de la salida.

CONCLUSIÓN:

En conjunto, calcular y ordenar las frecuencias de color permite obtener una paleta no solo representativa, sino también informativa sobre la estructura cromática de una imagen. Este proceso facilita identificar los tonos predominantes y comprender mejor la composición visual, lo que resulta especialmente útil en tareas de diseño, análisis estético, clasificación de imágenes y generación de estilos visuales coherentes.

Saludos.

Detección de Esquinas en Python, con OpenCV y numpy.

La detección de esquinas es una de las técnicas fundamentales en visión por computadora, ya que permite identificar puntos de interés en una imagen que se mantienen estables frente a cambios de iluminación, rotación o escala. Estos puntos son especialmente útiles en tareas como el reconocimiento de patrones, la reconstrucción 3D o la calibración de cámaras. En Python, gracias a la librería OpenCV, podemos implementar de manera sencilla y eficiente el algoritmo de Harris (cornerHarris), uno de los métodos clásicos y más influyentes en la detección de esquinas. En este artículo exploraremos cómo funciona este algoritmo, cómo aplicarlo en imágenes con OpenCV y qué parámetros ajustar para obtener los mejores resultados en distintos escenarios.

Pero entes de empezar, deberemos asegurarnos de tener instalados en nuestro sistema, los recursos y librerías necesarios. Que en este caso serán las librerías OpenCV y numpy:

Una vez que tengamos ambas librerías listas para usar en nuestro equipo, crearemos un nuevo script de Python en el que empezaremos importando ambas:

Hecho esto, ya podemos pasar a cargar la imagen cuyas esquinas queremos detectar. Para ello utilizaremos el método imread(), pasándole el nombre del archivo a leer. Tras lo cual, usaremos imshow() para que se muestre en pantalla nuestra imagen original:

OUTPUT:

Una practica habitual a la hora de realizar operaciones sobre imágenes es la de reducir las dimensiones de sus datos, pasando estas a escala de grises, para agilizar los cálculos a realizar. Eso mismo es lo que haremos a continuación empleando el método cvtColor() almacenando esta nueva versión en la variable gray que, como antes, mostraremos en pantalla con imshow():

OUTPUT:

Tal y como hemos expresado mas arriba, para la detección, vamos a hacer uso del algoritmo de Harris Corner, el cual, para los cálculos de gradientes, necesita que la imagen de entrada esté en un formato numérico de punto flotante. Es por ello que el siguiente paso será utilizar numpy para realizar dicha conversión:

Ahora ya estamos en condiciones de aplicar el referido algoritmo sobre nuestra imagen. Para esta operación usaremos el método de OpenCV, cornerHarris() el cual tomará los siguientes argumentos: 1. La imagen en escala de grises convertida a formato numérico en coma flotante, 2. El tamaño del vecindario considerado para el cálculo de las derivadas, 3. El tamaño del bloque utilizado en la detección y 4. El parámetro libre de Harris que influye en la sensibilidad de la detección de esquinas:

Esto almacenará en la variable dst, una matriz que indica la respuesta del algoritmo en cada punto de la imagen, de modo que donde haya valores más altos, mayores probabilidades habrá de que se correspondan con una esquina en la imagen:

Tras ello pasaremos a dilatar la imagen, expandiendo los valores máximos locales, para resaltar mejor las esquinas detectadas. Con ello, buscamos que las esquinas aparezcan más visibles y definidas en la imagen resultante:

Como último paso en el proceso de detección, estableceremos un umbral para establecer que puntos de la imagen pueden considerarse esquinas:

Aquí estamos utilizando dst.max() para obtener el valor máximo de la respuesta de Harris, de modo que al ser multiplicado por 0.27 se fijará un limite, de modo que los puntos que lo superen serán considerados esquinas que serán marcadas en rojo usando los valores rgb [0,0,255].

Una vez establecidos los puntos que serán considerados esquinas, ya solo restará mostrarlos en pantalla utilizando las mismas funciones que más arriba empleamos para mostrar la imagen en original y escala de grises:

OUTPUT:

Obtenemos así una imagen en la que la mayoría de las esquinas han sido detectadas por nuestro algoritmo. A su vez, podemos intentar mejorar el resultado probando con valores distintos al que hemos multiplicado por dst.max(), de modo que cuanto más bajo sea este más puntos serán detectados (y también más posibilidades habrá de establecer como esquina, puntos que no lo sean).

Para más información al respecto, no duden en consultar la información oficial de OpenCV:

https://docs.opencv.org/4.x/dc/d0d/tutorial_py_features_harris.html

Saludos.

UTILIZANDO ELEMENTOS DE IMAGEN CON PYTHON Y TKINTER.

Los widgets de imagen en Tkinter son una herramienta fundamental para mostrar gráficos, fotos e iconos en las aplicaciones GUI de Python. Ya que permiten una representación visual efectiva de la información, mejorando la usabilidad y la estética de la interfaz de usuario. En esta guía práctica, exploraremos cómo utilizar los principales widgets de imagen en Tkinter para mostrar imágenes en nuestras aplicaciones gráficas.

1- ETIQUETAS DE IMAGEN.

La etiqueta de imagen (‘Label‘) es la forma más básica de mostrar una imagen en una aplicación creada con Tkinter. A continuación mostramos un ejemplo sencillo de cómo cargar y mostrar una imagen utilizando este widget, para lo que nos valdremos de la clase ‘PhotoImage‘:

En este ejemplo, ‘image‘ es un objeto de la clase ‘PhotoImage‘ creado a partir del archivo de imagen cuya ruta hemos definido. Este, lo utilizaremos como argumento para crear una etiqueta (‘Label‘), que será la que se muestre en la ventana principal. Una de las ventajas de usar este widget reside en el hecho de que las dimensiones de ventana se ajustarán automaticamente a las dimensiones de la imagen, sin necesidad de especificarlas por nosotros.

OUTPUT:

2- CANVAS.

Por su parte, el canvas (‘Canvas‘) es más flexible y permite una mayor interacción con las imágenes. Así, por ejemplo, nos permite dibujar estas agregándole texto encima, tal y como hacemos en el siguiente ejemplo:

En este caso hemos empezado creando nuestra ventana y cargando la imagen con ‘PhotoImage()‘ como en el ejemplo anterior, para a continuación crear nuestro lienzo ‘Canvas‘ especificando sus dimensiones que en este caso serán las variables ‘ancho’ y alto’ de nuestra imagen (obtenidas mediante las funciones ‘width()‘ y ‘height()‘). Creado el lienzo, hemos insertado en el la imagen en cuestión con ‘create_image()‘ especificando a su vez, la posición de la misma en el canvas. Finalmente hemos insertado un texto sobre la misma, empleando ‘create_text()‘.

OUTPUT:

3- MARCO DE IMAGEN (FRAME).

El marco de imagen (‘Frame‘) nos será de gran utilidad cuando queramos organizar y mostrar varias imágenes juntas. Aquí tienes un ejemplo de cómo crear un marco y agregar etiquetas de imagen a él:

En este caso, tras crear la ventana principal (‘root‘) generamos un marco (‘frame‘) dentro de ella que contendrá las imágenes. Las imágenes se cargan utilizando ‘PhotoImage‘ (como vimos en los ejemplos anteriores) y se asignan a las variables ‘image1‘ e ‘image2‘ (en este caso no hemos especificado las rutas completas ya que previamente hemos hecho el cambio de directorio con ‘chdir()‘). Después, hemos creado las etiquetas para mostrar cada imagen que acto seguido, hemos incluido en el marco, una a la izquierda (‘label1‘) y otra a la derecha (‘label2‘).

OUTPUT:

CONCLUSION:

Los widgets de imagen en Tkinter ofrecen una forma efectiva de mostrar imágenes en aplicaciones gráficas de Python. Así, con la clase ‘PhotoImage‘, es posible cargar imágenes desde archivos y mostrarlas en etiquetas de imagen dentro de una ventana. Además, Tkinter proporciona la flexibilidad para organizar y diseñar la disposición de las imágenes junto con otros elementos de la interfaz gráfica, como botones y cuadros de texto. Esto permite crear aplicaciones visuales atractivas y funcionales con facilidad. En resumen, los widgets de imagen en Tkinter son una herramienta valiosa para desarrollar aplicaciones con interfaces de usuario interactivas y visualmente atractivas en Python.

Saludos.

ESQUELETIZADO DE IMAGENES CON PYTHON Y SCIKIT-IMAGE.

El procesamiento de imágenes es una disciplina fascinante que abarca una amplia gama de técnicas para manipular imágenes digitales con el fin de mejorar su calidad, extraer información relevante o realizar tareas específicas. Una de estas técnicas es el esqueletizado de imágenes, que tiene aplicaciones en diversas áreas, como visión por computadora, reconocimiento de patrones, análisis de formas y más. Concretamente consiste en un proceso en el que se reduce una forma binaria a su representación más esquemática, manteniendo la topología de la forma original. Esencialmente, el esqueleto de una imagen representa la «columna vertebral» de la forma, conservando su estructura esencial. Esta técnica es útil para simplificar la representación de formas y facilitar la extracción de características relevantes.

En este artículo, exploraremos en detalle la utilidad del esqueletizado de imágenes y cómo se implementa en Python utilizando la biblioteca ‘scikit-image‘ la cual deberemos instalar previamente en nuestro sistema con ‘pip install scikit-image‘:

IMPLEMENTACION EN PYTHON:

La mencionada biblioteca ‘scikit-image‘ proporciona una implementación eficiente y fácil de usar del esqueletizado de imágenes a través de la función skeletonize. Esta función toma una imagen binaria como entrada y devuelve el esqueleto de la forma representado como una matriz binaria. A continuación, veremos un ejemplo de cómo implementar el esqueletizado de imágenes en Python utilizando dicha librería aplicada a la siguiente imagen:

Así el primer paso que deberemos dar es naturalmente el de importar las librerías y recursos a utilizar y proceder al cargado y lectura de la imagen en cuestión con ‘OpenCV‘. En este punto usaremos la función ‘imread()‘ pasándole como primer argumento, la ruta a la imagen en cuestión y como segundo argumento, el valor 0, con lo que estaremos indicando que queremos cargarla en escala de grises:

Hecho esto y teniendo en cuenta que la operación que queremos realizar, ha de efectuarse sobre una imagen binaria, el siguiente paso será realizar dicha conversión mediante la aplicación de los correspondientes umbrales. En ocasiones puede ser útil la aplicación de inversión sobre la misma. Usándose en este caso la función ‘bitwise_not()‘:

Una vez realizados estos pasos previos, llevaremos a cabo la operación de esqueletización con ‘scikit-image‘ y su función ‘skeletonize()‘:

Finalmente mostraremos el resultado final, junto al original en gris y su versión binaria invertida, utilizando la función para visualizar fotos de ‘OpenCV‘, ‘imshow()‘:

OUTPUT:

CONCLUSION:

El esqueletizado de imágenes es una técnica poderosa en el campo del procesamiento de imágenes, con aplicaciones en diversas áreas como análisis de formas, extracción de características, reconocimiento de patrones y más. La implementación de esta técnica en Python utilizando la biblioteca ‘scikit-image‘ proporciona una forma eficiente y flexible de realizar operaciones de esqueletizado en imágenes digitales. Al comprender la utilidad y la implementación del esqueletizado de imágenes, los practicantes de procesamiento de imágenes pueden aprovechar esta técnica para una variedad de aplicaciones prácticas y proyectos de visión por computadora.

Saludos.

ENTRENANDO MODELOS PARA CLASIFICACIÓN DE IMAGENES CON PYTHON Y ‘TensorFlow’.

En el mundo de la inteligencia artificial y el aprendizaje automático, la clasificación de imágenes es una tarea fundamental. Clasificar imágenes puede implicar identificar objetos, reconocer patrones o incluso diagnosticar enfermedades basadas en imágenes médicas. En este artículo, exploraremos cómo utilizar Python junto con ‘TensorFlow‘, una de las bibliotecas de aprendizaje automático más populares, para entrenar modelos de clasificación de imágenes de manera efectiva. La explicación la dividiremos en cinco sencillos pasos:

INSTALACIÓN DE TENSOR FLOW:

Aunque para nuestro ejemplo vamos a utilizar la plataforma de ‘Google Colab‘ (en donde no es necesaria esta acción) conviene saber como podemos instalar la librería localmente en nuestro sistema. Para ello podremos utilizar el comando ‘pip‘ al que estamos acostumbrados:

PREPARACIÓN DE LOS DATOS:

El primer paso en el entrenamiento de un modelo de clasificación de imágenes es preparar los datos. Para este ejemplo, utilizaremos el conjunto de datos ‘MNIST‘, consistente en una colección de imágenes de dígitos escritos a mano. ‘TensorFlow‘ proporciona, aquí, funciones para cargar y pre-procesar dicho conjunto de datos:

Así, empezaremos a elaborar nuestro modelo, importando la librería ‘TensorFlow‘. Tras ello, cargamos los datos de imágenes MNIST utilizando la función ‘load_data()‘ para después normalizar estos dividiendo los valores de píxeles de las imágenes por 255 y así escalarlos en el rango [0, 1]:

CONSTRUCCIÓN DEL MODELO:

Una vez que los datos están preparados, podemos construir nuestro modelo de clasificación de imágenes. Para este ejemplo, utilizaremos una red neuronal convolucional (CNN), la cual constituye una arquitectura comúnmente utilizada para tareas de visión por computadora como la que pretendemos realizar:

En la construcción del modelo, primero definimos un modelo secuencial utilizando ‘tf.keras.models.Sequential([])‘, permitiéndonos agregar capas secuenciales una tras otra. Luego, agregamos capas de convolución 2D seguidas de capas de agrupación máxima para extraer características de las imágenes y reducir la dimensionalidad. Después de varias iteraciones, aplanamos las características en un vector unidimensional y las alimentamos a capas densas para la clasificación final.

Una vez que el modelo está construido, lo compilamos con ‘model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])‘. Aquí, especificamos el optimizador ‘adam‘, una función de pérdida adecuada para problemas de clasificación de múltiples clases, y las métricas que deseamos monitorear durante el entrenamiento, como la precisión. Este proceso de construcción y compilación establece los parámetros esenciales del modelo, preparándolo para el proceso de entrenamiento.

ENTRENAMIENTO DEL MODELO:

Una vez construido y compilado nuestro modelo, podemos entrenarlo utilizando los datos de entrenamiento que definimos con anterioridad:

El código para entrenar el modelo utiliza el método ‘fit()‘, donde proporcionamos los datos de entrenamiento (‘x_train‘) y sus correspondientes etiquetas de clase (‘y_train‘). A su vez, especificaremos el número de épocas (variable ‘epochs‘) de entrenamiento, que determina cuántas veces el modelo verá todo el conjunto de datos de entrenamiento. Además, utilizamos un conjunto de datos de validación (‘x_test‘ y ‘y_test‘) para evaluar el rendimiento del modelo después de cada época. Durante el entrenamiento, el modelo ajusta sus pesos para minimizar la función de pérdida, y al final de cada época, evalúa su desempeño en el conjunto de validación. Este proceso se repite durante el número especificado de épocas, preparando así el modelo para su evaluación final.

Proceso de entrenamiento del modelo.

EVALUACIÓN DEL MODELO:

Finalmente procederemos a la evaluación de nuestro modelo, obteniendo el valor de perdida en el conjunto de datos de prueba (‘test_loss‘) y la precisión (‘test_acc‘). Para ello utilizaremos el método ‘evaluate()‘ del TensorFlow:

CONCLUSIÓN:

En este artículo, hemos explorado cómo utilizar Python junto con TensorFlow para entrenar un modelo de clasificación de imágenes. Desde la preparación de los datos hasta la construcción, entrenamiento y evaluación del modelo, TensorFlow proporciona herramientas poderosas y fáciles de usar para trabajar con imágenes y realizar tareas de aprendizaje automático. Con este conocimiento, estás listo para comenzar a desarrollar tus propios modelos de clasificación de imágenes y explorar el emocionante campo de la visión por computadora.

Saludos.

DETECCIÓN DE TEXTO EN IMAGENES EN PYTHON, CON ‘EasyOCR’.

El Reconocimiento óptico de caracteres (‘ROC‘ u ‘OCR‘ por sus siglas en inglés), consiste en la extracción y detección de texto en imágenes. Se trata una tarea común en el campo de la visión por computadora que es ampliamente utilizada en aplicaciones tales como la captura y digitalización de documentos, traducción, detección de fraudes o reconocimiento de información en imágenes medicas. Así, esta semana vamos a aprender a extraer texto de una imagen, utilizando ‘EasyOCR‘ una librería en Python que nos permitirá realizar dicha tarea de una forma rápida y sencilla. Librería que deberemos instalar previamente en nuestro sistema, mediante el comando ‘pip install easyocr‘.

USO BASICO:

Una vez explicado el objetivo de nuestra practica, pasaremos a la extracción de texto de archivos de imagen. En esta ocasión usaremos el entorno de ‘Google Colab‘ en el que empezaremos realizando la instalación de ‘EasyOCR‘:

Tras ello pasaremos a importar la librería en cuestión, para a continuación, crear el objeto ‘reader‘ especificando el idioma (inglés en este caso) del texto que vamos a extraer:

Empezaremos extrayendo texto, en distintos tamaños, de una imagen en blanco y negro:

image.png

Para la lectura del texto en la imagen, usaremos aquí, la función «readtext()» pasando como argumento la ruta al archivo que contiene el texto que queremos obtener:

Esta función nos devolverá tres informaciones de cada línea de texto detectada: Las coordenadas de la imagen en las que se encuentra el área de texto (concebida como caja), el texto detectado y e nivel de confianza entendida como la probabilidad de que el texto detectado por el algoritmo ‘OCR‘ sea correcto. A su vez, podemos usar un bucle para acceder a estas tres informaciones de modo aislado:

Como se ve, el texto detectado en las líneas coincide con el presente en la imagen, lo que resulta coherente con los valores de probabilidad obtenidos.

A su vez, podemos usar «matplotlib» para mostrar el texto detectado en una etiqueta, para cada línea detectada en la imagen:

También podemos utilizar la información almacenada en la variable ‘bbox‘, para dibujar un recuadro que enmarque el área de la imagen ocupada por el texto:

Lo que hemos hecho sobre una imagen en blanco y negro, podremos hacerlo igualmente sobre una imagen a color como esta a la que hemos dado el nombre de «color_image.png«:

color_image.png

CONCLUSIÓN:

EasyOCR es una herramienta poderosa y fácil de usar para detectar texto en imágenes. Su capacidad para manejar múltiples idiomas, su precisión y su facilidad de integración lo hacen útil para una variedad de aplicaciones, desde la automatización de tareas hasta el procesamiento de documentos. En este artículo hemos visto, de un modo básico, como podemos usarle para extraer la información inherente al texto presente un un archivo de imagen y el modo en que podemos usar dicha información para mostrar gráficamente dicho texto en la imagen.

Saludos.

APLICANDO LA ‘TRANSFORMADA DE FOURIER’ EN PYTHON, CON ‘numpy’.

La ‘Transformada de Fourier‘ (cuyo nombre proviene del matemático y físico francés Joseph Fourier) es un método matemático que descompone una señal en sus componentes de frecuencia. En otras palabras, toma una señal en el dominio del tiempo y la convierte en su representación en el dominio de la frecuencia. Esto es útil para analizar las frecuencias presentes en una señal, como ondas sonoras y señales eléctricas, entre otras.

Joseph Fourier (1768-1830)

En las siguientes líneas vamos a ver un sencillo ejemplo de aplicación de esta técnica sobre una serie de tiempo que definiremos nosotros.

Antes de continuar, deberemos asegurarnos de tener instaladas las librerías que vamos a necesitar: ‘numpy‘ para la aplicación de la transformada y ‘matplotlib‘ para las representaciones gráficas:

Una ves instaladas las librerías que vayamos a emplear, crearemos un archivo de nombre ‘fourier.py‘ en el que tras hacer las importaciones pertinentes, empezaremos definiendo la serie de tiempo sobre la que vamos a aplicar la transformada. Serie de tiempo que crearemos con ‘np.arange()‘ y que irá de 0 a 10, incrementándose 0.01 cada vez:

Lo que hará nuestro script es mostrar simultáneamente la gráfica de la señal original y la resultante, tras aplicarle la transformada. Por ello utilizaremos a continuación ‘matplotlib‘ para mostrar dicha señal en una ventana destinada también a mostrar la gráfica resultado:

Una vez definida la señal original y su representación gráfica, es el momento de aplicarle la ‘Transformada de Fourier‘ con ‘numpy‘. Para lo cual, usaremos la función ‘fft()‘ del módulo ‘np.fft‘ a la que pasaremos nuestra señal original, definiendo las frecuencias con la función ‘fftfreq()‘ con un intervalo de muestreo de 0.01:

Tras ello, volveremos a emplear las funciones de ‘matplotlib‘ para generar la gráfica de la serie transformada, la cual mostraremos junto a la original:

Así, con todo, nuestro sencillo script quedaría de la siguiente manera:

OUTPUT:

En este ejercicio nos hemos limitado a utilizar la función ‘fft()‘ para calcular la ‘Transformada de Fourier’ discreta de una secuencia unidimensional. Sin embargo, hemos de tener en cuenta que el módulo ‘np.fft‘ de ‘numpy‘ ofrece una gran variedad de funciones para trabajar con la ‘Transformada de Fourier’. A continuación os mostramos algunas de las más comunes:

1-‘np.fft.fft()‘: Calcula la Transformada de Fourier discreta de una secuencia unidimensional.

2-‘np.fft.ifft()’: Calcula las Transformada Inversa de Fourier discreta de una secuencia unidimensional.

3-‘np.fft.fft2()’: Calcula la Transformada de Fourier bidimensional de una matriz.

4-‘np.fft.ifft2()’: Calcula la Transformada Inversa de Fourier bidimensional de una matriz.

5-‘np.fft.fftfreq()’: Genera las frecuencias correspondientes a las salidas de ‘fft‘.

6-‘np.fft.shift()’: Cambia el dominio de frecuencia de salida para centrarlo alrededor de cero.

7-‘np.fft.ishift()’: Deshacer el cambio generados por la función ‘shift()‘.

8-‘np.fft.rfft()’: Calcula la Transformada de Fourier discreta de valores reales.

9-‘np.fft.irfft()’: Calcula la Transformada Inversa de Fourier discreta para valores reales.

Estos métodos son ampliamente utilizados para realizar cálculos de transformadas de Fourier en diferentes dimensiones y tipos de datos, desde datos unidimensionales hasta matrices bidimensionales y valores reales. Permiten realizar análisis frecuencial, filtrado de señales, entre otros procesamientos fundamentales en el procesamiento de señales y el análisis de datos.

Saludos.

AJUSTE DE BRILLO Y CONTRASTE EN IMAGENES, CON ‘OpenCV’ Y ‘Python’.

El ajuste de brillo es una técnica común en el procesamiento de imágenes y visión por computadora. Permite corregir imágenes oscuras, realzar detalles en imágenes sobreexpuestas y ajustar la calidad visual en diversas aplicaciones, como fotografía, detección de objetos y más. En este artículo, exploraremos cómo ajustar el brillo de una imagen utilizando ‘OpenCV‘ y Python. Mostrando varios ejemplos para que puedas comprender y aplicar esta técnica de manera efectiva. Como es habitual, utilizaremos una imagen de muestra para realizar las operaciones:

Como es habitual, antes de empezar deberemos asegurarnos de tener instalados los recursos y librerías necesarios para efectuar las operaciones que queremos realizar. Para esta ocasión, deberemos instalar previamente (si no lo hemos hecho ya) las librerías ‘OpenCV‘ (para manipulación de imágenes) y ‘Numpy‘ (para trabajar con arreglos):

Una vez que tengamos instalado todo lo necesario para trabajar, crearemos un nuevo archivo ‘ajuste_brillo.py‘ en el que empezaremos importando las librerías necesarias para, a continuación, cargar la imagen original (bien introduciendo el nombre de la misma si se encuentra en el mismo directorio del de trabajo, bien introduciendo la ruta hasta la misma en caso contrario):

Una vez cargada la imagen, podremos empezar a ajustar el brillo de la misma. Para ello existen dos funciones en ‘OpenCV‘: ‘cv2.add()‘ con la que podremos incrementar el brillo de la imagen y ‘cv2.subtract()‘ para disminuirlo. Ambas funciones toman dos argumentos: El nombre de la imagen fuente, una matriz que contiene valores de brillo (matriz creada con ‘numpy‘) la cual multiplicaremos por un factor de incremento o decremento de brillo. Empecemos con un ejemplo en el que vamos a incrementar el brillo de la imagen original mediante la función ‘cv2.add()‘ y un factor de incremento de 50, almacenado en la variable ‘brightness_increase‘:

OUTPUT:

Tal y como hemos señalado, podemos disminuir el brillo de nuestra imagen, usando la función ‘cv2.subtract’, multiplicando la matriz de la imagen original por un factor de decremento (variable brightness_decrease‘) de 50. Como en el caso anterior, usaremos la función ‘cv2.imshow()‘ para mostrar tanto la imagen original como su versión modificada:

OUTPUT:

Por otra parte, el ajuste de brillo por sí solo puede no ser suficiente en algunos casos. Para un control más completo, podemos combinar el ajuste del brillo con el del contraste. Para ello podemos usar la función ‘cv2.convertScaleAbs()‘. Esta función toma tres argumentos: la imagen, el factor de escala para el contraste (alpha) y el valor de desplazamiento para el brillo (beta). A continuación mostramos dos ejemplos en los que aumentamos y disminuimos el brillo y contraste de nuestra imagen fuente:

OUTPUT:

OUTPUT:

Como se ve, es muy fácil el efectuar el ajuste de brillo y contraste sobre una imagen usando Python y la librería ‘OpenCV‘. Estos ajustes son útiles en diversas aplicaciones, desde el mejoramiento de imágenes hasta la visión por computadora. A partir de aquí puedes experimentar con los ejemplos proporcionados y personalizar los valores para obtener los resultados deseados en tus imágenes.

Saludos.