Application: gvSIG desktop

/* 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 com.iver.cit.gvsig.fmap.layers;

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

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.swing.ImageIcon;

import org.cresques.cts.IProjection;

import org.cresques.filter.RasterFilterStack;

import org.cresques.io.data.Grid;

import org.cresques.io.data.RasterBuf;

import org.cresques.io.datastruct.Statistic;

import org.cresques.px.Extent;

import com.hardcode.driverManager.Driver;

import com.hardcode.driverManager.DriverLoadException;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.MapControl;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.drivers.GeorreferencedRasterDriver;

import com.iver.cit.gvsig.fmap.drivers.RasterDriver;

import com.iver.cit.gvsig.fmap.layers.layerOperations.StringXMLItem;

import com.iver.cit.gvsig.fmap.layers.layerOperations.XMLItem;

import com.iver.utiles.DoubleUtilities;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * Clase b?sica de capa raster.

 *

 * @author Vicente Caballero Navarro

 */

public class FLyrRaster extends FLyrDefault implements RasterOperations {

        private RasterAdapter                                 source;

        boolean                                                         isPrinting = false;

        boolean                                                         mustTileDraw = false;

        boolean                                                         mustTilePrint = true;

        private int                                                        maxTileDrawWidth = 200;

        private int                                                 maxTileDrawHeight = 200;

        int                                                                 maxTilePrintWidth = 1500;

        int                                                                 maxTilePrintHeight = 1500;

        private StatusRasterInterface                status = null;

        private boolean                                                firstLoad = false;

        private int                                                 posX = 0, posY = 0;

        private double                                                 posXWC = 0, posYWC = 0;

        private int                                                 r = 0, g = 0, b = 0;

        private boolean                                                removeRasterFlag = true;

        /**

         * Devuelve el RasterAdapter de la capa.

         *

         * @return RasterAdapter.

         */

        public RasterAdapter getSource() {

                return source;

        }

        /**

         *Redefine wakeUp de FLyrDefault

         */

        public void wakeUp(){

                /*setName(getName());

                setProjection(getProjection());

                try {

                        load();

                } catch (DriverIOException e) {

                        e.printStackTrace();

                }*/

        }

        /**

         * Inserta el RasterAdapter.

         *

         * @param ra RasterAdapter.

         */

        public void setSource(RasterAdapter ra) {

                source = ra;

        }

        /**

         * Devuelve la pila de filtros aplicada sobre  la capa raster.

         *

         * @return RasterFilterStack.

         */

        public RasterFilterStack getFilterStack(){

                return source.getFilterStack();

        }

        /**

         * Asignar el estado del raster

         * @param status

         */

        public void setStatus(StatusRasterInterface status){

                this.status = status;

        }

        /**

         * Asigna la pila de filtros aplicada al raster

         * @return

         */

        public void setFilterStack(RasterFilterStack stack){

                source.setFilterStack(stack);

        }

        /**

         * Obtiene el estado del raster

         * @return

         */

        public StatusRasterInterface getStatus(){

                return this.status;

        }

        /**

         * Asigna la posici?n en la que se ha hecho click al mostrar

         * informaci?n del raster.

         * @param x        Posici?n en X

         * @param y        Posici?n en Y

         */

        public void setPos(int x, int y){

                this.posX = x;

                this.posY = y;

        }

        /**

         * Asigna la posici?n en coordenadas del mundo real en la que se ha

         * hecho click al mostrar informaci?n del raster.

         * @param x        Posici?n en X

         * @param y        Posici?n en Y

         */

        public void setPosWC(double x, double y){

                this.posXWC = x;

                this.posYWC = y;

        }

        /**

         * Asigna RGB en la posici?n en la que se ha

         * hecho click al mostrar informaci?n del raster.

         * @param r        valor de rojo

         * @param g        valor de verde

         * @param b        valor de azul

         */

        public void setRGB(int r, int g, int b){

                this.r = r;

                this.g = g;

                this.b = b;

        }

        /*

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#load()

         */

