Fragen zu einer Erreichbarkeitsanalyse mit OSM Daten

Hallo,

ich habe eine Frage zum (Routing) mit OSM Daten.

Ich habe auch schon im Internet und hier gesucht aber nur Dienste gefunden die mir das gesuchte anbieten aber nichts was mir erklärt wie ich es selber machen könnte.

Auf der Geofabrik Seite wird der “Spider Graph” beworben. Dieser zeigt mir anhand eines Startpunktes und einer einstellbaren Zeit alle Strassen an die anhand der eingestellten Parameter erreichen kann.

Ich würde gerne selber so ein Tool bauen finde aber keine richtigen Anhaltspunkte dazu. Hat da jemand schon mal was gelesen ?

Gruß,

Markus

Hi Markus,
der Pascal Neis hatte da was gebaut, was dann wohl auch in den OpenRouteService gelandet ist:
http://neis-one.org/2010/09/osm-fur-die-feuerwehr-2-0/
Vielleicht reicht dir das ja schon, ansonsten müsstest du uns bitte noch mehr Infos zu deiner Idee geben :slight_smile:

Hallo Markus

Du brauchst einen Routing-Algorithmus, dem du deine speziellen Anforderungen zusätzlich beibringst.
http://wiki.openstreetmap.org/wiki/Routing kann dein Startpunkt für eine Suche sein.
Der OpenRouteService von Pascal Neis wurde ja bereits von !i! erwähnt.

Edbert (EvanE)

Ich kann zum Rumspielen mit Routing-Funktionen pgrouting empfehlen. Wenns mal installiert ist, hat man ein System, das nicht so schrecklich performant ist, aber dafür halbwegs zu verstehen und man kann mal eben schnell was ausprobieren. Sowas wie “was liegt in 1500m um einen Punkt” ist zumindest schnell mal runtergetippt (*)

Grüße, Max

(*) wobei zwischen Demo und Verwendbarkeit da natürlich noch ein paar Tage Arbeit lägen. z.B. müssten Straßenabschnitte noch geteilt werden, bei denen nur ein Ende erreichbar ist, das andere aber zu weit weg. Die Frage “was sind 1500m in Minuten?” müsste geklärt werden und falls man die Straßenverkehrsordnung einhalten möchte, muss man die auch einbauen mit all ihren Regeln zum Abbiegen und zur Wahl der Fahrtrichtung. Ich beschränke mich auf Fußgänger, da gibt es weniger Vorschriften und für die Demo dürfen die sowieso laufen, wo sie wollen :wink:

PS: Und zur Qualitätssicherung kann mans auch nehmen: Der Weg, der im Süden so unnatürlich weit aus dem 1500m-Luftlinie-Kreis rausragt ist ein Fußweg, der mehrere Straßen ohne gemeinsamen Node überquert. Da kennt der Router keinen Halt bis zum Ende des Weges und markiert alles. Ich hab mal zumindest die Kreuzungen verbunden…

Im Wiki gibt es noch Isochrone und Distance maps.

Gruß,
Norbert

Ja das ist genau das was ich suche allerdings habe ich keine anständige Anleitung zum gefunden.

Seine Seite hatte ich gestern schon gesehen allerdings ist sie:

Ich werde ihn wohl mal so anschreiben müssen.

Als erster Ansatz hatte ich mir gedacht ich installiere mir eine OpenSource Routing Engine die mit OSM Daten läuft und dann gehe ich in einer schleife alle Nodes in einem bestimmten Umkreis um den startpunkt durch und meistens steht ja dann die Dauer der Strecke dort :slight_smile:

Ich werde mir auch mal das http://wiki.openstreetmap.org/wiki/Distancemap.pl DistanceMap.pl anschauen.

Vielen Dank auch an die anderen Hilfesteller hier !
Wenn ich da etwas hin bekomme stelle ich das gerne auch zur Verfügung.

Das wird eher nicht so schnell sein… Die beiden Routen zu zwei benachbarten Punkten führen ja oft über den gleichen Weg. Dass man den ersten schon ausgerechnet hat, könnte man sich beim zweiten Punkt zu Nutze machen.

Hi,

