Application: gvSIG desktop » gvSIG raster

*

* 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

* MA  02110-1301, USA.

*/

package org.gvsig.raster.fmap.layers;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.task.impl.BaseTaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Raster layer

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

 */

@SuppressWarnings("deprecation")

public class DefaultFLyrRaster extends FLyrDefault implements FLyrRaster, Multiresolution, InfoByPoint, Classifiable,

		IRasterLayerActions, ILayerState, VisualPropertyListener, SingleLayer {

	public static final String      PERSISTENT_NAME                = "FLyrRasterSE_Persistent";

    public static final String      PERSISTENT_DESCRIPTION         = "FLyrRasterSE Persistent";

    private RasterManager           rManager                       = RasterLocator.getManager();

	static private IConfiguration   configuration                  = new DefaultLayerConfiguration();

	protected int                   zoomLevel                      =  1;

	public boolean                  recalcLevel                    = true;

	private static GeometryManager  geomManager   	               = GeometryLocator.getGeometryManager();

	private static final Logger     logger                         = LoggerFactory.getLogger(DefaultFLyrRaster.class);

	protected FileUtils             fileUtil                       = RasterLocator.getManager().getFileUtils();

	protected RasterUtils           rasterUtil                     = RasterLocator.getManager().getRasterUtils();

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

	protected MathUtils             mathUtil                       = RasterLocator.getManager().getMathUtils();

	public class RasterTaskStatus extends BaseTaskStatus {

		Cancellable c = null;

		public RasterTaskStatus(String tittle, Cancellable c) {

			super(tittle);

			this.c = c;

		}

		public boolean isCancellationRequested() {

			if(c != null)

				return this.c.isCanceled();

			return false;

		}

		public void cancelRequest() {

			if(c != null)

				this.c.setCanceled(true);

	protected String                readingData            = null;

	//It is set to true if the method init has been called at least once

	private boolean                 layerInitialize        = false;

	public DefaultFLyrRaster() {

		affineTransformList = rManager.createHistoricalService();

	}

	public static void registerDynClass() {

		DynObjectManager manager = ToolsLocator.getDynObjectManager();

    	DynClass dynClass = manager.add("RasterInfo", "Raster layer Info by point");

    	dynClass.addDynFieldString("Band Value");

    	dynClass.addDynFieldString("World Point");

	}

	/**

	 * Builds a new raster layer

	 * @param fileName

	 * @return

	 */

	public static DefaultFLyrRaster createLayer(String layerName, File file) throws LoadLayerException {

		ProviderServices provServ = RasterLocator.getManager().getProviderServices();

		RasterDataParameters storeParameters = provServ.createParameters(file.getName());

		MapContextManager mcm = MapContextLocator.getMapContextManager();

		DefaultFLyrRaster lyr = (DefaultFLyrRaster) mcm.createLayer(layerName, storeParameters);

		enableStopped(); // Paramos la capa mientras se hace un load

		DataStoreParameters params = getDataStore().getParameters();

		DataStoreParameters p = params;

		if (params != null) {

				if(params instanceof RasterDataParameters)

					uri = ((RasterDataParameters)p).getURI();

			}

		}

		try {

			if(!getDataStore().isOpen())

				dataStore = rManager.getProviderServices().open(params);

			throw new LoadLayerException(this.getName());

		}

	}

	public void setLayerInitialized(boolean initialized) {

		layerInitialize = initialized;

	}

	/**

	 * Acciones de inicializaci?n despu?s de que la fuente de datos

	 */

	public void init() throws LoadLayerException, FilePaletteException {

		layerInitialize = true;

		if (getDataStore() == null)

			throw new LoadLayerException("Formato no valido", new IOException());

		}

		return render;

	}

		return uri;

	}

	/**

	 * Initializes the filter list to render this raster layer

	 */

	protected void initFilters() throws FilePaletteException {

		if(getDataType() == null)

			return;

		RasterFilterList filterList = rManager.createEmptyFilterList(getDataType()[0]);

		if(loadedFromProject) {

			filterList = getDataStore().getRender().getFilterList();

		if(getDataStore() == null)

			return;

		if(getDataStore().getNoDataValue() != null) {

			getDataStore().getNoDataValue().load();

		}

					params.setParam("colorTable", table);

					colorTableManager.addFilter(params);

				} else //sino hace lo que dice en las preferencias

						loadEnhancedOrColorTable(filterList);

			colorTableLoadedFromProject = null;

	 * de color por defecto

	 * @param filterManager

	 * @throws FilterTypeException

	 */

	private void loadEnhancedOrColorTable(RasterFilterList filterList) throws FilterTypeException, FilterManagerException, FilePaletteException {

		String colorTableName = null;

	public void draw(BufferedImage image, Graphics2D g, ViewPort vp, Cancellable cancel, double scale) throws ReadException {

		TaskEventManager task = rManager.getRasterTask();

		task.setEvent(null);

		if(!layerInitialize) {

			if (getDataStore() != null)

				try {

			enableStopped();

			// callLegendChanged(null);

			//Solo el zoom normal recalcula el nivel dependiendo de la escala. El zoom por niveles asigna

			//?l el nivel de zoom por lo que no habr? que recalcularlo.

			if(recalcLevel) {

			}

			if (isWithinScale(scale)) {

				if (mustTileDraw) {

					Point2D p = vp.getOffset();

					Rectangle r = new Rectangle((int) p.getX(), (int) p.getY(), vp.getImageWidth(), vp.getImageHeight());

						System.out.println("Se ha cancelado el pintado");

					} catch (QueryException e) {

						throw new ReadException("Error reading file.", e);

			}

			//callLegendChanged(null);

		} finally {

			disableStopped();

		ViewPortData vp2 = rManager.getDataStructFactory().createViewPortData(vp.getProjection(), e, imgSz );

		vp2.setMat(vp.getAffineTransform());

		vp2.setDPI((int)vp.getDPI());

		TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

		SimpleTaskStatus taskStatus = new RasterTaskStatus("Drawing " + getName() + "...", cancel);

		manager.add(taskStatus);

		taskStatus.setAutoremove(true);

		//Crea la reproyecci?n al vuelo la primera vez

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

			getDataStore().getProjection() != null &&

			params.getReprojectionOption() == RasterDataParameters.ON_THE_FLY) {

			getRender().createReprojectionOnTheFly(getDataStore(), getCoordTrans(), taskStatus);

		}

		try {

			if(getDataStore().isTiled()) {

				getRender().drawTiledService(g, vp2, vp.getImageSize(), taskStatus);

			logger.error("Error saving the projection", e);

		}

	}

	public void setProjection(IProjection proj, boolean persist) {

		try {

			getDataStore().setProjection(proj, persist);

					.getMaxY(), SUBTYPES.GEOM2D);

			/*

			ICoordTrans ct = getCoordTrans();

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

			if (ct != null && params.getReprojectionOption() == RasterDataParameters.ON_THE_FLY) {

			return null;

		}

	}

	/**

	 * Obtiene el valor del pixel del Image en la posici?n x,y

	 * @param x Posici?n x

		if (/*!isOpen() ||*/ !isVisible() || !isWithinScale(scale))

			return;

		TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

		SimpleTaskStatus taskStatus = new RasterTaskStatus("Printing raster " + getName() + "...", cancel);

		manager.add(taskStatus);

				}

			}

		}

		taskStatus.terminate();

	}

			if (this.isRemoveRasterFlag()) {

				if (getDataStore() != null) {

					try {

						getDataStore().close();

					// System.gc();

					this.setRemoveRasterFlag(true);

						File dirTemp = fileUtil.getTemporalFile();

						if(!file.exists())

							continue;

		return getDataStore().getFileSizeByProvider();

	}

	/**

	 * Returns the number of files in this raster layer

	public void setRenderFilterList(RasterFilterList filterList) {

		getRender().setFilterList(filterList);

	}

	public DynObjectSet getInfo(org.gvsig.fmap.geom.primitive.Point p, double tolerance) throws LoadLayerException, DataException {

		DynObjectSetRasterInfo info = new DynObjectSetRasterInfo();

		if (!isOpen()) {

			info.addField("Layer not open", normalizeAsXMLTag(getName()), 0);

			return info;

		}

		Point2D pReal = new Point2D.Double(p.getX(), p.getY());

		Point2D px = new Point2D.Double();

		if(	pReal.getX() > this.getMinX() &&

		}

		//int[] rgb = getPixel((int) p.getX(), (int) p.getY());

		//ColorConversion conv = rManager.getColorConversion();

		info.addField("File", normalizeAsXMLTag(getName()), 0);

		info.addField("View Point", "[" + p.getX() + " , " + p.getY() + "]", 1);

		info.addField("World Point", "[" + mathUtil.format(pReal.getX(), 3) + " , " + mathUtil.format(pReal.getY(), 3) + "]", 2);

			info.addField("Pixel Point", "Out", 3);

		else

			info.addField("Pixel Point", "[" + (int) px.getX() + ",  " + (int) px.getY() + "]", 3);

		//La informaci?n RGB no puede obtener de la capa

		/*info.addField("RGB", "[" + rgb[1] + ",  " + rgb[2] + ",  " + rgb[3] + "]", 4);

		double[] cmyk = conv.RGBtoCMYK(rgb[1] & 0xff, rgb[2] & 0xff, rgb[3] & 0xff, 1D);

		info.addField("CMYK", "[" + mathUtil.format(cmyk[0], 4) + ",  " + mathUtil.format(cmyk[1], 4) + ",  " + mathUtil.format(cmyk[2], 4) + ",  " + mathUtil.format(cmyk[3], 4) + "]", 5);

		hsl[2] = (int) (hsl[2] * 255. + 0.5);

		hsl[1] = (int) (hsl[1] * 255. + 0.5);

		info.addField("HSL", "[" + mathUtil.format(hsl[0], 4) + ",  " + mathUtil.format(hsl[1], 4) + ",  " + mathUtil.format(hsl[2], 4) + "]", 6);*/

		String data = "[";

		try {

			if (px != null) {

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

						if(getDataStore().isInside(pReal)) {

							Point2D pxAux = transformPoint(pReal);

									(int)pxAux.getY(), i)).intValue();

							if(getDataType()[0] == Buffer.TYPE_BYTE)

								data += (val & 0x000000ff) + ",  ";

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

						if(getDataStore().isInside(pReal)) {

							Point2D pxAux = transformPoint(pReal);

									(int)pxAux.getY(), i)).floatValue() + ",  ";

						}

					}

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

						if(getDataStore().isInside(pReal)) {

							Point2D pxAux = transformPoint(pReal);

									(int)pxAux.getY(), i)).doubleValue() + ",  ";

						}

					}

		}

		return info;

	}

	/**

	 * Transforma un punto real a coordenadas pixel

	 * @param numberBand

	 * @param pReal

	 * @return

	 * @throws ReadDriverException

	 */

	private Point2D transformPoint(Point2D pReal) throws LoadLayerException {

			throw new LoadLayerException("Error en la transformaci?n del punto", e);

		}

	}

	public Object getInfo(String key) {

		if (key.equals("DriverName"))

			return "gvSIG Raster Driver";

	public boolean isFileAccepted(File file) {

		return getDataStore().isFileSupported(file.getName());

	}

	/**

	 * Consulta si un fichero es aceptado o no para este tipo de capa.

	 * @param file Fichero a consultar

			return;

		getDataStore().saveGeoreferencingToRmf();

		affineTransformList.clear();

		affineTransformList.add(this.getAffineTransform());

	}

				state.disableStopped();

			else

				enableStopped();

			if(isAwake() || isClosed())

				try {

					this.load();

				} catch (LoadLayerException e) {

					e.printStackTrace();

				}

			/*

			 * Cuando se modifica la visibilidad de una capa raster se hace un updateDrawVersion de todas las

			 * capas raster de ese MapContext. Esto es porque la estrategia utilizada por RasterDrawStrategy hace

					if(listLayers.get(i) instanceof DefaultFLyrRaster)

						((DefaultFLyrRaster)listLayers.get(i)).updateDrawVersion();

			}

			super.setVisible(visibility);

	}

	public void setRois(List<ROI> rois) {

		getDataStore().setRois(rois);

	}

	public void setROIsFiles(List<File> file) throws RmfSerializerException {

		getDataStore().saveROIFileListToRmf(file);

	}

	public List<File> getROIsFiles() throws RmfSerializerException {

		return getDataStore().getROIFileListFromRmf();

	}

		newLayer.setName(getName());

		newLayer.setOpenRasterStore(ds);

		newLayer.firstLoad = firstLoad;

		List<RasterFilter> filters = getRender().getFilterList().getStatusCloned();

		//Hacemos una copia de las bandas a renderizar

		if(getDataStore().getNoDataValue().isDefined())

			newLayer.setNoDataTransparent(true);

		newLayer.enableOpen();

		return newLayer;

	}

	public FLayer getFileLayer() throws RasterDriverException {

		try {

			return cloneLayer();

		}

		return null;

	}

		getDataStore().addFile(file);

	}

		getDataStore().removeFile(file);

	}

		}

		return this.dataStore;

	}

	public IProjection getProjection() {

		if(getDataStore() == null)

			return null;

		RasterDataParameters p = (RasterDataParameters)getDataStore().getParameters();

		if(p.getReprojectionOption() == RasterDataParameters.DONT_CHANGE_PROJECTION)

			return null;

		if(dataStore instanceof CoverageStoreProviderServices) {

			try {

				this.dataStore = rManager.getProviderServices().open(

						dataStore.getParameters());

			} catch (NotSupportedExtensionException e) {

				throw new LoadLayerException("Extension not supported", e);

			}

		}

	}

	public void setDataStore(DataStore dataStore) throws LoadLayerException {

		setOpenRasterStore(dataStore);

		load();

	}

	public boolean isRemote() {

		return false;

	}

	/**

	 * Returns true if exists a process reading data from this layer

	 * @return

	public synchronized void setReadingData(String readingData) {

		this.readingData = readingData;

	}

	public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel,

			boolean fast)

			throws LoadLayerException, DataException {

	public void setZoomLevel(int zoomLevel) {

		this.zoomLevel = zoomLevel;

	}

	public boolean increaseZoomLevel() {

			zoomLevel ++;

			recalcLevel = false;

			return true;

		}

		return false;

	}

	public boolean decreaseZoomLevel() {

			zoomLevel --;

			recalcLevel = false;

			return true;

		}

		return false;

	}

	public Envelope getCoordsInLevel(Point2D center, int level, int w, int h) throws CreateEnvelopeException {

		Extent ex = getDataStore().getCoordsInLevel(center, level, w, h);

		return geomManager.createEnvelope(ex.getULX(), ex.getULY(), ex.getLRX(), ex.getLRY(), SUBTYPES.GEOM2D);

	}

	public boolean isEnabledMultiresolution() {

		return getDataStore().isTiled();

	}

	public void setTileServer(Class<?> tileServer) throws InitializeException {

		getDataStore().setTileServer(tileServer);

	}

	@Override

	public void loadFromState(PersistentState state)

			throws PersistenceException {

	@Override

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

	public static void registerPersistence() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

					DefaultFLyrRaster.class,

					PERSISTENT_NAME,

					PERSISTENT_DESCRIPTION,

					null

			);

			definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, "FLyrDefault");

			registerPersistence(definition);

		}

	}

	public static void registerPersistence(DynStruct definition) {

		definition.addDynFieldObject("rasterdatastore").setClassOfValue(RasterDataStore.class).setMandatory(false);

		definition.addDynFieldObject("legend").setClassOfValue(ILegend.class).setMandatory(false);

			throw new ReadException(getDataStore().getName(), e);

		} catch (GeometryTypeNotValidException e) {

			throw new ReadException(getDataStore().getName(), e);

	}

	public void setDataStore(DataStore dataStore, String domain) throws LoadLayerException {

		setDataStore(dataStore);

	}

	protected void finalize() {

		layerChangeSupport             = null;

		state                          = null;