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

import java.awt.geom.AffineTransform;

import java.io.File;

import java.io.IOException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

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.dataset.Buffer;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.RasterQuery;

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

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

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

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

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

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.exception.TileBuildException;

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.fusion.BufferListFusion;

import org.gvsig.raster.impl.provider.fusion.BufferListFusion.PixelSquareStructure;

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

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

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

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

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

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

import org.gvsig.raster.mosaic.io.downloader.MosaicTileServer;

import org.gvsig.timesupport.RelativeInstant;

import org.gvsig.timesupport.Time;

import org.gvsig.timesupport.TimeSupportLocator;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Data provider for raster mosaics

 *

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

 */

public class MosaicProvider extends AbstractRasterProvider {

        public static String                     NAME                     = "Mosaic Raster";

        public static String                     DESCRIPTION              = "Mosaic Raster Support";

        public final String                      METADATA_DEFINITION_NAME = NAME;

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

        private boolean                          open                     = false;

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

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

    protected static String[]                formatList               = null;

    //private MosaicRasterFormat               mosaicRasterFormat       = null;

    private List<RasterProvider>             providerList             = null;

    private double                           pixelSize                = 0D;

    private Extent                           extent                   = null;

        private double                           width                    = 0;

        private double                           height                   = 0;

        private Extent                           viewRequest              = null;

        //private TiledLayer                       tiledLayer               = null;

        //This provider needs a MosaicTileServer by set of layers

        private HashMap<String, MosaicTileServer>

                                                 tileServerMap            = new HashMap<String, MosaicTileServer>();

        private ArrayList<RasterProvider>        selectedProviders        = new ArrayList<RasterProvider>();

        private boolean                          bandCountCalculated      = false;

        public static void register() {

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

                registerFormats();

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

                        dataman.registerStoreProvider(NAME,

                                        MosaicProvider.class, MosaicDataParametersImpl.class);

                }

                if(DALFileLocator.getFilesystemServerExplorerManager() != null)

                        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                                        NAME, DESCRIPTION,

