Application: gvSIG desktop » gvSIG raster

/* 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.raster.georeferencing.lib.impl;

import java.awt.geom.AffineTransform;

import java.util.HashMap;

import javax.swing.SwingUtilities;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.RasterManager;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.GeoPointList;

import org.gvsig.fmap.dal.coverage.datastruct.NoData;

import org.gvsig.fmap.dal.coverage.datastruct.Params;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.store.DataServerWriter;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

import org.gvsig.fmap.dal.coverage.store.RasterWriter;

import org.gvsig.i18n.Messages;

import org.gvsig.raster.tools.algorithm.base.RasterBaseAlgorithmLibrary;

import org.gvsig.raster.tools.algorithm.base.process.IProcessActions;

import org.gvsig.raster.tools.algorithm.base.process.ProcessException;

import org.gvsig.raster.tools.algorithm.base.process.RasterProcess;

import org.gvsig.raster.tools.algorithm.base.util.Interpolation;

/**

 *  Resamples a image with the georeferencing parameters

 *  @author Nacho Brodin (nachobrodin@gmail.com)

 **/

public class GeoreferencingProcess extends RasterProcess implements IProcessActions {

        public static String             RASTER_STORE       = "RasterStore";

        public static String             GCPS               = "gcps";

        public static String             ORDER              = "Order";

        public static String             TIME               = "Time";

        public static String             RESULT             = "RESULT";

        public static String             FILENAME           = "FileName";

        public static String             XCELLSIZE          = "xCellSize";

        public static String             YCELLSIZE          = "yCellSize";

        public static String             INTERPOLATION      = "InterpolationMethod";

        //Capa a georreferenciar

        private RasterDataStore          store                          = null;

        //Fichero de salida

        private String                   filename           = null;

        // Lista puntos de control

        private GeoPointList             gcps               = null;

        // Metodo de resampleado utilizado

        private int                      rMethod            = 0;

        private int                      orden              = 0;

        private int[]                    bands              = null;

        //Tama?o de celda en X si es pasada por el usuario

        private double                   xCellSize           = 0;

        //Tama?o de celda en Y si es pasada por el usuario

        private double                   yCellSize           = 0;

        private DataServerWriter         writerBufferServer  = null;

        private long                     milis               = 0;

        public static void registerParameters() {

                RASTER_STORE = RasterBaseAlgorithmLibrary.registerInputParameter(RASTER_STORE, RasterDataStore.class);

                INTERPOLATION = RasterBaseAlgorithmLibrary.registerInputParameter(INTERPOLATION, Integer.class); 

                GCPS = RasterBaseAlgorithmLibrary.registerInputParameter(GCPS, GeoPointList.class);

                ORDER = RasterBaseAlgorithmLibrary.registerInputParameter(ORDER, Integer.class);

                TIME = RasterBaseAlgorithmLibrary.registerOutputParameter(TIME, Long.class);

        }

        /** Metodo que recoge los parametros del proceso georreferenciacion de un raster

        * <LI>rasterSE: capa a georeferenciar</LI>

        * <LI>filename: path con el fichero de salida</LI>

        * <LI>method: metodo de resampleo </LI>

        */

        public void init() {

                store = getParam(RASTER_STORE) != null ? (RasterDataStore)getParam(RASTER_STORE) : null;

                gcps = getParam(GCPS) != null ? (GeoPointList) getParam(GCPS) : null;

                filename = (String)getParam(FILENAME);

                rMethod = (int)getIntParam(INTERPOLATION);

                orden = (int)getIntParam(ORDER);

                bands = new int[store.getBandCount()];

                xCellSize = (double)getDoubleParam("xCellSize");

                yCellSize = (double)getDoubleParam("yCellSize");

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

                        bands[i]= i;

        }

