| gvSIG desktop 1

import com.iver.cit.gvsig.graph.core.NetworkLoader;

import com.iver.cit.gvsig.graph.core.NetworkRedLoader;

import com.iver.cit.gvsig.graph.core.NetworkWriter;

	NetworkWriter netBuilder = new NetworkWriter();

		// Para postgres:

		/* JdbcWriter pgEdgeWriter = new JdbcWriter();

		PostgreSQLDriver pgDriver = new PostgreSQLDriver();

		Connection conn = pgDriver.getConnection("localhost", 5432, "latin1", "postgres", "aquilina");

		stCreate.execute("CREATE TABLE nodes (id int4, x float8, y float8);");

		stCreate.execute("CREATE TABLE edges ();");

		conn.setAutoCommit(false);

		ResultSet res = st.executeQuery("SELECT nodes.oid, nodes.* FROM nodes;");

		// res.moveToInsertRow();

		ResultSet resEdges = st.executeQuery("SELECT edges.oid, edges.* FROM edges;");

		pgEdgeWriter.initialize(conn, res);

		pgNodeWriter.initialize(conn, resEdges);

		netBuilder.setEdgeWriter(pgEdgeWriter);

		netBuilder.setNodeWriter(pgNodeWriter); */

		netBuilder.setEdgeWriter(edgeWriter);

		netBuilder.setNodeWriter(nodeWriter);

import com.iver.cit.gvsig.graph.core.NetworkLoader;

import com.iver.cit.gvsig.graph.core.NetworkRedLoader;

