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 es.idr.teledeteccion.classification;

import java.awt.Component;

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import java.lang.reflect.Array;

import javax.swing.JOptionPane;

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

import org.gvsig.gui.beans.incrementabletask.IIncrementable;

import org.gvsig.gui.beans.incrementabletask.IncrementableEvent;

import org.gvsig.gui.beans.incrementabletask.IncrementableListener;

import org.gvsig.gui.beans.incrementabletask.IncrementableTask;

import org.gvsig.raster.buffer.RasterBuffer;

import org.gvsig.raster.dataset.GeoRasterWriter;

import org.gvsig.raster.dataset.IBuffer;

import org.gvsig.raster.dataset.NotSupportedExtensionException;

import org.gvsig.raster.dataset.RasterDriverException;

import org.gvsig.raster.grid.Grid;

import org.gvsig.raster.grid.roi.ROI;

import org.gvsig.rastertools.cutting.WriterBufferServer;

import Jama.Matrix;

import com.iver.andami.PluginServices;

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

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

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

/**

 * Proceso de clasificacion de una imagen. Obtencion de una imagen tematica cuyos valores 

 * han sido clasificados atendiendo a un grupo de clases.

 * Metodo de clasificacion: Maxima Probabilidad

 * 

 * */

public class ClassificationProcess  implements Runnable, IIncrementable, IncrementableListener{

        private Grid                                         inputGrid                        = null;

        private RasterBuffer                         rasterResult                = null;

        private MapContext                                 mapContext                         = null;

        private int                                         percent                           = 0;

        private boolean                                 cancel                                 = false;

        private Thread                                         blinker                                = null;

        private ROI                                         classVector[]                = null;

        private IncrementableTask                incrementableTask         = null;

        private WriterBufferServer                 writerBufferServer        = null;

        private String                                         fileNameOutput                 = null;

        public  ClassificationProcess(Grid imageGrid, ROI roisArray[], MapContext mapContext, String fileNameOutput){

                inputGrid= imageGrid;

                classVector= roisArray;

                this.mapContext=mapContext;

                this.fileNameOutput= fileNameOutput;

        }

        public void start() {

                cancel = false;

                blinker = new Thread(this);

                blinker.start();

        }

        /**Proceso de clasificacion para cada uno de los pixeles de la imagen*/

        public void run() {

                rasterResult= RasterBuffer.getBuffer(IBuffer.TYPE_DOUBLE, inputGrid.getRasterBuf().getWidth(), inputGrid.getRasterBuf().getHeight(), 3, true);

                int c=0;

                byte data[]= new byte[inputGrid.getBandCount()];

                for(int i=0; i<inputGrid.getLayerNY();i++){

                        for(int j=0; j<inputGrid.getLayerNX();j++){

                                inputGrid.getRasterBuf().getElemByte(i, j, data);

                                c= getPixelClass(data);

                                rasterResult.setElem(i, j, 0,(double) classVector[c].getColor().getRed());

                                rasterResult.setElem(i, j, 1,(double) classVector[c].getColor().getGreen());

                                rasterResult.setElem(i, j, 2,(double) classVector[c].getColor().getBlue());

                        }

                        percent = i*100/inputGrid.getNX();

                }

                // Escribir en fichero

                writeToFile();

        }

        /**

         * Metodo que implementa el clasificador de maxima probabilidad. 

         * Para cada pixel, obtiene la calase que minimiza la expresion: -Ln(P(x))= Ln(|Si|)+Y'* inverse(Si)*Y

         * 

         * @param pixelBandBalues: array con los valores de un pixel 

         * @return clase a la que pertenece el pixel (por el metodo de maxima probabilidad)

         * */

        public int getPixelClass(byte pixelBandsValues[]){

                double probabilidades[]=new double[classVector.length];

                // Para todas las clases definidas obtnemos el grado de pertenencia

                for (int clase=0; clase<classVector.length;clase++)

                {

                        // Vector Y

                        double[][] y = new double[inputGrid.getBandCount()][1];

                        for (int i=0;i<inputGrid.getBandCount();i++){

                                classVector[clase].getGrid().setBandToOperate(i);

                                y[i][0]=pixelBandsValues[i]-classVector[clase].getMeanValue();

                        }

                        Matrix Y = new Matrix(y);

                        Matrix S= new Matrix(classVector[clase].getVarCovMatrix());

                        Matrix result= (Y.transpose().times(S)).times(Y);

                        // Obtencion probabilidad de pertenencia del pixel a la clase clase

                        double probability= Math.log(Math.abs(S.det()))+ result.get(0, 0);

                        probabilidades[clase]=probability;

                }        

                // Obtner clase para la que la probabilidad es minima

                int clasefinal=0;

                if(probabilidades.length>1){

                        for (int x=0; x<classVector.length;x++){

                                if (probabilidades[x]<probabilidades[clasefinal])

                                        clasefinal=x;

                        }

                }

                return clasefinal;

        }

        public void writeToFile(){

//                 Escritura del raster a disco en fichero temporal

                // To Do: Parametrizar el path y el nombre del fichero de salida.

                GeoRasterWriter grw = null;

                writerBufferServer = new WriterBufferServer(rasterResult);

                try {

                        grw = GeoRasterWriter.getWriter(writerBufferServer, fileNameOutput, rasterResult.getBandCount(),new AffineTransform(), rasterResult.getWidth(), rasterResult.getHeight(), rasterResult.getDataType(), GeoRasterWriter.getWriter(fileNameOutput).getParams(), null);

                } catch (NotSupportedExtensionException e) {

                        e.printStackTrace();

                } catch (RasterDriverException e) {

                        e.printStackTrace();

                }

                try {

                        grw.dataWrite();

                } catch (IOException e) {

                        e.printStackTrace();

                }

                grw.writeClose();

            rasterResult.free();

            mapContext.beginAtomicEvent();

                FLayer lyr = null;

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

                if (endIndex < 0)

                         endIndex = fileNameOutput.length();

                try {

                         lyr = FLyrRasterSE.createLayer(fileNameOutput.substring(fileNameOutput.lastIndexOf(File.separator) + 1, endIndex),new File(fileNameOutput), mapContext.getProjection());

                } catch (LoadLayerException e) {

                         JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(),

                         PluginServices.getText(this, "error_cargar_capa"));

                 }

                mapContext.getLayers().addLayer(lyr);

                mapContext.endAtomicEvent();

                mapContext.invalidate();

                if (incrementableTask != null)

                        incrementableTask.processFinalize();

        }

        public  RasterBuffer getGridResult(){

                return rasterResult;

        }

        public String getLabel() {

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

        }

        public String getLog() {

                if (writerBufferServer==null)

                        return PluginServices.getText(this,"obteniendo_imagen")+"...";

                else

                        return PluginServices.getText(this,"escribiendo_resultado")+"...";

        }

        public int getPercent() {

                if (writerBufferServer==null)

                        return percent;

                else

                        return writerBufferServer.getPercent();

        }

        public String getTitle() {

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

        }

        public void actionCanceled(IncrementableEvent e) {

                if(writerBufferServer != null)

                        writerBufferServer.setCanceled(true, 0);

                cancel = true;

        }

        public void actionResumed(IncrementableEvent e) {

        }

        public void actionSuspended(IncrementableEvent e) {

        }

        public void setIncrementableTask(IncrementableTask incrementableTask) {

                this.incrementableTask = incrementableTask;

                this.incrementableTask.addIncrementableListener(this);

        }        

}