Application: gvSIG desktop » gvSIG raster

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.raster.wcs.app.wcsclient.layer;

import java.awt.Dimension;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.HashMap;

import java.util.List;

import javax.print.attribute.PrintRequestAttributeSet;

import org.cresques.cts.IProjection;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataParameters;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.coverage.grid.RasterFilter;

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

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

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

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

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

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

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

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.spi.DataManagerProviderServices;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.Tiling;

import org.gvsig.raster.fmap.layers.DefaultFLyrRaster;

import org.gvsig.raster.fmap.layers.IRasterLayerActions;

import org.gvsig.raster.fmap.layers.NotAvailableStateException;

import org.gvsig.raster.util.CancelTaskImpl;

import org.gvsig.raster.wcs.io.WCSDataParameters;

import org.gvsig.raster.wcs.io.WCSProvider;

import org.gvsig.raster.wcs.io.WCSServerExplorer;

import org.gvsig.raster.wcs.io.WCSServerExplorerParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.task.Cancellable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Class for the WCS layer.

 *

 * Capa para el WCS.

 *

 * Las capas WCS son tileadas para descargarlas del servidor. Esto quiere decir que

 * est?n formadas por multiples ficheros raster. Por esto la fuente de datos raster (IRasterDatasource)

 * de la capa FLyrWCS es un objeto de tipo CompositeDataset. Este objeto est? compuesto por un array

 * bidimensional de MultiRasterDataset. Cada uno de los MultiRasterDataset corresponde con un tile

 * salvado en disco. Estos MultiRasterDataset se crean cada vez que se repinta ya que en WCS a cada

 * zoom varian los ficheros fuente. La secuencia de creaci?n de un CompositeDataset ser?a la siguiente:

 * <UL>

 * <LI>Se hace una petici?n de dibujado por parte del usuario llamando al m?todo draw de FLyrWCS</LI>

 * <LI>Se tilea la petici?n</LI>

 * <LI>Cada tile se dibuja abriendo una FLyrRaster para ese tile</LI>

 * <LI>Si es el primer dibujado se guarda una referencia en la capa WCS a las propiedades de renderizado, orden de bandas,

 * transparencia, filtros aplicados, ...</LI>

 * <LI>Si no es el primer dibujado se asignan las propiedades de renderizado cuya referencia se guarda en la capa WCS</LI>

 * <LI>Se guarda el MultiRasterDataset de cada tile</LI>

 * <LI>Al acabar todos los tiles creamos un CompositeDataset con los MultiRasterDataset de todos los tiles</LI>

 * <LI>Asignamos a la capa la referencia de las propiedades de renderizado que tenemos almacenadas. De esta forma si hay

 * alguna modificaci?n desde el cuadro de propiedades ser? efectiva sobre los tiles que se dibujan.</LI>

 * </UL>

 *

 * @author jaume - jaume.dominguez@iver.es

 */

@SuppressWarnings("deprecation")

public class FLyrWCS extends DefaultFLyrRaster {

    private static final int             MAX_RETRY_TIMES           = 5;

    private static final GeometryManager geomManager               = GeometryLocator.getGeometryManager();

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

    private boolean                                          isPrinting                = false;

    private boolean                                          mustTileDraw              = false;

    private int                                                  maxTileDrawWidth          = 1023;

    private int                                                         maxTileDrawHeight         = 1023;

    private final int                                          maxTilePrintWidth         = 1023;

    private final int                                          maxTilePrintHeight        = 1023;

    private boolean                                                 firstLoad                 = false;

    private Envelope                                         fullEnvelope              = null;

    private int                          callCount;

    private RasterManager                rManager                  = RasterLocator.getManager();

    private boolean                      deleteCache               = false;

    @SuppressWarnings("unused")

    private class MyCancellable implements ICancellable {

        private Cancellable original;

        public MyCancellable(Cancellable cancelOriginal) {

            this.original = cancelOriginal;

        }

