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

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.List;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.util.MathUtils;

import org.gvsig.fmap.dal.coverage.util.RasterUtils;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

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

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

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

import org.gvsig.metadata.MetadataLocator;

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

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

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

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

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

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

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

import org.gvsig.raster.cache.tile.layer.TiledLayer;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

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 TileProvider extends DefaultRasterProvider implements TiledRasterProvider {

        public static String                NAME                     = "Tile Store";

        public static String                DESCRIPTION              = "Raster Tiled Source";

        public static final String          METADATA_DEFINITION_NAME = "TileStore";

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

        private RasterProvider              provider                 = null;

        private boolean                     open                     = false;

        private Extent                      viewRequest              = null;

        private TiledLayer                  tiledLayer               = null;

        private RasterUtils                 util                     = RasterLocator.getManager().getRasterUtils();

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

        private TileServer                  secondLevelTileServer    = null;

        public static void register() {                

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

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

                        dataman.registerStoreProvider(NAME,

                                        TileProvider.class, TileDataParametersImpl.class);

                }

                /*if(DALFileLocator.getFilesystemServerExplorerManager() != null)

                        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                                        NAME, DESCRIPTION,

                                        TileServerExplorer.class);*/

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

                        dataman.registerExplorerProvider(TileServerExplorer.NAME, TileServerExplorer.class, TileServerExplorerParameters.class);

                }

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        /**

         * Loads the specific provider to download data

         * @param file

         * @return

         * @throws NotSupportedExtensionException

         * @throws FileNotSupportedException 

         */

        private RasterProvider loadProvider(TileDataParametersImpl params, DataStoreProviderServices storeServices) throws ProviderNotRegisteredException, InitializeException {

                Object obj = params.getDataParameters();

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

                DataStoreProvider prov = null;

                if(obj != null && obj instanceof DataStoreParameters) //Remote 

                        prov = dataManager.createProvider(storeServices, (DataStoreParameters)obj);

                else { //File

                        if(params.getFile() != null) {

                                //We have to locate a provider's name which manages the selected file

                                //A FilesystemServerExplorer will give a getProviderNames service

                                FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

                                FilesystemServerExplorer serverExplorer = null;

                                try {

                                        paramsExplorer.setRoot(File.separator);

                                        serverExplorer = (FilesystemServerExplorer)dataManager.openServerExplorer(FilesystemServerExplorer.NAME, paramsExplorer);

                                } catch (ValidateDataParametersException e) {

                                        throw new InitializeException(e);

                                }

                                //Gets the list of provider's name to manage the file

                                ArrayList<String> provName = serverExplorer.getProviderNameList(params.getFile());

                                if(provName.size() > 0) {

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

                                                //Gets the first provider what is not a TileProvider

                                                if(provName.get(i).compareTo(NAME) != 0) {

                                                        DataStoreParameters newparams = dataManager.createStoreParameters(provName.get(i));

                                                        ((FilesystemStoreParameters)newparams).setFile(params.getFile()); 

                                                        prov = dataManager.createProvider(storeServices, newparams);

                                                }

                                        }

                                }

                        }

                }

                if(prov != null && prov instanceof RasterProvider) {

                        if(((RasterProvider)prov).isRotated())

                                throw new InitializeException("Rotation not supported tiling files", new Throwable());

                        return (RasterProvider)prov;

                }

                return null;

        }

        /**

         * Gets the internal provider used to feed the TileProvider

         * @return

         */

        public RasterProvider getInternalProvider() {

                return provider;

        }

        public Image getImageLegend() {

                return provider.getImageLegend();

        }

        public String getFileSuffix() {

                try {

                        return provider instanceof RemoteRasterProvider ? provider.getFileSuffix() : "tif";

                } catch(Throwable e) {

                        //if wmts doesn't exists in the classpath

                        return "tif";

                }

        }

        public String getRMFFile() {

                TileCacheManager  manager = TileCacheLocator.getManager();

                TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

                String path = tiledLayer.getBaseLayerDirectory().substring(0, tiledLayer.getBaseLayerDirectory().lastIndexOf(File.separator) + 1) + 

                                          tileCache.getConfigurationDirectory() + File.separator + 

                                          tiledLayer.getID() + ".rmf";

                try {

                        if(!new File(path).exists() && 

                                provider != null && 

                                provider.getRMFFile() != null &&

                                new File(provider.getRMFFile()).exists()) 

                                RasterLocator.getManager().getFileUtils().copyFile(provider.getRMFFile(), path);

                        if(provider != null && provider.getColorTable() != null) {        

                                ColorTable colorTable = provider.getColorTable();

                                RasterLocator.getManager().getProviderServices().saveObjectToRmfFile(path, ColorTable.class, colorTable);

                        }

                } catch (LocatorException e) {

                        logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

                } catch (FileNotFoundException e) {

                        logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

                } catch (IOException e) {

                        logger.info("No se ha podido copiar el fichero RMF a la capa tileada", e);

                } catch (RmfSerializerException e) {

                        logger.info("No se ha podido copiar la tabla de color a la capa tileada", e);

                }

                return path;

        }

        public TileProvider() throws NotSupportedExtensionException {

                super();

        }

        public void registerTileProviderFormats(Class<RasterProvider> c) {

        }

        /**

         * Assigns the provider associated to this tile server

         * @param prov

         * @throws NotSupportedExtensionException 

         */

        public void setProvider(RasterProvider prov) throws InitializeException  {

                this.provider = prov;

                init(getDataStoreParameters(), getStoreServices());

        }

        public TileProvider(TileDataParametersImpl params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(

                                                MetadataLocator.getMetadataManager().getDefinition(

                                                                DataStore.METADATA_DEFINITION_NAME)));

                if(!params.isSecondLevelCache()) {

                        try {

                                provider = loadProvider(params, storeServices);

                        } catch (ProviderNotRegisteredException e) {

                                throw new InitializeException("Provider not registered", e);

                        }

                        init(params, storeServices);

                        if(provider.getFileSizeByProvider() != null && provider.getFileSizeByProvider().length > 0)

                                fileSize = provider.getFileSizeByProvider()[0];

                }

        }

        /**

         * Creates the second level cache if the client has set a <code>TileServer</code> and the

         * <code>CacheStruct</code> is different that the old one. 

         * <UL>

         * <LI>First level cache without TileServer from the client: do nothing</LI>

         * <LI>First level cache with TileServer from the client and the structure is 

         * different to the old one: Builds a second level TileProvider</LI>

         * <LI>First level cache with TileServer from the client and the structure is 

         * equal to the old one: do nothing</LI>

         * <LI>Second level cache: sets the TileServer</LI>

         * </UL>

         * @param params

         * @param storeServices

         * @throws NotSupportedExtensionException

         */

        /*private void createsSecondLevelCache(TileDataParametersImpl params) throws NotSupportedExtensionException {

                //Se obtiene el TileServer que haya pasado el cliente en los par?metros si ha pasado alguno.

                TileServer tileServer = params.getTileServer();

                //Se obtiene el CacheStruct y se compara con el del provider

                CacheStruct cacheStruct = null;

                if(tileServer != null)

                        cacheStruct = tileServer.getStruct();

                if(params.isSecondLevelCache()) { //Cache de segundo nivel

                        this.secondLevelTileServer = tileServer;

                } else if(cacheStruct != null && !provider.getTileServer().getStruct().compare(cacheStruct)) { //Cache de primer nivel

                        //Si son distintos habr? que crear una cach? de segundo nivel por lo que creamos un nuevo TileProvider

                        //que tenga como par?metro el provider viejo

                        TileDataParametersImpl par = new TileDataParametersImpl();

                        par.setDataParameters(provider.getDataParameters());

                        par.setTileServer(tileServer);

                        par.setSecondLevelCache(true);

                        TileProvider newProvider = new TileProvider(par, null);

                        newProvider.setProvider(this.provider);

                        //Al TileProvider actual se le asigna como provider el TileProvider creado

                        this.provider = newProvider;

                }

        }*/

        /**

         * Crea las referencias al fichero y carga

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

         * @param proj Proyecci?n

         * @param param Parametros de carga

         * @throws NotSupportedExtensionException

         */

        public void init (DataStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException  {

                setParam(storeServices, params);

                open = true;

                setDataType(provider.getDataType());

                bandCount = provider.getBandCount();

                //if(getColorInterpretation() == null)

                        setColorInterpretation(provider.getColorInterpretation());

                /*else

                        getColorInterpretation().addColorInterpretation(provider.getColorInterpretation());*/

                setColorTable(provider.getColorTable());

                noData = provider.getNoDataValue();

                setFName(provider.getURIOfFirstProvider());

                proj = provider.getProjection();

                ownTransformation = provider.getAffineTransform();

                externalTransformation = (AffineTransform)ownTransformation.clone();

                createTiledLayer();

                //Force to deletes the layer if the flag is to true

                if(tiledLayer != null) {

                        if(param instanceof TileDataParameters) {

                                if(((TileDataParameters)param).isDeletingCache()) {

                                        TileCacheManager  manager = TileCacheLocator.getManager();

                                        TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

                                        tileCache.removeLayer(tiledLayer);

                                        ((TileDataParameters)param).deleteCache(false);

                                }

                        }

                }

                if(provider instanceof RemoteRasterProvider)

                        stats = new RemoteDataStoreStatistics(provider);

        }

        /**

         * Creates a new tiled layer if this hasn't been created yet or the ID has changed. 

         * An ID could changed because the file type has changed when the user uses WMTS properties.

         */

        private void createTiledLayer() {

                TileCacheManager  manager = TileCacheLocator.getManager();

                TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

                TiledLayer newLayer = tileCache.createLayer(provider.getTileServer(), TileCacheLibrary.DEFAULT_STRUCTURE);

                if(tiledLayer == null || newLayer.getID().compareTo(tiledLayer.getID()) != 0)

                        tiledLayer = newLayer;

        }

        public int getZoomLevels() {

                if(provider.getTileServer() != null)

                        return provider.getTileServer().getStruct().getNumberOfLevels();

                return 0;

        }

        public int getNearestLevel(double pixelSize) {

                double[] pixelSizes = getPixelSizeByLevel();

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

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

                                return i;

                        }

                }

                if(pixelSize < pixelSizes[getZoomLevels() - 1])

                        return getZoomLevels() - 1;

                return 0;

        }

        /**

         * Returns a list of pixel sizes by level

         * @return

         */

        public double[] getPixelSizeByLevel() {

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

                CacheStruct struct = provider.getTileServer().getStruct();

                for (int i = 0; i < struct.getNumberOfLevels(); i++) {

                        list[i] = math.adjustDouble(struct.getPixelSizeByLevel(i));

                }

                return list;

        }

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

                level = adjustLevel(level);

                double pixelSize = provider.getTileServer().getStruct().getPixelSizeByLevel(level);

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

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

                double lrx = ulx + (w * pixelSize);

                double lry = uly + (h * pixelSize);

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

        }

        /**

         * 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 AffineTransform getAffineTransform() {

                return provider.getAffineTransform();

        }

        /**

         * Obtiene el objeto que contiene el estado de la transparencia

         */

        public Transparency getTransparency() {

                return provider.getTransparency();

        }

        /**

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

                return provider.getExtent();

        }

        public RasterProvider load() {

                return this;

        }

        public boolean isOpen() {

                return open;

        }

        public boolean isTiled() {

                return true;

        }

        public void close() {

                open = false;

                if(provider != null)

                        provider.close();

        }

        public String translateFileName(String fileName) {

                return fileName;

        }

        public void setView(Extent e) {

                viewRequest = e;

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                return provider.getWidth();

        }

        public double getHeight() {

                return provider.getHeight();

        }

        public Object readCompleteLine(int line, int band)

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                return null;

        }

        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. 

         * 

         * @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 provider.readBlock(pos, blockHeight, scale);

        }

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

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                return provider.getData(x, y, band);

        }

        /**

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

        }

        /**

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

        }

        /**

         * Gets the tile list in a selected extent

         * @param ex

         * @param bandList

         * @param bufWidth

         * @param bufHeight

         * @return

         * @throws TileBuildException 

         */

        private List<Tile> getTileList(Extent ex, BandList bandList, int bufWidth, int bufHeight) throws TileBuildException {

                TileServer tileServer = provider.getTileServer();

                CacheStruct struct = tileServer.getStruct();

                tileServer.setFileSuffix(getFileSuffix());

                createTiledLayer(); //Creates a new layer when the file type changes

                Extent adjustedExtent = util.intersection(provider.getExtent(), ex);

                double newBufWidth = (adjustedExtent.width() * bufWidth) / ex.width();

                double pixelSizeRequest = adjustedExtent.width() / newBufWidth; 

                List<Tile> tileList = struct.getTileList(new Point2D.Double(adjustedExtent.getULX(), adjustedExtent.getULY()), 

                                new Point2D.Double(adjustedExtent.getLRX(), adjustedExtent.getLRY()), 

                                pixelSizeRequest);

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

                        loadTileTimeParameters(tileList.get(i));

                }

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

                        tileList.get(i).setDownloaderParams("BandList", bandList.clone());

                }

                return tileList;

        }

        /**

         * Loads the multidimensional parameters in a tile 

         * @param tile

         */

        private void loadTileTimeParameters(Tile tile) {

                if(provider.getDataParameters() instanceof MultiDimensionalStoreParameters) {

                        MultiDimensionalStoreParameters par = (MultiDimensionalStoreParameters)provider.getDataParameters();

                        tile.setVariable(par.getStringVariable());

                        tile.setZ(par.getStringLevel());

                        tile.setTimeInstant(par.getStringTime());

                }

        }

        public boolean needEnhanced() {

                return provider.needEnhanced();

        }

        public Tile getTile(DefaultRasterQuery q) throws TileGettingException {

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

                if(q.getCacheStruct() == null)

                        q.setCacheStruct(provider.getTileServer().getStruct());

                else

                        provider.getTileServer().setStruct(q.getCacheStruct());

                Tile tile = null;

                try {

                        tile = q.getCacheStruct().getTileStructure(

                                        q.getResolutionLevel(), q.getTileCol(), q.getTileRow(), 

                                        new Point2D.Double(q.getBBox().getULX(), q.getBBox().getULY()), 

                                        new Point2D.Double(q.getBBox().getLRX(), q.getBBox().getLRY()));

                } catch (TileBuildException e1) {

                        throw new TileGettingException(e1);

                }

                loadTileTimeParameters(tile);

                //Creamos un BandList con todas las bandas del fichero

                BandList bandList = new BandListImpl();

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

                        try {

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

                                bandList.addBand(band);

                        } catch(BandNotFoundInListException e) {

                                //No a?adimos la banda

                        }

                }

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

                tile.setDownloaderParams("BandList", bandList);

                createTiledLayer();

                return tiledLayer.getTile(tile);

        }

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

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

                try {

                        List<Tile> tileList = getTileList(ex, bandList, bufWidth, bufHeight);

                        tiledLayer.getTiles(tileList, listener, taskStatus);

                } catch (TileGettingException e) {

                        throw new RasterDriverException("Error getting the tile list", e);

                } catch (TileBuildException e) {

                        throw new RasterDriverException("Error building the tile list", e);

                }

        }

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

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

                //draw method

                List<Tile> tileList = null;

                try {

                        tileList = getTileList(extent, bandList, bufWidth, bufHeight);

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

                                tiledLayer.getTile(tileList.get(i));

                        }

                } catch (TileGettingException e) {

                        throw new RasterDriverException("Error getting the tile list", e);

                } catch (TileBuildException e) {

                        throw new RasterDriverException("Error building the tile list", e);

                }

                MemoryMatrixBuffer matrixBuffer = new MemoryMatrixBuffer(tileList);

                return matrixBuffer.getWindow(extent, rasterBuf);

        }

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

                throws ProcessInterruptedException, RasterDriverException {

                //return ((DefaultRasterProvider)provider).getWindow(ex, bandList, rasterBuf);

                return null;

        }

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

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

                Extent extent = new ExtentImpl(ulx, uly, ulx + w, uly - h);

                List<Tile> tileList = null;

                try {

                        tileList = getTileList(extent, bandList, rasterBuf.getWidth(), rasterBuf.getHeight());

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

                                tiledLayer.getTile(tileList.get(i));

                        }

                } catch (TileGettingException e) {

                        throw new RasterDriverException("Error getting the tile list", e);

                } catch (TileBuildException e) {

                        throw new RasterDriverException("Error building the tile list", e);

                }

                MemoryMatrixBuffer matrixBuffer = new MemoryMatrixBuffer(tileList);

                return matrixBuffer.getWindow(extent, rasterBuf);

        }

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

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

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

                q.setAreaOfInterest(x, y, w, h);

                q.setBandList(bandList);

                q.setBuffer(rasterBuf);

                Buffer b = ((DefaultRasterProvider)provider).getDataSet(q);

                if(b != null)

                        return b;

                else {

                        //TODO

                }

                return null;

        }

        public int getBlockSize() {

                return 0;

        }

        public void setAffineTransform(AffineTransform t){

        }

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

                return getZoomLevels();

        }

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

                return provider.getTileServer().getStruct().getLayerWidthOfTileMatrixByLevel(overview) * 

                                provider.getTileServer().getStruct().getTileSizeByLevel(overview)[0];

        }

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

                return provider.getTileServer().getStruct().getLayerHeightOfTileMatrixByLevel(overview) * 

                                provider.getTileServer().getStruct().getTileSizeByLevel(overview)[0];

        }

        public boolean isOverviewsSupported() {

                return false;

        }

        public String getName() {

                return NAME;

        }

        /**

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

         * @param pt Punto a transformar

         * @return punto transformado en coordenadas del mundo

         */

        public Point2D rasterToWorld(Point2D pt) {

                Point2D p = new Point2D.Double();

                getAffineTransform().transform(pt, p);

                return p;

        }

        /**

         * Convierte un punto desde del mundo a coordenadas pixel.

         * @param pt Punto a transformar

         * @return punto transformado en coordenadas pixel

         */

        public Point2D worldToRaster(Point2D pt) {

                Point2D p = new Point2D.Double();

                try {

                        getAffineTransform().inverseTransform(pt, p);

                } catch (NoninvertibleTransformException e) {

                        return pt;

                }

                return p;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof TileProvider) {

                }

        }

        /**

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

         */

        @Override

        public void setParam(DataStoreProviderServices storeServices, DataStoreParameters param) {

                if(param instanceof RemoteStoreParameters)

                        this.uri = ((RasterDataParameters)param).getURI();

                this.param = param;

                this.storeServices = storeServices;

        }

        public String getInfoByPoint(double x, double y, ICancellable cancellable) throws InfoByPointException {

                if(provider != null)

                        return provider.getInfoByPoint(x, y, cancellable);

                return "Not implemented";

        }

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

                if(provider != null)

                        return provider.getInfoByPoint(x, y, bbox, w, h, cancellable);

                return "Not implemented";

        }

        public ColorInterpretation getColorInterpretation() {

                return provider.getColorInterpretation();

        }

        /**

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

         * color por banda

         * @param DataStoreColorInterpretation

         */

        public void setColorInterpretation(ColorInterpretation colorInterpretation) {

                provider.setColorInterpretation(colorInterpretation);

        }

        public int[] getTileSize(int level) {

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

        }

        public void deleteLayerFromCache() {

                TileCacheManager  manager = TileCacheLocator.getManager();

                TileCache tileCache = manager.getTileCache(RasterLibrary.pathTileCache);

                if(tiledLayer != null)

                        tileCache.removeLayer(tiledLayer);

        }

        public TileServer getTileServer() {

                return secondLevelTileServer;

        }

        public void setSecondLevelTileServer(TileServer tileServer) {

                this.secondLevelTileServer = tileServer;

        }

        public void setTileServer(Class<?> tileServer) throws InitializeException {

                //TODO:Manejar excepciones

                //Crear par?metros

                TileDataParametersImpl par = new TileDataParametersImpl();

                par.setDataParameters(getDataParameters());

                par.setSecondLevelCache(true); //No crea un nuevo provider

                //Crea el proveedor de tiles de segundo nivel

                TileProvider newProvider = null;

                newProvider = new TileProvider(par, null);

                newProvider.setProvider(this.provider);

                //Instancia el TileServer pasado por el cliente con el TileProvider de segundo nivel

                Constructor<?> constructor;

                TileServer tServer = null;

                try {

                        constructor = tileServer.getConstructor(new Class<?>[]{DefaultRasterProvider.class});

                        Object [] args2 = {newProvider};

                        tServer = (TileServer)constructor.newInstance(args2);

                } catch (SecurityException e) {

                        e.printStackTrace();

                } catch (NoSuchMethodException e) {

                        e.printStackTrace();

                } catch (IllegalArgumentException e) {

                        e.printStackTrace();

                } catch (InstantiationException e) {

                        e.printStackTrace();

                } catch (IllegalAccessException e) {

                        e.printStackTrace();

                } catch (InvocationTargetException e) {

                        e.printStackTrace();

                }

                //Asigna el TileServer al nuevo provider de segundo nivel

                newProvider.setSecondLevelTileServer(tServer);

                //Asigna al provider de tiles de primer nivel el de segundo. 

                //Solo si las estructuras de cach? son diferentes

                if(!provider.getTileServer().getStruct().compare(tServer.getStruct())) {

                        this.setProvider(newProvider);

                        tiledLayer = null;

                }

        }

}