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.security.NoSuchAlgorithmException;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

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

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

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

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;

import org.gvsig.tools.task.TaskStatus;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Base class for all raster providers. 

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

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

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

        }

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

                return false;

        }

        public boolean isTimeSupported() {

                return false;

        }

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

        /**

         * 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 the set of data selected in the {@link RasterQuery}

         * @param q

         * @return

         * @throws RasterDriverException 

         * @throws ProcessInterruptedException 

         */

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

                DefaultRasterQuery q = (DefaultRasterQuery)query;

                if( q.getType() == DefaultRasterQuery.TYPE_ENTIRE || 

                        q.getType() == DefaultRasterQuery.TYPE_PX_SIZE || 

                        q.getType() == DefaultRasterQuery.TYPE_PX) {

                        return getWindow(q.getPixelX(), q.getPixelY(), q.getPixelW(), q.getPixelH(), 

                                        q.getBandList(), q.getBuffer(), q.getTaskStatus());

                }

                if(q.getType() == DefaultRasterQuery.TYPE_COORDS_SIZE) {

                        return getWindow(q.getBBox(), q.getBufWidth(), q.getBufHeight(), 

                                        q.getBandList(), q.getBuffer(), q.isAdjustToExtent(), q.getTaskStatus());

                }

                if(q.getType() == DefaultRasterQuery.TYPE_COORDS) {

                        if(q.getBBox() == null)

                                return getWindow(q.getX(), q.getY(), q.getW(), q.getH(), 

                                                q.getBandList(), q.getBuffer(), q.isAdjustToExtent(), q.getTaskStatus());

                        else

                                return getWindow(q.getBBox(), q.getBandList(), q.getBuffer(), q.getTaskStatus());

                }

                if(q.getType() == DefaultRasterQuery.TYPE_COORDS_SIZE_TILED) {

                        getWindow(q.getBBox(), q.getBufWidth(), q.getBufHeight(), 

                                        q.getBandList(), q.getTileListener(), q.getTaskStatus());

                }

                return null;

        }

        /**

         * 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, TaskStatus taskStatus) 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, TaskStatus status) 

                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, TaskStatus status) 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, TaskStatus status) 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, 

                        BandList bandList, Buffer rasterBuf, TaskStatus status)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();

        /**

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

        }

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

        }

        public double getPixelSizeX() {

                return externalTransformation.getScaleX();

        }

        public double getPixelSizeY() {

                return externalTransformation.getScaleY();

        }

        public NoData getNoDataValue() {

                if(noData == null) {

                        noData = RasterLocator.getManager().getDataStructFactory().createNoData(null, null, getRMFFile(), getBandCount());

                        noData.setDataType(getDataType()[0]);

                }

                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;

        }

        /**

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

        }

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

        }

        /**

         * Obtiene el gestor de ficheros RMF

         * @return RmfBloksManager

         */

        public RmfBlocksManager getRmfBlocksManager() {

                String fileRMF = getRMFFile();

                if(fileRMF != null) {

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

                                rmfBlocksManager = new RmfBlocksManager(fileRMF);

                        }

                }

                return rmfBlocksManager;

        }

        public String getRMFFile() {

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

                File rmfFolder = (getDataParameters() != null && getDataParameters() instanceof RasterDataParameters) ? 

                                                ((RasterDataParameters)getDataParameters()).getRMFFolder() : 

                                                null;

                String fileName = getURI();

                if(fileName.contains(File.separator)) {

                        if(!fileName.endsWith(File.separator)) {

                                fileName = fileName.substring(fileName.lastIndexOf(File.separator) + 1);

                                fileName = fileUtil.getNameWithoutExtension(fileName);

                        }

                }

                if(rmfFolder == null) {

                        if(getURI().contains(File.separator)) {

                                if(!getURI().endsWith(File.separator)) {

                                        String folder = getURI().substring(0, getURI().lastIndexOf(fileName));

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

                                                ((RasterDataParameters)getDataParameters()).setRMFFolder(new File(folder));

                                }

                        }

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

                } else {

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

                }

        }

        protected String getRMFFileForRemoteServices(String layerName) {

                String md5 = "";

                try {

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

                } 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� 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

         */

        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 {

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

        }

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

        }

        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;

        }

        /*

         * (non-Javadoc)

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

         */

        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

         */

        public RasterDataParameters getDataParameters() {

                if(getDataStoreParameters() instanceof RasterDataParameters)

                        return (RasterDataParameters)getDataStoreParameters();

                return null;

        }

        @SuppressWarnings("unchecked")

        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 fileName

         * @return

         */

        public String translateFileName(String fileName) {

                return fileName;

        }

        public String getFileSuffix() {

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

        }

        public String getURIOfFirstProvider() {

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

        }

        public String getURI() {

                return uri;

        }

        public void setFName(String n) {

                uri = n;

        }

        /**

         * Gets the size of the file if exists in Bytes

         * @return

         */

        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.

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

         */

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

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

                        return RasterDataStore.POSTGIS;

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

                        return RasterDataStore.REMOTE;

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

                //For providers with one file

                return new String[]{getURIOfFirstProvider()};

        }

        public int[] getBandCountByProvider() {

                return new int[]{getBandCount()};

        }

        public int getInternalProviderCount() {

                return 1;

        }

        public RasterProvider getInternalProvider(int i) {

                return this;

        }

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

                //Do nothing

        }

        public void removeFile(String 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.

         */

        @SuppressWarnings("unchecked")

        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.

         */

        @SuppressWarnings("unchecked")

        public Collection getTimes(Interval interval) {

                return null;

        }

        /**

         * Gets the list of geo points associated to this provider

         * @return

         */

        public GeoPointList getGeoPointList() {

                return geoPointList;

        }

        /**

         * Sets the list of geo points associated to this provider

         */

        public void setGeoPointList(GeoPointList geoPointList) {

                this.geoPointList = geoPointList;

        }

        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;

        }

}