Application: gvSIG desktop

package org.gvsig.raster.grid.filter.pansharp;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Dimension2D;

import java.awt.image.BufferedImage;

import java.awt.image.PixelGrabber;

import java.util.ArrayList;

import org.gvsig.raster.buffer.BufferFactory;

import org.gvsig.raster.buffer.RasterBuffer;

import org.gvsig.raster.buffer.RasterBufferInvalidException;

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.RasterDataset;

import org.gvsig.raster.datastruct.ViewPortData;

import org.gvsig.raster.grid.Grid;

import org.gvsig.raster.grid.render.ImageDrawer;

import org.gvsig.raster.grid.render.Rendering;

import org.gvsig.raster.hierarchy.IRasterDataset;

import com.iver.cit.gvsig.fmap.ViewPort;

public class PanSharpeningByteFilter extends  PanSharpeningFilter {

public PanSharpeningByteFilter (){

        super();        

}

public void pre(){

        // Recogemos los parametros

        loadParam();

        checkInput();  

        Dimension2D dimension = new Dimension(width, height);

         //Creamos el buffer donde se pinta la pancromatica

        imagePancr = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

        /*// Cargamos la imagen pancromatica en el Buffer

        BufferFactory ftryPancromatica=new BufferFactory(dataset.getGeoRasterMultiDataset().getDataset(pancrName));

        Rendering rPancromatica= new Rendering(ftryPancromatica);

        ViewPort vp = new ViewPort(null);

        ViewPortData vpPancr = new ViewPortData(vp.getProjection(),dataset.getGeoRasterMultiDataset().getDataset(pancrName).getExtent(), dimension);

        rPancromatica.draw((Graphics2D)imagePancr.getGraphics(), vpPancr);*/

        //Creamos el buffer donde se pinta la imagen de multiespectral. 

        //Pintar Imagen Multiespectral en imageMultiespectral

        imageMultiespec = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        BufferFactory ftryMultiespc=new BufferFactory(dataset.getMultiRasterDataset());

        Grid  a=null;

        try {

                a=new Grid(ftryMultiespc);

        } catch (RasterBufferInvalidException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

        }

        ImageDrawer imageM= new ImageDrawer();

        imageM.setBuffer(a.getRasterBuf());

        imageM.setBufferSize(a.getRasterBuf().getWidth(),a.getRasterBuf().getHeight());

        imageMultiespec = imageM.drawBufferOverImageObject(true, new int[]{0,1,2});

        rasterResult = RasterBuffer.getBuffer(IBuffer.TYPE_BYTE, width, height, 3, true);        

}                

/**

 *  Validamos que haya alguna otra banda adem?s de la pancrom?tica y que la pancrom?tica 

 *  sea de mayor resoluci?n que las dem?s.

 */

private void checkInput(){

        exec = true;

    if(heightMultiespec >= heightPancr || widthMultiespec >= widthPancr || heightMultiespec == 0 || widthMultiespec == 0)

            exec = false;

    String ficheros[]= dataset.getFileName();

    for(int i=0;i<ficheros.length;i++){

            if(ficheros[i] != pancrName){

                    if(dataset.getMultiRasterDataset().getDataset(ficheros[i]).getHeight() != heightMultiespec || dataset.getMultiRasterDataset().getDataset(ficheros[i]).getWidth()!= widthMultiespec){ 

                            exec = false;

                            break;

                    }                   

            }

    }

}

private void loadParam(){

        raster = (RasterBuffer) params.get("raster");

        posPancromatica= ((Integer) params.get("posPancromatica")).intValue();

        dataset=  (IRasterDataset)params.get("dataset");

        bandOrder = (ArrayList) params.get("order");

        alpha = ((Integer) params.get("alpha")).intValue();

    method = (String) params.get("method");

    coef = ((Double) params.get("coef")).doubleValue();

    coefBrovey = ((Integer) params.get("coefBrovey")).intValue();

        height = raster.getHeight();

        width = raster.getWidth();

        // Name de pancromatica

        pancrName=dataset.getMultiRasterDataset().getBands().getBand(posPancromatica).getFileName();

        params.put("pancName", pancrName);

        heightPancr = dataset.getMultiRasterDataset().getDataset(pancrName).getHeight();

    widthPancr = dataset.getMultiRasterDataset().getDataset(pancrName).getWidth();

    // Nombre de los ficheros que componen el dataser

    String[] ficherosNames= dataset.getFileName(); 

    for(int i=0;i<ficherosNames.length;i++){

            if(ficherosNames[i] != pancrName){

                    heightMultiespec = dataset.getMultiRasterDataset().getDataset(ficherosNames[i]).getHeight(); 

                    widthMultiespec = dataset.getMultiRasterDataset().getDataset(ficherosNames[i]).getWidth();

            }

    }

   relX = (int)widthPancr/widthMultiespec;

   relY = (int)heightPancr/heightMultiespec;

}

public void execute() {

        // Para cada linea 

        pre();

        if(exec){

                int[]                         pRGBArrayMultiesp = new int[width];

            int[]                         pRGBArrayPancr = null;

            PixelGrabber        pg = null;

            int                         widthDst = width * relX;

            //Para cada linea leemos los valores RGB del image. Aplicamos el algoritmo

            //y escribimos el resultado.

            if(method.equals("hsl")){

                    for(int iLine=0;iLine<height ;iLine++){

                            pg = new PixelGrabber(imageMultiespec, 0, iLine, width, 1, pRGBArrayMultiesp, 0, width);

                            try {

                        pg.grabPixels();

                    } catch (InterruptedException e) {e.printStackTrace();}    

                    pRGBArrayPancr = processIHS(pRGBArrayMultiesp, iLine);                            

                            ((BufferedImage)imagePancr).setRGB(0, iLine, width, 1, pRGBArrayPancr, 0, width);

                    }

            }else{

                    for(int iLine=0;iLine<height ;iLine++){

                            pg = new PixelGrabber(imageMultiespec, 0, iLine, width, 1, pRGBArrayMultiesp, 0, width);

                            try {

                        pg.grabPixels();

                    } catch (InterruptedException e) {e.printStackTrace();}    

                    pRGBArrayPancr = processBrovey(pRGBArrayMultiesp, iLine);                            

                            ((BufferedImage)imagePancr).setRGB(0, iLine, width, 1, pRGBArrayPancr, 0, width);

                    }

            }

        }        

        post();

        System.out.print("ccc");

}

public void post(){

        // Pasar el Buffer de datos de la imgPancr  a rasterResult

        PixelGrabber        pg = null;

        int[]                         datosLinea= new int[width];

        for(int iLine=0;iLine<height ;iLine++){

                //Recojo los datos RGB de la fila en Hexadecimal

                pg = new PixelGrabber(imagePancr, 0, iLine, width, 1, datosLinea, 0, width);

                try {

                        pg.grabPixels();

                } catch (InterruptedException e) {

                        e.printStackTrace();

                }

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

                        byte r = (byte)((datosLinea[i] >> 16) & 0xff);

                        byte g = (byte)((datosLinea[i] >> 8) & 0xff);

                        byte b = (byte)(datosLinea[i] & 0xff);

                        rasterResult.setElem(iLine, i, 0, r);

                        rasterResult.setElem(iLine, i, 1, g);

                        rasterResult.setElem(iLine, i, 2, b);

                }

        }

}

