| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap.layers;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Image;

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.util.ArrayList;

import org.cresques.geo.ViewPortData;

import org.cresques.io.GdalFile;

import org.cresques.io.GeoRasterFile;

import org.cresques.io.raster.RasterFilterStack;

import org.cresques.io.raster.RasterFilterStackManager;

import org.cresques.io.rasterOld.ComputeMinMaxFilter;

import org.cresques.io.rasterOld.GreyscaleRasterToImageFilter;

import org.cresques.io.rasterOld.LinearEnhancementFilter;

import org.cresques.io.rasterOld.RasterBuf;

import org.cresques.io.rasterOld.RasterStats;

import org.cresques.io.rasterOld.RasterToImageFilter;

import org.cresques.px.Extent;

import org.cresques.px.PxRaster;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.drivers.wcs.FMapWCSDriver;

import com.iver.cit.gvsig.fmap.operations.Cancellable;

import es.gva.cit.jgdal.Gdal;

import es.gva.cit.jgdal.GdalBuffer;

import es.gva.cit.jgdal.GdalException;

import es.gva.cit.jgdal.GdalRasterBand;

import es.gva.cit.jgdal.GeoTransform;

import es.uji.lsi.wcs.client.ServerErrorResponseException;

/**

 * Class to interact FMapWCSDriver

 * 

 * La clase FMapWCSAdaptor recubre la interacci?n con el FMapWCSDriver 

 * @author jaume - jaume.dominguez@iver.es

 *

 */

public class FMapWCSAdaptor {

	private boolean 					driverInitialized = false;

	private FMapWCSDriver				driver;

	private Rectangle2D 				fullExtent, bbox;

	private static final double 		METROSXGRADO = 111120D;

	private String 						coverageName;

	private String 						SRS;

	private String 						format;

	private String 						time;

	private String 						parameter;

	//private double 						maxRes;

	private Point2D						maxRes;

	private String 						coverageQuery;

	private String 						lastCoverageQuery = "";

	private File 						fCoverage = null;

	private PxRaster 					raster = null;

	private RasterFilterStack 			filterStack = null;

	private GeoRasterFile 				rasterFile = null;

	//private double 						res;

	private Point2D						res;

	private boolean 					zoomingToPixel;

	private int 						transparency = -1;

	private int 						rband = 0, gband = 1, bband = 2;

	private RasterFilterStackManager	stackManager = null;

	public 	boolean						firstLoad = false;

	/**

	 * Returns the coverage resolution

	 * 

	 * obtiene la resoluci?n de la cobertura (de la capa FlyrWCS)

	 * @return

	 */

	//public double getRes() {

	public Point2D getRes() {

		return res;

	}

	/**

	 * Sets the coverage resolution (the layer's resolution)

	 * 

	 * Establece la resoluci?n de la cobertura (de la capa FlyrWCS)

	 * @param res

	 */

	//public void setRes(double res) {

	public void setRes(Point2D res) {

		this.res = res;

	}

	/**

	 * Sets the driver that works with the adaptor.

	 * 

	 * Establece el driver sobre el que act?a el adaptador 

	 */

	public void setDriver(FMapWCSDriver d) {

		driver = d;

	}

	/**

	 * Gets a ref to the object that implements the vectorial interface in order

	 * of the Strategy can optimize the driver's function.

	 * 

	 * Obtiene una referencia al objeto que implementa la interfaz vectorial con

	 *  el fin de que las Strategy puedan optimizar en funci?n del driver.

	 */

	public FMapWCSDriver getDriver(){

		return driver;

	}

	/**

	 * Automatically called by gvSIG

	 * 

	 * Llamado autom?ticamente por gvSIG. 

	 * Pinta la cobertura (r?ster) en el ViewPort.

	 * 

	 * @param image, g, viewPort, cancel

	 * @throws ServerErrorResponseException 

	 * @throws ServerErrorResponseException 

	 */

