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.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.io.File;

import java.util.ArrayList;

import java.util.Date;

import java.util.Iterator;

import org.cresques.cts.IProjection;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.raster.cache.tile.provider.TileServer;

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

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

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.tools.dynobject.DynObject;

/**

 * Manejador de ficheros raster georeferenciados.

 *

 * Esta clase abstracta es el ancestro de todas las clases que proporcionan

 * soporte para ficheros raster georeferenciados.<br>

 * Actua tambien como una 'Fabrica', ocultando al cliente la manera en que

 * se ha implementado ese manejo. Una clase nueva que soportara un nuevo

 * tipo de raster tendr?a que registrar su extensi?n o extensiones usando

 * el m?todo @see registerExtension.<br>

 * 

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

 */

public abstract class DefaultRasterProvider extends AbstractCoverageStoreProvider implements RasterProvider {

        /**

         * 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 double                          noData                 = 0;

        protected String                          wktProjection          = "";

        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;

        /**

         * Indica si el valor NoData esta activo

         */

        protected boolean                         noDataEnabled          = false;

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

        public DefaultRasterProvider(AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices, DynObject metadata) {

                super(params, storeServices, metadata);

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

                        File f = new File(params.getURI());

                        if(f.exists())

                                setFileSize(f.length());

                }

                if(params.getURI() != null)

                        uri = translateFileName(params.getURI());

                ownTransformation = new AffineTransform();

