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

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.File;

import java.net.URI;

import java.security.NoSuchAlgorithmException;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLibrary;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.store.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.parameter.RasterFileStoreParameters;

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

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.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.store.props.Transparency;

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

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

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

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

import org.gvsig.fmap.dal.raster.spi.AbstractCoverageStoreProvider;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

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

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

import org.gvsig.raster.impl.datastruct.serializer.ColorTableRmfSerializer;

import org.gvsig.raster.impl.datastruct.serializer.NoDataRmfSerializer;

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

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

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

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

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

import org.gvsig.raster.impl.store.rmf.ClassSerializer;

import org.gvsig.raster.impl.store.rmf.RmfBlocksManager;

import org.gvsig.raster.impl.store.serializer.ColorInterpretationRmfSerializer;

import org.gvsig.raster.impl.store.serializer.GeoInfoRmfSerializer;

import org.gvsig.raster.impl.store.serializer.GeoPointListRmfSerializer;

import org.gvsig.raster.impl.store.serializer.ProjectionRmfSerializer;

import org.gvsig.raster.impl.store.serializer.StatisticsRmfSerializer;

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.timesupport.Interval;

import org.gvsig.timesupport.Time;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.locator.LocatorException;

/**

 * Base class for all raster providers.

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

 */

public abstract class AbstractRasterProvider extends AbstractCoverageStoreProvider implements RasterProvider {

    private static final Logger LOG = LoggerFactory.getLogger(AbstractRasterProvider.class);

        /**

         * Flags que representan a las bandas visualizables

         */

        public static final int                   RED_BAND               = 0x01;

        public static final int                   GREEN_BAND             = 0x02;

        public static final int                   BLUE_BAND              = 0x04;

        public static final int                   ALPHA_BAND             = 0x08;

        protected int                             bandCount              = 1;

        private int[]                             dataType               = null;

        protected NoData                          noData                 = null;

        protected Statistics                      stats                  = null;

        protected HistogramComputer               histogram              = null;

        protected DataStoreParameters             param                  = null;

        protected DataStoreProviderServices       storeServices          = null;

        protected RmfBlocksManager                rmfBlocksManager       = null;

        protected ColorTable                      colorTable             = null;

        private ColorInterpretation               colorInterpretation    = null;

        protected TimeSeries                      serialInfo             = null;

        protected Transparency                    transparency           = null;

        protected TileServer                      tileServer             = null;

        protected GeoPointList                    geoPointList           = null;

        protected FileUtils                       fileUtil               = RasterLocator.getManager().getFileUtils();

        protected RasterUtils                     rasterUtil             = RasterLocator.getManager().getRasterUtils();

        protected IProjection                     proj                   = null;

        protected long                            fileSize               = 0;

        protected long                            bytesReaded            = 0;

        protected long                            lineCnt                = 0;

        protected URI                          uri;

        protected String                          selectedSubdatasetID   = null;

        /**

         * Transformaci?n creada a partir de la informaci?n de georreferencia de la

         * propia imagen. Esta informaci?n est? en la cabecera o en ficheros

         * worldfile.

         */

        protected AffineTransform                 ownTransformation      = null;

        /**

         * Transformaci?n asignada de forma externa, bien desde el fichero rmf o

         * asignada directamente por el usuario.

         */

        protected AffineTransform                 externalTransformation = null;

        private static Logger                     logger                 = LoggerFactory.getLogger(AbstractRasterProvider.class.getName());

    public AbstractRasterProvider(AbstractRasterDataParameters params,

        DataStoreProviderServices storeServices, DynObject metadata) {

        super(params, storeServices, metadata);

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

            uri = params.getURI();

            if ("FILE".equalsIgnoreCase(uri.getScheme())) {

                File f = new File(uri);

                if (f.exists()) {

                    setFileSize(f.length());

                }

            }

            uri = translateURI(uri);

        }

        // If there is a defined SRS, set it to provider. This must be override

        // if provider is georeferenced.

        if(params != null && params.getSRS() != null){

            try {

                this.setProjection(params.getSRS(), false);

            } catch (RmfSerializerException e) {

                LOG.warn("Can not persist {} parameter projection to {} provider",

                    new Object[] { params.getSRSID(), this.getName() });

            }

        }

