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.fmap.layers;

import java.util.ArrayList;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectSet;

/**

 * {@link DynObject} implementation to facade a iterator of a WMTSInfo

 * and allow to be used as a {@link DynObjectSet} iterator.

 * 

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

 * @version $Id$

 * 

 */

public class DynObjectIteratorRasterInfo implements DisposableIterator {

    private ArrayList<Object> infoList = new ArrayList<Object>();

    private int               index    = -1;

    /**

     * Creates a new DynObjects iterator facade over a feature iterator.

     * Each WMTSInfo will be returned through a new or reused

     * {@link DynObjectWMTSInfo} which allows the {@link Feature} to be

     * used like a DynObject.

     * 

     * @param featureIterator

     *            to facade

     * @param featureFacade

     *            if not null this object will be reused as the facade for the

     *            Feature objects of the feature iterator

     */

    public DynObjectIteratorRasterInfo(Object info) {

        this.infoList.add(info);

        index = 0;

    }

    public void addObject(Object info) {

    	this.infoList.add(info);

    	if(index == -1)

    		index = 0;

    }

    public synchronized void dispose() {

    	this.infoList.clear();

    	index = -1;

    }

    public synchronized boolean hasNext() {

        return (infoList.size() == 0 || index >= infoList.size()) ? false : true;

    }

    public synchronized Object next() {

        Object o = infoList.get(index);

        index ++;

        return o;

    }

    public synchronized void remove() {

    	if(index < infoList.size() && index >= 0) {

    		index --;

    		infoList.remove(index);

    	}

    }

    public long getSize() {

        return infoList.size();

    }

}

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

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.impl.DefaultDynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

import org.gvsig.tools.visitor.Visitor;

/**

 * {@link DynObject} implementation to facade of a {@link FeatureSet} and allow

 * to be used as a {@link DynObjectSet}.

 * 

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

 * @version $Id$

 */

public class DynObjectSetRasterInfo extends BaseWeakReferencingObservable

    implements DynObjectSet, Observer {

	private DynObjectIteratorRasterInfo   ite      = null;

	private DynClass                      dynClass = null;

    /**

     * Creates a new facade over a given info, with fast dynobject

     * iteration.

     */

    public DynObjectSetRasterInfo() {

        dynClass =

            ToolsLocator.getDynObjectManager().createDynClass(

                "RasterInfoByPoint", "Raster", "Raster point information");

    }

    /**

     * Adds a field to the DynObject

     * @param name

     * @param object

     * @param order

     */

    public void addField(String name, Object object, int order) {

    	DynField field = dynClass.addDynField(name);

    	field.setDefaultFieldValue(object);

    	if(order != -1)

    		field.setOrder(order);

    	DefaultDynObject dynObject = new DefaultDynObject(dynClass);

    	ite = new DynObjectIteratorRasterInfo(dynObject);

    }

    public void dispose() {

    }

    public void accept(final Visitor visitor, long firstValueIndex) throws BaseException {

    	while(ite.hasNext()) {

    		visitor.visit(ite.next());

    	}

    }

    public void accept(final Visitor visitor) throws BaseException {

    	while(ite.hasNext()) {

    		visitor.visit(ite.next());

    	}

    }

    public long getSize() throws BaseException {

       return ite.getSize();

    }

    public DisposableIterator iterator(long index) throws BaseException {

        return iterator();

    }

    public DisposableIterator iterator() throws BaseException {

    	return ite;

    }

    public boolean isEmpty() throws BaseException {

    	return (getSize() == 0);

    }

    public boolean isDeleteEnabled() {

    	return true;

    }

    public void delete(DynObject dynObject) throws BaseException {

    }

    public boolean isUpdateEnabled() {

    	return true;

    }

    public void update(DynObject dynObject) throws BaseException {

    }

    public void update(Observable observable, Object notification) {

    }

}

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

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.grid.render.Render;

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

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

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

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

import org.gvsig.raster.roi.ROI;

import org.gvsig.tools.task.Cancellable;

/**

 * All kind of raster layers should implement this interface.

 *

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

 */

@SuppressWarnings("deprecation")

public interface FLyrRaster extends FLayer {

	/**

	 * Sets the layer as initialized. That's implies that the layer has

	 * the right filters and is opened,

	 * @param initialized

	 */

	public void setLayerInitialized(boolean initialized);

	/**

	 * Gets the uniform resource identifier

	 * @return

	 */

	public URI getURI();

	/**

	 * Returns true if a color table exists

	 * @return

	 */

	public boolean existColorTable();

	/**

	 * Define la ultima leyenda valida de la capa o se pone a null para que la

	 * capa busque una leyenda valida.

	 * @param ct

	 */

