En la entrada anterior me quedo pendiente profundizar algo en la base del código de la máscara de enfoque. La máscara de enfoque, y casi cualquier filtrado que se haga sobre una imagen, se implementa a partir de la convolución bidimensional discreta. En dicha convolución, el valor del píxel de salida se calcula mediante la suma ponderada de píxeles vecinos. En lo que se refiere al procesamiento de imágenes, la convolución se realiza entre la imagen y una matriz (los coeficientes del filtro) llamada máscara, o kernel. De manera matemática la convolución bidimensional se representa según:
Ya que lo más habitual es emplear una máscara de 3X3 elementos para realizar la convolución bidimensional, entonces la ecuación anterior se convierte en:
Como ejemplo para aclarar las áridas expresiones matématicas anteriores, tomamos una matriz de 4X4 que representa los valores de los píxeles de una imagen, y como máscara una matriz de 3X3
-Matriz imagen
[15 20 101 100]
[200 50 55 8]
[10 11 230 202]
[100 130 115 120]
-Máscara
[7 8 3]
[1 1 0]
[1 2 1]
Los pasos para realizar la convolución consisten en:
1.- Rotar la máscara 180º a partir del elemento del centro.
[1 2 1]
[0 1 1]
[3 8 7]
2.-Sobreponer el centro de la máscara sobre el elemento de interés.
[15 1 20 2 101 1 100]
[200 0 50 1 55 1 8]
[10 3 11 8 230 7 202]
[100 130 115 120]
3.-Multiplicar cada valor (peso) de la máscara rotada por el píxel de la matriz de imagen que se encuentra "bajo" la máscara.
4.-Sumar los productos individuales en el apartado anterior.
El resultado entonces es:
[197 88]
[181 190]
En el caso de trabajar en los extremos de la imagen lo que se hace es insertar ceros en los extremos, lo que se conoce como zero padding. El resultado del ejemplo es una matriz de 2X2 ya que no hemos trabajado en la zona de los extremos de la imagen.
El código en Python, usando numpy y Scipy para realizar la convolución bidimensional es:
import numpy as np
import cv2
kernel=np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], 'uint8')
signal=np.array([[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], 'uint8')
rows=signal.shape[0]-kernel.shape[0]+1
cols=signal.shape[1]-kernel.shape[1]+1
output=np.zeros((rows,cols), 'uint8')
kernel_reversed=np.rot90(np.rot90(kernel))
for i in range(0, output.shape[0]):
for j in range(0, output.shape[1]):
#desplazando el kernel
signal_patch=signal[i:i+len(kernel),j:j+len(kernel)]
output[i][j]=(kernel_reversed*signal_patch).sum()
print signal_patch
print output
Como referencias pueden valer los dos libros siguientes. El segundo es un clásico en el tratamiento digital de señales, viene a ser la continuación del, más clásico aún, Oppenheim.
-Gonzalez, R.C., and Woods, P.,
Digital Image Processing, Addison Wesley, 2002
-Proakis, John G., and Manolakis, Dimitris G.,
Digital Signal Processing: Principles, Algorithms and applications, Prentice-Hall Inc, 1996.
Mostrando entradas con la etiqueta lenguajes de programación. Mostrar todas las entradas
Mostrando entradas con la etiqueta lenguajes de programación. Mostrar todas las entradas
lunes, 15 de abril de 2013
Convolución Bidimensional
Etiquetas:
bidimensional,
convolucion,
imagen digital,
kernel,
lenguajes de programación,
librería,
máscara,
numpy,
programación,
python,
scipy,
zero padding
miércoles, 8 de agosto de 2012
Pure Data-PD
Pure Data (PD) es un lenguaje de programación gráfico, en tiempo real, para audio, vídeo y procesado de gráficos. Es la tercera rama más importante de la familia de lenguajes de programación patcher conocida como Max (Max / FTS, ISPW Max, Max / MSP,jMax, etc), y fue originalmente desarrollado por Miller Puckette en el IRCAM. Aunque el núcleo de PD sigue siendo desarrollado y mantenido por Miller Puckette, se incluye el trabajo de muchos desarrolladores, por lo que todo el paquete supone un gran esfuerzo comunitario.
PD es un ejemplo de lenguaje de programación de "flujo de datos". Es decir, las funciones u "objetos" son conectados, o "parcheados", unos con otros en un ambiente gráfico que modela el flujo de control y de los datos (audio, vídeo y/o gráficos). Por lo que PD es un lenguaje de programación especialmente orientado al procesado de señales.
El entorno de programación posee una base modular de código, en el que los objetos son utilizados como elementos de construcción en el desarrollo de programas en Pure Data. Además, el programa se hace arbitrariamente extensible a través de una API pública, por lo que alienta a otros desarrolladores a añadir sus propias rutinas, ya sea en el lenguaje de programación C o, con la ayuda de otros lenguajes externos. Estas unidades de código modulares y reusables, que resultan de la programación de algoritmos en PD, se suelen denominar "patches", y son usadas como programas independientes y compartidas libremente entre la comunidad de usuarios de PD.
Para el desarrollo de los ejemplos gráficos que se presentarán en posteriores posts en este apartado se emplea la líbreria GEM (Graphics Environment for Multimedia),que está indicada para la generación de gráficos OpenGL en tiempo real.
Suscribirse a:
Entradas (Atom)