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.graph.core;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.ArrayList;

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

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.VectorialAdapter;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.LineSegment;

public class Network {

        protected FLyrVect lyrVect;

        protected IGraph graph;

        protected ArrayList flags = new ArrayList();

        public void reconstruyeTramo(int idArc) {

                // TODO Auto-generated method stub

        }

        private int findClosestArc(double x, double y, double tolerance)

        {        

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

                FBitSet bitSet;

                try {

                        bitSet = lyrVect.queryByPoint(p, tolerance);

                        VectorialAdapter va = (VectorialAdapter) lyrVect.getSource();

                        int counter = 0;

                        double minDist = tolerance;

                        int foundGeom = -1;

                        for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet

                                        .nextSetBit(i + 1)) {

                                IGeometry geom;

                                geom = va.getShape(i);

                                Point2D nearest = getNearestPoint(p, geom, tolerance);

                                if (nearest != null)

                                {

                                        double dist = nearest.distance(p);

                                        if (dist < minDist)

                                        {

                                                minDist = dist;

                                                foundGeom = i;

                                        }

                                }

                        }

                        return foundGeom;

                } catch (DriverException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                } catch (DriverIOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                return -1;

        }

        protected Point2D getNearestPoint(Point2D point, IGeometry geom, double tolerance) {

                Point2D resul = null;

                Coordinate c = new Coordinate(point.getX(), point.getY());

                PathIterator theIterator = geom.getPathIterator(null, FConverter.FLATNESS); //polyLine.getPathIterator(null, flatness);

                double[] theData = new double[6];

                double minDist = tolerance;

                Coordinate from = null, first = null;

                while (!theIterator.isDone()) {

                        //while not done

                        int theType = theIterator.currentSegment(theData);

                        switch (theType) {

                                case PathIterator.SEG_MOVETO:

                                        from = new Coordinate(theData[0], theData[1]);

                                        first = from;

                                        break;

                                case PathIterator.SEG_LINETO:

                                        // System.out.println("SEG_LINETO");

                                        Coordinate to = new Coordinate(theData[0], theData[1]);

                                        LineSegment line = new LineSegment(from, to);

                                        Coordinate closestPoint = line.closestPoint(c);

                                        double dist = c.distance(closestPoint);

                                        if ((dist < minDist)) {

                                                resul = new Point2D.Double(closestPoint.x, closestPoint.y);

                                                minDist = dist;

                                        }

                                        from = to;

                                        break;

                                case PathIterator.SEG_CLOSE:

                                        line = new LineSegment(from, first);

                                        closestPoint = line.closestPoint(c);

                                        dist = c.distance(closestPoint);

                                        if ((dist < minDist)) {

                                                resul = new Point2D.Double(closestPoint.x, closestPoint.y);

                                                minDist = dist;

                                        }

                                        from = first;

                                        break;

                        } //end switch

                        theIterator.next();

                }

                return resul;

        }

        /**

         * TODO: POR TERMINAR!!!

         * @param flag

         * @return

         */