	public void setLastLegend(ColorTable ct);

	/**

	 * Crea el objeto renderizador de raster

	 * @return Rendering

	 */

	public Render getRender();

	/**

	 * Gets the MapContext object

	 * @return

	 */

	public MapContext getMapContext();

	/**

	 * Gets the full extent

	 * @return

	 */

	public Extent getFullRasterExtent();

	/**

	 * Gets the DataStore

	 * @return

	 */

	public RasterDataStore getDataStore();

	/**

	 * Metodo para consultar si una capa puede ser un RGB. Suponemos que es un RGB

	 * si el tipo de datos es de tipo byte y su interpretacion de color tiene

	 * asignada los tres colores.

	 * @return boolean

	 */

	public boolean isRGB();

	/**

	 * Returns true if the drawn is going to be tiled

	 * @return

	 */

	public boolean isTiled();

	/**

	 * Gets the regions of interest

	 * @return

	 * @throws ROIException

	 */

	public List<ROI> getRois() throws ROIException;

	/**

	 * Sets the regions of interest

	 */

	public void setRois(List<ROI> rois);

	/**

	 * Sets the files which contain the regions of interest. This method is temporal until

	 * after the refactoring of ROIs.

	 * @param file

	 * @throws RmfSerializerException

	 */

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

	/**

	 * Gets the files which contain the regions of interest. This method is temporal until

	 * after the refactoring of ROIs.

	 * @return

	 * @throws RmfSerializerException

	 */

	public List<File> getROIsFiles() throws RmfSerializerException;

	/**

	 * Obtiene la proyecci?n del fichero.

	 * @return IProjection

	 */

	public IProjection readProjection() throws RasterDriverException;

	/**

	 * Gets the tile size

	 * @return

	 */

	public int[] getTileSize();

	/**

	 * Obtiene el valor NoData asociado al raster.

	 * @return double

	 */

	public NoData getNoDataValue();

	/**

	 * Returs a string with the extension of the first file

	 */

	public String getFileFormat();

	/**

	 * Obtiene el flag que dice si la imagen est? o no georreferenciada

	 * @return true si est? georreferenciada y false si no lo est?.

	 */

	public boolean isGeoreferenced();

	/**

	 * Returns the number of bands of each dataset

	 * @return

	 */

	public int[] getBandCountFromDataset();

	/**

	 * Gets the projection in well known text format

	 * @return

	 * @throws RasterDriverException

	 */

	public String getWktProjection() throws RasterDriverException;

	/**

	 * Gets the color interpretation

	 * @param band

	 * @param dataset

	 * @return

	 */

	public String getColorInterpretation(int band, int dataset);

	/**

	 * When a process is using information of this layer this variable will contain

	 * the thread ID.

	 * @param readingData

	 */

	public void setReadingData(String readingData);

	/**

	 * Sets the nodata value for this layer

	 * @param noDataValue the noDataValue to set

	 */

	public void setNoDataValue(NoData noDataValue);

	/**

	 * Sets the minimum scale visible. Lower scales won't be drawn.

	 *

	 * @param minScale the scale > 0, -1 if not defined

	 * @see #getMinScale()

	 */

	public void setMinScale(double minScale);

	/**

	 * Sets the maximum scale visible. Higher scales won't be drawn.

	 *

	 * @param maxScale the scale > 0, -1 if not defined

	 * @see #getMaxScale()

	 */

	public void setMaxScale(double maxScale);

	/**

	 * Returns the maximum scale visible. Higher scales won't be drawn.

	 *

	 * @return the maximum scale > 0, -1 if not defined

	 * @see #setMaxScale(double)

	 */

	public double getMaxScale();

	/**

	 * Returns the minimum scale visible. Lower scales won't be drawn.

	 *

	 * @return the minimum scale > 0, -1 if not defined

	 * @see #setMinScale(double)

	 */

	public double getMinScale();

	/**

	 * @return Returns the removeRasterFlag.

	 */

	public boolean isRemoveRasterFlag();

	/**

	 * Asigna el valor del flag que dice si destruimos la memoria del raster

	 * al eliminarlo del TOC o  no.

	 * @param removeRasterFlag The removeRasterFlag to set.

	 */

	public void setRemoveRasterFlag(boolean removeRasterFlag);

	/**

	 * Borra de la lista de listeners el que se pasa como par?metro.

	 *

	 * @param o LayerListener a borrar.

	 *

	 * @return True si ha sido correcto el borrado del Listener.

	 */

	public boolean removeLayerListener(LayerListener o);

	/**

	 * @throws ReadException

	 * @throws ReadDriverException

	 * @see com.iver.cit.gvsig.fmap.layers.LayerOperations#draw(java.awt.image.BufferedImage,

	 * 		java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort,

	 * 		com.iver.utiles.swing.threads.Cancellable)

	 */

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

