Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

* 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., 51 Franklin Street, Fifth Floor, Boston, 

* MA  02110-1301, USA.

* 

*/

package org.gvsig.raster.reproject.app;

import java.io.File;

import java.util.HashMap;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.gvsig.app.prepareAction.PrepareContext;

import org.gvsig.app.prepareAction.PrepareContextView;

import org.gvsig.app.prepareAction.PrepareDataStoreParameters;

import org.gvsig.app.prepareAction.PrepareLayer;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.util.CRSUtils;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

import org.gvsig.raster.algorithm.process.DataProcess;

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

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

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

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

import org.gvsig.raster.mainplugin.config.Configuration;

import org.gvsig.raster.reproject.algorithm.ReprojectProcess;

import org.gvsig.raster.reproject.app.preparelayer.RasterProjectionActionsDialog;

import org.gvsig.raster.reproject.app.preparelayer.ReprojectionQueue;

import org.gvsig.raster.swing.RasterSwingLibrary;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PrepareLayerAskProjection implements PrepareDataStoreParameters, PrepareLayer, IProcessActions {

        protected CRSUtils              crsUtil                       = RasterLocator.getManager().getCRSUtils(); 

        private boolean                 changeReprojectionOption      = true;

        private int                     lastReprojectionOption        = RasterDataParameters.NEW_PROJETION_TO_THE_LAYER;

        private ReprojectionQueue       queue                         = ReprojectionQueue.getSingleton();

        private Logger                  log                           = LoggerFactory.getLogger(PrepareLayerAskProjection.class);

        @SuppressWarnings("deprecation")

        public DataStoreParameters prepare(DataStoreParameters storeParameters,

                        PrepareContext context) throws BaseException {

                if(!(storeParameters instanceof RasterDataParameters))

                        return storeParameters;

                DataManager dataManager = DALLocator.getDataManager();

                RasterDataStore dataStore = (RasterDataStore)dataManager.createStore(storeParameters);

                if (Configuration.getValue("general_ask_projection", Boolean.valueOf(false)).booleanValue()) {

                        IProjection proj = readProjection(dataStore);

                        if(proj != null) {

                                //((RasterDataParameters)storeParameters).setDynValue("CRS", proj);

                                compareProjections(proj, context.getViewProjection(), dataStore);

                        }

                }

                if(dataStore != null)

                        dataStore.close();

                if(((RasterDataParameters)storeParameters).getReprojectionOption() == RasterDataParameters.NEW_PROJETION_TO_THE_LAYER)

                        ((RasterDataParameters)storeParameters).setDynValue("CRS", null);

                if(((RasterDataParameters)storeParameters).getReprojectionOption() == RasterDataParameters.NOT_LOAD)

                        return null;

                return storeParameters;

        }

        public void post(DataStoreParameters storeParameters, PrepareContext context) {

                changeReprojectionOption = true;

        }

        public void pre(DataStoreParameters storeParameters, PrepareContext context) {

        }

        /**

         * If this flag is true the reprojection options can be changed by the user 

         * @return

         */

        public boolean getChangeOption() {

                return changeReprojectionOption;

        }

        /**

         * If this flag is true the reprojection options can be changed by the user 

         * @param changeOption

         */

        public void setChangeOption(boolean changeOption) {

                this.changeReprojectionOption = changeOption;

        }

        public FLayer prepare(FLayer layer, PrepareContextView context) {

                if (!(layer instanceof DefaultFLyrRaster))

                        return layer;

                DefaultFLyrRaster lyrRaster = (DefaultFLyrRaster) layer;

                String layerName = lyrRaster.getName();

                RasterDataParameters params = (RasterDataParameters)lyrRaster.getDataStore().getParameters();

                int repOption = params.getReprojectionOption();

                if(repOption == RasterDataParameters.REPROJECT_DATA) {

                        RasterDataParameters rasterParams = reproject(lyrRaster, context.getViewProjection());

                        if(rasterParams != null) {

                                MapContextManager mcm = MapContextLocator.getMapContextManager();

                                try {

                                        return (DefaultFLyrRaster) mcm.createLayer(layerName, rasterParams);

                                } catch (LoadLayerException e) {

                                        return lyrRaster;

                                }

                                /*DefaultFLyrRaster lyr = new DefaultFLyrRaster();

                                DataManager dataManager = DALLocator.getDataManager();

                                try {

                                        DataStore dataStore = dataManager.createStore(rasterParams);

                                        lyr.setName(layerName);

                                        lyr.setDataStore(dataStore);

                                        return lyr;

                                } catch (ValidateDataParametersException e) {

                                        return lyrRaster;

                                } catch (InitializeException e) {

                                        return lyrRaster;

                                } catch (ProviderNotRegisteredException e) {

                                        return lyrRaster;

                                } catch (LoadLayerException e) {

                                        return lyrRaster;

                                }*/

                        }

                } else if(repOption == RasterDataParameters.REPROJECT_VIEW) {

                        try {

                                if (lyrRaster != null && lyrRaster.readProjection() != null) {

                                        context.getMapControl().setProjection(lyrRaster.readProjection());

                                        lyrRaster.setVisible(true);

                                }

                        } catch (RasterDriverException e) {

                                RasterSwingLibrary.messageBoxError("Error reading the projection", null, e);

                        }

                } else if(repOption == RasterDataParameters.DONT_CHANGE_PROJECTION) {

                        lyrRaster.setVisible(true);

                        return lyrRaster;

                } else if(repOption == RasterDataParameters.NEW_PROJETION_TO_THE_LAYER) {

                        IProjection proj = context.getViewProjection();

                        if(proj != null)

                                lyrRaster.setProjection(proj, false);

                        lyrRaster.setVisible(true);

                        return lyrRaster;

                }

                return lyrRaster;

        }

        private RasterDataParameters reproject(FLyrRaster lyrRaster, IProjection dstProj) {

                RasterDataParameters params = (RasterDataParameters)lyrRaster.getDataStore().getParameters();

                int repOption = params.getReprojectionOption();

                if(repOption == RasterDataParameters.REPROJECT_DATA) {

                        IProjection srcProj = readProjection(lyrRaster.getDataStore());

                        if(srcProj == null)

                                return null;

                        String uri = params.getURI();

                        uri = uri.substring(0, uri.lastIndexOf(".")) + "_" + dstProj.getAbrev() + uri.substring(uri.lastIndexOf("."));

                        uri = uri.replace(':', '_');

                        if(!new File(uri).exists()) {                                        

                                DataProcess process = null;

                                try {

                                        process = RasterBaseAlgorithmLibrary.getManager().createRasterTask("RasterReprojectionProcess");

                                } catch (ProcessException e1) {

                                        RasterSwingLibrary.messageBoxError("error_creating_algorithm", null, e1);

                                        return params;

                                }

                                process.setActions(this);

                                process.addParam(ReprojectProcess.RASTER_STORE, lyrRaster.getDataStore());

                                process.addParam(ReprojectProcess.SIZEX, 0); //Calculo autom?tico de tama?o

                                process.addParam(ReprojectProcess.SIZEY, 0);

                                process.addParam(ReprojectProcess.PATH, uri);

                                process.addParam(ReprojectProcess.SRC_PROJECTION, srcProj);

                                process.addParam(ReprojectProcess.DST_PROJECTION, dstProj);

                                process.addParam(ReprojectProcess.CELLSIZE, lyrRaster.getDataStore().getCellSize());

                                //Despierta la cola que reproyecta im?genes

                                synchronized (queue) {

                                        queue.add(process, this);        

                                        queue.notify();

                                }

                                //Se suspende hasta que la cola haya terminado

                                try {

                                        synchronized (this) {

                                                this.wait();

                                        }

                                } catch (InterruptedException e) {

                                }

                                if(process.getResult() != null) {

                                        HashMap<String, Object> map = (HashMap<String, Object>)process.getResult();

                                        String filename = (String)map.get(ReprojectProcess.FILENAME);

                                        params.setURI(filename);

                                        return params;

                                }

                        } else {

                                params.setURI(uri);

                                return params;

                        }

                } else if(repOption == RasterDataParameters.REPROJECT_VIEW) {

                        //Esto se cambia en el prepare que tiene acceso al mapcontrol. Este prepare es a nivel de datos

                } 

                return null;

        }

        public void end(Object param) {

        }

        /**

         * Compares two projections and show a dialog to the user to make a decision

         * @param lyrProj

         * @param viewProj

         */

        private void compareProjections(IProjection lyrProj, IProjection viewProj, RasterDataStore dataStore) {

                if(!getChangeOption() || lyrProj == null || viewProj == null) {

                        ((RasterDataParameters)dataStore.getParameters()).setReprojectionOption(lastReprojectionOption);

                        return;

                }

                /*

                 * Si las proyecciones de vista y raster son distintas se lanza el

                 * dialogo de selecci?n de opciones. Este dialogo solo se lanza en caso

                 * de que el checkbox de aplicar a todos los ficheros no haya sido

                 * marcado. En este caso para el resto de ficheros de esa selecci?n se

                 * har? la misma acci?n que se hizo para el primero.

                 */

                if (!viewProj.getAbrev().endsWith(lyrProj.getAbrev())) {

                        String layerName = dataStore.getName().substring(dataStore.getName().lastIndexOf(File.separator) + 1, dataStore.getName().length());

                        RasterProjectionActionsDialog dialog = new RasterProjectionActionsDialog(

                                        dataStore.isReproyectable(), layerName, RasterDataParameters.REPROJECT_VIEW);

                        if (dialog != null) {

                                lastReprojectionOption = dialog.getRasterProjectionActionsPanel().getSelection();

                                ((RasterDataParameters)dataStore.getParameters()).setReprojectionOption(lastReprojectionOption);

                                setChangeOption(!dialog.getChangeProjectionOption());

                        }

                }

        }

        /**

         * Reads the projection from a DataStore

         * @param dataStore

         * @return

         * @throws RasterDriverException

         */

        @SuppressWarnings("deprecation")

        private IProjection readProjection(RasterDataStore dataStore) {

                try {

                        crsUtil.setCRSFactory(CRSFactory.cp);

                        if( dataStore == null )

                                return null;

                        return crsUtil.convertWktToIProjection(dataStore.getWktProjection());

                } catch (Exception e) {

                        //Si ha habido alg?n problema con la conversi?n metemos un log y que devuelva null 

                        log.info("Problems converting from WKT to IProjection", e);

                } catch (Error e) {

                        log.info("Problems converting from WKT to IProjection", e);

                }

                return null;

        }

        public String getDescription() {

                return "Prepare projection for Raster Layer";

        }

        public String getName() {

                return "PrepareRasterLayerProjection";

        }

        public Object create() {

                return this;

        }

        public Object create(Object[] args) {

                return this;

        }

        @SuppressWarnings("rawtypes")

        public Object create(Map args) {

                return this;

        }

        public void interrupted() {

        }

        public void updateProgress(int current, int total) {

        }

}