IMÁGENES RGB

RGB

Es el acrónimo inglés Red, Green, Blue, Rojo, Verde, Azul).

En el modelo RGB, cada color aparece en sus componentes espectrales primarios de rojo, verde y azul. Este modelo está basado en un sistema coordenado Cartesiano. El subespacio de interés para el modelo RGB es un cubo.

Los valores RGB son las tres esquinas del cubo que interceptan los ejes; el cyan, magenta y amarillo son las otras tres esquinas; el negro esta en el origen; y el blanco en la esquina más lejana al origen. En este modelo, la escala de grises (valores iguales de R,G y B) se extienden sobre la línea que une el negro con el blanco. [1]

Figura 1. Este cubo muestra de manera gráfica el modelo RGB. 

Considere una imagen RGB en el que cada imagen roja, verde y azul es una imagen de 8-bits. Bajo estas condiciones cada pixel de color RGB [esto es, una tripleta de valores (R,G,B)] se dice que tiene 24 bits de profundidad (3 planos imagen por el número de bits por plano). El término imagen de color total (full color) se utiliza generalmente para denotar una imgen de color RGB de 24-bits. El número total de colores de una imagen RGB de 24-bits es (28)3=16,777,216.[1]

MODELO DE COLOR HSI 

Corresponden a implementaciones más "precisas" del punto de vista psicovisual, del modelo de Matiz (H), Saturación (S) e Intensidad (I).

Esta transformación deriva del modelo RGB. El cubo RGB se transforma en el cilindro HSI.[2]

* La saturacion  corresponde a la distancia radial 

* El matiz corresponde al ángulo del sistema de coordenadas polar.

*La intensidad es el eje perpendicular al plano de coordenadas polares.

Figura 2. Esta imagen representa al espacio HSI

Conversión RGB a HSI

Esta dado de la siguiente manera:[2]

Código del modelo HSI.

import cv2

import numpy as np

import math

image = cv2.imread ('C:\Users\EROS\Pictures\Procesamiento Digital\Manzana.jpg',1)

ima = cv2.imread ('C:\Users\EROS\Pictures\Procesamiento Digital\Manzana.jpg',0)

row , col = ima.shape

H=np.zeros((row,col))

S=np.zeros((row,col))

I=np.zeros((row,col))

r=np.zeros((row,col))

g=np.zeros((row,col))

b=np.zeros((row,col))

image2 = np.zeros((row,col,3))

for i in range(row):

    for j in range(col):

        r[i,j]=image[i,j,0]/255.0

        g[i,j]=image[i,j,1]/255.0

        b[i,j]=image[i,j,2]/255.0

def color(r,g,b,row,col):

    paso1=1

    paso2=1

    p=1/2

    for i in range(row):

        for j in range(col):

            paso1=p*((r[i,j]-g[i,j])+(r[i,j]-b[i,j]))

            paso2=((r[i,j]-g[i,j])**2)+(r[i,j]-b[i,j])*(g[i,j]-b[i,j])

            paso2=paso2**(1/2)

            if(b[i,j] <= g[i,j]):

                H[i, j] =(math.acos(paso1/paso2))/360

            if(b[i,j]>g[i,j]):

                H[i,j]=(360-(math.acos(paso1/paso2)))/360

    return H

def saturacion(r,g,b):

    #min1 = 4

    row , col = b.shape

    for i in range(row):

        for j in range(col):

            if(r[i,j]<=g[i,j]):

                if(r[i,j]<=b[i,j]):

                    min1 = r[i,j]

            else:

                if(g[i,j]<=b[i,j]):

                    min1=g[i,j]

                else:

                    min1=b[i,j]

            S[i,j]=1-(3/(r[i,j]+g[i,j]+b[i,j]))*min1

    return S

def intensidad(r, g, b):  # metodo i

    row, col = r.shape

    for i in range(row):

        for j in range(col):

            I[i,j]=(r[i,j]+g[i,j]+b[i,j])*1/3

    return I