	/**

	 * Clones this layer

	 * @return

	 * @throws Exception

	 */

	public FLayer cloneLayer() throws Exception;

	/**

	 * Gets a layer which the source is a file

	 * @return

	 * @throws RasterDriverException

	 */

	public FLayer getFileLayer() throws RasterDriverException;

	/**

	 * Gets the position of the alpha band

	 * @return

	 */

	public int getAlphaBandNumber();

	public String getName();

	/**

	 * Gets the projection

	 * @return

	 */

	public IProjection getProjection();

	/**

	 * Devuelve si es reproyectable o no la capa

	 * @return

	 */

	public boolean isReproyectable();

	/**

	 * Recupera del raster la matriz de transformaci?n que lo situa en cualquier parte de la vista

	 * @return AffineTransform

	 */

	public AffineTransform getAffineTransform();

	/**

	 * Obtiene la lista de transformaciones que se han ido aplicando al raster.

	 * @return Historical. Lista de AffineTransform

	 */

	public Historical getAffineTransformHistorical();

	/**

	 * Asigna al raster la matriz de transformaci?n para situarlo en cualquier parte de la vista

	 * @param transf

	 */

	public void setAffineTransform(AffineTransform transf);

	/**

	 * Asigna al raster la matriz de transformaci?n para situarlo en cualquier parte de la vista.

	 * Esta versi?n no guarda en el historico.

	 * @param transf

	 */

	public void setAffineTransformWithoutHistorical(AffineTransform transf);

	/**

	 * Salva la georreferenciaci?n a fichero rmf.

	 * @param fName

	 * @throws RmfSerializerException

	 */

	public void saveGeoToRmf() throws RmfSerializerException;

	/**

	 * Metodo que obtiene si un punto cae dentro de los l?mites de la capa

	 * o fuera de ellos.

	 * @param p Punto a calcular

	 * @return true si est? dentro de los l?mites y false si est? fuera

	 */

	public boolean isInside(Point2D p);

	/**

	 * Returns true if this layer is remote

	 * @return

	 */

	public boolean isRemote();

	/**

	 * Gets the attribute list

	 * <UL>

	 * <LI>Filename</LI>

	 * <LI>Filesize</LI>

	 * <LI>Width</LI>

	 * <LI>Height</LI>

	 * <LI>Bands</LI>

	 * </UL>

	 * @return ArrayList<Object>

	 */

	public ArrayList<Object> getAttributes();

	/**

	 * Returns the full bounding box of this layer

	 * @return

	 */

	public Envelope getFullEnvelope();

	/**

	 * Ajusta las coordenadas especificadas en el par?metro al ?rea m?xima

	 * del raster en p?xeles.

	 * @param req Punto a ajustar dentro del extener del raster

	 */

	public Point2D adjustWorldRequest(Point2D req);

	/**

	 * Adds a new file. The behavior of this function depends on

	 * the kind of provider and its implementation.

	 * @param file

	 * @throws InvalidSourceException

	 */

	public void addFile(File file) throws InvalidSourceException;

	/**

	 * Removes a file. The behavior of this function depends on

	 * the kind of provider and its implementation.

	 * @param file

	 */

	public void removeFile(File file);

	/**

	 * When this flag is true then renderice nodata value as transparent

	 * @param t

	 */

	public void setNoDataTransparent(boolean t);

	/**

	 * Sets the layer projection

	 * @param proj

	 */

	public void setProjection(IProjection proj, boolean persist) throws RmfSerializerException;

}

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

import java.awt.Image;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.fmap.mapcontrol.tools.Events.MoveEvent;

import org.gvsig.fmap.mapcontrol.tools.Listeners.PanListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Implementaci?n de la interfaz PanListener como herramienta para realizar el

 * Pan.

 *

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

 */

public class GeorefPanListenerImpl implements PanListener {

	private static final GeometryManager 	geomManager	= GeometryLocator.getGeometryManager();

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

//	private final Image ipan = new ImageIcon(MapControl.class.getResource(

//				"images/CruxCursor.png")).getImage();

//	private Cursor cur = Toolkit.getDefaultToolkit().createCustomCursor(ipan,

//			new Point(16, 16), "");

	private MapControl 						mapControl;

	private DefaultFLyrRaster 					lyrRaster 	= null;

	private String							pathToFile 	= null;

	/**

	 * Crea un nuevo RectangleListenerImpl.

	 *

	 * @param mapControl MapControl.

	 */

	public GeorefPanListenerImpl(MapControl mapControl) {

		this.mapControl = mapControl;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.tools.Listeners.PanListener#move(java.awt.geom.Point2D,

	 * 		java.awt.geom.Point2D)

