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.wms.io;

import java.awt.geom.Rectangle2D;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.ConnectException;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

import java.util.TreeMap;

import java.util.Vector;

import java.util.prefs.Preferences;

import javax.management.RuntimeErrorException;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

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

import org.gvsig.remoteclient.exceptions.ServerErrorException;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSClient;

import org.gvsig.remoteclient.wms.WMSDimension;

import org.gvsig.remoteclient.wms.WMSLayer;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.remoteclient.wms.WMSStyle;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class WMSConnector  {

	private WMSClient                     client;

    private WMSLayerNode                  fmapRootLayer;

    private TreeMap<String, WMSLayerNode> layers = new TreeMap<String, WMSLayerNode>();

    private Logger                        log    = LoggerFactory.getLogger(WMSConnector.class);

    public WMSConnector(URL url) throws ConnectException, IOException {

    	client = new WMSClient(url.toString());

    }

    public String[] getLayerNames() {

    	return client.getLayerNames();

    }

    public String[] getLayerTitles() {

    	return client.getLayerTitles();

    }

	public void getCapabilities(URL server) throws RemoteServiceException {

//		try {

//			client.connect();

//		} catch (Exception e) {

//			throw new WMSException(e);

//		}

	}

    public File getMap(WMSStatus status, ICancellable cancel) throws RemoteServiceException {

        try {

			return client.getMap(status, cancel);

        } catch (org.gvsig.remoteclient.exceptions.WMSException e) {

            throw new RemoteServiceException(e.getMessage());

        } catch (ServerErrorException e) {

            throw new RemoteServiceException("WMS Unexpected server error." + e.getMessage(), e);

        }

    }

    /**

     * 

     * @param status

     * @param cancel

     * @param file

     * @throws RemoteServiceException

     */

    public void getMap(WMSStatus status, ICancellable cancel, File file) throws RemoteServiceException {

        try {

			URL url = client.getGetMapURL(status, cancel);

			downloadFile(url, file, cancel);

			String exceptionMessage = client.getExceptionMessage(file);

			if(exceptionMessage != null)

				throw new RemoteServiceException(exceptionMessage);

		} catch(IOException e) {

			throw new RemoteServiceException("WMS: error downloading the file. File:" + file.getAbsolutePath() + "...." + e.getMessage());

		} catch (ServerErrorException e) {

            throw new RemoteServiceException("WMS Unexpected server error."+e.getMessage());

        }  catch (org.gvsig.remoteclient.exceptions.WMSException e) {

            throw new RemoteServiceException(e.getMessage());

        }

    }

    public void downloadFile(URL url, File dstFile, ICancellable cancel) throws IOException {

		Preferences prefs = Preferences.userRoot().node( "gvsig.downloader" );

		// by default 1 minute (60000 milliseconds.

		int timeout = prefs.getInt("timeout", 60000);

		DataOutputStream dos;

		DataInputStream is;

		OutputStreamWriter os = null;

		HttpURLConnection connection = null;

		//If the used protocol is HTTPS

		if (url.getProtocol().equals("https")) {

			try {

				disableHttsValidation();

			} catch (KeyManagementException e) {

				e.printStackTrace();

			} catch (NoSuchAlgorithmException e) {

				e.printStackTrace();

			}

		}

		connection = (HttpURLConnection)url.openConnection();

		connection.setConnectTimeout(timeout);

		is = new DataInputStream(url.openStream());

		dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(dstFile)));

		byte[] buffer = new byte[1024 * 4];

		long readed = 0;

		for (int i = is.read(buffer); i > 0; i = is.read(buffer)){

			dos.write(buffer, 0, i);

			readed += i;

			if(cancel != null && cancel.isCanceled())

				return;

		}

		if(os != null) {

			os.close();

		}

		dos.close();

		is.close();

		is = null;

		dos = null;

	}

	/**

	 * This method disables the Https certificate validation.

	 * @throws KeyManagementException

	 * @throws NoSuchAlgorithmException

	 */

	private void disableHttsValidation() throws KeyManagementException, NoSuchAlgorithmException{

		// Create a trust manager that does not validate certificate chains

		TrustManager[] trustAllCerts = new TrustManager[] {

				new X509TrustManager() {

					public java.security.cert.X509Certificate[] getAcceptedIssuers() {

						return null;

					}

					public void checkClientTrusted(

							java.security.cert.X509Certificate[] certs, String authType) {

					}

					public void checkServerTrusted(

							java.security.cert.X509Certificate[] certs, String authType) {

					}

				}

		};

		// Install the all-trusting trust manager

		SSLContext sc = SSLContext.getInstance("SSL");

		sc.init(null, trustAllCerts, new java.security.SecureRandom());

		HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

	}

    /**

     * Gets the legend graphic of one layer

     */

    public File getLegendGraphic(WMSStatus status, String layerName, ICancellable cancel) throws RemoteServiceException {

        try {

        	File f = client.getLegendGraphic(status, layerName, cancel);

			return f;

        } catch (org.gvsig.remoteclient.exceptions.WMSException e) {

            //throw new RemoteServiceException(e.getMessage());

        } catch (ServerErrorException e) {

            throw new RemoteServiceException("WMS Unexpected server error."+e.getMessage());

        }

        return null;

    }

	/**

	 * Devuelve WMSClient a partir de su URL.

	 *

	 * @param url URL.

	 *

	 * @return WMSClient.

	 * @throws IOException

	 * @throws ConnectException

	 *

	 * @throws UnsupportedVersionException

	 * @throws IOException

	 */

    /**

     * Establishes the connection.

     * @param override, if true the previous downloaded data will be overridden

     * @return <b>true</b> if the connection was successful, or <b>false</b> if it was no possible

     * to establish the connection for any reason such as version negotiation.

     */

    public boolean connect(boolean override, ICancellable cancel) {

    	if (override) {

    		fmapRootLayer = null;

    		layers.clear();

    	}

		return client.connect(override, cancel);

    }

    /**

     * Establishes the connection.

     * @param override, if true the previous downloaded data will be overridden

     * @return <b>true</b> if the connection was successful, or <b>false</b> if it was no possible

     * to establish the connection for any reason such as version negotiation.

     */

    public boolean connect(DataServerExplorerParameters p, boolean override, ICancellable cancel) {

    	if (override) {

    		fmapRootLayer = null;

    		layers.clear();

    	}

    	WMSStatus status = new WMSStatus();

    	if (p!=null && p instanceof WMSServerExplorerParameters) {

    		status.setXyAxisOrder(((WMSServerExplorerParameters) p).isXyAxisOrder());

    	}

		return client.connect(status, override, cancel);

    }

    /**

     * 

     * @param cancel

     * @return

     * @deprecated Use {@link #connect(WMSServerExplorerParameters, boolean, ICancellable)}

     * instead

     */

    public boolean connect(ICancellable cancel) {

    	return client.connect(false, cancel);

    }

    /**

     * @return the version of this client.

     */

    public String getVersion() {

    	return client.getVersion();

    }

    /**

     * @return The title of the service offered by the WMS server.

     */

    public String getServiceTitle() {

		return client.getServiceInformation().title;

    }

    /**

     * Returns a Hash table containing the values for each online resource.

     * Using as key a String with name of the WMS request and the value returned

     * by the hash is another string containing the corresponding Url

     * @return HashTable

     */

	public Hashtable getOnlineResources() {

    	return client.getServiceInformation().getSupportedOperationsByName();

    }

    /**

     * @return <b>Vector</b> containing strings with the formats supported by this server.

     */

    public Vector getFormats() {

    	return client.getFormats();

    }

    /**

     * @return <b>Vector</b> containing strings with the information formats supported by this server.

     */

    public Vector getInfoFormats() {

    	return client.getInfoFormats();

    }

    /**

     * @return <b>Boolean</b> returns if the WMS is queryable (suppports GetFeatureInfo)

     */

    public boolean isQueryable() {

        return client.isQueryable();

    }

    /**

     * @return <b>Boolean</b> returns if the WMS supports getLegendGraphic operation (suppports GetFeatureInfo)

     */

    public boolean hasLegendGraphic() {

        return client.hasLegendGraphic();

    }

    /**

     * @return A tree containing the info of all layers available on this server.

     */

    public WMSLayerNode getLayersTree() {

        if (fmapRootLayer == null){

            WMSLayer clientRoot;

            if (client.getLayersRoot() == null) {

            	client.connect(false, null);

            }

            clientRoot = client.getLayersRoot();

            fmapRootLayer = parseTree(clientRoot, null);

        }

        return fmapRootLayer;

    }

    /**

     * Parses the client's layer node and translates it to a fmap's layer node

     * @param WMSLayer

     * @return WMSLayerNode

     */

    @SuppressWarnings("unchecked")

	private WMSLayerNode parseTree(WMSLayer node, WMSLayerNode parentNode) {

        WMSLayerNode myNode = new WMSLayerNode();

        // Name

        myNode.setName(node.getName());

        // Title

        myNode.setTitle(node.getTitle());

        // Transparency

        myNode.setTransparency(node.hasTransparency());

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

        	String srs = (String)node.getAllSrs().get(i);

        	if(node.getBbox(srs) == null) {

        		IProjection projSrc = CRSFactory.getCRS("EPSG:4326");

        		try {

        			IProjection projDst = CRSFactory.getCRS(srs);

        			if(projDst != null) {

        				try {

        					ICoordTrans t = projSrc.getCT(projDst);

        					Rectangle2D r = t.convert(getRectangleFromBoundaryBox(node.getLatLonBox()));

        					BoundaryBox bbox = getBoundaryBoxFromRectangle(r);

        					bbox.setSrs(srs);

        					node.addBBox(bbox);

        				} catch (Exception e) {

        					log.info("I cannot get the transformation between EPSG:4326 and " + srs, e);

        				}

        			}

        		} catch (Exception e1) {

        			log.info("I cannot get " + srs, e1);

        			node.removeSrs(srs);

        		}

        	}

		}

        myNode.setSrs(node.getAllSrs());

        // Queryable

        myNode.setQueryable(node.isQueryable() && client.getServiceInformation().isQueryable());

        // Parent layer

        myNode.setParent(parentNode);

        // Abstract

        myNode.setAbstract(node.getAbstract());

        // Fixed Size

        myNode.setFixedSize(node.getfixedWidth(), node.getfixedHeight());

        // LatLonBox

        if (node.getLatLonBox()!=null)

            myNode.setLatLonBox(node.getLatLonBox().toString());

        // Keywords

        ArrayList keywords = node.getKeywords();

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

        	myNode.addKeyword((String) keywords.get(i));

		}

        // Styles

        ArrayList styles = node.getStyles();

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

            WMSStyle style = (WMSStyle) styles.get(i);

            myNode.addStyle(style);

        }

        // Dimensions

        ArrayList dimensions = node.getDimensions();

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

            WMSDimension d = (WMSDimension) dimensions.get(i);

            myNode.addDimension(d.getName(), d.getUnits(), d.getUnitSymbol(), d.getDimensionExpression());

        }

        // Children

        int children = node.getChildren().size();

        myNode.setChildren(new ArrayList());

        for (int i = 0; i < children; i++) {

            myNode.getChildren().add(parseTree((WMSLayer)node.getChildren().get(i), myNode));

        }

        if (myNode.getName()!=null)

            layers.put(myNode.getName(), myNode);

        return myNode;

    }

    public Rectangle2D getRectangleFromBoundaryBox(BoundaryBox bbox) {

    	return new Rectangle2D.Double(bbox.getXmin(),

    			bbox.getYmin(),

    			Math.abs(bbox.getXmax() - bbox.getXmin()),

    			Math.abs(bbox.getYmax() - bbox.getYmin()));

    }

    public BoundaryBox getBoundaryBoxFromRectangle(Rectangle2D r) {

    	BoundaryBox bbox = new BoundaryBox();

    	bbox.setXmin(r.getMinX());

    	bbox.setXmax(r.getMaxX());

    	bbox.setYmin(r.getMinY());

    	bbox.setYmax(r.getMaxY());

    	return bbox;

    }

    public String getAbstract() {

    	return client.getServiceInformation().abstr;

    }

    public Rectangle2D getLayersExtent(String[] layerName, String srs) {

    	return client.getLayersExtent(layerName, srs);

    }

    public WMSLayerNode getLayer(String layerName) {

        if (getLayers().get(layerName) != null) {

            return (WMSLayerNode)layers.get(layerName);

        }

        return null;

    }

	private TreeMap getLayers() {

        if (fmapRootLayer == null){

            fmapRootLayer = getLayersTree();

        }

        return layers;

    }

    public String getFeatureInfo(WMSStatus _wmsStatus, int i, int j, int max_value, ICancellable cancellable) throws RemoteServiceException {

        try {

            return client.getFeatureInfo(_wmsStatus, i, j, max_value, cancellable);

        } catch (org.gvsig.remoteclient.exceptions.WMSException e) {

            throw new RemoteServiceException();

		}

    }

    public String getHost(){

    	return client.getHost();

    }

}

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

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