        ownTransformation = new AffineTransform();

        externalTransformation = new AffineTransform();

    }

        public AbstractRasterProvider(DataStoreParameters params,

                        DataStoreProviderServices storeServices, DynObject metadata) {

                super(params, storeServices, metadata);

                RasterDataParameters rasterParameters = (RasterDataParameters) params;

                URI uriParam = rasterParameters.getURI();

        if(uriParam != null) {

            if ("FILE".equalsIgnoreCase(uriParam.getScheme())) {

                File f = new File(uriParam);

                if (f.exists())

                    setFileSize(f.length());

            }

                        if(params instanceof RemoteStoreParameters)

                                uri = translateURI(uriParam);

                }

        if(rasterParameters != null && rasterParameters.getSRS() != null){

            try {

                this.setProjection(rasterParameters.getSRS(), false);

            } catch (RmfSerializerException e) {

                LOG.warn("Can not persist {} parameter projection to {} provider",

                    new Object[] { rasterParameters.getSRSID(), this.getName() });

            }

        }

                ownTransformation = new AffineTransform();

                externalTransformation = new AffineTransform();

        }

        public AbstractRasterProvider(String params) {

                super();

        }

        public AbstractRasterProvider(URI uri) {

        super();

    }

        public AbstractRasterProvider() {

                super(null, null, null);

        }

        public String[] getFormatList() {

                return null;

        }

        /**

         * Acciones de inicilizaci?n comunes a todos los drivers.

         * Este m?todo debe ser llamado explicitamente por el constructor de cada driver.

         * Estas son acciones de inicializaci?n que se ejecutan despu?s del constructor de cada driver.

         * Las acciones que hayan de ser realizadas antes se definen en el constructor de RasterDataset.

         */

        protected void init() {

        }

        public boolean isRGB() {

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

                        ColorInterpretation ci = getColorInterpretation();

                        return ci.isRGB();

                }

                return false;

        }

        public boolean isARGB() {

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

                        ColorInterpretation ci = getColorInterpretation();

                        return ci.isRGBA();

                }

                return false;

        }

        public boolean isTiled() {

                return false;

        }

        public boolean isTimeSupported() {

                return false;

        }

        public RasterProvider cloneProvider() throws CloneException {

                try {

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

                        AbstractRasterProvider provider = (AbstractRasterProvider)dataManager.createProvider(storeServices, param);

                        //DefaultRasterProvider provider = singleDatasetInstance(storeServices, param);

                        // Estas van por referencia

                        provider.histogram = histogram;

                        provider.stats = stats;

                        return provider;

                } catch (ProviderNotRegisteredException e) {

                        e.printStackTrace();

                } catch (InitializeException e) {

                        e.printStackTrace();

                }

                return null;

        }

        /**

         * Factoria para abrir distintos tipos de raster.

         * @param storeServices

         * @param param

         *

         * @return SingleDataset, o null si hay problemas.

         * @throws RasterDriverException

         */

        @SuppressWarnings("unchecked")

        public static AbstractRasterProvider singleDatasetInstance(DataStoreProviderServices storeServices, String param) throws RasterDriverException {

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

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

                //A FilesystemServerExplorer will give a getProviderNames service

                FilesystemServerExplorer serverExplorer = null;

                try {

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

                        paramsExplorer.setRoot(File.separator);

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

                } catch (ValidateDataParametersException e) {

                        throw new RasterDriverException("Error validating parameters", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error creating a server explorer ", e);

                } catch (ProviderNotRegisteredException e) {

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

                }

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

                File file = new File(param);

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

                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;

                                        try {

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

                                                ((FilesystemStoreParameters)newparams).setFile(file);

                                                if(storeServices == null)

                                                        storeServices = new DefaultRasterStore();

                                                return (AbstractRasterProvider)dataManager.createProvider(storeServices, newparams);

                                        } catch (InitializeException e) {

                                                throw new RasterDriverException("Error creating a server explorer ", e);

                                        } catch (ProviderNotRegisteredException e) {

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

                                        }

                                }

                        }

                }

                return null;

        }

        /**

         * Carga un fichero raster. Puede usarse para calcular el extent e instanciar

         * un objeto de este tipo.

         * @return RasterProvider

         */

        abstract public RasterProvider load();

        /**

         * Obtiene el ancho de la imagen

         * @return Ancho de la imagen

         */

        abstract public double getWidth();

        /**

         * Obtiene el ancho de la imagen

         * @return Ancho de la imagen

         */

        abstract public double getHeight();

        /**

         * Asigna un nuevo Extent

         * @param e        Extent

         */

        public abstract void setView(Extent e);

        /**

         * Obtiene el extent asignado

         * @return        Extent

         */

        public abstract Extent getView();

        /**

         * Obtiene el valor del raster en la coordenada que se le pasa.

         * El valor ser? Double, Int, Byte, etc. dependiendo del tipo de

         * raster.

         * @param x        coordenada X

         * @param y coordenada Y

         * @return data

         */

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

        /**

         * Gets the set of data selected in the {@link RasterQuery}

         * @param q

         * @return buffer

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         */

        public Buffer getDataSet(SpiRasterQuery query) throws ProcessInterruptedException, RasterDriverException {

                SpiRasterQuery q = (SpiRasterQuery)query;

                loadBuffer(q);

                return q.getBufferForProviders();

        }

        /**

         * Load a buffer with the parameters. The buffer should already have been created

         * inside the query structure <code>SpiRasterQuery</code> by the <code>RasterDataStore</code>. The other

         * parameters have been calculated too, all of them adjusted to the raster limits. The provider only

         * have to read the parameters and load the buffer.

         *

         * @param query

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

        abstract public void loadBuffer(SpiRasterQuery query) throws ProcessInterruptedException, RasterDriverException;

        abstract public int getBlockSize();

        abstract public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException;

        /**

         * Informa de si el dataset soporta overviews o no.

         * @return true si soporta overviews y false si no las soporta.

         */

        abstract public boolean isOverviewsSupported();

        public void reload() {

                try {

                        loadFromRmf(getRmfBlocksManager());

                } catch (ParsingException e) {

                        logger.debug("No se ha podido leer el RMF", e);

                }

        }

        /**

         * Carga metadatos desde el fichero Rmf si estos existen

         * @param fName Nombre del fichero

         * @throws ParsingException

         */

        protected void loadFromRmf(RmfBlocksManager manager) throws ParsingException {

                if (!manager.checkRmf())

                        return;

                if (!new File(manager.getPath()).exists())

                        return;

                GeoInfoRmfSerializer geoInfoSerializer = new GeoInfoRmfSerializer(this);

                ColorTableRmfSerializer colorTableSerializer = new ColorTableRmfSerializer();

                GeoPointListRmfSerializer gcpSerializer = new GeoPointListRmfSerializer();

                NoDataRmfSerializer noDataSerializer = null;

                if(noData == null)

                        noData = new DefaultNoData(null, null, manager.getPath(), getBandCount());

                noDataSerializer = new NoDataRmfSerializer((DefaultNoData)noData);

                ColorInterpretationRmfSerializer colorInterpSerializer = new ColorInterpretationRmfSerializer();

                ProjectionRmfSerializer projectionRmfSerializer = new ProjectionRmfSerializer();

                StatisticsRmfSerializer statsRmfSerializer = new StatisticsRmfSerializer(getStatistics());

                manager.addClient(geoInfoSerializer);

                manager.addClient(colorTableSerializer);

                manager.addClient(gcpSerializer);

                manager.addClient(noDataSerializer);

                manager.addClient(colorInterpSerializer);

                manager.addClient(projectionRmfSerializer);

                manager.addClient(statsRmfSerializer);

                manager.read(null);

                manager.removeAllClients();

                if (colorTableSerializer.getResult() != null)

                        setColorTable((ColorTable) colorTableSerializer.getResult());

                if (colorInterpSerializer.getResult() != null) {

                        DataStoreColorInterpretation ci = (DataStoreColorInterpretation) colorInterpSerializer.getResult();

                        setColorInterpretation(ci);

                        getTransparency().setColorInterpretation(ci);

                        getTransparency().setTransparencyBand(ci.getBand(DataStoreColorInterpretation.ALPHA_BAND));

                }

                if (projectionRmfSerializer.getResult() != null) {

                        proj = (IProjection) projectionRmfSerializer.getResult();

                }

                if( gcpSerializer.getResult() != null &&

                        gcpSerializer.getResult() instanceof GeoPointList &&

                        ((GeoPointList)gcpSerializer.getResult()).size() > 0) {

                        setGeoPointList((GeoPointList)gcpSerializer.getResult());

                }

        }

        /**

         * Obtiene el n?mero de bandas del fichero

         * @return Entero que representa el n?mero de bandas

         */

        public int getBandCount() {

                return bandCount;

        }

        /**

         * @return Returns the dataType.

         */

        public int[] getDataType() {

                return dataType;

        }

        /**

         * @param dataType The dataType to set.

         */

        public void setDataType(int[] dataType) {

                this.dataType = dataType;

        }

        public double getPixelSizeX() {

                return externalTransformation.getScaleX();

        }

        public double getPixelSizeY() {

                return externalTransformation.getScaleY();

        }

        public NoData getNoDataValue() {

                if(noData == null) {

                        noData = RasterLocator.getManager().getDataStructFactory().createDefaultNoData(getBandCount(), getDataType()[0]);

                        noData.setNoDataTransparent(false);

                        File rmfFile = getRMFFile();

                        if(rmfFile!=null){

                            noData.setFileName(rmfFile.getName());

                        }

                }

                return noData;

        }

        public void setNoDataValue(NoData value) {

                this.noData = value;

        }

        /**

         * Dice si el fichero tiene georreferenciaci?n o no.

         * @return true si tiene georreferenciaci?n y false si no la tiene

         */

        public boolean isGeoreferenced() {

                return true;

        }

        /**

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

         * @param pt Punto a transformar

         * @return punto transformado en coordenadas del mundo

         */

        public Point2D rasterToWorld(Point2D pt) {

                Point2D p = new Point2D.Double();

                externalTransformation.transform(pt, p);

                return p;

        }

        /**

         * Convierte un punto desde del mundo a coordenadas pixel.

         * @param pt Punto a transformar

         * @return punto transformado en coordenadas pixel

         */

        public Point2D worldToRaster(Point2D pt) {

                Point2D p = new Point2D.Double();

                try {

                        externalTransformation.inverseTransform(pt, p);

                } catch (NoninvertibleTransformException e) {

                        return pt;

                }

                return p;

        }

        /**

         * Calcula el extent en coordenadas del mundo real

         * @return Extent

         */

        public Extent getExtent() {

                return new ExtentImpl(        rasterToWorld(new Point2D.Double(0, 0)),

                                                        rasterToWorld(new Point2D.Double(getWidth(), getHeight())),

                                                        rasterToWorld(new Point2D.Double(getWidth(), 0)),

                                                        rasterToWorld(new Point2D.Double(0, getHeight())));

        }

        /**

         * Calcula el extent en coordenadas del mundo real sin rotaci?n. Solo coordenadas y tama?o de pixel

         * @return Extent

         */

        public Extent getExtentWithoutRot() {

                AffineTransform at = new AffineTransform(        externalTransformation.getScaleX(), 0,

                                                                                                        0, externalTransformation.getScaleY(),

                                                                                                        externalTransformation.getTranslateX(), externalTransformation.getTranslateY());

                Point2D p1 = new Point2D.Double(0, 0);

                Point2D p2 = new Point2D.Double(getWidth(), getHeight());

                at.transform(p1, p1);

                at.transform(p2, p2);

                return new ExtentImpl(p1, p2);

        }

        /**

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

         * @param provServices

         * @param param

         */

        public void setParam(DataStoreProviderServices provServices, DataStoreParameters param) {

                if(param instanceof RasterDataParameters)

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

                this.param = param;

                this.storeServices = provServices;

        }

        abstract public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException;

        public void selectSubdataset() {}

        /**

         * Selects the subdataset. This method will select

         * the rmf file.

         */

        protected void selectSubdataset(String subdataset) {

                selectedSubdatasetID = subdataset;

                getRmfBlocksManager().setPath(getRMFFile().getPath());

        }

        /**

         * Obtiene el gestor de ficheros RMF

         * @return RmfBloksManager

         */

        public RmfBlocksManager getRmfBlocksManager() {

                File fileRMF = getRMFFile();

                if(fileRMF != null) {

                        if (rmfBlocksManager == null || !fileRMF.equals(rmfBlocksManager)) {

                                rmfBlocksManager = new RmfBlocksManager(fileRMF.getPath());

                        }

                }

                return rmfBlocksManager;

        }

    public File getRMFFile() {

        String tail = selectedSubdatasetID == null ? ".rmf" : "-sd" + selectedSubdatasetID + ".rmf";

        File rmfFolder =

            (getDataParameters() != null && getDataParameters() instanceof RasterDataParameters)

                ? ((RasterDataParameters) getDataParameters()).getRMFFolder() : null;

        String fileName;

        URI objUri = getURI();

        File file;

        if ("FILE".equalsIgnoreCase(objUri.getScheme())) {

            file = new File(objUri);

            fileName = FilenameUtils.getBaseName(new File(objUri).getAbsolutePath());

            if (rmfFolder == null) {

                rmfFolder = file.getParentFile();

                if ((getDataParameters() != null && getDataParameters() instanceof RasterDataParameters)) {

                    ((RasterDataParameters) getDataParameters()).setRMFFolder(rmfFolder);

                }

            }

            return new File(rmfFolder.getAbsolutePath() + File.separator + fileName + tail);

        }

        return new File(getRMFFileForRemoteServices(getName()));

    }

        protected String getRMFFileForRemoteServices(String layerName) {

                String md5 = "";

                try {

                        md5 = RasterLocator.getManager().getFileUtils().convertPathToMD5(uri.toString());

                } catch (LocatorException e) {

                        logger.debug("Error getting the Locator", e);

                } catch (NoSuchAlgorithmException e) {

                        logger.debug("Error getting the algorithm MD5", e);

                }

                File path = new File(RasterLibrary.pathRMFRemote);

                if(!path.exists())

                        path.mkdir();

                return RasterLibrary.pathRMFRemote + File.separator + md5 + "-" + layerName + ".rmf";

        }

        public boolean isInside(Point2D p){

                //Realizamos los calculos solo si el punto est?n dentro del extent de la imagen rotada, as? nos ahorramos los calculos

                //cuando el puntero est? fuera

                Point2D pt = new Point2D.Double();

                try {

                        getAffineTransform().inverseTransform(p, pt);

                        if(        pt.getX() >= 0 && pt.getX() < getWidth() &&

                                        pt.getY() >= 0 && pt.getY() < getHeight())

                                return true;

                } catch (NoninvertibleTransformException e) {

                        return false;

                }

                return false;

        }

        /**

         * Consulta de si un raster tiene rotaci?n o no.

         * @return true si tiene rotaci?n y false si no la tiene.

         */

        public boolean isRotated() {

                if(externalTransformation.getShearX() != 0 || externalTransformation.getShearY() != 0)

                        return true;

                return false;

        }

        public boolean isMultiFile() {

                return false;

        }

        public boolean isMosaic() {

                return false;

        }

        /**

         * Devuelve si el Dataset es reproyectable

         * @return true if Dataset is reproyectable

         */

        public boolean isReproyectable() {

                return true;

        }

        public String getWktProjection() {

                if(proj != null && RasterLocator.getManager().isCRSUtilSupported())

                        return RasterLocator.getManager().getCRSUtils().convertIProjectionToWkt((IProjection) proj);

                return null;

        }

        public void saveObjectToRmf(Class<?> class1, Object value) throws RmfSerializerException {

        if (getRmfBlocksManager() != null) {

            ((DefaultProviderServices) RasterLocator.getManager().getProviderServices()).saveObjectToRmfFile(

                getRmfBlocksManager(), class1, value);

        }

        }

        /**

         * Carga un objecto desde un serializador del tipo class1. Usa value para iniciar dicho

         * serializador

         *

         * @param class1

         * @param value

         * @return

         * @throws RmfSerializerException

         */

        private static Object loadObjectFromRmfFile(RmfBlocksManager blocksManager, Class<?> class1, Object value) throws RmfSerializerException {

                ClassSerializer serializerObject = ((DefaultProviderServices)RasterLocator.getManager().getProviderServices()).getSerializerObject(class1, value);

                if (serializerObject == null)

                        throw new RmfSerializerException("No se ha podido encontrar el serializador para el Rmf");

                if (!blocksManager.checkRmf())

                        throw new RmfSerializerException("Error al comprobar el fichero Rmf");

                blocksManager.addClient(serializerObject);

                try {

                        blocksManager.read(null);

                } catch (ParsingException e) {

                        throw new RmfSerializerException("Error al leer el fichero Rmf", e);

                }

                blocksManager.removeAllClients();

                return serializerObject.getResult();

        }

        public Object loadObjectFromRmf(Class<?> class1, Object value) throws RmfSerializerException {

                RmfBlocksManager blocksManager = getRmfBlocksManager();

                if(blocksManager!=null){

                    return loadObjectFromRmfFile(blocksManager, class1, value);

                }

                return null;

        }

        /**

         * Carga un objeto del fichero RMF especificado por parametro

         * @param file

         * @param class1

         * @param value

         * @return Object

         * @throws RmfSerializerException

         */

        public static Object loadObjectFromRmfFile(String file, Class<?> class1, Object value) throws RmfSerializerException {

                String fileRMF = RasterLocator.getManager().getFileUtils().getNameWithoutExtension(file) + ".rmf";

                RmfBlocksManager blocksManager = new RmfBlocksManager(fileRMF);

                return loadObjectFromRmfFile(blocksManager, class1, value);

        }

        /**

         * Guarda en el RMF el objecto actual en caso de que exista un serializador para el

         * @param value

         * @throws RmfSerializerException

         */

        public void saveObjectToRmf(Object value) throws RmfSerializerException {

                saveObjectToRmf(value.getClass(), value);

        }

        /**

         * Carga un objecto desde un serializador usando el tipo del mismo objeto pasado por parametro.

         * Usa value para iniciar dicho serializador

         * @param value

         * @return Object

         * @throws RmfSerializerException

         */

        public Object loadObjectFromRmf(Object value) throws RmfSerializerException {

                return loadObjectFromRmf(value.getClass(), value);

        }

        public double getCellSize() {

                try {

                        Extent e = getExtent();

                        double dCellsize = (e.getMax().getX() - e.getMin().getX() ) / getWidth();

                        return dCellsize;

                } catch (NullPointerException e) {

                        return 1;

                }

        }

        public RasterProvider newProvider() {

                return null;

        }

        public ColorTable getColorTable() {

                return colorTable;

        }

        public Image getImageLegend() {

                return null;

        }

        public void setColorTable(ColorTable value) {

                colorTable = value;

        }

        public Transparency getTransparency() {

                return transparency;

        }

        public Metadata getMetadata() {

                return null;

        }

        public ColorInterpretation getColorInterpretation() {

                return this.colorInterpretation;

        }

        /**

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

         * color por banda

         * @param DataStoreColorInterpretation

         */

        public void setColorInterpretation(ColorInterpretation colorInterpretation) {

                this.colorInterpretation = colorInterpretation;

        }

        public Statistics getStatistics() {

                if(stats == null) {

                        stats = new SimpleProviderStatistics(this);

                }

                return stats;

        }

        public void setStatistics(Statistics stats) throws RmfSerializerException {

                this.stats = stats;

                saveObjectToRmf(Statistics.class, stats);

        }

        public HistogramComputer getHistogramComputer() {

                if (histogram == null)

                        histogram = new SimpleProviderHistogramComputer(this);

                return histogram;

        }

    //****************************************************

        //*********Implementing Disposable methods************

        //****************************************************

    public void doDispose() {

    }

    //****************************************************

        //*****Implementing DataStoreProvider methods*********

        //****************************************************

        @Override

        public DataServerExplorer getExplorer() throws ReadException,

                        ValidateDataParametersException {

            /*DataManager manager = DALLocator.getDataManager();

                FilesystemServerExplorerParameters params;

                try {

                        params = (FilesystemServerExplorerParameters) manager

                                        .createServerExplorerParameters(FilesystemServerExplorer.NAME);

                        params.setRoot(((AbstractRasterStoreParameters)this.getDataParameters()).getFile().getParent());

                        return manager.createServerExplorer(params);

                } catch (DataException e) {

                        throw new ReadException(this.getName(), e);

                }*/

            return null;

        }

        /**

         * Returs the DataParameters

         * @return the DataParameters

         */

        public RasterDataParameters getDataParameters() {

                if(getDataStoreParameters() instanceof RasterDataParameters)

                        return (RasterDataParameters)getDataStoreParameters();

                return null;

        }

        public Iterator<?> getChilds() {

                return null;

        }

        public ResourceProvider getResource() {

                return null;

        }

        public Object getSourceId() {

                if( this.getDataParameters() instanceof RasterFileStoreParameters)

                        return ((RasterFileStoreParameters)this.getDataParameters()).getFile();

                else

                        return this.getDataParameters().getURI();

        }

        public void open() throws OpenException {

        }

        /**

         * Traduce el nombre del fichero por un alias asignado por el propio driver.

         * Cuando es traducido por un alias el driver intentar? abrir el alias y no el

         * fichero. Esto es util porque algunos formatos tienen la extensi?n en el

         * fichero de cabecera pero lo que se abre realmente es el fichero de datos.

         * @param uri

         * @return uri

         */

        public URI translateURI(URI uri) {

            return uri;

        }

        /*

         * Si alguna subclase necesita sobreescribir este m?todo, deber? hacerlo con el translateURI en lugar de este.

         */

        public final String translateFileName(String fileName) {

                return fileName;

        }

        public String getFileSuffix() {

                String path = new File(getURIOfFirstProvider()).getAbsolutePath();

        return FilenameUtils.getExtension(path);

        }

        public URI getURIOfFirstProvider() {

            //FIXME: Esto que lo sobreescriban los proveedores que no son de archivo

//                return RasterLocator.getManager().getFileUtils().getFormatedRasterFileName(uri);

            return getURI();

        }

        public URI getURI() {

                return uri;

        }

        public void setFName(String n) {

            File file = new File(n);

            uri = file.toURI();

        }

    public String getName() {

        String pathName = null;

        try {

            URI x = this.getURI();

            pathName = new File(x).getAbsolutePath();

            return FilenameUtils.getBaseName(pathName);

        } catch (Throwable th1) {

            try {

                return FilenameUtils.getBaseName(this.uri.getPath());

            } catch (Throwable th2) {

                return this.uri.getPath();

            }

        }

    }

        public String getFullName() {

                return new File(uri).getAbsolutePath();

        }

        /**

         * Gets the size of the file if exists in Bytes

         * @return the size of file

         */

        public long getFileSize() {

                return fileSize;

        }

        public void setFileSize(long sz) {

                fileSize = sz;

        }

        public IProjection getProjection() {

                return proj;

        }

        public void setProjection(IProjection proj, boolean persist) throws RmfSerializerException {

                this.proj = proj;

                if(persist) {

                        saveObjectToRmf(IProjection.class, proj);

                }

        }

        protected long getTime() {

                return (new Date()).getTime();

        }

        public void setAffineTransform(AffineTransform t) {

                externalTransformation = (AffineTransform) t.clone();

        }

        public AffineTransform getAffineTransform() {

                return externalTransformation;

        }

        /**

         * Elimina la matriz de transformaci?n asociada al raster y que se tiene en

         * cuenta para el setView. Este reseteo tendr? en cuenta que si el raster

         * tiene asociado un rmf esta transformaci?n no ser? eliminada sino que se

         * asignar? la correspondiente al rmf existente.

         */

        public void resetAffineTransform() {

                externalTransformation.setToIdentity();

        }

        public AffineTransform getOwnAffineTransform() {

                return ownTransformation;

        }

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

                return null;

        }

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

                return null;

        }

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

        }

        public int[] getTileSize(int level) {

                return new int[]{0, 0};

        }

        public boolean isRasterEnclosed() {

                return false;

        }

        public int getSourceType() {

            String scheme = getURI().getScheme();

        if("PG".equalsIgnoreCase(scheme)){

                   return RasterDataStore.POSTGIS;

            } else if ("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme)) {

            return RasterDataStore.REMOTE;

            }

        //"file".equalsIgnoreCase(scheme)

                return RasterDataStore.FILE;

        }

        /**

         * Most of providers don't need tiles. It those cases this method

         * won't execute anything. Only providers that use tile cache will need

         * implement this function, for instance TileProvider and MosaicProvider.

         */

        public void deleteLayerFromCache() {

        }

        public TimeSeries getTimeSerials() throws RmfSerializerException {

                if(serialInfo == null) {

                        serialInfo =  new DefaultTimeSerials();

                        loadObjectFromRmf(TimeSeries.class, serialInfo);

                        //Seleccionamos la primera serie por defecto. El usuario seleccionar? otra si la necesita

                        serialInfo.selectSerial(0);

                }

                return serialInfo;

        }

        public void setTimeSerials(TimeSeries serialInfo) throws RmfSerializerException {

                this.serialInfo = serialInfo;

                saveObjectToRmf(TimeSeries.class, serialInfo);

        }

        public long[] getFileSizeByProvider() {

                return new long[]{getFileSize()};

        }

        public URI[] getURIByProvider() {

                //For providers with one file

                return new URI[]{getURIOfFirstProvider()};

        }

        public int[] getBandCountByProvider() {

                return new int[]{getBandCount()};

        }

        public int getInternalProviderCount() {

                return 1;

        }

        public RasterProvider getInternalProvider(int i) {

                return this;

        }

        public URI getURIByBand(int band) {

                //No matter which band be selected. In providers with one file is always the first URI

                return getURIOfFirstProvider();

        }

        public int getBandPositionByProvider(int band) {

                return band;

        }

        public int getSubdatasetCount() {

                return 0;

        }