                externalTransformation = new AffineTransform();

        }

        public DefaultRasterProvider(DataStoreParameters params,

                        DataStoreProviderServices storeServices, DynObject metadata) {

                super(params, storeServices, metadata);

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

                        File f = new File(((RasterDataParameters)params).getURI());

                        if(f.exists())

                                setFileSize(f.length());

                        if(params instanceof RemoteStoreParameters)

                                uri = translateFileName(((RasterDataParameters)params).getURI());

                }

                ownTransformation = new AffineTransform();

                externalTransformation = new AffineTransform();

        }

        public DefaultRasterProvider(String params) {

                super();

        }

        public DefaultRasterProvider() {

                super(null, null, null);

        }

        public String getFullName() {

                return getName();

        }

        public String getProviderName() {

                return getName();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getFormatList()

         */

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

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#isTiled()

         */

        public boolean isTiled() {

                return false;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#isTimeSupported()

         */

        public boolean isTimeSupported() {

                return false;

        }

        /*

         * (non-Javadoc)

         * @see java.lang.Object#clone()

         */

        public RasterProvider cloneProvider() throws CloneException {

                try {

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

                        DefaultRasterProvider provider = (DefaultRasterProvider)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 fName Nombre del fichero.

         *

         * @return SingleDataset, o null si hay problemas.

         */

        /*public static DefaultRasterProvider singleDatasetInstance(DataStoreProviderServices storeServices, DataStoreParameters param) throws RasterDriverException {

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

                try {

                        return (DefaultRasterProvider)dataManager.createProvider(storeServices, param);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error initializing provider", e);

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Provider not register error", e);

                }

        }*/

        /**

         * Factoria para abrir distintos tipos de raster.

         * @param fName Nombre del fichero.

         *

         * @return SingleDataset, o null si hay problemas.

         */

        public static DefaultRasterProvider 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);

                ArrayList<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 (DefaultRasterProvider)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.

         */

        abstract public RasterProvider load();

        /**

         * Cierra el fichero y libera los recursos.

         */

        abstract public void close();

        /**

         * 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

         */

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

        /**

         * Gets a window of data from the source. The result of this operation could be a list of tiles

         * that are sent through the listener.

         * @param ex

         * @param bufWidth

         * @param bufHeight

         * @param bandList

         * @param listener

         * @throws ProcessInterruptedException

         * @throws RasterDriverException

         */

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

                         BandList bandList, TileListener listener) throws ProcessInterruptedException, RasterDriverException;

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas reales.

         * No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los

         * pixeles de disco.

         * @param ulx Posici?n X superior izquierda

         * @param uly Posici?n Y superior izquierda

         * @param lrx Posici?n X inferior derecha

         * @param lry Posici?n Y inferior derecha

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @return Buffer de datos

         */

        abstract public Buffer getWindow(Extent extent, BandList bandList, Buffer rasterBuf) 

                throws ProcessInterruptedException, RasterDriverException;

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas reales.

         * No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los

         * pixeles de disco.

         * @param x Posici?n X superior izquierda

         * @param y Posici?n Y superior izquierda

         * @param w Ancho en coordenadas reales

         * @param h Alto en coordenadas reales

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @param adjustToExtent Flag que dice si el extent solicitado debe ajustarse al extent del raster o no.

         * @return Buffer de datos

         */

        abstract public Buffer getWindow(double x, double y, double w, double h, 

                        BandList bandList, Buffer rasterBuf, boolean adjustToExtent) throws ProcessInterruptedException, RasterDriverException;

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas reales.

         * Se aplica supersampleo o subsampleo dependiendo del tama?o del buffer especificado.

         *

         * @param minX Posici?n m?nima X superior izquierda

         * @param minY Posici?n m?nima Y superior izquierda

         * @param maxX Posici?n m?xima X inferior derecha

         * @param maxY Posici?n m?xima Y inferior derecha

         * @param bufWidth Ancho del buffer de datos

         * @param bufHeight Alto del buffer de datos

         * @param rasterBuf        Buffer de datos

         * @param adjustToExtent Flag que dice si el extent solicitado debe ajustarse al extent del raster o no.

         * @param bandList

         * @return Buffer de datos

         */

        abstract public Buffer getWindow(Extent extent, 

                        int bufWidth, int bufHeight, BandList bandList, Buffer rasterBuf, boolean adjustToExtent) throws ProcessInterruptedException, RasterDriverException;

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas pixel.

         * No aplica supersampleo ni subsampleo sino que devuelve una matriz de igual tama?o a los

         * pixeles de disco.

         * @param x Posici?n X superior izquierda

         * @param y Posici?n Y superior izquierda

         * @param w Ancho en coordenadas reales

         * @param h Alto en coordenadas reales

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @return Buffer de datos

         */

        abstract public Buffer getWindow(int x, int y, 

                        BandList bandList, Buffer rasterBuf) throws ProcessInterruptedException, RasterDriverException;

        /**

         * Obtiene una ventana de datos de la imagen a partir de coordenadas pixel.

         * Se aplica supersampleo o subsampleo dependiendo del tama?o del buffer especificado.

         *

         * @param x Posici?n X superior izquierda

         * @param y Posici?n Y superior izquierda

         * @param w Ancho en coordenadas reales

         * @param h Alto en coordenadas reales

         * @param bufWidth Ancho del buffer de datos

         * @param bufHeight Alto del buffer de datos

         * @param rasterBuf        Buffer de datos

         * @param bandList

         * @return Buffer de datos

         */

        abstract public Buffer getWindow(int x, int y, int w, int h, int bufWidth, int bufHeight, 

                        BandList bandList, Buffer rasterBuf)throws ProcessInterruptedException, RasterDriverException;

        abstract public int getBlockSize();

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getOverviewHeight(int, int)

         */

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

        /**

         * Returns true if supersampling operation is supported by this provider, i.e if 

         * a request greater than 1:1 will have a response.

         * @return

         */

        public boolean isSupersamplingSupported() {

                return true;

        }

        /**

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

                NoDataRmfSerializer noDataSerializer = new NoDataRmfSerializer(new DefaultNoData(noData, RasterLibrary.NODATATYPE_LAYER));

                ColorInterpretationRmfSerializer colorInterpSerializer = new ColorInterpretationRmfSerializer();

                ProjectionRmfSerializer projectionRmfSerializer = new ProjectionRmfSerializer();

                manager.addClient(geoInfoSerializer);

                manager.addClient(colorTableSerializer);

                manager.addClient(noDataSerializer);

                manager.addClient(colorInterpSerializer);

                manager.addClient(projectionRmfSerializer);

                manager.read(null);

                manager.removeAllClients();

                if (colorTableSerializer.getResult() != null)

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

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

                        noData = ((DefaultNoData) noDataSerializer.getResult()).getValue();

                        noDataEnabled = (((DefaultNoData) noDataSerializer.getResult()).getType() != RasterLibrary.NODATATYPE_DISABLED);

                }

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

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

                        setColorInterpretation(ci);

                        if (ci.getBand(DataStoreColorInterpretation.ALPHA_BAND) != -1)

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

                }

                if (projectionRmfSerializer.getResult() != null)

                        wktProjection = RasterLocator.getManager().getCRSUtils().convertIProjectionToWkt((IProjection) projectionRmfSerializer.getResult());

        }

        /**

         * Obtiene el n?nero 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;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.RasterDataSet#getPixelSizeX()

         */

        public double getPixelSizeX() {

                return externalTransformation.getScaleX();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.RasterDataSet#getPixelSizeY()

         */

        public double getPixelSizeY() {

                return externalTransformation.getScaleY();

        }

        /**

         * Obtiene el valor NoData asociado al raster. Si hay un valor en el fichero

         * RMF se devuelve este, sino se buscar? en la cabecera del raster o metadatos de

         * este. Si finalmente no encuentra ninguno se devuelve el valor por defecto

         * definido en la libreria.

         * @return

         */

        public double getNoDataValue() {

                return noData;

        }

        /**

         * Pone el valor original de noData. Primero lo consulta del valor del metadata

         * y luego del RMF.

         */

        public void resetNoDataValue() {

                /**

                 * Intentamos recuperar el valor del metadatas, en caso de no encontrarlo le

                 * asignamos el noData por defecto

                 */

                noDataEnabled = false;

                do {

                        if (getMetadata() == null) {

                                noData = RasterLibrary.defaultNoDataValue;

                                break;

                        }

                        if (getMetadata().getNoDataValue().length == 0) {

                                noData = RasterLibrary.defaultNoDataValue;

                                break;

                        }

                        noData = getMetadata().getNoDataValue()[0];

                        noDataEnabled = getMetadata().isNoDataEnabled();

                } while (false);

                try {

                        DefaultNoData noDataObject = (DefaultNoData) loadObjectFromRmf(DefaultNoData.class, null);

                        if (noDataObject != null) {

                                if (noDataObject.getType() > 0)

                                        noData = noDataObject.getValue();

                                noDataEnabled = (noDataObject.getType() > 0);

                        }

                } catch (RmfSerializerException e) {

                }

        }

        /**

         * Establece el valor del NoData

         * @param value

         */

        public void setNoDataValue(double value) {

                noData = value;

                noDataEnabled = true;

        }

        /**

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

        }

        /**

         * Dado unas coordenadas reales, un tama?o de buffer y un tama?o de raster.

         * Si el buffer es de mayor tama?o que el raster (supersampleo) quiere decir que

         * por cada pixel de buffer se repiten varios del raster. Esta funci?n calcula el

         * n?mero de pixels de desplazamiento en X e Y que corresponden al primer pixel del

         * buffer en la esquina superior izquierda. Esto es necesario porque la coordenada

         * solicitada es real y puede no caer sobre un pixel completo. Este calculo es

         * util cuando un cliente quiere supersamplear sobre un buffer y que no se lo haga

         * el driver autom?ticamente.

         * @param dWorldTLX Coordenada real X superior izquierda

         * @param dWorldTLY Coordenada real Y superior izquierda

         * @param dWorldBRX Coordenada real X inferior derecha

         * @param dWorldBRY Coordenada real Y inferior derecha

         * @param nWidth Ancho del raster

         * @param nHeight Alto del raster

         * @param bufWidth Ancho del buffer

         * @param bufHeight Alto del buffer

         * @return Array de dos elementos con el desplazamiento en X e Y.

         */

        public double[] calcSteps(double dWorldTLX, double dWorldTLY, double dWorldBRX, double dWorldBRY,

                        double nWidth, double nHeight, int bufWidth, int bufHeight) {

                Point2D p1 = new Point2D.Double(dWorldTLX, dWorldTLY);

                Point2D p2 = new Point2D.Double(dWorldBRX, dWorldBRY);

                Point2D tl = worldToRaster(new Point2D.Double(p1.getX(), p1.getY()));

                Point2D br = worldToRaster(new Point2D.Double(p2.getX(), p2.getY()));

                double wPx = (bufWidth / Math.abs(br.getX() - tl.getX()));

                double hPx = (bufHeight / Math.abs(br.getY() - tl.getY()));

                int x = (int)((tl.getX() > br.getX()) ? Math.floor(br.getX()) : Math.floor(tl.getX()));

                int y = (int)((tl.getY() > br.getY()) ? Math.floor(br.getY()) : Math.floor(tl.getY()));

                double a = (tl.getX() > br.getX()) ? (Math.abs(br.getX() - x)) : (Math.abs(tl.getX() - x));

                double b = (tl.getY() > br.getY()) ? (Math.abs(br.getY() - y)) : (Math.abs(tl.getY() - y));

                                double stpX = (int)((a * bufWidth) / Math.abs(br.getX() - tl.getX()));

                double stpY = (int)((b * bufHeight) / Math.abs(br.getY() - tl.getY()));

                return new double[]{stpX, stpY, wPx, hPx};

        }

        /**

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

         */

        public void setParam(DataStoreProviderServices provServices, DataStoreParameters param) {

                if(param instanceof RasterDataParameters)

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

                this.param = param;

                this.storeServices = provServices;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getOverviewWidth(int, int)

         */

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

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#selectSubdataset()

         */

        public void selectSubdataset() {}

        /**

         * Selects the subdataset. This method will select

         * the rmf file. 

         */

        protected void selectSubdataset(String subdataset) {

                selectedSubdatasetID = subdataset;

                getRmfBlocksManager().setPath(getRMFFile());

        }

        /**

         * Obtiene el gestor de ficheros RMF

         * @return RmfBloksManager

         */

        public RmfBlocksManager getRmfBlocksManager() {

                String fileRMF = getRMFFile();

                if (rmfBlocksManager == null || fileRMF.compareTo(rmfBlocksManager.getPath()) != 0) {

                        rmfBlocksManager = new RmfBlocksManager(fileRMF);

                }

                return rmfBlocksManager;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getRMFFile()

         */

        public String getRMFFile() {

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

                return fileUtil.getNameWithoutExtension(getURI()) + tail;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#isInside(java.awt.geom.Point2D)

         */

        public boolean isInside(Point2D p){

                //Realizamos los calculos solo si el punto est? 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;

        }

        /**

         * Devuelve si el RasterDataSet tiene el valor noData activo

         * @return the noDataEnabled

         */

        public boolean isNoDataEnabled() {

                return noDataEnabled;

        }

        /**

         * Define si el RasterDataSet tiene el valor noData activo

         * @param noDataEnabled the noDataEnabled to set

         */

        public void setNoDataEnabled(boolean noDataEnabled) {

                this.noDataEnabled = noDataEnabled;

        }

        /**

         * Devuelve si el Dataset es reproyectable

         * @return

         */

        public boolean isReproyectable() {

                return false;

        }

        public String getWktProjection() {

                return wktProjection;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#saveObjectToRmf(java.lang.Class, java.lang.Object)

         */

        @SuppressWarnings("unchecked")

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

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

         */

        @SuppressWarnings("unchecked")

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

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#loadObjectFromRmf(java.lang.Class, java.lang.Object)

         */

        @SuppressWarnings("unchecked")

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

                return loadObjectFromRmfFile(getRmfBlocksManager(), class1, value);

        }

        /**

         * Carga un objeto del fichero RMF especificado por parametro

         * @param file

         * @param class1

         * @param value

         * @return

         * @throws RmfSerializerException

         */

        @SuppressWarnings("unchecked")

        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

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

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#getColorTable()

         */

        public ColorTable getColorTable() {

                return colorTable;

        }

        /**

         * Define el objeto paleta. Si se define null quiere decir que no tiene paleta

         * para su visualizaci?n.

         * @param value

         */

        public void setColorTable(ColorTable value) {

                colorTable = value;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#getTransparency()

         */

        public Transparency getTransparency() {

                return transparency;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getMetadata()

         */

        public DataStoreMetadata getMetadata() {

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#getColorInterpretation()

         */

        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;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.dataset.RasterProvider#getStatistics()

         */

        public Statistics getStatistics() {

                if(stats == null) {

                        stats = new SimpleProviderStatistics(this);

                }

                return stats;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.store.props.Histogramable#getHistogramComputer()

         */

        public HistogramComputer getHistogramComputer() throws HistogramException, InterruptedException {

                if (histogram == null)

                        histogram = new SimpleProviderHistogramComputer(this);

                return histogram;

        }

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

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

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

    /*

     * (non-Javadoc)

     * @see org.gvsig.tools.dispose.impl.AbstractDisposable#doDispose()

     */

    public void doDispose() {

    }

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

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

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

    /**

     * Gets the specific parameter. All of them inherit from RasterStoreParameters

     */

    //public abstract RasterStoreParameters getRasterParameters();

        @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

         */

        public RasterDataParameters getDataParameters() {

                if(getDataStoreParameters() instanceof RasterDataParameters)

                        return (RasterDataParameters)getDataStoreParameters();

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.DataStoreProvider#getChilds()

         */

        @SuppressWarnings("unchecked")

        public Iterator getChilds() {

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.DataStoreProvider#getResource()

         */

        public ResourceProvider getResource() {

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.DataStoreProvider#getSourceId()

         */

        public Object getSourceId() {

                if( this.getDataParameters() instanceof RasterFileStoreParameters)

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

                else

                        return this.getDataParameters().getURI();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.spi.DataStoreProvider#open()

         */

        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 fileName

         * @return

         */

        public String translateFileName(String fileName) {

                return fileName;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getFileSuffix()

         */

        public String getFileSuffix() {

                return getURIOfFirstProvider().substring(getURIOfFirstProvider().lastIndexOf(".") + 1, getURIOfFirstProvider().length());

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getURIOfFirstProvider()

         */

        public String getURIOfFirstProvider() {

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

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getURI()

         */

        public String getURI() {

                return uri;

        }

        public void setFName(String n) {

                uri = n;

        }

        public long getFileSize() {

                return fileSize;

        }

        public void setFileSize(long sz) {

                fileSize = sz;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getProjection()

         */

        public IProjection getProjection() {

                return proj;

        }

        public void setProjection(IProjection p) {

                proj = p;

        }

        protected long getTime() {

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

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.RasterDataSet#setAffineTransform(java.awt.geom.AffineTransform)

         */

        public void setAffineTransform(AffineTransform t) {

                externalTransformation = (AffineTransform) t.clone();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.RasterDataSet#getAffineTransform()

         */

        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.

         * @return devuelve true si tiene fichero rmf asociado y false si no lo tiene.

         */

        public void resetAffineTransform() {

                externalTransformation.setToIdentity();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.fmap.dal.coverage.dataset.RasterDataSet#getOwnAffineTransform()

         */

        public AffineTransform getOwnAffineTransform() {

                return ownTransformation;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getInfoByPoint(double, double)

         */

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

                return null;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#setTileServer(java.lang.Class)

         */

        public void setTileServer(Class<?> tileServer) {

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getTileSize()

         */

        public int[] getTileSize(int level) {

                return new int[]{0, 0};

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#isRasterEnclosed()

         */

        public boolean isRasterEnclosed() {

                return false;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getOpenParameters()

         */

        public String getOpenParameters() {

                return param.getDataStoreName();

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getSourceType()

         */

        public int getSourceType() {

                if(getOpenParameters().startsWith("PG:host"))

                        return RasterDataStore.POSTGIS;

                if(getOpenParameters().startsWith("http:") || getOpenParameters().startsWith("https:"))

                        return RasterDataStore.REMOTE;

                return RasterDataStore.FILE;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getTimeSerials()

         */

        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;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#setTimeSerials(org.gvsig.fmap.dal.coverage.store.props.TimeSerials)

         */

        public void setTimeSerials(TimeSeries serialInfo) throws RmfSerializerException {

                this.serialInfo = serialInfo;

                saveObjectToRmf(TimeSeries.class, serialInfo);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.impl.provider.RasterProvider#getFileSizeByProvider()

         */

        public long[] getFileSizeByProvider() {

                return new long[]{getFileSize()};

        }