es gibt zwei Artikel die ähnlich u.a. den Dienst etwas beschreiben:

  • Neis, P., A. Zipf (2007)[1]: A Web Accessibility Analysis Service based on the OpenLS Route Service. AGILE 2007. International Conference on Geographic Information Science of the Association of Geograpic Information Laboratories for Europe (AGILE). Aalborg, Denmark.
    Artikel hier verfügbar
  • Neis, P., A. Zipf, R. Helsper, Kehl, A. (2007)[2]: Webbasierte Erreichbarkeitsanalyse – Vorschläge zur Definition eines Accessibility Analsysis Service (AAS) auf Basis des OpenLS Route Service. REAL CORP 2007. Wien, Austria.

viele gruesse
pascal

[1] http://agile.gis.geo.tu-dresden.de/web/Conference_Paper/CDs/AGILE%202007/PROC/PDF/97_PDF.pdf
[2] http://koenigstuhl.geog.uni-heidelberg.de/publications/bonn/CORP07-AAS-pn-az-final.pdf

Hi,

ich musste diesen speziellen Dienst leider vor 1.5 Wochen temporär auf dem Server
abschalten, weil ihn einfach zu viele Leute per Script verwendet haben und ihn
dabei immer wieder zum Abstüzen gebracht haben. Generell habe ich nichts
dagegen wenn Leute ihn in Scripten verwenden, allerdings machen es manche
mit nicht korrekten Anfragen was bei massig Requests dann in einem Absturz
bei mir endet :frowning: Ich weiß das ich dies auf meiner Seite abfangen kann, manchmal
würde ich mir aber auch wünschen das Leute mit etwas mehr Vorsicht andere
und vor allem kostenlose Dienste verwenden …

sorry & viele gruesse
pascal

Ja das kann ich sehr gut verstehen.
Gibt es die Erreichbarkeitsanalyse auch als Source Code oder ist das dein alleiniges Geistiges Eigentum ?

Gruß,

Markus

Hi,

die Erreichbarkeitsanalyse wurde im Rahmen eines Forschungsprojektes an der FH Mainz entwickelt.
Der Source Code ist leider nicht öffentlich zugänglich. Wenn du dir das Tool aber eh selber bauen willst,
würde ich dir eher empfehlen auf einer bestehendenn OS Lösung aufzubauen. Wenn du möchtest kann
ich dich dabei gerne unterstützen.Vielleicht ensteht dann wenigstens eine brauchbare und vor allem Offene Lösung :slight_smile:

viele gruesse
pascal

EDIT: ps. in den beiden erwähnten Artikeln ist eigentlich ganz gut beschrieben was wichtig ist und wie es funktioniert.

Tach,

Das ist in der Tat auch eine hochkomplexe Sache! Für die Lösung musste ich mein ganzes Team heranziehen.

1. Wir beschaffen die Daten:

Wir holen die Innenstadt von Köln ab:


wget -O data.osm http://www.openstreetmap.org/api/0.6/map?bbox=6.938,50.920,6.978,50.951

2. Wir erzeugen einen Routing-Graphen:

Dazu benutzen wir das überaus hochaufwendige Skript “analyze.pl”:


#!/usr/bin/perl

use strict;
use utf8;

binmode STDIN, ':utf8';
binmode STDOUT, ':utf8';

# type, id and attributes of current osm object

my $type;
my $id;
my %attr;

# lon lat of nodeIds

my %lon;
my %lat;

# nodeIds of ways

my @nodeIds;