	public void draw(BufferedImage image, Graphics2D g,

			ViewPort viewPort, Cancellable cancel) throws DriverException, ServerErrorResponseException {

		if (viewPort.getExtent().getMinX() > fullExtent.getMaxX())

			return;

		if (viewPort.getExtent().getMinY() > fullExtent.getMaxY())

			return;

		if (viewPort.getExtent().getMaxX() < fullExtent.getMinX())

			return;

		if (viewPort.getExtent().getMaxY() < fullExtent.getMinY())

			return;

		setBBox(viewPort.getAdjustedExtent());

		double x = bbox.getMinX();

		double y = bbox.getMinY();

		double w = bbox.getWidth();

		double h = bbox.getHeight();

		double scalex = viewPort.getAffineTransform().getScaleX()	/* g.getTransform().getScaleX()*/ ,

		scaley = viewPort.getAffineTransform().getScaleY()		/* g.getTransform().getScaleY() */;

		int wImg = (int) Math.abs(w*scalex)+1, hImg = (int) Math.abs(h*scaley)+1;

		if (wImg <= 0 || hImg <= 0) return;

		setCoverageQuery(bbox, new Dimension(wImg, hImg));

		//try {

			if (lastCoverageQuery.compareTo(coverageQuery) != 0) {

				setWCSClientCoverageQuery(coverageQuery);

				fCoverage = driver.getCoverage();

			}

			if (fCoverage != null) {

				//drawJaume(g, viewPort, fCoverage);

				drawLWS(g, viewPort, fCoverage);

			}

//		} catch (ServerErrorResponseException e) {

//			JOptionPane.showMessageDialog((Component)PluginServices.getMainFrame(), e.getMessage(), "Error",

//					JOptionPane.ERROR_MESSAGE);

//			View view=(View)PluginServices.getMDIManager().getActiveView();

//			view.getTOC().layerRemoved(LayerCollectionEvent.createLayerRemovedEvent(this));

//		}

	}

	/**

	 * Draws using PxRaster

	 * 

	 * Pinta usando PxRaster

	 */	

	private void drawLWS(Graphics2D g, ViewPort viewPort, File fCoverage) {

		//Creamos el PxRaster

		rasterFile = new GdalFile(viewPort.getProjection(), fCoverage.getAbsolutePath());

		Extent e = new Extent(bbox);

		raster = new PxRaster(rasterFile, null, rasterFile.getExtent());

		//Recuperamos la pila de filtros si ya hubiese sido cargado antes

		if(this.filterStack!=null)

			raster.filterStack = this.filterStack;

		raster.setTransparency(false);

		//Creamos el viewportdata

		ViewPortData vpData = new ViewPortData(viewPort.getProjection(), e, viewPort.getImageSize() );

		vpData.setMat(viewPort.getAffineTransform());

		//Asignamos transparencia y orden de bandas

		if(this.transparency==-1 && !this.firstLoad);

		else

			raster.setTransparency(this.transparency);

		raster.setBand(GeoRasterFile.RED_BAND,rband);

		raster.setBand(GeoRasterFile.GREEN_BAND, gband);

		raster.setBand(GeoRasterFile.BLUE_BAND, bband);

		//Despues del primer pxRaster asignamos el stackManager guardado para los siguientes.

		//Con esto conseguimos asignar los cambios que se hayan producido desde el cuadro de 

		//propiedades cuando creamos un nuevo pxRaster

		if(this.stackManager != null)

			raster.setStackManager(this.stackManager); 

		raster.draw(g, vpData);

		//En el primer pxRaster de una imagen obtenemos el Stack Manager para poder modificarlo

		//si queremos desde las propiedades

		if(this.stackManager == null)

			this.stackManager = raster.getStackManager(); 

		if(this.filterStack == null)

			this.filterStack = raster.filterStack;

	}

	/**

	 * Gets the filter stack

	 * 

	 * Obtiene la pila de filtros

	 * @return 

	 */

	public RasterFilterStack getFilterStack(){

		if(raster!=null)

			return raster.filterStack;

		return null;

	}

