Application: gvSIG desktop

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

 *

 * Copyright (C) 2006 Instituto de Desarrollo Regional 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Iba?ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)

 *   Campus Universitario s/n

 *   02071 Alabacete

 *   Spain

 *

 *   +34 967 599 200

 */

package org.gvsig.remotesensing.mosaic.process;

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import org.gvsig.fmap.raster.layers.FLyrRasterSE;

import org.gvsig.raster.RasterProcess;

import org.gvsig.raster.buffer.BufferFactory;

import org.gvsig.raster.buffer.RasterBuffer;

import org.gvsig.raster.buffer.RasterBufferInvalidException;

import org.gvsig.raster.buffer.WriterBufferServer;

import org.gvsig.raster.dataset.GeoRasterWriter;

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.IRasterDataSource;

import org.gvsig.raster.dataset.InvalidSetViewException;

import org.gvsig.raster.dataset.NotSupportedExtensionException;

import org.gvsig.raster.dataset.io.RasterDriverException;

import org.gvsig.raster.grid.Grid;

import org.gvsig.raster.grid.GridExtent;

import org.gvsig.raster.grid.OutOfGridException;

import org.gvsig.raster.util.RasterToolsUtil;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.exceptions.layers.LoadLayerException;

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

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

/** 

* Clase que implementa el proceso de construccion de un mosaico.

* 

* @author aMu?oz (alejandro.mu?oz@uclm.es)

* @version 30/4/2008

* */

public class MosaicProcess extends RasterProcess {

        // Layers que intervienen en el proceso

        private FLayers layers = null;

        // Extend completo del mosaico

        private GridExtent fullExtend= null;

        // Grid resultante

        Grid mosaicGrid = null;

        // Buffers con las imagenes

        RasterBuffer buffers[]= null;

        // Codigo operacion mayor, menor,media valor de la situada encima.

        int codOp= 0; 

        // indicador de proceso

        int percent=0;

//         PROVISIONAL -para cargar capa en vista-

        private MapContext mapContext                         = null;

        // writer para escritura en fichero 

        private WriterBufferServer writerBufferServer =null;

//  Numero de bandas 3 o 1 dependiendo de si es RGB o Nivel de gris

        int numbands=0;

        /** Inicializaci?n de los par?metros

         *  layers -  FLayers con los layers seleccionados para el mosaico.

         * 

         *         En la inicializacion se calcula el grid resultante.

         * */

        public void init() {

                layers= (FLayers)getParam("layers");

                codOp= getIntParam("codOp");

                numbands= getIntParam("numbands");

//                 PROVISIONAL

                mapContext = (MapContext)getParam("contexto");        

//                 Calculo del extend resultante

                fullExtend= calculateExtend(layers);

                int bands[]= new int[numbands];

                for(int i=0; i<numbands;i++)

                        bands[i]=i;

                try {

                                mosaicGrid= new Grid(fullExtend,fullExtend,IBuffer.TYPE_BYTE,bands);

                } catch (RasterBufferInvalidException e) {

                        RasterToolsUtil.messageBoxError("buffer_incorrecto", this, e);

                }

        }

        /**

         *  Proceso

         * */