while (<>) {

	# start of osm object

	if (m#^\s*<(changeset|node|way|relation)\s+id=['"](\d+)['"]#) {

		$type = $1;
		$id   = substr($type,0,1).$2;
		%attr = ();
		@nodeIds= ();
	}

	# lon lat of nodeIds

	if (m#^\s*<node\s+id=['"]([^'"]*)['"]\s+lat=['"]([^'"]*)['"]\s+lon=['"]([^'"]*)['"]#) {

		$lat{"n$1"} = $2;
		$lon{"n$1"} = $3;
		next;
	}

	# nodes of ways

	if (m#^\s*<nd\s+ref=['"]([^'"]*)['"]#) {

		push (@nodeIds, "n$1");
		next;
	}

	# tag value

	if (m#^\s*<tag\s+k=['"]([^'"]*)['"]\s+v=['"]([^'"]*)['"]#) {

		# xml entities are left as an exercise to the students™
		$attr{$1} = $2;
		next;
	}

	# end of way

	next unless m#^\s*</way># && @nodeIds>=2;

	#-------------------------------------------------------------------------------------
	#	preprocess way
	#	- test if usable
	#	- determine speed
	#-------------------------------------------------------------------------------------

	# skip if osm way is not a real world way
	# (may accept bus or train or younameit)

	next unless $attr{'highway'};

	# too dangerous

	next if $attr{'name'} =~ /katze/i;

	# compute available forward and backward speed for way (m/s)

	my $speedForward  = 1;
	my $speedBackward = 1;

	$speedForward=$speedBackward = 5 if $attr{'highway'} eq "pedestrian";

	# oneway

	$speedForward = 0 if $attr{'oneway'} eq '-1';
	$speedBackward= 0 if $attr{'oneway'} eq 'yes';

	#-------------------------------------------------------------------------------------
	#	generate graph entries
	#-------------------------------------------------------------------------------------

	# coordinates of graph nodes

	foreach my $nid (@nodeIds) {

		print "node\t$nid\t$lon{$nid}\t$lat{$nid}\n";
	}

	# process segments of ways resulting in graph arcs

	for (my $index=0; $index<@nodeIds-1; $index++) {

		# start and end node of segment

		my $snode = $nodeIds[$index  ];
		my $enode = $nodeIds[$index+1];

		# distance in degrees

		my $dLon = ($lon{$snode}-$lon{$enode}) * cos ($lat{$snode} * 3.1415925 / 180.0);
		my $dLat = ($lat{$snode}-$lat{$enode});

		# distance scaled to meters

		my $distance = sqrt($dLon*$dLon + $dLat*$dLat) / 360.0 * 40000000;

		# forward arc

		if ($speedForward>0) {

			my $time = $distance / $speedForward;
			print "arc\t$snode\t$enode\t$time\t$id\tf\t$index\n";
		}

		# backward arc

		if ($speedBackward>0) {

			my $time = $distance / $speedBackward;
			print "arc\t$enode\t$snode\t$time\t$id\tb\t$index\n";
		}
	}
}

Wir rufen das Skript auf:


./analyze.pl <data.osm >graph

Und erhalten eine Textdarstellung des Routing-Graphen “graph”.

Der Graph enthält Knoten mit Id und Koordinaten:


node n743325638 6.9722186 50.9463142

und gerichtete Kanten mit Angabe der verbundenen Knoten, der Entfernung, und der Quelle der Daten (OSM-Way-Id, Richtung, Segmentnummer):


arc n743325638 n743325592 10.0407049925005 w59865404 f 0

3. Wir führen die Erreichbarkeitsanalyse durch:

Dazu nutzen wir das unfassbar hochkomplexe “reachable.pl”:


#!/usr/bin/perl

# ./reachable.pl {lat} {lon} {distance} <data.graph

use strict;
use utf8;

# process args

my $startLat = 1.0 * shift (@ARGV);
my $startLon = 1.0 * shift (@ARGV);
my $maxDist  = 1.0 * shift (@ARGV);

# graph

my %lon;
my %lat;

my %neighbours;		# node -> list of nodes
my %arcLength;		# snode,enode -> distance

#-----------------------------------------------------------------------
#	read graph
#-----------------------------------------------------------------------

warn "reading graph ...\n";

while (<>) {

	chomp;
	my @f = split /\t/;

	# node

	if ($f[0] eq 'node') {

		my $node = $f[1];
		my $lon  = $f[2];
		my $lat  = $f[3];

		$lon{$node} = $lon;
		$lat{$node} = $lat;
		next;
	}

	# arc

	if ($f[0] eq 'arc') {

		my $snode = $f[1];
		my $enode = $f[2];
		my $dist  = $f[3] || 0.001;	# must NOT be zero

		# ignode multiple arcs between two nodes

		next if defined $arcLength{$snode, $enode};

		# no neighbours yet -> create list

		unless ($neighbours{$snode}) {
			$neighbours{$snode} = [];
		}

		# store arc

		$arcLength{$snode, $enode} = $dist;
		push (@{$neighbours{$snode}}, $enode);

		next;
	}
}

#-----------------------------------------------------------------------
#	lookup start node
#-----------------------------------------------------------------------

warn "lookup start node ...\n";

my $bestDistance = 1e30;
my $startNode;
my $cos = cos ($startLat * 3.1415925 / 180.0);

foreach my $node (keys %lon) {

	# distance in degrees

	my $dLon = ($lon{$node}-$startLon) * $cos;
	my $dLat = ($lat{$node}-$startLat);

	# skip square root and scaling

	my $distance = $dLon*$dLon + $dLat*$dLat;

	next unless $distance < $bestDistance;

	# found better node

	$startNode = $node;
	$bestDistance = $distance;
}

