Fragen zu einer Erreichbarkeitsanalyse mit OSM Daten

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 ?

Tach,

Das ist richtig.

Und sinnigerweise noch Fuß- und Fahradwege, Fußgängerzonen, Feldwege usw. auf 0 oder gleich verwerfen (next).
Dann auch “access=private” & Co beachten (aussonden). Und natürlich max_speed. Und max_speed:.
Alles nicht wirklich kompliziert, aber eine Menge (Fleiß-)Arbeit.

Kompliziert wird es dann bei den Abbiegebeschränkungen.

Orange Grüße
Der Assistent

Hallo,

ich wollte die Perl-Skripte eben benutzen um eine Erreichbarkeitsanalyse für meine Feuerwehr durchzuführen. Leider scheint das analyze.pl-Skript nicht richtig zu funktionieren. Ich benutze Ubuntu 15.10 dafür.
Für den graph bekomme ich noch eine richtig aussehende Datei. Wenn ich dann allerdings analyze.pl laufen lasse, steht in der reachable.txt nur


start		
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc				
arc
...

(und das über hunderttausende von Zeilen)

Geändert habe ich an den Dateien nichts.

Ich hatte ebenfalls bzw. zuerst die Anleitung von Netzwolfs Seite http://www.netzwolf.info/osm/routing/reachable verwendet, aber auch damit bekomme ich den gleichen Fehler.

Hat jemand einen Ansatzpunkt? Ich fand die Visualisierung der Straßen schön und ansehnlicher als ein Polygon über die Fläche des Stadtgebiets, in dem dann irgendwo nicht nachvollziehbare Löcher drin sind (wie es mir mit der Isochronen-Funktion des OpenRouteService passiert ist…).

Viele Grüße,
Christoph

Bei mir läufts nach der Anleitung auf der Homepage, auch mit Ubuntu 15.10. Was steht denn in der Ausgabe? Irgendwas mit

reading graph ...
lookup start node ...
start node n2041394 @ lat 48.1058734 lon 11.6360502.

Ich kann mir nämlich grad schwer vorstellen, dass dieses Programm schon keinen Startpunkt findet und bei dir steht hinter “start” schon nichts…

Grüße, Max

Hallo Max,

Startpunkt hatte er gefunden, allerdings war die Datei trotzdem leer.

Hab allerdings den Fehler gefunden; meine .osm-Datei hatte ich nicht über die Overpass-Api erzeugt sondern eine pbf-Datei der Geofabrik mittels osmosis in .osm umgewandelt. Anscheinend kam das Script damit nicht zurecht, nachdem ich meine Datei über die Overpass-Api erzeugt hatte funktioniert es auch. Danke!

Viele Grüße,

Christoph