jaja broma... bueno continuando con los temas anteriores http://www.forosdelweb.com/f165/proc...vo-2-a-961248/ vamos a ver que mas podemos hacer.Bueno ya tenemos nuestra imagen de muestras, en mi caso YO TE ELIJO LENAAA!! (pokemon parody); ustedes pueden utilizar el dichoso código del curso que ofertan en estos foros donde pueden tomar una fotografía e ir aplicando los filtros que vamos a ir aprendiendo. Ya vimos como pasar nuestra imagen en ARGB a escala de grises o monocromaticos; que otras cosas podemos hacerle a nuestra imagen? Bueno existes varios filtros divertidos a los cuales le podemos aplicar a una imagen tanto a imagenes ARGB o a Grayscale hoy hablaremos de 2 de mis favoritos ya que se pueden aplicar en varios proyectos.
Para iniciar hablaremos de las convoluciones... me voy a saltar varias cosas "cientificoides" que a todo mundo le aburre, una convolucion en pocas palabras es hacer un barrido sin alterarse los 2 datos en este caso la matriz del filtro y la imagen en su forma matricial pero el resultado de ese barrido o interacción sera la imagen final a mostrar. Mejor explicación en http://es.wikipedia.org/wiki/Convoluci%C3%B3n
Bueno ahora los 3 filtros preferidos por mi jejeje
El primero y el que mas me gusta por su efecto y por las diversas aplicaciones que se le pueden sacar jugo es el tututurururututututu (redobles)
FILTRO DE LAPLACE
creo que varios pusieron esa cara nada mas al leer el nombre, bueno este filtro es de tipo espacial utilizado para detección de bordes lo que hace un efecto muy "chido" como decimos por mis rumbos.Ahora, para lograr este filtro en nuestra imagen utilizaremos un Kernel, un kernel en este caso es una matriz muy comun de 3x3 en dimensiones pero pueden existir de varias dimensiones y los valores que esta matriz contiene son sacados a partir de formulas de las cuales no tocare tema
el kernel para el filtro de laplace tiene la siguiente forma.
jeje esas imágenes las saque de la siguiente pagina http://homepages.inf.ed.ac.uk/rbf/HIPR2/log.htm para el interesado puede darle una leída.Podemos utilizar cualquiera de esas 2 matrices o kernels, yo utilizo mi propia matriz calculada la cual tiene una forma siguiente disculpen por la falta de calidad jajaja
{0, 0, -1, 0, 0},
{0, -1, -2, -1, 0},
{-1, -2, 16, -2, -1},
{0, -1, -2, -1, 0},
{0, 0, -1, 0, 0}};
Es una matriz de 5x5, bueno pero y ahora que hago con eso...
es hora de aplicar la convolucion... en este caso en el siguiente codigo realizo la convolucion a mi imagen en escala de grises. Cita:
Ademas agrego una función en la cual checo si son mayores de 255 o menores a 0 ya que eso nos puede meter problemas, la llame Normalizarpublic int[][][] Laplace(int mat[][][])
{
int r1 = 0;
int[] N = new int[3];
int salida[][][] = new int[picw][pich][4];
int[][] filter = {
{0, 0, -1, 0, 0},
{0, -1, -2, -1, 0},
{-1, -2, 16, -2, -1},
{0, -1, -2, -1, 0},
{0, 0, -1, 0, 0}};
for (int y = 2; y < pich-2; y++)
{
for (int x = 2; x < picw-2; x++)
{
for(int i = -2; i<=2; i++)
for(int j = -2; j<=2; j++)
{
r1 = r1 + mat[x+j][y+i][1]*filter[j+2][i+2];
}
r1 = (int) Math.round(r1);
N = Normalizar(r1,r1,r1);
salida[x][y][1] = N[0];
salida[x][y][2] = N[1];
salida[x][y][3] = N[2];
r1 = 0;
}
}
return salida;
}
{
int r1 = 0;
int[] N = new int[3];
int salida[][][] = new int[picw][pich][4];
int[][] filter = {
{0, 0, -1, 0, 0},
{0, -1, -2, -1, 0},
{-1, -2, 16, -2, -1},
{0, -1, -2, -1, 0},
{0, 0, -1, 0, 0}};
for (int y = 2; y < pich-2; y++)
{
for (int x = 2; x < picw-2; x++)
{
for(int i = -2; i<=2; i++)
for(int j = -2; j<=2; j++)
{
r1 = r1 + mat[x+j][y+i][1]*filter[j+2][i+2];
}
r1 = (int) Math.round(r1);
N = Normalizar(r1,r1,r1);
salida[x][y][1] = N[0];
salida[x][y][2] = N[1];
salida[x][y][3] = N[2];
r1 = 0;
}
}
return salida;
}
Cita:
Ok y ahora cual es el resultado de nuestro filtro de laplace, como recuerdan yo había seleccionado a Lenna:private int[] Normalizar(int r1, int r2, int r3)
{
int[] x = new int[3];
if(r1>255)
x[0] = 255;
if(r1<0)
x[0] = 0;
if(r2>255)
x[1] = 255;
if(r2<0)
x[1] = 0;
if(r3>255)
x[2] = 255;
if(r3<0)
x[2] = 0;
return x;
}
{
int[] x = new int[3];
if(r1>255)
x[0] = 255;
if(r1<0)
x[0] = 0;
if(r2>255)
x[1] = 255;
if(r2<0)
x[1] = 0;
if(r3>255)
x[2] = 255;
if(r3<0)
x[2] = 0;
return x;
}
El otro filtro que usaremos es el de Prewitt Sobel también existen por separado pero la combinación de estos dos filtros hacer un efecto muy bueno. Esta pagina ofrece una buena cantidad de imágenes de muestra para que vean los diferentes tipos de filtros de detección de bordes http://www.owlnet.rice.edu/~elec539/...s/moredge.html Los filtros como Sobel tienen una gran diferencia con otros, en este caso podemos tener diferentes tipos de Kernels en los cuales cada uno se dedicara a "encontrar" los bordes dependiendo de su dirección o posición, digamos que existe un Kernel para detectar bordes que solo se encuentren en la posición X, hablando de ejes coordenados.
En este caso uso el Prewitt Sobel para encontrar bordes en la posición X y en la Y del eje coordenado de mi matriz.
Cita:
El efecto que nos da es el siguiente: public int[][][] Prewitt_Sobel(int mat[][][])
{
int r1 = 0, r2 = 0;
int salida[][][] = new int[picw][pich][4];
int[][] filterX = {
{-3, 0, 3},
{-10, 0, 10},
{-3, 0, 3}};
int[][] filterY = {
{-3, -10, -3},
{0, 0, 0},
{3, 10, 3}};
for (int y = 0; y < pich-2; y++)
{
for (int x = 0; x < picw-2; x++)
{
for(int i = 0; i<=2; i++)
for(int j = 0; j<=2; j++)
{
r1 = r1 + mat[x+j][y+i][1]*filterX[j][i];
r2 = r2 + mat[x+j][y+i][1]*filterY[j][i];
}
r1 = (int) Math.round(Math.sqrt(Math.pow(r1, 2)+Math.pow(r2, 2))*0.031);
salida[x][y][1] = r1;
salida[x][y][2] = r1;
salida[x][y][3] = r1;
r1 = 0; r2 = 0;
}
}
return salida;
}
{
int r1 = 0, r2 = 0;
int salida[][][] = new int[picw][pich][4];
int[][] filterX = {
{-3, 0, 3},
{-10, 0, 10},
{-3, 0, 3}};
int[][] filterY = {
{-3, -10, -3},
{0, 0, 0},
{3, 10, 3}};
for (int y = 0; y < pich-2; y++)
{
for (int x = 0; x < picw-2; x++)
{
for(int i = 0; i<=2; i++)
for(int j = 0; j<=2; j++)
{
r1 = r1 + mat[x+j][y+i][1]*filterX[j][i];
r2 = r2 + mat[x+j][y+i][1]*filterY[j][i];
}
r1 = (int) Math.round(Math.sqrt(Math.pow(r1, 2)+Math.pow(r2, 2))*0.031);
salida[x][y][1] = r1;
salida[x][y][2] = r1;
salida[x][y][3] = r1;
r1 = 0; r2 = 0;
}
}
return salida;
}
Bueno gente me retiro, espero estos filtros les sirva y seria bueno que comentaran si tuvieran dudas o alguna sugerencia en mis códigos ya que eso nos servirá a todos. O suban sus imágenes con sus Kernels que encontraron.
Nos vemos gente.
jajaja 
jeje 
Este tema le ha gustado a 3 personas