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

import java.awt.Image;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.Hashtable;

import java.util.List;

import java.util.Vector;

import javax.swing.ImageIcon;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.metadata.MetadataLocator;

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

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

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

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

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

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.RemoteRasterProvider;

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

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

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

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

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

import org.gvsig.raster.util.DefaultProviderServices;

import org.gvsig.raster.wms.io.downloader.WMSTileServer;

import org.gvsig.remoteclient.utils.Utilities;

import org.gvsig.remoteclient.wms.WMSStatus;

import org.gvsig.tools.ToolsLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase que representa al driver de acceso a datos de wms.

 *

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

 */

public class WMSProvider extends AbstractRasterProvider implements RemoteRasterProvider {

        public static String                NAME                     = "Wms Store";

        public static String                DESCRIPTION              = "Wms Raster file";

        public static final String          METADATA_DEFINITION_NAME = "WmsStore";

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

        private static final int            FIXED_SIZE               = 800;

        private Extent                      viewRequest              = null;

        private static Hashtable<String, WMSConnector>    

                                            drivers                  = new Hashtable<String, WMSConnector> ();

        private boolean                     open                     = false;

        private DataStoreTransparency       fileTransparency         = null;

        private final int                                        minTilePrintWidth        = 12;

        private final int                                        minTilePrintHeight       = 12;

        //The out size depends on the last request

        private int                         lastWidthRequest         = 0;

        private int                         lastHeightRequest        = 0;

        //Only for fixed size. Complete extent and FIXED_SIZE in long side

        private File                        fileLayerPixelSize       = null;

        private File                        lastRequest              = null;

        private AbstractRasterProvider       lastRequestProvider      = null;

        public static void register() {

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

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

                        dataman.registerStoreProvider(NAME,

                                        WMSProvider.class, WMSDataParametersImpl.class);

                }

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

