Ungap the Map, v2! Glue to the scheme sketcher, let people apply a proposed scheme, and see how it affects od2net output

I am following example from sotm-eu, and following it gives

Warning 1: Input datasource uses random layer reading, but output datasource does not support random layer writing

among output.

No idea is it pointless message or critical error or what, but would be nice to somehow get rid if it or get clearer error.

• Fully separated cycletracks next to a motorway aren't great. Maybe just project perpendicularly (or buffer and look for overlaps) and check the speed / classification of the parallel road. https://www.openstreetmap.org/way/153773332
• Separated paths through greenspace can sometimes be nice, but may be uncomfortable at night. https://www.openstreetmap.org/way/933851270
• Similarly, industrial land use as the surrounding thing may feel uncomfortable. https://www.openstreetmap.org/way/166148979

For all of these, I think we could first just detect this situation about the edge (and surface that info in the UI clearly). Then we can write edge cost and LTS functions that take these things into account, using TBD weightings.

And a further idea: local knowledge (or routing preference) is always going to be helpful. If we have a way in the UI to just annotate a road and edit the LTS / edge cost manually, then that could be super helpful.

Not useful and unsure how to implement, but see inspiration from the throughput layer in A/B Street

For visualization and/or analysis purposes, bundle parallel edes

There are ways to fix this by changing the arguments sent to tippecanoe, sure others have noticed it but cannot see an issue open on it.

Related issue is #37, I think fixing this one would yield a bigger benefit, especially for use cases where strategic planning is the aim.

Source: following instructions in #2

It's down as LTS 4 in the tool but is 20 mph living street.

Is the .ts code expecting speed in units of kph?

https://www.openstreetmap.org/way/31958493#map=19/53.80025/-1.55256

I know this is work in progress but thought I'd give it a spin. Things I've tried so far based on looking at https://github.com/dabreegster/od2net/blob/main/examples/run_all.sh

I've tried:

cd examples/liverpool/
python setup.py 
Traceback (most recent call last):
  File "/home/robin/github/people/dabreegster/od2net/examples/liverpool/setup.py", line 109, in <module>
    run(["mkdir", "-p", "input"])
NameError: name 'run' is not defined

This has been started, but needs docs and to include uptake info

The