	/**

	 * Sets the filter stack

	 * 

	 * Establece la pila de filtros

	 * 

	 * @param filterStack pila

	 */

	public void setFilterStack(RasterFilterStack filterStack){

		this.filterStack = filterStack; 		

	}

	/**

	 * Gets the last created PxRaster

	 * 

	 * Obtiene el ?ltimo PxRaster creado

	 * 

	 * @return

	 */

	public PxRaster getPxRaster(){

		return raster;

	}

	/**

	 * Gets the last open GeoRasterFile against the temp file received

	 * 

	 * Obtiene el ?ltimo GeoRasterFile abierto sobre el temporal recibido

	 * @return

	 */

	public GeoRasterFile getGeoRasterFile(){

		return rasterFile;

	}

	/**

	 * Sets the Bouning Box of the query according to the zoom. If the zoom's extension

	 * is greather than the coverage's full extent or the view only covers a part of

	 * the coverage's area, it cuts the required edges to those given by the coverage's

	 * full extent.

	 * 

	 * Establece la Bounding Box de la consulta seg?n el zoom. En caso de que 

	 * el zoom abarque m?s de la estensi?n m?xima (fullExtent) o la vista cubra

	 * solo una parte de la cobertura, acota los l?mites necesarios a aquellos

	 * marcados por la extensi?n m?xima.

	 * 

	 * @param rect

	 */

	public void setBBox(Rectangle2D rect) {

		double x1 = rect.getMinX();

		double y1 = rect.getMinY();

		double x2 = rect.getMaxX();

		double y2 = rect.getMaxY();

		if (x1 < fullExtent.getMinX())

			x1 = fullExtent.getMinX();

		if (y1 < fullExtent.getMinY())

			y1 = fullExtent.getMinY();

		if (x2 > fullExtent.getMaxX())

			x2 = fullExtent.getMaxX();

		if (y2 > fullExtent.getMaxY())

			y2 = fullExtent.getMaxY();

		if (bbox == null)

			bbox = new Rectangle2D.Double();

		bbox.setRect(x1, y1, x2 - x1, y2 - y1);

	}

	/**

	 * Establishes the initial values that will be included in the query.

	 * 

	 * Para establecer los valores iniciales que se incluiran en la consulta.

	 * 

	 * @param layersRectangle

	 * @param srs

	 * @param format

	 * @param parametro

	 * @param times

	 */

	public void setCoverageQuery(Rectangle2D bBox, Dimension sz) {

		String coverage    = "COVERAGE=" + coverageName;

		String crs 		   = "&CRS=" + SRS;

		String boundingBox = "&BBOX=" + bBox.getMinX() 

						   + "," + bBox.getMinY()

						   + "," + bBox.getMaxX()

						   + "," + bBox.getMaxY();

		String time 	   = this.time != null ? "&" + this.time : "";

		String param 	   = parameter != null ? "&" + parameter : "";

		res				   = new Point2D.Double(bBox.getWidth() / sz.getWidth(), bBox.getHeight() / sz.getHeight());

		// Calculo cutre para ver si son grados (o metros). Si da menos de 180

		// es que son grados y lo paso a metros. (LWS)

		if (bBox.getMaxY() < 181D)

			res.setLocation(res.getX()*METROSXGRADO, res.getY()*METROSXGRADO);

		String resX 	   = "&RESX=" + res.getX();

		String resY 	   = "&RESY=" + res.getY();

		String format 	   = "&FORMAT=" + this.format;

		coverageQuery = coverage + crs + boundingBox + time + param + resX	+ resY + format;

	}

	/**

	 * Takes the coverage parameters and give them to the WCS client. After this,

	 * it is possible to launch a GetCoverage operation.

	 * 

	 * Recoge los par?metros de la capa y los pasa al cliente WCS. Despu?s de

	 * esto, ya se puede lanzar una GetCoverage

	 *  

	 */

