Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.wmts.io.DefaultWMTSIOLibrary

/* 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.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.wmts.io;

import java.io.IOException;

import java.io.InputStream;

import java.net.InetAddress;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

import java.net.UnknownHostException;

import java.util.List;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.coverage.store.parameter.TileDataParameters;

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

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

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

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

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

import org.gvsig.raster.wmts.ogc.WMTSClient;

import org.gvsig.raster.wmts.ogc.WMTSOGCLocator;

import org.gvsig.raster.wmts.ogc.exception.WMTSException;

/**

 * Explorer for a WMTS server

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

 */

public class WMTSServerExplorer implements DataServerExplorer, DataServerExplorerProvider {

	public static final String           NAME                     = "WMTSRemoteServerExplorer";

	private WMTSClient                   ogcClient                = null;

	private WMTSServerExplorerParameters parameters               = null;

	public WMTSServerExplorer(

			WMTSServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		this.parameters = parameters;

	}

	public String getDataStoreProviderName() {

		return WMTSProvider.NAME;

	}

	public String getDescription() {

		return WMTSProvider.DESCRIPTION;

	}

	public DataStoreParameters getStoreParameters() {

		DataManager manager = DALLocator.getDataManager();

		WMTSDataParameters wmtsParams = null;

		try {

			wmtsParams = (WMTSDataParameters) manager.createStoreParameters(this.getDataStoreProviderName());

			wmtsParams.setURI(parameters.getHost());

			wmtsParams.setOGCClient(getOGCClient());

			if(WMTSProvider.TILED) {

				TileDataParameters tileParams = (TileDataParameters) manager.createStoreParameters("Tile Store");

				tileParams.setDataParameters(wmtsParams);

				return tileParams;

			} 

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		return wmtsParams;

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	public List<?> getDataStoreProviderNames() {

		return null;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.dal.DataServerExplorer#getParameters()

	 */

	public DataServerExplorerParameters getParameters() {

		return parameters;

	}

	public List<?> list() throws DataException {

		return null;

	}

	public List<?> list(int mode) throws DataException {

		return null;

	}

	public void remove(DataStoreParameters parameters) throws DataException {

	}

	public void dispose() {

	}

	public String getProviderName() {

		return null;

	}

	//**********************************************

	//Connector

	//**********************************************

	public void connect(ICancellable cancellable) throws WMTSException {

		URL url = null;

		boolean override = false;

		try {

			url = new URL(parameters.getHost());

		} catch (Exception e) {

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

		}

        try {

        	ogcClient = WMTSOGCLocator.getManager().createWMTSClient(url.toString());

        	ogcClient.setForceLongitudeFirstAxisOrder(parameters.isLongitudeFirst());

        	if (!ogcClient.connect(override, cancellable))

        		throw new WMTSException("Error connecting");

        } catch (IOException e) {

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

		}

	}

	/**

	 * Checks if the network and host are reachable

	 * @param timeout for the host

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable(int timeout) {

		URL url = null;

		URLConnection con = null;

		try {

			url = new URL(parameters.getHost());

			con = url.openConnection();

			if(con == null)

				return false;

			con.connect();

		} catch (MalformedURLException e) {

			return false;

		} catch (IOException e) {

			return false;

		}

		InputStream stream = null;

		try {

			stream = con.getInputStream();

			if(stream == null)

				return false;

		} catch (IOException e) {

		}

		return true;

	}

	/**

	 * Checks if the network and host are reachable

	 * @return true if both are reachable and false if they are not

	 */

	public boolean isHostReachable() {

		int timeout = 10000;

		return isHostReachable(timeout);

	}

	public boolean isConnected() {

		if(ogcClient != null)

			return true;

		return false;

	}

	public WMTSClient getOGCClient() {

		return ogcClient;

	}

	/*public WMTSThemes getThemes() {

		return connector.getThemes();

	}

    public WMTSLayer getLayer(String layerName) {

    	return connector.getLayer(layerName);

    }

	public List<WMTSTileMatrixSet> getTileMatrixSet() {

    	return connector.getTileMatrixSet();

    }

	public WMTSServiceIdentification getServiceIdentification() {

		return connector.getServiceIdentification();

	}

	public WMTSServiceProvider getServiceProvider() {

		return connector.getServiceProvider();

	}*/

	public String getHost() {

		return parameters.getHost();

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.wmts.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.ConnectException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.List;

import javax.swing.ImageIcon;

import org.gvsig.compat.net.ICancellable;

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.DatasetBand;

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.RasterDriverException;

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

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.coverage.util.MathUtils;

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.TileCacheLocator;

import org.gvsig.raster.cache.tile.TileCacheManager;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

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

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

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

import org.gvsig.raster.impl.DefaultRasterManager;

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

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.DefaultRasterProvider;

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

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

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

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

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.wmts.io.downloader.WMTSTileServer;

import org.gvsig.raster.wmts.ogc.WMTSClient;

import org.gvsig.raster.wmts.ogc.WMTSOGCLocator;

import org.gvsig.raster.wmts.ogc.WMTSStatus;

import org.gvsig.raster.wmts.ogc.exception.DownloadException;

import org.gvsig.raster.wmts.ogc.exception.ServerErrorException;

import org.gvsig.raster.wmts.ogc.exception.WMTSException;

import org.gvsig.raster.wmts.ogc.struct.WMTSBoundingBox;

import org.gvsig.raster.wmts.ogc.struct.WMTSLayer;

import org.gvsig.raster.wmts.ogc.struct.WMTSTile;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrix;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrixLimits;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrixSet;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrixSetLink;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Provider for WMTS service

 *

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

 */

public class WMTSProvider extends DefaultRasterProvider implements RemoteRasterProvider, TiledRasterProvider {

	public static String                NAME                     = "Wmts Store";

	public static String                DESCRIPTION              = "Wmts Raster file";

	public static final String          METADATA_DEFINITION_NAME = "WmtsStore";

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

	public static boolean               TILED                    = true;

	//Los tiles se piden de forma secuencial y sin lanzar threads para ello (+Lento)

	public static int                   SEQUENTIAL               = 0;

	//Los tiles se piden en threads y hay un thread manager para gestionar que no se pidan m?s de cierto n?mero

	public static int                   LIMITED_THREADS          = 1;

	//Los tiles se piden en threads y se lanzan tantos threads como tiles haya

	public static int                   UNLIMITED_THREADS        = 2;

	private int                         requestType              = LIMITED_THREADS;

	private static final double         MTS_X_GRADO              = 111319.490793274;

	private Extent                      viewRequest              = null;

	private WMTSClient                  ogcClient                = null;

	//private static Hashtable<URL, WMTSConnector>    

	//                                    drivers                  = new Hashtable<URL, WMTSConnector> ();

	private boolean                     open                     = false;

	private File                        lastRequest              = null;

	private DataStoreTransparency       lastFileTransparency     = null;

	private int                         lastWidthRequest         = 0;

	private int                         lastHeightRequest        = 0;

	private WMTSStatus                  lastStatus               = null;

	private boolean                     gridSubsets              = true;

	private Extent[]                    extentByLevel            = null; //Only for layers without gridSubsets

	private Extent                      bbox                     = null;

	private MathUtils                   math                     = RasterLocator.getManager().getMathUtils();

	/**

	 * This thread manages the number of tiles that have been thrown.

	 * This number is controlled by the NTHREADS_QUEUE variable.

	 * 

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

	 */

	public class RequestThreadManager extends Thread {

		private TilePipe               pipe           = null;

		private List<WMTSTile>         tiles          = null;

		private WMTSStatus             status         = null;

		public RequestThreadManager(TilePipe pipe, List<WMTSTile> tiles, WMTSStatus status) {

			this.pipe = pipe;

			this.tiles = tiles;

			this.status = status;

		}

		public void run() {

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

				WMTSTile tile = tiles.get(i);

				WMTSStatus statusCopy = status.cloneStatus();

				statusCopy.setTileRow(tile.getRow());

				statusCopy.setTileCol(tile.getCol());

				if (pipe.getSize() > TilePipe.NTHREADS_QUEUE) {

					try {

						synchronized (this) {

							wait();							

						}

					} catch( InterruptedException e ) {

					}

				}

				new RequestTileLauncher(pipe, statusCopy, tile).start();

			}

		}

	}

	/**

	 * Thread to download a tile

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

	 */

	class RequestTileLauncher extends Thread {

		private TilePipe      pipe    = null;

		private WMTSStatus    status  = null;

		private WMTSTile      tile    = null;

		public RequestTileLauncher(TilePipe pipe, WMTSStatus status, WMTSTile tile) {

			this.pipe = pipe;

			this.status = status;

			this.tile = tile;

		}

		public void run() {

			try {

				//File file = getConnector().getTile(status, null);

				URL url = getOGCClient().getTileURL(status);

				tile.setFile(getOGCClient().downloadFile(url, null));

				pipe.setTile(tile);

			} catch (DownloadException e) {

				logger.info("Error downloading files", e);

			} catch (MalformedURLException e) {

				logger.info("Malformed URL", e);

			} catch (WMTSException e) {

				logger.info("", e);

			}

		}

	}

	/**

	 * Point information 

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

	 */

	public class PointInfo {

		public Point2D worldCoord;

		public Point2D tile;

		public Point2D pixelInTile;

		public int     level;

		public PointInfo(Point2D worldCoord) {

			this.worldCoord = worldCoord;

		}

	}

	public static void register() {

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

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

			dataman.registerStoreProvider(NAME,

					WMTSProvider.class, WMTSDataParametersImpl.class);

		}

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

			dataman.registerExplorerProvider(WMTSServerExplorer.NAME, WMTSServerExplorer.class, WMTSServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	public WMTSProvider() throws NotSupportedExtensionException {

		super();

	}

	/**

	 * Constructor. Abre el dataset.

	 * @param proj Proyecci?n

	 * @param fName Nombre del fichero

	 * @throws NotSupportedExtensionException

	 */

	public WMTSProvider(String params) throws NotSupportedExtensionException {

		super(params);

		if(params instanceof String) {

			WMTSDataParameters p = new WMTSDataParametersImpl();

			p.setURI((String)params);

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

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

	public WMTSProvider(WMTSDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

		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 WMTSClient getOGCClient() throws WMTSException {

		if(ogcClient == null) {

			WMTSDataParameters p = (WMTSDataParameters)parameters;

			ogcClient = p.getOGCClient();

			if(ogcClient != null)

				return ogcClient;

			URL url = null;

			try {

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

			} catch (Exception e) {

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

			}

			try {

				ogcClient = WMTSOGCLocator.getManager().createWMTSClient(url.toString());

				ogcClient.connect(true, new ICancellable() {

					public boolean isCanceled() {

						return false;

					}

					public Object getID() {

						return null;

					}

				});

			} catch (ConnectException e) {

				throw new WMTSException("Connect exception",e);

			} catch (IOException e) {

				throw new WMTSException("Connect exception",e);

			}

		}

		return ogcClient;

	}

	/**

	 * 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 NotSupportedExtensionException {

		setParam(storeServices, params);

		if(((WMTSDataParameters)params).getImageFormat().compareTo("image/gif") == 0) {

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

			bandCount = 1;

		} else {

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

			bandCount = 4;

		}

		if(!(param instanceof WMTSDataParameters))

			return;

		gridSubsets = hasGridSubsets((WMTSDataParameters)param);

		open = true;

	}

	/**

	 * Returns true if this layer has grid subsets

	 * @return

	 */

	public boolean hasGridSubsets() {

		return gridSubsets;

	}

	/**

	 * Checks if this layer has grid subsets or doesn't

	 * @param p

	 * @return

	 */

	private boolean hasGridSubsets(WMTSDataParameters p) {

		List<WMTSTileMatrixLimits> tileMatrixSetLimits = null;

		List<WMTSTileMatrixSetLink> tileMatrixSetLinkList = p.getLayer().getTileMatrixSetLink();

		String srs = p.getSRSCode();

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

			WMTSTileMatrixSetLink tileMatrixSetLink = (WMTSTileMatrixSetLink)tileMatrixSetLinkList.get(i);

			WMTSTileMatrixSet tms = tileMatrixSetLink.getTileMatrixSet();

			List<WMTSTileMatrixLimits> tmsl = tileMatrixSetLink.getTileMatrixLimits();

			String srsTileSet = tms.getSupportedCRS();

			if(srsTileSet.compareTo(srs) == 0) {

				tileMatrixSetLimits = tmsl;

			}

		}

		return tileMatrixSetLimits.size() <= 0 ? false : true; 

	}

	/*public static final WMTSConnector getConnectorFromURL(URL url) throws IOException {

		WMTSConnector drv = (WMTSConnector) drivers.get(url);

		if (drv == null) {

			drv = new WMTSConnector(url);

			drivers.put(url, 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();

			colorInterpretation.initColorInterpretation(getBandCount());

			if(getBandCount() >= 3) {

				colorInterpretation.setColorInterpValue(0, DataStoreColorInterpretation.RED_BAND);

				colorInterpretation.setColorInterpValue(1, DataStoreColorInterpretation.GREEN_BAND);

				colorInterpretation.setColorInterpValue(2, DataStoreColorInterpretation.BLUE_BAND);

			}

			if(getBandCount() == 4)

				colorInterpretation.setColorInterpValue(3, DataStoreColorInterpretation.ALPHA_BAND);

			if(getBandCount() > 4 || getBandCount() < 3) {

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

					colorInterpretation.setColorInterpValue(i, DataStoreColorInterpretation.UNDEF_BAND);

				}

			}

			setColorInterpretation(colorInterpretation);

		}

		return super.getColorInterpretation();

	}

	public boolean isTiled() {

		return true;

	}

	public AffineTransform getAffineTransform() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

		Extent e = getExtent();

		double psX = e.width() / (lastWidthRequest <= 0 ? p.getWidth() : lastWidthRequest);

		double psY = -(e.height() / (lastHeightRequest <= 0 ? p.getHeight() : lastHeightRequest));

		ownTransformation = new AffineTransform(

				psX, 

				0, 

				0, 

				psY, 

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

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

		externalTransformation = (AffineTransform) ownTransformation.clone();

		return ownTransformation;

	}

	/**

	 * Gets the bounding box in world coordinates. If the layer has grid subsets (TileMatrixLimits) then

	 * this will have a only extent but if the layer doesn't have grid subsets then this will have a different

	 * extent in each level resolution. In this case we need to know the extent for each level.

	 * @return Extent

	 */

	public Extent getExtent() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

		if(gridSubsets) {

			WMTSLayer layer = p.getLayer();

			WMTSBoundingBox bbox = layer.getWGS84BBox();

			return new ExtentImpl(bbox.toRectangle2D());

		} else {

			/*WMTSTileMatrixSet tileMatrixSet = getTileMatrixSetLink().getTileMatrixSet();

			//Si ya se han calculado los niveles es q el extent es v?lido sino el nivel ser? el 0

			double scale = 0D;

			int level = 0;

			if(extentByLevel != null && p.getExtent() != null) {

				scale = getScale(p.getExtent(), p.getWidth());

				try {

					level = getLevelFromScale(scale, tileMatrixSet);

				} catch (RasterDriverException e) {

					e.printStackTrace();

				}				

			}

			Extent[] ext = getExtentByResolutionLevel();

			if(ext != null && level >= 0 && level < ext.length)

				return ext[level];*/

			if(bbox == null)

				getExtentByResolutionLevel();

			return bbox;

		}

	}

	/**

	 * Gets the suffix of the downloaded image

	 * @return

	 */

	public String getFileSuffix() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

		String format = p.getImageFormat();

		if (format == null){

			return "xml";

		}

		if (format.indexOf("png") >= 0){

	        return "png";

		}	

	    if (format.indexOf("xml") >= 0){

	        return "xml";

	    }	

	    if (format.indexOf("gif") >= 0){

	        return "gif";

	    }

	    if (format.indexOf("tif") >= 0){

	        return "tif";

	    }

	    if (format.indexOf("bmp") >= 0){

	        return "bmp";

	    }

	    if (format.indexOf("jpg") >= 0

	        || format.indexOf("jpeg") >= 0){

	        return "jpg";			 

	    }

		return "xml";

	}

	/**

	 * When a layer doesn't have grid subsets this will have a different bounding

	 * box by resolution level. This function calculates and returns the array of

	 * extents, one by resolution level.

	 * @return

	 */

	public Extent[] getExtentByResolutionLevel() {

		if(extentByLevel == null) {

			WMTSDataParameters p = (WMTSDataParameters)parameters;

			WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

			WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

	    	double widthMtsTile = 0;

	    	double heightMtsTile = 0;

			List<WMTSTileMatrix> tileMatrixList = tileMatrixSet.getTileMatrix();

			extentByLevel = new ExtentImpl[tileMatrixList.size()];

			double minX = 0;

			double minY = 0;

			double maxX = 0;

			double maxY = 0;

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

				WMTSTileMatrix tileMatrix = (WMTSTileMatrix)tileMatrixList.get(i);

		    	if(!p.isProjected()) {

		    		widthMtsTile = (tileMatrix.getScaleDenominator() * tileMatrix.getTileWidth() * 0.28) / (MTS_X_GRADO * 1000);

		    		heightMtsTile = (tileMatrix.getScaleDenominator() * tileMatrix.getTileWidth() * 0.28) / (MTS_X_GRADO * 1000);

		    	} else {

		    		widthMtsTile = (tileMatrix.getScaleDenominator() * tileMatrix.getTileWidth() * 0.28) / 1000;

		    		heightMtsTile = (tileMatrix.getScaleDenominator() * tileMatrix.getTileWidth() * 0.28) / 1000;

		    	}

		    	double h = Math.abs(tileMatrix.getTopLeftCorner()[0] - (tileMatrix.getTopLeftCorner()[0] - (tileMatrix.getMatrixHeight() * heightMtsTile)));

		    	Rectangle2D r = new Rectangle2D.Double(

		    			tileMatrix.getTopLeftCorner()[1], 

		    			tileMatrix.getTopLeftCorner()[0] - h,

		    			Math.abs(tileMatrix.getTopLeftCorner()[1] - (tileMatrix.getTopLeftCorner()[1] + (tileMatrix.getMatrixWidth() * widthMtsTile))),

		    			h);

		    	extentByLevel[i] = new ExtentImpl(r);

		    	if(i == 0) {

		    		minX = extentByLevel[i].getMin().getX();

		    		minY = extentByLevel[i].getMin().getY();

		    		maxX = extentByLevel[i].getMax().getX();

		    		maxY = extentByLevel[i].getMax().getY();

		    	} else {

		    		minX = Math.min(minX, extentByLevel[i].getMin().getX());

		    		minY = Math.min(minY, extentByLevel[i].getMin().getY());

		    		maxX = Math.max(maxX, extentByLevel[i].getMax().getX());

		    		maxY = Math.max(maxY, extentByLevel[i].getMax().getY());

		    	}

			}

			bbox = new ExtentImpl(minX, maxY, maxX, minY);

		}

		return extentByLevel;

	}

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

		return null;

	}

	public RasterProvider load() {

		return this;

	}

	public boolean isOpen() {

		return open;

	}

	public void close() {

		open = false;

	}

	public Transparency getTransparency() {

		if(lastFileTransparency == null) {

			lastFileTransparency = new DataStoreTransparency();

			lastFileTransparency.setTransparencyBand(3);

		}

		return lastFileTransparency;

	}

	public String translateFileName(String fileName) {

		return fileName;

	}

	public void setView(Extent e) {

		viewRequest = e;

	}

	public Extent getView() {

		return viewRequest;

	}

	public double getWidth() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

		if (lastWidthRequest <= 0) 

			return p.getWidth();

		return lastWidthRequest;

	}

	public double getHeight() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

		if (lastHeightRequest <= 0) 

			return p.getHeight();

		return lastHeightRequest;

	}

	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 {

		return null;

	}

	/**

	 * 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 WMTS 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 {

		return null;

	}

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

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	/**

	 * 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 {

		return null;

	}

	/**

	 * Gets the tile matrix from the selected level

	 * @param level

	 * @return

	 */

	private WMTSTileMatrix getTileMatrixByLevel(int level) {

		level = adjustLevel(level);

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		List<WMTSTileMatrixLimits> tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

		WMTSTileMatrixLimits tileMatrixLimits = null;

		WMTSTileMatrix tileMatrix = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level);

		if(hasGridSubsets()) {

			tileMatrixLimits = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level);

			tileMatrix = tileMatrixLimits.getTileMatrix();

		}

