Application: gvSIG desktop

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

 *

 * Copyright (C) 2006 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.

 */

package com.iver.cit.gvsig.fmap.layers;

import java.awt.Graphics2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import javax.print.attribute.PrintRequestAttributeSet;

import org.cresques.io.data.RasterMetaFileTags;

import org.cresques.px.Extent;

import com.iver.andami.PluginServices;

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

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

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

import com.iver.cit.gvsig.project.documents.view.gui.View;

import com.iver.utiles.XMLEntity;

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

/**

 * Clase de capa raster georeferenciada.

 *

 * @author Nacho Brodin (brodin_ign@gva.es)

 */

public class FLyrGeoRaster extends FLyrRaster{

        //**********************Vars****************************************

        private Extent                                         assignExtent = null;

        private IStackZoom                                 zoom = null;

        private FLyrPoints                                 lyrPoints = null;

        private double                                         widthPxImg, heightPxImg;

        private ViewPort                                 viewPortWithoutTransformation = null;

        /**

         * Dialogo de georreferenciaci?n asociado a la capa.

         */

        private IGeoUi                                         geoUI = null;

        private IPersistence                         persistence = null;

        //**********************End Vars************************************

        //**********************Methods*************************************

        /**

         * Constructor

         */

        public FLyrGeoRaster(){}

        /**

         * Contructor

         */

        public FLyrGeoRaster(IPersistence persistence, IStackZoom zoom){

                this.persistence = persistence;

                this.zoom = zoom;

        }

        /**

         * Funci?n encargada de realizar la transformaci?n para las coordenadas

         * del viewPort que se quiere dibujar. Para esta transformaci?n se tiene

         * en cuenta que la imagen tiene un extent propio y uno asignado por el

         * usuario por lo que habr? que transformar las coordenadas que solicita

         * el usuario en coordenadas de la imagen.

         * @param vp        ViewPort solicitado por el usuario.

         * @return        ViewPort transformado a coordenadas de la imagen.

         */

        public ViewPort toImageCoord(ViewPort vp) throws DriverException{

                this.viewPortWithoutTransformation = vp;

                if(this.assignExtent == null)

                        return vp;

                //Para la transformaci?n trasladamos virtualmente los extents, el real de la imagen

                // y el asignado al centro del eje de coordenadas. Despu?s trasladamos el viewPort

                //(vpTrasExtent) y con las proporciones de los 2 extents hallamos en ancho, alto y

                //coordenada de inicio del viewport. Todo esto equivale a trasladar y escalar el

                //viewPort para hallar el nuevo.

                Rectangle2D userExtent = new Rectangle2D.Double(assignExtent.minX(),

                                                                                                                assignExtent.minY(),

                                                                                                                assignExtent.width(),

                                                                                                                assignExtent.height());

                Rectangle2D imageExtent = super.getFullExtent();

                Rectangle2D vpExtent = vp.getExtent();

                //Traslaci?n del viewport estando el extent posicionado en el 0,0

                Rectangle2D vpTrasExtent = new Rectangle2D.Double(        vpExtent.getMinX() - userExtent.getMinX(),

                                                                                                                        vpExtent.getMinY() - userExtent.getMinY(),

                                                                                                                        vpExtent.getWidth(),

                                                                                                                        vpExtent.getHeight());

                double x = 0D, y = 0D, width = 0D, height = 0D;

                //Escalado de la anchura y altura. No hace falta traslaci?n

                width = (vpExtent.getWidth() * imageExtent.getWidth())/assignExtent.width();

                height = (vpExtent.getHeight() * imageExtent.getHeight())/assignExtent.height();

                //Escalado del min del viewport para hallar el min del nuevo

                x = (vpTrasExtent.getMinX() *  imageExtent.getWidth())/assignExtent.width();

                y = (vpTrasExtent.getMinY() *  imageExtent.getHeight())/assignExtent.height();

                //Traslaci?n

                x += imageExtent.getMinX();

                y += imageExtent.getMinY();

                Rectangle2D newExtent = new Rectangle2D.Double(x, y, width, height);

                ViewPort viewPort = new ViewPort(vp.getProjection());

                viewPort.setExtent(newExtent);

                viewPort.setImageSize(vp.getImageSize());

                viewPort.refreshExtent();

                return viewPort;

        }