//        public void addFile(File file) throws InvalidSourceException {

//                //Do nothing

//        }

//

//        public void removeFile(File file) {

//                //Do nothing

//        }

        public boolean needEnhanced() {

                return false;

        }

        /**

         * Gets the {@link Interval} of the store, that means the temporal

         * interval where the store has valid data.

         * In raster this method has sense in a mosaic. Therefore this has to be implemented

         * by the provider.

         * @return

         *         a time interval or null if there is not time support

         */

        public Interval getInterval() {

                return null;

        }

        /**

         * Gets all the possible values of time for which the store has data.

         * In raster this method has sense in a mosaic. Therefore this has to be implemented

         * by the provider.

         * @return

         *         a collection of {@link Time} objects.

         */

        public Collection<?> getTimes() {

                return null;

        }

        /**

         * Gets all the possible values of time for which the store has data

         * and intersects with an interval.

         * In raster this method has sense in a mosaic. Therefore this has to be implemented

         * by the provider.

         * @param interval

         *         the interval of time

         * @return

         *         a collection of {@link Time} objects.

         */

        public Collection<?> getTimes(Interval interval) {

                return null;

        }

        /**

         * Gets the list of geo points associated to this provider

         * @return the list of geo points

         */

        public GeoPointList getGeoPointList() {

                return geoPointList;

        }

        /**

         * Sets the list of geo points associated to this provider

         */

        public void setGeoPointList(GeoPointList geoPointList) {

                this.geoPointList = geoPointList;

        }

        /**

         * @deprecated This method should not be used. The store have a getDefaultBandList

         * @return BandList

         */

        public BandList getDefaultBandList() {

                BandList bandList = new BandListImpl();

                URI[] uriByProvider = getURIByProvider();

                int[] nBandsByProvider = getBandCountByProvider();

                for (int iProvider = 0; iProvider < uriByProvider.length; iProvider++) {

                        for (int iBand = 0; iBand < nBandsByProvider[iProvider]; iBand++) {

                                try {

                    bandList.addBand(new DatasetBandImpl(

                        new File(uriByProvider[iProvider]).getAbsolutePath(),

                        iBand,

                        getDataType()[0],

                        nBandsByProvider[iProvider])

                    );

                                } 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 void close() {

                if(transparency != null)

                        transparency.dispose();

                try {

                        finalize();

                } catch (Throwable e) {

                }

        }

        protected void finalize() throws Throwable {

                dataType               = null;

                noData                 = null;

                stats                  = null;

                histogram              = null;

                param                  = null;

                storeServices          = null;

                rmfBlocksManager       = null;

                colorTable             = null;

                colorInterpretation    = null;

                serialInfo             = null;

                transparency           = null;

                tileServer             = null;

                fileUtil               = null;

                rasterUtil             = null;

                proj                   = null;

                uri                    = null;

                selectedSubdatasetID   = null;

                ownTransformation      = null;

                externalTransformation = null;

        }

}