		return tileMatrix;

	}

	/**

	 * Returns the number of levels

	 * @return

	 */

	public int getZoomLevels() {

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		if(hasGridSubsets()) {

			List<WMTSTileMatrixLimits> tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

			return Math.min(tileMatrixSet.getTileMatrix().size(), tileMatrixSetLimits.size());

		}

		return tileMatrixSet.getTileMatrix().size();

	}

	public Extent getCoordsInTheNearestLevel(Extent extent, int w, int h) {

		double[] pixelSizes = getPixelSizeByLevel();

		double currentPixelSize = extent.width() / (double)w;

		int level = 0;

		for (int i = 0; i < (pixelSizes.length - 1); i++) {

			if(currentPixelSize < pixelSizes[i] && currentPixelSize >= pixelSizes[i + 1]) {

				level = i + 1;

				break;

			}

		}

		return getZoomLevelCoordinates(level, extent, w, h);

	}

	public Extent getCoordsInLevel(Point2D viewCenter, int level, int w, int h) {

		WMTSDataParameters p = (WMTSDataParameters)param;

		level = adjustLevel(level);

		WMTSTileMatrix tileMatrix = getTileMatrixByLevel(level);

		boolean proj = p.isProjected();

		double psX = tileMatrix.getWidthWCTile(proj) / tileMatrix.getTileWidth();

		double psY = tileMatrix.getHeightWCTile(proj) / tileMatrix.getTileHeight();

		double ulx = viewCenter.getX() - ((w / 2) * psX);

		double uly = viewCenter.getY() - ((h / 2) * psY);

		double lrx = ulx + (w * psX);

		double lry = uly + (h * psY);

		return new ExtentImpl(ulx, uly, lrx, lry);

	}

	/**

	 * Calculates the extent of a zoom level using other extent as a reference. The new extent is 

	 * calculated with the same coordinate at the center. 

	 * @param level

	 * @param extent

	 * @param w

	 * @param h

	 * @return

	 */

	public Extent getZoomLevelCoordinates(int level, Extent extent, int w, int h) {

		double centerX = extent.getCenterX();

		double centerY = extent.getCenterY();

		return getCoordsInLevel(new Point2D.Double(centerX, centerY), level, w, h);

	}

	/**

	 * Returns a list of pixel sizes by level

	 * @return

	 */

	public double[] getPixelSizeByLevel() {

		WMTSDataParameters p = (WMTSDataParameters)param;

		double[] list = new double[getZoomLevels()];

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

			WMTSTileMatrix tileMatrix = getTileMatrixByLevel(i);

			list[i] = math.adjustDouble(tileMatrix.getWidthWCTile(p.isProjected()) / tileMatrix.getTileWidth());

		}

		return list;

	}

	/**

	 * Adjust de level to the range

	 * @param level

	 * @return

	 */

	private int adjustLevel(int level) {

		if(level < 0)

			level = 0;

		if(level > getZoomLevels())

			level = getZoomLevels();

		return level;

	}

	public org.gvsig.raster.cache.tile.Tile getTile(DefaultRasterQuery q) throws TileGettingException {

		//q.getResolutionLevel(), q.getTileCol(), q.getTileRow(), q.getBBox(), q.getCacheStruct()!

		CacheStruct str = getTileServer().getStruct();

		//1-Selecci?n de WMTSTileMatrixSet por srs

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		List<WMTSTileMatrixLimits> tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

		WMTSTileMatrix tileMatrix = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(q.getResolutionLevel());

		if(gridSubsets) {

			WMTSTileMatrixLimits tileMatrixLimits = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(q.getResolutionLevel());

			tileMatrix = tileMatrixLimits.getTileMatrix();

		}

		int bufWidth = tileMatrix.getTileWidth();

		int bufHeight = tileMatrix.getTileHeight();

		try {

			Rectangle2D r = q.getBBox().toRectangle2D();//new Rectangle2D.Double(Math.min(minX, maxX), Math.min(minY, maxY), Math.abs(maxX - minX), Math.abs(maxY - minY));

			WMTSStatus status = buildWMTSStatus(r, bufWidth , bufHeight);

			int[] size = str.getTileSizeByLevel(q.getResolutionLevel());

			WMTSTile tile = WMTSOGCLocator.getManager().createTile(

					size, 

					new int[]{q.getTileRow(), q.getTileCol()}, 

					new double[]{q.getBBox().getULX(), q.getBBox().getULY(), q.getBBox().getLRX(), q.getBBox().getLRY()});

			File file = getOGCClient().getTile(status, null);

			tile.setFile(file);

			//Creamos un BandList con todas las bandas del fichero

			BandList bandList = new BandListImpl();

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

				try {

					DatasetBand band = new DatasetBandImpl(getURIOfFirstProvider(), i, getDataType()[i], getBandCount());

					bandList.addBand(band);

				} catch(BandNotFoundInListException e) {

					//No a?adimos la banda

				}

			}

			return drawTile(tile, null, bandList);

		} catch (WMTSException e) {

			throw new TileGettingException("Error getting tiles", e);

		} catch (ServerErrorException e) {

			throw new TileGettingException("Error getting tiles", e);

		} catch (RasterDriverException e) {

			throw new TileGettingException("Error getting tiles", e);

		}

	}

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

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

		Rectangle2D r = ex.toRectangle2D();//new Rectangle2D.Double(Math.min(minX, maxX), Math.min(minY, maxY), Math.abs(maxX - minX), Math.abs(maxY - minY));

		WMTSStatus status = buildWMTSStatus(r, bufWidth, bufHeight);

		request(status, bandList, listener, requestType);

	}

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

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

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

		WMTSStatus status = buildWMTSStatus(r, bufWidth, bufHeight);

		org.gvsig.raster.cache.tile.Tile[] tileList = request(status, bandList, null, requestType);

		MemoryMatrixBuffer matrixBuffer = new MemoryMatrixBuffer(tileList);

		return matrixBuffer.getWindow(extent, rasterBuf);

	}

	public Buffer getWindow(Extent extent, BandList bandList, Buffer rasterBuf, TaskStatus taskStatus) 

		throws ProcessInterruptedException, RasterDriverException {

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

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

		WMTSStatus status = buildWMTSStatus(r, lastWidthRequest, lastHeightRequest);

		org.gvsig.raster.cache.tile.Tile[] tileList = request(status, bandList, null, requestType);

		MemoryMatrixBuffer matrixBuffer = new MemoryMatrixBuffer(tileList);

		return matrixBuffer.getWindow(extent, rasterBuf);

	}

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

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

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

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

		WMTSStatus status = buildWMTSStatus(r, lastWidthRequest, lastHeightRequest);

		org.gvsig.raster.cache.tile.Tile[] tileList = request(status, bandList, null, requestType);

		MemoryMatrixBuffer matrixBuffer = new MemoryMatrixBuffer(tileList);

		return matrixBuffer.getWindow(new ExtentImpl(ulx, uly, ulx + w, uly - h), rasterBuf);

	}

	public Buffer getWindow(int x, int y, int w, int h, BandList bandList, Buffer rasterBuf, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

		lastWidthRequest = rasterBuf.getWidth();

		lastHeightRequest = rasterBuf.getHeight();

		return null;

	}

	/**

	 * Gets the information from a point 

	 * @param wcx

	 * @param wcy

	 * @param level

	 * @return

	 * @throws RasterDriverException

	 */

	public String getFeatureInfo(double wcx, double wcy, int level) throws RasterDriverException {

		PointInfo pointInfo = new PointInfo(new Point2D.Double(wcx, wcy));

		pointInfo.level = level;

		getTileInfo(pointInfo);

		WMTSClient ogcClient = null;

		try {

			ogcClient = getOGCClient();

			lastStatus.setTileRow((int)pointInfo.tile.getX());

			lastStatus.setTileCol((int)pointInfo.tile.getY());

			String fi = ogcClient.getFeatureInfo(lastStatus, (int)pointInfo.pixelInTile.getX(), (int)pointInfo.pixelInTile.getY(), null);

			return fi;

		} catch (WMTSException e) {

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

		} /*catch (ServerErrorException e) {

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

		}*/

	}

	/**

	 * Gets a tile position from a world coordinates point and a resolution level

	 * @param point

	 * @param level

	 * @return An array with two elements. The first is the row and the second the column

	 * of the tile in the tile matrix

	 */

	private void getTileInfo(PointInfo pointInfo) {

		WMTSDataParameters p = (WMTSDataParameters)param;

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		List<WMTSTileMatrixLimits> tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

		WMTSTileMatrixLimits tileMatrixLimits = null;

		WMTSTileMatrix tileMatrix = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(pointInfo.level);

		if(hasGridSubsets()) {

			tileMatrixLimits = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(pointInfo.level);

			tileMatrix = tileMatrixLimits.getTileMatrix();

		}

		List<WMTSTile> tiles = null;

		if(hasGridSubsets())

			tiles = tileMatrix.contains(p.isProjected(), tileMatrixLimits, pointInfo.worldCoord, getExtent().toRectangle2D());

		else

			tiles = tileMatrix.contains(p.isProjected(), pointInfo.worldCoord, getExtent().toRectangle2D());

		//Tile row and column

		pointInfo.tile = new Point2D.Double(tiles.get(0).getRow(), tiles.get(0).getCol());

		//Desplazamiento en pixels dentro del tile

		Point2D rasterPoint = tiles.get(0).worldToRaster(pointInfo.worldCoord);

		pointInfo.pixelInTile = new Point2D.Double(rasterPoint.getX(), rasterPoint.getY());

	}

	/**

	 * Builds the WMTSStatus object using the parameters and the request bounding box. 

	 * @param r

	 * @param bufWidth

	 * @return

	 * @throws RasterDriverException

	 */

	public WMTSStatus buildWMTSStatus(Rectangle2D r, int bufWidth, int bufHeight) throws RasterDriverException {

		WMTSDataParameters p = (WMTSDataParameters)param;

		//Mantiene actualizados los par?metros del WMTSStoreParameters con la ?ltima petici?n hecha

		p.setExtent(r);

		p.setWidth(bufWidth);

		p.setHeight(bufHeight);

		lastWidthRequest = bufWidth;

		lastHeightRequest = bufHeight;

		//1-Selecci?n de WMTSTileMatrixSet por srs

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		List<WMTSTileMatrixLimits> tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

		int initialLevel = p.getLayer().getInitialLevel(tileMatrixSet.getIdentifier());

		//Esto hace lo mismo que getScale y getLevelFromScale

		/*int level = 0;

		double[] pixelSizes = getPixelSizeByLevel();

		double psViewPort = math.adjustDouble(r.getWidth() / (double)bufWidth);

		for (int i = 0; i < pixelSizes.length - 1; i++) {

			if(psViewPort <= pixelSizes[i] && psViewPort > pixelSizes[i + 1]) {

				level = i;

				break;

			}

		}*/

		//2-Calculo de la escala

		double scale = getScale(r, bufWidth);

		//3-Selecci?n del nivel a partir de la escala

		int level = getLevelFromScale(scale, tileMatrixSet);

		//Para evitar que se salga del array si la capa tiene menos niveles que el tilematrixset

		int dif = 0;

		if(gridSubsets)

			dif = (level - initialLevel) >= tileMatrixSetLimits.size() ?  (level - initialLevel) - tileMatrixSetLimits.size() + 1 : 0;

		//4-Obtenemos la matriz de tiles y los l?mites si tiene subsets

		@SuppressWarnings("unused")

		WMTSTileMatrixLimits tileMatrixLimits = null;

		WMTSTileMatrix tileMatrix = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level - dif);

		if(gridSubsets)

			tileMatrixLimits = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level - initialLevel - dif);

		//5-Selecci?n de tiles que entran en esta bounding box

		List<WMTSTile> tiles = null;

		/*if(gridSubsets)

			tiles = tileMatrix.intersects(p.isProjected(), tileMatrixLimits, r, getExtent().toRectangle2D());

		else*/

		Extent[] extList = getExtentByResolutionLevel();

		tiles = tileMatrix.intersects(p.isProjected(), r, extList[level].toRectangle2D());

		//6-Petici?n

		WMTSStatus status = null;

		try {

			status = getOGCClient().createStatus();

		} catch (WMTSException e) {

			throw new RasterDriverException("Error creating WMTSStatus", e);

		}

		status.setTileList(tiles);

		status.setLayer(p.getLayer().getIdentifier());//.substring(p.getLayer().getIdentifier().indexOf("_") + 1));

		status.setFormat(p.getImageFormat());

		status.setInfoFormat(p.getInfoFormat());

		status.setStyle(p.getStyle() != null ? p.getStyle().getIdentifier() : "");

		status.setTileMatrixSet(tileMatrixSet.getIdentifier());

		status.setTileMatrix(tileMatrix.getIdentifier());

		status.setLevel(level - dif);

		this.lastStatus = status;

		return status;

	}

	/**

	 * Gets the resolution level from the real coordinates

	 * @param r

	 * @param 

	 * @return

	 * @throws RasterDriverException

	 */

	public int getLevelFromRealCoords(Rectangle2D r, int width) throws RasterDriverException {

		double scale = getScale(r, width);

		WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		return getLevelFromScale(scale, tileMatrixSet);

	}

	/**

	 * Gets the resolution level from the scale

	 * @param scale

	 * @param tileMatrixSet

	 * @return

	 * @throws RasterDriverException

	 */

	public int getLevelFromScale(double scale, WMTSTileMatrixSet tileMatrixSet) throws RasterDriverException {

		//Recorremos los tileMatrix para obtener la escala m?s aproximada

		int levelModifier = 0;

		scale = math.adjustDouble(scale);

		try {

			for (int resolutionLevel = 0; resolutionLevel < tileMatrixSet.getTileMatrix().size(); resolutionLevel++) {

				WMTSTileMatrix tm = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(resolutionLevel);

				double scaleDenominator = math.adjustDouble(tm.getScaleDenominator());

				if(scale >= scaleDenominator) {

					return Math.max(resolutionLevel + levelModifier, 0);

				}

			}

		} catch (IndexOutOfBoundsException e) {

			throw new RasterDriverException("Error in this resolution level", e);

		}

		return 0;

	}

	/**

	 * Get the tile matrix set using the crs

	 * @param srs

	 * @return

	 */

	public WMTSTileMatrixSetLink getTileMatrixSetLink() {

		WMTSDataParameters p = (WMTSDataParameters)param;

		List<WMTSTileMatrixSetLink> tileMatrixSetLinkList = p.getLayer().getTileMatrixSetLink();

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

			WMTSTileMatrixSetLink tileMatrixSetLink = (WMTSTileMatrixSetLink)tileMatrixSetLinkList.get(i);

			String srsTileSet = tileMatrixSetLink.getTileMatrixSet().getSupportedCRS();

			if(srsTileSet.compareTo(p.getSRSCode()) == 0) {

				return tileMatrixSetLink;

			}

		}

		if(tileMatrixSetLinkList != null && tileMatrixSetLinkList.size() > 0)

			return (WMTSTileMatrixSetLink)tileMatrixSetLinkList.get(0);

		return null;

	}

	/**

	 * Gets the scale using the extent and the width in pixels.

	 * @param r

	 * @param width

	 * @return

	 */

	private double getScale(Rectangle2D r, int width) {

		WMTSDataParameters p = (WMTSDataParameters)param;

		if(!p.isProjected()) {

			return (r.getWidth() * MTS_X_GRADO) / (width * 0.00028);

		} else

			return (r.getWidth()) / (width * 0.00028);

	}

	/**

	 * Throw a request

	 * @param status

	 * @param bandList

	 * @param listener

	 * @param alphaBandNumber 

	 * @return returns a buffer if the listener is null. In any other case it return null.

	 * @throws RasterDriverException 

	 * @throws ProcessInterruptedException 

	 */

	private synchronized org.gvsig.raster.cache.tile.Tile[] request(

			WMTSStatus status, BandList bandList, TileListener listener, int requestType) throws RasterDriverException, ProcessInterruptedException {

		//WMTSDataParameters p = (WMTSDataParameters)param;

		WMTSClient ogcClient = null;

		try {

			ogcClient = getOGCClient();

		} catch (WMTSException e) {

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

		}

		if(ogcClient == null)

			throw new RasterDriverException("Error getting the connector object");

		List<WMTSTile> tiles = status.getTileList();

		TilePipe pipe = new TilePipe();

		//TilePipe2 pipe = new TilePipe2();

		//TileThreadPool pool = null;

		//Caso 1: Lanza un thread que gestiona que no se lancen muchos threads a la vez

		if(requestType == LIMITED_THREADS) {

			RequestThreadManager threadManager = new RequestThreadManager(pipe, tiles, status);

			pipe.setRequestManager(threadManager);

			threadManager.start();

		//Caso 2: Lanza todos los threads

		} else if(requestType == UNLIMITED_THREADS) {

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

				WMTSTile tile = tiles.get(i);

				WMTSStatus statusCopy = status.cloneStatus();

				statusCopy.setTileRow(tile.getRow());

				statusCopy.setTileCol(tile.getCol());

				new RequestTileLauncher(pipe, statusCopy, tile).start();

			}

		}

		org.gvsig.raster.cache.tile.Tile[] tileList = new org.gvsig.raster.cache.tile.Tile[tiles.size()]; 

		if(requestType == LIMITED_THREADS || requestType == UNLIMITED_THREADS) {

			int nCollected = 0;

			while (nCollected < tiles.size()) {

				WMTSTile tile = pipe.getTile();

				tileList[nCollected] = drawTile(tile, listener, bandList);

				nCollected ++;

			}

		}

		if(requestType == SEQUENTIAL) {

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

				WMTSTile tile = tiles.get(i);

				status.setTileRow(tile.getRow());

				status.setTileCol(tile.getCol());

				//TODO:Cancelaci?n

				try {

					File file = ogcClient.getTile(status, null);

					tile.setFile(file);

					tileList[i] = drawTile(tile, listener, bandList);

				} catch (WMTSException e) {

					throw new RasterDriverException("Error getting tiles", e);

				} catch (ServerErrorException e) {

					throw new RasterDriverException("Error getting tiles", e);

				}

			}

		}

		if(listener != null) 

			listener.endReading();

		return tileList;

	}

	/**

	 * Reads a tile with gdal and calls the method nextBuffer

	 * @param tile

	 * @param listener

	 * @param bandList

	 * @return

	 * @throws RasterDriverException

	 */

	private synchronized org.gvsig.raster.cache.tile.Tile drawTile(WMTSTile tile, TileListener listener, BandList bandList) throws RasterDriverException {

		WMTSDataParameters p = (WMTSDataParameters)param;

		try {

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

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

				bandList.getBand(j).setFileName(tile.getFile().getPath());

			}

			DefaultRasterProvider driver = DefaultProviderServices.loadProvider(tile.getFile());

			colorTable = driver.getColorTable();

			bandCount = driver.getBandCount();

			lastFileTransparency = (DataStoreTransparency)driver.getTransparency();

			Buffer rasterBuf = DefaultRasterManager.getInstance().createBuffer(

					getDataType()[0], 

					tile.getWidthPx(), 

					tile.getHeightPx(), 

					3, 

					true);

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

			q.setAreaOfInterest(0, 0, tile.getWidthPx(), tile.getHeightPx());

			q.setBandList(bandList);

			q.setBuffer(rasterBuf);

			Buffer buf = driver.getDataSet(q);

			buf.setDataExtent(new Rectangle2D.Double(

					Math.min(tile.getULX(), tile.getLRX()), 

					Math.min(tile.getULY(), tile.getLRY()), 

					Math.abs(tile.getULX() - tile.getLRX()), 

					Math.abs(tile.getULY() - tile.getLRY())));

			Buffer alphaBand = null;

			if(p.getAlphaBand() != -1 && listener != null && p.getAlphaBand() < bandCount) {

				alphaBand = DefaultRasterManager.getInstance().createBuffer(

						getDataType()[0], 

						tile.getWidthPx(), 

						tile.getHeightPx(), 

						1, 

						true);

				int[] oldDB = bandList.getDrawableBands();

				bandList.setDrawableBands(new int[]{p.getAlphaBand()});

				q.setBandList(bandList);

				q.setBuffer(alphaBand);

				alphaBand = driver.getDataSet(q);

				bandList.setDrawableBands(oldDB);

			}

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

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

			}

			driver.close();

			TileCacheManager m = TileCacheLocator.getManager();

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

			t.setData(new Object[]{buf, alphaBand});

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

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

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

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

			if(listener != null) 

				listener.tileReady(t);

			else 

				return t;

		} catch (ProcessInterruptedException e) {

		} catch (TileGettingException e) {

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

		} catch (ProviderNotRegisteredException e) {

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

		} catch (InitializeException e) {

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