        public void process() throws ProcessInterruptedException, ProcessException {

                long t1 = new java.util.Date().getTime();

                RasterQuery query = RasterLocator.getManager().createQuery();

                query.setAllDrawableBands();

                query.setAreaOfInterest();

                query.setReadOnly(true);

                Buffer bufInput;

                try {

                        bufInput = store.query(query);

                } catch (RasterDriverException e1) {

                        throw new ProcessException("Error getting the input buffer", e1);

                } catch (InvalidSetViewException e1) {

                        throw new ProcessException("Error getting the input buffer", e1);

                }

                GeoTransformProcess transform = new GeoTransformProcess();

                transform.setActions(this);

                transform.addParam(GCPS, gcps);

                transform.addParam(ORDER, new Integer(orden));

                transform.execute();                

                // Obtenida la transformacion la aplicamos a los puntos extremos de la imagen

                double p1[] = transform.getCoordMap(0, 0);                

                double p2[] = transform.getCoordMap(store.getWidth(), 0);                

                double p3[] = transform.getCoordMap(0, store.getHeight());

                double p4[] = transform.getCoordMap(store.getWidth(), store.getHeight());        

                double xmin = Math.min(Math.min(p1[0], p3[0]), Math.min(p2[0], p4[0]));

                double ymin = Math.min(Math.min(p3[1], p4[1]), Math.min(p1[1], p2[1]));

                double xmax = Math.max(Math.max(p2[0], p4[0]), Math.max(p1[0], p3[0]));        

                double ymax = Math.max(Math.max(p1[1], p2[1]), Math.max(p3[1], p4[1]));

                //Extent newBbox = RasterLocator.getManager().getDataStructFactory().createExtent(xmin, ymax, xmax, ymin);

                int w = 0;

                int h = 0;

                if(xCellSize >= 0 && yCellSize >= 0) {

                        w = (int)((xmax - xmin) / xCellSize);

                        h = (int)((ymax - ymin) / yCellSize);

                } 

                int dataType = store.getDataType()[0];

                Buffer bufResult = RasterLocator.getManager().createBuffer(dataType, w, h, store.getBandCount(), true);

                NoData nd = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(

                                store.getBandCount(), dataType);

                Interpolation interpolation = new Interpolation(bufInput);

                double coord[] = null;

                double values[] = new double[bands.length];

                for(int row = 0; row < bufResult.getHeight(); row++) {

                        for(int col = 0; col < bufResult.getWidth(); col++) {

                                coord = transform.getCoordPixel(col * xCellSize + xmin, ymax - row * yCellSize);

                                for (int iBand = 0; iBand < store.getBandCount(); iBand++) {

                                        if( (coord[0] < 0) || (coord[1] < 0) || 

                                                (coord[0] > bufInput.getWidth() - 1) || 

                                                (coord[1] > bufInput.getHeight() - 1))

                                                values[iBand] = nd.getValue().doubleValue();                                        

                                        else {

                                                if(rMethod == Buffer.INTERPOLATION_Bilinear)

                                                        values[iBand] = interpolation.getBilinearValue(coord[0], coord[1], iBand);

                                                else if(rMethod == Buffer.INTERPOLATION_InverseDistance)

                                                        values[iBand] = interpolation.getInverseDistance(coord[0], coord[1], iBand);

                                                else

                                                        values[iBand] = interpolation.getNearestNeighbour(coord[0], coord[1], iBand);

                                        }

                                        if(dataType == Buffer.TYPE_BYTE) 

                                                bufResult.setElem(row, col, iBand, (byte)values[iBand]);

                                        else if(dataType == Buffer.TYPE_DOUBLE)

                                                bufResult.setElem(row, col, iBand, (double)values[iBand]);

                                        else if(dataType == Buffer.TYPE_FLOAT)

                                                bufResult.setElem(row, col, iBand, (float)values[iBand]);

                                        else if(dataType == Buffer.TYPE_SHORT)

                                                bufResult.setElem(row, col, iBand, (short)values[iBand]);

                                        else if(dataType == Buffer.TYPE_INT)

                                                bufResult.setElem(row, col, iBand, (int)values[iBand]);

                                }

                        }

                        updatePercent(row, bufResult.getHeight());

                }

                export(filename, bufResult, xCellSize, yCellSize, xmin, ymax);

                long t2 = new java.util.Date().getTime();

                milis = t2 - t1;

                SwingUtilities.invokeLater(new Runnable() {

                        public void run() {

                                if (externalActions != null) {

                                        externalActions.end(getResult());

                                }

                        }

                });

        }

        public Object getResult() {

                HashMap<String, Object> map = new HashMap<String, Object>();

                map.put(FILENAME, filename);

                map.put(TIME, new Long(milis));

                return map;

        }

        /**

         * Saves the result in a file

         * @param sFilename

         * @param buf

         * @param xcellsize

         * @param ycellsize

         * @param minX

         * @param maxY

         * @return

         */

        public boolean export(final String sFilename, Buffer buf, double xcellsize, double ycellsize, double minX, double maxY) {

        try {

            RasterManager manager = RasterLocator.getManager();

            writerBufferServer = manager.createDataServerWriter();

            writerBufferServer.setBuffer(buf, -1);

            final Params params = manager.createWriterParams(sFilename);

            final AffineTransform affineTransform =

                new AffineTransform(xcellsize, 0, 0,

                                -ycellsize, minX, maxY);

            final RasterWriter writer =

                manager.createWriter(writerBufferServer, sFilename,

                    buf.getBandCount(), affineTransform, buf.getWidth(),

                    buf.getHeight(), buf.getDataType(), params, null);

            writer.dataWrite();

            writer.writeClose();

        } catch (final Exception e) {

                e.printStackTrace();

            return false;

        }

        return true;

    }

        public String getTitle() {

                return Messages.getText("georreferenciacion_process");

        }

        public int getPercent() {

                if(writerBufferServer == null)

                        return percent;

                else

                        return writerBufferServer.getPercent();

        }

        public String getLog() {

                return Messages.getText("georreferencing_log_message");

        }

        public void interrupted() {

        }

        public void end(Object param) {        

        }

}