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

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 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 proj Projection

         * @param fName File name

         * @throws NotSupportedExtensionException

         */

        public MultiFileProvider(String params) throws NotSupportedExtensionException, OpenException {

                super(params);

                if(params instanceof String) {

                        MultiFileDataParameters p = new MultiFileDataParametersImpl();

                        p.setURI((String)params);

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

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

        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 proj Projection

         * @param param Load parameters

         * @throws NotSupportedExtensionException

         */

        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 {

                if(getParameters().getURI() != null && new File(getParameters().getURI()).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 leeran 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, getParameters().getURI());

                                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;

        }

        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 String[] getURIByProvider() {

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

                String[] uris = new String[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 String 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 String translateFileName(String fileName) {

                return fileName;

        }

        /**

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

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

                                try {

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

                                } catch (BandNotFoundInListException e1) {

                                }

                        }

                        boolean areThereBandsToDraw = false;

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

                                int[] bandsToDrawByProviderBand = globalBandList.getBufferBandToDraw(provider.getURI(), 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 String getURIByBand(int band) {

                int[] sub = getSubBandByBandNumber(band);

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

                return prov.getURIOfFirstProvider();

        }

        public void addFile(String file) throws InvalidSourceException {

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

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

//                if(providerList.size() > 0 && providerList.get(0).isTiled()) {

//                        //Comentado hasta que se puedan incorporar fuentes tileadas a aun MultiFile

//                        //en su lugar se sustituye el primer proveedor tileado por uno sin tilear

//                        

//                        RasterDataParameters storeParameters = provServ.createParametersForTiledFiled(file);

//                        

//                        try {

//                                RasterProvider newFileProv = (RasterProvider)dataManager.createProvider(storeServices, storeParameters);

//                                if(checkNewProvider(newFileProv)) {

//                                        getParameters().addProvider(newFileProv);

//                                }

//                        } catch (InitializeException e) {

//                                throw new InvalidSourceException("", e);

//                        } catch (ProviderNotRegisteredException e) {

//                                throw new InvalidSourceException("", e);

//                        }

//                } 

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

                String uri = firstDataParameters.getURI();

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

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

                getParameters().removeProvider(file);

        }

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new FileTileServer(store);

                }

                return tileServer;

        }

}