        public void load() throws DriverIOException {

                ((RasterFileAdapter) source).start();

                ((RasterFileAdapter) source).setTransparency(getTransparency());

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.LayerOperations#draw(java.awt.image.BufferedImage,

         *                 java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort,

         *                 com.iver.utiles.swing.threads.Cancellable)

         */

        public void draw(BufferedImage image, Graphics2D g, ViewPort vp,

                Cancellable cancel,double scale) throws DriverException {

                if (isWithinScale(scale)){

                try {

                        if(status!=null && firstLoad){

                                if(mustTileDraw){

                                        Point2D p = vp.getOffset();

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

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

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

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

                                                // drawing part

                                                try {

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

                                                        //g.setClip(tiles.getClip(tileNr).x, tiles.getClip(tileNr).y, tiles.getClip(tileNr).width - 5, tiles.getClip(tileNr).height);

                                                        ((RasterFileAdapter) source).draw(image, g, vport, cancel);

                                                } catch (NoninvertibleTransformException e) {

                                                        e.printStackTrace();

                                                }

                                        }

                                }else

                                        ((RasterFileAdapter) source).draw(image, g, vp, cancel);

                                status.applyStatus(this);

                                firstLoad = false;

                        }

                        if(mustTileDraw){

                                Point2D p = vp.getOffset();

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

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

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

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

                                        // drawing part

                                        try {

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

                                                ((RasterFileAdapter) source).draw(image, g, vport, cancel);

                                        } catch (NoninvertibleTransformException e) {

                                                e.printStackTrace();

                                        }

                                }

                        }else

                                ((RasterFileAdapter) source).draw(image, g, vp, cancel);

                } catch (DriverIOException e) {

                        throw new DriverException(e);

                }

