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;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.cresques.cts.GeoCalc;

import org.cresques.cts.IProjection;

import org.cresques.cts.gt2.CSUTM;

import com.iver.cit.gvsig.fmap.crs.CRSFactory;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.XMLEntity;

/**

 * Clase con atributos de la vista.

 * 050211, jmorell: A?ado los Grados como unidad de mapa.

 *

 * @author Vicente Caballero Navarro

 */

public class ViewPort {

        public static int KILOMETROS = 0;

        public static int METROS = 1;

        public static int CENTIMETRO = 2;

        public static int MILIMETRO = 3;

        public static int MILLAS = 4;

        public static int YARDAS = 5;

        public static int PIES = 6;

        public static int PULGADAS = 7;

        public static int GRADOS = 8;

        /**

         * Resoluci?n (Puntos por pulgada) de la vista actual. Se necesita para los

         * c?lculos de escala geogr?fica.

         */

        private static int dpi = java.awt.Toolkit.getDefaultToolkit()

                                                                                         .getScreenResolution();

        private Rectangle2D extent;

        private Rectangle2D adjustedExtent;

        private ExtentHistory extents = new ExtentHistory();

        private Dimension imageSize;

        private AffineTransform trans = new AffineTransform();

        private int distanceUnits = METROS;

        private int mapUnits = METROS;

        private ArrayList listeners = new ArrayList();

        private Point2D offset = new Point2D.Double(0, 0);

        private Rectangle2D clip;

        private Color backColor = null; //Color.WHITE;

        private IProjection proj;

        private double dist1pixel;

        private double dist3pixel;

        private double scale;

        private Rectangle2D cliprect;

        /**

         * Crea un nuevo ViewPort.

         *

         * @param proj Proyecci?n.

         */

        public ViewPort(IProjection proj) {

                // Por defecto

                this.proj = proj;

        }

        /**

         * A?ade un ViewPortListener al extentListener.

         *

         * @param arg0 ViewPortListener.

         *

         * @return True si ha sido a?adida correctamente.

         */

        public boolean addViewPortListener(ViewPortListener arg0) {

                return listeners.add(arg0);

        }

        /**

         * Borra el ViewPortListener que se pasa como par?metro delos

         * extentListener.

         *

         * @param arg0 ViewPortListener.

         *

         * @return True si ha sido borrado correctamente.

         */

        public boolean removeViewPortListener(ViewPortListener arg0) {

                return listeners.remove(arg0);

        }

        /**

         * Devuelve la distancia en pixels a partir de una distancia real.

         *

         * @param d Distancia real.

         *

         * @return Distancia en pixels.

         */

        public int fromMapDistance(double d) {

                Point2D.Double pWorld = new Point2D.Double(1, 1);

                Point2D.Double pScreen = new Point2D.Double();

                try {

                        trans.deltaTransform(pWorld, pScreen);

                } catch (Exception e) {

                        System.err.print(e.getMessage());

                }

                return (int) (d * pScreen.x);

        }

        /**

         * Devuelve un punto en pixels a partir de una coordenada X e Y real.

         *

         * @param x Coordenada X real.

         * @param y Coordenada Y real.

         *

         * @return Punto en pixels.

         */

        public Point2D fromMapPoint(double x, double y) {

                Point2D.Double pWorld = new Point2D.Double(x, y);

                Point2D.Double pScreen = new Point2D.Double();

                try {

                        trans.transform(pWorld, pScreen);

                } catch (Exception e) {

                        System.err.print(e.getMessage());

                }

                return pScreen;

        }

        /**

         * Devuelve el punto en pixels a partir de un punto real.

         *

         * @param point Punto real.

         *

         * @return Punto en pixels.

         */

        public Point2D fromMapPoint(Point2D point) {

                return fromMapPoint(point.getX(), point.getY());

        }

        /**

         * Devuelve un punto real a partir de una coordenada X e Y en pixels.

         *

         * @param x Coordenada X en pixels.

         * @param y Coordenada Y en pixels.

         *

         * @return Punto real.

         */

