Introducción

Procesamiento Digital de Imágenes 

El manejo de las imágenes digitales se ha convertido en las últimas décadas en un tema de interés extendido en diferentes áreas de las ciencias naturales, las ciencias médicas y las aplicaciones tecnológicas entre otras.

Una imagen puede ser definida matemáticamente como una función bidimensional

f(x,y)

Donde:

 (x,y) = son coordenadas espaciales (en un plano),

 f=  en cualquier par de coordenadas es la intensidad o nivel de gris de la imagen en esa coordenada.

Una imagen digital se compone de un número finito de elementos, cada uno con un lugar y valor específicos. Estos elementos son llamados pels, o pixels.

El campo del procesamiento digital de imágenes está construido sobre bases matemáticas y probabilísticas, pero la intuición y análisis humanos juegan un importante papel al momento de escoger una técnica u otra.

Abrir Imagen

A continuación se muestras las técnicas para el mejoramiento de una imagen, se ha ocupado el lenguaje de programación Python con la version Python 2.7.12  

Abrir una imagen con Python

Para poder abrir una imagen es importante primero tener instalado OpenCV en esta ocasión se utilizo la versión 3.1.0

import cv2          #Se importa la libreria cv2, la cual permite abrir una imagen

img = cv2.imread ('ruta_de_la_imagen\nombre_de_tu_imagen.jpg',0) 

cv2.imshow ('Original',img)        #Muestra la imagen

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados:

Negativo de una Imagen

Negativo de una imagen

El negativo de una imagen  es cambiar los tonos oscuros a tonos claros y viceversa los tonos claros a oscuros, aquí dejo el código explicado con comentarios y los resultados de lo que es el negativo de una imagen.

import numpy  as np

import cv2

img = cv2.imread ('C:\Python27\girasol.jpg',0)               #Abrimos una imagen

row, col=img.shape                                                          #Se conoce el tamañao de la imagen                                                   

negativo=np.zeros((row,col),dtype=np.uint8)                  #se crea la matriz, creando una nueva                    variable para la imagen negativo

for i in range(0,row):                                                        #Se recorre la matriz en filas y columnas

                for j in range (0,col):

negativo[i,j]= 255- img[i,j]                       #se invierte el valor que tenga el pixel de              entrada

cv2.imshow ('Original',img)                                             #Muestra imagen de entrada

cv2.imshow ('Negativo',negativo)                                    #Muestra imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados:

Transformación exponencial

Transformación exponencial

Esta función al igual que la logarítmica nos permite manipular el contraste de la imagen. Sin embargo presenta una problema el cual se debe de tener en cuenta al momento de su implementación, el problema que presenta es de desbordamiento de nivel de grises en la imagen resultante debido al exponente f de la función de transformación.

import numpy  as np

import cv2                                                                                        #Se importan las librerías necesarias

import math

img = cv2.imread ('C:\Python27\girasol.jpg',0)                 #Se abre una imagen

row, col=img.shape                                                           #Se conoce el tamaño de la imagen

loga=np.zeros((row,col),dtype=np.uint8)                          #Se crea una matriz

print ' en proceso...'                                                            #Imprime en pantalla: “En proceso,..”

for i in range(0,row):                                                          #Se recorre la matriz

                for j in range (0,col):

                               loga[i,j]= 1*img[i,j]**1.2                   #Se aplica la formula S(x,y)= Cx*

                                                                                            #C puede ser cualquier valor

cv2.imshow ('oscura',img)                                                 #Muestra imagen de entrada

cv2.imshow ('exponente', loga)                                         #Muestra imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados:

Transformación logaritmica

Transformación  logarítmica

A continuación se muestra el código de la transformación logarítmica donde se utiliza el log10 y posteriormente se muestra el resultado se aprecia claramente como en el resultado se aclara la imagen y se observan mas detalles dando así la forma al objeto que se encuentra en la imagen

import numpy  as np

import cv2                                                                         #Se importan las librerías necesarias

import math

img = cv2.imread ('C:\Python27\loga.jpg',0)                      #Se abre una imagen oscura