                if (getVirtualLayers() != null) {

                        getVirtualLayers().draw(image, g, vp, cancel,scale);

                }

                }

        }

        /**

         * Inserta la proyecci?n.

         *

         * @param proj Proyecci?n.

         */

        public void setProjection(IProjection proj) {

                super.setProjection(proj);

                if (source != null && source.getDriver() != null && source.getDriver() instanceof GeorreferencedRasterDriver) {

                        GeorreferencedRasterDriver geoDrv = (GeorreferencedRasterDriver) source.getDriver();

                        if (geoDrv.getProjection() == null) {

                                geoDrv.setProjection(proj);

                        }

                }

        }

        public void setTransparency(int trans) {

                super.setTransparency(trans);

                ((RasterFileAdapter) source).setTransparency(trans);

                if (getMapContext() != null){

                        getMapContext().invalidate();

                }

        }

        public int getTransparency() {

                return ((RasterFileAdapter) source).getTransparency();

        }

        /*

         * @see com.iver.cit.gvsig.fmap.layers.LayerOperations#getFullExtent()

         */

        public Rectangle2D getFullExtent() throws DriverException {

                return ((RasterFileAdapter) source).getFullExtent();

        }

        /**

         * Obtiene el valor del pixel del Image en la posici?n x,y

         * @param x Posici?n x

         * @param y Posici?n y

         * @return valor de pixel

         */

        public int[] getPixel(double wcx, double wcy){

                return ((RasterFileAdapter) source).getPixel(wcx, wcy);

        }

        public double getMaxX(){

                try {

                        return this.getFullExtent().getMaxX();

                }catch(DriverException e){

                        return 0D;

                }

        }

        public double getMaxY(){

                try {

                        return this.getFullExtent().getMaxY();

                }catch(DriverException e){

                        return 0D;

                }

        }

        public double getMinX(){

                try {

                        return this.getFullExtent().getMinX();

                }catch(DriverException e){

                        return 0D;

                }

        }

        public double getMinY(){

                try {

                        return this.getFullExtent().getMinY();

                }catch(DriverException e){

                        return 0D;

                }

        }

        public double getHeight(){

                try {

                        return this.getFullExtent().getHeight();

                }catch(DriverException e){

                        return 0D;

                }

        }

        public double getWidth(){

                try {

                        return this.getFullExtent().getWidth();

                }catch(DriverException e){

                        return 0D;

                }

        }

        /* (non-Javadoc)

         * @deprecated. See String getInfo(Point p) throws DriverException

         * @see com.iver.cit.gvsig.fmap.layers.layerOperations.InfoByPoint#queryByPoint(java.awt.Point)

         */

        public String queryByPoint(Point p) throws DriverException {

                String data = "<file:"+normalizeAsXMLTag(getName())+">\n";

                ArrayList attr = source.getAttributes();

                data += "  <raster\n";

                data += "    File=\""+((RasterFileAdapter) source).getFile()+"\"\n";

                for (int i=0; i<attr.size(); i++) {

                        Object [] a = (Object []) attr.get(i);

                        data += "    "+a[0].toString()+"=";

                        if (a[1].toString() instanceof String)

                                data += "\""+a[1].toString()+"\"\n";

                        else

                                data += a[1].toString()+"\n";

                }

                data += "    Point=\""+posX+" , "+posY+"\"\n";

                data += "    Point_WC=\""+posXWC+" , "+posYWC+"\"\n";

                data += "    RGB=\""+r+", "+g+", "+b+"\"\n";

                data += "  />\n";

                data += "</file:"+normalizeAsXMLTag(getName())+">\n";

                //System.out.println(data);

                return data;

        }

        public XMLItem[] getInfo(Point p, double tolerance, Cancellable cancel) throws DriverException {

                Point2D pReal = getMapContext().getViewPort().toMapPoint(p);

                Point2D px = null;

                if(        pReal.getX() > this.getMinX() &&

                        pReal.getX() < this.getMaxX() &&

                        pReal.getY() > this.getMinY() &&

                        pReal.getY() < this.getMaxY()){

                        ArrayList attr = source.getAttributes();

                        int w = 0, h = 0;

                        for (int i=0; i<attr.size(); i++) {

                                Object [] a = (Object []) attr.get(i);

                                if(a[0].toString().equals("Width"))

                                        w = ((Integer)a[1]).intValue();

                                if(a[0].toString().equals("Height"))

                                        h = ((Integer)a[1]).intValue();

                        }

                        px = new Point2D.Double();

                        px.setLocation( ((pReal.getX() - this.getMinX()) * w) / getWidth(),

                                                        ((this.getMaxY() - pReal.getY()) * h) / getHeight());

                }

                int[] rgb = this.getPixel(pReal.getX(), pReal.getY());

                StringXMLItem[] item = new StringXMLItem[1];

                String data = "<file:"+normalizeAsXMLTag(getName())+">\n";

                data += "  <raster\n";

                data += "    View_Point=\""+p.getX()+" , "+p.getY()+"\"\n";

                data += "    World_Point=\""+DoubleUtilities.format(pReal.getX(), 5)+" , "+DoubleUtilities.format(pReal.getY(), 5)+"\"\n";

                if(px == null)

                        data += "    Pixel_Point=\"Out\"\n";

                else{

                        data += "    Pixel_Point=\""+(int)px.getX()+" , "+(int)px.getY()+"\"\n";

                        data += "    Band_Value=\"";

                        for(int i = 0; i < this.getSource().getNumBands(); i++){

                                Object pxData = ((RasterDriver)this.getSource().getDriver()).getData((int)px.getX(), (int)px.getY(), i);

                                if(pxData != null){

                                        if(this.getSource().getDataType() >= 0 && this.getSource().getDataType() <= 3)

                                                        data += ((Integer)pxData).intValue()+"  ";

                                        if(this.getSource().getDataType() >= 4)

                                                        data += ((Float)pxData).floatValue()+"  ";

                                        if(this.getSource().getDataType() >= 5)

                                                        data += ((Double)pxData).doubleValue()+"  ";

                                }

                        }

                        data += "\"\n";

                }

                data += "    RGB=\""+rgb[1]+"  "+rgb[2]+"  "+rgb[3]+"\"\n";

                data += "  />\n";

                data += "</file:"+normalizeAsXMLTag(getName())+">\n";

                item[0] = new StringXMLItem(data, this);

                return item;

        }

        /**

         * Filters a string for being suitable as XML Tag, erasing

         * all not alphabetic or numeric characters.

         * @param s

         * @return string normalized

         */

        public String normalizeAsXMLTag(String s) {

                return s.replaceAll("[^a-zA-Z0-9]","");

        }

        /**

         * Obtiene atributos a partir de un georasterfile

         * @return

         */

        public ArrayList getAttributes() {

                return source.getAttributes();

        }

        /**

         * @throws XMLException

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#getProperties()

         */

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = super.getXMLEntity();

                if (source instanceof RasterFileAdapter) {

                        xml.putProperty("file", ((RasterFileAdapter) source).getFile());

                }

                xml.putProperty("driverName", getSource().getDriver().getName());

                //Si no hay ning?n Status aplicamos el StatusLayerRaster que se usa por defecto

                if(status == null)

                        status = new StatusLayerRaster();

                status.getXMLEntity(xml, true, this);

                return xml;

        }

        public void setXMLEntity03(XMLEntity xml)

        throws XMLException {

                super.setXMLEntity(xml);

                try {

                        Driver d = LayerFactory.getDM().getDriver(

                                xml.getStringProperty("driverName"));

                        File f = new File(xml.getStringProperty("file"));

                        RasterAdapter adapter = new RasterFileAdapter(f);

                        adapter.setDriver(d);

                        setSource(adapter);

                        // Para notificar al adapter-driver cual es la proyecci?n.

                        setProjection(super.getProjection());

                } catch (DriverLoadException e) {

                        throw new XMLException(e);

                }

        }

        public void setXMLEntity(XMLEntity xml)

        throws XMLException {

                super.setXMLEntity(xml);

                try {

                        Driver d = LayerFactory.getDM().getDriver(

                                xml.getStringProperty("driverName"));

                        File f = new File(xml.getStringProperty("file"));

                        RasterAdapter adapter = new RasterFileAdapter(f);

                        adapter.setDriver(d);

                        setSource(adapter);

                        // Para notificar al adapter-driver cual es la proyecci?n.

                        setProjection(super.getProjection());

                        //Inicializamos la clase a la que se usa por defecto para

                        //compatibilidad con proyectos antiguos

                        String claseStr = StatusLayerRaster.defaultClass;

                        if (xml.contains("raster.class")) {

                                claseStr = xml.getStringProperty("raster.class");

                        }

                        if(status!=null)

                                status.setXMLEntity(xml, this);

                        else{

                                //Cuando cargamos un proyecto

                                if(claseStr!=null && !claseStr.equals("")){

                                        try{

                                                Class clase = Class.forName(claseStr);

                                                Constructor constr = clase.getConstructor(null);

                                                status = (StatusRasterInterface)constr.newInstance(null);

                                                if(status!=null)

                                                        status.setXMLEntity(xml, this);

                                        }catch(ClassNotFoundException exc){

                                                exc.printStackTrace();

                                        }catch(InstantiationException exc){

                                                exc.printStackTrace();

                                        }catch(IllegalAccessException exc){

                                                exc.printStackTrace();

                                        }catch(NoSuchMethodException exc){

                                                exc.printStackTrace();

                                        }catch(InvocationTargetException exc){

                                                exc.printStackTrace();

                                        }

                                }

                        }

                        firstLoad = true;

                } catch (DriverLoadException e) {

                        throw new XMLException(e);

                }

        }

        /* (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.operations.Cancellable)

         */

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, PrintRequestAttributeSet propeties)

                throws DriverException {

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

                isPrinting = true;

                if (!mustTilePrint) {

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

                } else {

                // Para no pedir imagenes demasiado grandes, vamos

                // a hacer lo mismo que hace EcwFile: chunkear.

                // Llamamos a drawView con cuadraditos m?s peque?os

                // del BufferedImage ni caso, cuando se imprime viene con null

                        Tiling tiles = new Tiling(maxTilePrintWidth, maxTilePrintHeight, g.getClipRect());

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

                        //Si es la primera lectura salvamos los valores de m?ximo y m?nimo para la aplicaci?n

                        //de realce si la imagen es de 16 bits.

                        Statistic stats = getSource().getFilterStack().getStats();

                        if(stats != null)

                                stats.history.add(stats.new History(getName(), stats.minBandValue, stats.maxBandValue, stats.secondMinBandValue, stats.secondMaxBandValue));

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

                            // Parte que dibuja

                            try {

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

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

                                } catch (NoninvertibleTransformException e) {

                                        // TODO Auto-generated catch block

                                        e.printStackTrace();

                                }

                }

                        if(stats != null){

                                getSource().getFilterStack().getStats().history.clear();

                                stats = getSource().getFilterStack().getStats();

                        }

                }

            isPrinting = false;

                }

        }

        public void _print(Graphics2D g, ViewPort viewPort, Cancellable cancel,double scale)

                throws DriverException {

                // Para no pedir imagenes demasiado grandes, vamos

                // a hacer lo mismo que hace EcwFile: chunkear.

                // Llamamos a drawView con cuadraditos m?s peque?os

                // del BufferedImage ni caso, cuando se imprime viene con null

                int numW, numH;

                int stepX, stepY;

                int xProv, yProv, wProv, hProv;

                double xProvD, yProvD, wProvD, hProvD;

                int A = 1500;

                int H = 1500;

                int altoAux, anchoAux;

                AffineTransform mat = (AffineTransform) viewPort.getAffineTransform().clone();

                // Vamos a hacerlo en trozos de AxH

                Rectangle r = g.getClipRect();

                numW = (int) (r.width) / A;

                numH = (int) (r.height) / H;

                double[] srcPts = new double[8];

                double[] dstPts= new double[8];

                yProv = (int) r.y;

                for (stepY=0; stepY < numH+1; stepY++)

                {

                        if ((yProv + H) > r.getMaxY())

                                altoAux = (int) r.getMaxY() - yProv;

                        else

                                altoAux = H;

                        xProv = (int) r.x;

                        for (stepX=0; stepX < numW+1; stepX++)

                        {

                                    if ((xProv + A) > r.getMaxX())

                                            anchoAux = (int) r.getMaxX() - xProv;

                                    else

                                            anchoAux = A;

                                Rectangle newRect = new Rectangle(xProv, yProv, anchoAux, altoAux);

                                // Parte que dibuja

                                srcPts[0] = xProv;

                                srcPts[1] = yProv;

                                srcPts[2] = xProv + anchoAux+1;

                                srcPts[3] = yProv;

                                srcPts[4] = xProv + anchoAux+1;

                                srcPts[5] = yProv + altoAux+1;

                                srcPts[6] = xProv;

                                srcPts[7] = yProv + altoAux+1;

                                try {

                                                mat.inverseTransform(srcPts, 0, dstPts, 0, 4);

                                        Rectangle2D.Double rectCuadricula = new Rectangle2D.Double(

                                                        dstPts[0], dstPts[1],

                                                                dstPts[2] - dstPts[0], dstPts[5]-dstPts[3]);

                                        Extent extent = new Extent(rectCuadricula);

                                        Dimension tam = new Dimension(anchoAux+1, altoAux+1);

                                        ViewPort vp = viewPort.cloneViewPort();

                                        vp.setImageSize(tam);

                                        vp.setExtent(rectCuadricula);

                                        vp.setAffineTransform(mat);

                                        // ViewPortData vp = new ViewPortData(getProjection(), extent, tam);

                                        // vp.setMat(mat);

                                        // rasterList.draw(g2, vp);

                                        /*System.out.println("FLyrRaster.print(): fila "+stepX+" de "

                                                + numW + " , col "+stepY+" de " + numH +

                                                "\n, Extent = "+vp.getExtent() + " imageSize: "

                                                + tam);*/

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

                                        } catch (NoninvertibleTransformException e) {

                                                // TODO Auto-generated catch block

                                                e.printStackTrace();

                                        }

                                // Fin parte que dibuja

                                        xProv = xProv + A;

                        }

                        yProv = yProv + H;

                }

        }

        /**

         * A?ade un fichero a la capa raster

         * @param fileName Nombre del fichero

         */

        public void addFiles(String fileName){

                ((RasterFileAdapter) source).addFile(fileName);

        }

        /**

         * Elimina un fichero a la capa raster

         * @param fileName Nombre del fichero

         */

        public void delFile(String fileName){

                ((RasterFileAdapter) source).delFile(fileName);

        }

        /* (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.layers.RasterOperations#setBand(int, int)

         */

        public void setBand(int flag, int nBand) {

                this.getSource().setBand(flag, nBand);

        }

        /**

         * Borra de la lista de listeners el que se pasa como par?metro.

         *

         * @param o LayerListener a borrar.

         *

         * @return True si ha sido correcto el borrado del Listener.

         */

        public boolean removeLayerListener(LayerListener o) {

                if(this.isRemoveRasterFlag()){

                        /*try{

                                ((RasterFileAdapter) source).stop();

                        }catch(DriverIOException exc){

                        }*/

                        this.setRemoveRasterFlag(true);

                }

                return super.layerListeners.remove(o);

        }

        /**

         * @return Returns the removeRasterFlag.

         */

        public boolean isRemoveRasterFlag() {

                return removeRasterFlag;

        }

        /**

         * Asigna el valor del flag que dice si destruimos la memoria del raster

         * al eliminarlo del TOC o  no.

         * @param removeRasterFlag The removeRasterFlag to set.

         */

        public void setRemoveRasterFlag(boolean removeRasterFlag) {

                this.removeRasterFlag = removeRasterFlag;

        }

        public ImageIcon getTocImageIcon() {

                return new ImageIcon(MapControl.class.getResource("images/icolayerRaster.PNG"));

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.layers.RasterOperations#getTileSize()

         */

        public int[] getTileSize() {

                int[] size = {maxTileDrawWidth, maxTileDrawHeight};

                return size;

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.layers.RasterOperations#isTiled()

         */

        public boolean isTiled() {

                return mustTileDraw;

        }

        /**

         * Obtiene el flag que dice si la imagen est? o no georreferenciada

         * @return true si est? georreferenciada y false si no lo est?.

         */

        public boolean isGeoreferenced() {

                return getSource().isGeoreferenced();

        }

        /**

         * Obtiene el grid asociado

         * @return grid

         */

        public Grid getGrid(){

                return getSource().getGrid();

        }

        /**

         * Obtiene el tipo de dato de la capa raster

         * @return Entero que representa el tipo de dato de la capa raster.

         */

        public int getDataType() {

                return getSource().getDataType();

        }

        /*

         *  (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.layers.FLayer#cloneLayer()

         */

        public FLayer cloneLayer() throws Exception {

                FLyrRaster clonedLayer = new FLyrRaster();

                File f = new File(getSource().getFiles()[0].getName());

                RasterAdapter adapter = new RasterFileAdapter(f);

                com.hardcode.driverManager.Driver driver = LayerFactory.getDM().getDriver("gvSIG Image Driver");

                adapter.setDriver(driver);

                clonedLayer.setName(getName());

                clonedLayer.setVisible(isVisible());

                clonedLayer.setSource(adapter);

                clonedLayer.setProjection(getProjection());

                clonedLayer.setXMLEntity(getXMLEntity());

                clonedLayer.load();

                return clonedLayer;

        }

        /**

         * Set data buffer to create a memory raster driver

         * @param buf data buffer

         */

        public void setBuffer(RasterBuf buf){

                source.setBuffer(buf);

        }

        /**

         * Set extent to create a memory raster driver

         * @param ext Extent

         */

        public void setExtent(Extent ext){

                source.setExtent(ext);

        }

}