        public int creaArcosVirtualesComplejo(GvFlag flag) {

//                 Devuelve el idNodo del nodo virtual creado.

                /*        0.- Creamos el nuevo Nodo virtual.

                        1.- Recorremos los arcos nuevos mirando su idTramo.

                        2.- Si existe ese idtramo=> Ya hemos partido antes ese idTramo. Buscamos el arco virtual que contiene

                                ese nodo y lo partimos. Ojo, recorrer hasta el final los tramos para asegurarnos de que es el trozo

                                m?s peque?o.

                        3.- Si NO existe, utilizamos el IndiceArcos para coger los arcos que toca y partirlos.

                  4.- OJO: Si el porcentaje es 0 ? 100, no partimos el arco, devolvemos el id del nodo que toca.

                */

                        // NUEVO: 20/7/2004:

                        // Cuando trabajamos con sentidos, al partir un arco no podemos insertar 2 nuevos sin mirar

                        // si es o no de un ?nico sentido.) (Mirar idArco. Si es -1, no partimos el arco).

                        // FIN NUEVO

                        int idNodo1, idNodo2;

                        int idArco, elIdArco, elIdContraArco;

                        boolean encontrado;

                        GvNode newNode;

                                // Sacamos los idNodos del tramo

                        EdgePair edgePair = graph.getEdgesByIdArc(flag.getIdArc());

                        if (edgePair.getIdEdge() != -1)

                        {

//                                idNodo1 = Arcos[IndiceArcos[idTramo].idArco].idNodo1;

//                                idNodo2 = Arcos[IndiceArcos[idTramo].idArco].idNodo2;

                                idNodo1 = graph.getEdgeByID(edgePair.getIdEdge()).getIdNodeOrig();

                                idNodo2 = graph.getEdgeByID(edgePair.getIdEdge()).getIdNodeEnd();

                        }

                        else

                        {

//                                idNodo2 = Arcos[IndiceArcos[idTramo].idContraArco].idNodo1;

//                                idNodo1 = Arcos[IndiceArcos[idTramo].idContraArco].idNodo2;

                                idNodo2 = graph.getEdgeByID(edgePair.getIdInverseEdge()).getIdNodeOrig();

                                idNodo1 = graph.getEdgeByID(edgePair.getIdInverseEdge()).getIdNodeEnd();

                        }

                        if (flag.getPct() == 0)

                                return idNodo1;

                        if (flag.getPct() == 1) 

                                return idNodo2;

                        // Creamos el nodo de enmedio

//                        if (numNodos == maxNodos) // La jodimos, T?rtola, hay que usar reallocate

//                        {

//                                // NOTA: ESTO EN DEBUG HACE QUE FALLE AL USAR DESPUES EnlacesSTL. ES POR NO S? QU? HISTORIA

//                                // DEL HEAP. EN RELEASE NO FALLA. (TAMPOCO S? SI FASTIDIA ALGO).

//                                Nodos = (CNode *) realloc(Nodos,(numNodos + MAX_RESERVA_NODOS) * sizeof(CNode)); // Deber?amos chequear que devuelve algo correcto

//                                maxNodos = numNodos + MAX_RESERVA_NODOS;

//                        }

                        newNode = new GvNode();

                        // Nodo = &Nodos[numNodos];

//                        pNuevoNodo->idNodo = numNodos;

                        newNode.setIdNode(graph.numVertices());

                        // OJO: Las coordenadas estas puede que no tengan que ver con la realidad. Algo m?s correcto

                        // ser?a tener en cuenta el shape de verdad, pero creo que no influye en el resultado final.

//                        pNuevoNodo->x = Nodos[idNodo1].x + (Nodos[idNodo2].x - Nodos[idNodo1].x) * Porcentaje;

//                        pNuevoNodo->y = Nodos[idNodo1].y + (Nodos[idNodo2].y - Nodos[idNodo1].y) * Porcentaje;

                        GvNode node1 = graph.getNodeByID(idNodo1);

                        GvNode node2 = graph.getNodeByID(idNodo2);

                        newNode.setX(node1.getX() + (node2.getX() - node1.getX()) * flag.getPct());

                        newNode.setY(node1.getY() + (node2.getY() - node1.getY()) * flag.getPct());

                        encontrado = false;

                        elIdArco = -1;

                        elIdContraArco = -1;

                        boolean bIdTramoYaPartido = false;

                        // TODO: POR AQUI VOY

                        /* for (idArco = numArcosOriginal; idArco < numArcos; idArco++)

                        {

                                if (Arcos[idArco].idTramo == idTramo)

                                {

                                        bIdTramoYaPartido = true;

                                        idNodo1 = Arcos[idArco].idNodo1;

                                        idNodo2 = Arcos[idArco].idNodo2;

                                        // Comprobamos si est? enmedio

                                        CVector2 vA(Nodos[idNodo1].x, Nodos[idNodo1].y);

                                        CVector2 vB(Nodos[idNodo2].x, Nodos[idNodo2].y);

                                        CVector2 vPoint(pNuevoNodo->x, pNuevoNodo->y);

                                        CVector2 vVector1 = vPoint - vA;

                                        // Create a normalized direction vector from end point vA to end point vB

                                        CVector2 vVector2 = Normalize(vB - vA);

                                        // Use the distance formula to find the distance of the line segment (or magnitude)

                                        double d = Distance(vA, vB);

                                        // Using the dot product, we project the vVector1 onto the vector vVector2.

                                        // This essentially gives us the distance from our projected vector from vA.

                                        double t = Dot(vVector2, vVector1);

                                        // Si la proyecci?n es positiva y menor que la magnitud d, est? en medio

                                    if ((t >= 0) && (t <= d)) 

                                        {

                                                encontrado = true;

                                                if (t==0) return idNodo1; // No partimos

                                                if (t==d) return idNodo2; // Tampoco partimos

                                                if (Arcos[idArco].sentido)

                                                        elIdArco = idArco;

                                                else

                                                        elIdContraArco = idArco;

                                        } // if est? enmedio

                                } // if idTramo encontrado

                        } // for idArco

                        if (bIdTramoYaPartido && (! encontrado)) 

                                MessageBox(NULL,"Algo va mal con lo del producto escalar","",MB_OK);

                        if (encontrado)

                        {

//                                sprintf(Mensaje,"Voy a partir el idTramo= %ld (idArco %ld)",idTramo,elIdArco);

                                // MessageBox(NULL,Mensaje,"",MB_OK);

                                if (elIdArco != -1)

                                        PartirArco(elIdArco, numNodos);

                                if (elIdContraArco != -1)

                                        PartirArco(elIdContraArco, numNodos);

                        }

                        else

                        {

                                // Creamos 2 Arcos por cada arco que ten?amos antes.

                                if (IndiceArcos[idTramo].idArco != -1)

                                        PartirArco(IndiceArcos[idTramo].idArco, numNodos);

                                if (IndiceArcos[idTramo].idContraArco != -1)

                                        PartirArco(IndiceArcos[idTramo].idContraArco, numNodos);

                        } // else encontrado

                        numNodos++;

                        return (numNodos -1); */

                        return graph.numVertices();

        }

