Recovering full path

[RegularnaMatrica]

Hi, thank you for developing this package.

This question is not directly related to the primary intended use of the package, but I would appreciate any guidance. Is there a way to recover the full geometry from a path computed on a contracted graph?

contracted_path <- dodgr_paths(
  graph = contracted_graph,
  from = from,
  to = to
)

I am generating routes iteratively to satisfy certain boundary conditions. Because this process involves many iterations, I am using a contracted graph with dodgr_paths for performance reasons, as it is significantly faster than using the full graph.

Currently, after generating a route on the contracted graph, I attempt to reconstruct the full path by computing pairwise paths on the full graph. The object route_path represents the concatenation of contracted paths across iterations:

  # retrieve full transition vector for each contracted transition
  transition_list <- dodgr::dodgr_paths(
    graph = full_graph,
    from = route_path[-length(route_path)],
    to = route_path[2:length(route_path)],
    pairwise = TRUE
  )
  
  # convert transitions into matrix format
  transition_list <- transition_list |>
    unlist(recursive = FALSE) |>
    lapply(function(x) embed(x, 2)[, 2:1, drop = FALSE])
  
  # transition data.frame
  transition_df <- do.call(rbind, transition_list)
  colnames(transition_df) <- c(".vx0", ".vx1")
  transition_df <- data.table::as.data.table(transition_df)
  
  # add metadata to the transitions
  transition_df <- full_graph[transition_df, on = c(".vx0", ".vx1"),]

However, this approach is not valid in my case because the weighted distance (d_weighted) in the contracted graph is modified during each iteration to bias certain edge types.

Would it be possible to include a geometry column in the contracted graph that stores the corresponding full path geometry (e.g., as a sequence of coordinates or edge IDs) for each contracted edge?

If not currently supported, is there a recommended way to map contracted edges back to the original edge sequences?

[mpadge]

Good question @RegularnaMatrica. It's entirely possible to recover the "uncontracted" paths (in dodgr terminology). There is simply no current function to enable that. Here's some code which should do what you want. First set up a graph and calculate some paths:

library (dodgr)
graph <- readRDS ("some-graph-sc.Rds") |>
    weight_streetnet ()
graph_c <- dodgr_contract_graph (graph)

n <- 10L
from <- sample (graph_c$.vx0, size = n)
to <- sample (graph_c$.vx1, size = n)
p <- dodgr_paths(graph_c, from = from, to = to, pairwise = TRUE, vertices = FALSE)

The expansion from contracted back to full graph is held in a tempdir file called "edge_map". That can then be used in an internal function called uncontract_graph to recover the original, uncontracted version. A function to expand one of the paths would work like this:

edge_map <- dodgr:::get_edge_map (graph) # internal function

expand_one_path <- function (p, from_i = 1L, to_i = 1L, graph, graph_c, edge_map) {

    p_i <- p [[from_i]] [[to_i]]
    graph_ci <- graph_c [p_i, ]

    edge_map_i <- edge_map [which (edge_map$edge_new %in% graph_ci$edge_), ]
    index <- which (
        graph$edge_ %in% edge_map_i$edge_new |
        graph$edge_ %in% edge_map_i$edge_old |
        graph$edge_ %in% graph_ci$edge_
    )
    graph_ci_full <- graph [index, ]
    dodgr:::uncontract_graph (graph_ci, edge_map_i, graph_ci_full)
}

Applying that to one of the paths would then give this:

p11 <- expand_one_path (p, 1, 1, graph, graph_c, edge_map)
length (p [[1]] [[1]])  # Length of contracted path:
#> [1] 224

nrow (p11) # Length of uncontracted path:
#> [1] 517

^{Created on 2026-04-02 with reprex v2.1.1}

A full expand_dodgr_paths function would then just iteratively apply that. I might not have that exactly right - I'd have to check inside the uncontract_graph() function to make sure that the ordering of edges was perfectly retained. Doing it properly might require modifying code within that function to ensure all is perfectly recovered. That example is also SC-specific, and would also need to be generalised by using the dodgr_graph_cols() function, and manipulating corresponding columns that way, but idea stays the same.

It'd be great if you could submit a PR - you could just add it to https://github.com/UrbanAnalyst/dodgr/blob/main/R/paths.R, which is pretty short 👍