/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 4356

     import java.io.IOException;
     import java.util.ArrayList;
     import org.gvsig.remoteClient.wcs.WCSStatus;
     import com.iver.cit.gvsig.fmap.DriverException;
     import com.iver.cit.gvsig.fmap.drivers.WCSException;
     import com.iver.cit.gvsig.fmap.layers.WCSLayer;
     import es.uji.lsi.wcs.client.ServerErrorResponseException;
     import es.uji.lsi.wcs.client.ServerOutOfOrderException;
     /**
      * @author luisw
      */
-...
     	public String getLabel();
     	public String getDescription();
     	public void getCapabilities() throws ServerOutOfOrderException;
     	public void describeCoverage() throws ServerOutOfOrderException;
     	public File getCoverage() throws ServerErrorResponseException, IOException;
     	public void getCapabilities(WCSStatus status) throws WCSException;
     	public void describeCoverage(WCSStatus status) throws WCSException;
     	public File getCoverage(WCSStatus status) throws WCSException;
     	public String [] getCoverageNames();
     	public WCSLayer[] getLayerList();
     	/**
     	 * Gets the label of an specific label.
-...
     	 * @param coverageName (string)
     	 * @return double
     	 */
     	public Point2D getMaxResolution(String coverageName);
     	public Point2D getMaxResolution(String coverageName) throws WCSException ;
     	/**
     	 * Gets the times list of an specific coverage.

     /* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 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.drivers;
     import com.iver.andami.PluginServices;
     /**
      * Excepci�n provocada por el WCS.
+     *
      * @author Vicente Caballero Navarro
      */
     public class WCSException extends Exception {
     	String message;
     	public String getMessage() {
     		return PluginServices.getText(this, "wcs_server_error")+"\n"+format(message, 200);
+    	}
     	/**
+    	 *
     	 */
     	public WCSException() {
     		super();
+    	}
     	/**
     	 * Crea WCSException.
+    	 *
     	 * @param message
     	 */
     	public WCSException(String message) {
             super();
             this.message = message;
+    	}
     	/**
     	 * Crea WCSException.
+    	 *
     	 * @param message
     	 * @param cause
     	 */
     	public WCSException(String message, Throwable cause) {
     		super(format(message, 200), cause);
+    	}
     	/**
     	  * Crea WCSException.
+    	 *
     	 * @param cause
     	 */
     	public WCSException(Throwable cause) {
     		super(cause);
+    	}
         /**
          * Cuts the message text to force its lines to be shorter or equal to
          * lineLength.
          * @param message, the message.
          * @param lineLength, the max line length in number of characters.
          * @return the formated message.
          */
         private static String format(String message, int lineLength){
             if (message.length() <= lineLength) return message;
             String[] lines = message.split("\n");
             String theMessage = "";
             for (int i = 0; i < lines.length; i++) {
                 String line = lines[i].trim();
                 if (line.length()<lineLength)
                     theMessage += line+"\n";
                 else {
                     String[] chunks = line.split(" ");
                     String newLine = "";
                     for (int j = 0; j < chunks.length; j++) {
                         int currentLength = newLine.length();
                         chunks[j] = chunks[j].trim();
                         if (chunks[j].length()==0)
                             continue;
                         if ((currentLength + chunks[j].length() + " ".length()) <= lineLength)
                             newLine += chunks[j] + " ";
                         else {
                             newLine += "\n"+chunks[j]+" ";
                             theMessage += newLine;
                             newLine = "";
+                        }
+                    }
+                }
+            }
             return theMessage;
+        }
+    }

     import java.awt.geom.Rectangle2D;
     import java.io.File;
     import java.io.IOException;
     import java.net.ConnectException;
     import java.net.URL;
     import java.util.ArrayList;
     import java.util.Hashtable;
     import java.util.Iterator;
     import org.gvsig.remoteClient.wcs.WCSClient;
     import org.gvsig.remoteClient.wcs.WCSCoverage;
     import org.gvsig.remoteClient.wcs.WCSStatus;
     import com.iver.cit.gvsig.fmap.DriverException;
     import com.iver.cit.gvsig.fmap.drivers.RemoteServiceDriver;
     import com.iver.cit.gvsig.fmap.layers.WCSParameterModel;
     import com.iver.cit.gvsig.fmap.drivers.WCSException;
     import com.iver.cit.gvsig.fmap.layers.WCSLayer;
     import com.iver.cit.gvsig.fmap.services.OGCWCSService;
     import es.uji.lsi.wcs.XmlWcsParsing.AxisDescription;
     import es.uji.lsi.wcs.XmlWcsParsing.CoverageOffering;
     import es.uji.lsi.wcs.XmlWcsParsing.GMLEnvelopeWithTimePeriod;
     import es.uji.lsi.wcs.XmlWcsParsing.Interval;
     import es.uji.lsi.wcs.client.ServerErrorResponseException;
     import es.uji.lsi.wcs.client.ServerOutOfOrderException;
     import es.uji.lsi.wcs.client.WCSClient;
     /**
      * Driver between the FMap and WCSClient
+     *
-...
+     *
      */
     public class FMapWCSDriver extends RemoteServiceDriver implements OGCWCSService {
     	private WCSClient wcs = null;
     	private WCSClient client = null;
     	private WCSCoverage[] layers;
     	private Hashtable coverages;
     	private WCSLayer[] layerList;
     	/**
     	 * Returns the string "WCSDriver", which is the driver's name.
-...
     	 * Establece el servidor al que se quiere conectar.
+    	 *
     	 * @param host
     	 * @throws IOException
     	 */
     	public void setHost(String host){
     	public void setHost(String host) throws IOException{
     		super.setHost(host);
     		setServiceName("WCS");
     		wcs = new WCSClient(host);
     		client = new WCSClient(host);
+    	}
     	/**
     	 * Sends the GetCapabilities operation to the server.
+    	 *
     	 * Env?a la operaci?n GetCapabilities al servidor.
+    	 *
     	 * @throws ServerOutOfOrderException
     	 */
     	public void getCapabilities() throws ServerOutOfOrderException{
     		wcs.getCapabilities();
+    	}
     	/**
     	 * Sends the DescribeCoverage operation to the server.
+    	 *
     	 * Env?a la operaci?n DescribeCoverage
     	 */
     	public void describeCoverage(){
     		wcs.describeCoverage();
+    	}
     	/**
     	 * Sends the GetCoverage operation.
+    	 *
     	 * Env?a la operaci?n GetCoverage.
     	 * @throws IOException
     	 */
     	public File getCoverage() throws ServerErrorResponseException, IOException{
     		return wcs.getCoverage();
+    	}
     	/**
     	 * Returns the server's name. The string is extracted from the GetCapabilities
     	 * response.
+    	 *
     	 * Devuelve el nombre del servidor indicado por ?ste.
+    	 *
     	 * @return String
     	 */
     	public String getServerName(){
     		return wcs.getTheCapabilities().getServiceName();
+    	}
     	/**
     	 * Returns a human-readable string containing the server's name.
+    	 *
     	 * Devuelve el nombre legible del servidor devuelto por ?ste.
+    	 *
     	 * @return String
     	 */
     	public String getLabel(){
     		return wcs.getTheCapabilities().getServiceLabel();
     	 */
     	public String getLabel() {
     		return client.getServiceTitle();
+    	}
     	/**
-...
     	 * @return String
     	 */
     	public String getVersion(){
     		return wcs.getTheCapabilities().getVersion();
     		return client.getVersion();
+    	}
     	/**
     	 * <p>
     	 * Returns name and description of the server. It is supposed to be used
     	 * as the source of the abstract field in your application's interface.
+    	 *
     	 * </p>
     	 * <p>
     	 * Devuelve nombre y descripci?n (abstract) del servidor.
+    	 *
     	 * </p>
     	 * @return String
     	 */
     	public String getDescription(){
     		String name = wcs.getTheCapabilities().getServiceName();
     		String description = wcs.getTheCapabilities().getServiceDescription();
     		if ( (name == null) && (description == null) ) return "Sin descripci?n";
     		else if ( (name != null) && (description == null) ) return name;
     		else if ( (name == null) && (description != null) ) return description;
     		else if ( (name != null) && (description != null) ) return name+"\n\n"+description;
     		else return null;
     		return client.getDescription();
+    	}
     	/**
     	 * Returns the update sequence value.
+    	 *
     	 * Devuelve el valor de update sequence del servidor
+    	 *
     	 * @return String
     	 */
     	public String getUpdateSequence(){
     		return wcs.getTheCapabilities().getUpdateSequence();
+    	}
     	/**
     	 * Returns a list containing the formats supported by the coverage
-...
     	 * @return ArrayList
     	 */
     	public ArrayList getFormats(String coverage){
     		return wcs.getCoverageDescription(coverage).getSupportedFormats().getFormats();
     		return client.getFormats();
+    	}
     	/**
     	 * Returns the metadata link.
+    	 *
     	 * Devuelve el enlace a los metadatos.
+    	 *
     	 * @return String
     	 */
     	public String getMetadataLink(){
     		return wcs.getTheCapabilities().getServiceMetadatalink();
+    	}
     	/**
     	 * Returns the responsible party value.
+    	 *
     	 * Devuelve el valor para responsible party.
+    	 *
     	 * @return String
     	 */
     	public String getResponsibleParty(){
     		return wcs.getTheCapabilities().getServiceResponsibleParty();
     	public WCSLayer[] getLayerList(){
     		if (coverages == null) {
     			// the WCSLayer collection will be built
     			coverages = new Hashtable();
     			Hashtable wcsCoverages  = client.getCoverageList();
     			int sz = wcsCoverages.size();
     			// Create an array with the WCSCoverages
     			WCSCoverage[] coverageList = new WCSCoverage[sz];
     			Iterator it = wcsCoverages.keySet().iterator();
     			int i = 0;
     			while (it.hasNext()) {
     				coverageList[i] = (WCSCoverage) it.next();
     				i++;
+    			}
     			// Create a WCSLayer array from the previous WCSCoverage array
     			layerList = new WCSLayer[sz];
     			for (int j = 0; j < layers.length; j++) {
     				WCSLayer lyr = new WCSLayer();
     				WCSCoverage cov = coverageList[i];
     				lyr.setName(cov.getName());
     				lyr.addAllSrs(cov.getAllSrs());
     				lyr.setTitle(cov.getTitle());
     				lyr.setNativeSRS(cov.getNativeSRS());
     				lyr.setFormats(cov.getFormats());
     				lyr.setMaxRes(new Point2D.Double(cov.getResX(), cov.getResY()));
     				// TODO par?metres i time
     				layerList[j] = lyr;
     				coverages.put(lyr.getName(), lyr);
+    			}
+    		}
     		return layerList;
+    	}
     	/**
     	 * Returns a list containing the names of the coverages located at the server.
+    	 *
     	 * Devuelve una lista de nombres de coberturas
+    	 *
     	 * @return String[]
     	 */
     	public String[] getCoverageNames(){
     		return wcs.getTheCapabilities().getCoverageNames();
+    	}
     	/**
     	 * Returns the number of coverages at the server.
+    	 *
     	 * Devuelve el numero de coberturas en el servidor
+    	 *
     	 * @return int
     	 */
     	public int getNumOfCoverages(){
     		return getCoverageNames().length;
+    	}
     	/**
     	 * Returns the details of the coverage given by the coverage's name.
+    	 *
     	 * Devuelve los detalles de la cobertura en CoverageOffering
     	 * @param nomCobertura
     	 * @return CoverageOffering (es.uji.lsi.wcs.XmlParsing.CoverageOffering)
     	 */
     	public CoverageOffering getCoverageDetails(String nomCobertura){
     		return wcs.getCoverageDescription(nomCobertura);
+    	}
     	/**
     	 * Establishes the connection to the WCS server. Connecting to a WCS is
     	 * an abstraction, it actually sends a GetCapabilities and a general
     	 * DescribeCoverage request (not a coverage-specific DescribeCoverage request)
-...
     	 * @throws IOException, DriverException.
     	 */
     	public void connect() throws IOException, DriverException {
     		wcs = new WCSClient(getHost());
     		try {
     			wcs.getCapabilities();
     			wcs.describeCoverage();
     			setConnected(true);
     		} catch (ServerOutOfOrderException e) {
     			throw new DriverException(e);
+    		}
     		client = new WCSClient(getHost());
     		setConnected( client.connect() );
+    	}
     	/**
     	 * No close operation is needed since WCS service it is a non-session based
     	 * protocol. So, this does nothing and you can omit it.
-...
+    	 *
     	 */
     	public void close() {
     		// No fa res, tal volta this= null?
     		setConnected(false);
+    	}
     	/**
     	 * Returns the full extent for a specific SRS given by the second
     	 * argument srs of the specific coverage given by the coverage's name
     	 * in the first argument. You likely preffer to use getFullExtent(String, String)
+    	 *
     	 * Devuelve la extensi?n m?xima para un SRS espec?fico dado en el segundo
     	 * argumento de una cobertura especifica dada por su nombre en el primer
     	 * argumento. Probablemente prefiera usar getFullExtent(String, String)
+    	 *
     	 * @param coverageName
     	 * @param srs
     	 * @throws DriverException
     	 * @throws IOException
     	 */
     	private Rectangle2D getBoundingBoxExtensionMaxima(String coverageName, String srs) throws IOException, DriverException {
     		// TODO Has de considerar el cas per a quan el SRS no vinga als RequestResponse
     		// ni cap altre...
     		// IDEA: agafar  algun dels de CoverageOfferingBrief i aplicar la transformaci?.
     		CoverageOffering co = wcs.getCoverageDescription(coverageName);
     		if (!isConnected())
     		    connect();
     		if (co.getDomainSet() != null) {
     			if (co.getDomainSet().getSpatialDomain() != null){
     				ArrayList gewtpList = co.getDomainSet().getSpatialDomain().getGMLEnvelopeWithTimePeriodList();
     				Iterator it = gewtpList.iterator();
     				while (it.hasNext()){
     					GMLEnvelopeWithTimePeriod gewtp = (GMLEnvelopeWithTimePeriod) it.next();
     					if (gewtp.getSRSName().equals(srs)) {
     						return new Rectangle2D.Double(
     								gewtp.getMinX(),
     								gewtp.getMinY(),
     								gewtp.getMaxX()-gewtp.getMinX(),
     								gewtp.getMaxY()-gewtp.getMinY());
+    					}
+    				}
+    			}
+    		}
     		// Si llego aqu? es porque no ha habido ninguno. Tengo que transformar de las del BoundingBox.
     		return null;
+    	}
     	/**
     	 * Sends the GetCoverage query args using a string containing list of
     	 * &-separated pair-values (name=value)
+    	 *
     	 * Env?a los valores de la consulta GetCoverage en forma cadena de pares
     	 * 'nombre=valor' separados por '&'.
     	 */
     	public void setGetCoverageParams(String query) {
     		wcs.setGetCoverageParams(query);
+    	}
     	/**
     	 * Returns the label of an specific coverage given by the coverage name
+    	 *
     	 * Obtiene la etiqueta de una cobertura espec?fica
-...
     	 * @return string
     	 */
     	public String getLabel(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		return co.getCoverageOfferingBrief().getLabel();
     		return client.getLabel(coverageName);
+    	}
     	/**
-...
     	 * @throws IOException
     	 */
     	public Rectangle2D getFullExtent(String coverageName, String srs) throws IOException, DriverException {
     		return getBoundingBoxExtensionMaxima(coverageName, srs);
     		return client.getExtent(coverageName, srs);
+    	}
     	/**
-...
     	 * @return ArrayList de Parametro
     	 */
     	public ArrayList getParameters(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		ArrayList lista_descripciones =	co.getRangeSet().getAxisDescriptionList();
     		ArrayList lista_parametros = new ArrayList();
     		if (lista_descripciones!= null){
     			Iterator it = lista_descripciones.iterator();
     			while (it.hasNext()){
     				AxisDescription ad = ((AxisDescription) it.next());
     				WCSParameterModel p = new WCSParameterModel();
     				p.setName(ad.getName());
     				p.setType(ad.getValuesType());
     				if (p.getType().equals("singleValue")){
     						p.setLista_valores_simples(ad.getSingleValues());
+    				}
     				lista_parametros.add(p);
     				if (p.getType().equals("interval")){
     						Interval interv = ad.getInterval();
     						p.setMin(interv.getMin());
     						p.setMax(interv.getMax());
     						p.setRes(interv.getRes());
+    				}
+    			}
+    		}
     		return lista_parametros;
     		// TODO
     		return null;
+    	}
     	/**
-...
     	 * @param nombre de la cobertura (string)
     	 * @return double
     	 */
     	/*public double getMaxResolution(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		return co.getDomainSet().getSpatialDomain().getMaxRes();
     	}*/
     	public Point2D getMaxResolution(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		return co.getDomainSet().getSpatialDomain().getMaxRes();
     		// TODO
     		return null;
+    	}
-...
     	 * @return ArrayList
     	 */
     	public ArrayList getSRSs(String coverageName) {
     		// TODO Si el servidor da algun CRS en RequestResponse se usar? esta respuesta
     		// 		en caso contrario, se usar?n el de la cobertura en SpatialDomain.
     		//		Esto est? por revisar, ya que deber?a tener inteligencia para
     		//		transformar entre sistemas de proyecciones diferentes
     		CoverageOffering co = getCoverageDetails(coverageName);
     		return co.getDomainSet().getSpatialDomain().getGMLEnvelopeNames();
     		// TODO
     		return null;
+    	}
     	/**
-...
     	 * @return string
     	 */
     	public String getCoverageDescription(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		return co.getCoverageOfferingBrief().getDescription();
     		// TODO
     		return null;
+    	}
     	/**
-...
     	 * @return ArrayList
     	 */
     	public ArrayList getTimes(String coverageName) {
     		CoverageOffering co = getCoverageDetails(coverageName);
     		if (co.getDomainSet().getTemporalDomain()!=null){
     			return co.getDomainSet().getTemporalDomain().getGMLTimePositionList();
+    		}
     		// TODO
     		return null;
+    	}
     	public void getCapabilities(WCSStatus status) throws WCSException {
     		// TODO Auto-generated method stub
+    	}
     	public void describeCoverage(WCSStatus status) throws WCSException {
     		// TODO Auto-generated method stub
+    	}
     	public File getCoverage(WCSStatus status) throws WCSException {
     		// TODO Auto-generated method stub
     		return null;
+    	}
     	/**
          * Creates a new instance of a WCSClient.
          * @param host
          * @throws IOException
          * @throws ConnectException
          */
     	public void createClient(URL host) throws ConnectException, IOException{
     		client = new WCSClient(host.toString());
+    	}
+    }

trunk/extensions/extWCS/src/com/iver/cit/gvsig/fmap/drivers/RemoteServiceDriver.java
113	113	* Sets the host name.
114	114	*
115	115	* Establece el nombre del host.
	116	* @throws IOException
116	117	*/
117		public void setHost(String hostName) {
	118	public void setHost(String hostName) throws IOException {
118	119	this.hostName = hostName;
119	120	}
120	121

     /* 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.awt.image.DataBuffer;
     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 FMapWCSAdapter recubre la interacci?n con el FMapWCSDriver
      * @author jaume - jaume.dominguez@iver.es
+     *
      */
     public class FMapWCSAdapter {
     	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
     	 * @throws IOException
     	 */
     	public void draw(BufferedImage image, Graphics2D g,
     			ViewPort viewPort, Cancellable cancel) throws DriverException, ServerErrorResponseException, IOException {
     		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));
     			if (lastCoverageQuery.compareTo(coverageQuery) != 0) {
     				setWCSClientCoverageQuery(coverageQuery);
     					fCoverage = driver.getCoverage();
+    			}
     			if (fCoverage != null) {
     				//drawJaume(g, viewPort, fCoverage);
     				drawLWS(g, viewPort, fCoverage);
+    			}
+    	}
     	/**
     	 * 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;
     		rasterFile.close();
+    	}
     	/**
     	 * Gets the filter stack
+    	 *
     	 * Obtiene la pila de filtros
     	 * @return
     	 */
     	public RasterFilterStack getFilterStack(){
     		if(raster!=null)
     			return raster.filterStack;
     		return null;
+    	}
     	/**
     	 * Obtiene la lista de atributos de raster
     	 * @return	lista de atributos. Cada elmento de la lista es un array Object
     	 * con dos elementos. El primero el nombre del atributo y el segundo el valor
     	 * del mismo.
     	 */
     	public ArrayList getAttributes() {
     		if(rasterFile != null){
     			ArrayList attr = new ArrayList();
     			String dataType = "Byte";
     			if (rasterFile.getDataType() == DataBuffer.TYPE_BYTE) dataType = "Byte";
     			else if (rasterFile.getDataType() == DataBuffer.TYPE_SHORT)
     				dataType = "Short";
     			else if (rasterFile.getDataType() == DataBuffer.TYPE_USHORT)
     				dataType = "Unsigned Short";
     			else if (rasterFile.getDataType() == DataBuffer.TYPE_INT)
     				dataType = "Integer";
     			else if (rasterFile.getDataType() == DataBuffer.TYPE_FLOAT)
     				dataType = "Float";
     			else if (rasterFile.getDataType() == DataBuffer.TYPE_DOUBLE)
     				dataType = "Double";
     			else
     				dataType = "Unknown";
     			Object [][] a = {
     				{"Filename",rasterFile.getName().substring(rasterFile.getName().lastIndexOf("/")+1, rasterFile.getName().length())},
     				{"Filesize",new Long(rasterFile.getFileSize())},
     				{"Width",new Integer(rasterFile.getWidth())},
     				{"Height", new Integer(rasterFile.getHeight())},
     				{"Bands", new Integer(rasterFile.getBandCount())}
     				//{"BandDataType", dataType}
     			};
     			for (int i=0; i<a.length; i++){
     				System.out.println("===> "+a[i][0]+" "+a[i][1]);
     				attr.add(a[i]);
+    			}
     			return attr;
+    		}
     		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());
     		// TODO LWS 01 oct 05 esto no funciona. Hay que hacer un c?lculo correcto
     		// y reevaluar porqu? hizo falta.
     		// mientras tanto RESX y RESY ya no se usan
     		// 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 + format;
     		coverageQuery += "&WIDTH="+sz.width+"&HEIGHT="+sz.height;
     		System.out.println("coverageQuery="+coverageQuery);
     		// coverageQuery += resX + resY;
+    	}
     	/**
     	 * 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.
+    	 *

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff