| gvSIG desktop 1

package org.gvsig.georeferencing.utils;

import java.awt.Dimension;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.StringWriter;

import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.apache.crimson.jaxp.DocumentBuilderFactoryImpl;

import org.apache.xml.serialize.OutputFormat;

import org.apache.xml.serialize.XMLSerializer;

import org.cresques.cts.ProjectionPool;

import org.gvsig.georeferencing.gui.dialogs.GeoreferencingDialog;

import org.gvsig.georeferencing.layers.FLyrGeoRaster;

import org.gvsig.georeferencing.layers.FLyrPoints;

import org.gvsig.georeferencing.layers.GeoPoint;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

import com.iver.andami.PluginServices;

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

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

import com.iver.cit.gvsig.gui.View;

/**

 * Clase que controla la persistencia de la capa de puntos. 

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

 */

public class GeoPointPersistence{

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

        private ArrayList                 geoPointList = null;

        private Document                 xmlDoc = null;

        private Element                 generalTag = null;

        private FLyrPoints                 lyrPoints = null;

        private double[]                lastViewPort = null;

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

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

        /**

         * Constructor

         */

        public GeoPointPersistence(){}

        /**

         * Constructor

         * @param geoPointList        Lista de geopuntos

         */

        public GeoPointPersistence(FLyrPoints lyrPoints){

                this.geoPointList = lyrPoints.getListPoint();

                this.lyrPoints = lyrPoints;

        }

        /**

         * Carga la lista de puntos desde un fichero

         * @param file        Nombre del fichero

         * @return        Array con la lista de puntos

         */

        public void loadPointList(String file){

                try {

                DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

                DocumentBuilder db = dbf.newDocumentBuilder();

                File f = new File(file);

                Document doc = db.parse(f);

                if(doc.getDocumentElement().getTagName().equals("GeoPoints")){

                        NodeList nodeList = doc.getDocumentElement().getChildNodes();

                        lyrPoints.clear();

                        for(int i=0;i<nodeList.getLength();i++){

                                Node node = nodeList.item(i);

                                if(node.getNodeName().equals("FLyrGeoRaster")){

                                        NodeList nl = node.getChildNodes();

                                        lastViewPort = processFlyrGeoRasterNodeValue(nl);        

                                }

                                if(node.getNodeName().equals("GeoPoint")){

                                        NodeList nl = node.getChildNodes();

                                        processGeoPointNodeValue(nl);        

                                }

                        }

                        this.geoPointList = lyrPoints.getListPoint();

                }

            } catch (ParserConfigurationException e) {

                    return;

            } catch (SAXException e1) {

                    return;

            } catch (IOException e1) {

                    return;

            }

        }

        /**

         * Crea el XML con la lista de puntos y la salva a disco

         * @param file

         */

        public void savePointList(String file){

                this.geoPointList = lyrPoints.getListPoint();

                try {

                        DocumentBuilderFactory dbFactory = DocumentBuilderFactoryImpl.newInstance();

                    DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();

                    xmlDoc = docBuilder.newDocument();

                } catch(Exception e) {

                      System.out.println(e);

                }

                generalTag = xmlDoc.createElement("GeoPoints");

                xmlDoc.appendChild(generalTag);

                createXMLFLyrGeoRasterNode(lyrPoints.getLyrGeoRaster());

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

                        createXMLGeoPointNode((GeoPoint)(geoPointList.get(i)), i);

                XML2File(Document2Text(), file);

        } 

        /**

         * Crea el fichero Ascii con la lista de puntos y la salva a disco

         * @param file

         */

        public void saveAsciiPointList(String file){

                this.geoPointList = lyrPoints.getListPoint();

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

                        //TODO: FALTA IMPLEMENTAR LA EXPORTACI?N DE LA TABLA

                }    

        } 

        //****************************************************

        /**

         * Aplica una transformaci?n al extent dependiendo de si el extent de la imagen 

         * original ha cambiado o no. Si la capa FLyrGeoRaster cargada tiene un extent

         * distinto al que se ha salvado en el fichero de puntos esto significa que el 

         * extent de la miniimagen que tiene los puntos relativos a las coordenadas de la

         * imagen en pixels ha de sufrir un desplazamiento.

         * @param imgExtent Extent de la imagen 

         * @param miniExtent ViewPor del miniextent a transformar

         * @return ViewPort        ViewPort del miniextent transformado 

         */

        private ViewPort transformMiniExtent(Rectangle2D imgExtent, ViewPort miniExtent){

                if(        lastViewPort[0] != imgExtent.getMinX() ||

                        lastViewPort[1] != imgExtent.getMinY() ||

                        lastViewPort[2] != imgExtent.getWidth() ||

                        lastViewPort[3] != imgExtent.getHeight()){

                        Rectangle2D r = new Rectangle2D.Double();

                        r.setRect(         miniExtent.getExtent().getMinX() - (lastViewPort[0] - imgExtent.getMinX()), 

                                                miniExtent.getExtent().getMinY() - (lastViewPort[1] - imgExtent.getMinY()),

                                                miniExtent.getExtent().getWidth(),

                                                miniExtent.getExtent().getHeight());

                        miniExtent.setExtent(r);

                }

                return miniExtent;

        }

        /**

         * Aplica una transformaci?n al centro del extent dependiendo de si el extent de la imagen 

         * original ha cambiado o no. 

         */

        private Point2D transformCenter(Rectangle2D imgExtent, Point2D center){

                if(        lastViewPort[0] != imgExtent.getMinX() ||

                        lastViewPort[1] != imgExtent.getMinY() ||

                        lastViewPort[2] != imgExtent.getWidth() ||

                        lastViewPort[3] != imgExtent.getHeight()){

                        Point2D c = new Point2D.Double();

                        c.setLocation(center.getX() - (lastViewPort[0] - imgExtent.getMinX()), 

                                                  center.getY() - (lastViewPort[1] - imgExtent.getMinY()));

                        return c;

                }

                return center;

        }

        /**

         * Obtiene el valor del extent de la imagen obtenido desde un nodo

         * XML. A partir de este valor obtenido crea un punto en la capa.

         */

        private double[] processFlyrGeoRasterNodeValue(NodeList nl){

                double[] res = null;

                for(int j=0;j<nl.getLength();j++){

                        Node geoNode = nl.item(j);

                        if(geoNode.getNodeName().equals("ViewPort")){

                                res = new double[4];

                                NodeList vpChildNodes = geoNode.getChildNodes();

                                for(int i=0;i<vpChildNodes.getLength();i++){

                                        Node vpNode = vpChildNodes.item(i);

                                        if(vpNode.getNodeName().equals("Extent")){

                                                NodeList extentChildNodes = vpNode.getChildNodes();

                                                for(int k=0;k<extentChildNodes.getLength();k++){

                                                        Node extentNode = extentChildNodes.item(k);

                                                        if(extentNode.getNodeName().equals("X"))

                                                                res[0] = Double.valueOf(extentNode.getFirstChild().getNodeValue()).doubleValue();

                                                        if(extentNode.getNodeName().equals("Y"))

                                                                res[1] = Double.valueOf(extentNode.getFirstChild().getNodeValue()).doubleValue();

                                                        if(extentNode.getNodeName().equals("Width"))

                                                                res[2] = Double.valueOf(extentNode.getFirstChild().getNodeValue()).doubleValue();

                                                        if(extentNode.getNodeName().equals("Height"))

                                                                res[3] = Double.valueOf(extentNode.getFirstChild().getNodeValue()).doubleValue();

                                                }

                                        }

                                }

                        }

                }

                return res;

        }

        /**

         * Obtiene el valor de un punto georeferenciado obtenido desde un nodo

         * XML. A partir de este valor obtenido crea un punto en la capa.

         */

        private void processGeoPointNodeValue(NodeList nl){

                Point2D leftCenter = null, rightCenter = null;

                ViewPort leftViewPort = null, rightViewPort = null;

                double pX = 0D, pY = 0D, mX = 0D, mY = 0D;

                boolean active = false;

                for(int j=0;j<nl.getLength();j++){

                        Node geoNode = nl.item(j);

                        if(geoNode.getNodeName().equals("PixelX"))

                                pX = Double.valueOf(geoNode.getFirstChild().getNodeValue()).doubleValue();

                        if(geoNode.getNodeName().equals("PixelY"))

                                pY = Double.valueOf(geoNode.getFirstChild().getNodeValue()).doubleValue();

                        if(geoNode.getNodeName().equals("MapX"))

                                mX = Double.valueOf(geoNode.getFirstChild().getNodeValue()).doubleValue();

                        if(geoNode.getNodeName().equals("MapY"))

                                mY = Double.valueOf(geoNode.getFirstChild().getNodeValue()).doubleValue();

                        if(geoNode.getNodeName().equals("Active"))

                                active =  Boolean.valueOf(geoNode.getFirstChild().getNodeValue()).booleanValue();

                        if(geoNode.getNodeName().equals("LeftCenterPoint"))

                                leftCenter = processCenterPoint(geoNode.getChildNodes());

                        if(geoNode.getNodeName().equals("RightCenterPoint"))

                                rightCenter = processCenterPoint(geoNode.getChildNodes());

                        if(geoNode.getNodeName().equals("LeftViewPort"))

                                leftViewPort = processViewPort(geoNode.getChildNodes());

                        if(geoNode.getNodeName().equals("RightViewPort"))

                                rightViewPort = processViewPort(geoNode.getChildNodes());

                }

                Point2D p = new Point2D.Double();

                p.setLocation(pX, pY);

                Point2D m = new Point2D.Double();

                m.setLocation(mX, mY);

                lyrPoints.getPointManager().newEmptyPoint();

                View theView = null;

                try{

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

                }catch(ClassCastException exc){

                        return;

                }

                int pos = lyrPoints.getCountPoints() -1;

                try{

                        leftViewPort = transformMiniExtent(lyrPoints.getLyrGeoRaster().getFullExtent(), leftViewPort);

                        leftCenter = transformCenter(lyrPoints.getLyrGeoRaster().getFullExtent(), leftCenter);

                }catch(DriverException ex){}

                lyrPoints.setPointActive(pos, active);

                lyrPoints.setLeftCenterPoint(pos,leftCenter);

                lyrPoints.setRightCenterPoint(pos, rightCenter);

                lyrPoints.setLeftViewPort(pos, leftViewPort);

                lyrPoints.setRightViewPort(pos, rightViewPort);

                lyrPoints.getPointManager().updateData(pos + 1, p, m, lyrPoints.getPointManager().getDialog(), theView);

                if(lyrPoints.getCountPoints() > 0){

                        GeoreferencingDialog grd = lyrPoints.getPointManager().getDialog();

                        grd.getConectorPanel().getDataPointsTabPanel().

                                getSelectPointsPanel().getTableControlerPanel().setNItems(lyrPoints.getCountPoints());

                        grd.getConectorPanel().getDataPointsTabPanel().

                                getTablePointsPanel().getTableControlerPanel().setNItems(lyrPoints.getCountPoints());

                        lyrPoints.getPointManager().selectPoint(0, grd);

                }

                //lyrPoints.addPoint(p, m);

        }

        /**

         * Procesa un nodo correspondiente a un extent

         * @param nodeList Lista de nodos

         * @return Rectangle2D

         */

        private Rectangle2D processExtent(NodeList nodeList){

                Rectangle2D r = new Rectangle2D.Double();

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

                for(int j=0;j<nodeList.getLength();j++){

                        Node node = nodeList.item(j);

                        if(node.getNodeName().equals("X"))

                                x = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                        if(node.getNodeName().equals("Y"))

                                y = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                        if(node.getNodeName().equals("Width"))

                                width = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                        if(node.getNodeName().equals("Height"))

                                height = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                }

                r.setRect(x, y, width, height);

                return r;

        }

        /**

         * Procesa un nodo correspondiente a la dimension de un viewPort

         * @param nodeList Lista de nodos

         * @return Rectangle2D

         */

        private Dimension processImageSize(NodeList nodeList){

                Dimension d = new Dimension();

                double x = 0D, y = 0D;

                for(int j=0;j<nodeList.getLength();j++){

                        Node node = nodeList.item(j);

                        if(node.getNodeName().equals("Width"))

                                x = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                        if(node.getNodeName().equals("Height"))

                                y = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                }

                d.setSize(x, y);

                return d;

        }

        /**

         * Procesa el nodo correspondiente a un viewport de una mini imagen

         * @param nodeList Lista de nodos

         * @return ViewPort obtenido

         */

        private ViewPort processViewPort(NodeList nodeList){

                ViewPort vp = new ViewPort(null);

                for(int j=0;j<nodeList.getLength();j++){

                        Node node = nodeList.item(j);

                        if(node.getNodeName().equals("Projection"))

                                vp.setProjection(ProjectionPool.get(node.getFirstChild().getNodeValue()));

                        if(node.getNodeName().equals("Extent"))

                                vp.setExtent(processExtent(node.getChildNodes()));

                        if(node.getNodeName().equals("Dimension"))

                                vp.setImageSize(processImageSize(node.getChildNodes()));

                }

                vp.setScale();

                return vp;

        }

        /**

         * Procesa un node correspondiente a un punto central de una

         * mini imagen

         * @param nodeList Lista de elementos del nodo centro

         * @return Punto obtenido

         */

        private Point2D processCenterPoint(NodeList nodeList){

                Point2D p = new Point2D.Double();

                double x = 0D, y = 0D;

                for(int j=0;j<nodeList.getLength();j++){

                        Node node = nodeList.item(j);

                        if(node.getNodeName().equals("X"))

                                x = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                        if(node.getNodeName().equals("Y"))

                                y = Double.valueOf(node.getFirstChild().getNodeValue()).doubleValue();

                }

                p.setLocation(x, y);

                return p;

        }

        //****************************************************

        /**

         * Crea un elemento simple xml de la forma <elem>texNode</elem>

         * a?adiendoselo al elemento padre pasado por par?metro

         * @param parent Elemento padre del XML

         * @param elem        tag

         * @param textNode        valor

         */

        private void createSimpleElement(Element parent, String elem, String textNode){

                Element itemlevel1 = null;

                itemlevel1 = xmlDoc.createElement(elem);

                itemlevel1.appendChild(xmlDoc.createTextNode(textNode));

                parent.appendChild(itemlevel1);    

        }

        /**

         * Crear un bloque que representa un viewport

         * @param parent Elemento padre del XML

         * @param elem tag

         * @param values lista de valores

         */

        private void createViewPortNode(Element parent, String elem, String[] values){

                Element itemlevel1 = null;

                Element itemlevel2 = null;

                itemlevel1 = xmlDoc.createElement(elem);

                createSimpleElement(itemlevel1, "Projection", values[6]);

                itemlevel2 = xmlDoc.createElement("Extent");

                createSimpleElement(itemlevel2, "X", values[0]);

                createSimpleElement(itemlevel2, "Y", values[1]);

                createSimpleElement(itemlevel2, "Width", values[2]);

                createSimpleElement(itemlevel2, "Height", values[3]);

                itemlevel1.appendChild(itemlevel2);

                itemlevel2 = xmlDoc.createElement("Dimension");

                createSimpleElement(itemlevel2, "Width", values[4]);

                createSimpleElement(itemlevel2, "Height", values[5]);

                itemlevel1.appendChild(itemlevel2);                

                parent.appendChild(itemlevel1);

        }

        /**

         * Convierte la capa a georreferenciar a un elemento XML que ser? a?adidoo al

         * documento. 

         * @param lyrGeo Capa a georreferenciar 

         */

        private void createXMLFLyrGeoRasterNode(FLyrGeoRaster lyrGeo) {

                Element xmlGeoPoint;

                xmlGeoPoint = xmlDoc.createElement("FLyrGeoRaster");

                generalTag.appendChild(xmlGeoPoint);

                xmlGeoPoint.setAttribute("Name", lyrGeo.getName());

                String[] vpData = {String.valueOf(lyrGeo.getMinX()),

                                                        String.valueOf(lyrGeo.getMinY()),

                                                        String.valueOf(lyrGeo.getWidth()),

                                                        String.valueOf(lyrGeo.getHeight()),

                                                        String.valueOf(lyrGeo.getImageWidth()),

                                                        String.valueOf(lyrGeo.getImageHeight()),

                                                        lyrGeo.getProjection().getAbrev()};

                createViewPortNode(xmlGeoPoint, "ViewPort", vpData);

        }

        /**

         * Convierte un geopunto a un elemento XML que ser? a?adido al 

         * documento. 

         * @param geoPoint GeoPoint

         * @param i Posici?n del punto en la lista

         */

        private void createXMLGeoPointNode(GeoPoint geoPoint, int i) {

                Element xmlGeoPoint;

                Element itemlevel1;

                xmlGeoPoint = xmlDoc.createElement("GeoPoint");

                xmlGeoPoint.setAttribute("n", String.valueOf(i));

                generalTag.appendChild(xmlGeoPoint);

                createSimpleElement(xmlGeoPoint, "PixelX", String.valueOf(geoPoint.pixelPoint.getX()));

                createSimpleElement(xmlGeoPoint, "PixelY", String.valueOf(geoPoint.pixelPoint.getY()));

                createSimpleElement(xmlGeoPoint, "MapX", String.valueOf(geoPoint.mapPoint.getX()));

                createSimpleElement(xmlGeoPoint, "MapY", String.valueOf(geoPoint.mapPoint.getY()));

                createSimpleElement(xmlGeoPoint, "Active", String.valueOf(geoPoint.active));

                itemlevel1 = xmlDoc.createElement("LeftCenterPoint");

                createSimpleElement(itemlevel1, "X", String.valueOf(geoPoint.leftCenterPoint.getX()));

                createSimpleElement(itemlevel1, "Y", String.valueOf(geoPoint.leftCenterPoint.getY()));

                xmlGeoPoint.appendChild(itemlevel1);

                itemlevel1 = xmlDoc.createElement("RightCenterPoint");

                createSimpleElement(itemlevel1, "X", String.valueOf(geoPoint.rightCenterPoint.getX()));

                createSimpleElement(itemlevel1, "Y", String.valueOf(geoPoint.rightCenterPoint.getY()));

                xmlGeoPoint.appendChild(itemlevel1);

                String[] values1 = {String.valueOf(geoPoint.leftViewPort.getExtent().getX()),

                                                        String.valueOf(geoPoint.leftViewPort.getExtent().getY()),

                                                        String.valueOf(geoPoint.leftViewPort.getExtent().getWidth()),

                                                        String.valueOf(geoPoint.leftViewPort.getExtent().getHeight()),

                                                        String.valueOf(geoPoint.leftViewPort.getImageWidth()),

                                                        String.valueOf(geoPoint.leftViewPort.getImageHeight()),

                                                        geoPoint.leftViewPort.getProjection().getAbrev()};

                createViewPortNode(xmlGeoPoint, "LeftViewPort", values1);

                String[] values2 = {String.valueOf(geoPoint.rightViewPort.getExtent().getX()),

                                                        String.valueOf(geoPoint.rightViewPort.getExtent().getY()),

                                                        String.valueOf(geoPoint.rightViewPort.getExtent().getWidth()),

                                                        String.valueOf(geoPoint.rightViewPort.getExtent().getHeight()),

                                                        String.valueOf(geoPoint.rightViewPort.getImageWidth()),

                                                        String.valueOf(geoPoint.rightViewPort.getImageHeight()),

                                                        geoPoint.rightViewPort.getProjection().getAbrev()};

                createViewPortNode(xmlGeoPoint, "RightViewPort", values2);                

    }

        //****************************************************

        /**

         * escribe a disco el texto XML

         * @param textXML        Texto XML

         * @param fileName        Nombre del fichero

         */

        private void XML2File(String textXML, String fileName) {

            try {

              OutputStream fout= new FileOutputStream(fileName);

              OutputStream bout= new BufferedOutputStream(fout);

              OutputStreamWriter out = new OutputStreamWriter(bout);

              out.write(textXML);

              out.flush();

              out.close();

            }catch (IOException e) {

              System.out.println(e.getMessage());

            }

        }

        /**

         * Convierte el objeto Document que contiene el XML construido a 

         * texto XML para que podamos salvarlo a disco.

         * @return Cadena de texto XML

         */

        private String Document2Text() {

            StringWriter strWriter = null;

            XMLSerializer xmlSerializer = null;

            OutputFormat outFormat = null;

            try {

                    xmlSerializer = new XMLSerializer();

                    strWriter = new StringWriter();

                    outFormat = new OutputFormat();

                    outFormat.setEncoding("ISO-8859-15");

                    outFormat.setIndenting(true);

                    outFormat.setIndent(4);

                    xmlSerializer.setOutputCharStream(strWriter);

                    xmlSerializer.setOutputFormat(outFormat);

                    xmlSerializer.serialize(xmlDoc);

                    strWriter.close();

                   } catch (IOException ioEx) {

                      System.out.println("Error : " + ioEx);

                   }

                    return strWriter.toString();

        }

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

}