        public boolean isCanceled() {

            return original.isCanceled();

        }

        public Object getID() {

            return this;

        }

    }

    public FLyrWCS() {

        super();

        this.updateDrawVersion();

        try {

            enableAwake();

        } catch (NotAvailableStateException e) {

            logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

        }

    }

    public FLyrWCS(DataStoreParameters dataStoreParameters) throws Exception {

        this();

        //Create the explorer and connect

        DataManager dataManager = DALLocator.getDataManager();

        WCSServerExplorerParameters explorerParams = (WCSServerExplorerParameters)

        dataManager.createServerExplorerParameters(WCSProvider.NAME);

        explorerParams.setHost((String)dataStoreParameters.getDynValue("uri"));

        WCSServerExplorer wmsServerExplorer =

            (WCSServerExplorer) dataManager.openServerExplorer(WCSProvider.NAME, explorerParams);

        wmsServerExplorer.connect(null);

        wmsServerExplorer.getCoverageList();

        //Set the parameters

        setParameters((WCSDataParameters)dataStoreParameters);

        setExplorer(wmsServerExplorer);

    }

    public static DataStore createDataStore(String host, IProjection srs) throws InitializeException {

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

        RasterDataParameters params = null;

        try {

            params = (RasterDataParameters)dataman.createServerExplorerParameters(WCSProvider.NAME);

        } catch (InitializeException e) {

            return null;

        } catch (ProviderNotRegisteredException e) {

            return null;

        }

        URI uriHost;

        try {

            uriHost = new URI(host);

        } catch (URISyntaxException e1) {

            throw new InitializeException(e1);

        }

        params.setURI(uriHost);

        params.setSRS(srs);

        try {

            return dataman.openStore(params.getDataStoreName(), params);

        } catch (ValidateDataParametersException e) {

            throw new InitializeException(e);

        } catch (ProviderNotRegisteredException e) {

            throw new InitializeException(e);

        }

    }

    public void setDataStore(DataStore dataStore) throws LoadLayerException {

        this.dataStore = (RasterDataStore) dataStore;

        try {

            if(this.dataStore.isOpen())

                enableOpen();

        } catch (NotAvailableStateException e) {

            logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

        }

        setProjection(this.dataStore.getProjection());

    }

