Application: gvSIG desktop » gvSIG raster

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

 *

 * Copyright (C) 2007 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 org.gvsig.raster.georeferencing.swing.impl.view.synchronize;

import java.awt.geom.Point2D;

import java.util.List;

import org.gvsig.fmap.dal.coverage.RasterLocator;

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

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

import org.gvsig.gui.beans.table.exceptions.NotInitializeException;

import org.gvsig.raster.georeferencing.swing.impl.layer.GCPsGraphicLayer;

import org.gvsig.raster.georeferencing.swing.impl.layer.GPGraphic;

import org.gvsig.raster.georeferencing.swing.impl.tool.PanTool;

import org.gvsig.raster.georeferencing.swing.impl.tool.SelectPointTool;

import org.gvsig.raster.georeferencing.swing.impl.tool.ZoomRectangleTool;

import org.gvsig.raster.georeferencing.swing.impl.view.ViewPanelImpl;

import org.gvsig.raster.georeferencing.swing.impl.view.ZoomPanelImpl;

import org.gvsig.raster.georeferencing.swing.view.GeoreferencingView;

import org.gvsig.raster.georeferencing.swing.view.IGraphicLayer;

import org.gvsig.raster.georeferencing.swing.view.IViewRequestManager;

import org.gvsig.raster.georeferencing.swing.view.ToolListener;

import org.gvsig.raster.swing.pagedtable.PagedTable;