	 */

	@SuppressWarnings("deprecation")

	public void move(MoveEvent event) {

		ViewPort vp = mapControl.getMapContext().getViewPort();

		Point2D from = vp.toMapPoint(event.getFrom());

		Point2D to = vp.toMapPoint(event.getTo());

		Rectangle2D.Double r = new Rectangle2D.Double();

		Rectangle2D extent = vp.getExtent();

		r.x = extent.getX() - (to.getX() - from.getX());

		r.y = extent.getY() - (to.getY() - from.getY());

		r.width = extent.getWidth();

		r.height = extent.getHeight();

		Envelope env;

		try {

			env = geomManager.createEnvelope(r.getMinX(), r.getMinY(), r

					.getMaxX(), r.getMaxY(), SUBTYPES.GEOM2D);

			vp.setEnvelope(env);

		} catch (CreateEnvelopeException e) {

			logger.error("Error creating the envelope", e);

		}

		// mapControl.drawMap();

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.tools.Listeners.ToolListener#cancelDrawing()

	 */

	public boolean cancelDrawing() {

		return true;

	}

	/**

	 * @return Returns the lyrRaster.

	 */

	public DefaultFLyrRaster getLyrRaster() {

		return lyrRaster;

	}

	/**

	 * @param lyrRaster The lyrRaster to set.

	 */

	public void setLyrRaster(DefaultFLyrRaster lyrRaster) {

		this.lyrRaster = lyrRaster;

	}

	/**

	 * @return Returns the pathToFile.

	 */

	public String getPathToFile() {

		return pathToFile;

	}

	/**

	 * @param pathToFile The pathToFile to set.

	 */

	public void setPathToFile(String pathToFile) {

		this.pathToFile = pathToFile;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.mapcontrol.tools.Listeners.ToolListener#getImageCursor()

	 */

	public Image getImageCursor() {

		return null;

	}

}

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

import java.util.ArrayList;

import java.util.HashMap;

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

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

import org.gvsig.fmap.dal.coverage.grid.render.Render;

import org.gvsig.fmap.mapcontext.MapContext;

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

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

/**

 * Aplica estrategias de dibujado para las capas raster. Hace que las 

 * capas que est?n ocultas por otras no sean dibujadas. Esta estrategia tiene que ser

 * aplicada a capas raster de FMap por falta de eficiencia en el dibujado. Esta clase

 * es totalmente dependiente de FMap y puede ser eliminada en caso de que este no exita.

 * 28/11/2007

 * @author Nacho Brodin nachobrodin@gmail.com

 */

public class RasterDrawStrategy {

	/**

	 * Cada mapContext existente lleva asociadad una estrategia de dibujado

	 */

	public static HashMap<MapContext, HashMap<DefaultFLyrRaster, Boolean>>        

	                             mapContextStrategy    = new HashMap<MapContext, HashMap<DefaultFLyrRaster, Boolean>> ();

	private MapContext           mapContext            = null;

	private DefaultFLyrRaster         lyrRaster             = null;

	/**

	 * Estructura de datos para almacenar la asociaci?n entre el extent de una capa

	 * y su informaci?n de transparencia. Esta es necesaria para la comprobaci?n de si la 

	 * capa con la que se est? intersectando tiene transparencia o no la tiene. Con esto 

	 * se puede decidir si dibujar la capa actual o no.

	 * 16/06/2008

	 * @author Nacho Brodin nachobrodin@gmail.com

	 */

	public class LayerIntersection {

		public Extent  extent          = null;

		public boolean hasTransparency = false;

		/**

		 * Constructor. Asigna el Extent y la informaci?n de transparencia

		 * @param ext Extent

		 * @param transp Transparencia

		 */

		public LayerIntersection(Extent ext, boolean transp) {

			this.extent = ext;

			this.hasTransparency = transp;

		} 

	}

	/**

	 * Al constructor le pasamos el contexto de dibujado para la toma de decisi?n.

	 * @param mapContext Context

	 * @throws ExpansionFileReadException

	 * @throws ReadDriverException

	 */

	public RasterDrawStrategy(MapContext mapContext, DefaultFLyrRaster lyrRaster) {

		this.mapContext = mapContext;

		this.lyrRaster = lyrRaster;

	}

	/**

	 * <P>

	 * Estrategia de dibujado para las capas raster que hace que si

	 * una capa est? oculta completamente por otra que no tiene transparencias entonces

	 * esta no ser? dibujada.

	 * </P>

	 * <P>

	 * La estrategia la calcula solo la primera capa raster que aparezca. El resto

	 * de las capas la preguntaran a esta.

	 * </P>

	 * <P>

	 * <code>Estrategia:</code>

	 * Analizamos la lista de capas desde la primera que se dibuja en el TOC hasta la ?ltima

	 * <UL>

	 * <LI>Si la capa tiene rotaci?n se dibuja siempre.</LI>

	 * <LI>Si la capa no est? activa en el TOC no se dibuja nunca</LI>

	 * <LI>Si la capa no es transparente y no hay extents en la lista se dibuja y se a?ade el extent a la lista</LI>

	 * <LI>Si el extent de la capa intersecta con uno de la lista</LI>

	 * </UL>

	 * Comprobamos si est? detr?s de un extent de la lista. Si es as? no se dibuja

	 * Si no est? est? detr?s de un extent comprobamos si tiene transparencias

	 * Si no tiene transparencias a?adimos el extent a la lista

	 * </P>

	 * @param lyrs

	 * @throws ReadDriverException 

	 * @throws ExpansionFileReadException 

	 */

	public void stackStrategy() {

		if(mapContext == null || lyrRaster == null)

			return;

		ArrayList<FLayer> listLayers = new ArrayList<FLayer>();

		FLayers lyrs = mapContext.getLayers();

		listLayers = getLayerList(lyrs, listLayers);

		ArrayList<LayerIntersection> extentList = new ArrayList<LayerIntersection>();

		//Solo la primera capa calcula la estrategia. Las dem?s se la preguntan a esta.

		//Calculamos cual es la primera capa raster de FLayers y contamos cuantas capas raster hay

		int posFirstRasterLayer = 0;

		int nRasterLayers = 0;

		boolean firstTime = true;

		for (int i = 0; i < listLayers.size(); i++) {

			FLayer lyr = (FLayer) listLayers.get(i);

			if(firstTime && lyr instanceof DefaultFLyrRaster && lyr.isVisible()) {

				posFirstRasterLayer = i;

				firstTime = false;

			}

			if(lyr instanceof DefaultFLyrRaster)

				nRasterLayers ++;

		}

		//Si hay solo una capa raster no se calcula ninguna estrategia

		if(nRasterLayers == 1) {

			mapContextStrategy.put(mapContext, null);

			return;

		}

		//Si no es la primera capa se obtiene la estrategia que calcul? la primera capa

		if(lyrRaster != listLayers.get(posFirstRasterLayer)) {

			if(!(listLayers.get(posFirstRasterLayer) instanceof DefaultFLyrRaster))

				return;

			mapContextStrategy.put(mapContext, ((DefaultFLyrRaster)listLayers.get(posFirstRasterLayer)).getRasterStrategy());

			return;

		}

		HashMap<DefaultFLyrRaster, Boolean> layersToPaint = new HashMap<DefaultFLyrRaster, Boolean>();

		//Calculo de estrategia. Solo llega aqu? la primera capa.

		//La lista de capas en FLayers est? en orden inverso a lo que aparece en el TOC, es decir, la ?ltima capa

		//del TOC es la primera de la lista de FLayers y la primera del TOC es la ?ltima de la lista.

		for (int i = (listLayers.size() - 1); i >= 0; i--) {

			FLayer lyr = (FLayer) listLayers.get(i);

			if (!(lyr instanceof DefaultFLyrRaster))

				continue;

			DefaultFLyrRaster rLyr = ((DefaultFLyrRaster)lyr);

			if(rLyr.getRender() == null || rLyr.getRender().getFilterList() == null || rLyr.getFullEnvelope() == null)

				continue;

			//Si no est? activa y/o visible no se dibuja nunca 

			if(!rLyr.isVisible()) {

				layersToPaint.put(rLyr, new Boolean(false));

				continue;

			}

			//Si tiene rotaci?n se dibuja siempre

			if(rLyr.getAffineTransform() != null) {

				if(	rLyr.getAffineTransform().getShearX() != 0 || 

						rLyr.getAffineTransform().getShearY() != 0) {

					layersToPaint.put(rLyr, new Boolean(true));

					continue;

				}

			}

			//Si es la primera metemos el extent en la lista y se dibuja

			//Si no es la primera y no intersecta con ning?n extent. Metemos el extent y dibujamos			

			LayerIntersection li = areIntersecting(extentList, rLyr);

			if((i == (listLayers.size() - 1)) || li == null) {

				boolean colorTableAlpha = false;

				if(rLyr.getRender().getFilterList() != null) { 

					Render render = rLyr.getRender();

					if(render != null) {

						if(render.getColorTable() != null)

							colorTableAlpha = render.getColorTable().hasAlpha();

					}

				}

				extentList.add(new LayerIntersection(rLyr.getFullRasterExtent(), (rLyr.existsAlphaBand() || rLyr.isTransparent() || colorTableAlpha)));

				layersToPaint.put(rLyr, new Boolean(true));

				continue;

			}

			//Si con la que intersecta no tiene transparencia no se dibuja

			if(li != null && !li.hasTransparency) {

				layersToPaint.put(rLyr, new Boolean(false));

				continue;

			}

			if(!rLyr.isTransparent())

				li.hasTransparency = false;

			layersToPaint.put(rLyr, new Boolean(true));			

		}

		mapContextStrategy.put(mapContext, layersToPaint);

	}

	/**

	 * Obtiene la lista de capas del TOC. Si hay capas agrupadas lo tiene en cuenta y mira

	 * dentro de la agrupaci?n.

	 * @param srcLyrs

	 * @param destLyrs

	 * @return

	 */

	public static ArrayList<FLayer> getLayerList(FLayers srcLyrs, ArrayList<FLayer> destLyrs) {

		for (int i = 0; i < srcLyrs.getLayersCount(); i++) {

			if(srcLyrs.getLayer(i) instanceof DefaultFLyrRaster)

				destLyrs.add(srcLyrs.getLayer(i));

			if(srcLyrs.getLayer(i) instanceof FLayers)

				destLyrs = getLayerList((FLayers)srcLyrs.getLayer(i), destLyrs);

		}

		return destLyrs;

	}

	/**

	 * Comprueba si la capa que se pasa por par?metro est? oculta por alguno

	 * de los extent de la lista

	 * @param extentList Lista de extensiones

	 * @param lyr Capa raster

	 * @return 

	 */

	private LayerIntersection areIntersecting(ArrayList<LayerIntersection> extentList, DefaultFLyrRaster lyr) {

		for (int i = 0; i < extentList.size(); i++) {

			Extent ex = lyr.getFullRasterExtent();

			Extent ex1 = ((LayerIntersection)extentList.get(i)).extent;

			if(RasterLocator.getManager().getRasterUtils().isInside(ex, ex1))

				return ((LayerIntersection)extentList.get(i));

		}

		return null;

	}

	/**

	 * Obtiene un TreeMap con la lista de capas que se dibujan. Si se al TreeMap se

	 * le pasa como par?metro una capa raster y devuelve null es que no se dibuja.

	 *  

	 * @return TreeMap con la lista de capas a dibujar.

	 */

	public HashMap<DefaultFLyrRaster, Boolean> getStrategy() {

		return (HashMap<DefaultFLyrRaster, Boolean>)mapContextStrategy.get(mapContext);

	}

}

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

import java.io.File;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.grid.RasterFilterList;

import org.gvsig.fmap.dal.coverage.grid.RasterFilterListManager;

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

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.Transparency;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Esta clase almacena el estado de un raster en cuanto a las caracteristicas

 * de opacidad, bandas y filtros. Estas caracter?sticas pueden ser salvadas a

 * un xml y recuperadas por la capa a trav?s de las funciones setXMLEntity y

 * getXMLEntity

 *

 * @deprecated

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

 */

public class StatusLayerRaster implements IStatusRaster {

	public static String 			defaultClass    = "org.gvsig.fmap.raster.layers.StatusLayerRaster";

	//Valor de opacidad global de la imagen

	public int						transparency    = 255;

	//Rangos de transparencia

	public ArrayList<TransparencyRange>

	                                ranges          = new ArrayList<TransparencyRange>();

	//(Selecci?n de bandas)N?mero de banda  asignado al Rojo, verde y azul

	public int 						bandR           = 0;

	public int 						bandG           = 1;

	public int 						bandB           = 2;

	public List<File>		        files           = new ArrayList<File>();

	//Filtros para poder montar una nueva pila

	public List<String>		        filters         = new ArrayList<String>();

	private DefaultFLyrRaster       layer           = null;

	private int                     alphaBandNumber = -1;

	//Utilizado para la persistencia

	private boolean 				loadClass		= false;

	public void loadFromState(PersistentState state, DefaultFLyrRaster layer)throws PersistenceException {

//		this.layer = layer;

//		//RECUPERAR PROPIEDADES

//

//		//Recuperamos las propiedades de los filtros

//		for(int i = 0; i < xml.getPropertyCount(); i++) {

//			if(xml.getPropertyName(i).startsWith("filter."))

//				filters.add(xml.getPropertyName(i) + "=" + xml.getPropertyValue(i));

//		}

//

//		//Rangos de transparencia

//		if (xml.contains("filter.transparency.active") && xml.getBooleanProperty("filter.transparency.active")) {

//			int i = 0;

//			String value = null;

//			while(true) {

//				if(xml.contains("filter.transparency.transparencyRange" + i)) {

//					value = xml.getStringProperty("filter.transparency.transparencyRange" + i);

//					int alpha = 0;

//					if(value.indexOf("@") != 0) {

//						try {

//							alpha = Integer.parseInt(value.substring(value.indexOf("@") + 1, value.length()));

//						} catch (NumberFormatException e) {

//							alpha = 0;

//						}

//						if(value.indexOf("@") != -1)

//							value = value.substring(0, value.indexOf("@"));

//					}

//					TransparencyRange range = new TransparencyRange(value);

//					if(alpha != 0)

//						range.setAlpha(alpha);

//					ranges.add(range);

//				} else

//					break;

//				i ++;

//			}

//		}

//

//		if(xml.contains("filter.transparency.bandnumber"))

//			alphaBandNumber = xml.getIntProperty("filter.transparency.bandnumber");

//

//		if (xml.contains("raster.opacityLevel")) {

//			transparency = xml.getIntProperty("raster.opacityLevel");

//			//Esto soluciona un problema de compatibilidad entre branch v10 y HEAD. Eliminar en futuras versiones

//			if(nameClass != null && nameClass.compareTo("com.iver.cit.gvsig.fmap.layers.StatusLayerRaster") == 0)

//				transparency = 255 - transparency;

//		}

//

//		if (xml.contains("raster.bandR"))

//			bandR = xml.getIntProperty("raster.bandR");

//

//		if (xml.contains("raster.bandG"))

//			bandG = xml.getIntProperty("raster.bandG");

//

//		if (xml.contains("raster.bandB"))

//			bandB = xml.getIntProperty("raster.bandB");

//

//

//		int cont = 0;

//		while(true && cont < 50) {

//			if (xml.contains("raster.file" + cont)) {

//				files.add(xml.getStringProperty("raster.file" + cont));

//				cont++;

//			}else

//				break;

//		}

	}

	@SuppressWarnings("unchecked")

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		this.transparency = state.getInt("transparency");

		this.bandR = state.getInt("bandR");

		this.bandG = state.getInt("bandG");

		this.bandB = state.getInt("bandB");

		this.alphaBandNumber = state.getInt("alphaBandNumber");

		this.loadClass = state.getBoolean("loadClass");

		this.layer = (DefaultFLyrRaster)state.get("layer");

		this.ranges = new ArrayList(state.getList("ranges"));

		this.files = new ArrayList(state.getList("files"));

		this.filters = new ArrayList(state.getList("filters"));

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		state.set("transparency", this.transparency);

		state.set("bandR", this.bandR);

		state.set("bandG", this.bandG);

		state.set("bandB", this.bandB);

		state.set("alphaBandNumber", this.alphaBandNumber);

		state.set("loadClass",this.loadClass);

		state.set("layer", this.layer);

		state.set("ranges", this.ranges);

		state.set("files", this.files);

		state.set("filters",this.filters);

	}

	public void setStateProperties(boolean loadClass, DefaultFLyrRaster layer) throws PersistenceException {

		this.layer = layer;

		this.loadClass = loadClass;

	}

	public static void registerPersistence() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.addDefinition(StatusLayerRaster.class,

				"StatusLayerRaster_Persistent",

				"StatusLayerRaster Persistent definition (FIXME loadClass)", null, null);

		definition.addDynFieldInt("transparency");

		definition.addDynFieldInt("bandR").setMandatory(true);

		definition.addDynFieldInt("bandG").setMandatory(true);

		definition.addDynFieldInt("bandB").setMandatory(true);

		definition.addDynFieldInt("alphaBandNumber");

		definition.addDynFieldBoolean("loadClass");

		definition.addDynFieldObject("layer")

			.setClassOfValue(DefaultFLyrRaster.class);

		definition.addDynFieldList("ranges")

			.setClassOfItems(TransparencyRange.class);

		definition.addDynFieldList("files")

			.setClassOfItems(String.class);

		definition.addDynFieldList("filters")

			.setClassOfItems(String.class);

	}