    public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale) throws ReadException {

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

                SimpleTaskStatus taskStatus = new RasterTaskStatus("Drawing " + getName() + "...", cancel);

                manager.add(taskStatus);

                taskStatus.setAutoremove(true);

        if(!firstLoad) {

            try {

                initFilters();

                try {

                                        if(!isOpen())

                                                enableOpen();

                                } catch (NotAvailableStateException e) {

                                        throw new ReadException("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), e);

                                }

            } catch (FilePaletteException e) {

                logger.error(e.getMessage(), this, e);

            }

            firstLoad = true;

        }

        callCount = 0;

        enableStopped();

        if(recalcLevel) {

                        double pixelSize = viewPort.getEnvelope().getLength(0) / (double)viewPort.getImageWidth();

                        zoomLevel = dataStore.getNearestLevel(pixelSize);

                }

                recalcLevel = true;

        if (isWithinScale(scale)) {

            if(mustTileDraw) {

                Point2D p = viewPort.getOffset();

                Rectangle r = new Rectangle((int) p.getX(), (int) p.getY(), viewPort.getImageWidth(), viewPort.getImageHeight());

                Tiling tiles = new Tiling(maxTileDrawWidth, maxTileDrawHeight, r);

                tiles.setAffineTransform((AffineTransform) viewPort.getAffineTransform().clone());

                for (int tileNr = 0; tileNr < tiles.getNumTiles(); tileNr++) {

                    // drawing part

                    try {

                        ViewPort vp = tiles.getTileViewPort(viewPort, tileNr);

                        drawTile(g, vp, taskStatus, scale);

                    } catch (LoadLayerException e) {

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

                    } catch (NoninvertibleTransformException e) {

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

                    }

                }

            } else {

                try {

                    drawTile(g, viewPort, taskStatus, scale);

                } catch (LoadLayerException e) {

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

                }

            }

        }

        disableStopped();

        /*Runtime r = Runtime.getRuntime();

                System.err.println("********************WCS**********************");

                System.err.println("Memoria Total: " + (r.totalMemory() / 1024) +"KB");

                System.err.println("Memoria Usada: " + ((r.totalMemory() - r.freeMemory()) / 1024) +"KB");

                System.err.println("Memoria Libre: " + (r.freeMemory() / 1024) +"KB");

                System.err.println("Memoria MaxMemory: " + (r.maxMemory() / 1024) +"KB");

                System.err.println("*********************************************");*/

    }

    /**

     * This is the method used to draw a tile in a WCS mosaic layer.

     * @throws LoadLayerException

     * @throws ReadDriverException

     * @return true when a tile has been painted

     */

    private void drawTile(Graphics2D g, ViewPort vp, SimpleTaskStatus taskStatus, double scale) throws LoadLayerException, ReadException {

        callCount++;

        // Compute the query geometry

        // 1. Check if it is within borders

        Envelope envelope = getFullEnvelope();

        Envelope vpEnv = vp.getAdjustedExtent();

        if (!vpEnv.intersects(envelope)) {

            return;

        }

        // 2. Compute extent to be requested.

        Rectangle2D bBox = new Rectangle2D.Double();

        Rectangle2D.intersect(getRectable2DFromEnvelope(vpEnv),

            getRectable2DFromEnvelope(envelope), bBox);

        // 3. Compute size in pixels

        double scalex = vp.getAffineTransform().getScaleX();

        double scaley = vp.getAffineTransform().getScaleY();

        int wImg = (int) Math.ceil(Math.abs(bBox.getWidth() * scalex) + 1);

        int hImg = (int) Math.ceil(Math.abs(bBox.getHeight() * scaley) + 1);

        Dimension sz = new Dimension(wImg, hImg);

        if ((wImg <= 0) || (hImg <= 0)) {

            return;

        }

        try {

            //Rectangle2D extent = new Rectangle2D.Double();

            //Rectangle2D.Double vpExtent = this.getRectable2DFromEnvelope(vpEnv);

            //Rectangle2D.intersect(vpExtent, bBox, extent);

            Extent ex = rManager.getDataStructFactory().createExtent(

                vp.getAdjustedEnvelope().getMinimum(0),

                vp.getAdjustedEnvelope().getMaximum(1),

                vp.getAdjustedEnvelope().getMaximum(0),

                vp.getAdjustedEnvelope().getMinimum(1));

            ViewPortData vpData = rManager.getDataStructFactory().createViewPortData(vp.getProjection(), ex, sz );

            vpData.setMat(vp.getAffineTransform());

            vpData.setDPI((int)vp.getDPI());

            try {

                getParameters().setExtent(bBox);

                getParameters().setWidth(wImg);

                getParameters().setHeight(hImg);

                if(getDataStore().getParameters() instanceof WCSDataParameters) {

                                        getRender().draw(g, vpData, taskStatus);

                } else {

                        Envelope adjustedExtent = vp.getAdjustedExtent();

                                        Extent e = rManager.getDataStructFactory().createExtent(adjustedExtent.getLowerCorner().getX(),

                                                        adjustedExtent.getUpperCorner().getY(), adjustedExtent.getUpperCorner().getX(),

                                                        adjustedExtent.getLowerCorner().getY());

                                        ViewPortData vp2 = rManager.getDataStructFactory().createViewPortData(vp.getProjection(), e, vp.getImageSize() );

                                        vp2.setMat(vp.getAffineTransform());

                                        vp2.setDPI((int)vp.getDPI());

                                        getParameters().setExtent(ex.toRectangle2D());

                                        getRender().drawTiledService(g, vp2, vp.getImageSize(), taskStatus);

                }

            /*} catch (RasterDriverException e) {

                    setAvailable(false);

                                JOptionPane.showMessageDialog(null, "Problems drawing this layer:" + e.getMessage(), Messages.getText("Error"), JOptionPane.ERROR_MESSAGE);

                                logger.info("Problems drawing this layer:" + e.getMessage(), e);*/

            } catch (ProcessInterruptedException e) {

            } catch (QueryException e) {

                    throw new RemoteServiceException("Problems drawing this layer: " + e.getMessage(), e);

                        } finally {

                    taskStatus.terminate();

            }

        } catch (RemoteServiceException e) {

            if (!taskStatus.isCancellationRequested()) {

                if (callCount < MAX_RETRY_TIMES) {

                    logger.warn("\n[ FLyrWCS.drawFixedSize() ]  Failed in trying " + callCount + "/" + MAX_RETRY_TIMES + ")\n"); // mess code

                    drawTile(g, vp, taskStatus, scale);

                } else {

                    if (!isPrinting) {

                        this.setVisible(false);

                    }

                    throw new LoadLayerException(getName(), e);

                }

            }

        }

        callCount--;

        return;

    }

    /**

     * <p>

     * Gets the max resolution allowed by the coverage. Requesting a higher resolution

     * than this value does not cause any error, but the info responsed is just an

     * interpolation. <br>

     * </p>

     *

     * <p>

     * In exchange for obtaining a greater file and without additional information,

     * we can easily fit it into the View. <br>

     * </p>

     *

     * <p>

     * Obtiene la resoluci?n m?xima soportada por la cobertura. La petici?n

     * de una resoluci?n superior a la soportada no provoca ning?n error, aunque

     * la informaci?n obtenida s?lo es una mera interpolaci?n de informaci?n. <br>

     * </p>

     *

     * <p>

     * A cambio de obtener un archivo mayor y sin informaci?n adicional, podemos

     * f?cilmente acoplarlo a la vista. <br>

     * </p>

     *

     * @return double

     */

    public Point2D getMaxResolution() {

        return getExplorer().getMaxResolution(getName());

    }

    private Rectangle2D.Double getRectable2DFromEnvelope(Envelope env) {

        return new Rectangle2D.Double(env.getMinimum(0), env.getMinimum(1), env

            .getLength(0), env.getLength(1));

    }

    /**

     * Gets the explorer

     * @return

     */

    public WCSServerExplorer getExplorer() {

            try {

                        return (WCSServerExplorer)getDataStore().getExplorer();

                } catch (ValidateDataParametersException e) {

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

                } catch (DataException e) {

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

                }

            return null;

    }

    /**

     * Calcula el contenido del fichero de georreferenciaci?n de una imagen.

     * @param bBox Tama?o y posici?n de la imagen (en coordenadas de usuario)

     * @param sz Tama?o de la imagen en pixeles.

     * @return el 'WorldFile', como String.

     * @throws IOException

     */

    public String getDataWorldFile(Rectangle2D bBox, Dimension sz) throws IOException {

        StringBuffer data = new StringBuffer();

        data.append((bBox.getMaxX() - bBox.getMinX()) / (sz.getWidth() - 1) + "\n");

        data.append("0.0\n");

        data.append("0.0\n");

        data.append("-" + (bBox.getMaxY() - bBox.getMinY()) / (sz.getHeight() - 1) + "\n");

        data.append("" + bBox.getMinX() + "\n");

        data.append("" + bBox.getMaxY() + "\n");

        return data.toString();

    }

    public FLayer cloneLayer() throws Exception {

        RasterDataStore  ds = dataStore.cloneDataStore();

        FLyrWCS layer = new FLyrWCS();

        layer.setName(getParameters().getCoverageName());

        layer.setOpenRasterStore(ds);

        layer.fullEnvelope = fullEnvelope;

        layer.setExplorer(getExplorer());

        List<RasterFilter> filters = getRender().getFilterList().getStatusCloned();

        //Hacemos una copia de las bandas a renderizar

        ColorInterpretation ci = getRender().getRenderColorInterpretation();

                if(ci != null) {

                        layer.getRender().setRenderColorInterpretation(ci.cloneColorInterpretation());

                }

        //Asignamos el entorno

        if(layer.getRender().getFilterList() == null)

            layer.getRender().setFilterList(RasterLocator.getManager().createEmptyFilterList(getRender().getFilterList().getInitDataType()));

        layer.getRender().getFilterList().setEnv(getRender().getFilterList().getEnv());

        layer.getRender().getFilterList().setStatus(filters);

        // Asignamos los valores noData del original

        layer.setNoDataValue(getNoDataValue());

        if(dataStore.getNoDataValue().isDefined())

                layer.setNoDataTransparent(true);

        layer.enableOpen();

        return layer;

    }

    public Transparency getRenderTransparency() {

        return getRender().getRenderingTransparency();

    }

    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, PrintRequestAttributeSet properties) throws ReadException {

        if (isVisible() && isWithinScale(scale)){

            draw(null, g, viewPort, cancel, scale);

        }

    }

    /**

     * Inserta la extensi?n total de la capa en la proyeccion original.

     *

     * @param fullExtent

     *            Rect?ngulo.

     */

    public void setFullEnvelope(Envelope envelope) {

        Envelope cur = this.getFullEnvelope();

        if (cur == envelope) {

            return;

        }

        if (cur != null && cur.equals(envelope)) {

            return;

        }

        this.fullEnvelope = envelope;

        this.updateDrawVersion();

    }

    /**

     * Sets the layer's full extent.

     *

     * Establece la extensi?n m?xima de la capa.

     *

     * @param rect

     */

    public void setFullExtent(Rectangle2D fullExtent) {

        this.setFullEnvelope(this.getEnvelopeFromRectable2D(fullExtent));

    }

    private Envelope getEnvelopeFromRectable2D(Rectangle2D rect) {

        try {

            return geomManager.createEnvelope(rect.getMinX(), rect.getMinY(),

                rect.getMaxX(), rect.getMaxY(),

                SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e) {

            logger.error("Error creating the envelope", e);

        }

        return null;

    }

    public HashMap<String, Object> getProperties() {

        HashMap<String, Object> info = new HashMap<String, Object>();

        try {

            info.put("name", getName());

            info.put("selectedLayers", getParameters().getCoverageName());

            info.put("host", getParameters().getURI());

            info.put("crs", getParameters().getSRSCode());

            info.put("format", getParameters().getFormat());

            info.put("time", getParameters().getTime());

            return info;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

    public int[] getTileSize() {

        int[] size = {maxTileDrawWidth, maxTileDrawHeight};

        return size;

    }

    public String getTocImageIcon() {

        return "ico-WCS-Layer";

    }

    public boolean isTiled() {

        return mustTileDraw;

    }

        public boolean isRemote() {

                return true;

        }

    @Override

    public DynObjectSet getInfo(Point p, double tolerance, Cancellable cancel,

        boolean fast) throws LoadLayerException, DataException {

        //try {

        ViewPort viewPort = getMapContext().getViewPort();

        Point tiledPoint = new Point((int) p.getX() % maxTilePrintWidth, (int) p.getY() % maxTilePrintHeight);

        Rectangle rect = new Rectangle(0, 0, viewPort.getImageWidth() - 1, viewPort.getImageHeight() - 1);

        Tiling tiles = new Tiling(maxTilePrintWidth, maxTilePrintHeight, rect);

        tiles.setAffineTransform((AffineTransform) viewPort.getAffineTransform().clone());

        int nCols = tiles.getNumCols();

        int col = (int) p.getX() / maxTilePrintWidth;

        int row = (int) p.getY() / maxTilePrintHeight;

        int tileIndex = (row * nCols) + col;

        ViewPort vp = null;

        try {

            vp = tiles.getTileViewPort(viewPort, tileIndex);

        } catch (NoninvertibleTransformException e1) {

            throw new LoadLayerException("", e1);

        }

        getParameters().setExtent(this.getRectable2DFromEnvelope(vp.getAdjustedExtent()));

        getParameters().setWidth(vp.getImageWidth());

        getParameters().setHeight(vp.getImageHeight());

        CancelTaskImpl cancellable = new CancelTaskImpl(cancel);

        getParameters().setCancellable(cancellable);

        String fInfo;

        try {

            fInfo = getDataStore().getInfoByPoint(tiledPoint.getX(), tiledPoint.getY(), cancellable);

        } catch (InfoByPointException e) {

            throw new LoadLayerException("Error in getInfoByPoint", e);

        }

        return new DynObjectSetWCSInfo(fInfo, DynObjectSetWCSInfo.TYPE_TEXT);

    }

        @Override

        public String getFileFormat() {

                return "WCS";

        }

    public boolean isActionEnabled(int action) {

        switch (action) {

        case IRasterLayerActions.ZOOM_PIXEL_RESOLUTION:

        case IRasterLayerActions.FLYRASTER_BAR_TOOLS:

        case IRasterLayerActions.BANDS_FILE_LIST:

        case IRasterLayerActions.GEOLOCATION:

        case IRasterLayerActions.PANSHARPENING:

        case IRasterLayerActions.SAVE_COLORINTERP:

            return false;

        case IRasterLayerActions.BANDS_RGB:

        case IRasterLayerActions.REMOTE_ACTIONS:

        case IRasterLayerActions.COLOR_TABLE:

            return true;

        }

        return super.isActionEnabled(action);

    }

    public boolean overviewsSupport() {

        return false;

    }

    public org.gvsig.fmap.dal.coverage.datastruct.Extent getFullRasterExtent() {

        Envelope env = getFullEnvelope();

        double minx = env.getMinimum(0);

        double miny = env.getMinimum(1);

        double maxx = env.getMaximum(0);

        double maxy = env.getMaximum(1);

        Point2D ul = new Point2D.Double(minx, maxy);

        Point2D ur = new Point2D.Double(maxx, maxy);

        Point2D ll = new Point2D.Double(minx, miny);

        Point2D lr = new Point2D.Double(maxx, miny);

        return rManager.getDataStructFactory().createExtent(ul, lr, ur, ll);

    }

    public WCSDataParameters getParameters() {

        /*if(params == null) {

            DataManager datamanager = DALLocator.getDataManager();

            WCSServerExplorerParameters explorerParams = null;

            try {

                explorerParams = (WCSServerExplorerParameters) datamanager.createServerExplorerParameters(WCSServerExplorer.NAME);

                explorerParams.setHost("");

                explorer = (WCSServerExplorer) datamanager.createServerExplorer(explorerParams);

                DataStoreParameters parameters = explorer.getStoreParameters();

                if(parameters instanceof WCSDataParameters) {

                    params = (WCSDataParameters) parameters;

                }

            } catch (InitializeException e) {

            } catch (ProviderNotRegisteredException e) {

            } catch (ValidateDataParametersException e) {

            }

        }*/

        return getWCSParameters(getDataStore().getParameters());

    }

    /**

     * Gets <code>WCSDataParameters</code>

     * @param parameters

     * @return

     */

    private WCSDataParameters getWCSParameters(DataStoreParameters parameters) {

            WCSDataParameters params = null;

            if(parameters instanceof WCSDataParameters) {

                        params = (WCSDataParameters) parameters;

                }

                if(parameters instanceof TileDataParameters) {

                        DataParameters p = ((TileDataParameters) parameters).getDataParameters();

                        if(p instanceof WCSDataParameters) {

                                params = (WCSDataParameters) p;

                        }

                }

                return params;

    }

    /**

     * Sets the explorer

     * @param explorer

     */

    public void setExplorer(WCSServerExplorer explorer) {

            if(getDataStore() != null)

                    getDataStore().setExplorer(explorer);

    }

    /**

         * Assigns the flag to delete this layer from the cache

         * @param selected

         */

        public void deleteCache(boolean deleteCache) {

                this.deleteCache = deleteCache;

        }

    /**

     * Sets the data store parameters

     * @param params

     * @throws InitializeException

     */

    public void setParameters(DataStoreParameters params) throws InitializeException {

        if(params instanceof TileDataParameters) {

                        ((TileDataParameters)params).deleteCache(deleteCache);

                }

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

        try {

            DataStore dStore = dataman.openStore(params.getDataStoreName(), params);

            this.setDataStore(dStore);

                        if(params instanceof WCSDataParameters) {

                                this.setName((String)((WCSDataParameters)params).getURI());

                        }

                        if(params instanceof TileDataParameters) {

                                DataParameters p = ((TileDataParameters) params).getDataParameters();

                                if(p instanceof WCSDataParameters) {

                                        this.setName((String)((WCSDataParameters) p).getURI());

                                }

                        }

        } catch (ValidateDataParametersException e) {

            throw new InitializeException(e);

        } catch (ProviderNotRegisteredException e) {

            throw new InitializeException(e);

        } catch (LoadLayerException e) {

            throw new InitializeException(e);

        }

    }

        /*@Override

        public void loadFromState(PersistentState state)

        throws PersistenceException {

                String host = state.getString("host");

                getParameters();

                ((WCSServerExplorerParameters)explorer.getParameters()).setHost(host);

                if(!explorer.isHostReachable()) {

                        loadDataStore = false;

                        super.loadFromState(state);

                        return;

                }

                try {

                        explorer.connect(new CancelTaskImpl());

                        explorer.getCoverageList();

                } catch (Exception e) {

                        loadDataStore = false;

                        super.loadFromState(state);

                        return;

                }

                loadDataStore = true;

                super.loadFromState(state);

                params = getDataStore().getParameters();

                this.fullEnvelope = (Envelope) state.get("fullEnvelope");

                try {

                        if(this.dataStore.isOpen())

                                enableOpen();

                } catch (NotAvailableStateException e) {

                        logger.error("Fallo el estado de open. Closed=" + isClosed() + " Awake=" + isAwake(), this, e);

                }

                //getParameters().setCoverageName((String)state.get("name"));

        }*/

    /*@Override

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set("fullEnvelope", this.fullEnvelope);

                state.set("host", getParameters().getURI());

                state.set("name", getName());

        }*/

        /*public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition(PERSISTENT_NAME);

                if( definition == null ) {

                        if (manager.getDefinition(FLyrDefault.class) == null) {

                                FLyrDefault.registerPersistent();

                        }

                        definition = manager.addDefinition(

                                        FLyrWCS.class,

                                        PERSISTENT_NAME,

                                        PERSISTENT_DESCRIPTION,

                                        null,

                                        null

                        );

                        definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, "FLyrDefault");

                }

                DefaultFLyrRaster.registerPersistence(definition);

                definition.addDynFieldObject("fullEnvelope").setClassOfValue(Envelope.class).setMandatory(false);

                definition.addDynFieldString("host").setMandatory(false);

                definition.addDynFieldString("name").setMandatory(false);

        }*/

        public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.getDefinition("FLyrWCS_Persistent");

                if( definition == null ) {

                        if (manager.getDefinition(DefaultFLyrRaster.class) == null) {

                                DefaultFLyrRaster.registerPersistence();

                        }

                        definition = manager.addDefinition(

                                        FLyrWCS.class,

                                        "FLyrWCS_Persistent",

                                        "FLyrWCS Persistent Definition",

                                        null,

                                        null

                        );

                        definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE, DefaultFLyrRaster.PERSISTENT_NAME);

                }

                DefaultFLyrRaster.registerPersistence(definition);

        }

}