	private void setWCSClientCoverageQuery(String query) {

		lastCoverageQuery = query;

		((FMapWCSDriver) driver).setGetCoverageParams(query);

	}

	/**

	 * Returns the coverage name.

	 * 

	 * Devuelve el nombre de la cobertura

	 * @return

	 */

	public String getCoverageName() {

		return coverageName;

	}

	/**

	 * Sets the coverage name.

	 * 

	 * Establece el nombre de la cobertura

	 * @param coverageName

	 */

	public void setCoverageName(String coverageName) {

		this.coverageName = coverageName;

	}

	/**

	 * Returns an string containing the query that originated the coverage.

	 * 

	 * Obtiene una cadena que contiene la consulta que origin? la cobertura.

	 * @return String

	 */

	public String getCoverageQuery() {

		return coverageQuery;

	}

	/**

	 * Sets the query string (an URL) that originates the coverage.

	 * 

	 * Establece la cadena que contiene la consulta (URL) que origina la cobertura.

	 * @param coverageQuery

	 */

	public void setCoverageQuery(String coverageQuery) {

		this.coverageQuery = coverageQuery;

	}

	/**

	 * The coverage format.

	 * 

	 * El formato de la cobertura.

	 * @return String

	 */

	public String getFormat() {

		return format;

	}

	/**

	 * Sets the coverage format to download.

	 * 

	 * Establece el formato de la cobertura a descargar.

	 * @param format

	 */

	public void setFormat(String format) {

		this.format = format;

	}

	/**

	 * Gets the max coverage extension.

	 * 

	 * Obtiene la extensi?n m?xima de la cobertura

	 * @return

	 * @throws DriverException

	 * @throws IOException

	 */

	public Rectangle2D getFullExtent() throws IOException, DriverException {

	    if (fullExtent==null)

	        fullExtent = driver.getFullExtent(coverageName, SRS);

		return fullExtent;

	}

	/**

	 * Sets the max extension for the coverage. This value is specified

	 * by the server. Thus, this method should be used ONLY to reload

	 * this value from a saved proyect.

	 * 

	 * Establece la extensi?n m?xima de la cobertura. ?ste valor viene

	 * especificado por el servidor. No deber?a de usarse m?s que para

	 * recuperar un proyecto guardado o desde el Wizard.

	 * 

	 * @param fullExtent

	 */

	public void setFullExtent(Rectangle2D fullExtent) {

		this.fullExtent = fullExtent;

	}

	/**

	 * Gets the paramenter in name-value pair-formed string.

	 * 

	 * Recupera el valor de par?metro en forma de par nombre-valor: "nombre=valor"

	 * 

	 * @return String

	 */

	public String getParameter() {

		return parameter;

	}

	/**

	 * Sets the parameter and the parameter value list of the coverage as a name-value

	 * pair form where, for the moment, value is a comma-separated values list. 

	 * 

	 * Establece el par?metro y la lista de valores de la cobertura en forma

	 * de par nombre-valor donde valor es, por el momento, una lista separada 

	 * por comas

	 * @param parameter

	 */

	public void setParameter(String parameter) {

		this.parameter = parameter;

	}

	/**

	 * Gets the coverage SRS

	 * 

	 * Obtiene el SRS de la cobertura

	 * @return String

	 */

	public String getSRS() {

		return SRS;

	}

	/**

	 * Sets the coverage SRS

	 * 

	 * Establece el SRS

	 * @param srs

	 */

	public void setSRS(String srs) {

		SRS = srs;

	}

	/**

	 * Gets the TIME parameter.

	 * 

	 * Obtiene el par?metro TIME.

	 * 

	 * @return String

	 */

	public String getTime() {

		return time;

	}

	/**

	 * Sets the TIME parameter (according with the OGC standard it may

	 * be a comma-separated value list, but probably the server will not

	 * support querys with more than one value)

	 * 

	 * Establece el par?metro TIME (puede ser seg?n OGC una

	 * lista de valores separados por comas pero casi seguro que

	 * el servidor no soportar? m?s de un valor)

	 * @param time

	 */