def conversion(r, g, b,H,S,I,row,col):  # metodo i

    for i in range(row):

        for j in range(col):

            H[i,j]=H[i,j]*360

            if(H[i,j]==0):

                b[i,j]=I[i,j]-((I[i,j]*S[i,j]))

                r[i,j]=I[i,j]+2*(I[i,j]*S[i,j])

                g[i,i]=I[i,j]-I[i,j]*S[i,j]

            if(H[i,j]==120):

                b[i,j]=I[i,j]-I[i,j]*S[i,j]

                r[i,j]=I[i,j]-I[i,j]*S[i,j]

                g[i,i]=I[i,j]+2*(I[i,j]*S[i,j])

            if(H[i,j]==240):

                b[i,j]=I[i,j]+2*(I[i,j]*S[i,j])

                r[i,j]=I[i,j]-I[i,j]*S[i,j]

                g[i,i]=I[i,j]-I[i,j]*S[i,j]

            if(H[i,j]>0 and H[i,j]<120 ):

                b[i,j]=I[i,j]*(1-S[i,j])

                r[i,j]=I[i,j]*(1+(S[i,j]*math.cos(H[i,j]))/(math.cos(60-H[i,j])))

                g[i,j]=3*I[i,j]-(r[i,j]+b[i,j])

            if(120< H[i,j] and H[i,j]<240 ):

                H[i,j]=H[i,j]-120

                r[i,j]=I[i,j]*(1-S[i,j])

                g[i,j]=I[i,j]*(1+(S[i,j]*math.cos(H[i,j]))/(math.cos(180-H[i,j])))

                b[i,j]=3*I[i,j]-(r[i,j]+g[i,j])

            if(240< H[i,j] and H[i,j]<360 ):

                H[i,j]=H[i,j]-240

                g[i,j]=I[i,j]*(1-S[i,j])

                b[i,j]=I[i,j]*(1+(S[i,j]*math.cos(H[i,j]))/(math.cos(300-H[i,j])))

                r[i,j]=3*I[i,j]-(g[i,j]+b[i,j])

    return r,g,b

H= color(r,g,b,row,col)

S = saturacion(r,g,b)

I = intensidad(r,g,b)

r,g,b=conversion(r,g,b,H,S,I,row,col)

for i in range(row):

    for j in range(col):

        image2[i,j,0]=(r[i,j])

        image2[i,j,1]=(g[i,j])

        image2[i,j,2]=(b[i,j])

cv2.imshow('convertida',image2)

cv2.imshow('i',I)

cv2.imshow('original',image)

cv2.waitKey(0)

cv2.destroyAllWindows()

 Figura 3. Ejemplo de una imagen original, monocromática y su modelo HSI. 

 Figura 4. Otro ejemplo de una imagen original  monocromática y su modelo HSI. 

Referencias

[1]http://www2.elo.utfsm.cl/~elo328/pdf1dpp/PDI13_Color_1dpp.pdf

[2]http://turing.iimas.unam.mx/~elena/PDI-Mast/Tema_6_C.pdf

  Consulta 13 de Enero del 2017

  Consulta 15 de Enero del 2017

DETECCIÓN DE BORDES

Bordes: Variaciones fuertes de la intensidad que corresponden a las fronteras de los objetos visualizados.[1]

Operadores de gradiente

Detectan los bordes en base a las derivadas espaciales de la imagen que se calculan mediante operadores de convolución.

La derivada de una señal continua proporciona las variaciones locales con respecto a la variable, de forma que el valor de la derivada es mayor cuanto más rápidas son estas variaciones. En el caso de funciones bidimensionales f(x,y), la derivada es un vector que apunta en la dirección de la máxima variación de f(x,y) y cuyo módulo es proporcional a dicha variación. Este vector se denomina gradiente y se define: 

Figura 1. La imagen muestra las funciones gradientes

La primera función es la derivada parcial fx(x,y) (gradiente de fila GF(i,j) ) y gradiente en el eje Y (GC(i,j)), se obtienen mediante la convolución de la imagen con las máscaras. La magnitud y orientación del vector gradiente obtiene la imagen final, como lo muestra la función 2.

Operador de Roberts. 