        public void process() throws InterruptedException {

                // Parte de carga de los datos

                buffers= new RasterBuffer[layers.getLayersCount()];

                IRasterDataSource dsetCopy = null; 

                try {

                        double minX= fullExtend.getMin().getX();

                        double minY= fullExtend.getMin().getY();

                        double maxX=  fullExtend.getMax().getX();

                        double maxY=  fullExtend.getMax().getY();

                        // Se cargan todos los raster en los grid correspondientes

                        percent=0;

                        for(int i=0; i< layers.getLayersCount();i++)

                        {

                                dsetCopy = ((FLyrRasterSE)layers.getLayer(i)).getDataSource().newDataset();

                                BufferFactory bufferFactory = new BufferFactory(dsetCopy);

                                bufferFactory.setAdjustToExtent(false);

                                if (!RasterBuffer.loadInMemory(dsetCopy))

                                        bufferFactory.setReadOnly(true);

                                bufferFactory.setDrawableBands(((FLyrRasterSE)layers.getLayer(i)).getRenderBands());

                                bufferFactory.setAreaOfInterest(minX,minY,maxX,maxY,fullExtend.getNX(),fullExtend.getNY());

                                buffers[i]= (RasterBuffer) bufferFactory.getRasterBuf();

                                percent=(int)(i*100/layers.getLayersCount());

                        }

                }catch (RasterDriverException e) {

                        RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_writer"), this, e);        

                } catch (InvalidSetViewException e) {

                        RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_extension"), this, e);        

                } catch (InterruptedException e) {

                        Thread.currentThread().interrupt();

                }

//                 Construccion del mosaico: Operaci?n M?ximo

                if(codOp==0){

                        int progress = 0;

                        for(int band=0; band<numbands; band++){

                                mosaicGrid.setBandToOperate(band);

                                for(int col=0; col<mosaicGrid.getLayerNY(); col++){

                                        progress++;

                                        for(int row=0; row<mosaicGrid.getLayerNX();row++){

                                                setValueMax(row,col,band);

                                        }

                                        percent=(int)( progress*100/(mosaicGrid.getLayerNY()*numbands));

                                }

                        }

                }

//                Construccion del mosaico: Operaci?n M?nimo

                if(codOp==1){

                        int progress = 0;

                        for(int band=0; band<numbands; band++){

                                mosaicGrid.setBandToOperate(band);

                                for(int col=0; col<mosaicGrid.getLayerNY(); col++){

                                        progress++;

                                        for(int row=0; row<mosaicGrid.getLayerNX();row++){

                                                setValueMin(row,col,band);

                                        }

                                        percent=(int)( progress*100/(mosaicGrid.getLayerNY()*numbands));

                                }

                        }

                }

//                 Construccion del mosaico: Operaci?n Media

                if(codOp==2){

                        int progress = 0;

                        for(int band=0; band<numbands; band++){

                                mosaicGrid.setBandToOperate(band);

                                for(int col=0; col<mosaicGrid.getLayerNY(); col++){

                                        progress++;

                                        for(int row=0; row<mosaicGrid.getLayerNX();row++){

                                                setValueMean(row,col,band);

                                        }

                                        percent=(int)( progress*100/(mosaicGrid.getLayerNY()*numbands));

                                }

                        }

                }

//                Construccion del mosaico: Operaci?n Superior

                if(codOp==3){

                        for(int col=0; col<mosaicGrid.getLayerNY(); col++){

                                for(int row=0; row<mosaicGrid.getLayerNX();row++){

                                        //setValueMax(row,col);

                                        percent= col*100/mosaicGrid.getLayerNY();

                                }

                        }

                }

                // Escritura en fichero

                writeToFile((RasterBuffer)mosaicGrid.getRasterBuf(),0);

                writeToFile((RasterBuffer)buffers[0],1);

                writeToFile((RasterBuffer)buffers[1],2);

        }

        /**

         *  M?todo que establece para la coordenada x,y el valor m?ximo 

         *  de todos los valores para ese p?xel en cualquiera de las imagenes.

         *  Si el valor en cualquiera de las imagenes es noData no es tenido en cuenta 

         *  @param cordenada x 

         *  @param coordenada y  

         * */

        public void setValueMax(int x, int y, int band){

                byte result=-128;

                for(int buf=0;buf<buffers.length;buf++){

                        byte data = (byte)(buffers[buf].getElemByte(y,x,band));

//                                 TO DO: TENER EN CUENTA NODATA REAL DEL BUFER

                        if(data==97)

                                data=-128;

                        result=(byte) Math.max((byte)result,(byte)data);                

                }

                try {

                                mosaicGrid.setCellValue(x,y,(byte)result);

                                result=-128;

                } catch (OutOfGridException e) {

                                e.printStackTrace();

                }

        }