	public void setTime(String time) {

		this.time = time;

	}

	/**

	 * Gets the WCS server's address.

	 * 

	 * Obtiene la direcci?n del servidor WCS

	 * @return String

	 */

	public String getHost() {

		return ((FMapWCSDriver) driver).getHost();

	}

	/**

	 * Sets the WCS server address.

	 * 

	 * Establece la direcci?n del servidor WCS

	 * @param host (String)

	 */

	public void setHost(String host) {

		((FMapWCSDriver) driver).setHost(host);

	}

	/**

	 * @deprecated

	 * @param g

	 * @param viewPort

	 * @param fCoverage

	 */

	private void drawJaume(Graphics2D g, ViewPort viewPort, File fCoverage) {

		Image coverage = renderizeRaster(getRaster(fCoverage));

		Point2D p1 = new Point2D.Double(bbox.getMinX(), bbox.getMaxY());

		viewPort.getAffineTransform().transform(p1, p1);

		g.drawImage(coverage, (int) p1.getX(), (int) p1.getY(), null);

	}

	/**

	 * Computes the geofile raster.

	 * 

	 * Computa el r?ster del fichero geogr?fico.

	 * 

	 * @deprecated

	 * @param coverage

	 * @return RasterBuf

	 */

	private RasterBuf getRaster(File coverage) {

		RasterBuf raster = null;

		Gdal migdal = new Gdal();

		GeoTransform gt = null;

		int ancho = 0, alto = 0;

		GdalRasterBand mirasterband = null;

		int rastercount = 0;

		try {

			migdal.open(coverage.getAbsolutePath(), Gdal.GA_ReadOnly);

		} catch (Exception ge) {

			ge.printStackTrace();

		}

		try {

			gt = migdal.getGeoTransform();

		} catch (GdalException e) {

			System.out

			.println("I can't obtain the array geoTransform for this image");

		}

		try {

			rastercount = migdal.getRasterCount();

			ancho = migdal.getRasterXSize();

			alto = migdal.getRasterYSize();

			int ngcp = migdal.getGCPCount();

			//System.out.println("NGCP="+ngcp);

		} catch (GdalException ge) {

			ge.printStackTrace();

			//...

		}

		try {

			int dataType = migdal.getRasterBand(1).getRasterDataType();

			GdalBuffer buf = null;

			/*

			 * Evita el problema de que haya m?s de 3 bandas en el fichero esto

			 * deberia hacerse asignando a las 3 bandas del raster una banda

			 * distinta del fichero (no necesariamente 1->0, 2->1 y 3->2

			 */

			if (rastercount > 3)

				rastercount = 3;

			if (dataType == Gdal.GDT_Byte) {

				raster = new RasterBuf(RasterBuf.TYPE_INT, ancho, alto,

						rastercount, null);

				for (int iBand = 0; iBand < rastercount; iBand++) {

					mirasterband = migdal.getRasterBand(iBand + 1);

					buf = mirasterband.readRaster(0, 0, ancho, alto, ancho,

							alto, dataType);

					for (int y = 0; y < alto; y++)

						for (int x = 0; x < ancho; x++)

							raster.setPixelInt(x, y, iBand, buf.buffByte[y

																		 * ancho + x] & 0xff);

				}

				migdal.close();

			} else if (dataType == Gdal.GDT_CInt16

					|| dataType == Gdal.GDT_UInt16

					|| dataType == Gdal.GDT_Int16) {

				raster = new RasterBuf(RasterBuf.TYPE_INT, ancho, alto,

						rastercount, null);

				for (int iBand = 0; iBand < rastercount; iBand++) {

					// System.out.println("Banda:"+iBand);

					mirasterband = migdal.getRasterBand(iBand + 1);

					buf = mirasterband.readRaster(0, 0, ancho, alto, ancho,

							alto, dataType);

					for (int y = 0; y < alto; y++)

						for (int x = 0; x < ancho; x++)

							raster.setPixelInt(x, y, iBand, buf.buffShort[y

																		  * ancho + x] & 0xffff);

				}

				migdal.close();

			}

		} catch (GdalException e1) {

			e1.printStackTrace();

		}

		return raster;

	}