```bash

code in there can run with quarto render README.qmd improving reproducibility.

Could set

#| eval: false

for the computationally intensive chunks or could just run the whole thing on any suitably resourced computer.

I plan to give this a bash over the next couple of weeks in any case, impressive speed-ups compared with routing used by PCT from what I can tell.

Probably make a multi-page book, possibly integrated with the Svelte app or not

• Contribution guide
• Credits (including Rust and other tech dependencies)
• Describe different ways of using/interpreting -- what people can access something safely right now, vs if we could modify any road
• Explain why turn restrictions (and relations) are ignored
• Define scope (and notable omissions like PT and accessibility/connectivity)
• Explain use cases with walkthroughs/examples (comparing to current counts, looking for what could be done safely right now, looking for potential demand, understanding detours)
• How to interpret overall potential demand vs making just a few upgraded edges?
• Flow chart for how to use it
• Pipeline diagram of how it works
• Perf table
• Intro it as betweenness centrality in different worlds (existing or perfect)
• Validation against real counts, possibly ignoring absolute and even relative amounts; just checking ordering
• Explain why one country-wide run is more useful than a bunch of runs in smaller regions
• Expandable detail sections, explaining how it works, like with the OSM node model (and how node pairs work)
• Explain why a full traffic assignment model isn't useful
• Include all references (especially https://npct.github.io/pct-shiny/regions_www/www/static/03a_manual/pct-bike-eng-user-manual-c1.pdf)

Currently settings such as the tags associated with paths on which cycling is forbidden are hard coded in .rs files:

Would it be possible to replace such settings with config files in json for easier editing and less Rust code reading? Aligns with the aim set out in #28 to make this more accessible (and in this case configurable) for others.

Use case: places like Norway and I believe Japan where cycling on footpaths is allowed, or for uses where we want to route cycling on a wider part of the network to inform investment decisions.

• Finish porting TS to Rust logic
• Split into a new crate, and add a WASM API
• Remove old code from the frontend, and use the WASM API for messages/rationale
• Start unit tests
• Ping BikeOttawa folks (and ask about highway=construction and maxspeed bugs)

York geojson, near Holgate:

pmtiles using current settings:

pmtiles using --no-line-simplification or --simplify-only-low-zooms:

Possible reference, https://www.liedman.net/2015/04/13/add-elevation-data-to-osrm/

A way to run all examples locally, recording time / memory / space / etc requirements and formatting nicely for docs.

• Specify OD pattern interactively, drawing zones / points and assigning weights
• Pick route profile and other things
• Output config.json
• Integrate with popgetter?

Concentrate on usage of crossings, not roads. As an example, see if the Angel crossing lights up

From every building to https://www.openstreetmap.org/way/23196317:

AREA=leeds
URL=https://download.geofabrik.de/europe/great-britain/england/west-yorkshire-latest.osm.pbf

mkdir $AREA
curl $URL -o $AREA/input.osm.pbf
ogr2ogr -f GeoJSON -dialect sqlite -sql 'SELECT ST_Centroid(geometry) FROM multipolygons WHERE building IS NOT NULL' $AREA/origins.geojson $AREA/input.osm.pbf
# For destinations, just one hospital: https://www.openstreetmap.org/way/23196317
echo '{"type":"FeatureCollection","features":[{"type":"Feature","properties":{},"geometry":{"coordinates":[-1.5521021406315,53.80241788159283],"type":"Point"}}]}' > $AREA/destinations.geojson

# Generate the "fast" network
cargo run --release -- '{"directory":"'"$AREA"'","requests":{"Generate":{"pattern":"FromEveryOriginToOneDestination"}},"routing":{"FastPaths":{"cost":"Distance"}}}'
mv $AREA/output.geojson $AREA/fast_output.geojson

# Now a rough approximation of a "quiet" network, penalizing main roads heavily
rm -f $AREA/ch.bin
cargo run --release -- '{"directory":"'"$AREA"'","requests":{"Generate":{"pattern":"FromEveryOriginToOneDestination"}},"routing":{"FastPaths":{"cost":"AvoidMainRoads"}}}'
mv $AREA/output.geojson $AREA/quiet_output.geojson

Manually load the two leeds/{fast,quiet}_output.geojson files in the viewer

Decide a name. I have many ideas offline, but none quite fit yet

This project started by making HTTP requests to OSRM, but the performance of that is terrible. I'm going to remove that integration for now to simplify and trim dependencies. Later on, revisit this:

• Can we link against the native API and get better performance?
• Can we use a prepared OSRM CH and just do the calculation ourselves?
• Can we use an input graph from OSRM, effectively copying/reusing its profile?

Same questions for other routing engines

• Preserve the hierarchy of blocks
• Print the final summary more nicely (flamegraph / proportional)
• Work on the API style
• Get feedback from r/rust and console-rs

Most users will be using one of the two, so figure out how to nicely integrate

Next: Create an example for Lisbon! @partavogen already forked this repo and is trying to make that, but also facing some issues.

Originally posted by @temospena in #2 (comment)

Hi all,

We are exploring od2net in Lisbon, and facing some problems.
Regarding #18 , how can we add this as the gradient value? Is it a matter to put the geotiff in a folder and point to it, or we need to pre-process with the data?
Here is a nice geotiff of Lisbon area: https://github.com/U-Shift/Declives-RedeViaria/blob/main/raster/LisboaIST_clip_r1.tif (10m res)
https://github.com/U-Shift/Declives-RedeViaria/blob/main/raster/LisboaCOPERNICUS_clip.tif (25m res)

Thanks!

Loading the GJ file with all edges and optionally origins/destinations is painfully slow

• Optionally omit edges with low counts?
• Try pmtiles (possibly with attribute-filter or https://github.com/felt/tippecanoe#geojson-extension to simplify at low zooms)

• wf02eq, UK output area to workplace zone, about 16 million rows
• wu03ew, UK MSOA to MSOA, about 2 million rows
• Soundcast, completely disaggregated individuals (about 4 million people?)

Run one of the Python examples end-to-end in GH actions and check something about the output. Pick a small one and possibly stash fixed input files somewhere.

If you have two different count outputs, visualize the diff

Example diffs could represent a network modification (if some edge becomes nicer, how does traffic redirect) or be used to parameter tune (if we change LTS definition, what overall effect does it have?)

• Document it
• Get rid of default filenames for input.osm.pbf, origins.geojson, etc?
• Name ch.bin more carefully, based on params
• Name the output more carefully

Just documenting findings as I look at this with Joey:

That's from running it in browser for Leeds. Not an issue with this codebase but with the LTS scoring or OSM tags or combination. There is a light seggregated cycleway on and off the road but is defo not suitable for children, this is quite a scary place to be on a bike:

Source: https://www.google.com/maps/@53.8067038,-1.5294913,3a,60y,90t/data=!3m6!1e1!3m4!1sVjDNXOnf-deeLq26tVSLWg!2e0!7i16384!8i8192?entry=ttu

A particularly useful first example to flesh out more.

• For visualization, we actually only care about one destination (hospital) at a time
• We can use 2011 OA-to-OA flows, noting the hospital is the main thing in its OA
• Be careful about LTS / edge scoring -- the obvious path by the hospital isn't lit, so it's not a good option
• actdev UI for inspiration
• Questions
  • Assuming existing infra, what percentage of the staff can safely reach the hospital today?
  • If we could improve infrastructure everywhere, what's the potential network look like?

Possibly this could be a generally useful mode of the web app... instead of loading a prebuilt network representing some OD pattern, let people manually pick a destination, use preconfigured OD data, and show the network to that one place. Depending on the size of the inputs, could/should we...

• run this totally in-browser with WASM
• have a simple API to calculate on-the-fly
• precalculate and store files for some fixed destinations

https://github.com/dabreegster/routing-engines/blob/main/src/plugins/route_cost.rs is a placeholder

• A speed per way (so cobblestone or canal towpaths aren't fast, even if they're safe from LTS perspective)
• Can we directly or indirectly use profiles from OSRM, etc in a very quick way?

• Compare to p33 of https://content.tfl.gov.uk/cycling-action-plan.pdf
• Try out results in a place with an existing rich network, like in NL
• Compare current behavior to real traffic counters

• Plumb along and display zones for origins/destinations too?
• Scale O/D circles based on count, and include histograms for them too?
• Try rank/ordering for line width (1st most important edge, 2nd...)

• Output counts forwards and backwards
• Be much more careful in the routing input graph and edge cost function with one-ways (depending on the policy question, we may care about existing one-ways or not)

Deadline: 24th August.

https://twitter.com/osmscience/status/1688249220954812417

and publish to https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry

Blocked by branding

Just a heads-up after reproducing some of the code in the README, managed to get this map which I'm happy with 🎉

FYI anyone running this on Ubuntu, you may need to update your node version. This is what worked for me after reading this.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash
source ~/.bashrc
nvm list-remote
nvm install v18.12.0
nvm use v18.12.0

Use case: you want to know the main areas that will benefit from investment in a particular bridge. Illustration for Waterloo Bridge:

This suggests that many of the users are coming from the south of the river to access destinations just north of the river.

I recall conversations at FOSS4G last year in Florence about ways to do this on-the-fly, that was impressive. In this case it's just returning all the routes that intersect with the view area after zooming in and clicking 'Free lines'. Not the most intuitive interface or efficient implementation, but works to illustrate the concept.

Source: https://www.pct.bike/m/?r=london

Similar to LTS, visualize and break down distance by roads with excess width, parking/turn lanes, etc

Today:

• from every origin to one destination
• from every origin to nearest destination
• from zone to zone
• from zone to point

Can we re-express this with less repetition?

Also, another pattern is commuting distance from an origin, without knowing direction