1. Snapping
This approach simply ‘snaps’ a landing to the nearest existing road
segment. Since the snapping is done for each landing it is also called
an independent path method.
## project new roads using the 'snap' approach
projRoads_snap <- roads::projectRoads(landings, costRaster, roadsLine,
roadMethod = 'snap')
#> 0s detected in cost raster, these will be considered as existing roads
## plot the cost raster, landings, and roads segments to the landings
plot(costRaster, col = rastColours, main = "'Snapped' roads")
points(landings, pch = 19, col = 'red')
plot(projRoads_snap$roads, add = TRUE)
## update legend
points(x = 5.5, y = 4.8, pch = 19, xpd = TRUE, col = 'red')
text(x = 5.7, y = 4.8, labels = 'landing', adj = c(0, 0.4), xpd = TRUE)
lines(x = c(5.3, 5.6), y = c(4.2, 4.2), lwd = 2, xpd = TRUE)
text(x = 5.75, y = 4.2, labels = 'roads', adj = c(0, 0.3), xpd = TRUE)
Using this approach, a few issues would arise:
parallel roads are not realistic since there is no branching and
this leads to increased numbers of roads;
costs are not included (i.e., slope and barriers like large water
bodies).
This means this approach, while simple to implement, would over
estimate the amount of simulated roads.
2. Least Cost Paths (LCP)
This approach builds upon the snapping approach by assuming a ‘cost
directed’ path (i.e., “as the wolf runs”) for each landing to the
existing road network. This approach requires that a cost surface be
provided and used to build a mathematical graph using igraph and takes
considerably longer to compute.
Once the graph is built, the least cost path between each landing and
the nearest existing road is determined using Dijkstra’s
algorithm, which is implemented in the shortest_paths
function in igraph. Then the graph is updated so that the
graph returned in the result reflects the new roads built.
## project new roads using the 'LCP' approach
projRoads_lcp <- roads::projectRoads(landings,
costRaster,
roadsLine,
roadMethod = 'lcp')
#> 0s detected in cost raster, these will be considered as existing roads
## plot the cost raster and overlay it with new roads
plot(costRaster, col = rastColours, main = "'LCP' roads")
plot(projRoads_lcp$roads, add = TRUE)
points(landings, pch = 19, col = 'red') ## landings points
## legend
points(x = 5.5, y = 4.8, pch = 19, xpd = TRUE, col = 'red')
text(x = 5.7, y = 4.8, labels = 'landing', adj = c(0, 0.4), xpd = TRUE)
lines(x = c(5.3, 5.6), y = c(4.2, 4.2), lwd = 2, xpd = TRUE)
text(x = 5.75, y = 4.2, labels = 'roads', adj = c(0, 0.3), xpd = TRUE)
The main disadvantage of this approach is that roads are developed
independently. The least cost path may produce parallel or redundant
roads since a path is made for each target to the corresponding closest
point. This may mimic road development since road tenures give licensees
the right to limit other industrial users from using their road (i.e.,
gated roads); thereby forcing the other industrial users to consider
building a nearly parallel road. In some cases there will be branching,
where two roads connecting two landings to an existing road network will
use the same least cost path; however, this will be conditional on the
spatial configuration of the local cost surface and the existing road
network. Thus, the amount of road being developed from the LCP is
dependent on the local cost surface and may be either higher or lower
than the corresponding snap approach.
3. Dynamic Least Cost Paths (DLCP)
This approach reduces the number of parallel roads seen in the LCP
method because a road to each landing is built sequentially and the cost
in the graph is updated after each so that roads built earlier can be
used to access other landings. The order is determined by the
ordering argument to projectRoads and by
default builds roads to the closest landings first. To prevent this and
build roads in the order that the landings are supplied use
ordering = none.
## project new roads using the 'DLCP' approach
projRoads_dlcp <- roads::projectRoads(landings,
costRaster,
roadsLine,
roadMethod = 'dlcp')
#> 0s detected in cost raster, these will be considered as existing roads
## plot the cost raster and overlay it with new roads
plot(costRaster, col = rastColours, main = "'DLCP' roads")
plot(projRoads_dlcp$roads, add = TRUE)
points(landings, pch = 19, col = 'red') ## landings points
## legend
points(x = 5.5, y = 4.8, pch = 19, xpd = TRUE, col = 'red')
text(x = 5.7, y = 4.8, labels = 'landing', adj = c(0, 0.4), xpd = TRUE)
lines(x = c(5.3, 5.6), y = c(4.2, 4.2), lwd = 2, xpd = TRUE)
text(x = 5.75, y = 4.2, labels = 'roads', adj = c(0, 0.3), xpd = TRUE)
The DLCP approach produces more of a network rather than many
parallel roads. However, it is sensitive to the ordering of the
landings. Below we reverse the order of the landings but continue using
the default ordering of closest first. The two closest landings are tied
for distance to the road and the tie is broken by the order they are
supplied in so switching that produces a different road network.
## project new roads using the 'DLCP' approach
projRoads_dlcp2 <- roads::projectRoads(rev(landings),
costRaster,
roadsLine,
roadMethod = 'dlcp')
#> 0s detected in cost raster, these will be considered as existing roads
## plot the cost raster and overlay it with new roads
plot(costRaster, col = rastColours, main = "'DLCP' roads")
plot(projRoads_dlcp2$roads, add = TRUE)
points(landings, pch = 19, col = 'red') ## landings points
## legend
points(x = 5.5, y = 4.8, pch = 19, xpd = TRUE, col = 'red')
text(x = 5.7, y = 4.8, labels = 'landing', adj = c(0, 0.4), xpd = TRUE)
lines(x = c(5.3, 5.6), y = c(4.2, 4.2), lwd = 2, xpd = TRUE)
text(x = 5.75, y = 4.2, labels = 'roads', adj = c(0, 0.3), xpd = TRUE)
4. Minimum Spanning Tree (MST) with Least Cost Paths (LCP)
The MST approach builds upon the LCP approach by determining if
landings should be connected to one another before being connected to
the existing road network. In the MST approach, LCPs are estimated both
between the landings and between landings and the existing road network.
These distances are then used as nodes for solving a minimum spanning
tree. The sequence of vertices from the LCPs are then constructed
following the solution to the MST.
## project new roads using the 'MST' approach
projRoads_mst <- roads::projectRoads(landings,
costRaster,
roadsLine,
roadMethod = 'mst')
#> 0s detected in cost raster, these will be considered as existing roads
## plot the cost raster and overlay it with new roads
plot(costRaster, col = rastColours, main = "'MST' roads")
plot(projRoads_mst$roads, add = TRUE)
points(landings, pch = 19, col = 'red') ## landings points
## legend
points(x = 5.5, y = 4.8, pch = 19, xpd = TRUE, col = 'red')
text(x = 5.7, y = 4.8, labels = 'landing', adj = c(0, 0.4), xpd = TRUE)
lines(x = c(5.3, 5.6), y = c(4.2, 4.2), lwd = 2, xpd = TRUE)
text(x = 5.75, y = 4.2, labels = 'roads', adj = c(0, 0.3), xpd = TRUE)
The MST approach will produce the least amount of roads (relative to
the other approaches), given landings are allowed to connect to other
landings. This approach simulates a realistic view of road branching
relative to the other approaches. However, given the need to get LCP
distances, solve a MST and then construct the LCPs, it will likely be
the most costly in terms of computation time.