die unless $startNode;

# start node found

warn "start node $startNode @ lat $lat{$startNode} lon $lon{$startNode}.\n";

print "start\t$lon{$startNode}\t$lat{$startNode}\n";

#-----------------------------------------------------------------------
#	reachability analysis
#-----------------------------------------------------------------------

my %bestDistance;	# distance from startnode to node
my %predecessor;	# only needed if way from start to certain node to be displayed

$bestDistance{$startNode} = 0;

my @nodesToBeAnalyzed = ($startNode);

# as long as nodes available

while (@nodesToBeAnalyzed) {

	# order by distance and get nearest, terminate if nearest outside limit

	@nodesToBeAnalyzed = sort {$bestDistance{$a} <=> $bestDistance{$b}} @nodesToBeAnalyzed;

	my $thisNode = $nodesToBeAnalyzed[0];
	my $thisDist = $bestDistance{$thisNode};

	last if $thisDist>$maxDist;

	shift (@nodesToBeAnalyzed);

	# check arcs

	my $hasOuterNeighbour = 0;

	foreach my $thatNode (@{$neighbours{$thisNode}}) {

		# dist to thatNode via thisNode

		my $viaDist = $thisDist + $arcLength{$thisNode, $thatNode};

		# reachable?

		if ($viaDist <= $maxDist) {
		
			print "arc\t$lon{$thisNode}\t$lat{$thisNode}\t$lon{$thatNode}\t$lat{$thatNode}\n";

		} else {

			print "noarc\t$lon{$thisNode}\t$lat{$thisNode}\t$lon{$thatNode}\t$lat{$thatNode}\n";
			$hasOuterNeighbour=1;
		}

		# already known distance of thatNode

		my $thatDist = $bestDistance{$thatNode};

		# if first touch of thatNode, add to todo list

		push (@nodesToBeAnalyzed, $thatNode) unless defined $thatDist;

		# remember best distance to thatNode

		$bestDistance{$thatNode} = $viaDist if !defined $thatDist || $viaDist<$thatDist;
	}

	print "inner\t$lon{$thisNode}\t$lat{$thisNode}\n" if $hasOuterNeighbour;
}

# list nodes on todo list

foreach my $thisNode (@nodesToBeAnalyzed) {

	print "outer\t$lon{$thisNode}\t$lat{$thisNode}\n";
}

# done

Wir rufen es mit der Startposition und maximalen Entfernung auf:


./reachable.pl 50.936 6.948 500 <graph >reachable.txt

und erhalten die Erreichbarkeitsanalyse “reachable.txt”.

Diese enthält den Startknoten “start”, gerade noch erreichbare Knoten “inner” und nicht mehr erreichbare Knoten “outer”, jeweils mit Angabe der Koordinaten:


start 6.9479894 50.9358304
inner 6.9510076 50.9330590
outer 6.9394997 50.9355044

Außerdem die erreichbaren Kanten “arc” und nur teilweise erreichbare Kanten “noarc” jeweils mit Anfangs- und Endkoordinaten:


arc 6.9479894 50.9358304 6.9470897 50.9358754
noarc 6.9510076 50.9330590 6.9525011 50.9332148

4. Wir machen das Ergebnis der Analyse sichtbar:

Dazu legen wir eine HTML-Datei “reachable.htm” (selbstverständlich auch überaus komplex!) an:


<html>
<head>
<title>Reachable</title>

<script type="text/javascript" src="http://www.openlayers.org/api/OpenLayers.js"></script>
<script type="text/javascript" src="http://www.openstreetmap.org/openlayers/OpenStreetMap.js"></script>
<script type="text/javascript">
var map;