        public Point2D toMapPoint(int x, int y) {

                Point pScreen = new Point(x, y);

                return toMapPoint(pScreen);

        }

        public Rectangle2D toMapRectangle(Rectangle2D r){

                double w=toMapDistance((int)r.getWidth());

                double h=toMapDistance((int)r.getHeight());

                Point2D p1=toMapPoint((int)r.getX(),(int)r.getY());

                return new Rectangle2D.Double(p1.getX(),p1.getY(),w,h);

        }

        /**

         * Devuelve la distancia real a partir de la distancia en pixels.

         *

         * @param d Distancia en pixels.

         *

         * @return Distancia real.

         */

        public double toMapDistance(int d) {

                double dist = d / trans.getScaleX();

                return dist;

        }

        /**

         * Devuelve un punto real a partir de un punto en pixels.

         *

         * @param pScreen Punto en pixels.

         *

         * @return Punto real.

         *

         * @throws RuntimeException

         */

        public Point2D toMapPoint(Point2D pScreen) {

                Point2D.Double pWorld = new Point2D.Double();

                AffineTransform at;

                try {

                        at = trans.createInverse();

                        at.transform(pScreen, pWorld);

                } catch (NoninvertibleTransformException e) {

                        throw new RuntimeException(e);

                }

                return pWorld;

        }

        /**

         * Calcula la distancia entre dos puntos en unidades de usuario. Los puntos

         * est?n en unidades de usuario. Se tiene en cuenta la proyecci?n, con lo

         * que es INDISPENSABLE que la variable proj contenga el valor correcto de

         * la proyecci?n.

         *

         * @param pt1

         * @param pt2

         *

         * @return distancia real.

         */

        public double distanceWorld(Point2D pt1, Point2D pt2) {

                double dist = -1;

                dist = pt1.distance(pt2);

                if ((proj != null) && !(proj instanceof CSUTM)) {

                        dist = new GeoCalc(proj).distanceVincenty(proj.toGeo(pt1),

                                        proj.toGeo(pt2));

                }

                return dist;

        }

        /**

         * Rellena el extent anterior como actual.

         */

        public void setPreviousExtent() {

                extent = extents.removePrev();

                //Calcula la transformaci?n af?n

                calculateAffineTransform();

                // Lanzamos los eventos de extent cambiado

                callExtentChanged(getAdjustedExtent());

        }

        /**

         * <p>

         * When the zoom changes (for instance when using the zoom in or zoom out tools,

         * but also zooming to a selected feature or shape) the extent that covers that

         * area is the value returned by this method. It is not the actual area shown

         * in the view because it does not care about the aspect ratio. However, any

         * part of the real world contained in this extent is shown in the view.<br>

         * </p>

         * <p>

         * Probably <b>this is not what you are looking for</b>. If you are looking for

         * the complete extent currently shown, you must use getAdjustedExtent() method

         * which returns the extent that contains this one but regarding the current

         * view's aspect ratio.

         * </p>

         * @return Extent.

         */

        public Rectangle2D getExtent() {

                return extent;

        }

        /**

         * Inserta el extent.

         *

         * @param r Extent.

         */

        public void setExtent(Rectangle2D r) {

                if (extent != null) {

                        extents.put(extent);

                }

                //Esto comprueba que el extent no es de anchura o altura = "0"

                //y si es as? lo redimensiona.

                if (r!=null &&((r.getWidth() == 0) || (r.getHeight() == 0))) {

                        extent = new Rectangle2D.Double(r.getMinX() - 0.1,

                                        r.getMinY() - 0.1, r.getWidth() + 0.2, r.getHeight() + 0.2);

                } else {

                        extent = r;

                }

                //Calcula la transformaci?n af?n

                calculateAffineTransform();

                // Lanzamos los eventos de extent cambiado

                callExtentChanged(getAdjustedExtent());

        }

        /**

         * Inserta la escala.

     * TODO: (FJP) Que alguien me explique qu? sentido tiene esto

         *

         * @param scale escala.

         */

        public void setScale() {

                //this.scale = scale;

                //Calcula la transformaci?n af?n

                calculateAffineTransform();

                // Lanzamos los eventos de extent cambiado

                callExtentChanged(getAdjustedExtent());

        }