        /**

         * TODO: Por ahora, cogemos el nodo m?s cercano. Lo correcto

         * es a?adir un nuevo nodo que divida el arco, y devolver el 

         * id de ese nodo.

         * @param flag

         * @return

         */

        public int creaArcosVirtuales(GvFlag flag) {

                EdgePair pair = graph.getEdgesByIdArc(flag.getIdArc());

                if (pair.getIdEdge() != -1)

                {

                        GvEdge edge = graph.getEdgeByID(pair.getIdEdge());

                        GvNode from = graph.getNodeByID(edge.getIdNodeOrig());

                        GvNode to = graph.getNodeByID(edge.getIdNodeEnd());

                        double dist1 = flag.getOriginalPoint().distance(from.getX(), from.getY());

                        double dist2 = flag.getOriginalPoint().distance(to.getX(), to.getY());

                        if (dist1 < dist2)

                                return from.getIdNode();

                        else

                                return to.getIdNode();

//                        if (flag.getPct() > 0.5)

//                                return to.getIdNode();

//                        else        

//                                return from.getIdNode();

                }

                else

                {

                        GvEdge edge = graph.getEdgeByID(pair.getIdInverseEdge());

                        GvNode from = graph.getNodeByID(edge.getIdNodeOrig());

                        GvNode to = graph.getNodeByID(edge.getIdNodeEnd());

                        double dist1 = flag.getOriginalPoint().distance(from.getX(), from.getY());

                        double dist2 = flag.getOriginalPoint().distance(to.getX(), to.getY());

                        if (dist1 < dist2)

                                return from.getIdNode();

                        else

                                return to.getIdNode();

//                        if (flag.getPct() < 0.5)

//                                return to.getIdNode();

//                        else        

//                                return from.getIdNode();                        

                }

        }

        /**

         * @param idArc

         * @param x

         * @param y

         * @return entre 0.0 y 1.0

         */

        private double percentAlong(long idArc, double x, double y)

        {

                return 0;

        }

        /**

         * Adds a flag on a network. flagDirection set if the flag

         * must be on left or right edge.

         * @param x

         * @param y

         * @param flagDirection

         * @param tol tolerance in map units

         * @return null if there is no place to add flag.

         *  You can increase the tolerance, then. 

         */

        public GvFlag addFlag(double x, double y, int flagDirection, double tol)

        {

                int idArc = findClosestArc(x, y, tol);

                if (idArc == -1)

                        return null;

                GvFlag flag = new GvFlag(x,y);

                flag.setIdArc(idArc);

                flag.setPct(percentAlong(idArc, x, y));

                flag.setDirec(flagDirection);

                flag.setIdFlag(flags.size());

                return flag;                

        }

        /**

         * Adds 2 flags on a network. (On both sides of an arc)

         * @param x

         * @param y

         * @param tol tolerance in map units

         * @return null if there is no place to add flag.

         *  You can increase the tolerance, then. 

         */        