window.onload = function () {

	map = new OpenLayers.Map ('map');

	map.displayProjection = new OpenLayers.Projection('EPSG:4326');
	map.addLayer (new OpenLayers.Layer.OSM.Mapnik('Mapnik'));

	var vectors;
	map.addLayer (vectors = new OpenLayers.Layer.Vector ('Reachability'));

	OpenLayers.Request.GET({

		async: false,
		url: 'reachable.txt',

		success: function(request) {

			var lines = (request.responseText||'').split('\n');
			for (var i in lines) {

				var f=lines[i].split('\t');

				switch (f[0]) {

				case 'arc':
					p0 = new OpenLayers.Geometry.Point (f[1], f[2]).
					transform(this.map.displayProjection, this.map.getProjectionObject());
					p1 = new OpenLayers.Geometry.Point (f[3], f[4]).
					transform(this.map.displayProjection, this.map.getProjectionObject());

					geometry = new OpenLayers.Geometry.LineString ([p0, p1]);

					style = {
						strokeColor:	'blue',
						strokeWidth:	4,
						strokeOpacity:	0.5
					}

					feature = new OpenLayers.Feature.Vector(geometry, null, style);

					vectors.addFeatures([feature]);
					break;

				case 'noarc':
					p0 = new OpenLayers.Geometry.Point (f[1], f[2]).
					transform(this.map.displayProjection, this.map.getProjectionObject());
					p1 = new OpenLayers.Geometry.Point (f[3], f[4]).
					transform(this.map.displayProjection, this.map.getProjectionObject());

					geometry = new OpenLayers.Geometry.LineString ([p0, p1]);

					style = {
						strokeColor:	'red',
						strokeWidth:	4,
						strokeOpacity:	0.5
					}

					feature = new OpenLayers.Feature.Vector(geometry, null, style);

					vectors.addFeatures([feature]);
					break;

				case 'start':
					point = new OpenLayers.Geometry.Point (f[1], f[2]).
					transform(this.map.displayProjection, this.map.getProjectionObject());

					style = {
						pointRadius:	5,
						strokeColor:	'black',
						strokeWidth:	1,
						strokeOpacity:	1,
						fillColor:	'yellow',
						fillOpacity:	0.8
					}

					feature = new OpenLayers.Feature.Vector(point, null, style);

					vectors.addFeatures([feature]);
					break;

				case 'inner':
					point = new OpenLayers.Geometry.Point (f[1], f[2]).
					transform(this.map.displayProjection, this.map.getProjectionObject());

					style = {
						pointRadius:	3,
						strokeColor:	'blue',
						strokeWidth:	1,
						strokeOpacity:	1,
						fillColor:	'blue',
						fillOpacity:	0.5
					}

					feature = new OpenLayers.Feature.Vector(point, null, style);
					vectors.addFeatures([feature]);
					break;

				case 'outer':
					point = new OpenLayers.Geometry.Point (f[1], f[2]).
					transform(this.map.displayProjection, this.map.getProjectionObject());

					style = {
						pointRadius:	3,
						strokeColor:	'red',
						strokeWidth:	1,
						strokeOpacity:	1,
						fillColor:	'red',
						fillOpacity:	0.5
					}

					feature = new OpenLayers.Feature.Vector(point, null, style);
					vectors.addFeatures([feature]);
					break;
				}
			}
		}
	});

	map.zoomToExtent (vectors.getDataExtent());
};
</script>
</head>

<body style="margin: 0">
<h1>Reachable</h1>
<div id="map" style="background: gray; width: 100%; height: 75%;"></div>
</body>
</html>

Wir legen HTML-Seite “reachable.htm” und Erreichbarkeits-Analyse “reachable.txt” in ein Verzeichnis und rufen die Webseite auf.

5. Wir erfreuen uns des Ergebnisses.

6. Nachbemerkung:

Diese Erreichbarkeitsanalyse wurde im Rahmen des Verzehrs eines Stückes Almkäse in Verbindung mit dem Genuss eines Glases Rotwein entwickelt. Der Source Code ist öffentlich zugänglich.

Plüschige Grüße
Der Assistent (orange)

Wie kommt Ihr eigentlich mit den Datenmengen zurecht? Wenn ich mir einen innerstädtischen 2km-Kreis mit allen Punkten ausgeben lasse, komme ich auf ein paar tausend Kreuzungen, so eine OSM-Straßenkreuzung mit je 2 Radwegen hat allein schon 9 Verbindungen. Sowas dauert bei mir 10 Sekunden zur Berechnung und die Darstellung könnte den einen oder anderen Browser leicht verletzen… Dynamisch will ich sowas gar nicht anbieten, das sorgt nur für Frust auf beiden Seiten :wink:

Grüße, Max

Hi,

Glückwunsch! Wo ist das Polygon, ach halt, das kommt bei deinem ach so einem Ansatz ja noch nicht heraus :wink:
Perfekt wenn du da auch noch ein so “hochkomplexes” Script für haettest … aber bitte nicht nur eine einfache
konvexe Hülle, bitte eine die auch das Straßennetz beachtet … :slight_smile: Es können ja auch Inseln z.B. duch das Autobahnetz
entstehen. Ich denke das ist für dich und dein Team ein klacks, vermutlich zwischen Kuchen und Kaffee zu erledigen.

