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

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALFileLocator;

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.datastruct.BandList;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.provider.TileServer;

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

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

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

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

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

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

import org.gvsig.raster.impl.provider.tile.FileTileServer;

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

/**

 * A data provider for a multiband image readed from different files

 *

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

 */

public class MultiFileProvider extends AbstractRasterProvider {

        public static String                     NAME                     = "Multifile Raster";

        public static String                     DESCRIPTION              = "Multifile Raster Support";

        public final String                      METADATA_DEFINITION_NAME = NAME;

        private Extent                           viewRequest              = null;

        private TileServer                       tileServer               = null;

        private boolean                          open                     = false;

    private DataStoreTransparency            fileTransparency         = null;

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

    protected static String[]                formatList               = null;

        /**

         *

         */

        public static void register() {

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

                registerFormats();

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

                        dataman.registerStoreProvider(NAME,

                                        MultiFileProvider.class, MultiFileDataParametersImpl.class);

                }

                if(DALFileLocator.getFilesystemServerExplorerManager() != null)

                        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                                        NAME, DESCRIPTION,

                                        MultiFileServerExplorer.class);

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

                        dataman.registerExplorerProvider(NAME, MultiFileServerExplorer.class, MultiFileServerExplorerParameters.class);

                }

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        private static void registerFormats() {

                formatList      = new String[] {

                                "mff"};

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

                        RasterLocator.getManager().getProviderServices().addFormat(

                                        formatList[i],

                                        MultiFileProvider.class);

        }

        /**

         *

         */

        public MultiFileProvider() {

        }

        /**

         * Opens the dataset.

         * @param params

         * @param proj Projection

         * @param fName File name

         * @throws NotSupportedExtensionException

         * @throws OpenException

     * @deprecated use {@link #MultiFileProvider(URI)}, this constructor will be removed in gvSIG 2.5

         */

        public MultiFileProvider(String params) throws NotSupportedExtensionException, OpenException {

                super(params);

        logger.info("Deprecated use of MultiFileProvider constructor");

                if(params instanceof String) {

                        MultiFileDataParameters p = new MultiFileDataParametersImpl();

                        URI uriObj;

            try {

                uriObj = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

                        p.setURI(uriObj);

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

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

         /**

     * Opens the dataset.

         * @param uri

     * @param proj Projection

     * @param fName File name

     * @throws NotSupportedExtensionException

         * @throws OpenException

     */

    public MultiFileProvider(URI uri) throws NotSupportedExtensionException, OpenException {

        super(uri);

        MultiFileDataParameters p = new MultiFileDataParametersImpl();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

    /**

     * @param params

     * @param storeServices

     * @throws NotSupportedExtensionException

     * @throws OpenException

     */

    public MultiFileProvider(MultiFileDataParametersImpl params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(

                                                MetadataLocator.getMetadataManager().getDefinition(

                                                                DataStore.METADATA_DEFINITION_NAME)));

                init(params, storeServices);

        }

        /**

         * Build file references

         * @param params

         * @param storeServices

         * @param proj Projection

         * @param param Load parameters

         * @throws NotSupportedExtensionException

         * @throws OpenException

         */

        public void init(MultiFileDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

                openFromMff();

                uri = getParameters().getURI();

                setParam(storeServices, params);

                try {

                        setFirstProviderToNotTiled();

                } catch (InvalidSourceException e1) {

                        throw new OpenException(e1.getMessage(), e1);

                }

                super.init();

                try {

                        loadFromRmf(getRmfBlocksManager());

                } catch (ParsingException e) {

                        logger.debug("Problems reading from RMF", e);

                }

                open = true;

        }

        /**

         * Open from a .mff file.

         * This method loads all providers and adds these to the parameters

         * @throws OpenException

         */

        private void openFromMff() throws OpenException {

                URI uriParam = getParameters().getURI();

        if (uriParam != null) {

            File fileFromUriParam = new File(uriParam);

            if (fileFromUriParam.exists()) {

                boolean loadedProviders = true;

                if (getParameters().hasProviders()) {

                    // solo se considera que est?n todos los providers cargados

                    // si existen y est?n open,

                    // sino se leer?n de disco

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

                        if (!getParameters().getProviders().get(i).isOpen())

                            loadedProviders = false;

                    }

                } else

                    loadedProviders = false;

                if (loadedProviders)

                    return;

                try {

                    if (getParameters().hasProviders())

                        getParameters().removeAllProviders();

                    MultiFileFormat multiFileFormat = new MultiFileFormat();

                    multiFileFormat = MultiFileFormatSerializer.read(multiFileFormat, fileFromUriParam.getAbsolutePath());

                    for (int i = 0; i < multiFileFormat.getNumberOfFiles(); i++) {

                        try {

                            File file = new File(multiFileFormat.getPathToFile(i));

                            if (file.exists()) {

                                RasterProvider prov = loadProvider(multiFileFormat.getPathToFile(i), storeServices);

                                getParameters().addProvider(prov);

                            }

                        } catch (ProviderNotRegisteredException e) {

                            throw new OpenException("A provider can't be loaded", e);

                        } catch (InitializeException e) {

                            throw new OpenException("A provider can't be initialized", e);

                        }

                    }

                } catch (IOException e1) {

                    throw new OpenException("File .mff can't be read", e1);

                } catch (ParsingException e1) {

                    throw new OpenException("File .mff can't be parsed", e1);

                }

            }

        }

        }

        /**

         * Loads the specific provider

         * @param file

         * @return

         * @throws NotSupportedExtensionException

         * @throws FileNotSupportedException

         */

        @SuppressWarnings("unchecked")

        private RasterProvider loadProvider(String file, DataStoreProviderServices storeServices) throws ProviderNotRegisteredException, InitializeException {

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

                DataStoreProvider prov = null;

                if(file != 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);

                        }

                        File f = new File(file);

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

                        List<String> provName = serverExplorer.getProviderNameList(f);

                        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("Tile Store") != 0) {

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

                                                ((FilesystemStoreParameters)newparams).setFile(f);

                                                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;

        }

        /**

         * Checks if the new file is compatible with the old one

         * @param file

         * @return

         * @throws LocatorException

         * @throws NotSupportedExtensionException

         * @throws RasterDriverException

         * @throws CloseException

         */

        private boolean checkNewProvider(RasterProvider p) {

                Rectangle2D extentOrigin = getExtent().toRectangle2D();

                Extent extentNewFile = p.getExtent();

                // Comprobamos que el extent y tama?o del fichero a?adido sea igual al

                // fichero original. Si no es as? no abrimos la capa y mostramos un aviso

                double widthNewFile = (extentNewFile.getMax().getX() - extentNewFile.getMin().getX());

                double heightNewFile = (extentNewFile.getMax().getY() - extentNewFile.getMin().getY());

                if ((widthNewFile - extentOrigin.getWidth()) > 1.0 || (widthNewFile - extentOrigin.getWidth()) < -1.0 || (heightNewFile - extentOrigin.getHeight()) > 1.0

                                || (heightNewFile - extentOrigin.getHeight()) < -1.0) {

                        return false;

                }

                if ((extentNewFile.getMax().getX() - extentNewFile.getMin().getX()) != extentOrigin.getWidth()

                                || (extentNewFile.getMax().getY() - extentNewFile.getMin().getY()) != extentOrigin.getHeight()) {

                        return false;

                }

                return true;

        }

        /**

         * @return MultiFileDataParameters

         */

        public MultiFileDataParameters getParameters() {

                try {

                        return (MultiFileDataParameters)parameters;

                } catch (ClassCastException e) {

                        return null;

                }

        }

        public RasterProvider load() {

                return this;

        }

        public int getBandCount() {

                List<RasterProvider> providerList = getParameters().getProviders();

                int bandCount = 0;

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

                        bandCount += providerList.get(i).getBandCount();

                }

                return bandCount;

        }

        public int[] getDataType() {

                List<RasterProvider> providerList = getParameters().getProviders();

                int[] datatypes = new int[getBandCount()];

                int k = 0;

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

                        int[] dtByProv = providerList.get(i).getDataType();

                        for (int j = 0; j < dtByProv.length; j++) {

                                datatypes[k] = dtByProv[j];

                                k++;

                        }

                }

                return datatypes;

        }

        public URI[] getURIByProvider() {

                List<RasterProvider> providerList = getParameters().getProviders();

                URI[] uris = new URI[providerList.size()];

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

                        uris[i] = providerList.get(i).getURIOfFirstProvider();

                }

                return uris;

        }

        public int getBandPositionByProvider(int band) {

                return getSubBandByBandNumber(band)[1];

        }

        public URI getURIOfFirstProvider() {

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).getURIOfFirstProvider();

        }

        public Extent getExtent() {

                List<RasterProvider> providerList = getParameters().getProviders();

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

                        return providerList.get(0).getExtent();

                return null;

        }

        public AffineTransform getAffineTransform() {

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).getAffineTransform();

        }

        public void setAffineTransform(AffineTransform t) {

                List<RasterProvider> providerList = getParameters().getProviders();

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

                        providerList.get(i).setAffineTransform(t);

                }

        }

        public int getInternalProviderCount() {

                return getParameters().getProviders().size();

        }

        public RasterProvider getInternalProvider(int i) {

                return getParameters().getProviders().get(i);

        }

        public int[] getBandCountByProvider() {

                List<RasterProvider> providerList = getParameters().getProviders();

                int[] bc = new int[providerList.size()];

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

                        bc[i] = providerList.get(i).getBandCount();

                }

                return bc;

        }

        public long[] getFileSizeByProvider() {

                List<RasterProvider> providerList = getParameters().getProviders();

                long[] fs = new long[providerList.size()];

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

                        fs[i] = ((AbstractRasterProvider)providerList.get(i)).getFileSize();

                }

                return fs;

        }

        public Point2D rasterToWorld(Point2D pt) {

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).rasterToWorld(pt);

        }

        public Point2D worldToRaster(Point2D pt) {

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).worldToRaster(pt);

        }

        public boolean isInside(Point2D p){

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).isInside(p);

        }

        public double getCellSize() {

                List<RasterProvider> providerList = getParameters().getProviders();

                return providerList.get(0).getCellSize();

        }

        public Statistics getStatistics() {

                if(stats == null || (stats instanceof MultiProviderStatistics &&

                                ((MultiProviderStatistics)stats).getNumberOfProviders() != getParameters().getProviders().size())) {

                        List<RasterProvider> providerList = getParameters().getProviders();

                        stats = new MultiProviderStatistics(providerList, this);

                }

                return stats;

        }

        public HistogramComputer getHistogramComputer() {

                if(histogram == null ||

                        (histogram instanceof MultiProviderHistogramComputer &&

                        ((MultiProviderHistogramComputer)histogram).getNumberOfProviders() != getParameters().getProviders().size())) {

                        histogram = new MultiProviderHistogramComputer(this);

                }

                return histogram;

        }

        /**

         * A multiband provider doesn't have a color table because this will have

         * more than one band.

         */

        public ColorTable getColorTable() {

                return null;

        }

        public boolean isOpen() {

                return open;

        }

        public void close() {

        }

        public URI translateURI(URI uri) {

                return uri;

        }

        /**

         * Asigna el extent de la vista actual. existe un fichero .rmf debemos hacer una transformaci?n

         * de la vista asignada ya que la petici?n viene en coordenadas del fichero .rmf y la vista (v)

         * ha de estar en coordenadas del fichero.

         */

        public void setView(Extent e) {

                viewRequest = new ExtentImpl(e);

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                List<RasterProvider> providerList = getParameters().getProviders();

                if(providerList != null && providerList.size() > 0) {

                        return providerList.get(0).getWidth();

                }

                return 0;

        }

        public double getHeight() {

                List<RasterProvider> providerList = getParameters().getProviders();

                if(providerList != null && providerList.size() > 0) {

                        return providerList.get(0).getHeight();

                }

                return 0;

        }

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

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                return null;

        }

        /**

         * Gets a number of provider and the band of this provider

         * @param band

         * @return

         */

        private int[] getSubBandByBandNumber(int band) {

                List<RasterProvider> providerList = getParameters().getProviders();

                int[] res = new int[2];

                int acum = 0;

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

                        acum += providerList.get(i).getBandCount();

                        if(acum > band) {

                                res[0] = i;

                                int aux = (acum - providerList.get(i).getBandCount());

                                res[1] = band - aux;

                                return res;

                        }

                }

                return res;

        }

        @Override

        public void loadBuffer(SpiRasterQuery q)

                        throws ProcessInterruptedException, RasterDriverException {

                List<RasterProvider> providerList = getParameters().getProviders();

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

                        SpiRasterQuery query = (SpiRasterQuery)q.clone();

                        BandList bandListByFile = createBandListByProvider(q.getBandList(), providerList.get(i));

                        query.setBandList(bandListByFile);

                        providerList.get(i).getDataSet(q);

                }

                /*for (int i = 0; i < providerList.size(); i++) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(providerList.get(i));

                        RasterQuery query = ((DefaultRasterQuery)q).clone();

                        BandList bandListByFile = createBandListByProvider(q.getBandList(), providerList.get(i));

                        query.set

                        try {

                                store.query((RasterQuery)q);

                        } catch (QueryException e) {

                                throw new RasterDriverException("Error in query to the provider " + i, e);

                        }

                }*/

        }

        public Object getData(int x, int y, int band)throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                int[] sub = getSubBandByBandNumber(band);

                RasterProvider prov = getParameters().getProviders().get(sub[0]);

                return prov.getData(x, y, sub[1]);

        }

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

                throws ProcessInterruptedException, RasterDriverException {

                providerList = getParameters().getProviders();

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

                q.setAreaOfInterest(extent);

                q.setBandList(bandList);

                q.setBuffer(rasterBuf);

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

                        rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

                }

                return rasterBuf;

        }*/

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

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

                providerList = getParameters().getProviders();

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

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

                q.setBandList(bandList);

                q.setBuffer(rasterBuf);

                q.setAdjustToExtent(adjustToExtent);

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

                        rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

                }

                return rasterBuf;

        }*/

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

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

                providerList = getParameters().getProviders();

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

                q.setAreaOfInterest(extent, bufWidth, bufHeight);

                q.setBuffer(rasterBuf);

                q.setAdjustToExtent(adjustToExtent);

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

                        BandList bandListByFile = createBandListByProvider(bandList, providerList.get(i));

                        if(bandListByFile != null) {

                                q.setBandList(bandListByFile);

                                rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

                        }

                }

                return rasterBuf;

        }*/

        /**

         * Creates a <code>BandList</code> for each provider of this <code>MultiFileProvider</code>.

         * When a request is made, the <code>BandList</code> is global for all files. A specific

         * <code>BandList</code> has to be built for each provider.

         * @param globalBandList

         * @param provider

         * @return

         */

        private BandList createBandListByProvider(BandList globalBandList, RasterProvider provider) {

                if(provider.isTiled()) {

                        //Si los proveedores que hay por debajo son tileados estos crear?n su propio buffer para escribir

                        //cada tile. Por ello no usar? el buffer que viene del store. Esto quiere decir que el BandList ha

                        //de ser distinto para que escriba bien en su buffer

                        //TODO: De momento no se permiten MultiFiles con proveedores tileados. Esto es porque

                        //los tiles crean su propio buffer y no escriben en el buffer creado en el Store

                } else {

                        BandList bandListByFile = new BandListImpl();

                        String pathUriProvider = new File(provider.getURI()).getAbsolutePath();

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

                                try {

                                        bandListByFile.addBand(new DatasetBandImpl(pathUriProvider, i, provider.getDataType()[0], provider.getBandCount()));

                                } catch (BandNotFoundInListException e1) {

                                }

                        }

                        boolean areThereBandsToDraw = false;

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

                                int[] bandsToDrawByProviderBand = globalBandList.getBufferBandToDraw(pathUriProvider, i);

                                if(bandsToDrawByProviderBand != null) {

                                        areThereBandsToDraw = true;

                                        for (int j = 0; j < bandsToDrawByProviderBand.length; j++) {

                                                bandListByFile.getBand(i).addPositionToDrawInBuffer(bandsToDrawByProviderBand[j]);

                                        }

                                }

                        }

                        if(areThereBandsToDraw)

                                return bandListByFile;

                }

                return null;

        }

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

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

                providerList = getParameters().getProviders();

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

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

                q.setBandList(bandList);

                q.setBuffer(rasterBuf);

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

                        rasterBuf = ((DefaultRasterProvider)providerList.get(i)).getDataSet(q);

                }

                return rasterBuf;

        }*/

        public int getBlockSize() {

                return 0;

        }

        public ColorInterpretation getColorInterpretation() {

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

                        String[] cis = new String[getBandCount()];

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

                                if(i == 0)

                                        cis[i] = ColorInterpretation.GRAY_BAND;

                                else

                                        cis[i] = ColorInterpretation.UNDEF_BAND;

                        }

                        setColorInterpretation(new DataStoreColorInterpretation(cis));

                }

                return super.getColorInterpretation();

        }

        public DataStoreTransparency getTransparency() {

                if(fileTransparency == null)

                        fileTransparency = new DataStoreTransparency(getColorInterpretation());

                return fileTransparency;

        }

        /**

         * Informa de si el driver ha supersampleado en el ?ltimo dibujado. Es el driver el que colocar?

         * el valor de esta variable cada vez que dibuja.

         * @return true si se ha supersampleado y false si no se ha hecho.

         */

        public boolean isSupersampling() {

                return false;

        }

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

                if(band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                return 0;

        }

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

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                return 0;

        }

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

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                return 0;

        }

        public boolean isMultiFile() {

                return true;

        }

        public boolean isOverviewsSupported() {

                return true;

        }

        public boolean isReproyectable() {

                return true;

        }

        public String getProviderName() {

                return NAME;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof MultiFileProvider) {

                        //Not implemented yet

                }

        }

        public boolean isTimeSupported() {

                return true;

        }

        public URI getURIByBand(int band) {

                int[] sub = getSubBandByBandNumber(band);

                RasterProvider prov = getParameters().getProviders().get(sub[0]);

                return prov.getURIOfFirstProvider();

        }

        /**

         * @param file

         * @throws InvalidSourceException

         */

        public void addFile(String file) throws InvalidSourceException {

                ProviderServices provServ = RasterLocator.getManager().getProviderServices();

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

                setFirstProviderToNotTiled();

                List<RasterDataParameters> storeParametersList = provServ.createParametersList(file);

                for (int j = 0; j < storeParametersList.size(); j++) {

                        RasterProvider newFileProv;

                        try {

                                newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

                                if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

                                        getParameters().addProvider(newFileProv);

                                }

                        } catch (InitializeException e) {

                                throw new InvalidSourceException("", e);

                        } catch (ProviderNotRegisteredException e) {

                                throw new InvalidSourceException("", e);

                        }

                }

        }

        private void setFirstProviderToNotTiled() throws InvalidSourceException {

                List<RasterProvider> providerList = getParameters().getProviders();

                if(providerList == null || providerList.size() <= 0 || !providerList.get(0).isTiled())

                        return;

                //Si el primer proveedor es tileado se cambia a no tileado

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

                ProviderServices provServ = RasterLocator.getManager().getProviderServices();

                RasterDataParameters firstDataParameters = providerList.get(0).getDataParameters();

                URI uri = firstDataParameters.getURI();

                List<RasterDataParameters> storeParametersList = provServ.createParametersList(new File(uri).getAbsolutePath());

                for (int j = 0; j < storeParametersList.size(); j++) {

                        RasterProvider newFileProv;

                        try {

                                newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

                                if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

                                        getParameters().setFirstProvider(newFileProv);

                                }

                        } catch (InitializeException e) {

                                throw new InvalidSourceException("Error replacing the first provider", e);

                        } catch (ProviderNotRegisteredException e) {

                                throw new InvalidSourceException("Error replacing the first provider", e);

                        }

                }

        }

        public void removeFile(File file) {

                getParameters().removeProvider(file.toURI());

        }

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new FileTileServer(store);

                }

                return tileServer;

        }

    public void addFile(File file) throws InvalidSourceException {

        ProviderServices provServ = RasterLocator.getManager().getProviderServices();

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

        setFirstProviderToNotTiled();

        List<RasterDataParameters> storeParametersList = provServ.createParametersList(file);

        for (int j = 0; j < storeParametersList.size(); j++) {

            RasterProvider newFileProv;

            try {

                newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParametersList.get(j));

                if(!newFileProv.isTiled() && checkNewProvider(newFileProv)) {

                    getParameters().addProvider(newFileProv);

                }

            } catch (InitializeException e) {

                throw new InvalidSourceException("", e);

            } catch (ProviderNotRegisteredException e) {

                throw new InvalidSourceException("", e);

            }

        }

    }

}