Application: gvSIG desktop » gvSIG raster

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

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

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

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

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

			<artifactId>org.gvsig.raster.algorithm</artifactId>

	        <!--<dependency>

	        </dependency>-->

				<artifactId>org.gvsig.raster.algorithm</artifactId>

import org.gvsig.raster.algorithm.RasterBaseAlgorithmLibrary;

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

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

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

/* 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.IProcessActions;

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

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

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

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

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

import org.gvsig.raster.tools.app.basic.RasterToolsUtil;

import org.gvsig.raster.tools.app.basic.config.Configuration;

import org.gvsig.raster.tools.app.basic.raster.gui.wizard.ReprojectionQueue;

import org.gvsig.raster.tools.app.basic.raster.gui.wizard.proj.RasterProjectionActionsDialog;

import org.gvsig.tools.exception.BaseException;

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

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

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

	}

	@SuppressWarnings("unchecked")

	private RasterDataParameters reproject(FLyrRaster lyrRaster, IProjection dstProj) {

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

		int repOption = params.getReprojectionOption();

		if(repOption == RasterDataParameters.REPROJECT_DATA) {

			try {

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

					RasterProcess process = null;

					try {

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

					} catch (ProcessException e1) {

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

				}

			} catch (RasterDriverException e) {

				RasterToolsUtil.messageBoxError("Error creating layer", null, e);

			} 

		} 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

	 */

	private IProjection readProjection(RasterDataStore dataStore) throws RasterDriverException {

		try {

			crsUtil.setCRSFactory(CRSFactory.cp);

			if( dataStore == null )

				return null;

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

		} catch (Exception e) {

			throw new RasterDriverException("Problems converting from WKT to IProjection", e);

		} catch (Error e) {

			e.printStackTrace();

			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("unchecked")

	public Object create(Map args) {

		return this;

	}

	public void interrupted() {

	}

}

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

		ApplicationManager appGvSigMan = ApplicationLocator.getManager();

		appGvSigMan.registerPrepareOpenLayer(new PrepareLayerAskProjection());

		appGvSigMan.registerPrepareOpenDataStoreParameters(new PrepareLayerAskProjection());

            <artifactId>org.gvsig.raster.algorithm</artifactId>