Application: gvSIG desktop » gvSIG raster

import java.io.IOException;

import java.net.ConnectException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.List;

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

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

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.raster.wmts.ogc.struct.WMTSTileMatrixSet;

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

import org.gvsig.tools.ToolsLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

	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

	//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;

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

	private boolean                     open                     = false;

	private File                        lastRequest              = null;

	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);

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

					try {

						synchronized (this) {

						}

					} catch( InterruptedException e ) {

					}

			}

		}

	}

	/**

	 * Thread to download a tile

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

			}

		}

	}

	/**

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

	 */

	public class PointInfo {

		public Point2D tile;

		public Point2D pixelInTile;

		public int     level;

		public PointInfo(Point2D worldCoord) {

			this.worldCoord = worldCoord;

		}

		}

		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

	 */

		super(params);

		if(params instanceof String) {

			WMTSDataParameters p = new WMTSDataParametersImpl();

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

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

			init(p, null);

		}

	}

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Gets the connector from the URL

	 * @return

			ogcClient = p.getOGCClient();

			if(ogcClient != null)

				return ogcClient;

			URL url = null;

			try {

			} 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;

					}

			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

				tileMatrixSetLimits = tmsl;

			}

		}

	}

	private boolean areSrsEquals(String sourceSrs, String appSrs) {

		if(sourceSrs.compareTo(appSrs) == 0)

			return true;

			if(appSrs.equals("EPSG:4326"))

				return true;

		}

		return false;

	}

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

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

		if (drv == null) {

		}

		return drv;

	}*/

	/**

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

	 * color por banda

	public ColorInterpretation getColorInterpretation() {

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

			ColorInterpretation colorInterpretation = new DataStoreColorInterpretation(getBandCount());

				colorInterpretation = DataStoreColorInterpretation.createGrayInterpretation();

				colorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

			if(getBandCount() == 4)

				colorInterpretation = DataStoreColorInterpretation.createRGBAInterpretation();

			if(getBandCount() > 4 || getBandCount() == 2) {

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

					colorInterpretation.setColorInterpValue(i, DataStoreColorInterpretation.UNDEF_BAND);

		}

		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(

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

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

		externalTransformation = (AffineTransform) ownTransformation.clone();

		return ownTransformation;

	}

	/**

	 * <p>

	 * extension of this layer, else we'll see if the tag WGS84BoundingBox is defined (it can be approximated).

	 * In this case we'll take WGS84BoundingBox as entire extension.

	 * </p>

	 * <br>

	 * <br>

	 * <p>

	 * If the layer has grid subsets (TileMatrixLimits) then

		if(layer.getBBox() != null)

			return new ExtentImpl(layer.getBBox().toRectangle2D());

		if(layer.getWGS84BBox() != null) {

			String crsCode = p.getSRSCode();

			Rectangle2D r = layer.getWGS84BBoxTransformed(crsCode);

			if(r != null)

				return new ExtentImpl(r);

		}

		if(bbox == null)

			getExtentByResolutionLevel();

		return bbox;

		/*if(gridSubsets) {

			WMTSBoundingBox bbox = layer.getWGS84BBox();

			return new ExtentImpl(bbox.toRectangle2D());

			return bbox;

		}*/

	}

	/**

	 * Gets the suffix of the downloaded image

	 * @return

		}

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

	        return "png";

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

	        return "xml";

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

	        return "gif";

	    }

	    }

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

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

	    }

		return "xml";

	}

			WMTSDataParameters p = (WMTSDataParameters)parameters;

			WMTSTileMatrixSetLink tileMatrixSetLink = getTileMatrixSetLink();

			WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

	    	double widthMtsTile = 0;

	    	double heightMtsTile = 0;

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

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

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

		    	}

		    	//TODO: Revisar!!! Creo que el top left sale al rev?s en el de la nasa

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

		    	Rectangle2D r = new Rectangle2D.Double(

		    			tileMatrix.getTopLeftCorner()[1] - h,

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

		    			h);

		}

		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(getColorInterpretation());

		}

		return lastFileTransparency;

	}

	public NoData getNoDataValue() {

		NoData nodata = super.getNoDataValue();

		if(nodata != null)

		return noData;

	}

	}

	public void setView(Extent e) {

	public double getWidth() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

			return p.getWidth();

		return lastWidthRequest;

	}

	public double getHeight() {

		WMTSDataParameters p = (WMTSDataParameters)parameters;

			return p.getHeight();

		return lastHeightRequest;

	}

		throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

		return null;

	}

	/**

	 * 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

	 * 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

	 * @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 FileNotOpenException

	 * @throws RasterDriverException

	 */

	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

	 * @throws RasterDriverException

	 * @throws ProcessInterruptedException

	 */

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

		return null;

	}

	/**

	 * Gets the tile matrix from the selected level

	 * @param level

	 */

	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()) {

		}

		return tileMatrix;

	}

	/**

	 * Returns the number of levels

	 * @return

			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]) {

				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);

	}

	/**

	 * @param level

	 * @param extent

	 * @param w

		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

			level = getZoomLevels();

		return level;

	}

	public org.gvsig.raster.cache.tile.Tile getTile(SpiRasterQuery 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());

		}

		int bufWidth = tileMatrix.getTileWidth();

		int bufHeight = tileMatrix.getTileHeight();

		try {

			Extent adjBbox = q.getAdjustedRequestBoundingBox();

			Rectangle2D r = adjBbox.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(

					new double[]{adjBbox.getULX(), adjBbox.getULY(), adjBbox.getLRX(), adjBbox.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 {

					bandList.addBand(band);

				} catch(BandNotFoundInListException e) {

					//No a?adimos la banda

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

		}

	}

	@Override

			throws ProcessInterruptedException, RasterDriverException {

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

		WMTSStatus status = buildWMTSStatus(r, q.getAdjustedWidth(), q.getAdjustedBufHeight());

		Buffer b = matrixBuffer.getWindow(q.getAdjustedRequestBoundingBox(), q.getBufWidth(), q.getBufHeight(), q.getBandList().getDrawableBandsCount());

		q.setBufferResult(b);

	}

	/**

	 * @param wcx

	 * @param wcy

	 * @param level

		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);

	}

	/**

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

	 * @param point

	 */

	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());

	}

	/**

	 * @param r

	 * @param bufWidth

	 * @return

	 */

	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();

				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)

		else*/

		Extent[] extList = getExtentByResolutionLevel();

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

		//6-Petici?n

		WMTSStatus status = null;

		try {

		WMTSLayer wmtsLayer = p.getLayer();

		status.setTileList(tiles);

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

		status.setFormat(p.getImageFormat());

		status.setInfoFormat(p.getInfoFormat());

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

		status.setLevel(level - dif);

		status.setDimension(p.getDimension());

		status.setValueForDimension(p.getDimensionSelectedValue());

		wmtsLayer.buildResourceURLListFromTemplate(status);

		this.lastStatus = status;

		return status;

	}

	/**

	 * Gets the resolution level from the real coordinates

	 * @param r

	 * @return

	 * @throws RasterDriverException

	 */

		WMTSTileMatrixSet tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

		return getLevelFromScale(scale, tileMatrixSet);

	}

	/**

	 * Gets the resolution level from the scale

	 * @param scale

		}

		return 0;

	}

	/**

	 * Get the tile matrix set using the crs

	 * @param srs

			return (WMTSTileMatrixSetLink)tileMatrixSetLinkList.get(0);

		return null;

	}

	/**

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

	 * @param r

		} else

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

	}

	/**

	 * Throw a request

	 * @param status

	 * @param bandList

	 * @param listener

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

	 */

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

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

		} 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);

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

			}

		}

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

			int nCollected = 0;

			while (nCollected < tiles.size()) {

				nCollected ++;

			}

		}

		if(requestType == SEQUENTIAL) {

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

				WMTSTile tile = tiles.get(i);

				}

			}

		}

			listener.endReading();

		return tileList;

	}

	/**

	 * Reads a tile with gdal and calls the method nextBuffer

	 * @param tile

			colorTable = driver.getColorTable();

			bandCount = driver.getBandCount();

			lastFileTransparency = (DataStoreTransparency)driver.getTransparency();

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

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

			int[] drawableBands = bandList.getDrawableBands();

			RasterDataStore store = new DefaultRasterStore();

			store.setProvider(driver);

			Buffer buf = store.query(q);

			buf.setDataExtent(new Rectangle2D.Double(

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

			Buffer alphaBand = null;

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

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

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

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

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

				listener.tileReady(t);

				return t;

		} catch (ProcessInterruptedException e) {

		}

		return null;

	}

	public Image getImageLegend() {

		try {

			File file = getOGCClient().getLegendGraphic(

					((WMTSDataParameters)param).getLayer(),

					new ICancellable() {

						public boolean isCanceled() {

							return false;

						}

						public Object getID() {

							return null;

						}

	}

	public void setAffineTransform(AffineTransform t){

	}

	public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

        public WMTSDataParameters getParameters() {

		return (WMTSDataParameters)this.param;

	}

	/**

	 * Convierte un punto desde coordenadas pixel a coordenadas del mundo.

	 * @param pt Punto a transformar

		}

		return p;

	}

	public void setStatus(RasterProvider provider) {

		if(provider instanceof WMTSProvider) {

		}

	}

	public File getLastRequest() {

		return lastRequest;

	}

	/**

	 * ASigna el par?metro de inicializaci?n del driver.

	 */

		this.param = param;

		this.storeServices = storeServices;

	}

	public String getInfoByPoint(int x, int y, Extent bbox, int w, int h, ICancellable cancellable) throws InfoByPointException {

		int level;

		try {

			throw new InfoByPointException("Error in getFeatureInfo", e);

		}

	}

	public int getNearestLevel(double pixelSize) {

		double[] pixelSizes = getPixelSizeByLevel();

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

			return getZoomLevels() - 1;

		return 0;

	}

	public TileServer getTileServer() {

		if(tileServer == null) {

			DefaultRasterStore store = new DefaultRasterStore();

		}

		return tileServer;

	}

	public int[] getTileSize(int level) {

		return getTileServer().getStruct().getTileSizeByLevel(level);

	}

	public boolean isRasterEnclosed() {

		return true;

	}

	public Buffer getBufferLastRequest() throws ProcessInterruptedException, RasterDriverException {

		return null;

	}

	/**

	 * Gets the srs code

	 * @return

	public RasterProvider getInternalProvider() {

		return this;

	}

	public HistogramComputer getHistogramComputer() {

		if (histogram == null)

			histogram = new RemoteStoreHistogram(this);

		return histogram;

	}

}