import com.iver.cit.gvsig.graph.core.NetworkWriter;

		NetworkWriter netBuilder = new NetworkWriter();

			netBuilder.writeNetwork(true);

		NetworkWriter netBuilder;

		GenerateRedNetworkTask(FLyrVect layer, File redFile, NetworkWriter netBuilder){

			netBuilder.createRedFile(layer, redFile,  this);

		NetworkWriter netBuilder = new NetworkWriter();

/* 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.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteOrder;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.util.ArrayList;

import edu.uci.ics.jung.graph.Graph;

import edu.uci.ics.jung.graph.Vertex;

import edu.uci.ics.jung.graph.decorators.Indexer;

import edu.uci.ics.jung.graph.impl.DirectedSparseEdge;

import edu.uci.ics.jung.graph.impl.DirectedSparseVertex;

import edu.uci.ics.jung.graph.impl.SparseGraph;

/**

 * @author fjp

 * 

 * Primero vienen los arcos, y luego los nodos. En la cabecera, 3 enteros

 * con el numero de tramos, el de arcos y el de nodos.

 *

 */

public class NetworkRedLoader implements INetworkLoader {

	private File netFile = new File("c:/ejes.red");

	public IGraph loadNetwork() {

		long t1 = System.currentTimeMillis();

		int numArcs;

		int numEdges;

		int numNodes;

		short sentidoDigit; // => 1 en esa direcci?n. 0=> Al contrario. SOLO

		// SE UTILIZA PARA LOS CALCULOS POR IDTRAMO Y

		// PORCENTAJE

		// PARA SABER SI EST? M?S CERCA DE UN NODO O DEL OTRO.

			RandomAccessFile file;

			try {

				file = new RandomAccessFile(netFile.getPath(),

						"r");

				FileChannel channel = file.getChannel();

				MappedByteBuffer buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

				buf.order(ByteOrder.LITTLE_ENDIAN);

				numArcs = buf.getInt();

				numEdges = buf.getInt();

				numNodes = buf.getInt();

				GvGraph g = new GvGraph(numArcs, numEdges, numNodes);

				// Nodes

				buf.position(30*numEdges + 12);

				for (int i=0; i < numNodes; i++)

				{

					GvNode node = readNode(buf);

					g.addNode(node);

				}

				// Arcos			

				buf.position(12);

				for (int i=0; i < numEdges; i++)

				{

					GvEdge edge = readEdge(buf);

					edge.setIdEdge(i);

					g.addEdge(edge);

					GvNode node = g.getNodeByID(edge.getIdNodeOrig());

					node.getEnlaces().add(edge);

					EdgePair edgePair = g.getEdgesByIdArc(edge.getIdArc());

					if (edgePair == null)

					{

						edgePair = new EdgePair();						

						g.addEdgePair(edgePair);

					}

					if (edge.getDirec() == 1)

						edgePair.setIdEdge(i);

					else

						edgePair.setIdInverseEdge(i);

				}

			long t2 = System.currentTimeMillis();

			System.out.println("Tiempo de carga: " + (t2-t1) + " msecs");

			System.out.println("NumEdges = " + g.numEdges());

			return g;

			} catch (FileNotFoundException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			} catch (IOException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		return null;

	}

	public Graph loadJungNetwork()

	{

		SparseGraph g = new SparseGraph();

		long t1 = System.currentTimeMillis();

		RandomAccessFile file;

		try {

			file = new RandomAccessFile(netFile.getPath(),

					"r");

			FileChannel channel = file.getChannel();

			MappedByteBuffer buf = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());

			buf.order(ByteOrder.LITTLE_ENDIAN);

			int numArcs = buf.getInt();

			int numEdges = buf.getInt();

			int numNodes = buf.getInt();

			// Nodes

			buf.position(24*numEdges + 12);

			for (int i=0; i < numNodes; i++)

			{

				GvNode node = readNode(buf);

				Vertex v = new DirectedSparseVertex();

//				v.addUserDatum("ID", node.idNode, UserData.CLONE);

//				v.addUserDatum("X", node.x, UserData.CLONE);

//				v.addUserDatum("Y", node.y, UserData.CLONE);

	//			v_locations.setLocation(v, new Point2D.Double(x.doubleValue(),y.doubleValue()));

				g.addVertex(v);				

			}

			Indexer indexer = Indexer.getIndexer(g);

			buf.position(12);

			for (int i=0; i < numEdges; i++)

			{

				GvEdge edge = readEdge(buf);

				int nodeOrig = edge.getIdNodeOrig();

				int nodeEnd = edge.getIdNodeEnd();

				Vertex vFrom = (Vertex) indexer.getVertex(nodeOrig);

				Vertex vTo = (Vertex) indexer.getVertex(nodeEnd);

				DirectedSparseEdge edgeJ = new DirectedSparseEdge(vFrom, vTo);

				g.addEdge(edgeJ);

			}

			long t2 = System.currentTimeMillis();

			System.out.println("Tiempo de carga: " + (t2-t1) + " msecs");

			return g;

		} catch (FileNotFoundException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	private GvNode readNode(MappedByteBuffer buf) {

		GvNode node = new GvNode();

		node.setIdNode(buf.getInt());

		node.setX(buf.getFloat());

		node.setY(buf.getFloat());

		return node;

	}

	private GvEdge readEdge(MappedByteBuffer buf) {

		GvEdge edge = new GvEdge();

		// memcpy(&Arcos[link_num].idTramo,puntero,sizeof(long));

		edge.setIdArc(buf.getInt());

		// Sentido de digitalizaci?n.Un 1 indica que va en ese sentido, un cero al contrario.

		// memcpy(&Arcos[link_num].sentido,puntero,sizeof(int));

		edge.setDirec(buf.getInt());

		// idNodeOrig

		edge.setIdNodeOrig(buf.getInt());

		// memcpy(&node_num1,puntero,sizeof(long));

		// idNodeEnd

		edge.setIdNodeEnd(buf.getInt());

//		memcpy(&node_num2,puntero,sizeof(long));

		// Read the link costs.

		// Type

		edge.setType(buf.getInt());

//		memcpy(&Arcos[link_num].TipoTramo,puntero,sizeof(int));

		// Distance

		edge.setDistance(buf.getDouble());

		edge.setWeight(buf.getDouble());

//		memcpy(&Arcos[link_num].Coste2,puntero,sizeof(float));

//		pNodo1 = &Nodos[node_num1];

//		Arcos[link_num].idNodo1 = node_num1;

//

//		Arcos[link_num].idNodo2 = node_num2;

		// pNodo2->Enlaces.Add(link_num);

//		// NUEVO 11-JUL-2002

//			if (Arcos[link_num].sentido)

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

//		else

//			IndiceArcos[Arcos[link_num].idTramo].idContraArco = link_num;

//

//		// NUEVO 27-JUL-2003

//		Arcos[link_num].numSoluc = 0;

//

//		// NUEVO 23_2_2005

//		CreaConectores(link_num);

		return edge;

	}

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		NetworkRedLoader redLoader = new NetworkRedLoader();

		redLoader.loadNetwork();

		redLoader.loadJungNetwork();

	}

	public File getNetFile() {

		return netFile;

	}

	public void setNetFile(File netFile) {

		this.netFile = netFile;

	}

}

/* 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.Point2D;

import java.io.File;

import com.hardcode.driverManager.Driver;

import com.hardcode.driverManager.DriverLoadException;

import com.hardcode.driverManager.DriverManager;

import com.hardcode.driverManager.DriverValidation;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.hardcode.gdbms.engine.data.NoSuchTableException;

import com.hardcode.gdbms.engine.data.driver.DBDriver;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.data.driver.FileDriver;

import com.hardcode.gdbms.engine.data.driver.ObjectDriver;

import com.hardcode.gdbms.engine.values.NumericValue;

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

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

import edu.uci.ics.jung.algorithms.shortestpath.DijkstraDistance;

import edu.uci.ics.jung.graph.ArchetypeVertex;

import edu.uci.ics.jung.graph.Graph;

import edu.uci.ics.jung.graph.Vertex;

import edu.uci.ics.jung.graph.decorators.Indexer;

import edu.uci.ics.jung.graph.impl.DirectedSparseVertex;

import edu.uci.ics.jung.graph.impl.SparseGraph;

import edu.uci.ics.jung.utils.UserData;

import edu.uci.ics.jung.visualization.DefaultSettableVertexLocationFunction;

import edu.uci.ics.jung.visualization.SettableVertexLocationFunction;

public class NetworkLoader implements INetworkLoader {

	private String fieldNodeId = "NODEID";

	private String fieldNodeX = "X";

	private String fieldNodeY = "Y";

	private String fieldArcId = "ARCID";

	private String fieldDirection = "DIRECTION";

	private String fieldNodeOrig = "NODEORIGIN";

	private String fieldNodeEnd = "NODEEND";

	private String fieldType = "TYPE";

	private String fieldDist = "DIST";

	private String fieldCost = "COST";

	private SelectableDataSource nodeReader;

	private SelectableDataSource edgeReader;

	private Indexer indexer;

	private boolean bUseCostField;

	/**

     * The user data key used to retrieve the vertex locations (if any) defined by this class.

     */

    public static final String LOCATIONS = "jung.io.GvSIGNetReader.LOCATIONS";

	protected SettableVertexLocationFunction v_locations = new DefaultSettableVertexLocationFunction();

	/**

	 * By default, the fields are:

	 * private String fieldNodeId = "NODEID";

	 * 	 fieldNodeX = "X";

	 * 	 fieldNodeY = "Y";

	 * 

	 * 	 fieldArcId = "NODEID";

	 * 	 fieldDirection = "X";

	 * 	 fieldNodeOrig = "Y";

	 * 	 fieldNodeEnd = "NODEORIGIN";

	 * 	 fieldType = "NODEEND";

	 * 	 fieldDist = "DIST";

	 * 

	 * If you need to change any, use the correspondant "setFieldXXXX"

	 * BEFORE calling loadNetwork. And remember to set nodeReader and 

	 * edgeReader also.

	 */

	public NetworkLoader(boolean bUseCostField) {

		this.bUseCostField = bUseCostField;

	}

	public String getFieldArcId() {

		return fieldArcId;

	}

	public void setFieldArcId(String fieldArcId) {

		this.fieldArcId = fieldArcId;

	}

	public String getFieldDirection() {

		return fieldDirection;

	}

	public void setFieldDirection(String fieldDirection) {

		this.fieldDirection = fieldDirection;

	}

	public String getFieldDist() {

		return fieldDist;

	}

	public void setFieldDist(String fieldDist) {

		this.fieldDist = fieldDist;

	}

	public String getFieldNodeEnd() {

		return fieldNodeEnd;

	}

	public void setFieldNodeEnd(String fieldNodeEnd) {

		this.fieldNodeEnd = fieldNodeEnd;

	}

	public String getFieldNodeId() {

		return fieldNodeId;

	}

	public void setFieldNodeId(String fieldNodeId) {

		this.fieldNodeId = fieldNodeId;

	}

	public String getFieldNodeOrig() {

		return fieldNodeOrig;

	}

	public void setFieldNodeOrig(String fieldNodeOrig) {

		this.fieldNodeOrig = fieldNodeOrig;

	}

	public String getFieldNodeX() {

		return fieldNodeX;

	}

	public void setFieldNodeX(String fieldNodeX) {

		this.fieldNodeX = fieldNodeX;

	}

	public String getFieldNodeY() {

		return fieldNodeY;

	}

	public void setFieldNodeY(String fieldNodeY) {

		this.fieldNodeY = fieldNodeY;

	}

	public String getFieldType() {

		return fieldType;

	}

	public void setFieldType(String fieldType) {

		this.fieldType = fieldType;

	}

	public void setEdgeReader(SelectableDataSource edgeReader) {

		this.edgeReader = edgeReader;

	}

	public void setNodeReader(SelectableDataSource nodeReader) {

		this.nodeReader = nodeReader;

	}

	/**

	 * @param args

	 */

	public static void main(String[] args) {

		NetworkLoader netLoader = new NetworkLoader(false);

		//Setup de los drivers

		DriverManager dm = new DriverManager();

		dm.setValidation(new DriverValidation() {

				public boolean validate(Driver d) {

					return ((d instanceof ObjectDriver) ||

					(d instanceof FileDriver) ||

					(d instanceof DBDriver));

				}

			});

		dm.loadDrivers(new File("../_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/drivers"));

		//Setup del factory de DataSources

        DataSourceFactory dsf = LayerFactory.getDataSourceFactory();

		dsf.setDriverManager(dm);

		//Setup de las tablas

		dsf.addFileDataSource("gdbms dbf driver", "nodes", "c:/nodes.dbf");

		dsf.addFileDataSource("gdbms dbf driver", "edges", "c:/edges.dbf");

        DataSource dsNodes;

		try {

			dsNodes = dsf.createRandomDataSource("nodes",

			        DataSourceFactory.MANUAL_OPENING);

	        DataSource dsEdges = dsf.createRandomDataSource("edges",

	                DataSourceFactory.MANUAL_OPENING);

			SelectableDataSource sdsNodes = new SelectableDataSource(dsNodes);

			SelectableDataSource sdsEdges = new SelectableDataSource(dsEdges);

			netLoader.setNodeReader(sdsNodes);

			netLoader.setEdgeReader(sdsEdges);

			Graph g = netLoader.loadJungNetwork();

			System.out.println("Num nodos=" + g.numVertices() + " numEdges = " + g.numEdges());

			// Probamos la algoritmia: distancia entre nodo 1 y nodo 1000

			DijkstraDistance distCalculator = new DijkstraDistance(g, new EdgeWeightLabeller());

			ArchetypeVertex vOrig = netLoader.indexer.getVertex(1);

			ArchetypeVertex vEnd = netLoader.indexer.getVertex(1000);

			long t1 = System.currentTimeMillis();

			Number dist = distCalculator.getDistance(vOrig, vEnd);

			long t2 = System.currentTimeMillis();

			System.out.println("dist =" + dist + " meters. msecs: " + (t2-t1));

			System.out.println(vOrig + " - " + vEnd);

			System.out.println(vOrig.getUserDatum("X") + ", " + vOrig.getUserDatum("Y")

							+ " - " + vEnd.getUserDatum("X") + ", " + vEnd.getUserDatum("Y"));

		} catch (DriverLoadException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (NoSuchTableException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (DriverException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public Graph loadJungNetwork() {

		try {

			int fieldIndexIdNode = nodeReader.getFieldIndexByName(fieldNodeId);

			int fieldIndexX = nodeReader.getFieldIndexByName(fieldNodeX);;

			int fieldIndexY = nodeReader.getFieldIndexByName(fieldNodeY);;

			int fieldIndexArcID = edgeReader.getFieldIndexByName(fieldArcId);

			int fieldIndexDirection = edgeReader.getFieldIndexByName(fieldDirection);

			int fieldIndexNodeOrig = edgeReader.getFieldIndexByName(fieldNodeOrig);

			int fieldIndexNodeEnd = edgeReader.getFieldIndexByName(fieldNodeEnd);

			int fieldIndexType = edgeReader.getFieldIndexByName(fieldType);

			int fieldIndexDist = edgeReader.getFieldIndexByName(fieldDist);

			SparseGraph g = new SparseGraph();

//			g.getEdgeConstraints().clear();

			long t1 = System.currentTimeMillis();

			// Mirar NumberEdgeVAlue e Indexer

			for (int i=0; i < nodeReader.getRowCount(); i++)

			{

				NumericValue id = (NumericValue) nodeReader.getFieldValue(i, fieldIndexIdNode);

				NumericValue x = (NumericValue) nodeReader.getFieldValue(i, fieldIndexX);

				NumericValue y = (NumericValue) nodeReader.getFieldValue(i, fieldIndexY);

				Vertex v = new DirectedSparseVertex();

				v.addUserDatum("ID", id, UserData.CLONE);

				v.addUserDatum("X", x, UserData.CLONE);

				v.addUserDatum("Y", y, UserData.CLONE);

				v_locations.setLocation(v, new Point2D.Double(x.doubleValue(),y.doubleValue()));

				g.addVertex(v);				

			}

			indexer = Indexer.getIndexer(g);

			for (int i=0; i < edgeReader.getRowCount(); i++)

			{

				NumericValue arcID = (NumericValue) edgeReader.getFieldValue(i, fieldIndexArcID);

				NumericValue direc = (NumericValue) edgeReader.getFieldValue(i, fieldIndexDirection);

				NumericValue nodeOrig = (NumericValue) edgeReader.getFieldValue(i, fieldIndexNodeOrig);

				NumericValue nodeEnd = (NumericValue) edgeReader.getFieldValue(i, fieldIndexNodeEnd);

				NumericValue type = (NumericValue) edgeReader.getFieldValue(i, fieldIndexType);

				NumericValue dist = (NumericValue) edgeReader.getFieldValue(i, fieldIndexDist);

				Vertex vFrom = (Vertex) indexer.getVertex(nodeOrig.intValue());

				Vertex vTo = (Vertex) indexer.getVertex(nodeEnd.intValue());

				FEdge edge = new FEdge(vFrom, vTo);

				edge.setArcID(arcID.intValue());

				edge.setDirection(direc.intValue());

				edge.setIdNodeOrig(nodeOrig.intValue());

				edge.setIdNodeEnd(nodeEnd.intValue());

				edge.setType(type.intValue());

				edge.setWeight(dist.doubleValue());

				g.addEdge(edge);

			}

			long t2 = System.currentTimeMillis();

			System.out.println("Tiempo de carga desde nodes.dbf y edges.dbf y generando JUNG network: " + (t2-t1) + " msecs");

			return g;

		} catch (DriverException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	public IGraph loadNetwork() {

		try {

			int fieldIndexIdNode = nodeReader.getFieldIndexByName(fieldNodeId);

			int fieldIndexX = nodeReader.getFieldIndexByName(fieldNodeX);;

			int fieldIndexY = nodeReader.getFieldIndexByName(fieldNodeY);;

			int fieldIndexArcID = edgeReader.getFieldIndexByName(fieldArcId);

			int fieldIndexDirection = edgeReader.getFieldIndexByName(fieldDirection);

			int fieldIndexNodeOrig = edgeReader.getFieldIndexByName(fieldNodeOrig);

			int fieldIndexNodeEnd = edgeReader.getFieldIndexByName(fieldNodeEnd);

			int fieldIndexType = edgeReader.getFieldIndexByName(fieldType);

			int fieldIndexDist = edgeReader.getFieldIndexByName(fieldDist);

			int fieldIndexCost = edgeReader.getFieldIndexByName(fieldCost);

			GvGraph g = new GvGraph();

			long t1 = System.currentTimeMillis();

			// Mirar NumberEdgeVAlue e Indexer

			for (int i=0; i < nodeReader.getRowCount(); i++)

			{

				NumericValue id = (NumericValue) nodeReader.getFieldValue(i, fieldIndexIdNode);

				NumericValue x = (NumericValue) nodeReader.getFieldValue(i, fieldIndexX);

				NumericValue y = (NumericValue) nodeReader.getFieldValue(i, fieldIndexY);

				GvNode node = new GvNode();

				node.setX(x.doubleValue());

				node.setY(y.doubleValue());

				node.setIdNode(i);

				g.addNode(node);				

			}

			for (int i=0; i < edgeReader.getRowCount(); i++)

			{

				NumericValue arcID = (NumericValue) edgeReader.getFieldValue(i, fieldIndexArcID);

				NumericValue direc = (NumericValue) edgeReader.getFieldValue(i, fieldIndexDirection);

				NumericValue nodeOrig = (NumericValue) edgeReader.getFieldValue(i, fieldIndexNodeOrig);

				NumericValue nodeEnd = (NumericValue) edgeReader.getFieldValue(i, fieldIndexNodeEnd);

				NumericValue type = (NumericValue) edgeReader.getFieldValue(i, fieldIndexType);

				NumericValue dist = (NumericValue) edgeReader.getFieldValue(i, fieldIndexDist);

				GvEdge edge = new GvEdge();

				edge.setIdArc(arcID.intValue());

				edge.setIdEdge(i);

				edge.setDirec(direc.intValue());

				edge.setIdNodeOrig(nodeOrig.intValue());

				edge.setIdNodeEnd(nodeEnd.intValue());

				edge.setType(type.intValue());

				edge.setDistance(dist.doubleValue());

				if (bUseCostField)

				{

					NumericValue cost = (NumericValue) edgeReader.getFieldValue(i, fieldIndexCost);

					edge.setWeight(cost.doubleValue());

				}

				g.addEdge(edge);

			}

			long t2 = System.currentTimeMillis();

			System.out.println("Tiempo de carga desde nodes.dbf y edges.dbf y generando JUNG network: " + (t2-t1) + " msecs");

			return g;

		} catch (DriverException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		return null;

	}

	public String getFieldCost() {

		return fieldCost;

	}

	public void setFieldCost(String fieldCost) {

		this.fieldCost = fieldCost;

	}

	public Indexer getIndexer() {

		return indexer;

	}

}

/* 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.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteOrder;

import java.sql.Types;

import java.util.ArrayList;

import java.util.Hashtable;

import javax.imageio.stream.FileImageOutputStream;

import com.hardcode.gdbms.engine.values.IntValue;

import com.hardcode.gdbms.engine.values.NumericValue;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

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

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

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.edition.DefaultRowEdited;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.IWriter;

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

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

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

import com.iver.utiles.swing.threads.CancellableMonitorable;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

/**

 * @author fjp

 *

 * 

 */

public class NetworkWriter {

	private FLyrVect lyr;

	private String fieldType;

	private String fieldDist;

	private String fieldCost;

	private String fieldSense;

	private IWriter nodeWriter;

	private IWriter edgeWriter;

	private FieldDescription[] nodeFields;

	private FieldDescription[] edgeFields;

	public NetworkWriter() {

		// Set up fields for table nodes

		nodeFields = new FieldDescription[3];

		FieldDescription fieldNodeId = new FieldDescription();

		fieldNodeId.setFieldName("NODEID");

		fieldNodeId.setFieldType(Types.INTEGER);

		FieldDescription fieldX = new FieldDescription();

		fieldX.setFieldName("X");

		fieldX.setFieldType(Types.DOUBLE);

		fieldX.setFieldDecimalCount(2);

		FieldDescription fieldY = new FieldDescription();

		fieldY.setFieldName("Y");

		fieldY.setFieldType(Types.DOUBLE);

		fieldY.setFieldDecimalCount(2);

		nodeFields[0] = fieldNodeId;

		nodeFields[1] = fieldX;

		nodeFields[2] = fieldY;

		// Set up fields for table edges

		edgeFields = new FieldDescription[7];

		// ID_TRAMO ORIGINAL!!!

		FieldDescription fieldArcID = new FieldDescription();

		fieldArcID.setFieldName("ArcID");

		fieldArcID.setFieldType(Types.INTEGER);

		FieldDescription fieldDirection = new FieldDescription();

		fieldDirection.setFieldName("Direction");

		fieldDirection.setFieldType(Types.SMALLINT);

		FieldDescription fieldNodeOrigin = new FieldDescription();

		fieldNodeOrigin.setFieldName("NodeOrigin");

		fieldNodeOrigin.setFieldType(Types.INTEGER);

		FieldDescription fieldNodeEnd = new FieldDescription();

		fieldNodeEnd.setFieldName("NodeEnd");

		fieldNodeEnd.setFieldType(Types.INTEGER);

		FieldDescription fieldType = new FieldDescription();

		fieldType.setFieldName("Type");

		fieldType.setFieldType(Types.SMALLINT);

		FieldDescription fieldDistanceDist = new FieldDescription();

		fieldDistanceDist.setFieldName("Dist");

		fieldDistanceDist.setFieldType(Types.DOUBLE);

		FieldDescription fieldDistanceCost = new FieldDescription();

		fieldDistanceCost.setFieldName("Cost");

		fieldDistanceCost.setFieldType(Types.DOUBLE);

		edgeFields[0] = fieldArcID;

		edgeFields[1] = fieldDirection;

		edgeFields[2] = fieldNodeOrigin;

		edgeFields[3] = fieldNodeEnd;

		edgeFields[4] = fieldType;

		edgeFields[5] = fieldDistanceDist;

		edgeFields[6] = fieldDistanceCost;

	}

	public FLyrVect getLayer() {

		return lyr;

	}

	public void setLayer(FLyrVect lyr) {

		this.lyr = lyr;

	}

	/**

	 * We iterate by each geometry and add Nodes and Edges using writers. Each

	 * node must have its own ID.

	 * 

	 * @throws DriverIOException

	 * @throws EditionException

	 * @throws DriverException

	 * 

	 */

	public void writeNetwork(boolean bUseCostField) throws EditionException,

			DriverException {

		double distance;

		double cost;

		short arcType;

		int direction;

		int i;

		int idNodo1, idNodo2, nodeCount, edgeCount;

		short sentidoDigit; // => 1 en esa direcci?n. 0=> Al contrario. SOLO

		// SE UTILIZA PARA LOS CALCULOS POR IDTRAMO Y

		// PORCENTAJE

		// PARA SABER SI EST? M?S CERCA DE UN NODO O DEL OTRO.

		VectorialAdapter adapter = (VectorialAdapter) lyr.getSource();

		try {

			int numEntities = adapter.getShapeCount();

			Hashtable nodeHash = new Hashtable();

			Value[] values = new Value[3];

			SelectableDataSource sds = lyr.getRecordset();

			int senseFieldIndex = sds.getFieldIndexByName(fieldSense);

			int distFieldIndex = sds.getFieldIndexByName(fieldDist);

			int costFieldIndex = sds.getFieldIndexByName(fieldCost);

			int typeFieldIndex = sds.getFieldIndexByName(fieldType);

			if (typeFieldIndex == -1) {

				throw new RuntimeException("Field invalid:" + fieldType);

			}

			if (distFieldIndex == -1) {

				throw new RuntimeException("Field invalid:" + fieldDist);

			}

			// We create a table definition for node table.

			ITableDefinition nodesTableDef = new TableDefinition();

			nodesTableDef.setFieldsDesc(nodeFields);

			nodesTableDef.setName("Nodes");

			// We create a table definition for edges table.

			ITableDefinition edgeTableDef = new TableDefinition();

			edgeTableDef.setFieldsDesc(edgeFields);

			edgeTableDef.setName("Edges");

			nodeWriter.initialize(nodesTableDef);

			edgeWriter.initialize(edgeTableDef);

			nodeWriter.preProcess();

			edgeWriter.preProcess();

			edgeCount = 0;

			nodeCount = 0; 

			for (i = 0; i < numEntities; i++) {

				IGeometry geom = adapter.getShape(i);

				Geometry jtsGeom = geom.toJTSGeometry();

				Coordinate[] coords = jtsGeom.getCoordinates();

				Coordinate c1 = coords[0];

				Coordinate c2 = coords[coords.length - 1];

				NodeGv nodeAux;

				if (!nodeHash.containsKey(c1)) // No est?.

				{

					idNodo1 = nodeCount++;

					nodeAux = new NodeGv(c1, idNodo1);

					nodeHash.put(c1, nodeAux);

					writeNode(nodeAux);

				} else {

					nodeAux = (NodeGv) nodeHash.get(c1);

				}

				idNodo1 = nodeAux.getId().intValue();

				if (!nodeHash.containsKey(c2)) // No est?.

				{

					idNodo2 = nodeCount++;

					nodeAux = new NodeGv(c2, idNodo2);

					nodeHash.put(c2, nodeAux);

					writeNode(nodeAux);

				} else {

					nodeAux = (NodeGv) nodeHash.get(c2);

				}

				idNodo2 = nodeAux.getId().intValue();

				NumericValue valAux = (NumericValue) sds.getFieldValue(i,

						typeFieldIndex);

				arcType = valAux.shortValue();

				valAux = (NumericValue) sds.getFieldValue(i, distFieldIndex);

				distance = valAux.doubleValue();

				if (bUseCostField)

				{

					valAux = (NumericValue) sds.getFieldValue(i, costFieldIndex);

					cost = valAux.doubleValue();					

				}

				else

					cost = distance;

				direction = -1;

				if (senseFieldIndex == -1)

					direction = 3; // 3-> Doble sentido, 1-> seg?n viene, 2 ->

				// al rev?s, cualquier otro valor-> No hay

				// arco

				else {

					valAux = (NumericValue) sds.getFieldValue(i,

							senseFieldIndex);

					direction = valAux.shortValue();

				}

				if (direction == 3) {

					sentidoDigit = 1; // En esa direcci?n

					writeEdge(i, sentidoDigit, idNodo1, idNodo2, arcType,

							distance, cost);

					edgeCount++;

					sentidoDigit = 0;

					writeEdge(i, sentidoDigit, idNodo2, idNodo1, arcType,

							distance, cost);

					edgeCount++;

				}

				if (direction == 1) {

					sentidoDigit = 1; // En esa direcci?n

					writeEdge(i, sentidoDigit, idNodo1, idNodo2, arcType,

							distance, cost);

					edgeCount++;

				}

				if (direction == 2) {

					sentidoDigit = 0;

					writeEdge(i, sentidoDigit, idNodo2, idNodo1, arcType,

							distance, cost);

					edgeCount++;

				}

			}

			nodeWriter.postProcess();

			edgeWriter.postProcess();

		} catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

			e.printStackTrace();

			throw new DriverException(e);

		} catch (DriverIOException e) {

			e.printStackTrace();

			throw new DriverException(e);

		}

	}

	private void writeNode(NodeGv node) throws EditionException {

		Value[] values = new Value[nodeFields.length];

		int id = node.getId().intValue();

		values[0] = ValueFactory.createValue(id);

		values[1] = ValueFactory.createValue(node.getCoordinate().x);

		values[2] = ValueFactory.createValue(node.getCoordinate().y);

		DefaultRow myRow = new DefaultRow(values, id + "");

		IRowEdited editedRow = new DefaultRowEdited(myRow,

				DefaultRowEdited.STATUS_ADDED, id);

		nodeWriter.process(editedRow);	

	}

	/**

	 * Writes .red file (IVER network format). Useful to do some tests.

	 * @param lyrSrc

	 * @param redFile

	 * @return

	 * @throws DriverException

	 * @throws IOException

	 */

	public int createRedFile(FLyrVect lyrSrc, File redFile,  CancellableMonitorable cancel)

			throws DriverException {

		// PRIMERO VAN EL NUMERO DE TRAMOS, LUEGO EL NUMERO DE ARCOS Y LUEGO

		// EL NUMERO DE NODOS, DESPUES

		// IDTRAMO-SENTIDO_DIGITALIZACION-IDNODOORIGEN-IDNODODESTINO-TIPOTRAMO-DISTANCIA

		// Y POR FIN

		// IDNODO-XLONG-YLONG

		// El campo sentido indica //3-> Doble sentido, 1-> seg?n viene, 2

		// -> al rev?s, cualquier otro valor-> No hay arco

		// TipoTamo va a ser un campo num?rico, entero.

		// 0-> Autopista.

		// 1-> Autov?a.

		// 2-> Nacional.

		// 3-> Nacional - Comarcal.

		// 4-> Comarcal.

		// 5-> Otras.

		// 6-> Ferry.

		// 7-> Conexiones

		// Los nombres son orientativos. Basta saber que puede haber hasta X

		// tipos distintos de tramos, cada uno

		// con su velocidad. Esa velocidad se fijar? en la funci?n

		// FijaVelocidades. OJO, empezar siempre desde el 0

		double distance, cost;

		short arcType;

		int direction;

		int i;

		int idNodo1, idNodo2, nodeCount, edgeCount;

		short sentidoDigit; // => 1 en esa direcci?n. 0=> Al contrario. SOLO

		// SE UTILIZA PARA LOS CALCULOS POR IDTRAMO Y

		// PORCENTAJE

		// PARA SABER SI EST? M?S CERCA DE UN NODO O DEL OTRO.

		Hashtable nodeHash = new Hashtable();

		ArrayList nodes = new ArrayList();

		try {

			if (lyrSrc.getShapeType() != FShape.LINE) {

				return -1;

			}

			RandomAccessFile file = new RandomAccessFile(redFile.getPath(),

					"rw");

			FileImageOutputStream output = new FileImageOutputStream(file);

//			FileChannel channel = file.getChannel();

//			MappedByteBuffer buf = channel.map(MapMode.READ_WRITE, 0,

//					16 * 1024);

//			buf.order(ByteOrder.LITTLE_ENDIAN);

			output.setByteOrder(ByteOrder.LITTLE_ENDIAN);

			nodeCount = 0;

			VectorialAdapter adapter = (VectorialAdapter) lyrSrc.getSource();

			int numTramos;

			numTramos = adapter.getShapeCount();

			// Cambiamos otra vez: Escribimos primero el n? de tramos. Luego va

			// el n? de arcos y el de nodos.

			// buf.putInt(numTramos);

			output.writeInt(numTramos);

			// /////// Cambiamos el formato: primero van los arcos y luego los

			// nodos

			// file.writeInt(0);

			output.writeInt(0);

			// OJO: El numero de arcos todav?a no lo sabemos, habr? que volver

			// luego y escribir el numero correcto. Es por lo de los sentidos.

			// Metemos 2 arcos si es doble sentido, y uno si es de un solo

			// sentido

			// Guardamos un long. Luego volveremos aqu? y grabaremos el n? de

			// nodos

			// file.writeInt(0);

			output.writeInt(numTramos);

			// AHORA METEMOS LOS NOMBRES DE LOS CAMPOS. EN EL CARGA RED LOS

			// USAREMOS PARA LEER DEL DBF.

			edgeCount = 0;

			SelectableDataSource sds = lyrSrc.getRecordset();

			int senseFieldIndex = -1;

			int distFieldIndex = -1;

			int typeFieldIndex = -1;

			int costFieldIndex = -1;

			if (fieldSense != null)

				senseFieldIndex = sds.getFieldIndexByName(fieldSense);

			if (fieldDist != null)

				distFieldIndex = sds.getFieldIndexByName(fieldDist);

			if (fieldType != null)

				typeFieldIndex = sds.getFieldIndexByName(fieldType);

			if (fieldCost != null)

				costFieldIndex = sds.getFieldIndexByName(fieldCost);

			NumericValue valAux = null;

			for (i = 0; i < numTramos; i++) {

				IGeometry geom = adapter.getShape(i);

				Geometry jtsGeom = geom.toJTSGeometry();

				Coordinate[] coords = jtsGeom.getCoordinates();

				Coordinate c1 = coords[0];

				Coordinate c2 = coords[coords.length - 1];

				if(cancel != null)

					cancel.reportStep();

				NodeGv nodeAux;

				if (!nodeHash.containsKey(c1)) // No est?.

				{

					idNodo1 = nodeCount++;

					nodeAux = new NodeGv(c1, idNodo1);

					nodeHash.put(c1, nodeAux);

					nodes.add(nodeAux);

				} else {

					nodeAux = (NodeGv) nodeHash.get(c1);

				}

				idNodo1 = nodeAux.getId().intValue();

				if (!nodeHash.containsKey(c2)) // No est?.

				{

					idNodo2 = nodeCount++;

					nodeAux = new NodeGv(c2, idNodo2);

					nodeHash.put(c2, nodeAux);

					nodes.add(nodeAux);

				} else {

					nodeAux = (NodeGv) nodeHash.get(c2);

				}

				idNodo2 = nodeAux.getId().intValue();

				if (typeFieldIndex != -1)

					valAux = (NumericValue) sds.getFieldValue(i, typeFieldIndex);

				else

					valAux = ValueFactory.createValue(0); // no hay tipo

				arcType = valAux.shortValue();

				// TipoTramo = DBFReadIntegerAttribute(hDBF, i, indiceCampo1);

				if (distFieldIndex != -1)

					valAux = (NumericValue) sds.getFieldValue(i, distFieldIndex);

				else

					valAux = ValueFactory.createValue(jtsGeom.getLength());

				distance = valAux.floatValue();

				// Distancia = (float) DBFReadDoubleAttribute(hDBF, i,