| gvSIG desktop 1

/* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 */

package org.cresques.filter.correction;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.util.Arrays;

import org.cresques.io.data.RasterBuf;

/**

 * Filtro de Mediana que se aplica en la imagen. Toma como entrada la imagen

 * y el lado de la ventana de filtrado.

 * 

 * @author Diego Guerrero Sevilla  <diego.guerrero@uclm.es>

 *

 */

public class MedianImageFilter extends MedianFilter {

        public MedianImageFilter(){

                super();

        }

        public void pre(){

                exec = true;

                this.image = (Image) params.get("raster");

                height = image.getHeight(null);

        width = image.getWidth(null);

                this.ladoVentana = ((Integer) params.get("ladoVentana")).intValue();

                imageResult = new BufferedImage(image.getWidth(null),image.getHeight(null), BufferedImage.TYPE_INT_ARGB);

                super.pre();

        }

public void process(int col, int line) {

                int px;

                ladoVentana = Math.abs(ladoVentana);     // El lado de la ventana debe

                if(ladoVentana % 2 == 0) ladoVentana++;  // ser positivo e impar.

            int tamVentana = ladoVentana*ladoVentana;

            int semiLado = (ladoVentana-1)>>1;

                int [] ventanaR = new int[tamVentana];

                int [] ventanaG = new int[tamVentana];

                int [] ventanaB = new int[tamVentana];

                px = ((BufferedImage) image).getRGB(col, line); 

                int alpha = (px & 0xff000000);       //Extraigo el alpha para mantenerlo.

                                // Obtener el vector con la ventanas de muestras (una por componente RGB)

                                int k=0;

                                for (int i=-semiLado;i<=semiLado;i++)

                                        for(int j=-semiLado;j<=semiLado;j++)

                                        {

                                                if((col+i >= 0) && (line+j >= 0) &&(col+i < width)&&(line+j < height)){  

                                                        px = ((BufferedImage) image).getRGB(col+i, line+j);

                                                        ventanaR[k] =(px & 0x00ff0000) >> 16;

                                                        ventanaG[k] =(px & 0x0000ff00) >> 8;

                                                        ventanaB[k] =(px & 0x000000ff);

                                                        k++;

                                                }

                                        }

                                // Ordenar los valores de las ventanas

                                    // se supone que usa quickSort.

                                Arrays.sort(ventanaR,0,k);

                                Arrays.sort(ventanaG,0,k);

                                Arrays.sort(ventanaB,0,k);

                        //Extraer los elementos centrales y asignarselos al pixel (x,y)

                        ((BufferedImage) imageResult).setRGB(col, line,         alpha | 

                                                                                                        ((ventanaR[k>>1] << 16) & 0x00ff0000) |

                                                                                                        ((ventanaG[k>>1] << 8) & 0x0000ff00) |

                                                                                                        (ventanaB[k>>1] & 0x000000ff));

        }

        public void processLine(int y) {

                // TODO Auto-generated method stub

        }

        public int getInRasterDataType() {

                return RasterBuf.TYPE_IMAGE;

        }

        public int getOutRasterDataType() {

                return RasterBuf.TYPE_IMAGE;

        }

        public Object getResult(String name) {

                if (name.equals("raster")) {

            return (Object) this.imageResult;

        } else {

            return null;

        }

        }

        public void processSuperSampling(int col, int line){

                int px;

                ladoVentana = Math.abs(ladoVentana);     // El lado de la ventana debe

                if(ladoVentana % 2 == 0) ladoVentana++;  // ser positivo e impar.

            int tamVentana = ladoVentana*ladoVentana;

            int semiLado = (ladoVentana-1)>>1;

            int indiceX,indiceY,origenX,origenY;

                int [] ventanaR = new int[tamVentana];

                int [] ventanaG = new int[tamVentana];

                int [] ventanaB = new int[tamVentana];

                px = ((BufferedImage) image).getRGB(col, line); 

                int alpha = (px & 0xff000000);       //Extraigo el alpha para mantenerlo.

                if ((contX+1-semiLado>=0) && (contY+1-semiLado>=0)&& (contX+1+semiLado<stepX.length) && (contY+1+semiLado<stepY.length)){

                        // Calcular el alcance del kernel cuyo centro es (x,y)

                        int offsetX=0;

                        int offsetY=0;

                        for (int i=0;i<semiLado;i++){

                                offsetX=offsetX+stepX[contX+i+1];

                                offsetY=offsetY+stepY[contY+i+1];

                        }

                        if((col+offsetX<width)&&(line+offsetY<height)){

//                                 Obtener el vector con las ventanas de muestras (una por componente RGB) **************************

                                // Me situo en la esquina superior izquierda del "kernel"

                                origenX=col;

                                origenY=line;

                                for (int i=0;i<semiLado;i++){

                                        origenX=origenX-stepX[contX-i];

                                        origenY=origenY-stepY[contY-i];        

                                }

                                //Recorro el kernel seg�n los step

                                int k=0;

                                indiceX=origenX;

                                for (int i=-semiLado;i<=semiLado;i++){

                                        indiceY=origenY;

                                        for(int j=-semiLado;j<=semiLado;j++){                

                                                px = ((BufferedImage) image).getRGB(indiceX, indiceY);

                                                ventanaR[k] =(px & 0x00ff0000) >> 16;

                                                ventanaG[k] =(px & 0x0000ff00) >> 8;

                                                ventanaB[k] =(px & 0x000000ff);

                                                indiceY=indiceY+stepY[contY+j+1];

                                                k++;

                                        }

                                        indiceX=indiceX+stepX[contX+i+1];

                                }

                                //**************************************************************************************************

                                // Ordenar los valores de las ventanas

                                    // se supone que usa quickSort.

                                Arrays.sort(ventanaR);

                                Arrays.sort(ventanaG);

                                Arrays.sort(ventanaB);

                                //Extraer los elementos centrales y asignarselos al pixel (x,y)

                                for(int i = col; i < width && i < (col + stepX[contX + 1]); i++)

                                        for(int j = line; j < height && j < (line + stepY[contY + 1]); j++)

                                                        ((BufferedImage) imageResult).setRGB(i, j,         alpha | 

                                                                                                                ((ventanaR[(tamVentana-1)/2] << 16) & 0x00ff0000) |

                                                                                                                ((ventanaG[(tamVentana-1)/2] << 8) & 0x0000ff00) |

                                                                                                                (ventanaB[(tamVentana-1)/2] & 0x000000ff));

                                return;

                        }

                }

                 // Si la ventana se sale de la imagen dejar el pixeles original

                for(int i = col; i < width && i < (col + stepX[contX + 1]); i++)

                        for(int j = line; j < height && j < (line + stepY[contY + 1]); j++)

                                ((BufferedImage) imageResult).setRGB(i, j, px);

        }

}