Obtiene buena respuesta ante bordes diagonales. Ofrece buenas prestaciones en cuanto a localización. El gran inconveniente de este operador es su extremada sensibilidad al ruido y por tanto tiene pobres cualidades de detección. [1]

En el caso discreto, se puede aproximar la derivada diferenciando los valores contiguos.

*Aproximación discreta en esa región:

*Otra alternativa: diferencias cruzadas: 

Es el operador de gradiente más simple. Utiliza direcciones diagonales para calcular el vector gradiente mediante las mascaras que se muestran en la figura 1.1.[1]

Figura 1.1. Mascaras de operador de Roberts.

Pseudocodigo para el Operador de Roberts.

1. Leemos la imagen en escala de grises.

2. Se obtiene el tamaño de la imagen.

3. Creamos las matriz  para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.

Bordex = np.zeros((row, col), dtype=np.uint8)

Bordey = np.zeros((row, col), dtype=np.uint8)

Final = np.zeros((row, col), dtype=np.uint8)

5. Creamos dos arrays para el filtro de Borde en X y otro en Y de  tipo float, en este caso el tamaño será de 2x2.

x = np.array([[1,0],[0,-1]], dtype=np.float)

y = np.array([[0,1],[-1, 0]], dtype=np.float)

6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad, esto para X.

6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

      a = i-1
      c = j-1
      Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [c, i] * x[1, 0]
      + image [i, j] * x [1, 1]

        .

7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad., esto para Y.

7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

        a = i-1
        c = j-1
        Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [c, i] * y[1, 0]

        + image [i, j] * y [1, 1]

8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación. 

Mx=pow(Bordex,2)

My=pow(Bordey,2)

Final = ((Mx)+(My))**0.5

9. Mostramos la imagen original.

10. Mostramos la imagen Final aplicada la función.

11. Guardamos Imagen.

12. Cerramos ventanas.

13. Fin

Figura 1.2 Ejemplo de una imagen original y su función operador de Roberts.

Operador de Prewitt. 

El operador de Prewitt expande la definición del gradiente en máscara de 3 x 3 para ser más inmune al ruido, utiliza la misma ecuación que Roberts, pero con una constante k=1 como se muestra en la figura 1.3.[1]

                                           Figura 1.3. Mascaras de operador de Prewitt

Este operador no otorga importancia especial a píxeles cercanos al centro de la máscara

Pseudocodigo para el  Operador de Prewitt.

1. Leemos la imagen en escala de grises.

2. Se obtiene el tamaño de la imagen.

3. Creamos las matriz  para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.

Bordex = np.zeros((row, col), dtype=np.uint8)

Bordey = np.zeros((row, col), dtype=np.uint8)

Final = np.zeros((row, col), dtype=np.uint8)

5. Creamos dos arrays para el filtro de Borde en X y otro en Y de  tipo float, en este caso el tamaño será de 3x3.

x = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float)

6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad, esto para X.

6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

        a = i-1
        b = i + 1
        c = j-1
        d = j + 1
        Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
        + image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
        + image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]

        

7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad., esto para Y.

7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

        a = i-1
        b = i + 1
        c = j-1
        d = j + 1
        Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [a, d] * y[0, 2]
        + image [i, c] * y[1, 0] + image [i, j] *y [1, 1] + image [i, d] * y [1, 2]
        + image [b, c] * y [2, 0] + image [b, j]*y [2, 1] + image [b, d] * y [2, 2]

8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación. 

Mx=pow(Bordex,2)

My=pow(Bordey,2)

Final = ((Mx)+(My))**0.5

9. Mostramos la imagen original.

10. Mostramos la imagen final aplicada la función.

11. Guardamos Imagen.

12. Cerramos ventanas.

13. Fin

       

                       Figura 1.4 Ejemplo de una imagen original y su función operador de Prewitt.

Operador de Sobel. 

De igual manera que en el operador de Robert, para este operador usamos la misma ecuación que es la magnitud del gradiente, al igual que los demás operadores Sx y Sy puede implementarse  usando máscaras de convolución.[2]

