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: