ECUALIZACIÓN DE UN HISTOGRAMA

Veamos que cambios se obtienen en el Histograma al ecualizar la imagen.


import numpy as np
from matplotlib import pyplot as plt                                             #Impportamos las librerias
import cv2

img=cv2.imread('C:\Users\L\Desktop\python\lobo.jpg',0)          #Abrimos una imagen
ecu=cv2.equalizeHist(img)                                                           #Ecualizamos el histograma
ed=np.hstack((ecu,img))                                                               #Lo almacenamos en una variable
cv2.imwrite('ed.png',ed)                                                                #Muestra las imagenes juntas

cv2.imshow('ECUA',ed)                                                                #Muestra la imagen original
cv2.imshow('ECUA',ecu)                                                              #Muestra la nueva imagen
hist=cv2.calcHist([ecu],[0],None,[256],[0,256])          #Grafica el histograma de la imagen ecualizada
plt.hist(ecu.ravel(),256,[0,256]);plt.show()                                   #Muestra el histograma ecualizado
k=cv2.waitKey(0)
cv2.destroyAllWindows()


VISUALIZACIÓN:

Imagen normal:

Imagen Ecualizada: 

Histograma Normal:

Histograma Ecualizado:

CASO 3 

Cambiaremos el valor de la variable para visualizar las diferencia en la imagen.

import numpy as np                                                 #Importamos las librerias

import cv2

img=cv2.imread('C:\Users\L\Desktop\python\pag,jpg',0)          #Agregamos una imagen

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

caso=np.zeros((row,col),dtype=np.uint8)                                     #Creamos matriz

a=130                                                                                          #Asignamos valor

for i in range (0,row):

     for j in range (0,col):                                                              #Recorremos la matriz

          x=img[i,j]                                                                          #Guardamos la imagen en una variable

          if a<x:                                                                                #Verificamos las condiciones

               caso[i,j]=0

          elif a>x:

               caso[i,j]=255

cv2.imshow('IMAGEN',img)                                                     #Mostramos la imagen original

cv2.imshow('NUEVA',caso)                                                      #Mostramos la nueva imagen

k=cv2.waitKey(0)

cv2.destroyAllWindows()

VISUALIZACIÓN:

'a'  con valor de 130

                      'a' con valor de 60 

CASO 2

Se pueden cambiar los valores de x y n para cambiar la nueva apariencia en la imagen nueva.


import numpy as np
import cv2                                                                 #Importamos librerias

img=cv2.imread('C:\Users\L\Desktop\python\galaxy.jpg',0)
row,col=img.shape                                                   #Tamaño de la imagen
caso=np.zeros((row,col),dtype=np.uint8)                   #Creamos la matriz
x=50
n=200                                                                        #Asignamos los valores
for a in range (0,row):
       for b in range (0,col):                                           #Recorremos la matriz
             f=img[a,b]                                                      #Almacenamos la imagen en una variable
             if  x<f  and  f<=n:                                           #Comparamos las condiciones
                  caso[a,b]=255
             else:
                   caso[a,b]=img[a,b]

cv2.imshow('IMAGEN',img)                                    #Mostramos la imagen original
cv2.imshow('NUEVA',caso)                                     #Mostramos la nueva imagen
k=cv2,waitKey(0)
cv2.destroyAllWindows()


VISUALIZACION:

HISTOGRAMA DE UNA IMAGEN


Un histograma es un gráfico en el cual se da una idea de la distribución de los niveles que tiene la imagen. Una gráfica con los valores de píxeles que van de 0 a 255 (aunque no siempre es así).

NOTA: es necesario instalar la librería matplotlib para mostrar el histograma.

import numpy as np
from matplotlib import pyplot as plt                  #Importamos las librerias necesarias
import cv2

img =cv2.imread('C:\Users\L\Desktop\python\lobo.jpg',0)
cv2.imshow('IMAGEN',img)                              #Mostramos la imagen original
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 gráfica del Histograma
print hist                                            #Muestra los valores del Histograma
k = cv2.waitKey(0)
cv2.destroyAllWindows()

Visualización:

CASO 1

import numpy as np

import cv2                                                                 #Importamos las librerias

img = cv2.imread('C:\Users\L\Desktop\python\gatonegro.jpg',0)
row,col=img.shape                                                 #tamaño de la imagen

caso1=np.zeros((row,col),dtype=np.uint8)                  #Creamos la matriz
a=30
b=80                                                                    #Damos los valores a los intervalos
for i in range(0,row):
    for j in range(0,col):                                           #Recorremos la matriz
        x=img[i,j]                                                       #Almacenamos en una variable la imagen principal
        if a < x and x < b:
            caso1[i,j]=255                                            #Aplicamos la Formula
        else:
            caso1[i,j]=0
cv2.imshow('IMAGEN',img)                                  #Mostramos la imagen original
cv2.imshow('CASO1',caso1)                                 #Mostramos la nueva imagen
k=cv2.waitKey(0)

Visualizacion:

AUMENTAR CONTRASTE

El contraste es una cierta forma de medir el rango dinámico de los colores de la imagen, si la imagen esta poco contrastada su margen dinámico es muy pequeño, en cambio si la imagen esta bastante contrastada tiene una amplia diversidad de colores con valores altos y bajos.

import numpy as np
import cv2                                                  #Importamos las librerias

img = cv2.imread('C:\Users\L\Desktop\python\cubos.jpg', 0)
row, col = img.shape                                                     #Tamaño de la imagen
contraste = np.zeros((row, col), dtype=np.uint8)         #Creamos la matriz
np.amin(img)                                             #Minimo de la imagen
a=np.amin(img)                                         #Guardamos el valor minimo en una variable
np.amax(img)                                            #Valor maximo
b = np.amax(img)                                      #Guardamos el valor maximo en una variable
for i in range(0, row):                                 #Recorremos la matriz
    for j in range(0, col):
        contraste[i, j] = (img[i, j] - b) * 255 / (a - b)                 #Formula para el contraste

cv2.imshow('ESCALA DE GRISES',img)              #Mostramos la imagen original
cv2.imshow('CONTRASTADA',contraste)             #Mostramos la imagen mejorada
k=cv2.waitKey(0)
cv2.destroyAllWindows()

VISUALIZACIÓN:

TRANSFORMACIÓN LOGARÍTMICA

La transformación logarítmica es similar ala exponencial, solo que sin el problema de desbordes.

En el siguiente programa podemos mirar como mejora el contraste y brillo de la imagen, permitiéndonos visualizar detalles que no se apreciaban antes de ello. 

import numpy  as np

import cv2                                                                           #Importamos las librerias

import math

img = cv2.imread ('C:\Users\L\Desktop\python\cubos.jpg',0)                      

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

log=np.zeros((row,col),dtype=np.uint8)                            #Creamos la  matriz

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

f=np.amax(img)                                                                 #guardamos el maximo en una variable

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

                                                                                                

for a in range(0,row):                                                     #Recorremos la matriz

      for b in range (0,col):

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

                              

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

cv2.imshow ('TRANSFORMACIÓN', log)                                  #Muestra la mejora de la imagen

k=cv2. waitKey(0)

cv2.destroyAllWindows()

VISUALIZACIÓN:

TRANSFORMACIÓN EXPONENCIAL

Se trata de una función que nos permite manipular el contraste en una imagen. Sin embargo presenta un problema de desbordamiento de nivel de grises, por lo cual en su uso se debe considerar.

import numpy as np
import cv2                                  #Importamos las librerías
import math
img = cv2.imread ('C:\Users\L\Desktop\python\mismanzanas.jpg',0)    
row, col = img.shape
exp=np.zeros((row,col),dtype=np.uint8)                   #Creamos la matriz

for a in range (0,row):
       for b in range (0,col):                                    #Recorremos las matriz
           exp[a,b]=1*img[a,b]**1.2                        #Formula S(x,y)=Cx*

cv2.imshow('IMAGEN',img)                                  #Mostramos imagen original
cv2.imshow('TRANSFORMACIÓN',exp)             #Mostramos imagen transformada
k=cv2.waitkey(0)
cv2.destroyAllWindows()


VISUALIZACIÓN:

IMAGEN EN NEGATIVO

El negativo de una imagen se trata de cambiar los tonos de color mas claros a tonos de color mas obscuros y viceversa.

import numpy as np
import cv2
img = cv2.imread('C:\Users\L\Desktop\python\mismanzanas.jpg', 0)      #Abrimos la imagen
row, col = img.shape                                                                          #Tamaño de la imagen
negativo = np.zeros((row, col), dtype=np.uint8)             #Creamos una matriz usando una variable    

                                                                                           para una nueva imagen 

for a in range(0, row):                                                  #Con un ciclo recorremos las filas                            for b in range(0, col):                                                 y columnas
                 negativo[a, b] = 255 - img[a, b]         #Con esta operación invertimos el valor de los pixeles

cv2.imshow('ORIGINAL', img)                                #Mostramos la imagen original
cv2.imshow('NEGATIVO', negativo)                       #Mostramos la imagen con los colores negativos
k = cv2.waitKey(0)
cv2.destroyAllWindows()

Visualización:

ABRIR UNA IMAGEN

Un sencillo programa para abrir una imagen usando el lenguaje de programación Python se muestra a continuación .
Ademas se mostraran diferentes metodos para el mejoramiento visual de las imágenes usando este lenguaje de programación.

Nota: Es importante el tener instalado el Open CV, de otra manera no seria posible visualizar la imagen.

import cv2                  #Importamos la libreria para abrir la imagen
img=cv2.imread('C:\Users\L\Desktop\python\mismanzanas.jpg',0)
cv2.imshow('IMAGEN',img)
k=cv2.waitkey(0)
cv2.destroyAllWindows()    


  Visualización:

Introducción

El procesamiento digital de imágenes es un campo de investigación abierto. Esta relacionada con las matemáticas, la computación, y el conocimiento cada vez mayor de ciertos órganos del cuerpo humano que intervienen en la percepción y en la manipulación de las imágenes. Aunado a esto, la inquietud del hombre por imitar y usar ciertas características del ser humano como apoyo en la solución de problemas. El avance del Procesamiento Digital de Imágenes se ve reflejado en la medicina, la astronomía, geología, microscopia, etc. Información meteorológica, transmisión y despliegue agilizado de imágenes por Internet tienen sustento gracias a estos avances

Una imagen digital es una imagen (función) f(x,y) que ha sido discretizada tanto en coordenadas espaciales como en luminosidad.

. Una imagen digital puede ser considerada como una matriz cuyos índices de renglón y columna identifican un punto (un lugar en el espacio bidimensional) en la imagen y el correspondiente valor de elemento de matriz identifica el nivel de gris en aquel punto. 

Los elementos de estos arreglos digitales son llamados elementos de imagen o pixels.