Este operador pone un especial énfasis en pixeles cercanos al centro de la máscara, este maneja una constante k=2, se obtiene con el producto de un vector de diferenciación por uno de suavizamiento. [2]

Figura 1.5. Mascaras del operador de Sobel

Pseudocodigo para el Operador de Sobel.

Nota: En este caso solo cambia las máscaras

1. Leemos la imagen en escala de grises.

2. Se obtiene el tamaño de la imagen.

3. Creamos las matriz  para cada función a realizar, en este caso se utilizaran tres, una para la función Borde en X, otra para la función Borde en Y y una más para la función final ya que es donde se almacenará los datos finales a través del calculo de la magnitud de las dos funciones anteriores, estas de tipo uint8 con el tamaño de la imagen.

Bordex = np.zeros((row, col), dtype=np.uint8)

Bordey = np.zeros((row, col), dtype=np.uint8)

Final = np.zeros((row, col), dtype=np.uint8)

5. Creamos dos arrays para el filtro de Borde en X y otro en Y de  tipo float, en este caso el tamaño será de 3x3.

x = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float)
y = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float)

6. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad, esto para X.

6.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

        a = i-1
        b = i + 1
        c = j-1
        d = j + 1
        Bordex [i, j] = image [a, c] * x[0, 0] + image [a, j] * x [0, 1] + image [a, d] * x[0, 2]
        + image [i, c] * x [1, 0] + image [i, j] *x [1, 1] + image [i, d] * x [1, 2]
        + image [b, c] * x [2, 0] + image [b, j] *x [2, 1] + image [b, d] * x [2, 2]

        

7. Se realiza el recorrido de la matriz con dos ciclos for, una para filas y otro para columnas pero que empiece en la posición 1  y termine con una posición menos para el manejo de la vecindad., esto para Y.

7.1.Realizamos la convolución del tamaño del filtro con la subimagen del mismo tamaño que este, utilizando la vecindad:

        a = i-1
        b = i + 1
        c = j-1
        d = j + 1
        Bordey [i, j] = image [a, c] * y[0, 0] + image [a, j] * y [0, 1] + image [a, d] * y[0, 2]
        + image [i, c] * y[1, 0] + image [i, j] *y [1, 1] + image [i, d] * y [1, 2]
        + image [b, c] * y [2, 0] + image [b, j]*y [2, 1] + image [b, d] * y [2, 2]

8. Calculamos la magnitud de las dos funciones para obtener la matriz Final con la siguiente operación. 

Mx=pow(Bordex,2)

My=pow(Bordey,2)

Final = ((Mx)+(My))**0.5

9. Mostramos la imagen original.

10. Mostramos la imagen final, aplicada la función.

11. Guardamos Imagen.

12. Cerramos ventanas.

13. Fin

                                                                                                                                                                   

Figura 1.4 Ejemplo de una imagen original y su función operador de Sobel.

Laplaciano de una Gaussiana.

Este detector de orillas se basa en la segundas derivadas o Laplaciano de una Gaussiana.

La ventaja de usar un operador que se basa en la segunda derivada es que se puede estimar con mayor presición la localización de la orilla, que es exactamente donde la segunda derivada cruza cero.

En una primera aproximación al Laplaciano de una Gaussiana, podría preprocesarse la imagen con un suavizamiento Gaussiano, para eliminar ruido, seguido de un operador Laplaciano. El Laplaciano de una Gaussiana (LOG: Laplacian of a Gaussian) se expresa como:[3]

∇^2G = (∂^2G/∂x ^2 ) + (∂^ 2G/∂y^ 2 )

Donde G es una distribución normal o Gaussiana en dos dimensiones.

Figura 1.5.Máscara 3x3 para el operador Laplaciano. 

Figura 1.6.Máscara 3x3 para el operador Laplaciano de una Gaussiana. 

Referencias

[1]http://catarina.udlap.mx/u_dl_a/tales/documentos/lis/ramos_r_m/capitulo3.pdf

[2]http://www.sc.ehu.es/ccwgrrom/transparencias/pdf-vision-1-transparencias/capitulo-6.pdf

  Consulta 15 de Diciembre del 2016

  Consulta 8 de Enero del 2017