import javax.swing.ImageIcon;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

import org.gvsig.raster.impl.datastruct.BandListImpl;

import org.gvsig.raster.impl.datastruct.DatasetBandImpl;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.RemoteRasterProvider;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.raster.impl.store.properties.RemoteStoreHistogram;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.wms.io.downloader.WMSTileServer;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.ToolsLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase que representa al driver de acceso a datos de wms.

 *

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

 */

public class WMSProvider extends AbstractRasterProvider implements RemoteRasterProvider {

	public static String                NAME                     = "Wms Store";

	public static String                DESCRIPTION              = "Wms Raster file";

	public static final String          METADATA_DEFINITION_NAME = "WmsStore";

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

	private static final int            FIXED_SIZE               = 800;

	private Extent                      viewRequest              = null;

	private static Hashtable<String, WMSConnector>    

	                                    drivers                  = new Hashtable<String, WMSConnector> ();

	private boolean                     open                     = false;

	private DataStoreTransparency       fileTransparency         = null;

	private final int					minTilePrintWidth        = 12;

	private final int					minTilePrintHeight       = 12;

	//The out size depends on the last request

	private int                         lastWidthRequest         = 0;

	private int                         lastHeightRequest        = 0;

	//Only for fixed size. Complete extent and FIXED_SIZE in long side