        /**

         * Devuelve la escala. Debe estar siempre actualizada y no calcularse nunca

         * aqu? pues se utiliza en el dibujado para cada geometr?a

         *

         * @return Escala.

         */

        public double getScale() {

                return proj.getScale(extent.getMinX(), extent.getMaxX(),

                        imageSize.getWidth(), dpi);

        }

        /**

         * Devuelve la matriz de transformaci?n.

         *

         * @return Matriz de transformaci?n.

         */

        public AffineTransform getAffineTransform() {

                return trans;

        }

        /**

         * Devuelve las dimensiones de la imagen.

         *

         * @return Returns the imageSize.

         */

        public Dimension getImageSize() {

                return imageSize;

        }

        /**

         * Inserta las dimensiones de la imagen.

         *

         * @param imageSize The imageSize to set.

         */

        public void setImageSize(Dimension imageSize) {

                this.imageSize = imageSize;

                calculateAffineTransform();

        }

        /**

         * Llamada a los listeners tras el cambio de extent.

         *

         * @param newRect Extent.

         */

        private void callExtentChanged(Rectangle2D newRect) {

                ExtentEvent ev = ExtentEvent.createExtentEvent(newRect);

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

                        ViewPortListener listener = (ViewPortListener) listeners.get(i);

                        listener.extentChanged(ev);

                }

        }

        /**

         * Llamada a los listeners tras el cambio de color.

         *

         * @param c Color.

         */

        private void callColorChanged(Color c) {

                ColorEvent ce = ColorEvent.createColorEvent(c);

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

                        ViewPortListener listener = (ViewPortListener) listeners.get(i);

                        listener.backColorChanged(ce);

                }

        }

        /**

         * Llamada a los listeners tras el cambio de extent.

         *

         * @param newRect Extent.

         */

        private void callProjectionChanged(IProjection projection) {

                ProjectionEvent ev = ProjectionEvent.createProjectionEvent(projection);

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

                        ViewPortListener listener = (ViewPortListener) listeners.get(i);

                        listener.projectionChanged(ev);

                }

        }

        /**

         * C?lculo de la matriz de transformaci?n.

         *

         * @throws RuntimeException

         */

        private void calculateAffineTransform() {

                if ((imageSize == null) || (extent == null) ||

                                (imageSize.getWidth() <= 0) || (imageSize.getHeight() <= 0)) {

                        return;

                }

                AffineTransform escalado = new AffineTransform();

                AffineTransform translacion = new AffineTransform();

                double escalaX;

                double escalaY;

                escalaX = imageSize.getWidth() / extent.getWidth();

                escalaY = imageSize.getHeight() / extent.getHeight();

                double xCenter = extent.getCenterX();

                double yCenter = extent.getCenterY();

                double newHeight;

                double newWidth;

                adjustedExtent = new Rectangle2D.Double();

                if (escalaX < escalaY) {

                        scale = escalaX;

                        newHeight = imageSize.getHeight() / scale;

                        adjustedExtent.setRect(xCenter - (extent.getWidth() / 2.0),

                                yCenter - (newHeight / 2.0), extent.getWidth(), newHeight);

                } else {

                        scale = escalaY;

                        newWidth = imageSize.getWidth() / scale;

                        adjustedExtent.setRect(xCenter - (newWidth / 2.0),

                                yCenter - (extent.getHeight() / 2.0), newWidth,

                                extent.getHeight());

                }

                translacion.setToTranslation(-getAdjustedExtent().getX(),

                        -getAdjustedExtent().getY() - getAdjustedExtent().getHeight());

                escalado.setToScale(scale, -scale);

                AffineTransform offsetTrans = new AffineTransform();

                offsetTrans.setToTranslation(offset.getX(), offset.getY());

                trans.setToIdentity();

                trans.concatenate(offsetTrans);

                trans.concatenate(escalado);

                trans.concatenate(translacion);

                // Calculamos las distancias de 1 pixel y 3 pixel con esa transformaci?n

                // de coordenadas, de forma que est?n precalculadas para cuando las necesitemos

                AffineTransform at;

                try {

                        at = trans.createInverse();

                        java.awt.Point pPixel = new java.awt.Point(1, 1);

                        Point2D.Float pProv = new Point2D.Float();

                        at.deltaTransform(pPixel, pProv);

                        dist1pixel = pProv.x;

                        dist3pixel = 3 * pProv.x;

                } catch (NoninvertibleTransformException e) {

                        System.err.println("transformada afin = " + trans.toString());

                        System.err.println("extent = " + extent.toString() +

                                " imageSize= " + imageSize.toString());

                        throw new RuntimeException(e);

                }

        }

        /**

         * Inserta la desviaci?n.

         *

         * @param p Punto.

         */

        public void setOffset(Point2D p) {

                offset = p;

        }

        /**

         * The offset is the position where to start drawing. The offset of a View is

         * always (0, 0) because the drawing area fits with the full window area. But in

         * a Layout it is up to the place where the FFrameView is located.

         *

         * @param p Point, in pixels, where the map starts.

         */

        public Point2D getOffset() {

                return offset;

        }

        /**

         * Inserta el color de fondo.

         *

         * @param c Color de fondo.

         */

        public void setBackColor(Color c) {

                backColor = c;

                callColorChanged(backColor);

        }

        /**

         * Devuelve el color de fondo.

         *

         * @return Color de fondo.

         */

        public Color getBackColor() {

                return backColor;

        }

        /**

         * Returns the extent currently covered by the view.

         *

         * @return Returns the adjustedExtent.

         */

        public Rectangle2D getAdjustedExtent() {

                if (cliprect!=null){

                        return adjustedExtent.createIntersection(cliprect);

                }

                return adjustedExtent;

        }

        /**

         * Devuelve la unidad de medida.

         *

         * @return Returns the distanceUnits.

         */

        public int getDistanceUnits() {

                return distanceUnits;

        }

        /**

         * Inserta la unidad de medida.

         *

         * @param distanceUnits The distanceUnits to set.

         */

        public void setDistanceUnits(int distanceUnits) {

                this.distanceUnits = distanceUnits;

        }

        /**

         * Devuelve la unidad de medida del mapa.

         *

         * @return Returns the mapUnits.

         */

        public int getMapUnits() {

                return mapUnits;

        }

        /**

         * Inserta la unidad de medida del mapa.

         *

         * @param mapUnits The mapUnits to set.

         */

        public void setMapUnits(int mapUnits) {

                this.mapUnits = mapUnits;

        }

        /**

         * Devuelve la anchura de la imagen.

         *

         * @return anchura en pixels de la imagen.

         */

        public int getImageWidth() {

                return imageSize.width;

        }

        /**

         * Devuelve la altura de la imagen.

         *

         * @return altura de la imagen.

         */

        public int getImageHeight() {

                return imageSize.height;

        }

        /**

         * Devuelve la distancia real de un pixel.

         *

         * @return Distancia real de un pixel.

         */

        public double getDist1pixel() {

                return dist1pixel;

        }

        /**

         * Inserta la distancia real de un pixel.

         *

         * @param dist1pixel Distancia real de un pixel.

         */

        public void setDist1pixel(double dist1pixel) {

                this.dist1pixel = dist1pixel;

        }

        /**

         * Devuelve la distancia real de tres pixel.

         *

         * @return Distancia real de tres pixel.

         */

        public double getDist3pixel() {

                return dist3pixel;

        }

        /**

         * Inserta la distancia real de tres pixels.

         *

         * @param dist3pixel Distancia real de tres pixels.

         */

        public void setDist3pixel(double dist3pixel) {

                this.dist3pixel = dist3pixel;

        }

        /**

         * Devuelve los Extents anteriores almacenados.

         *

         * @return Returns the extents.

         */

        public ExtentHistory getExtents() {

                return extents;

        }

        /**

         * Devuelve la proyecci?n.

         *

         * @return Returns the proj.

         */

        public IProjection getProjection() {

                return proj;

        }

        /**

         * Inserta la proyecci?n.

         *

         * @param proj The proj to set.

         */

        public void setProjection(IProjection proj) {

                if(this.proj == null || !this.proj.getAbrev().equals(proj.getAbrev())) {

                        this.proj = proj;

                        callProjectionChanged(proj);

                }

        }

        /**

         * M?todo que solo lo utilizamos a la hora de imprimir. NO lanza

         * un calculateAffineTransform, ni recalcula el adjustedExtent.

         * TODO: Para evitar este m?todo, habr?a que redefinir el interfaz

         * RasterAdapter, y que recibiera un ViewPortData.

         * @param at

         */

        public void setAffineTransform(AffineTransform at)

        {

            this.trans = at;

        }

        /**

         * Devuelve el XMLEntity.

         *

         * @return XMLEntity.

         */

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className",this.getClass().getName());

                if (adjustedExtent != null) {

                        xml.putProperty("adjustedExtentX", adjustedExtent.getX());

                        xml.putProperty("adjustedExtentY", adjustedExtent.getY());

                        xml.putProperty("adjustedExtentW", adjustedExtent.getWidth());

                        xml.putProperty("adjustedExtentH", adjustedExtent.getHeight());

                }

                if (backColor != null)

                    xml.putProperty("backColor", StringUtilities.color2String(backColor));

                if (clip != null) {

                        xml.putProperty("clipX", clip.getX());

                        xml.putProperty("clipY", clip.getY());

                        xml.putProperty("clipW", clip.getWidth());

                        xml.putProperty("clipH", clip.getHeight());

                }

                xml.putProperty("dist1pixel", dist1pixel);

                xml.putProperty("dist3pixel", dist3pixel);

                xml.putProperty("distanceUnits", distanceUnits);

                if (extent != null) {

                        xml.putProperty("extentX", extent.getX());

                        xml.putProperty("extentY", extent.getY());

                        xml.putProperty("extentW", extent.getWidth());

                        xml.putProperty("extentH", extent.getHeight());

                }

                xml.addChild(extents.getXMLEntity());

                xml.putProperty("mapUnits", mapUnits);

                xml.putProperty("offsetX", offset.getX());

                xml.putProperty("offsetY", offset.getY());

                if (proj != null) {

                        xml.putProperty("proj", proj.getAbrev());

                }

                xml.putProperty("scale", scale);

                return xml;

        }

        /**

         * Crea un nuevo ViewPort a partir del XMLEntity.

         *

         * @param xml XMLEntity.

         *

         * @return Nuevo ViewPort.

         */

        public static ViewPort createFromXML03(XMLEntity xml) {

                ViewPort vp = new ViewPort(null);

                if (xml.contains("adjustedExtentX")) {

                        vp.adjustedExtent = new Rectangle2D.Double(xml.getDoubleProperty(

                                                "adjustedExtentX"),

                                        xml.getDoubleProperty("adjustedExtentY"),

                                        xml.getDoubleProperty("adjustedExtentW"),

                                        xml.getDoubleProperty("adjustedExtentH"));

                }

                if (xml.contains("backColor")) {

                        vp.setBackColor(StringUtilities.string2Color(xml.getStringProperty(

                                                "backColor")));

                }

                if (xml.contains("clipX")) {

                        vp.clip = new Rectangle2D.Double(xml.getDoubleProperty("clipX"),

                                        xml.getDoubleProperty("clipY"),

                                        xml.getDoubleProperty("clipW"),

                                        xml.getDoubleProperty("clipH"));

                }

                vp.setDist1pixel(xml.getDoubleProperty("dist1pixel"));

                vp.setDist3pixel(xml.getDoubleProperty("dist3pixel"));

                vp.setDistanceUnits(xml.getIntProperty("distanceUnits"));

                vp.extents = ExtentHistory.createFromXML03(xml.getChild(0));

                if (xml.contains("extentX")) {

                        vp.setExtent(new Rectangle2D.Double(xml.getDoubleProperty("extentX"),

                                        xml.getDoubleProperty("extentY"),

                                        xml.getDoubleProperty("extentW"),

                                        xml.getDoubleProperty("extentH")));

                        //Calcula la transformaci?n af?n

                        vp.calculateAffineTransform();

                        // Lanzamos los eventos de extent cambiado

                        // vp.callExtentListeners(vp.adjustedExtent);

                }

                vp.setMapUnits(xml.getIntProperty("mapUnits"));

                vp.setOffset(new Point2D.Double(xml.getDoubleProperty("offsetX"),

                                xml.getDoubleProperty("offsetY")));

                if (xml.contains("proj")) {

                        vp.proj = CRSFactory.getCRS(xml.getStringProperty("proj"));

                }

                //vp.setScale(xml.getDoubleProperty("scale"));

                vp.setScale();

                return vp;

        }

        /**

         * Crea un nuevo ViewPort a partir del XMLEntity.

         *

         * @param xml XMLEntity.

         *

         * @return Nuevo ViewPort.

         */

        public static ViewPort createFromXML(XMLEntity xml) {

                ViewPort vp = new ViewPort(null);

                if (xml.contains("adjustedExtentX")) {

                        vp.adjustedExtent = new Rectangle2D.Double(xml.getDoubleProperty(

                                                "adjustedExtentX"),

                                        xml.getDoubleProperty("adjustedExtentY"),

                                        xml.getDoubleProperty("adjustedExtentW"),

                                        xml.getDoubleProperty("adjustedExtentH"));

                }

                if (xml.contains("backColor")) {

                        vp.setBackColor(StringUtilities.string2Color(xml.getStringProperty(

                                                "backColor")));

                }

                if (xml.contains("clipX")) {

                        vp.clip = new Rectangle2D.Double(xml.getDoubleProperty("clipX"),

                                        xml.getDoubleProperty("clipY"),

                                        xml.getDoubleProperty("clipW"),

                                        xml.getDoubleProperty("clipH"));

                }

                vp.setDist1pixel(xml.getDoubleProperty("dist1pixel"));

                vp.setDist3pixel(xml.getDoubleProperty("dist3pixel"));

                vp.setDistanceUnits(xml.getIntProperty("distanceUnits"));

                vp.extents = ExtentHistory.createFromXML(xml.getChild(0));

                if (xml.contains("extentX")) {

                        vp.setExtent(new Rectangle2D.Double(xml.getDoubleProperty("extentX"),

                                        xml.getDoubleProperty("extentY"),

                                        xml.getDoubleProperty("extentW"),

                                        xml.getDoubleProperty("extentH")));

                        //Calcula la transformaci?n af?n

                        vp.calculateAffineTransform();

                        // Lanzamos los eventos de extent cambiado

                        // vp.callExtentListeners(vp.adjustedExtent);

                }

                vp.setMapUnits(xml.getIntProperty("mapUnits"));

                vp.setOffset(new Point2D.Double(xml.getDoubleProperty("offsetX"),

                                xml.getDoubleProperty("offsetY")));

                if (xml.contains("proj")) {

                        vp.proj = CRSFactory.getCRS(xml.getStringProperty("proj"));

                }

                //vp.setScale(xml.getDoubleProperty("scale"));

                vp.setScale();

                return vp;

        }

        /**

         * Clona el ViewPort.

         *

         * @return ViewPort clonado.

         */

        public ViewPort cloneViewPort() {

                return createFromXML(getXMLEntity());

        }

        /**

         * Devuelve el String con datos del ViewPort.

         *

         * @return Cadena con datos del ViewPort.

         */

        public String toString() {

                String str;

                str = "Datos del viewPort:\nExtent=" + extent + "\nadjustedExtent=" +

                        adjustedExtent + "\nimageSize=" + imageSize + "\nescale=" + scale +

                        "\ntrans=" + trans;

                return str;

        }

        public void setClipRect(Rectangle2D rectView) {

                cliprect=rectView;

        }

        public Rectangle2D fromMapRectangle(Rectangle2D r) {

                double w=fromMapDistance((int)r.getWidth());

                double h=fromMapDistance((int)r.getHeight());

                Point2D p1=fromMapPoint((int)r.getX(),(int)r.getY());

                return new Rectangle2D.Double(p1.getX(),p1.getY(),w,h);

        }

}