                                        MosaicServerExplorer.class);

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

                        dataman.registerExplorerProvider(NAME, MosaicServerExplorer.class, MosaicServerExplorerParameters.class);

                }

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        @SuppressWarnings("deprecation")

        private static void registerFormats() {

                formatList      = new String[] {"mrf"};

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

                        RasterLocator.getManager().addFormat(formatList[i], MosaicProvider.class);

        }

        public String[] getFormatList() {

                return formatList;

        }

        /**

         * Returns true if the extension is supported and false if doesn't

         * @param ext

         * @return

         */

        public boolean isExtensionSupported(String ext) {

                if(ext.indexOf(".") != -1)

                        ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

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

                        if(formatList[i].compareTo(ext) == 0)

                                return true;

                }

                return false;

        }

        public MosaicProvider() {

        }

        /**

         * Opens the dataset.

         * @param proj Projection

         * @param fName File name

         * @throws NotSupportedExtensionException

         */

        public MosaicProvider(String params) throws NotSupportedExtensionException, OpenException {

                super(params);

                if(params instanceof String) {

                        MosaicDataParametersImpl p = new MosaicDataParametersImpl();

                        p.setURI((String)params);

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

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

        public MosaicProvider (MosaicDataParametersImpl 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 (AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

                setParam(storeServices, params);

                openFromMrf();

                calcMetadataFromParams();

                super.init();

                try {

                        loadFromRmf(getRmfBlocksManager());

                } catch (ParsingException e) {

                        //No lee desde rmf

                }

                open = true;

        }

        /**

         * Calculates metadata using the parameters

         */

        private void calcMetadataFromParams() {

                uri = getParameters().getURI();

                providerList = getParameters().getProviders();

                pixelSize = getParameters().getPixelSize();

                //Se le pone banda de transparencia siempre

                if(providerList.get(0).getDataType()[0] == Buffer.TYPE_BYTE) {

                        transparency = new DataStoreTransparency();

                        transparency.setTransparencyBand(getBandCount() - 1);

                } else 

                        transparency = providerList.get(0).getTransparency();

                extent = null;

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

                        if(extent == null)

                                extent = providerList.get(i).getExtent();

                        else

                                extent = extent.encloseBoundinBoxes(providerList.get(i).getExtent());

                        //Usa el primer NoData de la primera imagen que tenga un valor asignado

                        if(noData == null && providerList.get(i).getNoDataValue().isDefined()) {

                                noData = providerList.get(i).getNoDataValue();

                                noData.setFileName(getParameters().getURI());

                        }

                }

                width = extent.width() / pixelSize;

                height = extent.height() / pixelSize;

                ownTransformation = new AffineTransform(pixelSize, 0, 

                                                        0, -pixelSize, 

                                                        extent.getULX(), extent.getULY());

                externalTransformation = (AffineTransform) ownTransformation.clone();

                ((MosaicDataParametersImpl)getParameters()).resetParamsChanged();

        }

        public ColorInterpretation getColorInterpretation() {

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

                        ColorInterpretation ci = null;

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

                                RasterProvider prv = providerList.get(i);

                                if(prv.getBandCount() == getBandCount() && prv.getColorInterpretation() != null) {

                                        ci = prv.getColorInterpretation().cloneColorInterpretation();

                                }

                        }

                        if(ci == null) {

                                if(getDataType()[0] == Buffer.TYPE_BYTE) {

                                        if(getBandCount() == 4)

                                                ci = DataStoreColorInterpretation.createARGBInterpretation();

                                        if(getBandCount() == 3)

                                                ci = DataStoreColorInterpretation.createRGBInterpretation();

                                        if(getBandCount() == 1)

                                                ci = DataStoreColorInterpretation.createPaletteInterpretation();

                                } else {

                                        if(getBandCount() == 1)

                                                ci = DataStoreColorInterpretation.createGrayInterpretation();

                                        else 

                                                ci = DataStoreColorInterpretation.createDefaultInterpretation();

                                }

                        }

                        setColorInterpretation(ci);

                }

                return super.getColorInterpretation();

        }

        /**

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

        }

        /**

         * Open from a .mrf file. 

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

         * @throws OpenException

         */

        private void openFromMrf() throws OpenException {

                if(getParameters().getURI() != null && new File(getParameters().getURI()).exists()) {

                        try {

                                if(getParameters().getProviders() != null)

                                        getParameters().getProviders().clear();

                                MosaicRasterFormat multiFileFormat = new MosaicRasterFormat();

                                multiFileFormat = MosaicRasterFormatSerializer.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);

                                                        if(i == 0)

                                                                getParameters().setPixelSize(prov.getCellSize());

                                                        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 .mrf can't be read", e1);

                        } catch (ParsingException e1) {

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

                        }

                } 

        }

        public RasterProvider load() {

                return this;

        }

        /**

         * Gets the MosaicDataParameters

         * @return

         */

        public MosaicDataParameters getParameters() {

                try {

                        return (MosaicDataParameters)parameters;

                } catch (ClassCastException e) {

                        return null;

                }

        }

        public boolean isOpen() {

                return open;

        }

        public void close() {

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

                        providerList.get(i).close();

                }

        }

        /**

         * @return Returns the dataType.

         */

        public int[] getDataType() {

                if(providerList.get(0).getDataType()[0] == Buffer.TYPE_BYTE) {

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

                        for (int i = 0; i < providerList.get(0).getDataType().length; i++) {

                                dt[i] = providerList.get(0).getDataType()[i];

                        }

                        dt[getBandCount() - 1] = Buffer.TYPE_BYTE;

                        return dt;

                }

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

        }

        /**

         * Gets the number of bands

         * @return 

         */

        public int getBandCount() {

                if(!bandCountCalculated) {

                        bandCount = providerList.get(0).getBandCount();

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

                                if(providerList.get(i).getBandCount() > bandCount)

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

                        }

                }

                return bandCount;

        }

        public String[] getURIByProvider() {

                providerList = getParameters().getProviders();

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

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

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

                }

                return uris;

        }

        public int[] getBandCountByProvider() {

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

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

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

                }

                return n;

        }

        public BandList getDefaultBandList() {

                BandList bandList = new BandListImpl();

                int[] nBandsByProvider = getBandCountByProvider();

                int nBands = 0;

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

                        nBands = Math.max(nBandsByProvider[i], nBands);

                }

                for (int iBand = 0; iBand < nBands; iBand++) {

                        try {

                                bandList.addBand(new DatasetBandImpl(getURI(), iBand, getDataType()[0], nBands));

                        } catch (BandNotFoundInListException e1) {

                        }        

                }

                int[] drawableBands = new int[bandList.getBandCount()];

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

                        drawableBands[i] = i;

                }

                bandList.setDrawableBands(drawableBands);

                return bandList;

        }

        public String getURIByBand(int band) {

                return getURI();

        }

        public double getPixelSizeX() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return pixelSize;

        }

        public double getPixelSizeY() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return pixelSize;

        }

        public NoData getNoDataValue() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return noData;

        }

        public Extent getExtent() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return extent;

        }

        public double getCellSize() {

                return pixelSize;

        }

        public Statistics getStatistics() {

                if(stats == null || getParameters().hasParamsChanged()) {

                        //First of all read the statistics in the rmf. If these have not been calculated then

                        //we'll read the statistics from simple files

                        stats = super.getStatistics();

                        try {

                                loadObjectFromRmf(SimpleProviderStatistics.class, stats);

                        } catch (RmfSerializerException e) {

                                // Si no se puede cargar del RMF, recalcularemos las estadisticas.

                        }

                        if(!stats.isCalculated()) {

                                calcMetadataFromParams();

                                providerList = getParameters().getProviders();

                                stats = SimpleProviderStatistics.union(this, providerList);

                        }

                }

                return stats;

        }

        public HistogramComputer getHistogramComputer() {

                if(histogram == null || getParameters().hasParamsChanged()) {

                        calcMetadataFromParams();

                        providerList = getParameters().getProviders();

                        try {

                                histogram = SimpleProviderHistogramComputer.union(this, providerList);

                        } catch (HistogramException e) {

                                return null;

                        } catch (InterruptedException e) {

                                return null;

                        }

                }

                return histogram;

        }

        public String getURIOfFirstProvider() {

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

        }

        public long getFileSize() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                long sizeMosaic = 0;

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

                        long[] fs = providerList.get(i).getFileSizeByProvider();

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

                                sizeMosaic += fs[j];

                        }

                }

                return sizeMosaic;

        }

        public IProjection getProjection() {

                return proj;

        }

        public void setProjection(IProjection p) {

        }

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

                return null;

        }

        public int[] getTileSize(int level) {

                return null;

        }

        public int getSourceType() {

                return RasterDataStore.MOSAIC;

        }

        public String translateFileName(String fileName) {

                return fileName;

        }

        public void setView(Extent e) {

                viewRequest = new ExtentImpl(e);

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return width;

        }

        public double getHeight() {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return height;

        }

        @SuppressWarnings("deprecation")

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

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                /*if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                blockHeight = pos + blockHeight > getHeight() ? (int)(getHeight() - pos) : blockHeight;

                Buffer buf = RasterLocator.getManager().createBuffer(getDataType()[0], (int)getWidth(), blockHeight, getBandCount(), true);

                BandList bandList = new BandListImpl();

                bandList.clear();

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

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

                        try {

                                int dataType = getDataType()[i];

                                DatasetBand band = new DatasetBandImpl(getURIByBand(i), 

                                                                                                        getBandPositionByProvider(i), 

                                                                                                        dataType, 

                                                                                                        getBandCount());

                                bandList.addBand(band, i);

                                drawableBands[i] = i;

                        } catch(BandNotFoundInListException ex) {

                                //No a�adimos la banda

                        }

                }

                bandList.setDrawableBands(drawableBands);

                return getWindow(0, pos, bandList, buf);*/

                return null;

        }

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

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                return null;

        }

        /**

         * 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 crearan su propio buffer para escribir

                        //cada tile. Por ello no usara� 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(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;

        }

        private double adjustCoordinate(double c) {

                return (c > 0.95 || c < 0.05) ? Math.round(c) : c;

        }

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

                List<Buffer> bufferList = new ArrayList<Buffer>();

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

                        RasterProvider provider = providerList.get(i);

                        Extent extIntersection = getView().intersection(provider.getExtent());

                        if(extIntersection == null)

                                continue;

                        double relWidth = getView().width() / rasterBuf.getWidth();

                        double relHeight = getView().height() / rasterBuf.getHeight();

                        int w = (int)Math.ceil(adjustCoordinate(extIntersection.width() / relWidth));

                        int h = (int)Math.ceil(adjustCoordinate(extIntersection.height() / relHeight));

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

                        q.setAreaOfInterest(extIntersection, w, h);

                        q.setDrawableBands(bandList.getDrawableBands());

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(provider);

                        Buffer buf = null;

                        try {

                                buf = store.query(q);

                                buf.setDataExtent(extIntersection.toRectangle2D());

                        } catch (QueryException e) {

                                throw new RasterDriverException("Error reading data", e);

                        }

                        bufferList.add(buf);

                }

                if(bufferList.size() == 0)

                        return rasterBuf;

                PixelSquareStructure pxSquare = BufferListFusion.buildPixelSquareStructure(rasterBuf, getView(), getCellSize());

                BufferListFusion bufferFusion = new BufferListFusion(bufferList, pxSquare, BufferListFusion.FIRST);

                rasterBuf = bufferFusion.getWindow();

                bufferFusion.dispose();

                return rasterBuf;

        }

        public void loadBuffer(SpiRasterQuery q) throws ProcessInterruptedException, RasterDriverException {

                if(getParameters().hasParamsChanged())

                        calcMetadataFromParams();

                setView(q.getAdjustedRequestBoundingBox());

                getBuffersFusion(q.getBandList(), q.getTaskStatus(), q.getBufferForProviders()) ;

        }

        public int getBlockSize() {

                return 0;

        }

        public boolean isTiled() {

                return false;

        }

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

                return 0;

        }

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

                return 0;

        }

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

                return 0;

        }

        public boolean isOverviewsSupported() {

                return false;

        }

        public boolean isReproyectable() {

                return false;

        }

        public String getName() {

                return NAME;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof MosaicProvider) {

                }

        }

        public boolean isTimeSupported() {

                return true;

        }

        public boolean isMosaic() {

                return true;

        }

//        public void deleteLayerFromCache() {

//                String layerName = getLayerNameFromSelection(null);

//                TileCacheManager  manager = TileCacheLocator.getManager();

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

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

//                tileCache.removeLayer(newLayer);

//        }

        /**

         * Gets the layer name using the time selection and visibility

         * @param t

         * @return

         */

        private String getLayerNameFromSelection(Time t) {

                String name = "";

                MessageDigest md = null;

                try {

                        md = java.security.MessageDigest.getInstance("MD5");

                } catch (NoSuchAlgorithmException e) {

                }

                //Without time selected

                if(t == null || selectedProviders.size() != providerList.size()) {

                        selectedProviders.clear();

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

                                RasterProvider prov = providerList.get(i);

                                selectedProviders.add(prov);

                                if(!((RasterDataParameters)prov.getDataParameters()).isVisible())

                                        name += prov.getURI().substring(prov.getURI().lastIndexOf(File.separator) + 1, prov.getURI().length());

                        }

                } else {

                        selectedProviders.clear();

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

                                try {

                                        TimeSeries tSeries = providerList.get(i).getTimeSerials();

                                        ArrayList<?> tList = tSeries.getTimeList();

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

                                                Object obj = tList.get(i);

                                                RelativeInstant instant = null;

                                                if(obj instanceof Date) {

                                                        Date s = (Date)obj;

                                                        instant = TimeSupportLocator.getManager().createRelativeInstant(s);

                                                }

                                                if(obj instanceof Double) {

                                                        long s = ((Double)obj).longValue();

                                                        instant = TimeSupportLocator.getManager().createRelativeInstant(s);

                                                }

                                                if( instant != null && 

                                                        t.intersects(instant) &&

                                                        !selectedProviders.contains(providerList.get(i))) {

                                                        RasterProvider prov = providerList.get(i);

                                                        selectedProviders.add(prov);

                                                        if(!((RasterDataParameters)prov.getDataParameters()).isVisible())

                                                                name += prov.getURI().substring(prov.getURI().lastIndexOf(File.separator) + 1, prov.getURI().length());

                                                }

                                        }

                                } catch (RmfSerializerException e) {

                                        logger.debug("Error reading rmf time serials", e);

                                }

                        }

                }

                if(md != null) {

                        md.update(name.getBytes());

                        return math.convertToHex(md.digest());

                } else {

                        return name;

                }

        }

        /**

         * 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 TileCache createTiledLayer(String layerName) {

//                TileCacheManager  manager = TileCacheLocator.getManager();

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

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

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

//                        tiledLayer = newLayer;

//                return tileCache;

//        }

        /**

         * 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, String layerName) throws TileBuildException {

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

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

                Extent adjustedExtent = util.intersection(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++) {

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

                }

                return tileList;

        }*/

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new FileTileServer(store);

                }

                return tileServer;

        }

        /**

         * Gets the tile server from the Hashmap

         * @param layerName

         * @return

         */

        /*public TileServer getTileServer(String layerName) {

                MosaicTileServer tileServer = tileServerMap.get(layerName);

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new MosaicTileServer(store, 

                                        providerList,

                                        layerName,

                                        getParameters().getOverlapMethod(),

                                        getParameters().getColorCorrectionMethod(),

                                        getNoDataValue());

                        tileServerMap.put(layerName, tileServer);

                }

                return tileServer;

        }*/

}