| gvSIG desktop 1

/* 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.Graphics2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.cresques.px.Extent;

import com.iver.cit.gvsig.StackZoom;

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

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

import com.iver.cit.gvsig.fmap.operations.Cancellable;

import com.iver.cit.gvsig.gui.Panels.SelectFilePanel;

/**

 * Clase de capa raster georeferenciada.

 *

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

 */

public class FLyrGeoRaster extends FLyrRaster{

        private Extent assignExtent = null;

        private StackZoom zoom = new StackZoom();

        /**

         * 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.

         */

        private ViewPort toImageCoord(ViewPort vp) throws DriverException{

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

                double vpMinX = 0D, vpMinY = 0D;

                //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);

                /*System.out.println("--userExtent="+userExtent);

                System.out.println("--imageExtent="+imageExtent);

                System.out.println("--vpExtent="+vpExtent);

                System.out.println("--vpTrasExtent="+vpTrasExtent);

                System.out.println("--imgSize="+vp.getImageSize());

                System.out.println("--newExtent="+newExtent);*/

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

                viewPort.setExtent(newExtent);

                viewPort.setImageSize(vp.getImageSize());

                viewPort.setScale();

                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)throws DriverException {

                super.print(g, this.toImageCoord(viewPort), 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)

                throws DriverException {                

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

        }

        /**

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

        }*/

        /**

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

                        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;

        }

        /**

         * Obtiene la pila de extents aplicados

         * @return pila de extents

         */

        public StackZoom getStackZoom(){

                return zoom;

        }

        /**

         * 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, ptoWCX = 0.0, ptoWCY = 0.0;

                int pixelImgX = 0, pixelImgY = 0;

                try{

                        wcWidth = getFullExtent().getWidth();

                        wcHeight = getFullExtent().getHeight();

                        pixelImgX = (int)((((pixel.getX() * wcWidth) / SelectFilePanel.widthPxImg)) + this.getFullExtent().getMinX());

                        pixelImgY = (int)((((pixel.getY() * wcHeight) / SelectFilePanel.heightPxImg)) + this.getFullExtent().getMinY());

                }catch(DriverException ex){}

                p.setLocation(pixelImgX, pixelImgY);

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

        }

}