/**

 * Clase para realizar operaciones y mantener la sincronizaci?n entre las 

 * capas de puntos de las dos vistas y las dos ventanas de zoom.

 * 

 * 04/02/2008

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class GCPSynchronizationImpl {

        private ToolListener                  toolListener                   = null;

        //Vistas

        private ViewPanelImpl                 viewRaster                     = null;

        private ViewPanelImpl                 viewMap                        = null;

        private ZoomPanelImpl                 zoomMap                        = null;

        private ZoomPanelImpl                 zoomRaster                     = null;

        //Capas de puntos

        private GCPsGraphicLayer              viewRasterGCPs                 = null;

        private GCPsGraphicLayer              viewMapGCPs                    = null;

        private GCPsGraphicLayer              viewRasterGCPsZoom             = null;

        private GCPsGraphicLayer              viewMapGCPsZoom                = null;

        //Gestores de peticiones

        private IViewRequestManager           viewRasterRequestManager       = null;

        private IViewRequestManager           viewMapRequestManager          = null;

        private IViewRequestManager           zoomRasterRequestManager       = null;

        private IViewRequestManager           zoomMapRequestManager          = null;

        //Herramientas de selecci?n

        private SelectPointTool               viewRasterSelectPointTool      = null;

        private SelectPointTool               viewMapSelectPointTool         = null;

        private SelectPointTool               zoomRasterSelectPointTool      = null;

        private SelectPointTool               zoomMapSelectPointTool         = null;

        private PagedTable                    table                          = null;

        private GeoPointList                  geoPointList                         = null;

        public GCPSynchronizationImpl(GeoPointList gpList, ToolListener listener) {

                this.toolListener = listener;

                this.geoPointList = gpList;

        }

        /**

         * Asigna las vistas

         * @param vRaster

         * @param vMap

         * @param zRaster

         * @param zMap

         */

        public void setViews(

                        GeoreferencingView vRaster, 

                        GeoreferencingView vMap, 

                        GeoreferencingView zRaster, 

                        GeoreferencingView zMap,

                        PagedTable table) {

                this.table = table;

                viewRaster = (ViewPanelImpl)vRaster;

                viewMap = (ViewPanelImpl)vMap;

                zoomMap = (ZoomPanelImpl)zMap;

                zoomRaster = (ZoomPanelImpl)zRaster;

                if(zoomRaster != null)

                        zoomRasterSelectPointTool = new SelectPointTool(zoomRaster.getCanvas(), toolListener);

                if(zoomMap != null)

                        zoomMapSelectPointTool = new SelectPointTool(zoomMap.getCanvas(), toolListener);

                if(viewRaster != null)

                        viewRasterSelectPointTool = new SelectPointTool(viewRaster.getCanvas(), toolListener);

                if(viewMap != null)

                        viewMapSelectPointTool = new SelectPointTool(viewMap.getCanvas(), toolListener);

                createGCPLayers();

                registerPointToolListener();

        }

        /**

         * Asigna los gestores de peticiones.

         * @param vRaster

         * @param vMap

         * @param zRaster

         * @param zMap

         */

        public void setRequestsManager(

                        IViewRequestManager vRaster, 

                        IViewRequestManager vMap, 

                        IViewRequestManager zRaster, 

                        IViewRequestManager zMap) {

                viewRasterRequestManager = vRaster;

                viewMapRequestManager= vMap;

                zoomRasterRequestManager = zRaster;

                zoomMapRequestManager = zMap;

        }

        /**

         * Asigna las capas de puntos

         * @param vRaster

         * @param vMap

         * @param zRaster

         * @param zMap

         */

        public void setLayerPoints(

                        IGraphicLayer vRaster, 

                        IGraphicLayer vMap, 

                        IGraphicLayer zRaster, 

                        IGraphicLayer zMap) {

                viewRasterGCPs = (GCPsGraphicLayer)vRaster;

                viewMapGCPs = (GCPsGraphicLayer)vMap;

                viewRasterGCPsZoom = (GCPsGraphicLayer)zRaster;

                viewMapGCPsZoom = (GCPsGraphicLayer)zMap;

        }

        /**

         * Activa o desactiva la capa de puntos

         * @param active

         */

        public void setActiveLayerZoomCursor(boolean active) {

                if(viewRaster != null && viewRaster.getZoomCursorGraphicLayer() != null) 

                        viewRaster.getZoomCursorGraphicLayer().setActive(active);

                if(viewMap != null && viewMap.getZoomCursorGraphicLayer() != null)

                        viewMap.getZoomCursorGraphicLayer().setActive(active);

        }

        /**

         * Recalcula las coordenadas de dibujado de los puntos de control

         * y redibuja estos en todas las vistas

         */

        public void redrawPoints() {

                if(viewMapGCPs != null)

                        viewMapGCPs.recalcMapDrawCoordinates();

                if(viewRasterGCPs != null)

                        viewRasterGCPs.recalcPixelDrawCoordinates();

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.recalcMapDrawCoordinates();

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.recalcPixelDrawCoordinates();

                repaint();        

        }

        /**

         * Redibuja el canvas de todas las vistas

         */

        private void repaint() {

                if(viewRaster != null)

                        viewRaster.getCanvas().repaint();

                if(viewMap != null)

                        viewMap.getCanvas().repaint();

                if(zoomMap != null)

                        zoomMap.getCanvas().repaint();

                if(zoomRaster != null)

                        zoomRaster.getCanvas().repaint();

        }

        /**

         * Registra el listener para la herramienta de selecci?n de puntos de control

         */

        public void registerPointToolListener() {

                if(zoomMap != null) {

                        zoomMapSelectPointTool.setActive(false);

                        zoomMap.getControl().addTool(zoomMapSelectPointTool);

                        zoomMap.getControl().registerToolListener(ZoomRectangleTool.class, toolListener);                        

                        zoomMap.getControl().registerToolListener(PanTool.class, toolListener);

                }

                if(zoomRaster != null) {

                        zoomRasterSelectPointTool.setActive(false);

                        zoomRaster.getControl().addTool(zoomRasterSelectPointTool);

                        zoomRaster.getControl().registerToolListener(ZoomRectangleTool.class, toolListener);

                        zoomRaster.getControl().registerToolListener(PanTool.class, toolListener);

                }

                if(viewRaster != null) {

                        viewRasterSelectPointTool.setActive(false);

                        viewRaster.getControl().addTool(viewRasterSelectPointTool);

                        viewRaster.getControl().registerToolListener(ZoomRectangleTool.class, toolListener);

                        viewRaster.getControl().registerToolListener(PanTool.class, toolListener);

                }

                if(viewMap != null) {

                        viewMapSelectPointTool.setActive(false);

                        viewMap.getControl().addTool(viewMapSelectPointTool);

                        viewMap.getControl().registerToolListener(ZoomRectangleTool.class, toolListener);

                        viewMap.getControl().registerToolListener(PanTool.class, toolListener);

                }

        }

        /**

         * A?ade un punto a las capas gr?ficas

         * @param map Coordenadas del mapa del punto

         * @param raster Coordenadas pixel del punto

         * @return identificador del punto a?adido

         */

        public long addPoint(Point2D map, Point2D raster) {

                GeoPoint gp = RasterLocator.getManager().getDataStructFactory().createGeoPoint(raster, map);

                long id = System.currentTimeMillis();

                //Esperamos al menos 5 ms para que la carga de los puntos no sea

                //tan r?pida que coincida el id de dos puntos

                try {

                        Thread.sleep(80);

                } catch (InterruptedException e) {

                }

                if(viewRasterGCPs != null) 

                        viewRasterGCPs.addPixelGeoPoint(gp, id);

                if(viewMapGCPs != null)

                        viewMapGCPs.addMapGeoPoint(gp, id);

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.addPixelGeoPoint(gp, id);

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.addMapGeoPoint(gp, id);

                return id;

        }

        /**

         * Elimina todos los puntos gr?ficos de las capas

         *

         */

        public void removeAllPoints() {

                if(viewRasterGCPs != null)

                        viewRasterGCPs.removeAllPoints();

                if(viewMapGCPs != null)

                        viewMapGCPs.removeAllPoints();

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.removeAllPoints();

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.removeAllPoints();

        }

        /**

         * Asigna las coordenadas del mundo real y raster al punto indicado en el par?metro. 

         * @param point Punto a asignar las nuevas coordenadas

         * @param xMap Coordenada real en X

         * @param yMap Coordenada real en Y

         * @param xRaster Coordenada pixel en X

         * @param yRaster Coordenada pixel en Y

         */

        public void setCoordinates(int point, double xMap, double yMap, double xRaster, double yRaster) {

                setXMapCoordinate(point, xMap);

                setYMapCoordinate(point, yMap);

                setXRasterCoordinate(point, xRaster);

                setYRasterCoordinate(point, yRaster);

                redrawPoints();

        }

        /**

         * Asigna la coordenada del mundo real X

         * @param point

         * @param xMap

         */

        public void setXMapCoordinate(int point, double xMap) {

                double oldMapY = viewRasterGCPs.getPoint(point).getGeoPoint().getMapPoint().getY();

                viewRasterGCPs.getPoint(point).getGeoPoint().getMapPoint().setLocation(xMap, oldMapY); 

        }

        /**

         * Asigna la coordenada del mundo real Y

         * @param point

         * @param yMap

         */

        public void setYMapCoordinate(int point, double yMap) {

                double oldMapX = viewRasterGCPs.getPoint(point).getGeoPoint().getMapPoint().getX();

                viewRasterGCPs.getPoint(point).getGeoPoint().getMapPoint().setLocation(oldMapX, yMap); 

        }

        /**

         * Asigna la coordenada raster X

         * @param point

         * @param xRaster

         */

        public void setXRasterCoordinate(int point, double xRaster) {

                double oldRasterY = viewRasterGCPs.getPoint(point).getGeoPoint().getPixelPoint().getY();

                viewRasterGCPs.getPoint(point).getGeoPoint().getPixelPoint().setLocation(xRaster, oldRasterY); 

        }

        /**

         * Asigna la coordenada raster Y

         * @param point

         * @param xRaster

         */

        public void setYRasterCoordinate(int point, double yRaster) {

                double oldRasterX = viewRasterGCPs.getPoint(point).getGeoPoint().getPixelPoint().getX();

                viewRasterGCPs.getPoint(point).getGeoPoint().getPixelPoint().setLocation(oldRasterX, yRaster);

        }

        /**

         * Elimina un punto de la lista a partir de su posici?n

         * @param position

         */

        public void removePoint(int position) {

                if(viewRasterGCPs != null)

                        viewRasterGCPs.removePixelGeoPoint(position);

                if(viewMapGCPs != null)

                        viewMapGCPs.removePixelGeoPoint(position);

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.removePixelGeoPoint(position);

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.removePixelGeoPoint(position);

        }

        /**

         * Informa de si la tool de selecci?n de puntos est? activa o no

         * @return true si est? activa y false si no lo est?

         */

        public boolean isSelectPointToolSelected() {

                if(viewRaster != null)

                        if(viewRaster.getControl().getToolSelected() instanceof SelectPointTool)

                                return true;

                return false;

        }

        /**

         * Obtiene la lista de puntos

         * @return ArrayList

         */

        public List<GPGraphic> getPointList() {

                if(viewRasterGCPs != null)

                        return viewRasterGCPs.getPointList();

                return null;

        }

        /**

         * Obtiene un array con la lista de puntos 

         * @return

         */

        public List<GeoPoint> getGeoPoints() {

                List<GPGraphic> pointList = getPointList();

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

                        geoPointList.add(((GPGraphic) pointList.get(i)).getGeoPoint());

                return geoPointList;

        }

        /**

         * Activa o desactiva la visualizaci?n de un punto.

         * @param active true para activarlo y false para desactivarlo

         * @param position Posici?n del punto

         */

        public void setVisiblePoint(boolean visible, int position) {

                if(viewRasterGCPs != null)

                        ((GPGraphic)viewRasterGCPs.getPointList().get(position)).setDraw(visible);

                if(viewMapGCPs != null)

                        ((GPGraphic)viewMapGCPs.getPointList().get(position)).setDraw(visible);

                if(viewRasterGCPsZoom != null)

                        ((GPGraphic)viewRasterGCPsZoom.getPointList().get(position)).setDraw(visible);

                if(viewMapGCPsZoom != null)

                        ((GPGraphic)viewMapGCPsZoom.getPointList().get(position)).setDraw(visible);

        }

        /**

         * Asigna la numeraci?n a los puntos de control. Tanto a la tabla como

         * a los GeoPuntos

         * @throws NotInitializeException

         */

        public void calcPointsNumeration() {

                List<GPGraphic> pointList = getPointList();

                for (int i = 0; i < table.getRowCount(); i++) { 

                        table.setValueAt(new Integer(i), i, 1);

                        long id = (long)((Long)table.getValueAt(i, table.getColumnCount() - 1)).longValue();

                        if(i < pointList.size()) {

                                for (int j = 0; j < pointList.size(); j++) {

                                        GPGraphic gpg = ((GPGraphic)pointList.get(j));

                                        if(id == gpg.getId()) {

                                                ((GPGraphic)pointList.get(j)).getGeoPoint().setNumber(i);

                                                break;

                                        }

                                }

                        }

                }

                redrawPoints();

        }

        public void createGCPLayers() {

                if(viewRaster != null) {

                        viewRasterGCPs = new GCPsGraphicLayer(GPGraphic.PIXEL, toolListener);

                        viewRasterGCPs.setCanvas(viewRaster.getCanvas());

                        viewRaster.addGraphicLayer(viewRasterGCPs);

                        viewRasterRequestManager.setGCPsGraphicLayer(viewRasterGCPs);

                }

                if(zoomRaster != null) {

                        viewRasterGCPsZoom = new GCPsGraphicLayer(GPGraphic.PIXEL, toolListener);

                        viewRasterGCPsZoom.setCanvas(zoomRaster.getCanvas());

                        zoomRaster.addGraphicLayer(viewRasterGCPsZoom);

                        zoomRasterRequestManager.setGCPsGraphicLayer(viewRasterGCPsZoom);

                }

                if(viewMap != null) {

                        viewMapGCPs = new GCPsGraphicLayer(GPGraphic.MAP, toolListener);

                        viewMapGCPs.setCanvas(viewMap.getCanvas());

                        viewMap.addGraphicLayer(viewMapGCPs);

                        viewMapRequestManager.setGCPsGraphicLayer(viewMapGCPs);

                }

                if(zoomMap != null) {

                        viewMapGCPsZoom = new GCPsGraphicLayer(GPGraphic.MAP, toolListener);

                        viewMapGCPsZoom.setCanvas(zoomMap.getCanvas());

                        zoomMap.addGraphicLayer(viewMapGCPsZoom);

                        zoomMapRequestManager.setGCPsGraphicLayer(viewMapGCPsZoom);

                }

        }

        /**

         * Activa y desactiva los n?meros de punto de las capas gr?ficas

         * @param active

         */

        public void setActiveNumberPoint(boolean active) {

                if(viewMapGCPs != null)

                        viewMapGCPs.setShowNumber(active);

                if(viewRasterGCPs != null)

                        viewRasterGCPs.setShowNumber(active);

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.setShowNumber(active);

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.setShowNumber(active);

        }

        /**

         * Activa o desactiva la capa de puntos

         * @param active

         */

        public void setActiveLayerPoints(boolean active) {

                if(viewRasterGCPs != null) 

                        viewRasterGCPs.setActive(active);

                if(viewMapGCPs != null)

                        viewMapGCPs.setActive(active);

                if(viewRasterGCPsZoom != null)

                        viewRasterGCPsZoom.setActive(active);

                if(viewMapGCPsZoom != null)

                        viewMapGCPsZoom.setActive(active);

        }

        /**

         * Obtiene un punto (GeoPoint) a partir de su n?mero. Hay que tener en cuenta que el n?mero de

         * punto puede no coincidir con su posici?n en el array.

         * @return GeoPoint

         */

        public GeoPoint getPointByNumber(int number) {

                List<GPGraphic> pointList = getPointList();

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

                        GeoPoint p = ((GPGraphic)pointList.get(i)).getGeoPoint();

                        if(p.getNumber() == number)

                                return p;

                }

                return null;

        }

        /**

         * Obtiene la posici?n de un punto a partir de su n?mero. Hay que tener en cuenta que el n?mero de

         * punto puede no coincidir con su posici?n en el array.

         * @return entero con la posici?n o -1 si no existe

         */

        public int getPointPositionByNumber(int number) {

                List<GPGraphic> pointList = getPointList();

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

                        GeoPoint p = ((GPGraphic)pointList.get(i)).getGeoPoint();

                        if(p.getNumber() == number)

                                return i;

                }

                return -1;

        }

}