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

                }

                return null;

        }

        public Image getImageLegend() {

                try {

                        File file = getOGCClient().getLegendGraphic(

                                        ((WMTSDataParameters)param).getLayer(),

                                        ((WMTSDataParameters)param).getStyle(), 

                                        new ICancellable() {

                                                public boolean isCanceled() {

                                                        return false;

                                                }

                                                public Object getID() {

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

        }

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

                return 0;

        }

        public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

                return 0;

        }

        public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

                return 0;

        }

        public boolean isOverviewsSupported() {

                return false;

        }

        public boolean isReproyectable() {

                return false;