	/**

	 * Construye un objeto Image a partir de un RasterBuf

	 * @deprecated (usado en drawJaume)

	 * @param raster

	 * @return Image

	 */

	public Image renderizeRaster(RasterBuf raster) {

		RasterStats stats = new RasterStats(raster.getBandNr());

		int alpha = 255; // transparencia

		boolean debug = false;

		ComputeMinMaxFilter filter = new ComputeMinMaxFilter(raster, stats);

		LinearEnhancementFilter lEFilter = new LinearEnhancementFilter(raster,

				stats);

		Image image = null;

		if (raster.getBandNr() == 1)

			image = new GreyscaleRasterToImageFilter(raster, alpha).getImage();

		else

			image = new RasterToImageFilter(raster, alpha).getImage();

		if (debug)

			stats.pinta();

		return image;

	}

	/**

	 * Returns the current bounding box.

	 * 

	 * Devuelve la boundix box actual.

	 * 

	 * @return Rectangle2D

	 */

	public Rectangle2D getBbox() {

		return bbox;

	}

	/**

	 * Gets the max resolution of the coverage.

	 * 

	 * Obtiene la resoluci?n m?xima de la cobertura

	 * @return maxRes

	 */

	//public double getMaxResolution() {

	public Point2D getMaxResolution() {

		return maxRes;

	}

	/**

	 * Sets the MAX resolution supported by the coverage.

	 * 

	 * The max resolution is given by the server within the DescribeCoverage document

	 * in the SpationDomain section.

	 * 

	 * Use this method only to load this value from there (the DescribeCoverage document)

	 * of from an already saved project because an incorrect value will bring

	 * computing errors when doing "zoom to raster resolution".

	 * 

	 * 

	 * 

	 * Establece la resoluci?n M?XIMA que soporta la cobertura.

	 * 

	 * La resoluci?n m?xima viene fijada por el servidor dentro documento

	 * DescribeCoverage en la secci?n SpatialDomain.

	 * 

	 * Use este m?todo ?nicamente para cargar el valor para la resoluci?n m?xima

	 * desde all? o desde un proyecto guardado en anterioridad, puesto que un

	 * valor incorrecto reportar? (conllevar?) errores de c?lculo cuando se haga

	 * un "zoom a la resoluci?n del r?ster".

	 * 

	 * @param res

	 */

	//public void setMaxResolution(double res) {

	public void setMaxResolution(Point2D res) {

		maxRes = res;

	}

	/**

	 * Sets the transparency for the next PxRaster that is going to be loaded.

	 * 

	 * Asigna la transparencia para el siguiente PxRaster que se cargue.

	 * @param t

	 */

	public void setTransparency(int t){

		this.transparency = t;

	}

	/**

	 * Sets the R-band.

	 * 

	 * Asigna la banda R.

	 * @param r

	 */

	public void setBandR(int r){

		this.rband = r;

	}

	/**

	 * Sets the G-band.

	 * 

	 * Asigna la banda G

	 * @param g

	 */

	public void setBandG(int g){

		this.gband = g;

	}

	/**

	 * Sets the B-band.

	 * 

	 * Asigna la banda B

	 * @param b

	 */

	public void setBandB(int b){

		this.bband = b;

	}

	/**

	 * Gets the coverage (not the FLyrWCS) from an URL.

	 * 

	 * Obtiene la cobertura (no la FLyrWCS) a partir de una URL.

	 * @param query

	 */

	public void getCoverageFromQuery(String query) {

		driver.setGetCoverageParams(query);

	}

}

public class FLyrWCS extends FLyrDefault {

	private WCSParamsPanel 				toc = null;

		if(status!=null)

import java.awt.Component;

import javax.swing.JOptionPane;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.gui.View;

		if(this.transparency != -1)