        public GvFlag addFlag(double x, double y, double tol)

        {

                int idArc = findClosestArc(x, y, tol);

                if (idArc == -1)

                        return null;

                GvFlag flag = new GvFlag(x, y);

                flag.setIdArc(idArc);

                flag.setDirec(GvFlag.BOTH_DIRECTIONS);

                flag.setPct(percentAlong(idArc, x, y));

                flag.setIdFlag(flags.size());

                flags.add(flag);

                return flag;

        }

        public void addFlag(GvFlag flag) {

                flags.add(flag);

        }

        public GvFlag[] getFlags() {

                return (GvFlag[]) flags.toArray(new GvFlag[0]);

        }

        public void setFlags(ArrayList flags) {

                this.flags = flags;

        }

        public IGraph getGraph() {

                return graph;

        }

        public void setGraph(IGraph graph) {

                this.graph = graph;

        }

        public FLyrVect getLayer() {

                return lyrVect;

        }

        public void setLayer(FLyrVect lyr) {

                this.lyrVect = lyr;

        }

        public void removeFlags() {

                flags = new ArrayList();                

        }

        void PartirArco(int idEdge, int idNode)

        {

                // Se supone que el nuevo Nodo YA est? creado. Aqui dentro se coge el arco viejo y se le pega un tajo.

                // (Se modifican los enlaces de los nodos de ese arco y se crean los arcos nuevos, fijando sus costes).

                // Para sacar el porcentaje nos aprovechamos de que el nuevo nodo est? puesto en base a ese porcentaje

                // en distancia de los extremos.

                GvEdge newEdge;

                GvEdge oldEdge;

                GvNode pN1, pN2;

                double pct;

                        oldEdge = graph.getEdgeByID(idEdge);

                        // OJO, controlando los ceros por si acaso la recta es horizontal o vertical (Y si mide cero???)

//                        pN1 = &Nodos[Arcos[idArco].idNodo1];

//                        pN2 = &Nodos[Arcos[idArco].idNodo2];

                        pN1 = graph.getNodeByID(graph.getEdgeByID(idEdge).getIdNodeOrig());

                        pN2 = graph.getNodeByID(graph.getEdgeByID(idEdge).getIdNodeEnd());

                        GvNode newNode = graph.getNodeByID(idNode);

                        if (newNode.getX() != pN1.getX())

                                pct = Math.abs((newNode.getX() - pN1.getX())/(pN2.getX()-pN1.getX()));

                        else

                                pct = Math.abs((newNode.getY() - pN1.getY())/(pN2.getY()-pN1.getY()));

                        GvEdge first = new GvEdge();

                        first.setIdEdge(graph.numEdges());

                        first.setIdArc(oldEdge.getIdArc());

                        first.setDistance(oldEdge.getDistance() * pct);

                        first.setWeight(oldEdge.getWeight() * pct);

                        first.setDirec(oldEdge.getDirec());

                        first.setIdNodeOrig(oldEdge.getIdNodeOrig());

                        first.setType(oldEdge.getType());

                        first.setIdNodeEnd(idNode);

                        graph.addEdge(first);

                        GvEdge second = new GvEdge();

                        second.setIdEdge(graph.numEdges());

                        second.setDistance(oldEdge.getDistance()*(1.0-pct));

                        second.setWeight(oldEdge.getWeight()*(1.0-pct));

                        second.setIdArc(oldEdge.getIdArc());

                        second.setDirec(oldEdge.getDirec());

                        second.setType(oldEdge.getType());

                        second.setIdNodeOrig(idNode);

                        second.setIdNodeEnd(oldEdge.getIdNodeEnd());

                        graph.addEdge(second);

                        //////////////////////////////////////////////////////

                        // Ahora retocamos los enlaces que salen de cada nodo

                        //////////////////////////////////////////////////////

                        int i;

                        boolean encontrado = false;

                        for (i=0; i<pN1.getEnlaces().size(); i++)

                        {

                                GvEdge aux = (GvEdge) pN1.getEnlaces().get(i);

                                if (aux.getIdEdge() == idEdge)

                                {

                                        pN1.getEnlaces().set(i, first);

                                        encontrado = true;

                                        break;

                                }

                        } // for

                        newNode.getEnlaces().add(second);

        }

}