	public List<String> getFilters() {

		return this.filters;

	}

	public void applyStatus(DefaultFLyrRaster layer) throws NotSupportedExtensionException, RasterDriverException, FilterTypeException, FileNotFoundInListException, OperationNotSupportedException, FilterManagerException, InvalidSourceException {

		//Eliminamos el fichero inicial y cargamos las bandas si hay para que se carguen

		//en el orden correcto

		if(layer instanceof DefaultFLyrRaster) {

			if(files != null && files.size() != 0){

				//((FLyrRasterSE)layer).delFile((String)files.get(0));

				for (int i = 1; i < files.size(); i++)

					((DefaultFLyrRaster)layer).addFile(files.get(i));

			}

		}

		//Asigna las bandas

		String[] valuesCI = new String[layer.getDataStore().getBandCount()];

		valuesCI[bandR] = ColorInterpretation.RED_BAND;

		valuesCI[bandG] = ColorInterpretation.GREEN_BAND;

		valuesCI[bandB] = ColorInterpretation.BLUE_BAND;

		ColorInterpretation ci = RasterLocator.getManager().getDataStructFactory().createColorInterpretation(valuesCI);

		if(layer.getRender() != null)

			layer.getRender().setRenderColorInterpretation(ci);

		//Asigna la transparencia

		Transparency transp = layer.getRender().getRenderingTransparency();

		if(transp != null && transparency != 255) {

			transp.setOpacity(transparency);

			transp.activeTransparency();

		}

		//Rangos de transparencia

		if(transp != null && ranges != null) {

			transp.setTransparencyRangeList(ranges);

			transp.activeTransparency();

		}

		//Banda de transparencia

		if(transp != null && alphaBandNumber != -1) {

			transp.setTransparencyBand(alphaBandNumber);

			transp.activeTransparency();

		}

		//Filtros

		/*if (layer.getRender().getFilterList() != null) {

			layer.getRender().getFilterList().createFilterListFromStrings((ArrayList<String>)filters);

			enhancedCompV10((ArrayList<String>)filters, layer);

			//sortFilters(layer.getRenderFilterList());

		}*/

		//Refrescamos todas las vistas

		layer.getMapContext().invalidate();

		/*IWindow[] w = PluginServices.getMDIManager().getAllWindows();

		for (int i = 0; i < w.length; i++) {

			if(w[i] != null && w[i] instanceof AbstractViewPanel)

				((AbstractViewPanel)w[i]).getMapControl().getMapContext().invalidate();

		}*/

	}