        /**

         * Dibujado de la capa de raster georeferenciado aplicando la

         * transformaci?n del viewPort.

         */

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

                        Cancellable cancel,double scale) throws DriverException {

                super.draw(image, g, this.toImageCoord(vp), cancel, scale);

        }

        /**

         * Impresi?n de la capa de raster georeferenciado aplicando la

         * transformaci?n del viewPort.

         */

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

                double scale, PrintRequestAttributeSet properties)throws DriverException {

                super.print(g, this.toImageCoord(viewPort), cancel, scale, properties);

        }

        /**

         * Impresi?n de la capa de raster georeferenciado aplicando la

         * transformaci?n del viewPort.

         */

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

                throws DriverException {

                _print(g, this.toImageCoord(viewPort), cancel, scale);

        }

        /**

         * Transforma un pixel de la imagen cuyas coordenadas son (0..maxWidth, 0..maxHeight)

         * en coordenadas del mundo real a partir del extent asignado a la imagen.

         * @param pixel Pixel de la imagen

         * @return        Coordenadas del mundo de ese pixel

         */

        public Point2D img2World(Point2D pixel){

                Point2D p = new Point2D.Double();

                double wcWidth = 0.0, wcHeight = 0.0;

                double mapImgX = 0, mapImgY = 0;

                try{

                        wcWidth = getFullExtent().getWidth();

                        wcHeight = getFullExtent().getHeight();

                        //La esquina superior izquierda de la vista es minX,maxY y la de la imagen minX,minY

                        double pixelImgX = pixel.getX();

                        double pixelImgY = getImageHeight() - pixel.getY();

                        //Hallamos el pto en coordenadas reales con una regla de tres

                        mapImgX = (((pixelImgX * wcWidth) / widthPxImg));

                        mapImgY = (((pixelImgY * wcHeight) / heightPxImg));

                        //Trasladamos a su ubicaci?n real

                        mapImgX += this.getFullExtent().getMinX();

                        mapImgY += this.getFullExtent().getMinY();

                }catch(DriverException ex){}

                p.setLocation(mapImgX, mapImgY);

                return p;

        }

        /**

         * Transforma un pixel de la imagen cuyas coordenadas son (0..maxWidth, 0..maxHeight)

         * en coordenadas del mundo real a partir del extent asignado a la imagen.

         * @param x Coordenada X del pixel de la imagen

         * @param y Coordenada Y del pixel de la imagen

         * @return        Coordenadas del mundo de ese pixel

         */

        public Point2D img2World(double x, double y){

                Point2D p = new Point2D.Double();

                p.setLocation(x, y);

                return this.img2World(p);

        }

        /**

         * Transforma una coordenada del mundo real a un pixel  (0..maxWidth, 0..maxHeight)

         * en coordenadas de la imagen a partir del extent asignado a esta.

         * @param wcPoint coordenada del mundo

         * @return        Pixel de la imagen

         */

        public Point2D world2Img(Point2D wcPoint){

                //Si el punto cae fuera de la imagen salimos devolviendo null

                if(        wcPoint.getX() < this.getMinX() ||

                        wcPoint.getX() > this.getMaxX() ||

                        wcPoint.getY() < this.getMinY() ||

                        wcPoint.getY() > this.getMaxY())

                        return null;

                //Hallamos pixelImg q son las coordenadas en pixeles de la imagen que corresponden

                //con el punto wcPoint

                double wcWidth = 0.0, wcHeight = 0.0, ptoWCX = 0.0, ptoWCY = 0.0;

                double pixelImgX = 0, pixelImgY = 0;

                try{

                        wcWidth = getFullExtent().getWidth();

                        wcHeight = getFullExtent().getHeight();

                        //Traslaci?n al origen ya que la imagen empieza en 0,0

                        ptoWCX = wcPoint.getX() - getFullExtent().getMinX();

                        ptoWCY = wcPoint.getY() - getFullExtent().getMinY();

                        //Hallamos el pto en pixeles con una regla de tres

                        pixelImgX = ((ptoWCX * getImageWidth()) / wcWidth);

                        pixelImgY = ((ptoWCY * getImageHeight()) / wcHeight);

                        //La esquina superior izquierda de la vista es minX,maxY y la de la imagen minX,minY

                        pixelImgY = getImageHeight() - pixelImgY;

                }catch(DriverException ex){}

                Point2D result = new Point2D.Double();

                result.setLocation(pixelImgX, pixelImgY);

                return result;

        }

        /**

         * Transforma una coordenada del mundo real a un pixel  (0..maxWidth, 0..maxHeight)

         * en coordenadas de la imagen a partir del extent asignado a esta.

         * @param x wcPoint coordenada X del mundo

         * @param y wcPoint coordenada Y del mundo

         * @return        Pixel de la imagen

         */

        public Point2D world2Img(double x, double y){

                Point2D p = new Point2D.Double();

                p.setLocation(x, y);

                return this.world2Img(p);

        }

        /**

         * Recupera el extent asignado, si existe y llama al setXMLEntity de la capa de puntos

         */

        public void setXMLEntity(XMLEntity xml)throws XMLException {

                super.setXMLEntity(xml);

                if (xml.contains("raster.assignExtent.minX") &&

                        xml.contains("raster.assignExtent.minY") &&

                        xml.contains("raster.assignExtent.maxX") &&

                        xml.contains("raster.assignExtent.maxY")){

                        //Comprobamos si existe el fichero .rmf y si existe analizamos el contenido

                        //buscando el bloque que contiene georreferenciaci?n. Si tiene este bloque

                        //no utilizaremos el extent asignado que lleva el proyecto para que use la

                        //georreferenciaci?n de la imagen.

                        boolean georefRmf = false;

                        String path = ((RasterFileAdapter)getSource()).getFile().getPath();

                        String rmfName = path.substring(0, path.lastIndexOf(".")) + ".rmf";

                        File rmfFile = new File(rmfName);

                        try{

                                BufferedReader inGrf = new BufferedReader(new InputStreamReader(new FileInputStream(rmfFile)));

                                String str = inGrf.readLine();

                                while(        str != null &&

                                                !str.startsWith("</"+RasterMetaFileTags.LAYER) &&

                                                !str.startsWith("</"+RasterMetaFileTags.GEOPOINT))

                                       str = inGrf.readLine();

                            if(str.startsWith("</"+RasterMetaFileTags.LAYER))

                                    georefRmf = true;

                        }catch(FileNotFoundException ex){

                                //Si no encuentra el fichero no se modifica la variable georefRmf

                        }catch(IOException ex){

                                //Si da un error de I/O no se modifica la variable georefRmf

                        }

                        if(!georefRmf){

                                this.assignExtent = new Extent(xml.getDoubleProperty("raster.assignExtent.minX"),

                                                                                        xml.getDoubleProperty("raster.assignExtent.minY"),

                                                                                        xml.getDoubleProperty("raster.assignExtent.maxX"),

                                                                                        xml.getDoubleProperty("raster.assignExtent.maxY"));

                        }

                        if (xml.contains("raster.assignExtent.imageWidth") &&

                                        xml.contains("raster.assignExtent.imageHeight")){

                                        this.widthPxImg = xml.getDoubleProperty("raster.assignExtent.imageWidth");

                                        this.heightPxImg = xml.getDoubleProperty("raster.assignExtent.imageHeight");

                        }

                }

        }

        /**

         * Cambia el nombre a la capa de puntos si esta empieza por * para que no se salve con ese

         * nombre y llama a getXMLEntity del padre. Salva el extent asignado, si existe y llama a

         * getXMLEntity de la capa de puntos para que se guarden los puntos de control en el proyecto.

         * @throws XMLException

         */

        public XMLEntity getXMLEntity() throws XMLException {

                boolean active = false;

                if(getName().startsWith("*")){

                        setName(getName().substring(1, getName().length()));

                        active = true;

                }

                XMLEntity xml = super.getXMLEntity();

                if(active)

                        setName("*"+getName());

                if(this.assignExtent != null){

                        xml.putProperty("raster.assignExtent.minX", assignExtent.getMin().getX());

                        xml.putProperty("raster.assignExtent.minY", assignExtent.getMin().getY());

                        xml.putProperty("raster.assignExtent.maxX", assignExtent.getMax().getX());

                        xml.putProperty("raster.assignExtent.maxY", assignExtent.getMax().getY());

                        xml.putProperty("raster.assignExtent.imageWidth", this.getImageWidth());

                        xml.putProperty("raster.assignExtent.imageHeight", this.getImageHeight());

                }

                try{

                        geoUI.savePoints();

                }catch(Exception ex){

                        //La capa de puntos no est? cargada por lo que no podemos salvar

                }

                return xml;

        }

        /**

         * A partir de nuevas coordenadas actualiza la vista, minimagen, capa de puntos el

         * dialogo y la tabla.

         *

         */

        public void updateData(int nPunto, Point2D pixel, Point2D map, View view){

                this.geoUI.updateData(nPunto, pixel, map, view);

        }

        /**

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

                try{

                        //Hacemos invisible LyrPoints para que la capa gr?fica de Fmap no dibuje nada

                        this.getLyrPoints().setVisible(false);

                        geoUI.close();

                }catch(NullPointerException ex){

                        //Si geoUI es null no hace falta que cerremos la ventana

                }

                return super.removeLayerListener(o);

        }

        //**********************End Methods**********************************

        //**********************Setters & Getters****************************

        /**

         * @return Returns the viewPortWithoutTransform.

         */

        public ViewPort getViewPortWithoutTransformation() {

                return viewPortWithoutTransformation;

        }

        /**

         * Asigna la capa de puntos asociada a la capa Georraster

         * @param lyr Capa de puntos

         */

        public void setFLyrPoints(FLyrPoints lyr){

                this.lyrPoints = lyr;

        }

        /**

         * Obtiene la capa de puntos asociada a la capa Georraster. Si no existe

         * crear? una.

         * @return        Capa de puntos

         */

        public FLyrPoints getFLyrPoints()throws ClassCastException{

                //Si no existe una capa de puntos la creamos

                if(lyrPoints == null){

                        View theView = (View) PluginServices.getMDIManager().getActiveWindow();

                        MapContext fmap = theView.getMapControl().getMapContext();

                        lyrPoints = new FLyrPoints(this, persistence);

                        fmap.setGraphicsLayer(lyrPoints);

                }

                return lyrPoints;

        }

        /**

         * Asigna la dimensi?n de la imagen de disco en pixeles

         * @param w        Ancho

         * @param h Alto

         */

        public void setImageDimension(double w, double h){

                this.widthPxImg = w;

                this.heightPxImg = h;

        }

        /**

         * Obtiene el ancho de la imagen de disco en pixeles. Si no se tiene valor es

         * porque se ha abierto un proyecto con una imagen con rmf asociado. En este

         * caso se tendr? que leer el ancho de los atributos de la capa.

         * @return

         */

        public double getImageWidth(){

                if(this.widthPxImg == 0){

                        ArrayList attr = getSource().getAttributes();

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

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

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

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

                        }

                }

                return this.widthPxImg;

        }

        /**

         * Obtiene el alto de la imagen de disco en pixeles. Si no se tiene valor es

         * porque se ha abierto un proyecto con una imagen con rmf asociado. En este

         * caso se tendr? que leer el ancho de los atributos de la capa.

         * @return

         */

        public double getImageHeight(){

                if(this.heightPxImg == 0){

                        ArrayList attr = getSource().getAttributes();

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

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

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

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

                        }

                }

                return this.heightPxImg;

        }

        /**

         * @return Returns the geoDialog.

         */

        public IGeoUi getGeoDialog() {

                return geoUI;

        }

        /**

         * @param geoDialog The geoDialog to set.

         */

        public void setGeoDialog(IGeoUi geoDialog) {

                this.geoUI = geoDialog;

        }

        /**

         * Obtiene el extent de la capa

         * @return extent en Rectangle2D.

         */

        public Rectangle2D getFullExtent()throws DriverException {

                if(assignExtent == null)

                        return super.getFullExtent();

                return assignExtent.toRectangle2D();

        }

        /**

         * Obtiene el extent de la capa

         * @return extent de la capa

         */

        public Extent getAssignExtent(){

                try{

                        if(assignExtent == null)

                                return new Extent(        super.getFullExtent().getMinX(),

                                                                        super.getFullExtent().getMinY(),

                                                                        super.getFullExtent().getMaxX(),

                                                                        super.getFullExtent().getMaxY());

                }catch(DriverException ex){}

                return assignExtent;

        }

        /**

         * Obtiene la coordenada X m?xima

         */

        public double getMaxX(){

                if(assignExtent == null)

                        return super.getMaxX();

                return assignExtent.maxX();

        }

        /**

         * Obtiene la coordenada Y m?xima

         */

        public double getMaxY(){

                if(assignExtent == null)

                        return super.getMaxY();

                return assignExtent.maxY();

        }

        /**

         * Obtiene la coordenada X m?nima

         */

        public double getMinX(){

                if(assignExtent == null)

                        return super.getMinX();

                return assignExtent.minX();

        }

        /**

         * Obtiene la coordenada Y m?nima

         */

        public double getMinY(){

                if(assignExtent == null)

                        return super.getMinY();

                return assignExtent.minY();

        }

        /**

         * Obtiene el alto

         */

        public double getHeight(){

                if(assignExtent == null)

                        return super.getHeight();

                return assignExtent.height();

        }

        /**

         * Obtiene el ancho

         */

        public double getWidth(){

                if(assignExtent == null)

                        return super.getWidth();

                return assignExtent.width();

        }

        /**

         * @param assignExtent The assignExtent to set.

         */

        public void setAssignExtent(Extent assignExtent) {

                if(assignExtent.getMax().distance(assignExtent.getMin()) > 0){

                        this.assignExtent = assignExtent;

                        setAssignZoomIntoStack();

                }

        }

        /**

         * Guarda el zoom asignado a la capa en la pila de zooms

         */

        public void setAssignZoomIntoStack(){

                zoom.setZoom(assignExtent);

        }

        /**

         * Asigna el ?ltimo extent seleccionado si hay alguno

         */

        public void setLastExtent(){

                Extent e = null;

                e = zoom.getLastZoom();

                if(e != null)

                        this.assignExtent = e;

        }

        /**

         * Asigna el siguiente extent de la pila si hay alguno

         */

        public void setNextExtent(){

                Extent e = null;

                e = zoom.getNextZoom();

                if(e != null)

                        this.assignExtent = e;

        }

        /**

         * Obtiene la pila de extents aplicados

         * @return pila de extents

         */

        public IStackZoom getStackZoom(){

                return zoom;

        }

        /**

         * Obtiene la capa de puntos

         * @return FLyrPoints

         */

        public FLyrPoints getLyrPoints() {

                return lyrPoints;

        }

        /**

         * Obtiene el objeto que gestiona la persistencia

         * @return interfaz IPersistence

         */

        public IPersistence getPersistence() {

                return persistence;

        }

        /**

         * Asigna el objeto que gestiona la persistencia

         * @param persistence

         */

        public void setPersistence(IPersistence persistence) {

                this.persistence = persistence;

                if(this.lyrPoints != null)

                        this.lyrPoints.setPersistence(persistence);

        }

        /**

         * Obtiene el objeto que gestiona la pila de zooms

         * @return IStackZoom

         */

        public IStackZoom getZoom() {

                return zoom;

        }

        /**

         * Asigna el objeto que gestiona la pila de zooms

         * @param IStackZoom

         */

        public void setZoom(IStackZoom zoom) {

                if(this.zoom == null)

                        this.zoom = zoom;

        }

        //**********************End Setters & Getters************************

}