| 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.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.IFeature;

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.iver.cit.gvsig.graph.GraphException;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.LineSegment;

import com.vividsolutions.jts.geom.MultiLineString;

public class Network {

        protected FLyrVect lyrVect;

        protected IGraph graph;

        protected ArrayList flags = new ArrayList();

        protected int numOriginalEdges;

        protected int numOriginalNodes;

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

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

                graph.addNode(newNode);

                Coordinate newC = new Coordinate(newNode.getX(), newNode.getY());

                encontrado = false;

                elIdArco = -1;

                elIdContraArco = -1;

                boolean bIdTramoYaPartido = false;

                // TODO: POR AQUI VOY

                for (idArco = numOriginalEdges; idArco < graph.numEdges(); idArco++) {

                        GvEdge addedEdge = graph.getEdgeByID(idArco);

                        if (addedEdge.getIdArc() == flag.getIdArc()) {

                                bIdTramoYaPartido = true;

                                idNodo1 = addedEdge.getIdNodeOrig();

                                idNodo2 = addedEdge.getIdNodeEnd();

                                // Comprobamos si est? enmedio

                                GvNode n1 = graph.getNodeByID(idNodo1);

                                GvNode n2 = graph.getNodeByID(idNodo2);

                                Coordinate c1 = new Coordinate(n1.getX(), n1.getY());

                                Coordinate c2 = new Coordinate(n2.getX(), n2.getY());

                                LineSegment line = new LineSegment(c1, c2);

                                double t = line.projectionFactor(newC);

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

                                // en medio

                                if ((t >= 0) && (t <= 1)) {

                                        encontrado = true;

                                        if (t == 0)

                                                return idNodo1; // No partimos

                                        if (t == 1)

                                                return idNodo2; // Tampoco partimos

                                        if (addedEdge.getDirec() == 1)

                                                elIdArco = idArco;

                                        else

                                                elIdContraArco = idArco;

                                } // if est? enmedio

                        } // if idTramo encontrado

                } // for idArco

                if (bIdTramoYaPartido && (!encontrado))

                        throw new RuntimeException(

                                        "Algo va mal con lo del producto escalar");

                if (encontrado) {

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

                        // %ld)",idTramo,elIdArco);

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

                        if (elIdArco != -1)

                                PartirArco(elIdArco, newNode.getIdNode());

                        if (elIdContraArco != -1)

                                PartirArco(elIdContraArco, newNode.getIdNode());

                } else {

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

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

                                PartirArco(edgePair.getIdEdge(), newNode.getIdNode());

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

                                PartirArco(edgePair.getIdInverseEdge(), newNode.getIdNode());

                } // else encontrado

                return newNode.getIdNode();

        }

        /**

         * 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 creaArcosVirtualesSimple(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

         * @throws DriverIOException

         */

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

                        throws DriverIOException {

                // Le pasamos el idTramo, la coordenada X de donde hemos pulsado y la

                // coordenada Y

                // Primero calculamos la longitud total del shape.

                // Luego calculamos el punto m?s cercano y su distancia para cada

                // segmento del shape.

                // Nos quedamos con el que est? m?s cerca y luego recorremos hasta ?l

                // acumulando distancia.

                // Finalmente, dividimos esa distancia por la longitud total.

                IGeometry geom = lyrVect.getSource().getShape(idArc);

                MultiLineString jtsGeom = (MultiLineString) geom.toJTSGeometry();

                Coordinate[] coords = jtsGeom.getCoordinates();

                Coordinate userCoord = new Coordinate(x, y);

                double longReal = 0;

                // Le pegamos una primera pasada para saber su longitud real.

                // OJO, NO TRABAJAMOS CON SHAPES MULTIPARTE, NO TIENE SENTIDO CON LAS

                // REDES (CREO)

                // POR ESO SUPONEMOS UNA ?NICA PARTE (L?NEA CONT?NUA)

                // A la vez calculamos el punto m?s cercano y su distancia para cada

                // segmento.

                double minDist = Double.MAX_VALUE;

                double distTo = 0;

                double dist = 0;

                Coordinate cOrig = null;

                Coordinate closestPoint = null;

                for (int j = 0; j < coords.length - 1; j++) {

                        Coordinate c1 = coords[j];

                        Coordinate c2 = coords[j + 1];

                        LineSegment line = new LineSegment(c1, c2);

                        Coordinate auxPoint = line.closestPoint(userCoord);

                        dist = userCoord.distance(auxPoint);

                        if ((dist < minDist)) {

                                minDist = dist;

                                cOrig = c1;

                                closestPoint = auxPoint;

                                distTo = longReal;

                        }

                        longReal += line.getLength();

                }

                dist = cOrig.distance(closestPoint);

                double longBuscada = distTo + dist;

                double pct;

                if (longReal > 0)

                        pct = longBuscada / longReal;

                else

                        pct = 0.0;

                return pct;

        }

        /**

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

         * @throws GraphException

         */

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

                        throws GraphException {

                try {

                        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;

                } catch (DriverIOException e) {

                        e.printStackTrace();

                        throw new GraphException(e);

                }

        }

        /**

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

         * @throws GraphException 

         */

        public GvFlag addFlag(double x, double y, double tol) throws GraphException {

                try {

                        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;

                } catch (DriverIOException e) {

                        e.printStackTrace();

                        throw new GraphException(e);

                }

        }

        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;

                numOriginalEdges = graph.numEdges();

                numOriginalNodes = graph.numVertices();

        }

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

        }

}