A Nearest Neighbor Query in Time-Dependent Road Networks - MDM

.gitignore

@@ -17,3 +17,4 @@ null
 *.aux
 *.synctex*
 bin
+core/.RData

core/pom.xml

@@ -14,6 +14,7 @@
 	      <id>maven-repo</id>
 	      <url>http://arida.github.io/maven-repo/</url>
 	    </repository>
+
 	</repositories>
 
 	<licenses>
@@ -77,9 +78,26 @@
 		    <artifactId>rtree</artifactId>
 		    <version>0.7.1</version>
 		</dependency>
-	</dependencies>
-
 
+		 <dependency>
+			<groupId>postgresql</groupId>
+			<artifactId>postgresql</artifactId>
+			<version>9.1-901-1.jdbc4</version>
+		</dependency>
+
+		 <dependency>
+			<groupId>org.postgis</groupId>
+			<artifactId>postgis-jdbc</artifactId>
+			<version>1.3.3</version>
+		</dependency>
+
+		 <dependency>
+			<groupId>org.apache.commons</groupId>
+			  <artifactId>commons-lang3</artifactId>
+			<version>3.4</version>
+		</dependency>
+
+	</dependencies>
 
 	<build>
 		<plugins>
@@ -141,6 +159,26 @@
 	        	</executions>
 	      	</plugin>
  -->
+ 			<plugin>
+		        <groupId>org.apache.maven.plugins</groupId>
+		        <artifactId>maven-shade-plugin</artifactId>
+		        <version>2.4.2</version>
+		        <executions>
+		          <execution>
+		            <phase>package</phase>
+		            <goals>
+		              <goal>shade</goal>
+		            </goals>
+		            <configuration>
+		              <transformers>
+		                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+		                  <mainClass>org.graphast.query.rnn.CompareRNNSearchsMethodsAnalysis</mainClass>
+		                </transformer>
+		              </transformers>
+		            </configuration>
+		          </execution>
+		        </executions>
+		      </plugin>
 		</plugins>
 	</build>
 </project>

core/src/main/java/org/graphast/importer/CostGenerator.java

@@ -4,90 +4,101 @@
 
 import org.graphast.model.Graph;
 
