| gvSIG desktop 1

	private int idStart = -1;

	private ArrayList idStops = null;

	private ArrayList<IDijkstraListener> listeners = new ArrayList<IDijkstraListener>();

	private boolean callMinimumCostNodeSelectedListeners(GvNode node) {

	private boolean callAdjacenteEdgeVisitedListeners(GvNode fromNode, GvEdge edge) {

	private class StopAux {

	private GvFlag sourceFlag;

	private boolean bExploreAll = false; // by default

	private double maxCost = Double.MAX_VALUE;

	private double maxDistance = Double.MAX_VALUE;

	private GvFlag[] destinations;

	private GeometryFactory geomFactory = new GeometryFactory();

	private int fieldIndexStreetName;

	public void setFielStreetName(String name) {

		try {

			int aux = net.getLayer().getRecordset().getFieldIndexByName(name);

			if (aux == -1)

				throw new RuntimeException("Field " + name + " not found.");

			fieldIndexStreetName = aux;

		} catch (BaseException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	private void populateRouteSimple(int idStart, int idEnd)

			throws BaseException {

				int idEnlace;

				GvNode node;

				GvEdge link;

				double costeEntrada;

				// Trazar el camino desde idEnd hasta idStart hacia atr?s marcando los Enlaces

				double Coste = 0;

				double Coste2 = 0;

				IGraph graph = net.getGraph();

				node = graph.getNodeByID(idEnd);

				int from_link = node.get_best_from_link();

				VectorialAdapter va = (VectorialAdapter) net.getLayer().getSource();

				while (node.getIdNode() != idStart)

				{

					if (from_link == -1)

					{

						throw new RuntimeException("Fallo al recorrer de manera inversa la soluci?n. Encontrado arco con -1");

						// break; // FALLO!!

					} 

					link = graph.getEdgeByID(from_link);

					IFeature feat = va.getFeature(link.getIdArc());

					route.addRouteFeature(feat.getGeometry(), link.getIdArc(), 

							link.getWeight(), link.getDistance(), feat.getAttribute(getFieldIndexStreetName()).toString());

					node = graph.getNodeByID(link.getIdNodeOrig());

					Coste = Coste + link.getWeight();

					Coste2 = Coste2 + link.getDistance();

					// TODO:

					// from_link = node.get_from_link(idEnlace, &costeEntrada);

					from_link = node.get_best_from_link();

			    }	

				System.out.println("Salgo con node = " + node.getIdNode());

			}

	protected void populateRoute(GvFlag origin, GvFlag dest, int idStart,

			int idEnd) throws BaseException {

					int idEnlace;

					GvNode node;

					GvEdge link;

					double costeEntrada;

					// Trazar el camino desde idEnd hasta idStart hacia atr?s marcando los Enlaces

					IGraph graph = net.getGraph();

					node = graph.getNodeByID(idEnd);

					int from_link = node.get_best_from_link();

					VectorialAdapter va = (VectorialAdapter) net.getLayer().getSource();

					/*	Miramos los nodos de los tramos inicio y final, y cogemos el nodo que tenga el from_link rellenado. E IGUAL A NUMSOLUCGLOBAL!!!!

						A partir de ah?, recorremos hacia atr?s y tenemos el cuerpo principal del shape. Luego, para

						las puntas hay que tener en cuenta los porcentajes, viendo el trozo que est? pegando a los nodos

						que sabemos que est?n en el path

					*/

					/* 22/9/2003 Corregimos el fallo que hab?a de escribir el shape de atr?s adelante.

					*  Guardamos lo que necesitamos en listaShapes y recorremos esa lista guardando los tramos

					*	con el sentido adecuado.

					*/

					/* 3/Febrero/2005 Limpieza de c?digo superfluo y correci?n de un fallo raro. Ahora es m?s simple y parece

					* que no falla. A ver si dura. IDEA: quiz?s se necesite meter el porcentaje en los arcos partidos.

					*/	

					// Define a template class for a vector of IDs.

					InfoShp infoShp;

					Stack pilaShapes = new Stack();

			//		typedef stack<CInfoShp> PILAINFO;

			//		PILAINFO pilaShapes;

					double costeTramoFinal=-1;

					GvNode nodeEnd = graph.getNodeByID(idEnd);

					GvEdge finalEdge = graph.getEdgeByID(nodeEnd.get_best_from_link());

					costeTramoFinal = finalEdge.getWeight();

					GvNode pNodo;

					GvEdge pEnlace;

					boolean bFlipearShape = false;

					double pctMax, pctMin;

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

					// Trozo del final

					// El shape va de idStop1 a idStop2, y el porcentaje viene en ese sentido.

					// Si el idEnd es idStop1, quiere decir que el tramo que falta va en ese sentido tambi?n,

					// as? que recorremos ese shape desde idStop1 hasta que rebasemos o igualemos ese porcentaje.

					// Si no, hemos pasado por idStop2 y la parte que hay que meter es desde el pto interior a idStop2

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

					IFeature feat = va.getFeature(finalEdge.getIdArc());

					MultiLineString jtsGeom = (MultiLineString) feat.getGeometry().toJTSGeometry();

			//		CoordinateFilter removeDuplicates = new UniqueCoordinateArrayFilter(); 

			//		jtsGeom.apply(removeDuplicates);

			//		jtsGeom.geometryChanged();

					// SI ESTAMOS SOBRE EL MISMO TRAMO, CASO PARTICULAR

					// y el sentido de circulaci?n es correcto

					if ((origin.getIdArc() == dest.getIdArc()) && (nodeEnd.getBestCost() <= costeTramoFinal))

					{

						if (dest.getPct() > origin.getPct())

						{

							pctMax = dest.getPct();

							pctMin = origin.getPct(); 

						}

						else

						{

							pctMax = origin.getPct();

							pctMin = dest.getPct();

							bFlipearShape = true;

						}

						LineString line = NetworkUtils.getPartialLineString(jtsGeom, 

								pctMax, 1);

						pctMin = pctMin / pctMax; // Porque ha cambiado la longitud

													// del shape

						line = NetworkUtils.getPartialLineString(line, pctMin, 0);

						if (bFlipearShape)

							line = line.reverse();

						IGeometry geom = FConverter.jts_to_igeometry(line);

						// TODO: Calcular bien el length de este arco, 

						// basandonos en el porcentaje costeTramoFinal / costeOriginal

						route.addRouteFeature(geom, origin.getIdArc(), 

								costeTramoFinal, line.getLength(), feat.getAttribute(getFieldIndexStreetName()).toString());

						return ; // Deber?a sacar el coste

					}

					// Trazar el camino desde idEnd hasta idStart hacia atr?s marcando los Enlaces

					pNodo = graph.getNodeByID(idEnd);

					while ((pNodo.getIdNode() != idStart)) 

					{

						idEnlace = pNodo.get_best_from_link();

						pEnlace = graph.getEdgeByID(idEnlace);

						pNodo = graph.getNodeByID(pEnlace.getIdNodeOrig());

						infoShp = new InfoShp();

						infoShp.distance = pEnlace.getDistance();

						infoShp.cost = pEnlace.getWeight();

						if ((pEnlace.getIdArc() == origin.getIdArc()) || (pEnlace.getIdArc() == dest.getIdArc()))

						{

							if (pEnlace.getIdArc() == origin.getIdArc())

							{

								infoShp.pct = origin.getPct();

								infoShp.idArc = origin.getIdArc();

								if (pEnlace.getDirec() == 0) 

								{

									infoShp.direction = 1;

									infoShp.bFlip = true;

								}

								else // Hemos pasado por el 2

								{

									infoShp.direction = 0;

									infoShp.bFlip = false;

								} // if else */

							}

							else

							{

								infoShp.pct = dest.getPct();

								infoShp.idArc = dest.getIdArc();

								if (pEnlace.getDirec() == 0)

								{

									infoShp.direction = 0;

									infoShp.bFlip = true;

								}

								else

								{

									infoShp.direction = 1;

									infoShp.bFlip = false;

								} // if else */

							}

						}

						else

						{

							infoShp.pct = 1.0;

							infoShp.idArc = pEnlace.getIdArc();

							infoShp.direction =1;

							if (pEnlace.getDirec() == 1)

								infoShp.bFlip = false;

							else

								infoShp.bFlip = true;

						}

						pilaShapes.push(infoShp);

					}

					// Y ahora recorremos hacia atr?s el vector y escribimos los shapes.

					// VECTORINFO::iterator theIterator;

					int auxC = 0;

					while (!pilaShapes.empty())  

					{

						infoShp = (InfoShp) pilaShapes.peek();

						feat = va.getFeature(infoShp.idArc);

						MultiLineString line = (MultiLineString) feat.getGeometry().toJTSGeometry();

			//			line.apply(removeDuplicates);

			//			line.geometryChanged();

						LineString aux = null;

						if (infoShp.pct < 1.0)

							aux = NetworkUtils.getPartialLineString(line, infoShp.pct,

									infoShp.direction);

						IGeometry geom = null;

						if (aux == null)

						{

							if (infoShp.bFlip)

								line = line.reverse();

							geom = FConverter.jts_to_igeometry(line);

						}	

						else

						{

							if (infoShp.bFlip)

								aux = aux.reverse();

							geom = FConverter.jts_to_igeometry(aux);

						}	

						route.addRouteFeature(geom, infoShp.idArc, 

								infoShp.cost, infoShp.distance, feat.getAttribute(getFieldIndexStreetName()).toString());

						pilaShapes.pop();

						auxC++;

					}

					return;

				}

	LineString SituaSobreTramo(Geometry geom, int idArc, double pct, int parte) {

		int j, numVertices;

		double longAcum, longReal, longBuscada, distSobre, miniPorcentaje;

		double nuevaX, nuevaY; // Por cuestiones de claridad al programar

		double dist=0;

		longAcum = 0;

		longReal = geom.getLength();

		longBuscada = longReal * pct;

		Coordinate[] coords = geom.getCoordinates();

		Coordinate c1 = null, c2 = null;

		ArrayList savedCoords = new ArrayList();

	 	if (parte > 0) // Hemos entrado por el 1 hacia el 2 (al 2 no llegamos)

		{

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

			{

				c1 = coords[j];

				c2 = coords[j+1];

				dist = c1.distance(c2);

				longAcum += dist;

				savedCoords.add(c1);

				if (longAcum >= longBuscada)

				{

					// Hasta aqu?. Ahora ahi que poner el punto sobre el tramo

					distSobre = dist - (longAcum - longBuscada);

					miniPorcentaje = distSobre/dist;

					nuevaX = c1.x + (c2.x-c1.x) * miniPorcentaje;

					nuevaY = c1.y + (c2.y-c1.y) * miniPorcentaje;

					savedCoords.add(new Coordinate(nuevaX, nuevaY));

					break;

				} // if longAcum >= longBuscada

			} // for j

		}

		else // Hemos entrado por el 2 hacia el 1

		{

			numVertices = 0;

			for( j = 0; j < coords.length; j++ ) 

			{

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

				// 13_ene_2005: Si el ?ltimo punto es el ?ltimo punto no

				// podemos acceder al elemento j+1 porque nos salimos del shape

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

				c1 = coords[j];

				if (j < coords.length -1)

				{					

					c2 = coords[j+1];

					dist = c1.distance(c2);

					longAcum += dist;

				}

				if (longAcum >= longBuscada)

				{

					// Hasta aqu?. Empezamos a meter puntos

					if (numVertices == 0) 

					{

						distSobre = dist - (longAcum - longBuscada);

						miniPorcentaje = distSobre/dist;

						nuevaX = c1.x + (c2.x-c1.x) * miniPorcentaje;

						nuevaY = c1.y + (c2.y-c1.y) * miniPorcentaje;

						savedCoords.add(new Coordinate(nuevaX, nuevaY));

					}

					else

					{

						savedCoords.add(c2);

					}

					numVertices ++;

					// break;

				} // if longAcum >= longBuscada

			} // for j

			// savedCoords.add(c2);

		} // if else

	 	return geomFactory.createLineString((Coordinate[] )savedCoords.toArray(new Coordinate[0]));

	}

	private int getFieldIndexStreetName() {

		return fieldIndexStreetName;

	}