        /**

         *  M?todo que establece para la coordenada x,y el valor m?ximo 

         *  de todos los valores para ese p?xel en cualquiera de las imagenes.

         *  Si el valor en cualquiera de las imagenes es noData no es tenido en cuenta 

         *  @param cordenada x 

         *  @param coordenada y  

         * */

        public void setValueMin(int x, int y,int band){

                byte result=127;

                        for(int buf=0;buf<buffers.length;buf++){

                                byte data = (byte)(buffers[buf].getElemByte(y,x,band)&0xff);

                                // TO DO: TENER EN CUENTA NO DATA

                                if(data==97)

                                        data=127;

                                result=(byte) Math.min((byte)result,(byte)data);                

                        }

                        try {

                                mosaicGrid.setCellValue(x,y,(byte)result);

                        } catch (OutOfGridException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

        }

        /**

         *  M?todo que establece para la coordenada x,y el valor medio  

         *  de todos los valores para ese p?xel en cualquiera de las imagenes.

         *  Si el valor en cualquiera de las imagenes es noData no es tenido en cuenta 

         *  @param cordenada x 

         *  @param coordenada y  

         * */

        public void setValueMean(int x, int y, int band){

                int result=0;

                int buffTotales= buffers.length;

                for(int buf=0;buf<buffers.length;buf++){

                        int data = (int)((byte)(buffers[buf].getElemByte(y,x,band)&0xff)+127);

//                        TO DO: TENER EN CUENTA NODATA REAL DEL BUFER

                        if(data==97+127){

                                buffTotales--;

                                data =0;

                        }

                        result+=data;                

                }

                if(buffTotales==0)

                        buffTotales=1;

                result=(int)((result/buffTotales));

                try {

                                mosaicGrid.setCellValue(x,y,(byte)(result-127));

                } catch (OutOfGridException e) {

                                e.printStackTrace();

                }

        }

        /**

         * M?todo que calcula el extend resultante para la operaci?n de mosaico

         * 

         * @param layers que intervienen en la operacion.

         * @return GridExtend del mosaico

         * */

        private GridExtent calculateExtend (FLayers layers){

                GridExtent result= null;

                double minX=0,maxX=0,minY=0,maxY=0, cellSize=25;

                try {

                        minX = layers.getLayer(0).getFullExtent().getMinX();

                        minY = layers.getLayer(0).getFullExtent().getMinY();

                        maxX = layers.getLayer(0).getFullExtent().getMaxX();

                        maxY = layers.getLayer(0).getFullExtent().getMaxY();

                        for(int i=1; i<layers.getLayersCount();i++){

                                minX= Math.min(minX,layers.getLayer(i).getFullExtent().getMinX());

                                minY= Math.min(minY,layers.getLayer(i).getFullExtent().getMinY());

                                maxX= Math.max(maxX,layers.getLayer(i).getFullExtent().getMaxX());

                                maxY= Math.max(maxY,layers.getLayer(i).getFullExtent().getMaxY());

                        }

                } catch (ExpansionFileReadException e) {

                        e.printStackTrace();

                } catch (ReadDriverException e) {

                        e.printStackTrace();

                }

                result = new GridExtent(minX,minY,maxX,maxY,cellSize);

                return result;

        }

        /**

         *  M?todo que escribe en fichero el grid resultante de la operaci?n de mosaico.

         *  

         * */

        public void writeToFile(RasterBuffer buf, int i){

                try{

                        String filename= "mosaico"+i+".tif";

                        GeoRasterWriter grw = null;

                        writerBufferServer = new WriterBufferServer(buf);

                        AffineTransform aTransform = new AffineTransform(fullExtend.getCellSize(),0.0,0.0,-fullExtend.getCellSize(),fullExtend.getMin().getX(),fullExtend.getMax().getY());

                        grw = GeoRasterWriter.getWriter(writerBufferServer, filename, mosaicGrid.getBandCount(),aTransform, mosaicGrid.getRasterBuf().getWidth(), mosaicGrid.getRasterBuf().getHeight(), mosaicGrid.getRasterBuf().getDataType(), GeoRasterWriter.getWriter(filename).getParams(), null);

                        grw.dataWrite();

                        grw.setWkt((String)((FLyrRasterSE)layers.getLayer(0)).getWktProjection());

                        grw.writeClose();

                        //mapContext.beginAtomicEvent();

                        FLayer lyr = null;

                        int endIndex = filename.lastIndexOf(".");

                        if (endIndex < 0)

                                endIndex = filename.length();

                        lyr = FLyrRasterSE.createLayer(

                                        filename.substring(filename.lastIndexOf(File.separator) + 1, endIndex),

                                        filename,

                                        ((FLyrRasterSE)layers.getLayer(0)).getProjection()

                                        );

                        mapContext.getLayers().addLayer(lyr);

                        mapContext.endAtomicEvent();

                        mapContext.invalidate();

                } catch (NotSupportedExtensionException e) {

                        RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_writer_notsupportedextension"), this, e);

                } catch (RasterDriverException e) {

                        RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_writer"), this, e);        

                } catch (IOException e) {

                        RasterToolsUtil.messageBoxError(PluginServices.getText(this, "error_writer"), this, e);

                }catch (LoadLayerException e) {

                        RasterToolsUtil.messageBoxError("error_cargar_capa", this, e);

                }catch (InterruptedException e) {

                        Thread.currentThread().interrupt();

                }         

        }

        /**

         * @return descripcion

         * */

        public String getTitle() {

                return PluginServices.getText(this,"mosaic_process");

        }

        /**

         * @return  indicador de progreso

         * */

        public int getPercent() {

                if(writerBufferServer==null)

                        return percent;

                else 

                        return writerBufferServer.getPercent();

        }

        /*

        // Identificaci?n de zonas de solapamiento

        public boolean getSolapes(FLyrRasterSE raster1, FLyrRasterSE raster2){

                Grid grid1=null, grid2=null, aux=null;;

                IRasterDataSource dsetCopy = null; 

                dsetCopy =raster1.getDataSource().newDataset();

                BufferFactory bufferFactory = new BufferFactory(dsetCopy);

                IRasterDataSource dsetCopy2 = null; 

                dsetCopy2 =raster2.getDataSource().newDataset();

                BufferFactory bufferFactory2 = new BufferFactory(dsetCopy2);

                if (!RasterBuffer.loadInMemory(dsetCopy))

                        bufferFactory.setReadOnly(true);        

                try {

                        grid1 = new Grid(bufferFactory,raster1.getRenderBands());

                        grid2= new Grid(bufferFactory2,raster2.getRenderBands());

                } catch (RasterBufferInvalidException e) {

                        e.printStackTrace();

                }        

                // En grid1 la imagen con la cordenada x menor.

                if(grid2.getGridExtent().getMin().getX()< grid1.getGridExtent().getMin().getX())

                        {

                                try {

                                        grid1 = new Grid(bufferFactory2,raster2.getRenderBands());

                                        grid2= new Grid(bufferFactory,raster1.getRenderBands());

                                } catch (RasterBufferInvalidException e) {

                                        e.printStackTrace();

                                }        

                        }

                double xmin= grid1.getGridExtent().getMin().getX();

                double xmax= grid1.getGridExtent().getMax().getX();

                double ymin= grid1.getGridExtent().getMin().getY();

                double ymax= grid1.getGridExtent().getMax().getY();

                double xmin2= grid2.getGridExtent().getMin().getX();

                double ymin2= grid2.getGridExtent().getMin().getY();

                if(!(xmin2>xmin && xmin2<xmax)){

                        System.out.print("Las imagenes no se solapan en las X");

                        return false;

                }

                if(!(ymin2>ymin && ymin2<ymax)){

                        System.out.print("Las imagenes no se solapan en las Y");

                        return false;

                }

                // Detectado el solapamiento

                System.out.print("Rango x["+ xmin2 + ","+ Math.min(xmax,grid2.getGridExtent().getMax().getX())+"].");

                System.out.print("Rango y["+ ymin2 + ","+ Math.min(ymax,grid2.getGridExtent().getMax().getY())+"].");

                return true;

        }*/

}