	private File                        fileLayerPixelSize       = null;

	private File                        lastRequest              = null;

	private AbstractRasterProvider       lastRequestProvider      = null;

	public static void register() {

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					WMSProvider.class, WMSDataParametersImpl.class);

		}

		if (!dataman.getExplorerProviders().contains(WMSServerExplorer.NAME)) {

			dataman.registerExplorerProvider(WMSServerExplorer.NAME, WMSServerExplorer.class, WMSServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	public WMSProvider() throws NotSupportedExtensionException {

		super();

	}

	public void registerTileProviderFormats(Class<RasterProvider> c) {

	}

	/**

	 * Constructor. Abre el dataset.

	 * @param proj Proyecci?n

	 * @param fName Nombre del fichero

	 * @throws NotSupportedExtensionException

	 */

	public WMSProvider(String params) throws InitializeException {

		super(params);

		if(params instanceof String) {

			WMSDataParameters p = new WMSDataParametersImpl();

			p.setURI((String)params);

			super.init(p, null, ToolsLocator.getDynObjectManager()

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

	public WMSProvider(WMSDataParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Gets the connector from the URL

	 * @return

	 * @throws RemoteServiceException

	 */

	public WMSConnector getConnector() throws RemoteServiceException {

		WMSDataParameters p = (WMSDataParameters)parameters;

		URL url = null;

		try {

			url = new URL(p.getURI());

		} catch (Exception e) {

			throw new RemoteServiceException("Malformed URL",e);

		}

		try {

			return WMSProvider.getConnectorFromURL(url, false);

		} catch (IOException e) {

			throw new RemoteServiceException("Error getting the connector",e);

		}

	}

	/**

	 * Crea las referencias al fichero y carga

	 * las estructuras con la informaci?n y los metadatos.

	 * @param proj Proyecci?n

	 * @param param Parametros de carga

	 * @throws NotSupportedExtensionException

	 */

	public void init (DataStoreParameters params,

			DataStoreProviderServices storeServices) throws InitializeException {

		setParam(storeServices, params);

		setDataType(new int[]{Buffer.TYPE_BYTE, Buffer.TYPE_BYTE, Buffer.TYPE_BYTE});

		bandCount = 3;

		open = true;

		try {

			loadInitialInfo();

		} catch (RasterDriverException e) {

			throw new InitializeException(e.getMessage(), e);

		}

	}

	/**

	 * When a WMS provider is opened the information of data type, number of bands and transparency 

	 * is not available. Only after the first time a raster has been downloaded it can be know.

	 * @param newDataType

	 * @param buf

	 * @param bandList

	 * @return

	 * @throws RasterDriverException 

	 */

	private void loadInitialInfo() throws RasterDriverException {

		WMSDataParametersImpl p = (WMSDataParametersImpl)parameters;

		Extent ext = getExtent();

		Rectangle2D bBox = ext.toRectangle2D();

		int w = 0;

		int h = 0;

		if(ext.width() > ext.height()) {

			w = 200;

			h = (int)((ext.height() * w) / ext.width());

		} else {

			h = 200;

			w = (int)((ext.width() * h) / ext.height());

		}

		p.setWidth(w);

		p.setHeight(h);

		p.setExtent(bBox);

		if(p.getSRSCode() != null) {

			try {

				IProjection proj = CRSFactory.getCRS(p.getSRSCode());

				setProjection(proj, false);

			} catch (Exception e) {

			}

		}

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		lastRequest = downloadFile(wmsStatus, ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), w, h);

		AbstractRasterProvider driver;

		try {

			driver = DefaultProviderServices.loadProvider(lastRequest);

			setDataType(driver.getDataType());

			bandCount = driver.getBandCount();

			if(bandCount > 3) {

				getColorInterpretation().setColorInterpValue(3, DataStoreColorInterpretation.ALPHA_BAND);

				getTransparency().setTransparencyBand(3);

			}

			setColorTable(driver.getColorTable());

			driver.close();

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("", e);

		}

	}

	public static final WMSConnector getConnectorFromURL(URL url, boolean updating) throws IOException {

		WMSConnector drv = null;

		if(!updating) {

			drv = (WMSConnector) drivers.get(url.toString());

		} else {

			if(drivers.get(url.toString()) != null)

				drivers.remove(url.toString());

		}

		if (drv == null) {

			drv = new WMSConnector(url);

			drivers.put(url.toString(), drv);

		}

		return drv;

	}

	/**

	 * Obtiene el objeto que contiene que contiene la interpretaci?n de

	 * color por banda

	 * @return

	 */

	public ColorInterpretation getColorInterpretation() {

		if(super.getColorInterpretation() == null) {

			ColorInterpretation colorInterpretation = new DataStoreColorInterpretation(getBandCount());

			if(getBandCount() == 1 || getBandCount() == 2)

				colorInterpretation = DataStoreColorInterpretation.createGrayInterpretation();

			if(getBandCount() == 3)

				colorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

			if(getBandCount() == 4)

				colorInterpretation = DataStoreColorInterpretation.createRGBAInterpretation();

			setColorInterpretation(colorInterpretation);

		}

		return super.getColorInterpretation();

	}

	public AffineTransform getAffineTransform() {

		WMSDataParameters p = (WMSDataParameters)parameters;

		if(p.isSizeFixed()) {

			Extent e = getExtent(); // FIXME: it should also be taken from parameters instead of from the full layer extent

			double psX = e.width() / (p.getWidth() - 1);

			double psY = -(e.height() / (p.getHeight() - 1));

			ownTransformation = new AffineTransform(

					psX , 

					0, 

					0, 

					psY, 

					e.getULX() - (psX / 2),

					e.getULY() - (psY / 2));

		} else {

			Rectangle2D bbox = p.getExtent();

			double psX = bbox.getWidth() / p.getWidth();

			double psY = -(bbox.getHeight() / p.getHeight());

			ownTransformation = new AffineTransform(

					psX, 

					0, 

					0, 

					psY,

					bbox.getX(),

					(bbox.getY()+bbox.getHeight())); // FIXME: check for other CRSs such as 4326

		}

		externalTransformation = (AffineTransform) ownTransformation.clone();

		return ownTransformation;

	}

	/**

	 * Calcula el extent en coordenadas del mundo real

	 * @return Extent

	 */

	public Extent getExtent() {

		WMSDataParameters p = (WMSDataParameters)parameters;

		Vector<?> layerNames = Utilities.createVector(p.getLayerQuery(), ",");

		String[] ln = new String[layerNames.size()];

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

			ln[i] = (String)layerNames.get(i);

		}

		Rectangle2D r = null;

		try {

			r = getConnector().getLayersExtent(ln, p.getSRSCode());

			if (r == null) {

				String latLonID = "EPSG:4326";

				r = getConnector().getLayersExtent(ln, latLonID);

				if (r == null) {

					r = getConnector().getLayersExtent(ln, "CRS:84");

				}

				IProjection reqProj = CRSFactory.getCRS(p.getSRSCode());

				IProjection latLonProj = CRSFactory.getCRS(latLonID);

				if ((reqProj != null) && (latLonProj != null)) {

					ICoordTrans ct = latLonProj.getCT(reqProj);

					Rectangle2D reprojectedRect = ct.convert(r);

					r = reprojectedRect;

				}

			}

		} catch (RemoteServiceException e) {

		}

		if(r == null)

			return null;

		return new ExtentImpl(r.getMinX(), r.getMaxY(), r.getMaxX(), r.getMinY());

	}

	public Rectangle2D getLayerExtent(String layerName, String srs) throws RemoteServiceException {

		return getConnector().getLayersExtent(new String[]{layerName}, srs);

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		open = false;

	}

	public Transparency getTransparency() {

		if(fileTransparency == null)

			fileTransparency = new DataStoreTransparency(getColorInterpretation());

		return fileTransparency;

	}

	public String translateFileName(String fileName) {

		return fileName;

	}

	public void setView(Extent e) {

		viewRequest = e;

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		WMSDataParameters p = (WMSDataParameters)parameters;

		return p.getWidth();

	}

	public double getHeight() {

		WMSDataParameters p = (WMSDataParameters)parameters;

		return p.getHeight();

	}

	/**

	 * Gets WMS parameters

	 * @return

	 */

	public WMSDataParameters getParameters() {

		return (WMSDataParameters)parameters;

	}

	public Object readCompleteLine(int line, int band)

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	/**

	 * When the remote layer has fixed size this method downloads the file and return its reference. 

	 * File layer has in the long side FIXED_SIZE pixels and the bounding box is complete. This file could be

	 * useful to build an histogram or calculate statistics. This represents a sample of data.

	 * @return

	 * @throws RasterDriverException

	 */

	public File getFileLayer() throws RasterDriverException {

		if(fileLayerPixelSize != null)

			return fileLayerPixelSize;

		WMSDataParameters p = (WMSDataParameters)parameters;

		Extent e = getExtent();

		Rectangle2D bBox = new Rectangle2D.Double(e.getULX(), e.getLRY(), e.width(), e.height());

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		if(!p.isSizeFixed()) {

			int w = 0;

			int h = 0;

			if(e.width() > e.height()) {

				w = FIXED_SIZE;

				h = (int)((e.height() * FIXED_SIZE) / e.width());

			} else {

				h = FIXED_SIZE;

				w = (int)((e.width() * FIXED_SIZE) / e.height());

			}

			wmsStatus.setWidth(w);

			wmsStatus.setHeight(h);

			fileLayerPixelSize = downloadFile(wmsStatus, e.getULX(), e.getULY(), e.getLRX(), e.getLRY(), w, h);

		} else {

			fileLayerPixelSize = downloadFile(wmsStatus, e.getULX(), e.getULY(), e.getLRX(), e.getLRY(), 

					p.getFixedSize().width, p.getFixedSize().height);

		}

		return fileLayerPixelSize;

	}

	/**

	 * Reads a complete block of data and returns an tridimensional array of the right type. This function is useful

	 * to read a file very fast without setting a view. In a WMS service when the size is fixed then it will read the

	 * entire image but when the source hasn't pixel size it will read a sample of data. This set of data will have

	 * the size defined in FIXED_SIZE. 

	 * 

	 * @param pos Posici?n donde se empieza  a leer

	 * @param blockHeight Altura m?xima del bloque leido

	 * @return Object que es un array tridimendional del tipo de datos del raster. (Bandas X Filas X Columnas)

	 * @throws InvalidSetViewException

	 * @throws FileNotOpenException

	 * @throws RasterDriverException

	 */

	public Object readBlock(int pos, int blockHeight, double scale) 

	throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

		File lastFile = getFileLayer();

		BandList bandList = new BandListImpl();

		for (int i = 0; i < 3; i++) {

			try {

				bandList.addBand(new DatasetBandImpl(lastFile.getPath(), pos, Buffer.TYPE_BYTE, 3));

			} catch (BandNotFoundInListException e1) {

			}

		}

		bandList.setDrawableBands(new int[]{0, 1, 2});

		try {

			lastRequestProvider = openLastRequest();

			return lastRequestProvider.readBlock(pos, blockHeight, scale);

		} catch (ProviderNotRegisteredException exc) {

			throw new RasterDriverException("Error building GdalDriver", exc);

		} catch (InitializeException exc) {

			throw new RasterDriverException("Error building GdalDriver", exc);

		}

	}

	public double getLastRequestHeight() throws RasterDriverException {

		if(lastRequestProvider == null) {

			try {

				lastRequestProvider = openLastRequest();

			} catch (ProviderNotRegisteredException e) {

				throw new RasterDriverException("Error building GdalDriver", e);

			} catch (InitializeException e) {

				throw new RasterDriverException("Error building GdalDriver", e);

			}

		}

		return lastRequestProvider.getHeight();

	}

	public double getLastRequestWidth() throws RasterDriverException {

		if(lastRequestProvider == null) {

			try {

				lastRequestProvider = openLastRequest();

			} catch (ProviderNotRegisteredException e) {

				throw new RasterDriverException("Error building GdalDriver", e);

			} catch (InitializeException e) {

				throw new RasterDriverException("Error building GdalDriver", e);

			}

		}

		return lastRequestProvider.getWidth();

	}

	public File getLastRequest() {

		return lastRequest;

	}

	public Buffer getBufferLastRequest() throws ProcessInterruptedException, RasterDriverException {

		try {

			lastRequestProvider = openLastRequest();

			return getDownloadedRaster(lastRequestProvider);

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (QueryException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}

	/**

	 * Opens the last request downloaded

	 * @return

	 * @throws ProviderNotRegisteredException

	 * @throws InitializeException

	 * @throws RasterDriverException

	 */

	private AbstractRasterProvider openLastRequest() throws ProviderNotRegisteredException, InitializeException, RasterDriverException {

		if(lastRequestProvider != null)

			lastRequestProvider.close();

		File lastFile = getFileLayer();

		lastRequestProvider = DefaultProviderServices.loadProvider(new File(lastFile.getPath()));

		setColorTable(lastRequestProvider.getColorTable());

		return lastRequestProvider;

	}

	public Object getData(int x, int y, int band)

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	/**

	 * Gets the georeferencing file name form a raster file

	 * @param file

	 * a raster file

	 * @return

	 * a georeferencing file

	 */

	private String getWorldFile(String file){		

		String worldFile = file;

		int index = file.lastIndexOf(".");

		if (index > 0){			

			worldFile = file.substring(0, index) + getExtensionWorldFile();

		}

		return worldFile;

	}

	/**

	 * Obtiene la extensi?n del fichero de georreferenciaci?n

	 * @return String con la extensi?n del fichero de georreferenciaci?n dependiendo

	 * del valor del formato obtenido del servidor. Por defecto asignaremos un .wld

	 */

	private String getExtensionWorldFile() {

		WMSDataParameters p = (WMSDataParameters)parameters;

		String extWorldFile = ".wld";

		if(p.getFormat().equals("image/tif") || p.getFormat().equals("image/tiff")) {

			extWorldFile = ".tfw";

		}

		return extWorldFile;

	}

	public WMSStatus loadWMSStatus(Rectangle2D bBox) {

		WMSDataParameters p = (WMSDataParameters)parameters;

		WMSStatus wmsStatus = new WMSStatus();

		wmsStatus.setLayerNames(Utilities.createVector(p.getLayerQuery(), ","));

		wmsStatus.setSrs(p.getSRSCode());

		wmsStatus.setFormat(p.getFormat());

		wmsStatus.setInfoFormat(p.getInfoFormat());

		List<RemoteWMSStyle> listStyles = p.getStyles();

		Vector<?> v = listStyles != null ? new Vector<RemoteWMSStyle>(listStyles) : null; 

		wmsStatus.setStyles(v);

		wmsStatus.setDimensions(p.getDimensions());

		wmsStatus.setTransparency(p.isWmsTransparent());

		wmsStatus.setOnlineResource((String) p.getOnlineResource().get("GetMap"));

		if(p.isSizeFixed()) {

			wmsStatus.setExtent(getExtent().toRectangle2D());

		} else

			wmsStatus.setExtent(bBox);

		wmsStatus.setHeight(p.getHeight());

		wmsStatus.setWidth(p.getWidth());

		wmsStatus.setXyAxisOrder(p.isXyAxisOrder());

		IProjection proj = getProjection();

		if(proj != null)

			wmsStatus.setProjected(proj.isProjected());

		return wmsStatus;

	}

	/**

	 * This function downloads the file and creates the georeferencing file

	 * @param wmsStatus

	 * @param ulx

	 * @param uly

	 * @param lrx

	 * @param lry

	 * @param w

	 * @param h

	 * @return

	 * @throws RasterDriverException

	 */

	private File downloadFile(WMSStatus wmsStatus, double ulx, double uly, double lrx, double lry, int w, int h) throws RasterDriverException {

		WMSDataParameters p = (WMSDataParameters)parameters;

		try {

			lastRequest = getConnector().getMap(wmsStatus, ((WMSDataParameters)parameters).getCancellable());

		} catch (RemoteServiceException e) {

			throw new RasterDriverException(e.getMessage(), e);

		}

		if(lastRequest == null)

			return null;

		String nameWorldFile = getWorldFile(lastRequest.getPath());

		try {

			if(p.isSizeFixed()) {

				Extent e = getExtent();

				fileUtil.createWorldFile(nameWorldFile, e, p.getWidth(), p.getHeight());

			} else {

				fileUtil.createWorldFile(nameWorldFile, new ExtentImpl(ulx, uly, lrx, lry), w, h);

			}

		} catch (IOException e) {

			throw new RasterDriverException("Error creating world file", e);

		}

		return lastRequest;

	}

	@Override

	public void loadBuffer(SpiRasterQuery q) 

			throws ProcessInterruptedException, RasterDriverException {

		Extent bbox = q.getRequestBoundingBox();

		lastWidthRequest = q.getBufWidth();

		lastHeightRequest = q.getBufHeight();

		WMSStatus wmsStatus = loadWMSStatus(bbox.toRectangle2D());

		lastRequest = downloadFile(wmsStatus, 

				bbox.getULX(), 

				bbox.getULY(), 

				bbox.getLRX(), 

				bbox.getLRY(), 

				q.getBufWidth(), 

				q.getBufHeight());

		if (lastRequest == null) {

			return;

		}

		Buffer b = null;

		try {

			b = getDownloadedRaster(lastRequest);

		} catch (QueryException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

		q.setBufferResult(b);

	}

	private Buffer getDownloadedRaster(File f) throws ProcessInterruptedException, QueryException, ProviderNotRegisteredException, InitializeException {

		AbstractRasterProvider provider = DefaultProviderServices.loadProvider(new File(f.getPath()));

		setColorTable(provider.getColorTable());

		return getDownloadedRaster(provider);

	}

	private Buffer getDownloadedRaster(AbstractRasterProvider provider) throws ProcessInterruptedException, QueryException, ProviderNotRegisteredException, InitializeException {

		DefaultRasterStore store = new DefaultRasterStore();

		store.setProvider(provider);

		RasterQuery q = RasterLocator.getManager().createQuery();

		q.setAreaOfInterest();

		if(getColorInterpretation() != null)

			q.setDrawableBands(getColorInterpretation().buildRenderBands());

		if(store.getBandCount() > 3)

			q.forceARGBRequest();

		else 

			q.forceRGBRequest();

		Buffer buf = store.query(q);

		store.close();

		return buf;

	}

	/**

	 * Assigns the list of bands RGB and read a window of data

	 * @param rasterBuf

	 * @param bandList

	 * @param lastFile

	 * @param ulx

	 * @param uly

	 * @param lrx

	 * @param lry

	 * @return

	 * @throws RasterDriverException

	 * @throws ProcessInterruptedException

	 */

	/*public Buffer getBuffer(Buffer rasterBuf, BandList bandList, File lastFile, 

			double ulx, double uly, double lrx, double lry) throws RasterDriverException, ProcessInterruptedException {

		try {

			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

			String serverName = bandList.getBand(0).getFileName();

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

				bandList.getBand(i).setFileName(lastFile.getPath());

			}

			AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastFile.getPath()));

			setColorTable(driver.getColorTable());

			DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

			q.setAreaOfInterest(new ExtentImpl(ulx, uly, lrx, lry));

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			Buffer buf = driver.getDataSet(q);

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

				bandList.getBand(i).setFileName(serverName);

			}

			return buf;

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}*/

	/*public void getWindow(Extent ex, int bufWidth, int bufHeight, 

			BandList bandList, TileListener listener, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		Buffer raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], bufWidth, bufHeight, 3, true);

		getWindow(ex, bufWidth, bufHeight, bandList, raster, true, null);

		raster.setDataExtent(ex.toRectangle2D());

		TileCacheManager m = TileCacheLocator.getManager();

		org.gvsig.raster.cache.tile.Tile t = m.createTile(-1, 0, 0);

		t.setData(new Object[]{raster});

		t.setUl(new Point2D.Double(ex.getULX(), ex.getULY()));

		t.setLr(new Point2D.Double(ex.getLRX(), ex.getLRY()));

		t.setDownloaderParams("AffineTransform", getAffineTransform());

		t.setDownloaderParams("Tiling", new Boolean(false));

		try {

			listener.tileReady(t);

		} catch (TileGettingException e) {

			throw new RasterDriverException("Error throwing a tile", e);

		}

		//listener.nextBuffer(raster, null, new ExtentImpl(minX, minY, maxX, maxY), getAffineTransform(), null, false);

		listener.endReading();

	}*/

	/*public Buffer getWindow(Extent ex, BandList bandList, Buffer rasterBuf, TaskStatus status) 

		throws ProcessInterruptedException, RasterDriverException {

		Rectangle2D bBox = ex.toRectangle2D();

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		lastRequest = downloadFile(wmsStatus, ex.getULX(), ex.getULY(), ex.getLRX(), ex.getLRY(), rasterBuf.getWidth(), rasterBuf.getHeight());

		if (lastRequest == null) {

			return rasterBuf;

		}

		try {

			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

			String serverName = bandList.getBand(0).getFileName();

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

				bandList.getBand(i).setFileName(lastRequest.getPath());

			}

			AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

			setColorTable(driver.getColorTable());

			DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

			q.setAreaOfInterest(ex);

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			Buffer buf = driver.getDataSet(q);

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

				bandList.getBand(i).setFileName(serverName);

			}

			driver.close();

			return buf;

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}*/

	/*public Buffer getWindow(double ulx, double uly, double w, double h, 

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		Rectangle2D bBox = new Rectangle2D.Double(ulx, uly, w, h);

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		lastRequest = downloadFile(wmsStatus, ulx, uly, ulx + w, uly - h, rasterBuf.getWidth(), rasterBuf.getHeight());

		if (lastRequest == null) {

			return rasterBuf;

		}

		try {

			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

			String serverName = bandList.getBand(0).getFileName();

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

				bandList.getBand(i).setFileName(lastRequest.getPath());

			}

			AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

			setColorTable(driver.getColorTable());

			DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

			q.setAreaOfInterest(ulx, uly, w, h);

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			q.setAdjustToExtent(adjustToExtent);

			Buffer buf = driver.getDataSet(q);

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

				bandList.getBand(i).setFileName(serverName);

			}

			return buf;

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}*/

	/*public Buffer getWindow(Extent extent, int bufWidth, int bufHeight, 

			BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		Rectangle2D bBox = extent.toRectangle2D();//new Rectangle2D.Double(ulx, lry, Math.abs(lrx - ulx), Math.abs(lry - uly));

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		lastRequest = downloadFile(wmsStatus, extent.getULX(), extent.getULY(), extent.getLRX(), extent.getLRY(), rasterBuf.getWidth(), rasterBuf.getHeight());

		if (lastRequest == null) {

			return rasterBuf;

		}

		try {

			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

			String serverName = bandList.getBand(0).getFileName();

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

				bandList.getBand(i).setFileName(lastRequest.getPath());

			}

			AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

			setColorTable(driver.getColorTable());

			DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

			q.setAreaOfInterest(extent, bufWidth, bufHeight);

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			q.setAdjustToExtent(adjustToExtent);

			Buffer buf = driver.getDataSet(q);

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

				bandList.getBand(i).setFileName(serverName);

			}

			return buf;

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}*/

//	public Buffer getWindow(int x, int y, 

//			BandList bandList, Buffer rasterBuf) throws ProcessInterruptedException, RasterDriverException {

//		int w = rasterBuf.getWidth();

//		int h = rasterBuf.getHeight();

//		Point2D p1 = rasterToWorld(new Point2D.Double(x, y));

//		Point2D p2 = rasterToWorld(new Point2D.Double(x + w, y + h));

//		lastWidthRequest = rasterBuf.getWidth();

//		lastHeightRequest = rasterBuf.getHeight();

//		Rectangle2D bBox = new Rectangle2D.Double(p1.getX(), p1.getY(), Math.abs(p1.getX() - p1.getX()), Math.abs(p1.getY() - p2.getY()));

//		WMSStatus wmsStatus = loadWMSStatus(bBox);

//		

//		lastRequest = downloadFile(wmsStatus, p1.getX(), p1.getY(), p2.getX(), p2.getY(), rasterBuf.getWidth(), rasterBuf.getHeight());

//		

//		if (lastRequest == null) {

//			return rasterBuf;

//		}

//

//		AbstractRasterProvider driver = null;

//		try {

//			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

//			String serverName = bandList.getBand(0).getFileName();

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

//				bandList.getBand(i).setFileName(lastRequest.getPath());

//			}

//			

//			driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

//			Buffer buf = driver.getWindow(0, 0, w, h, bandList, rasterBuf);

//

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

//				bandList.getBand(i).setFileName(serverName);

//			}

//			

//			return buf;

//		} catch (ProviderNotRegisteredException e) {

//			throw new RasterDriverException("Error building GdalDriver", e);

//		} catch (InitializeException e) {

//			throw new RasterDriverException("Error building GdalDriver", e);

//		}

//	}

	/*public Buffer getWindow(int x, int y, int w, int h, 

			BandList bandList, Buffer rasterBuf, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		Point2D p1 = rasterToWorld(new Point2D.Double(x, y));

		Point2D p2 = rasterToWorld(new Point2D.Double(x + w, y + h));

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

		Rectangle2D bBox = new Rectangle2D.Double(p1.getX(), p1.getY(), Math.abs(p1.getX() - p1.getX()), Math.abs(p1.getY() - p2.getY()));

		WMSStatus wmsStatus = loadWMSStatus(bBox);

		lastRequest = downloadFile(wmsStatus, p1.getX(), p1.getY(), p2.getX(), p2.getY(), rasterBuf.getWidth(), rasterBuf.getHeight());

		if (lastRequest == null) {

			return rasterBuf;

		}

		AbstractRasterProvider driver = null;

		try {

			//El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

			String serverName = bandList.getBand(0).getFileName();

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

				bandList.getBand(i).setFileName(lastRequest.getPath());

			}

			driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

			setColorTable(driver.getColorTable());

			DefaultRasterQuery q = (DefaultRasterQuery)RasterLocator.getManager().createQuery();

			q.setAreaOfInterest(0, 0, w, h);

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			Buffer buf = driver.getDataSet(q);

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

				bandList.getBand(i).setFileName(serverName);

			}

			return buf;

		} catch (ProviderNotRegisteredException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		} catch (InitializeException e) {

			throw new RasterDriverException("Error building GdalDriver", e);

		}

	}*/

	public Image getImageLegend() {

		try {

			WMSStatus wmsStatus = loadWMSStatus(getExtent().toRectangle2D());

			wmsStatus.setOnlineResource((String) getParameters().getOnlineResource().get("GetCapabilities"));

			File file = getConnector().getLegendGraphic(wmsStatus, getParameters().getLayerQuery(), null);

			Image img = null;

			if ((file != null) && (file.length() > 0)) {

				img = new ImageIcon(file.getAbsolutePath()).getImage();

			}

			return img;

		} catch (Exception e) {

			logger.info("Problems in GetLegendGraphic", e);

		}

		return null;

	}

	public int getBlockSize() {

		return 0;

	}

	public void setAffineTransform(AffineTransform t){

	}