row, col=img.shape                                                                      #Se conoce el tamaño de la imagen

loga=np.zeros((row,col),dtype=np.uint8)                          #se crea una matriz

np.amax(img)                                                                                 #se conoce el máximo de la imagen

b=np.amax(img)                                                                            #el maximo se almacena en otra variable

c=255/math.log10(1+b)                                                               #se calcula C= 255/log10(1|R|)

print c                                                                                                 #Imprime c

for i in range(0,row):                                                                    #se recorre la matriz

                for j in range (0,col):

                               loga[i,j]= c*math.log10(1+img[i,j])         #se aplica la formula S(x,y)=Clog10(1+r)

                              

cv2.imshow ('oscura',img)                                                         #Muestra la imagen oscura

cv2.imshow ('loga', loga)                                                                            #Muestra claridad en la imagen oscursa para apreciar los detalles desconocidos

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados:

Aumento de contraste

Aumento de contraste

El contraste mide, en cierto modo, el rango dinámico de los colores en la imagen, es decir, una imagen muy contrastada tiene un amplio abanico de colores (o tonos de gris) desde valores muy bajos a valores muy altos. Para una imagen con poco contraste los colores están muy juntos, el margen dinámico es pequeño.

import numpy  as np                                                           #Se importan las librerias

import cv2

img = cv2.imread ('C:\Python27\leons.jpg',0)                   #Se abre la imagen

row, col=img.shape                                                            #se conoce el tamaño de la imagen

print row                                                                             #en esta linea y la siguiente se imprime el tamaño

print col

contraste=np.zeros((row,col),dtype=np.uint8)                   #Se crea una matriz

np.amin(img)                                                                      #Saca el minimo de la imagen

print np.amin(img)                                                             #Imprime el valor minimo

a=np.amin(img)                                                                 #El valor minimo se almacena en una variabe

np.amax(img)                                                                     #Saca el valor maximo

b=np.amax(img)                                                                 #Almacena el maximo en una variable

print b                                                                                 #Imprime valor maximo

for i in range(0,row):                                                          #Se recorre la matriz

                for j in range (0,col):

                               contraste[i,j]=(img[i,j]-b)*255/(a-b)    #Se usa la formula para el contraste

cv2.imshow ('escala grises',img)                                        #Muestra imagen de entrada

cv2.imshow ('contraste',contraste)                                     #Muesta imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultado:

Primer caso

Primer caso:

import numpy  as np                                               #Importacion de librerias

import cv2

img = cv2.imread ('C:\Python27\girasol.jpg',0)       #Imagen de entrada

row, col=img.shape                                                   #Tamaño de la imagen

print row                                                                   #Imprime tamaño

print col

primer=np.zeros((row,col),dtype=np.uint8)             #Se crea una matriz

a=30                                                                          #Se dan valores a los intervalos

b=80

for i in range(0,row):                                                 #Se recorre la matriz

         for j in range (0,col):

x=img[i,j]                                              #Se almacena en una variable la      imagen de entrada

                   if a<=x and x<=b:                                   #Se aplica la formula

                            primer[i,j]=255

                   else:

                            primer[i,j]=0        

cv2.imshow ('Entrada',img)                                    #Muestra imagen de entrada

cv2.imshow ('Primer caso',primer)                         #Muestra imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultado:

Histograma de una imagen

Histograma de una imagen

Se puede considerar como un histograma gráfico o representación, lo que le da una idea general acerca de la distribución de la intensidad de una imagen. Es una parcela con valores de píxel (que van de 0 a 255, no siempre) en el eje X y el número de píxeles correspondientes en la imagen en el eje Y.

Para poder tener ejecutar el código es importante tener instalada lalibreria matplotlib

Import numpy as np

from matplotlib import pyplot as plt                                  #Importacion de librerias necesarias

import cv2

img = cv2.imread ('C:\Python27\leons.jpg',0)                   #Se abre una imagen de entrada

print ('en proceso...')                                                           #Imprime un mensaje

