| gvSIG desktop 1

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

import com.iver.cit.gvsig.graph.GraphException;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.MultiLineString;

	protected int numOriginalEdges;

	protected int numOriginalNodes;

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

				if (nearest != null) {

					if (dist < minDist) {

	protected Point2D getNearestPoint(Point2D point, IGeometry geom,

			double tolerance) {

		PathIterator theIterator = geom.getPathIterator(null,

				FConverter.FLATNESS); // polyLine.getPathIterator(null,

										// flatness);

			// while not done

			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

	 * 

	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.

	 * 

	public int creaArcosVirtualesSimple(GvFlag flag) {

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

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

					from.getY());

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

					to.getY());

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

			// return to.getIdNode();

			// else

			// return from.getIdNode();

		} else {

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

					from.getY());

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

					to.getY());

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

			// return to.getIdNode();

			// else

			// return from.getIdNode();

	 * @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 tol

	 *            tolerance in map units

	 * @return null if there is no place to add flag. You can increase the

	 *         tolerance, then.

	 * @throws GraphException

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

		}

	 * 

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

		}

		numOriginalEdges = graph.numEdges();

		numOriginalNodes = graph.numVertices();

		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

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