/**

 * @return  tipo de dato del buffer de entrada

 * */

public int getInRasterDataType() {

        return RasterBuffer.TYPE_BYTE;

}

/**

 * @return tipo de dato del buffer de salida

 * */

public int getOutRasterDataType() {

        return RasterBuffer.TYPE_BYTE;

}

/**

 * @return  buffer resultante tras aplicar el filtro

 * */

public Object getResult(String name) {

        if (name.equals("raster"))

                return (IBuffer)rasterResult;

                return null;

}

/**

 * Aplica la operaci?n de refinamiento sobre el buffer Multiespectral que contiene 

 * el RGB que es pasado por par?metro utilizando la pancrom?tica.

 * @param bufferInput        Buffer rgb 

 * @param length                longitud del buffer de la pancromatica utilizado

 * @param iLine                        l?nea leida de la imagen multiespectral

 * @return                                buffer con el resultado de la operaci?n

 */

private int[] processBrovey(int[] bufferInput, int iLine){            

        double[]                hsl;

        int[]                        rgb;            

        PixelGrabber         pg = null;

        //Longitud del buffer de salida

        int                         widthDst = width * relX;

        //Buffer de salida

        int[]                        bufferPancr = new int[width];

        pg = new PixelGrabber(imagePancr, 0, iLine, width, 1, bufferPancr , 0, width);

        try {

        pg.grabPixels();

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

    for(int iElem=0; iElem<width; iElem++){

                int r = ((bufferInput[iElem] >> 16) & 0xff);

                int g = ((bufferInput[iElem] >> 8) & 0xff);

                int b = (bufferInput[iElem] & 0xff);

                byte i = (byte)((bufferPancr[iElem] >> 16) & 0xff);

                double scale = (3.0*(i+coefBrovey))/(r+g+b+1.0);

                r *= scale;g *= scale;b *= scale;                        

                bufferPancr[iElem] = ((alpha << 24) & 0xff000000) | 

                                                        ((r << 16) & 0x00ff0000)| 

                                                        ((g << 8) & 0x0000ff00) | 

                                                        (b & 0x000000ff);

        }

        return bufferPancr;

}

/**

 * Aplica la operaci?n de refinamiento sobre el buffer Multiespectral que contiene 

 * el RGB que es pasado por par?metro utilizando la pancrom?tica.

 * @param bufferInput        Buffer rgb 

 * @param length                longitud del buffer de la pancromatica utilizado

 * @param iLine                        l?nea leida de la imagen multiespectral

 * @return                                buffer con el resultado de la operaci?n

 */

private int[] processIHS(int[] bufferInput, int iLine){            

        int[]                        bufferPancr = new int[width];

        /* double[]                hsl;

        int[]                        rgb;

        PixelGrabber         pg = null;

        //Buffer de salida

        pg = new PixelGrabber(imagePancr, 0, iLine, width, 1, bufferPancr , 0, width);

        try {

        pg.grabPixels();

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

    int[] uvw , tmp = new int[3];

    double[] xyz;

        for(int iElem=0; iElem<width; iElem++){

                xyz = ColorSpaceConversion.RGBtoHSL( (bufferInput[iElem] >> 16) & 0x000000ff,

                                                                                   (bufferInput[iElem] >> 8) & 0x000000ff,

                                                                                         bufferInput[iElem] & 0x000000ff);

                xyz[2] = ((bufferPancr[iElem] & 0x000000ff)/255.0) + coef;

                tmp[0] = (int)(255.0 * xyz[0] / 360.0 + 0.5);

                tmp[2] = (int) (xyz[2]*255. + 0.5);

                tmp[1] = (int) (xyz[1]*255. + 0.5);

                uvw = ColorSpaceConversion.HSLtoRGB(tmp[ColorSpaceConversion.H],

                                                                                        tmp[ColorSpaceConversion.S],

                                                                                        tmp[ColorSpaceConversion.L]);

                bufferPancr[iElem] = ((alpha << 24) & 0xff000000) |

                                                        ((uvw[0] << 16) & 0x00ff0000)|

                                                        ((uvw[1] << 8) & 0x0000ff00) |

                                                        (uvw[2] & 0x000000ff);

        }*/

        return bufferPancr;

}

/**

 * Aplica la operaci?n de refinamiento sobre el buffer Multiespectral que contiene 

 * el RGB que es pasado por par?metro utilizando la pancrom?tica.

 * @param bufferInput        Buffer rgb 

 * @param length                longitud del buffer de la pancromatica utilizado

 * @param iLine                        l?nea leida de la imagen multiespectral

 * @return                                buffer con el resultado de la operaci?n

 *//*

private int[] processBrovey(byte[] bufferInputR,byte[] bufferInputG,byte[] bufferInputB , int iLine){            

        int[]                        bufferPancr = new int[width];

    for(int iElem=0; iElem<width; iElem++){

                int r = ((bufferInputR[iElem] >> 16) & 0xff);

                int g = ((bufferInputG[iElem] >> 8) & 0xff);

                int b = (bufferInputB[iElem] & 0xff);

                byte i = (byte)((bufferPancr[iElem] >> 16) & 0xff);

                double scale = (3.0*(i+coefBrovey))/(r+g+b+1.0);

                r *= scale;g *= scale;b *= scale;                        

                bufferInputR[iElem] =(byte) ((r << 16) & 0x00ff0000);

                bufferInputG[iElem] =(byte) ((g << 8) & 0x0000ff00) ;

                bufferInputB[iElem] =(byte) (b & 0x000000ff); 

        }

        return bufferPancr;

}*/

}