Aber ansonsten schöne Sache, nette Kombination von mehreren Skripten!

viele gruesse
pascal

Tach.

Stand nicht im Pflichtenheft.

Pflichtenheft ist erfüllt.

Was genau eignet sich als “Anhaltspunkt” besser als zwei (sehr) kurze Skripte?

Orange Grüße
Der Assistent

% cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 13
model name : Intel(R) Pentium(R) M processor 1.73GHz
stepping : 8
cpu MHz : 1733.000
cache size : 2048 KB
[…]

% time ./reachable.pl 50.936 6.948 2000 graph >reachable.txt
reading graph …
lookup start node …
start node n382012853 @ lat 50.9358304 lon 6.9479894.

real 0m1.805s
user 0m1.716s
sys 0m0.016s

% wc -l reachable.txt
22467 reachable.txt

Dürfte den Browser crashen.

Man beachte aber, dass nichts am Ablauf optimiert ist. So wird ein Way mit n Knoten rücksichtslos in n-1 Abschnitte zerteilt und jeder Abschnitt als eine Kante im Graph genutzt. Real würde man nur an Abzeigungen schneiden. Und bei der Ausgabe aufeinanderfolgende Linien zusammenfassen. Compilierte Binaries statt eines Skriptes nutzen. Zur Skalierung die einzelnen Graphkanten in Kacheln wegspeichern; natürlich binär und nicht als Text. Und bei einer Anforderung nur die zur Beantwortung nötigen Kacheln laden.

Die Aufgabenstellung war aber: “Ich würde gerne selber so ein Tool bauen finde aber keine richtigen Anhaltspunkte dazu.”

Orange Grüße
Der Assistent

Hey Super das war genau das was ich gesucht habe…

Ich danke dir … daran werde ich mich jetzt versuchen … vielen Dank auch an dein ganzes Team …

Was ich erreiche werde ich zur Verfügung stellen. Mir schwebt da tatsächlich ein für jedermann erreichbarer Dienst vor.

Ich muss mich korrigieren :slight_smile: … Du gibst in der Analyse als Begrenzungs-kriterium eine “Distanz” an … ich hätte nur gerne alle erreichbaren Nodes innerhalb eines “X” Minuten Kriteriums.
Geht das mit deinem Script auch ?

Nahmd,

Der “Distanz”-Parameter für reachable.pl wird in “Zeiteinheiten” angegeben. Welche Zeiteinheit Du wählst, ist Dir überlassen.

Schau Dir “analyze.pl” ab Zeile 82 an: da wird eine Vorwärts- und eine Rückwärtsgeschwindigkeit berechnet.
Die hier gezeigte Version setzt allgemein beide auf 1, also 1m/Zeiteinheit, aber Fußgängerzonen auf 5m/Zeiteinheit. Die Werte sind grober Unfug, zeigen aber die Funktion: durch die hohe Geschwindigkeit erstreckt sich die erreichbare Region weit nach Osten und dann hoch zum Dom (durchgehend Fußgängerzone).

BTW. wird die Geschwindigkeit für Einbahnstraßen in falscher Richtung auf 0 gesetzt, das Skript versteht also das Konzept “Einbahnstraße”. Ist für Fußgänger zwar Unfug, zeigt aber, wie es geht. Du kannst an der Stelle auch highway=primary oder highway=secondary aussondern, um Fußgänger von der Nord-Süd-Fahrt fernzuhalten, oder auch Bus- und Bahnlinien mit reinnehmen mit höherer Geschwindigkeit, Du kannst Treppen mit sehr geringer Geschwindigkeit “bestrafen“, und und und…

Wenn Du reachable.pl mit Minuten füttern willst, gibst Du speedForward und speedBackward einfach in Metern pro Minute an. So einfach ist das. :slight_smile:

Orange Grüße
Der Assistent

Cool, danke ich versuche grade PERL ein wenig zu verstehen …

Bin in MSSQL uns .NET zuhause …

Um aber meine Aufgabe (Welche Nodes sind mit dem Auto in 50 min zu erreichen) zu lösen, muss ich die Parameter Speed4W, SpeedBW jeweils abhängig vom Strassen Typ auf die Durchschnittsgeschwindigkeit setzen … !? Sehe ich das richtig ?