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.Extent;

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.impl.grid.GridInterpolated;

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             METHOD             = "method";

        public static String             XCELLSIZE          = "xCellSize";

        public static String             YCELLSIZE          = "yCellSize";

        public static String             INTERPOLATION      = "Interpolation";

        //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;

        //Indicador de progreso

        private int                      percent            = 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 final 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(METHOD);

                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(p1[0], p3[0]);

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

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

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

                Extent bbox = store.getExtent();

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

                int w = 0;

                int h = 0;

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

                        w = (int)(bbox.width() * xCellSize);

                        h = (int)(bbox.height() * yCellSize);

                } else {

                        double[] size = getSize(bbox, newBbox);

                        w = (int)size[0];

                        h = (int)size[1];

                        xCellSize = yCellSize = size[2];

                }

                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];

                int progress = 0;

                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);

                                if(coord[0] < 0)

                                        coord[0] = 0;

                                if(coord[1] < 0)

                                        coord[1] = 0;

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

                                        coord[0] = bufInput.getWidth() - 1;

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

                                        coord[1] = bufInput.getHeight() - 1;

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

                                        if(rMethod == GridInterpolated.INTERPOLATION_Bilinear)

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

                                        if(rMethod == GridInterpolated.INTERPOLATION_InverseDistance)

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

                                        else

                                                values[iBand] = interpolation.getBilinearValue(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]);

                                }

                        }

                        percent = (int)(progress * 100 / (bufResult.getHeight() * bands.length));

                }

                export(filename, bufResult, xCellSize, xmin, ymin);

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

                milis = t2 - t1;

                SwingUtilities.invokeLater(new Runnable() {

                        public void run() {

                                if (externalActions != null) {

                                        externalActions.end(getResult());

                                }

                        }

                });

                if(externalActions!=null)

                        externalActions.end(filename);

        }

        /**

         * Gets the size of the new image

         * @param bbox

         * @param newBbox

         * @return

         */

        private double[] getSize(Extent bbox, Extent newBbox) {

                double sumSideOldBBox = bbox.width() + bbox.height();

                double sumSideNewBBox = newBbox.width() + newBbox.height();

                double d1x = (bbox.width() * 100) / sumSideOldBBox; 

                double d1y = (bbox.height() * 100) / sumSideOldBBox;

                double d2x = (newBbox.width() * 100) / sumSideNewBBox;

                double d2y = (newBbox.height() * 100) / sumSideNewBBox;

                double p2y = (store.getHeight() * d2y) / d1y;

                double p2x = (store.getWidth() * d2x) / d1x;

                double newCellSize = newBbox.width() / p2x;

                return new double[]{Math.round(p2x), Math.round(p2y), newCellSize};

        }

        public Object getResult() {

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

                map.put(FILENAME, filename);

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

                return map;

        }

        public boolean export(final String sFilename, Buffer buf, double cellsize, double minX, double minY) {

        try {

            RasterManager manager = RasterLocator.getManager();

            final DataServerWriter writerBufferServer =

                manager.createDataServerWriter();

            writerBufferServer.setBuffer(buf, -1);

            final Params params = manager.createWriterParams(sFilename);

            final AffineTransform affineTransform =

                new AffineTransform(cellsize, 0, 0,

                    -cellsize, minX, minY);

            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) {        

        }

}