Derzeit werden als "Demonstrationsexperiment zur Verbesserung des Straßenoberflächenmanagements" Daten gesammelt, die von kostengünstigen Sensoren erfasst werden, die an Fahrzeugen des öffentlichen Verkehrs wie Bussen und Taxis angebracht sind, und Big Data, das diese aggregiert, werden veröffentlicht.
** Straßenoberflächenmanagement Big Data Open Data-Wettbewerb ** http://micrms.force.com/apis
Dieses Mal haben wir es möglich gemacht, den Zustand der Straßenoberfläche auf der Karte anhand dieser Daten zu überprüfen.
** Zustand der Straßenoberfläche Viewer ** http://needtec.sakura.ne.jp/road_mgt/road_mgt.html
GitHub https://github.com/mima3/road_mgt
Die API-Spezifikationen können von den folgenden heruntergeladen werden. http://micrms.force.com/developer
Die Daten können grob in die folgenden drei unterteilt werden.
Normalerweise verwenden Sie Straßenoberflächenzustandsdaten und Straßenoberflächenspezifikationsdaten.
Um den Zustand der Straßenoberfläche zu erhalten, rufen Sie die folgende URL auf.
http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface
Das Ergebnis ist XML wie folgt:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
<rm:iri>2.65</rm:iri>
<rm:step>0.0</rm:step>
<rm:patching_num>0</rm:patching_num>
<rm:municipality_id>1</rm:municipality_id>
<rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
<rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
<rm:section_id>-1</rm:section_id>
<rm:speed>37.55711977</rm:speed>
<rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
<geo:alt>0.0</geo:alt>
<rm:rms>21.14314346</rm:rms>
<geo:long>140.1434769</geo:long>
<rm:rutting_amount>3.75</rm:rutting_amount>
<rm:pothole_num>0</rm:pothole_num>
<rm:speed_fluctuation_flag>0</rm:speed_fluctuation_flag>
<rdfs:label>road-surface_282</rdfs:label>
<rm:cracking_rate>5.3</rm:cracking_rate>
<geo:lat>35.61753776</geo:lat>
<rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
<rm:distance>220</rm:distance>
</rdf:Description>
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_294">
<rm:speed_fluctuation_flag>1</rm:speed_fluctuation_flag>
<rm:patching_num>0</rm:patching_num>
<rm:iri>2.5</rm:iri>
<rm:step>0.0</rm:step>
<rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
<rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
<rm:section_id>-1</rm:section_id>
<rm:municipality_id>1</rm:municipality_id>
<rm:distance>340</rm:distance>
<geo:alt>0.0</geo:alt>
<rm:cracking_rate>7.5</rm:cracking_rate>
<geo:long>140.1464737</geo:long>
<rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
<rm:rms>26.23188158</rm:rms>
<geo:lat>35.61759593</geo:lat>
<rm:pothole_num>0</rm:pothole_num>
<rm:speed>42.15859739</rm:speed>
<rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
<rm:rutting_amount>5.3</rm:rutting_amount>
<rdfs:label>road-surface_294</rdfs:label>
</rdf:Description>
Abkürzung
</rdf:RDF>
Die maximale Anzahl von Erfassungen beim Ausführen der API beträgt standardmäßig 300. Um nachfolgende Daten zu erhalten, müssen Sie den Offset wie unten gezeigt verwenden.
(1) Machen Sie zuerst den Anfang http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&limit=300&offset=0
(2) Wenn Sie die Daten normal abrufen können, ändern Sie den Offset und führen Sie ihn aus. http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&limit=300&offset=300
(3) Wiederholen Sie diesen Vorgang, bis die folgende Antwort erhalten wird.
404 notFound
Straßenoberflächenzustände können durch Angabe von Parametern gefiltert werden. Folgende Parameter können angegeben werden.
Name | Schimmel | Erläuterung |
---|---|---|
municipality | xsd:int | Gemeindeausweis Es scheint der Ausweis der lokalen Regierung zu sein, aber ich verstehe die Bedeutung nicht, weil es keine Erklärung wie ein natürliches Recht gibt. Enthält 1 und 11. Vielleicht ist 1 Chiba City und 11 Toyonaka City. |
section | xsd:int | Abschnitts-ID. Vielleicht erhält der Straßenabschnitt intern einen eindeutigen Ausweis, aber ich bin mir nicht sicher.-Es gibt 1 oder so. |
date_start | xsd:date | Analysedatum. Fehler, wenn nicht mit Endspezifikation festgelegt(YYYY-MM-DD) |
date_end | xsd:date | Analysedatum. Fehler, wenn nicht mit Startspezifikation festgelegt(YYYY-MM-DD) |
lat_start | xsd:double | Breitengrad beginnen. Fehler, wenn nicht mit Endspezifikation festgelegt |
lat_end | xsd:double | Breitengrad Ende. Fehler, wenn nicht mit Startspezifikation festgelegt |
lon_start | xsd:double | Längengrad starten. Fehler, wenn nicht mit Endspezifikation festgelegt |
lon_end | xsd:double | Ende der Länge. Fehler, wenn nicht mit Startspezifikation festgelegt |
Ausführungsbeispiel mit angegebenem Längen- und Breitengrad:
http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&lat_start=34.66802946&lon_start=135.362425&lat_end=35.67436512&lon_end=140.2823427&offset=300&limit=300
Hinweis Wenn Sie die hier eingeführten Parameter und andere Parameter als Offset und Limit angeben, tritt ein Fehler auf. Dies bedeutet, dass Code wie der folgende zu einem Fehler führt.
$.ajax({
type : 'GET',
url : 'http://roadmgt.herokuapp.com/api/v1/datapoints',
cache: false //Das Vermeiden des Caches führt zu einem Fehler.
data : {
data_type : 'road-surface',
lat_start : lat_start,
lon_start : lon_start,
lat_end : lat_end,
lon_end : lon_end,
offset : offset,
limit : limit
},
success : function (data) {
},
'error' : function(xhr, textStatus, error) {
}
});
Dies birgt das Risiko, dass sich der Inhalt auch dann nicht ändert, wenn die Daten im IE-System aktualisiert werden.
Im Fall von cahce = false wird durch Angabe eines eindeutigen temporären Werts für den Parameter eine andere Anforderung erkannt und die Verwendung des Cache vermieden, dies ist jedoch nicht verfügbar.
http://stackoverflow.com/questions/4303829/how-to-prevent-a-jquery-ajax-request-from-caching-in-internet-explorer
Sie können das Ziel direkt abrufen, indem Sie den in rdf: about beschriebenen URI angeben.
Ausführungsbeispiel: http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282
Akquisitionsergebnis:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
<rm:iri>2.65</rm:iri>
<rm:step>0.0</rm:step>
<rm:patching_num>0</rm:patching_num>
<rm:municipality_id>1</rm:municipality_id>
<rm:too_slow_fast_flag>0</rm:too_slow_fast_flag>
<rm:subsidence_and_puddle>0.0</rm:subsidence_and_puddle>
<rm:section_id>-1</rm:section_id>
<rm:speed>37.55711977</rm:speed>
<rdf:type>http://roadmgt.herokuapp.com/vocab/rm#road-surface</rdf:type>
<geo:alt>0.0</geo:alt>
<rm:rms>21.14314346</rm:rms>
<geo:long>140.1434769</geo:long>
<rm:rutting_amount>3.75</rm:rutting_amount>
<rm:pothole_num>0</rm:pothole_num>
<rm:speed_fluctuation_flag>0</rm:speed_fluctuation_flag>
<rdfs:label>road-surface_282</rdfs:label>
<rm:cracking_rate>5.3</rm:cracking_rate>
<geo:lat>35.61753776</geo:lat>
<rm:analysis_timestamp>2014-12-30 17:00:02.0</rm:analysis_timestamp>
<rm:distance>220</rm:distance>
</rdf:Description>
</rdf:RDF>
Wenn Sie den Eigenschaftsnamen nach dem Zielnamen angeben, können Sie nur die Eigenschaft abrufen. Zu diesem Zeitpunkt muss ":" in "_" geändert werden. Wenn Sie beispielsweise "rm: step" erhalten möchten, geben Sie "rm_step" an.
Ausführungsbeispiel: http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282/rm_step
Akquisitionsergebnis
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" xmlns:rm="http://roadmgt.herokuapp.com/vocab/rm#">
<rdf:Description rdf:about="http://roadmgt.herokuapp.com/api/v1/datapoints/road-surface_282">
<rm:step>0.0</rm:step>
</rdf:Description>
</rdf:RDF>
Die Haupteigenschaften werden unten erläutert.
Eigentum | Name | Schimmel | Erläuterung |
---|---|---|---|
rm:analysis_timestamp | Datum und Uhrzeit der Analyse | xsd:dateTime | 「2015-01-14 09:01:Es hat das Format "57". |
rm:iri | IRI | xsd:double | Internationaler Rauheitsindex Objektiv Ebenheit (Fahrkomfort) der Fahrbahn.Zu bewertende Skala http://www.kandoken.jp/huroku/130913_2_kouenshiryo.pdf |
rm:pothole_num | Anzahl der Schlaglöcher | xsd:int | Anzahl der Löcher, die durch die Vertiefung der Fahrbahnoberfläche entstehen |
rm:patching_num | Anzahl der Patches | xsd:int | Anzahl der Erste-Hilfe-Maßnahmen gegen Fahrbahnschäden http://www.mlit.go.jp/road/ir/ir-council/pdf/roadstock05.pdf |
rm:cracking_rate | Rissrate | xsd:double | http://www.town.oki.fukuoka.jp/file/gyousei/nyuusatsu/FILE_346_45.pdf |
rm:rutting_amount | Brunfttiefe | xsd:double | http://www.fuzita.org/cod/rut_.html |
rm:step | Schritt | xsd:double | |
rm:subsidence_and_puddle | Sinken / Pfütze | xsd:double | |
geo:lat | Breite | xsd:double | |
geo:long | Längengrad | xsd:double | |
geo:alt | Höhe | xsd:double |
Dies entspricht im Wesentlichen dem Zustand der Straßenoberfläche. Gehen Sie zur folgenden URL.
http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-master&lat_start=34.66802946&lon_start=135.362425&lat_end=35.67436512&lon_end=140.2823427&offset=300&limit=300
Derzeit sind nur die folgenden roten Liniendaten vorhanden.
Wie Sie durch Erweitern sehen können, scheinen Daten für jede Spur vorhanden zu sein.
Python Hier beschreiben wir, wie Sie den Straßenoberflächenzustand in Python ermitteln.
road_mgt.py
# -*- coding: utf-8 -*-
import urllib
import urllib2
from lxml import etree
import csv
from collections import defaultdict
def get_road_surface(offset, limit):
"""
Daten zum Zustand der Straßenoberfläche
"""
url = ('http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=road-surface&offset=%d&limit=%d' % (offset, limit))
req = urllib2.Request(url)
opener = urllib2.build_opener()
conn = opener.open(req)
cont = conn.read()
parser = etree.XMLParser(recover=True)
root = etree.fromstring(cont, parser)
namespaces = {
'geo' : 'http://www.w3.org/2003/01/geo/wgs84_pos#',
'rdf' : 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
'rdfs' : 'http://www.w3.org/2000/01/rdf-schema#',
'rm' : 'http://roadmgt.herokuapp.com/vocab/rm#'
}
row = []
datas = {}
value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
for value_tag in value_tags:
label = value_tag.find('rdfs:label', namespaces).text
step = value_tag.find('rm:step', namespaces).text
alt = value_tag.find('geo:alt', namespaces).text
analysis_timestamp = value_tag.find('rm:analysis_timestamp', namespaces).text
rutting_amount = value_tag.find('rm:rutting_amount', namespaces).text
municipality_id = value_tag.find('rm:municipality_id', namespaces).text
speed_fluctuation_flag = value_tag.find('rm:speed_fluctuation_flag', namespaces).text
section_id = value_tag.find('rm:section_id', namespaces).text
distance = value_tag.find('rm:distance', namespaces).text
long = value_tag.find('geo:long', namespaces).text
iri = value_tag.find('rm:iri', namespaces).text
cracking_rate = value_tag.find('rm:cracking_rate', namespaces).text
pothole_num = value_tag.find('rm:pothole_num', namespaces).text
subsidence_and_puddle = value_tag.find('rm:subsidence_and_puddle', namespaces).text
speed = value_tag.find('rm:speed', namespaces).text
rms = value_tag.find('rm:rms', namespaces).text
lat = value_tag.find('geo:lat', namespaces).text
too_slow_fast_flag = value_tag.find('rm:too_slow_fast_flag', namespaces).text
patching_num = value_tag.find('rm:patching_num', namespaces).text
row.append({
'label' : label,
'step' : step,
'alt' : alt,
'analysis_timestamp' : analysis_timestamp,
'rutting_amount' : rutting_amount,
'municipality_id' : municipality_id,
'speed_fluctuation_flag' : speed_fluctuation_flag,
'section_id' : section_id,
'distance' : distance,
'long' : long,
'iri' : iri,
'cracking_rate' : cracking_rate,
'pothole_num' : pothole_num,
'subsidence_and_puddle' : subsidence_and_puddle,
'speed' : speed,
'rms' : rms,
'lat' : lat,
'too_slow_fast_flag' : too_slow_fast_flag,
'patching_num' :patching_num
})
return row
def get_meas_locale(offset, limit):
"""
Positionsdaten zum Zeitpunkt der Straßenoberflächenmessung
"""
url = ('http://roadmgt.herokuapp.com/api/v1/datapoints?data_type=meas-locale&offset=%d&limit=%d' % (offset, limit))
req = urllib2.Request(url)
opener = urllib2.build_opener()
conn = opener.open(req)
cont = conn.read()
parser = etree.XMLParser(recover=True)
root = etree.fromstring(cont, parser)
namespaces = {
'geo' : 'http://www.w3.org/2003/01/geo/wgs84_pos#',
'rdf' : 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
'rdfs' : 'http://www.w3.org/2000/01/rdf-schema#',
'rm' : 'http://roadmgt.herokuapp.com/vocab/rm#'
}
row = []
datas = {}
value_tags = root.xpath('//rdf:Description', namespaces=namespaces)
for value_tag in value_tags:
label = value_tag.find('rdfs:label', namespaces).text
gpstimestamp = value_tag.find('rm:gpstimestamp', namespaces).text
course = value_tag.find('rm:course', namespaces).text
measurement_start_timestamp = value_tag.find('rm:measurement_start_timestamp', namespaces).text
mounting_direction = value_tag.find('rm:mounting_direction', namespaces).text
car_model = value_tag.find('rm:car_model', namespaces).text
long = value_tag.find('geo:long', namespaces).text
lat = value_tag.find('geo:lat', namespaces).text
alt = value_tag.find('geo:alt', namespaces).text
model_number = value_tag.find('rm:model_number', namespaces).text
car_number = value_tag.find('rm:car_number', namespaces).text
speed = value_tag.find('rm:speed', namespaces).text
vertical_accuracy = value_tag.find('rm:vertical_accuracy', namespaces).text
measurement_timestamp = value_tag.find('rm:measurement_timestamp', namespaces).text
horizontal_accuracy = value_tag.find('rm:horizontal_accuracy', namespaces).text
row.append({
'label' : label,
'gpstimestamp' : gpstimestamp,
'course' : course,
'measurement_start_timestamp' : measurement_start_timestamp,
'mounting_direction' : mounting_direction,
'car_model' : car_model,
'long' : long,
'lat' : lat,
'alt' : alt,
'model_number' : model_number,
'car_number' : car_number,
'speed' : speed,
'vertical_accuracy' : vertical_accuracy,
'measurement_timestamp' : measurement_timestamp,
'horizontal_accuracy' : horizontal_accuracy
})
return row
def get_road_surface_all():
ret = []
limit = 300
offset = 0
try:
while True:
print ('get_road_surface_all %d' % offset)
r = get_road_surface(offset, limit)
ret.extend(r)
offset += limit
except urllib2.HTTPError, ex:
if ex.code == 404:
return ret
else:
raise
Mit get_road_surface_all () können Sie alle Straßenoberflächenbedingungen abrufen. Als Programm führe ich einfach die API mit urllib aus und analysiere die Antwort mit lxml.
JavaScript Hier beschreiben wir, wie Sie mit JavaScript den Zustand der Straßenoberfläche ermitteln.
/**
*Führen Sie die Straßenoberflächeninformations-API aus
*/
function getDataByRange(data_type, lat_start, lon_start, lat_end, lon_end, callback) {
var offset = 0;
var limit = 300;
var obj = {};
function loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset, limit, obj, cb) {
console.log(offset, limit);
$.ajax({
type : 'GET',
url : 'http://roadmgt.herokuapp.com/api/v1/datapoints',
cache: true , //,Ein Fehler tritt auf, wenn der Cache auf false gesetzt ist. Anstatt seltsame Parameter zu ignorieren, drehen sie sich vielleicht um
data : {
data_type : data_type,
lat_start : lat_start,
lon_start : lon_start,
lat_end : lat_end,
lon_end : lon_end,
offset : offset,
limit : limit
},
success : function (data) {
console.log(data);
var root = data.documentElement;
var attrs = root.attributes;
var records = root.childNodes;
for(var i=0; i<records.length; i++){
if(records[i].nodeName.match(/rdf:Description/i)){
var s = records[i].attributes["rdf:about"].value;
var props = records[i].childNodes;
for(var j=0; j<props.length; j++){
if(props[j].nodeType == 1){
var p = props[j].nodeName;
var o = props[j].textContent;
if (!obj[s]) {
obj[s] = {};
}
if (obj[s][p]) {
if (!Array.isArray(obj[s][p])) {
var tmp = arys[s][p];
obj[s][p] = [];
obj[s][p].push(tmp);
}
obj[s][p].push(o);
} else {
obj[s][p] = o;
}
}
}
}
}
loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset + limit, limit, obj, cb);
},
'error' : function(xhr, textStatus, error) {
console.log(xhr);
var err = xhr.responseText;
if (err == '404 notFound') {
cb(null , obj);
} else {
cb(err , null);
}
}
});
}
loadRoadOffset(lat_start, lon_start, lat_end, lon_end, offset, limit, obj, function(err, res) {
callback(err, res);
});
}
Führen Sie diese Funktion wie folgt aus:
getDataByRange('road-master', surfaceRange.lat_min, surfaceRange.long_min, surfaceRange.lat_max, surfaceRange.long_max, function(err, data) {
console.log('loadRoad', err, data);
});
Dieser Prozess erhält alle Straßenspezifikationsdaten im angegebenen Bereich.
Sie können den Zustand der Straßenoberfläche ermitteln, indem Sie die API "Demonstrationsexperiment im erweiterten Straßenoberflächenmanagement" ausführen.
Dies ermöglicht es, den Verschlechterungsstatus von Straßen zu visualisieren.
Recommended Posts