                        dataman.registerExplorerProvider(WMSServerExplorer.NAME, WMSServerExplorer.class, WMSServerExplorerParameters.class);

                }

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        public WMSProvider() throws NotSupportedExtensionException {

                super();

        }

        public void registerTileProviderFormats(Class<RasterProvider> c) {

        }

        /**

         * Constructor. Abre el dataset.

         * @param proj Proyecci?n

         * @param fName Nombre del fichero

         * @throws NotSupportedExtensionException

         */

        public WMSProvider(String params) throws InitializeException {

                super(params);

                if(params instanceof String) {

                        WMSDataParameters p = new WMSDataParametersImpl();

                        p.setURI((String)params);

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

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

        public WMSProvider(WMSDataParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(

                                                MetadataLocator.getMetadataManager().getDefinition(

                                                                DataStore.METADATA_DEFINITION_NAME)));

                init(params, storeServices);

        }

        /**

         * Gets the connector from the URL

         * @return

         * @throws RemoteServiceException

         */

        public WMSConnector getConnector() throws RemoteServiceException {

                WMSDataParameters p = (WMSDataParameters)parameters;

                URL url = null;

                try {

                        url = new URL(p.getURI());

                } catch (Exception e) {

                        throw new RemoteServiceException("Malformed URL",e);

                }

                try {

                        return WMSProvider.getConnectorFromURL(url, false);

                } catch (IOException e) {

                        throw new RemoteServiceException("Error getting the connector",e);

                }

        }

        /**

         * Crea las referencias al fichero y carga

         * las estructuras con la informaci?n y los metadatos.

         * @param proj Proyecci?n

         * @param param Parametros de carga

         * @throws NotSupportedExtensionException

         */

        public void init (DataStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                setParam(storeServices, params);

                setDataType(new int[]{Buffer.TYPE_BYTE, Buffer.TYPE_BYTE, Buffer.TYPE_BYTE});

                bandCount = 3;

                open = true;

                try {

                        loadInitialInfo();

                } catch (RasterDriverException e) {

                        throw new InitializeException(e.getMessage(), e);

                }

        }

        /**

         * When a WMS provider is opened the information of data type, number of bands and transparency 

         * is not available. Only after the first time a raster has been downloaded it can be know.

         * @param newDataType

         * @param buf

         * @param bandList

         * @return

         * @throws RasterDriverException 

         */

        private void loadInitialInfo() throws RasterDriverException {

                WMSDataParametersImpl p = (WMSDataParametersImpl)parameters;

                Extent ext = getExtent();

                Rectangle2D bBox = ext.toRectangle2D();

                int w = 0;

                int h = 0;

                if(ext.width() > ext.height()) {

                        w = 200;

                        h = (int)((ext.height() * w) / ext.width());

                } else {

                        h = 200;

                        w = (int)((ext.width() * h) / ext.height());

                }

                p.setWidth(w);

                p.setHeight(h);

                p.setExtent(bBox);

                if(p.getSRSCode() != null) {

                        try {

                                IProjection proj = CRSFactory.getCRS(p.getSRSCode());

                                setProjection(proj, false);

                        } catch (Exception e) {

                        }

                }

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                lastRequest = downloadFile(wmsStatus, ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), w, h);

                AbstractRasterProvider driver;

                try {

                        driver = DefaultProviderServices.loadProvider(lastRequest);

                        setDataType(driver.getDataType());

                        bandCount = driver.getBandCount();

                        if(bandCount > 3) {

                                getColorInterpretation().setColorInterpValue(3, DataStoreColorInterpretation.ALPHA_BAND);

                                getTransparency().setTransparencyBand(3);

                        }

                        setColorTable(driver.getColorTable());

                        driver.close();

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("", e);

                }

        }

        public static final WMSConnector getConnectorFromURL(URL url, boolean updating) throws IOException {

                WMSConnector drv = null;

                if(!updating) {

                        drv = (WMSConnector) drivers.get(url.toString());

                } else {

                        if(drivers.get(url.toString()) != null)

                                drivers.remove(url.toString());

                }

                if (drv == null) {

                        drv = new WMSConnector(url);

                        drivers.put(url.toString(), drv);

                }

                return drv;

        }

        /**

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

         * color por banda

         * @return

         */

        public ColorInterpretation getColorInterpretation() {

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

                        ColorInterpretation colorInterpretation = new DataStoreColorInterpretation(getBandCount());

                        if(getBandCount() == 1 || getBandCount() == 2)

                                colorInterpretation = DataStoreColorInterpretation.createGrayInterpretation();

                        if(getBandCount() == 3)

                                colorInterpretation = DataStoreColorInterpretation.createRGBInterpretation();

                        if(getBandCount() == 4)

                                colorInterpretation = DataStoreColorInterpretation.createRGBAInterpretation();

                        setColorInterpretation(colorInterpretation);

                }

                return super.getColorInterpretation();

        }

        public AffineTransform getAffineTransform() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                if(p.isSizeFixed()) {

                        Extent e = getExtent(); // FIXME: it should also be taken from parameters instead of from the full layer extent

                        double psX = e.width() / (p.getWidth() - 1);

                        double psY = -(e.height() / (p.getHeight() - 1));

                        ownTransformation = new AffineTransform(

                                        psX , 

                                        0, 

                                        0, 

                                        psY, 

                                        e.getULX() - (psX / 2),

                                        e.getULY() - (psY / 2));

                } else {

                        Rectangle2D bbox = p.getExtent();

                        double psX = bbox.getWidth() / p.getWidth();

                        double psY = -(bbox.getHeight() / p.getHeight());

                        ownTransformation = new AffineTransform(

                                        psX, 

                                        0, 

                                        0, 

                                        psY,

                                        bbox.getX(),

                                        (bbox.getY()+bbox.getHeight())); // FIXME: check for other CRSs such as 4326

                }

                externalTransformation = (AffineTransform) ownTransformation.clone();

                return ownTransformation;

        }

        /**

         * Calcula el extent en coordenadas del mundo real

         * @return Extent

         */

        public Extent getExtent() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                Vector<?> layerNames = Utilities.createVector(p.getLayerQuery(), ",");

                String[] ln = new String[layerNames.size()];

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

                        ln[i] = (String)layerNames.get(i);

                }

                Rectangle2D r = null;

                try {

                        r = getConnector().getLayersExtent(ln, p.getSRSCode());

                        if (r == null) {

                                String latLonID = "EPSG:4326";

                                r = getConnector().getLayersExtent(ln, latLonID);

                                if (r == null) {

                                        r = getConnector().getLayersExtent(ln, "CRS:84");

                                }

                                IProjection reqProj = CRSFactory.getCRS(p.getSRSCode());

                                IProjection latLonProj = CRSFactory.getCRS(latLonID);

                                if ((reqProj != null) && (latLonProj != null)) {

                                        ICoordTrans ct = latLonProj.getCT(reqProj);

                                        Rectangle2D reprojectedRect = ct.convert(r);

                                        r = reprojectedRect;

                                }

                        }

                } catch (RemoteServiceException e) {

                }

                if(r == null)

                        return null;

                return new ExtentImpl(r.getMinX(), r.getMaxY(), r.getMaxX(), r.getMinY());

        }

        public Rectangle2D getLayerExtent(String layerName, String srs) throws RemoteServiceException {

                return getConnector().getLayersExtent(new String[]{layerName}, srs);

        }

        public RasterProvider load() {

                return this;

        }

        public boolean isOpen() {

                return open;

        }

        public void close() {

                open = false;

        }

        public Transparency getTransparency() {

                if(fileTransparency == null)

                        fileTransparency = new DataStoreTransparency(getColorInterpretation());

                return fileTransparency;

        }

        public String translateFileName(String fileName) {

                return fileName;

        }

        public void setView(Extent e) {

                viewRequest = e;

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                return p.getWidth();

        }

        public double getHeight() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                return p.getHeight();

        }

        /**

         * Gets WMS parameters

         * @return

         */

        public WMSDataParameters getParameters() {

                return (WMSDataParameters)parameters;

        }

        public Object readCompleteLine(int line, int band)

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                return null;

        }

        /**

         * When the remote layer has fixed size this method downloads the file and return its reference. 

         * File layer has in the long side FIXED_SIZE pixels and the bounding box is complete. This file could be

         * useful to build an histogram or calculate statistics. This represents a sample of data.

         * @return

         * @throws RasterDriverException

         */

        public File getFileLayer() throws RasterDriverException {

                if(fileLayerPixelSize != null)

                        return fileLayerPixelSize;

                WMSDataParameters p = (WMSDataParameters)parameters;

                Extent e = getExtent();

                Rectangle2D bBox = new Rectangle2D.Double(e.getULX(), e.getLRY(), e.width(), e.height());

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                if(!p.isSizeFixed()) {

                        int w = 0;

                        int h = 0;

                        if(e.width() > e.height()) {

                                w = FIXED_SIZE;

                                h = (int)((e.height() * FIXED_SIZE) / e.width());

                        } else {

                                h = FIXED_SIZE;

                                w = (int)((e.width() * FIXED_SIZE) / e.height());

                        }

                        wmsStatus.setWidth(w);

                        wmsStatus.setHeight(h);

                        fileLayerPixelSize = downloadFile(wmsStatus, e.getULX(), e.getULY(), e.getLRX(), e.getLRY(), w, h);

                } else {

                        fileLayerPixelSize = downloadFile(wmsStatus, e.getULX(), e.getULY(), e.getLRX(), e.getLRY(), 

                                        p.getFixedSize().width, p.getFixedSize().height);

                }

                return fileLayerPixelSize;

        }

        /**

         * Reads a complete block of data and returns an tridimensional array of the right type. This function is useful

         * to read a file very fast without setting a view. In a WMS service when the size is fixed then it will read the

         * entire image but when the source hasn't pixel size it will read a sample of data. This set of data will have

         * the size defined in FIXED_SIZE. 

         * 

         * @param pos Posici?n donde se empieza  a leer

         * @param blockHeight Altura m?xima del bloque leido

         * @return Object que es un array tridimendional del tipo de datos del raster. (Bandas X Filas X Columnas)

         * @throws InvalidSetViewException

         * @throws FileNotOpenException

         * @throws RasterDriverException

         */

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

        throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                File lastFile = getFileLayer();

                BandList bandList = new BandListImpl();

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

                        try {

                                bandList.addBand(new DatasetBandImpl(lastFile.getPath(), pos, Buffer.TYPE_BYTE, 3));

                        } catch (BandNotFoundInListException e1) {

                        }

                }

                bandList.setDrawableBands(new int[]{0, 1, 2});

                try {

                        lastRequestProvider = openLastRequest();

                        return lastRequestProvider.readBlock(pos, blockHeight, scale);

                } catch (ProviderNotRegisteredException exc) {

                        throw new RasterDriverException("Error building GdalDriver", exc);

                } catch (InitializeException exc) {

                        throw new RasterDriverException("Error building GdalDriver", exc);

                }

        }

        public double getLastRequestHeight() throws RasterDriverException {

                if(lastRequestProvider == null) {

                        try {

                                lastRequestProvider = openLastRequest();

                        } catch (ProviderNotRegisteredException e) {

                                throw new RasterDriverException("Error building GdalDriver", e);

                        } catch (InitializeException e) {

                                throw new RasterDriverException("Error building GdalDriver", e);

                        }

                }

                return lastRequestProvider.getHeight();

        }

        public double getLastRequestWidth() throws RasterDriverException {

                if(lastRequestProvider == null) {

                        try {

                                lastRequestProvider = openLastRequest();

                        } catch (ProviderNotRegisteredException e) {

                                throw new RasterDriverException("Error building GdalDriver", e);

                        } catch (InitializeException e) {

                                throw new RasterDriverException("Error building GdalDriver", e);

                        }

                }

                return lastRequestProvider.getWidth();

        }

        public File getLastRequest() {

                return lastRequest;

        }

        public Buffer getBufferLastRequest() throws ProcessInterruptedException, RasterDriverException {

                try {

                        lastRequestProvider = openLastRequest();

                        return getDownloadedRaster(lastRequestProvider);

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (QueryException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }

        /**

         * Opens the last request downloaded

         * @return

         * @throws ProviderNotRegisteredException

         * @throws InitializeException

         * @throws RasterDriverException

         */

        private AbstractRasterProvider openLastRequest() throws ProviderNotRegisteredException, InitializeException, RasterDriverException {

                if(lastRequestProvider != null)

                        lastRequestProvider.close();

                File lastFile = getFileLayer();

                lastRequestProvider = DefaultProviderServices.loadProvider(new File(lastFile.getPath()));

                setColorTable(lastRequestProvider.getColorTable());

                return lastRequestProvider;

        }

        public Object getData(int x, int y, int band)

                throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                return null;

        }

        /**

         * Gets the georeferencing file name form a raster file

         * @param file

         * a raster file

         * @return

         * a georeferencing file

         */

        private String getWorldFile(String file){                

                String worldFile = file;

                int index = file.lastIndexOf(".");

                if (index > 0){                        

                        worldFile = file.substring(0, index) + getExtensionWorldFile();

                }

                return worldFile;

        }

        /**

         * Obtiene la extensi?n del fichero de georreferenciaci?n

         * @return String con la extensi?n del fichero de georreferenciaci?n dependiendo

         * del valor del formato obtenido del servidor. Por defecto asignaremos un .wld

         */

        private String getExtensionWorldFile() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                String extWorldFile = ".wld";

                if(p.getFormat().equals("image/tif") || p.getFormat().equals("image/tiff")) {

                        extWorldFile = ".tfw";

                }

                return extWorldFile;

        }

        public WMSStatus loadWMSStatus(Rectangle2D bBox) {

                WMSDataParameters p = (WMSDataParameters)parameters;

                WMSStatus wmsStatus = new WMSStatus();

                wmsStatus.setLayerNames(Utilities.createVector(p.getLayerQuery(), ","));

                wmsStatus.setSrs(p.getSRSCode());

                wmsStatus.setFormat(p.getFormat());

                wmsStatus.setInfoFormat(p.getInfoFormat());

                List<RemoteWMSStyle> listStyles = p.getStyles();

                Vector<?> v = listStyles != null ? new Vector<RemoteWMSStyle>(listStyles) : null; 

                wmsStatus.setStyles(v);

                wmsStatus.setDimensions(p.getDimensions());

                wmsStatus.setTransparency(p.isWmsTransparent());

                wmsStatus.setOnlineResource((String) p.getOnlineResource().get("GetMap"));

                if(p.isSizeFixed()) {

                        wmsStatus.setExtent(getExtent().toRectangle2D());

                } else

                        wmsStatus.setExtent(bBox);

                wmsStatus.setHeight(p.getHeight());

                wmsStatus.setWidth(p.getWidth());

                IProjection proj = getProjection();

                if(proj != null)

                        wmsStatus.setProjected(proj.isProjected());

                return wmsStatus;

        }

        /**

         * This function downloads the file and creates the georeferencing file

         * @param wmsStatus

         * @param ulx

         * @param uly

         * @param lrx

         * @param lry

         * @param w

         * @param h

         * @return

         * @throws RasterDriverException

         */

        private File downloadFile(WMSStatus wmsStatus, double ulx, double uly, double lrx, double lry, int w, int h) throws RasterDriverException {

                WMSDataParameters p = (WMSDataParameters)parameters;

                try {

                        lastRequest = getConnector().getMap(wmsStatus, ((WMSDataParameters)parameters).getCancellable());

                } catch (RemoteServiceException e) {

                        throw new RasterDriverException(e.getMessage(), e);

                }

                if(lastRequest == null)

                        return null;

                String nameWorldFile = getWorldFile(lastRequest.getPath());

                try {

                        if(p.isSizeFixed()) {

                                Extent e = getExtent();

                                fileUtil.createWorldFile(nameWorldFile, e, p.getWidth(), p.getHeight());

                        } else {

                                fileUtil.createWorldFile(nameWorldFile, new ExtentImpl(ulx, uly, lrx, lry), w, h);

                        }

                } catch (IOException e) {

                        throw new RasterDriverException("Error creating world file", e);

                }

                return lastRequest;

        }

        @Override

        public void loadBuffer(SpiRasterQuery q) 

                        throws ProcessInterruptedException, RasterDriverException {

                Extent bbox = q.getRequestBoundingBox();

                lastWidthRequest = q.getBufWidth();

                lastHeightRequest = q.getBufHeight();

                WMSStatus wmsStatus = loadWMSStatus(bbox.toRectangle2D());

                lastRequest = downloadFile(wmsStatus, 

                                bbox.getULX(), 

                                bbox.getULY(), 

                                bbox.getLRX(), 

                                bbox.getLRY(), 

                                q.getBufWidth(), 

                                q.getBufHeight());

                if (lastRequest == null) {

                        return;

                }

                Buffer b = null;

                try {

                        b = getDownloadedRaster(lastRequest);

                } catch (QueryException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

                q.setBufferResult(b);

        }

        private Buffer getDownloadedRaster(File f) throws ProcessInterruptedException, QueryException, ProviderNotRegisteredException, InitializeException {

                AbstractRasterProvider provider = DefaultProviderServices.loadProvider(new File(f.getPath()));

                setColorTable(provider.getColorTable());

                return getDownloadedRaster(provider);

        }

        private Buffer getDownloadedRaster(AbstractRasterProvider provider) throws ProcessInterruptedException, QueryException, ProviderNotRegisteredException, InitializeException {

                DefaultRasterStore store = new DefaultRasterStore();

                store.setProvider(provider);

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

                q.setAreaOfInterest();

                if(getColorInterpretation() != null)

                        q.setDrawableBands(getColorInterpretation().buildRenderBands());

                if(store.getBandCount() > 3)

                        q.forceARGBRequest();

                else 

                        q.forceRGBRequest();

                Buffer buf = store.query(q);

                store.close();

                return buf;

        }

        /**

         * Assigns the list of bands RGB and read a window of data

         * @param rasterBuf

         * @param bandList

         * @param lastFile

         * @param ulx

         * @param uly

         * @param lrx

         * @param lry

         * @return

         * @throws RasterDriverException

         * @throws ProcessInterruptedException

         */

        /*public Buffer getBuffer(Buffer rasterBuf, BandList bandList, File lastFile, 

                        double ulx, double uly, double lrx, double lry) throws RasterDriverException, ProcessInterruptedException {

                try {

                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

                        String serverName = bandList.getBand(0).getFileName();

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

                                bandList.getBand(i).setFileName(lastFile.getPath());

                        }

                        AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastFile.getPath()));

                        setColorTable(driver.getColorTable());

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

                        q.setAreaOfInterest(new ExtentImpl(ulx, uly, lrx, lry));

                        q.setBandList(bandList);

                        q.setBuffer(rasterBuf);

                        Buffer buf = driver.getDataSet(q);

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

                                bandList.getBand(i).setFileName(serverName);

                        }

                        return buf;

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }*/

        /*public void getWindow(Extent ex, int bufWidth, int bufHeight, 

                        BandList bandList, TileListener listener, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

                Buffer raster = DefaultRasterManager.getInstance().createBuffer(getDataType()[0], bufWidth, bufHeight, 3, true);

                getWindow(ex, bufWidth, bufHeight, bandList, raster, true, null);

                raster.setDataExtent(ex.toRectangle2D());

                TileCacheManager m = TileCacheLocator.getManager();

                org.gvsig.raster.cache.tile.Tile t = m.createTile(-1, 0, 0);

                t.setData(new Object[]{raster});

                t.setUl(new Point2D.Double(ex.getULX(), ex.getULY()));

                t.setLr(new Point2D.Double(ex.getLRX(), ex.getLRY()));

                t.setDownloaderParams("AffineTransform", getAffineTransform());

                t.setDownloaderParams("Tiling", new Boolean(false));

                try {

                        listener.tileReady(t);

                } catch (TileGettingException e) {

                        throw new RasterDriverException("Error throwing a tile", e);

                }

                //listener.nextBuffer(raster, null, new ExtentImpl(minX, minY, maxX, maxY), getAffineTransform(), null, false);

                listener.endReading();

        }*/

        /*public Buffer getWindow(Extent ex, BandList bandList, Buffer rasterBuf, TaskStatus status) 

                throws ProcessInterruptedException, RasterDriverException {

                Rectangle2D bBox = ex.toRectangle2D();

                lastWidthRequest = rasterBuf.getWidth();

                lastHeightRequest = rasterBuf.getHeight();

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                lastRequest = downloadFile(wmsStatus, ex.getULX(), ex.getULY(), ex.getLRX(), ex.getLRY(), rasterBuf.getWidth(), rasterBuf.getHeight());

                if (lastRequest == null) {

                        return rasterBuf;

                }

                try {

                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

                        String serverName = bandList.getBand(0).getFileName();

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

                                bandList.getBand(i).setFileName(lastRequest.getPath());

                        }

                        AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

                        setColorTable(driver.getColorTable());

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

                        q.setAreaOfInterest(ex);

                        q.setBandList(bandList);

                        q.setBuffer(rasterBuf);

                        Buffer buf = driver.getDataSet(q);

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

                                bandList.getBand(i).setFileName(serverName);

                        }

                        driver.close();

                        return buf;

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }*/

        /*public Buffer getWindow(double ulx, double uly, double w, double h, 

                        BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

                Rectangle2D bBox = new Rectangle2D.Double(ulx, uly, w, h);

                lastWidthRequest = rasterBuf.getWidth();

                lastHeightRequest = rasterBuf.getHeight();

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                lastRequest = downloadFile(wmsStatus, ulx, uly, ulx + w, uly - h, rasterBuf.getWidth(), rasterBuf.getHeight());

                if (lastRequest == null) {

                        return rasterBuf;

                }

                try {

                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

                        String serverName = bandList.getBand(0).getFileName();

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

                                bandList.getBand(i).setFileName(lastRequest.getPath());

                        }

                        AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

                        setColorTable(driver.getColorTable());

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

                        q.setAreaOfInterest(ulx, uly, w, h);

                        q.setBandList(bandList);

                        q.setBuffer(rasterBuf);

                        q.setAdjustToExtent(adjustToExtent);

                        Buffer buf = driver.getDataSet(q);

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

                                bandList.getBand(i).setFileName(serverName);

                        }

                        return buf;

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }*/

        /*public Buffer getWindow(Extent extent, int bufWidth, int bufHeight, 

                        BandList bandList, Buffer rasterBuf, boolean adjustToExtent, TaskStatus status) throws ProcessInterruptedException, RasterDriverException {

                Rectangle2D bBox = extent.toRectangle2D();//new Rectangle2D.Double(ulx, lry, Math.abs(lrx - ulx), Math.abs(lry - uly));

                lastWidthRequest = rasterBuf.getWidth();

                lastHeightRequest = rasterBuf.getHeight();

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                lastRequest = downloadFile(wmsStatus, extent.getULX(), extent.getULY(), extent.getLRX(), extent.getLRY(), rasterBuf.getWidth(), rasterBuf.getHeight());

                if (lastRequest == null) {

                        return rasterBuf;

                }

                try {

                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

                        String serverName = bandList.getBand(0).getFileName();

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

                                bandList.getBand(i).setFileName(lastRequest.getPath());

                        }

                        AbstractRasterProvider driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

                        setColorTable(driver.getColorTable());

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

                        q.setAreaOfInterest(extent, bufWidth, bufHeight);

                        q.setBandList(bandList);

                        q.setBuffer(rasterBuf);

                        q.setAdjustToExtent(adjustToExtent);

                        Buffer buf = driver.getDataSet(q);

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

                                bandList.getBand(i).setFileName(serverName);

                        }

                        return buf;

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }*/

//        public Buffer getWindow(int x, int y, 

//                        BandList bandList, Buffer rasterBuf) throws ProcessInterruptedException, RasterDriverException {

//                int w = rasterBuf.getWidth();

//                int h = rasterBuf.getHeight();

//                Point2D p1 = rasterToWorld(new Point2D.Double(x, y));

//                Point2D p2 = rasterToWorld(new Point2D.Double(x + w, y + h));

//                lastWidthRequest = rasterBuf.getWidth();

//                lastHeightRequest = rasterBuf.getHeight();

//                Rectangle2D bBox = new Rectangle2D.Double(p1.getX(), p1.getY(), Math.abs(p1.getX() - p1.getX()), Math.abs(p1.getY() - p2.getY()));

//                WMSStatus wmsStatus = loadWMSStatus(bBox);

//                

//                lastRequest = downloadFile(wmsStatus, p1.getX(), p1.getY(), p2.getX(), p2.getY(), rasterBuf.getWidth(), rasterBuf.getHeight());

//                

//                if (lastRequest == null) {

//                        return rasterBuf;

//                }

//

//                AbstractRasterProvider driver = null;

//                try {

//                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

//                        String serverName = bandList.getBand(0).getFileName();

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

//                                bandList.getBand(i).setFileName(lastRequest.getPath());

//                        }

//                        

//                        driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

//                        Buffer buf = driver.getWindow(0, 0, w, h, bandList, rasterBuf);

//

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

//                                bandList.getBand(i).setFileName(serverName);

//                        }

//                        

//                        return buf;

//                } catch (ProviderNotRegisteredException e) {

//                        throw new RasterDriverException("Error building GdalDriver", e);

//                } catch (InitializeException e) {

//                        throw new RasterDriverException("Error building GdalDriver", e);

//                }

//        }

        /*public Buffer getWindow(int x, int y, int w, int h, 

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

                Point2D p1 = rasterToWorld(new Point2D.Double(x, y));

                Point2D p2 = rasterToWorld(new Point2D.Double(x + w, y + h));

                lastWidthRequest = rasterBuf.getWidth();

                lastHeightRequest = rasterBuf.getHeight();

                Rectangle2D bBox = new Rectangle2D.Double(p1.getX(), p1.getY(), Math.abs(p1.getX() - p1.getX()), Math.abs(p1.getY() - p2.getY()));

                WMSStatus wmsStatus = loadWMSStatus(bBox);

                lastRequest = downloadFile(wmsStatus, p1.getX(), p1.getY(), p2.getX(), p2.getY(), rasterBuf.getWidth(), rasterBuf.getHeight());

                if (lastRequest == null) {

                        return rasterBuf;

                }

                AbstractRasterProvider driver = null;

                try {

                        //El nombre de fichero que ha puesto en el bandList es el del servidor y no el del fichero en disco

                        String serverName = bandList.getBand(0).getFileName();

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

                                bandList.getBand(i).setFileName(lastRequest.getPath());

                        }

                        driver = DefaultProviderServices.loadProvider(new File(lastRequest.getPath()));

                        setColorTable(driver.getColorTable());

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

                        q.setAreaOfInterest(0, 0, w, h);

                        q.setBandList(bandList);

                        q.setBuffer(rasterBuf);

                        Buffer buf = driver.getDataSet(q);

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

                                bandList.getBand(i).setFileName(serverName);

                        }

                        return buf;

                } catch (ProviderNotRegisteredException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                } catch (InitializeException e) {

                        throw new RasterDriverException("Error building GdalDriver", e);

                }

        }*/

        public Image getImageLegend() {

                try {

                        WMSStatus wmsStatus = loadWMSStatus(getExtent().toRectangle2D());

                        wmsStatus.setOnlineResource((String) getParameters().getOnlineResource().get("GetCapabilities"));

                        File file = getConnector().getLegendGraphic(wmsStatus, getParameters().getLayerQuery(), null);

                        Image img = null;

                        if ((file != null) && (file.length() > 0)) {

                                img = new ImageIcon(file.getAbsolutePath()).getImage();

                        }

                        return img;

                } catch (Exception e) {

                        logger.info("Problems in GetLegendGraphic", e);

                }

                return null;

        }

        public int getBlockSize() {

                return 0;

        }

        public void setAffineTransform(AffineTransform t){

        }

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

                return 0;

        }

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

                return 0;

        }

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

                return 0;

        }

        public boolean isOverviewsSupported() {

                return false;

        }

        public boolean isReproyectable() {

                return false;

        }

        public String getProviderName() {

                return NAME;

        }

        public String getName() {

                return this.getParameters().getName();

        }

        public String getFullName() {

                return this.uri;

        }

        /**

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

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

                        getAffineTransform().inverseTransform(pt, p);

                } catch (NoninvertibleTransformException e) {

                        return pt;

                }

                return p;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof WMSProvider) {

                }

        }

        /**

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

         */

        public void setParam(DataStoreProviderServices storeServices, DataStoreParameters param) {

                if(param instanceof WMSDataParameters)

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

                this.param = param;

        }

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

                WMSDataParameters p = (WMSDataParameters)parameters;

                WMSStatus wmsStatus = new WMSStatus();

                wmsStatus.setLayerNames(Utilities.createVector(p.getLayerQuery(), ","));

                wmsStatus.setSrs(p.getSRSCode());

                wmsStatus.setFormat(p.getFormat());

                wmsStatus.setInfoFormat(p.getInfoFormat());

                List<RemoteWMSStyle> listStyles = p.getStyles();

                Vector<?> v = listStyles != null ? new Vector<RemoteWMSStyle>(listStyles) : null;

                wmsStatus.setStyles(v);

                wmsStatus.setDimensions(p.getDimensions());

                wmsStatus.setTransparency(p.isWmsTransparent());

                wmsStatus.setOnlineResource((String) p.getOnlineResource().get("GetMap"));

                wmsStatus.setExtent(bbox.toRectangle2D());

                wmsStatus.setHeight(h);

                wmsStatus.setWidth(w);

                try {

                        return getConnector().getFeatureInfo(wmsStatus, x, y, Integer.MAX_VALUE, cancellable);

                } catch (RemoteServiceException e) {

                        throw new InfoByPointException("Error in getFeatureInfo", e);

                }

        }

        /**

         * Gets the suffix of the downloaded image

         * @return

         */

        public String getFileSuffix() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                String format = p.getFormat();

                if (format == null){

                        return "xml";

                }

                if (format.indexOf("png") >= 0){

                return "png";

                }        

            if (format.indexOf("xml") >= 0){

                return "xml";

            }        

            if (format.indexOf("gif") >= 0){

                return "gif";

            }

            if (format.indexOf("tif") >= 0){

                return "tif";

            }

            if (format.indexOf("bmp") >= 0){

                return "bmp";

            }

            if (format.indexOf("jpg") >= 0

                || format.indexOf("jpeg") >= 0){

                return "jpg";                         

            }

                return "xml";

        }

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new WMSTileServer(store);

                }

                return tileServer;

        }

        public boolean isRasterEnclosed() {

                WMSDataParameters p = (WMSDataParameters)parameters;

                if(p.isSizeFixed()) {

                        return false;

                }

                return true;

        }

        public String getRMFFile() {

                if(lastRequest != null)

                        return fileUtil.getNameWithoutExtension(lastRequest.getAbsolutePath()) + ".rmf";

                return null;

        }

        public HistogramComputer getHistogramComputer() {

                if (histogram == null)

                        histogram = new RemoteStoreHistogram(this);

                return histogram;

        }

}