	/**

	 * M?todo para mantener la compatibilidad con la v10 del realce. El realce de la v10 no

	 * aporta suficiente informaci?n por lo que se a?ade un filtro de realce generico v1.9

	 * @param filterArguments

	 * @param layer

	 * @param filterListManager

	 * @throws FilterTypeException

	 * @throws FilterManagerException

	 */

	public static void enhancedCompV10(ArrayList<String> filterArguments, DefaultFLyrRaster layer) throws FilterTypeException, FilterManagerException {

		RasterFilterList filterList = layer.getRender().getFilterList();

		filterList.remove("enhanced_stretch");

		filterList.remove("tailTrim");

		/*boolean removed = false;

		RasterFilterList list = layer.getRender().getFilterList();

		for (int i = 0; i < list.lenght(); i++) {

			RasterFilter f = list.get(i);

			if(f instanceof TailTrimFilter || f instanceof LinearEnhancementFilter) {

				list.remove(f.getName());

				removed = true;

			}

		}

		if(removed)

			list.controlTypes();*/

		//Para compatibilidad de realce con proyectos antiguos

		for (int i = 0; i < filterArguments.size(); i++) {

			if(((String)filterArguments.get(i)).startsWith("filter.enhanced.active=true")) {

				RasterFilterListManager enhancementManager = filterList.getManagerByID("EnhancementStretch");

				Params params = filterList.createEmptyFilterParams();

				params.setParam("stats", ((RasterDataStore)layer.getDataStore()).getStatistics());

				params.setParam("remove", new Boolean(false));

				params.setParam("renderBands", layer.getRender().getRenderColorInterpretation().buildRenderBands());

				params.setParam("stretchs", null);//coge el LinearStretchParams por defecto

				enhancementManager.addFilter(params);

			}

		}

	}

	public int[] getRenderBands() {

		return new int[]{bandR, bandG, bandB};

	}

	public RasterFilterList getFilterList() throws FilterTypeException {

		/*RasterManager rManager = RasterLocator.getManager();

		try {

			RasterFilterList filterList = layer.getRender().getFilterList();

			if(filterList != null)

				filterList.createFilterListFromStrings((ArrayList<String>)filters);

			else {

				filterList = rManager.createEmptyFilterList(Buffer.TYPE_BYTE);

			}

			return filterList;

		} catch (NullPointerException e) {

			return null;

		}*/

		return null;

	}

	public ColorTable getColorTable() throws FilterTypeException {

		return layer.getRender().getColorTable();

	}

	public List<String> getFilterArguments() {

		return filters;

	}

	String nameClass = null;

	/**

	 * Asigna el nombre de la clase que se ha leido desde el proyecto

	 * @param nameClass

	 */

	public void setNameClass(String nameClass) {

		this.nameClass = nameClass;

	}

}

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

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.URI;

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.fmap.dal.DataStoreParameters;

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

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

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

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