Add files via upload

Author: vlarmet

DESCRIPTION

@@ -10,15 +10,15 @@ Description: Calculation of distances, shortest paths and isochrones on weighted
     bidirectional Dijkstra (Goldberg, Andrew & Fonseca F. Werneck, Renato (2005) <https://pdfs.semanticscholar.org/0761/18dfbe1d5a220f6ac59b4de4ad07b50283ac.pdf>),
     A* search (P. E. Hart, N. J. Nilsson et B. Raphael (1968) <doi:10.1109/TSSC.1968.300136>),
     new bidirectional A* (Pijls & Post (2009) <http://repub.eur.nl/pub/16100/ei2009-10.pdf>),
-    Contraction hierarchies (R. Geisberger, P. Sanders, D. Schultes and D. Delling (2008) <doi:10.1007/978-3-540-68552-4_24>).
+    Contraction hierarchies (R. Geisberger, P. Sanders, D. Schultes and D. Delling (2008) <doi:10.1007/978-3-540-68552-4_24>),
+    PHAST (D. Delling, A.Goldberg, A. Nowatzyk, R. Werneck (2011) <doi:10.1016/j.jpdc.2012.02.007>).
 License: GPL (>= 2)
 Imports: Rcpp (>= 1.0.1), RcppParallel, RcppProgress , data.table
 LinkingTo: Rcpp, RcppParallel, RcppProgress
 SystemRequirements: GNU make, C++11
 RoxygenNote: 6.1.1
 URL: https://github.com/vlarmet/cppRouting
-Suggests:
-    knitr, 
-    rmarkdown, 
-    igraph
+Suggests: knitr, rmarkdown, igraph
 VignetteBuilder: knitr
+NeedsCompilation: yes
+Packaged: 2019-12-20 11:17:10 UTC; vlarmet

R/RcppExports.R

@@ -101,6 +101,14 @@ Dijkstra_mat_par <- function(dep, arr, gfrom, gto, gw, NbNodes) {
     .Call(`_cppRouting_Dijkstra_mat_par`, dep, arr, gfrom, gto, gw, NbNodes)
 }
 
+Phast3 <- function(dep, arr, gfrom, gto, gw, NbNodes) {
+    .Call(`_cppRouting_Phast3`, dep, arr, gfrom, gto, gw, NbNodes)
+}
+
+Phast_par <- function(dep, arr, gfrom, gto, gw, NbNodes) {
+    .Call(`_cppRouting_Phast_par`, dep, arr, gfrom, gto, gw, NbNodes)
+}
+
 Simplify3 <- function(gfrom, gto, gw, NbNodes, loop, keep, iterate, progress) {
     .Call(`_cppRouting_Simplify3`, gfrom, gto, gw, NbNodes, loop, keep, iterate, progress)
 }

R/get_detour.R

@@ -78,7 +78,7 @@ get_detour<-function(Graph,from,to,extra=NULL,keep=NULL,long=FALSE){
   }
 
   res<-Detour(from_id,to_id,Graph$data$from,Graph$data$to,Graph$data$dist,Graph$nbnode,t=extra,Graph$dict$ref,to_keep)
-
+  
 
   if (long){
     names(res)<-paste0(from)
@@ -94,5 +94,4 @@ get_detour<-function(Graph,from,to,extra=NULL,keep=NULL,long=FALSE){
     return(res)
   }
 
-}
-
+}

R/get_distance_mat.R

@@ -3,10 +3,15 @@
 #' @param Graph  An object generated by makegraph(), cpp_simplify() or cpp_contract() function.
 #' @param from A vector of one or more vertices from which distances are calculated (origin).
 #' @param to A vector of one or more vertices (destination).
+#' @param algorithm Character. Only for contracted graph, "mch" for Many to many CH, "phast" for PHAST algorithm
 #' @param allcores Logical. If TRUE, all cores are used.
 #' @return Matrix of shortest distances.
 #' @note If graph is not contracted, get_distance_matrix() recursively perform Dijkstra algorithm for each 'from' nodes.
-#' Else, the algorithm is a modified bidirectional search adapted to many to many computation.
+#' If graph is contracted, the user has the choice between : \itemize{
+#'   \item many to many contraction hierarchies (mch) : should be applied if the matrix is square or 'almost' square.
+#'   \item PHAST (phast) : outperform mch on rectangular matrix
+#' }
+#'  See details in package website : https://github.com/vlarmet/cppRouting/blob/master/README.md
 #' @examples 
 #' #Data describing edges of the graph
 #' edges<-data.frame(from_vertex=c(0,0,1,1,2,2,3,4,4), 
@@ -25,7 +30,7 @@
 #' print(dir_dist)
 #' print(non_dir_dist)
 
-get_distance_matrix<-function(Graph,from,to,allcores=FALSE){
+get_distance_matrix<-function(Graph,from,to,algorithm="phast",allcores=FALSE){
   if (any(is.na(from))) stop("NAs are not allowed in origin/destination nodes")
   if (any(is.na(to))) stop("NAs are not allowed in origin/destination nodes")
   from<-as.character(from)
@@ -60,23 +65,59 @@ get_distance_matrix<-function(Graph,from,to,allcores=FALSE){
   }
 
   if (length(Graph)==5){
-    if (allcores==TRUE){
-      
-      if (length(to)< length(from)){
-        res<-par_Bidir_mat2(to_id,from_id,Graph$data[,2],Graph$data[,1],Graph$data[,3],Graph$nbnode,Graph$rank)
+    
+    if (algorithm=="mch"){
+      if (allcores==TRUE){
+        
+        if (length(to)< length(from)){
+          res<-par_Bidir_mat2(to_id,from_id,Graph$data[,2],Graph$data[,1],Graph$data[,3],Graph$nbnode,Graph$rank)
+          
+        }
+        else {
+          res<-par_Bidir_mat2(from_id,to_id,Graph$data[,1],Graph$data[,2],Graph$data[,3],Graph$nbnode,Graph$rank)
+          
+        }
+        
 
       }
       else {
-        res<-par_Bidir_mat2(from_id,to_id,Graph$data[,1],Graph$data[,2],Graph$data[,3],Graph$nbnode,Graph$rank)
-        
+        if (length(to)< length(from))  res<-Bidir_mat3(to_id,from_id,Graph$data[,2],Graph$data[,1],Graph$data[,3],Graph$nbnode,Graph$rank)
+        else res<-Bidir_mat3(from_id,to_id,Graph$data[,1],Graph$data[,2],Graph$data[,3],Graph$nbnode,Graph$rank)
       }
+    }
+    else{
 
+      test<-data.frame(id=Graph$dict$id,rank=(Graph$nbnode)-Graph$rank)
 
+      if (allcores==TRUE){
+        
+        if (length(to)< length(from)){
+          res<-Phast_par(test$rank[to_id+1],
+                         test$rank[from_id+1],
+                         test$rank[match(Graph$data$to,test$id)],
+                         test$rank[match(Graph$data$from,test$id)],
+                         Graph$data[,3],
+                         Graph$nbnode)
+          
+        }
+        else {
+          res<-Phast_par(test$rank[from_id+1],
+                         test$rank[to_id+1],
+                         test$rank[match(Graph$data$from,test$id)],
+                         test$rank[match(Graph$data$to,test$id)],
+                         Graph$data[,3],
+                         Graph$nbnode)
+          
+        }
+        
+        
+      }
+      else {
+        if (length(to)< length(from))  res<-Phast3(test$rank[to_id+1],test$rank[from_id+1],test$rank[match(Graph$data$to,test$id)],test$rank[match(Graph$data$from,test$id)],Graph$data[,3],Graph$nbnode)
+        else res<-Phast3(test$rank[from_id+1],test$rank[to_id+1],test$rank[match(Graph$data$from,test$id)],test$rank[match(Graph$data$to,test$id)],Graph$data[,3],Graph$nbnode)
+      }
     }
-    else {
-      if (length(to)< length(from))  res<-Bidir_mat3(to_id,from_id,Graph$data[,2],Graph$data[,1],Graph$data[,3],Graph$nbnode,Graph$rank)
-      else res<-Bidir_mat3(from_id,to_id,Graph$data[,1],Graph$data[,2],Graph$data[,3],Graph$nbnode,Graph$rank)
-    }
+
 
   }
 

R/get_path_pair.R

@@ -8,7 +8,7 @@
 #' @param keep numeric or character. Vertices of interest that will be returned. 
 #' @param long logical. If TRUE, a long data.frame is returned instead of a list.
 #' Default to 1, when cost is expressed in the same unit than coordinates. See details
-#' @return List containing shortest path nodes between from and to.
+#' @return List or a data.frame containing shortest path nodes between from and to.
 #' @note 'from' and 'to' must be the same length.
 #' @details If the input graph has been contracted by cpp_contract() function, the algorithm is a modified bidirectional search.
 #' To perform A* and New Bidirectional A star, projected coordinates should be provided in the Graph object.  

R/graphs.R

@@ -3,7 +3,10 @@
 #' @param df  A data.frame or matrix containing 3 columns: from, to, cost. See details.
 #' @param directed logical. If FALSE, then all edges are duplicated by inverting 'from' and 'to' nodes.
 #' @param coords Optional. A data.frame or matrix containing all nodes coordinates. Columns order should be 'node_ID', 'X', 'Y'.
-#' @return List
+#' @return List with two useful attributes for the user : \cr
+#' 
+#' \emph{nbnode} : total number of vertices \cr
+#' \emph{dict$ref} : vertices IDs
 #' @details 'from' and 'to' are character or numeric vector containing nodes IDs. 
 #' 'cost' is a non-negative numeric vector describing the cost (e.g time, distance) between each 'from' and 'to' nodes.
 #' coords should not be angles (e.g latitude and longitude), but expressed in a projection system. 
@@ -30,8 +33,6 @@
 #' #Construct graph with coordinates
 #' directed_graph2<-makegraph(edges, directed=TRUE, coords=coord)
 #' 
-#' 
-#' 
 
 makegraph<-function(df,
                      directed=TRUE,

build/vignette.rds

@@ -0,0 +1,6 @@
+## ----setup, include=FALSE------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>"
+)
+

inst/doc/cpprouting.R

@@ -0,0 +1,77 @@
+---
+title: "cppRouting"
+author: "Vincent Larmet"
+date: "`r Sys.Date()`"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{cppRouting}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r setup, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>"
+)
+```
+
+#Package presentation
+
+`cppRouting` is an `R` package which provide functions to calculate distances, shortest paths and isochrones/isodistances on non-negative weighted graphs.  
+`cppRouting` is characterized by :  
+
+- its ability to work on large road graphs (country/continent scale)
+- its large choice of `one-to-one` shortest path algorithms
+- its implementation of **contraction hierarchies** algorithm
+
+`cppRouting` is therefore particularly adapted for geographer, or whoever who need to calculate accessibility indicators at large scale.  
+Most of the functions are written in C++ and use std::priority_queue container from the Standard Template Library.  
+This package have been made with `Rcpp` and `RcppParallel` packages.
+
+
+#Main functions
+  
+`cppRouting` package provide these functions :  
+  
+- `get_distance_matrix` : compute distance matrix (between all combinations origin-destination nodes - *one-to-many*),  
+- `get_distance_pair` : compute distances between origin and destination by pair (*one-to-one*),  
+- `get_path_pair` : compute shortest paths between origin and destination by pair (*one-to-one*),  
+- `get_multi_paths` : compute shortest paths between all origin nodes and all destination nodes (*one-to-many*),  
+- `get_isochrone` : compute isochrones/isodistances with one or multiple breaks.  
+- `get_detour` : return nodes that are reachable within a fixed additional cost around shortest paths. This function can be useful in producing accessibility indicators.  
+- `cpp_simplify` : remove non-intersection nodes, duplicated edges and isolated loops in the graph. Graph topology is preserved so distance calculation is faster and remains true. This function can be applied to very large graphs (several millions of nodes).  
+- `cpp_contract` : contract the graph by applying **contraction hierarchies** algorithm.  
+
+  
+###Path algorithms                    
+Path algorithms proposed by the package are :  
+
+  - **1** uni-directional Dijkstra algorithm,
+  - **2** bi-directional Dijkstra algorithm,
+  - **3** uni-directional A* algorithm  
+  - **4** New bi-directional A* algorithm (Piljs & Post, 2009 : see http://repub.eur.nl/pub/16100/ei2009-10.pdf)
+  - **5** *one-to-one* bi-directional Dijkstra adapted to contraction hierarchies (Geisberger & al., 2008) 
+  - **6** *many-to-many* bi-directional Dijkstra adapted to contraction hierarchies (Geisberger & al., 2008) 
+  - **7** PHAST algorithm (Hardware-accelerated shortest path trees), *one-to-all* algorithm adapted to contraction hierarchies (Delling & al., 2011)
+
+
+*1*, *2*, *3* and *4* are available for **one-to-one** calculation in `get_distance_pair` and `get_path_pair` functions on a **non-contracted** graph.
+In these functions, uni-directional Dijkstra algorithm is stopped when the destination node is reached.  
+`A*` and `NBA*` are relevant if geographic coordinates of all nodes are provided. Note that coordinates should be expressed in a **projection system**.  
+To be accurate and efficient, `A*` and `NBA*` algorithms should use an admissible heuristic function (here the Euclidean distance), i.e cost and heuristic function must be expressed in the same unit.  
+In `cppRouting`, heuristic function `h` for a node (n) is defined such that :   
+**h(n,d) = ED(n,d) / k**
+with *h* the heuristic, *ED* the Euclidean distance, *d* the destination node and a constant *k*.  
+So in the case where coordinates are expressed in meters and cost is expressed in time, *k* is the maximum speed allowed on the road. By default, constant is 1 and is designed for graphs with cost expressed in the same unit than coordinates (for example in meters).  
+If coordinates cannot be provided, bi-directional Dijkstra algorithm is the best option in terms of performance.  
+
+*5* is used for **one-to-one** calculation in `get_distance_pair` and `get_path_pair` functions on a **contracted** graph.  
+
+*1* is used for **one-to-many** calculation in `get_distance_matrix` function on a **non-contracted** graph.  
+
+*6* and *7* are available for **one-to-many** calculation in `get_distance_matrix` function on a **contracted** graph.  
+
+#Examples and applications using `cppRouting`  
+
+see : https://github.com/vlarmet/cppRouting/blob/master/README.md