+
 public class CostGenerator {
 
 	public static int[] generateSyntheticEdgesCosts(int distance) {
 
 		Random random = new Random();
 
-		int minSpeed, maxSpeed;
+		int minSpeed, maxSpeed;	 //Millimeters Per Millisecond (mm/ms)	
 		int[] syntheticCosts = new int[96];
 
+		//1:00h to 6:00h
 		for(int i=0; i<24; i++) {
-			minSpeed = 14;
-			maxSpeed = 17;
+			minSpeed = 14; // 50km/h
+			maxSpeed = 17; // 60km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//6:00h to 7:00h
 		for(int i=24; i<28; i++) {
-			minSpeed = 6;
-			maxSpeed = 9;
+			minSpeed = 6; //21km/h
+			maxSpeed = 9; //32km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//7:00h to 9:00h
 		for(int i=28; i<36; i++) {
-			minSpeed = 1;
-			maxSpeed = 4;
+			minSpeed = 1; //3km/h
+			maxSpeed = 4; //14km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//9:00h to 11:00h
 		for(int i=36; i<44; i++) {
-			minSpeed = 6;
-			maxSpeed = 9;
+			minSpeed = 6; //21km/h
+			maxSpeed = 9; //32km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//11:00h to 14:00h
 		for(int i=44; i<56; i++) {
-			minSpeed = 1;
-			maxSpeed = 4;
+			minSpeed = 1; //3km/h
+			maxSpeed = 4; //14km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//14:00h to 16:00h
 		for(int i=56; i<64; i++) {
-			minSpeed = 14;
-			maxSpeed = 17;
+			minSpeed = 14; //50km/h
+			maxSpeed = 17; //60km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//16:00h to 17:00h
 		for(int i=64; i<68; i++) {
-			minSpeed = 6;
-			maxSpeed = 9;
+			minSpeed = 6; //21km/h
+			maxSpeed = 9; //30/km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//17:00h to 20:00h
 		for(int i=68; i<80; i++) {
-			minSpeed = 1;
-			maxSpeed = 4;
+			minSpeed = 1; //3km/h
+			maxSpeed = 4; //14km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//20:00h to 22:00h
 		for(int i=80; i<88; i++) {
-			minSpeed = 6;
-			maxSpeed = 9;
+			minSpeed = 6; //21km/h
+			maxSpeed = 9; //30/km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 
 		}
 
+		//22:00h to 00:00h
 		for(int i=88; i<96; i++) {
-			minSpeed = 14;
-			maxSpeed = 17;
+			minSpeed = 14; //50km/h
+			maxSpeed = 17; //60km/h
 
 			syntheticCosts[i] = distance/(random.nextInt(maxSpeed-minSpeed)+minSpeed);
 

core/src/main/java/org/graphast/importer/GraphGeneratorGrid.java

@@ -0,0 +1,135 @@
+package org.graphast.importer;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+
+import org.graphast.model.Edge;
+import org.graphast.model.EdgeImpl;
+import org.graphast.model.GraphBounds;
+import org.graphast.model.GraphImpl;
+import org.graphast.model.Node;
+import org.graphast.model.NodeImpl;
+
+public class GraphGeneratorGrid {
+
+	private int width;
+	private int length;
+	private GraphBounds graph;
+	private double percentagemPoi;
+	private BigDecimal distance_largura;
+	private BigDecimal distance_altura;
+
+	public GraphGeneratorGrid(String pathGraph, int width, int length, double percentualPoi) {
+		this.width = width;
+		this.length = length;
+		this.percentagemPoi = percentualPoi;
+		this.graph = new GraphImpl(pathGraph);
+	}
+
+	public GraphGeneratorGrid(String pathGraph, int size, double percentualPoi) {
+		this(pathGraph, size, size, percentualPoi);
+	}
+
+	public void generateGraph() {
+		plotNodes();
+		plotEdges();
+		graph.createBounds();
+	}
+
+	private void plotNodes() {
+
+		BigDecimal interador_largura = BigDecimal.valueOf(180).divide(BigDecimal.valueOf(width), 8, RoundingMode.HALF_UP);
+		BigDecimal interador_altura =  BigDecimal.valueOf(180).divide(BigDecimal.valueOf(length), 8, RoundingMode.HALF_UP);
+		this.distance_largura = interador_largura;
+		this.distance_altura = interador_altura;
+
+		Set<Integer> listaIdsPoi = getListIdsPois();
+
+		Integer category = 0;
+		for (int i = 0; i < width; i++) {
+			BigDecimal latitude = interador_altura.multiply(BigDecimal.valueOf(i)).add(BigDecimal.valueOf(-90));
+			for (int j = 0; j < length; j++) {
+				BigDecimal longitude = interador_largura.multiply(BigDecimal.valueOf(j)).add(BigDecimal.valueOf(-90));;
+				Node node = new NodeImpl(Long.valueOf(category), latitude.doubleValue(), longitude.doubleValue());
+				if(listaIdsPoi.contains(category)) {
+					int[] costs = new int[]{0};
+					node.setCategory(category);
+					node.setExternalId(category);
+					node.setLabel("CATEGORY "+category);	
+					node.setCosts(costs);
+					listaIdsPoi.remove(category);
+				}
+				graph.addNode(node);
+				category++;
+			}
+		}
+	}
+
+	private Set<Integer> getListIdsPois() {
+
+		int quantidadeVerticesPoi = BigDecimal.valueOf(width).multiply(BigDecimal.valueOf(length)).multiply(BigDecimal.valueOf(percentagemPoi)).divide(BigDecimal.valueOf(100.0f), 8, RoundingMode.UP).intValue();
+
+		Set<Integer> listIdPoi = new HashSet<>();
+		do {
+			int rangeMax = width*length - 1;
+			Double idRandom = generatePdseurandom(0, rangeMax);
+			listIdPoi.add(idRandom.intValue());
+		} while(listIdPoi.size()<quantidadeVerticesPoi);
+
+		return listIdPoi;
+	}
+
+
+	private void plotEdges() {
+		for (int i = 0; i < width*length - 1; i++) {
+
+			//altura
+			if(i < (width * length - width)) {
+
+				Edge edgeOutTopDown = new EdgeImpl(Long.valueOf(i).longValue(), Long.valueOf(i+length).longValue(), distance_altura.intValue());
+				addCost(edgeOutTopDown);
+				graph.addEdge(edgeOutTopDown);
+
+				Edge edgeInTopDown = new EdgeImpl(Long.valueOf(i+length).longValue(), Long.valueOf(i).longValue(), distance_altura.intValue());
+				addCost(edgeInTopDown);
+				graph.addEdge(edgeInTopDown);
+			}
+
+			//largura
+			if(i%width != width - 1) {
+
+				Edge edgeOutLeftRight = new EdgeImpl(Long.valueOf(i).longValue(), Long.valueOf(i+1).longValue(), distance_largura.intValue());
+				addCost(edgeOutLeftRight);
+				graph.addEdge(edgeOutLeftRight);
+
+				Edge edgeInLeftRight = new EdgeImpl(Long.valueOf(i+1).longValue(), Long.valueOf(i).longValue(), distance_largura.intValue());
+				addCost(edgeInLeftRight);
+				graph.addEdge(edgeInLeftRight);
+
+			}
+
+		}
+	}
+
+	private double generatePdseurandom(int rangeMin, int rangeMax) {
+		return rangeMin + (rangeMax - rangeMin) * new Random().nextDouble();
+	}
+
+	private void addCost(Edge edge) {
+
+		int distanceInMeters = edge.getDistance() * 100;
+		int[] edgesCosts = CostGenerator.generateSyntheticEdgesCosts(distanceInMeters);
+		edge.setCosts(edgesCosts);
+	}
+
+	public boolean isConnected() {
+		return Boolean.TRUE;
+	}
+
+	public GraphBounds getGraph() {
+		return graph;
+	}
+}