cv2.imshow('imagen', img)                                                #Muesta la imagen de entrada

print ('Valores:')                                                                   #Imprime un mensaje

hist = cv2.calcHist([img],[0],None,[256],[0,256])              #Calcula el histograma de rango [0:256]

plt.hist(img.ravel(),256,[0,256]); plt.show()                       #Muestra la grafica del histograma

print hist                                                                               #Imprime los valores del histograma

k = cv2.waitKey(0)                                                              #Destruye la imagen

cv2.destroyAllWindows()                                                          

print ('fin')                                                                            #Imprime mensaje

Resultados

Segundo caso

Segundo caso

En este caso el valor es a=50 y b=200, puede variar para tener diferentes resultados

import numpy  as np                                                                                    #Importación de librerias

import cv2

img = cv2.imread ('C:\Python27\girasol.jpg',0)                                 #Abre una imagen de entrada

row, col=img.shape                                                                                      #Tamaño de la imagen

ima=np.zeros((row,col),dtype=np.uint8)                                           #Crea una matriz de la imagen

a=50                                                                                                                    #Se asignan valores

b=200

print ('procesando...')                                                                                 #Imprime mensaje

for i in range(0,row):                                                                                    #Se recorre la imagen

                for j in range (0,col):

                               x=img[i,j]                                                                           #Almacena img en una variable

                               if a<=x and x<=b:                                                           #Se comparan las condiciones

                                               ima[i,j]=255

                               else:

                                               ima[i,j]=img[i,j]

cv2.imshow ('entrada',img)                                                                      #Muestra imagen de entrada

cv2.imshow ('Salida',ima)                                                                           #Muestra imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados

Tercer caso

Tercer caso

 En los resultados se muestra como cambia la imagen de salida cuando el valor de a cambia

import numpy  as np                                                                           #Importacion de librerias

import cv2

img = cv2.imread ('C:\Python27\girasol.jpg',0)                                 #Abrir imagen

row, col=img.shape                                                                            #Tamaño de imagen

tercer=np.zeros((row,col),dtype=np.uint8)                                      #Creación de matriz

a=130                                                                                                #Asignación de valores

print ('procesando...')                                                                        #Imprime mensaje

for i in range(0,row):                                                                        #Recorre matriz

                for j in range (0,col):

                               x=img[i,j]                                                         #Img se almacena en una variable

                               if a<=x:                                                             #Se verifican las condiciones

                                               tercer[i,j]=0

                               elif a>x:

                                               tercer[i,j]=255

cv2.imshow ('Entrada',img)                                                            #Muestra imagen de entrada

cv2.imshow ('Salida',tercer)                                                            #Muestra imagen de salida

k=cv2. waitKey(0)

cv2.destroyAllWindows()

print (‘fin’)

Resultados

a=130

a=80

Ecualización de un histograma

Ecualización de una imagen

En los resultados se muestran como quedan las imágenes y las dos gráficas una sin ecualizar y la otra si, con el fin de ver la diferencia de una y otra y observar los cambios efectuados 

import numpy as np                                                                                    #Se importan librerias

from matplotlib import pyplot as plt

import cv2

img = cv2.imread ('C:\Python27\leons.jpg',0)                                   #Abrir imagen

equ = cv2.equalizeHist (img)                                                                    #Ecualiza el histograma

ed = np.hstack ((equ,img))                                                                       #Se almacena en

cv2.imwrite ( 'ed.png' , ed)                                                                       #Muetsra juntas las imagenes

                              

cv2.imshow ('ecua',ed)                                                                 #Muestra imagen original y equalizada

cv2.imshow ('ecua.',equ)

hist = cv2.calcHist([equ],[0],None,[256],[0,256])                             #Se grafica el histograma de la imagen ecualizada

plt.hist(equ.ravel(),256,[0,256]); plt.show()                       #Se muestra histograma ecualizado

k=cv2. waitKey(0)

cv2.destroyAllWindows()

Resultados

Imagen original e imagen ecualizada

Gráfica de la imagen sin ecualizar

 

Gráfica una vez ecualizada