Archiv des Autors: Thomas

Erstellen von Wachstumskurven mit Gnuplot

Posted on by
Kommentar

Hinweise auf den Gesundheits- und Ernährungszustand von Kindern- und Jugendlichen können sich durch die Messung anthropometrischer Merkmale und deren Einordnung in Perzentilkurven, die die Verteilung der Körpermaße in einer Referenzpopulation wiederspiegeln, ergeben. Eine aktuelle Studie zur Gesundheit von Kindern und Jugendlichen[ 1] liefert solche Perzentilkurven ausgewählter Körpermaße von Kindern und Jugendlichen im Alter von 3 Monaten bis 17 Jahren.
Als individuelle Datenquelle können die Ergebnisse der kinderärztlichen Untersuchungen, die im Mutterpass dokumentiert sind, herangezogen werden. Es gibt insgesamt 9 Vorsorgeuntersuchungen, angefangen von der U1 direkt am Tag der Geburt, bis hin zur U9 im 5 Lebensjahr, bzw. bis zu 4 Monaten später. Bei allen Vorsorgeuntersuchungen wird in der Regel auch das Gewicht und die Körpergröße erfasst. Darüber hinaus sollte man diese Körpermaße in regelmäßigen Abständen auch selbst erfassen. Oft erinnern die Kinder selbst an die Messungen, da sie ab einem gewissen Lebensalter an ihrem eigenen Wachstum Interesse zeigen. Für die Darstellung der gemessenen Daten soll die skriptgesteuerte Plottersoftware Gnuplot, die unter freier Lizenz für alle gängigen Betriebssysteme verfügbar ist, verwendet werden. Die Aufbereitung der Daten für Gnuplot ist denkbar einfach: In einer Textdatei werden spaltenweise Messzeitpunkt, Körpergröße in cm und Körpergewicht in Gramm, jeweils durch Leerzeichen oder Tabulator getrennt erfasst. In Zeile 4 des folgenden kleinen Gnuplot-Skripts wird dem Programm mitgeteilt, dass es sich bei den Daten für die x-Achse um Datumsangaben handelt, die folgende Zeile beschreibt das Format, in dem das Datum vorliegt. Das Höchstalter des zu untersuchenden Kindes muß gegebenfalls in Zeile 15 als oberer Grenzwert des Darstellungsbereichs angepasst werden. Dabei zählt nur die Dekade des Jahrtausends als Kindesalter (Gnuplot repräsentiert Zeitangaben intern als Sekunden seit dem 01.01.2000). Mein Skript geht von den Daten zweier Kinder aus, die in den Dateien "bruno.dat" und "felix.dat" gespeichert sind. In diesen Dateien ist der Zeitpunkt der Messung natürlich durch das reale Datum vermerkt. Da die Daten aber über das Alter des Kindes abgetragen werden sollen, muss in Zeile 45 und 46 das Datum der Messung entsprechend verschoben werden, so dass die Geburt mit dem Datum 01.01.2000 zusammenfällt. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#!/usr/bin/gnuplot 
#
set encoding utf8
set xdata time
set timefmt "%d.%m.%Y"
set xtics rotate by -45
set format x "%b/%y"
 
set termoption dash
set size ratio 0.7 1.0, 1.0; set origin 0.0, 0.0
set ylabel "Körpergröße [cm]"
set xlabel "Alter [Jahre]" offset screen 0,-0.02
#####################################
# Als Endpunkt das Höchstalter eintragen:
set xrange ['01.01.2000':'01.01.2009']
set ytics mirror
unset y2label
unset y2range
unset y2tics
set format x "%y"
set mxtics 12
set key left
set key screen 0.1,0.9
 
set style line 1 lt 1 lc rgb "red" lw 3
set style line 2 lt 1 lc rgb "grey" lw 1
set style line 3 lt 1 lc rgb "black" lw 1
set style line 4 lt 1 lc rgb "green" lw 1
 
#####################################################
# Darstellung der Körperlänge über dem Kindesalter
#
# Sekunden/Tag = 86400
# Differenz der Geburtsdatumsangaben in Tagen = 962
# Differenz zwischen Brunos Geburtstag und 1.1.2000 in Tagen = 1660
# Verschiebe die Zeitangaben, so dass sie am 1.1.2000 starten.
 
plot "KiGGS-Referenzperzentile-Länge.dat" using 1:5 title "Perzentile P50 (KiGGS 2003-06)" ls 1 smooth csplines, \
     "" using 1:6 title "Perzentile P75" ls 2 smooth csplines, \
     "" using 1:4 t "Perzentile P25" ls 2 smooth csplines, \
     "" using 1:7 title "Perzentile P90" ls 3 smooth csplines, \
     "" using 1:3 t "Perzentile P10" ls 3 smooth csplines, \
     "" using 1:8 title "Perzentile P97" ls 4 smooth csplines, \
     "" using 1:2 t "Perzentile P3" ls 4 smooth csplines, \
     "bruno.dat" using (timecolumn(1)-1660*86400):2 title "Bruno Körpergröße" with linespoints  4, \
     "felix.dat" using (timecolumn(1)-(963+1660)*86400):2 title "Felix Körpergröße" with linespoints 5
 
set term svg fsize 8
set output "kurven-l.svg"
replot
 
pause -1

45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

set ylabel "BMI [kg/m²]"
 
plot "KiGGS-Referenzperzentile-BMI.dat" using 1:5 title "Perzentile P50 (KiGGS 2003-06)" ls 1 smooth csplines, \
     "" using 1:6 title "Perzentile P75" ls 2 smooth csplines, \
     "" using 1:4 t "Perzentile P25" ls 2 smooth csplines, \
     "" using 1:7 title "Perzentile P90" ls 3 smooth csplines, \
     "" using 1:3 t "Perzentile P10" ls 3 smooth csplines, \
     "" using 1:8 title "Perzentile P97" ls 4 smooth csplines, \
     "" using 1:2 t "Perzentile P3" ls 4 smooth csplines, \
     "bruno.dat" using (timecolumn(1)-1660*86400):($3/1000.0)/($2/100.0)**2 title "Bruno BMI" with linespoints  4, \
     "felix.dat" using (timecolumn(1)-(963+1660)*86400):($3/1000.0)/($2/100.0)**2 title "Felix BMI" with linespoints 5
 
set term svg fsize 8
set output "kurven-bmi.svg"
replot
 
pause -1

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

set ylabel "Gewicht [kg]"
 
plot "KiGGS-Referenzperzentile-Gewicht.dat" using 1:5 title "Perzentile P50 (KiGGS 2003-06)" ls 1 smooth csplines, \
     "" using 1:6 title "Perzentile P75" ls 2 smooth csplines, \
     "" using 1:4 t "Perzentile P25" ls 2 smooth csplines, \
     "" using 1:7 title "Perzentile P90" ls 3 smooth csplines, \
     "" using 1:3 t "Perzentile P10" ls 3 smooth csplines, \
     "" using 1:8 title "Perzentile P97" ls 4 smooth csplines, \
     "" using 1:2 t "Perzentile P3" ls 4 smooth csplines, \
     "bruno.dat" using (timecolumn(1)-1660*86400):($3/1000.0) title "Bruno Gewicht" with linespoints  4, \
     "felix.dat" using (timecolumn(1)-(963+1660)*86400):($3/1000.0) title "Felix Gewicht" with linespoints 5
 
set term svg fsize 8
set output "kurven.svg"
replot
 
pause -1

Die Dateien KiGGS-Referenzperzentile-Länge.dat, KiGGS-Referenzperzentile-Gewicht.dat und KiGGS-Referenzperzentile-BMI.dat mit der Angabe der Referenzperzentilen zu Größe, Gewicht und BMI, auf Grundlage der oben erwähnten Studie, stehen zum Download bereit.

Notes:

  1. Robert Koch-Institut (2011): Referenzperzentile für anthropometrische Maßzahlen und Blutdruck aus der Studie zur Gesundheit von Kindern und Jugendlichen in Deutschland (KiGGS). Beiträge zur Gesundheitsberichterstattung des Bundes. RKI, Berlin ↩

Bilder für eine Veröffentlichung vorbereiten

Posted on by
Kommentar

Um Speicherplatz zu sparen, der beim Hoster oftmals kontingiert ist, sollten die Bilder vor einem Upload gut komprimiert werden. Dies kann mit einem Dienst wie bspw. jpegmini geschehen, der oft wesentlich bessere Kompressionsergebnisse erzielt, als herkömmliche Bildbearbeitungssoftware. Die Größe der mit Digitalkameras erzeugten Bilder ist für die Betrachtung am Bildschirm oftmals ungeeignet, man sollte die Bilder also auf ein geeignetes Maß verkleinern. Unter Linux bietet sich dazu die ImageMagick-Suite an. Sie stellt umfangreiche Werkzeugen zur Bildbearbeitung auf der Kommandozeilen-Ebene bereit. Die Schritte verkleinern und einen Text einfügen kann man mit der Shell und dem Werkzeug convert in wenigen Zeilen erledigen:

for f in *.jpg;
> do
> a=`basename $f .jpg`;
> convert $f -resize 25% -font Courier \
> -pointsize 25 -fill white \
> -undercolor '#00000080' -gravity SouthWest \
> -annotate -0+5 ' © Ilses Erika ' $a'_tn.jpg'
> done

Für Galeriebilder sollte man statt des Prozent-Operators besser den

@-Operator verwenden. Durch Angabe von -resize @Pixelanzahl haben alle Bilder die gleiche Pixelanzahl, was einen ruhigeren Bildlauf durch eine Galerie ermöglicht. Evtl. sollten vor dem Hochladen der Bilder noch die Meta-Informationen aus dem Bild entfernt werden. Dies kann mit dem Tool exiv2 geschehen:

exiv2 -d datei.jpg

Natürlich lassen sich mit

exiv2 aber auch Meta-Informationen setzen, z.B. die Autorenschaft eines Bildes (exiv2 -M"set Exif.Image.Copyright Ilses Erika" datei.jpg) oder ein Bildkommentar.

Tunnelblick

Posted on by
Kommentar

Einrichtung eines ssh-Tunnels durch das Internet zwischen einem Android-Smartphone und einem Linux-Host.

Firewall-Mechanismen

Nutzt man unterwegs mit seinem Smartphone einen öffentlichen Hotspot, so besteht die Gefahr, dass der Datenverkehr durch den Betreiber ausgewertet, also auch evtl. unverschlüsselt gesendete Daten mitgelesen und missbraucht werden. Nun besteht prinzipiell die Möglichkeit, auf dem heimischen PC, der über einen Breitbandanschluß mit dem Internet verbunden ist, einen sshd zu installieren und den Datenverkehr des Smartphones über einen ssh-Tunnel zum heimischen PC zu leiten.
Oft schützen die Provider der Breitbandanschlüsse ihre Kunden jedoch durch eine Firewall vor unerwünschten Zugriffen aus dem Internet. Während man auf die Firewall des heimischen Routers normalerweise vollen administrativen Zugriff hat, ist dies naturgemäß bei der Firewall des Providers nicht der Fall. Dies bedeutet, dass die vom heimischen PC angebotenen Server-Dienste nicht aus dem Internet erreichbar sind (es sei denn, das die providerseitige Firewall die Ports dafür standardmäßig offen hält, was selten der Fall ist). Nun muß prinzipiell jede Firewall auch Pakete von außen hereinlassen und zwar die Antwortpakete zu Anfragen an Web- und Mailserver etc. die der Nutzer durch Browser oder Email-Clients an die Server im Internet richtet. Damit die Firewall entscheiden kann, ob ein Paket von außerhalb die Antwort auf ein ausgehendes Paket ist, wird im Router Buch darüber geführt, welcher interne Rechner mit welchem Rechner außerhalb kommuniziert und welche Ports dabei angesprochen wurden.

Die Rolle von Vermittlungsservern

Um nun eine Client-Server-Kommunikation durch eine restriktive Firewall hindurch zu ermöglichen, bedient man sich eines Vermittlungsservers: Beide Kommunikationspartner, also Server und Client nehmen periodisch Kontakt mit dem Vermittlungsserver auf. Somit kennt dieser die IP-Adressen der Teilnehmer und die Ports auf denen sie zu kommunizieren wünschen. Will ein Teilnehmer nun die Verbindung aufnehmen, meldet er diesen Wunsch beim Vermittlungsserver an, erhält von ihm die IP-Adresse und den Port der Gegenstelle und kann nun seine Anfrage losschicken. Diese wird zwar von der Firewall der Gegenstelle verworfen, aber der Router von dem die Anfrage stammt wartet dennoch auf die Antwort. Der Vermittlungsserver teilt nun der Gegenstelle die Daten der Anfrage mit und läßt sie antworten. Das Antwortpaket passiert nun die auf Antwort wartende Firewall und nun können beide Kommunikationspartner ohne den Vermittlungsserver weiter Daten austauschen. Dieses Verfahren ist auch unter dem Begriff Hole Punching bekannt. Eine grobe Simulation dieser Arbeitsweise mit einfachen Netzwerktools zeigt ein Artikel in der c’t und erläutert diese Problematik ausführlicher.

NeoRouter Mesh und Co.

Ein prominentes Beispiel eines solchen Vermittlungsservers ist Skype. Es gibt jedoch auch Anbieter, die Vermittlungsdienste für allgemeinere Aufgaben bereitstellen. Einer von ihnen ist die Firma NeoRouter Inc.. Der Einsatz ihres Dienstes NeoRouter Mesh zum Aufbau eines ssh-Tunnels zwischen Smartphone und einem hinter einer Firewall verborgenen Linux-Hosts, der einen Proxy für den Internetzugriff bereitstellt, soll hier demonstriert werden. Die folgende Vorgehensweise benötigt keine Root-Rechte auf dem Smartphone, dieses muß also nicht gerootet werden.

Schritt für Schritt

Auf der Herstellerseite der Firma NeoRouter Inc. kann man die notwendige Mesh Domain und den Account beantragen. Anschließend kann die Software für die verschiedenen Endgeräte auf der Download-Seite heruntergeladen und installiert werden.
Auf dem Linux-Host, der als Server dienen soll, wird nach der Installation nrserver gestartet. Anschließend kann die App NeoRouter Mesh auf dem Android-Smartphone aufgerufen werden.

Konfiguration der App NeoRouter Mesh

Konfiguration der App NeoRouter Mesh


Nach der Authentifizierung sollte die App den Linux-Host nun unter My Computers auflisten. Tippt man länger auf den Host, zu dem der Tunnel aufgebaut werden soll, öffnet sich ein Auswahlfenster und man kann nun den Dienst ssh 22 auswählen. Durch diese Auswahl richtet die App eine Port-Weiterleitung vom Port 32973 des lokalen Hosts (also des Smartphones) zum Port 22 des entfernten ausgewählten Linux-Host ein (bzw. teilt sie diesen Wunsch dem Vermittlungsserver mit).

ConnectBot: ein ssh-client für Android

Nun kann die ssh-App ConnectBot gestartet werden. Aus einer Dropdown-Liste kann man die Dienste ssh, telnet und local auswählen.

Konfiguration der App ConnectBot

Konfiguration der App ConnectBot

Wir wählen ssh (local gestattet die Einrichtung eines ssh-Zugangs zum Smartphone) und geben im Eingabefenster siegel@localhost:32973 als Ziel ein. Wir erinnern uns, daß durch NeoRouter Mesh eine Weiterleitung vom lokalen Port 32973 zum Port 22 des Linux-Hosts eingerichtet wurde. Nachdem man auf dem Linux-Host angemeldet wurde, kann man in der Werkzeugleiste (ganz unten rechts) den Punkt Port-Weiterleitung aufrufen.

Einrichten einer Port-Weiterleitung mit ConnectBot

Einrichten einer Port-Weiterleitung mit ConnectBot

Hier kann man unter Vergabe eines Spitznamen eine Weiterleitung vom Typ Lokal mit dem Quellport: 8080 zum Ziel localhost:3128 einrichten. Der Port 3128 ist der Standard-Port des Proxy-Programms squid, welches auf dem Linux-Host installiert und konfiguriert werden mußte. Bei der Auswahl des Quellports ist zu bedenken, dass unter Unix-artigen Betriebssystemen (also auch unter Android) nur root Dienste betreiben darf, die Portnummern kleiner 1024 benötigen (sogenannte Systemports).

Der Proxy-Server squid

Wie bereits erwähnt, muß auf dem Linux-Host ein Proxy-Server eingerichtet werden. Nach dessen Installation sind in der Datei /etc/squid/squid.conf noch einige Kleinigkeiten einzutragen. So muß dem Proxy noch ein Name über das Schlüsselwort visible_hostname zugewiesen werden, dieser kann beliebig gewählt werden. Außerdem muß das Disk Cache Directory durch das Schlüsselwort cache_dir bezeichnet werden und es sollte die Zeile http_access deny to_localhost in der Config-Datei vorhanden sein. Im übrigen ist die Datei squid.conf sehr gut kommentiert und man muss eigentlich nur den dort gemachten Empfehlungen folgen. Vor dem ersten Start von squid ist die Cache-Verzeichnisstruktur durch den Aufruf von squid -z anzulegen. Nun kann man mit squid -NCd1 den Dämon probeweise starten, ohne ihn in den Hintergrund zu schicken. So kann man evtl. Fehlermeldungen besser beobachten. Später kann man den Dämon dann durch /etc/init.d/squid start aktivieren. Für weitere Konfigurations-Details sei auf den Eintrag bei selflinux.org und das HOWTO der Seite www.linuxhomenetworking.com verwiesen.

Eintrag des Proxy-Servers im Browser

Um nun durch den eingerichteten Tunnel über den Linux-Host surfen zu können, muß in Opera (Chrome für Android unterstützte zum Verfassungszeitpunkt des Artikels die Angabe eines Proxy-Servers noch nicht) auf dem Smartphone die Adresse des Proxy-Servers angegeben werden. Dies kann durch Aufruf von opera:config geschehen.

Mit Opera die Benutzung eines Proxy-Servers einrichten

Mit Opera die Benutzung eines Proxy-Servers einrichten

Als HTTP-Server muß dann 127.0.0.2:8080 eingetragen werden, denn der lokale Port 8080 wird ja durch die mit ConnectBot eingerichtete Port-Weiterleitung an den Proxy-Port 3128 des fernen Linux-Host weitergereicht. Nach dem Speichern dieser Angaben und einem Neustart von Opera, wird nun jede Anfrage von Opera durch den Tunnel an den Proxy weitergeleitet.

Hat man bspw. bei dem Dienst no-ip für seine eigene, vom Provider dynamisch zugeteilte IP-Adresse einen Domainnamen eingerichtet, so lassen sich unter diesem Domainnamen nun auch Seiten aus dem Internet aufrufen. Da sich hinter der vom Provider vergebenen IP-Adresse normalerweise der heimische Router verbirgt, man aber mit dem Domainnamen eigentlich einen Rechner hinter dem eigenen Router (also im eigenen lokalen Netz) erreichen möchte, ist im Router eine entsprechende Port-Weiterleitung (oft unter dem Menü-Punkt Virtueller Server erreichbar) zu dem gewünschten Rechner und Port zu konfigurieren. Handelt es sich zum Beispiel um eine Webcam und ist für diese im eigenen Router eine entsprechende Port-Weiterleitung konfiguriert, so könnte eine Abfrage des gerade sichtbaren Bildes z.B. durch http://dcs-900.no-ip.org:8080/IMAGE.JPG erfolgen, wenn der bei no-ip registrierte Domainname dcs-900.ni-ip.org lautet und in der Webcam der Port 8080 als Dienstport konfiguriert wurde.

Screenshots auf dem Samsung Galaxy Nexus

Posted on by
Kommentar

Das Android-Handy Samsung Galaxy Nexus bietet eine einfache Möglichkeit zur Anfertigung von Screenshots an: Gleichzeitiges Drücken der Lautstärke-Leiser-Taste und der Power-Taste bis eine verkleinerte Darstellung des Screenshots erscheint. Der Screenshot wird unter /sdcard/Pictures/Screenshots/ im png-Format abgelegt.

Konfiguration zertifikatbasierter SSH-Zugänge

Posted on by
Kommentar

SSH bietet die Möglichkeit der Zugangs-Authentifizierung mittels öffentlicher Schlüssel (Public Key Authentication). Bei der konventionellen Zugangskontrolle durch Username und Passwort liegt die Schwachstelle beim Passwort, läßt es sich erraten, so ist der Zugang hergestellt.
Bei der zertifikatbasierten Zugangskontrolle wird durch das Dienstprogramm ssh-keygen ein Schlüsselpaar, bestehend aus einem öffentlichen und einem privaten Schlüssel, erzeugt. Anschließend verbleibt der private Schlüssel auf dem Client, während der öffentliche Schlüssel auf den Server übertragen wird. Schlüssel lassen sich prinzipiell schwieriger kompromittieren als Kennwörter. Ein weitere Vorteil dieser Methode ist, daß sie (entsprechende Konfiguration vorausgesetzt) den Zugang ohne Benutzerinteraktion herstellen kann, zusätzlich läßt sie sich als einzig legitime Art der Anmeldung (Authentifizierung) festlegen. Der private Schlüssel wird üblicherweise nochmals mit einer Passphrase gesichert (von Passphrase spricht man, da sie aus mehreren Worten bestehen kann). Diese wird dann beim Zugang abgefordert. Um die Angabe der Passphrase nicht bei jedem Zugang vornehmen zu müssen, läuft normalerweise ein ssh-agent, der die Angabe der Passphrase stellvertretend übernimmt.
Die Anmeldung erfolgt nun sinngemäß etwa folgendermaßen: Auf dem Client wird mittels des hier vorhandenen privaten Schlüssels eine Signatur erzeugt, diese wiederum kann der Server mit dem bei ihm hinterlegten öffentlichen Schlüssel des Client prüfen.

Praxis:

Erzeugen des privaten und öffentlichen Schlüssels (der Option -t wird der Typ des Schlüssels übergeben, die möglichen Werte nennt die Manualseite):
# ssh-keygen -t rsa

Es entstehen Dateien mit den Schlüsselpaaren:
~/.ssh/id_rsa und ~/.ssh/id_rsa.pub.

Die *.pub-Dateien können nun auf den Server kopiert werden und dort an ~/.ssh/authorized_keys angehängt werden, diesen Schritt übernimmt das Dienstprogramm ssh-copy-id:

# ssh-copy-id -i ~/.ssh/id_rsa.pub user@server

Schlangengrube: Python-Skripte auf dem Android-Smartphone

Posted on by
Kommentar

Wie einem Artikel im Linux Journal zu entnehmen war, ist Java nicht die einzige Möglichkeit eine App für Android-Smartphones zu erstellen. Einen sehr interessanten Weg eröffnet die Installation des Scripting Layer for Android (SL4A). SL4A stellt Skript-Sprachen ein High-level Interface zur Android-API zur Verfügung. Genaugenommen wird nur eine Untermenge des Android API zugänglich gemacht. Dabei unterstützt SL4A nicht nur Python, sondern auch Perl, JRuby, Lua, BeanShell, JavaScript und Tcl. Die erforderlichen Installationsschritte sind im o.g. Artikel ausführlich erläutert, ergänzend soll lediglich gesagt werden, dass ein Skript unter Linux durch den Aufruf von ./platform-tools/adb vom Wurzelverzeichnis des Android SDK aus auf das virtuelle Android-Device übertragen wird und nicht durch Aufruf von tools/adb, wie im Artikel genannt.
Um Dateien zu einem realen Smartphone zu Übertragen hat sich sftp bewährt, dazu muß lediglich ein sshd auf dem Smartphone installiert werden (über Google-Play möglich).

Eine Übersicht zur API-Referenz, sowie einige Tutorials zum SL4A, sind über den Link erhältlich.

Welche Leistung über die API zur Verfügung steht, läßt das Beispiel eines Barcode-Scanners in 6 Zeilen Python-Code erahnen.

OSM-Karten in WordPress-Blogs einbetten

Posted on by
2

In einem anderen Artikel habe ich bereits beschrieben, wie man mit Hilfe der Opensource JavaScript-Bibliothek OpenLayers GPX-Tracks einer OSM-Karte überlagern kann um diese auf einer Webseite einzubetten. In Form des OSM-Plugins bietet sich für Nutzer eines WordPress-Blogs eine sehr vereinfachte Integration von OSM-Karten mit verschiedenen Layern, sowie Markern durch die Angabe von Shortcodes an.
Das erwähnte Plugin wird mit einem ftp-Client (z.B. FileZilla) in das Verzeichnis /wp-content/plugins der WordPress-Installation übertragen und anschließend im Plugin-Menu aktiviert.

Die Funktionen des Plugins stehen nun zur Verfügung und können im Text durch die Platzierung von Shortcodes der Form [osm_map ...] eingefügt werden. Argumente des [osm_map]-Präfix sind z.B.:

Für allgemeine Angaben zur Karte:

  • width…die Breite der Karte [osm_map … width=”450″]
  • height…die Höhe der Karte [osm_map … height=”600″]
  • lat…Breitengrad des Kartenzentrums [osm_map … lat=23.6565]
  • long…Längengrad des Kartenzentrums [osm_map … long=”32″]
  • zoom…Zoomstufe der Karte [osm_map … zoom=”13″]
  • type…Kartentyp (Osmarender, Mapnik, CycleMap, GoogleStreet, GooglePhysical,
    GoogleSatellite, GoogleHybrid, All, AllOsm, AllGoogle, Ext) [osm_map … type=”All”] if it is set to all, LayerSchwith is enabled
  • map_border…Kartenrahmen [osm_map … map_border=”medium solid blue”]

Für das Hinzufügen eines Tracks:

  • gpx_file…Absolute url des gpx-files [osm_map … gpx_file=”http://www.Domain.com/blog/sample.gpx”]
  • gpx_colour…Farbe der gpx-Route [osm_map … gpx_colour=”black”]
  • gpx_file_list…Entsprechende Angabe für mehrere Routen [osm_map … gpx_file=”http://www.Domain.com/blog/sample01.gpx,http://www.Domain.com/blog/sample02.gpx”]
  • gpx_colour_list…Entsprechende Angabe für mehrere Routen [osm_map … gpx_colour_list=”black,green”]
  • kml_file…Absolute url kml-file [osm_map … kml_file=”http://www.Domain.com/blog/sample.kml”]
  • kml_colour…Farbe der Route [osm_map … kml_colour=”black”]

Für das Hinzufügen eines einzelnen Markers:

  • marker…Hinzufügen eines Markers [osm_map … marker=”33.54,85.333,Customfieldname”]
  • marker_name…Definiert ein Bildchen für den Marker. [osm_map … marker_name=”../../../uploads/BikeLogo.png”]
  • m_txt_n…Definiert einen zeilenweisen Text, der beim Klicken auf den Marker erscheint. [osm_map … m_txt_01=”Waldquelle” m_txt_02=<”a href=’www.domain.de’>Bild</a>”]
  • marker_file…Alternativ zur direkten Texteingabe mit m_txt kann hier die url eines Textfiles angegeben werden: [osm_map … marker_file=”http://cyberleaf.bplaced.net/wp-content/uploads/textfile.txt”]
  • marker_height…Definiert die Höhe des Markers. [osm_map … marker_height=”23″]
  • marker_width…Definiert die Breite des Markers. [osm_map … marker_width=”23″]
  • marker_focus…Definiert die Orientierung des Markers (0…center, 1…left bottom, 2…left top, 3…right
    top, 4…right bottom). [osm_map … marker_focus=”1″]

Geht man im Dashboard von WordPress auf Einstellungen und wählt den Punkt OSM an, gelangt man zu einem Dialog und kann sich den Shortcode sogar interaktiv generieren lassen.

Um Probleme bei der Angabe von Pfaden besser auf die Spur zu kommen, sollte im Browser die Javascript-Konsole angeschaltet werden. Relative Pfadangaben beziehen sich auf den Installationsort des osm-plugins (also /wp-content/plugins/osm, bzw. /wp-content/plugins/osm/icons für marker_name)

Am Ende noch ein Beispiel:

Hat man die nötigen Dateien im Dashboard über den Punkt Mediathek->Datei hinzufügen hochgeladen, kann das folgende Stück Code auf der Seite eingebunden werden:

[osm_map lat="50.834" long="14.051" zoom="16" width="600" height="450" ov_map=”0″
marker_file="http://cyberleaf.bplaced.net/wp-content/uploads/2012/10/marker_001.txt"]

und nachfolgenden Angaben in der Datei marker_001.txt:

lat	lon	title	description	icon	iconSize	iconOffset
50.834	14.052	Großvaterstuhl	Blick auf den Großvaterstuhl <br><img src="http://cyberleaf.bplaced.net/wp-content/uploads/2012/10/picture_001.jpg" width="500" height="634" alt="GStuhl">	http://cyberleaf.bplaced.net/wp-content/uploads/2012/10/marker_001.png 	50,63	0,-20

Als Ausgabe erhält man:

Weitere Informationen zum OSM-Plugin finden sich auf der Homepage des Plugins.

Oracle VirtualBox 4.2 unter OpenSUSE 12.2 installieren

Posted on by
Kommentar

Dieser Artikel beschreibt die Installation der Version 4.2 von Oracle VirtualBox unter OpenSUSE 12.2. Man benötigt Root-Rechte für die Installation, die man durch Eingabe des Kommandos su erlangt. Die Eingabe von uname -a ergibt die aktuell installierte Version des Kernels:

Linux tp-t530.site 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux

In diesem Fall also die Desktop-Version. Demnach müssen auch die nachfolgend zu installierenden Pakete den Zusatz Desktop tragen:

# zypper install kernel-desktop-devel kernel-source kernel-syms Xerces-c gcc make

Nach dem nun notwendigen Reboot und der anschließenden Root-Authentifikation muß man dem System das VirtualBox-OpenSUSE-Repository hinzufügen (Es gibt für OpenSUSE 12.2 kein eigenes Repo, da die Version 11.4 auch noch unter 12.2 funktioniert):

# cd /etc/zypp/repos.d/
# wget http://download.virtualbox.org/virtualbox/rpm/opensuse/11.4/virtualbox.repo

Jetzt kann VirtualBox 4.2 eingespielt werden:

# zypper install VirtualBox-4.2

Bis einschließlich Version 3 von VirtualBox waren zwei unterschiedliche Ausgaben mit unterschiedlichen Lizenzen verfügbar: eine Version mit komplettem Funktionsumfang und proprietärer Lizenz (die für private Zwecke kostenlos nutzbar war) und einer Version mit eingeschränktem Funktionsumfang (es fehlte z.B. die USB-Unterstützung) und öffentlichem Quellcode unter der GNU GPL. Oracle stellt ab Version 4.0 nur noch eine Version zur Verfügung, die unter der GPL steht und der früheren Open Source Version im Funktionsumfang ähnelt. Die Zusatzfunktionen (USB 2.0, RDP, PXE Boot für Intel-Karten) der proprietären Version sind in einem Extension Pack zusammengefaßt und können (dann wieder unter der proprietären Lizenz) nachinstalliert und genutzt werden. Da dieses Extension Pack nicht über das Repository installierbar ist, muß es direkt von der VirtualBox-Seite heruntergeladen (www.virtualbox.org/wiki/Downloads) werden. Das Extension Pack muß die gleiche Version wie VirtualBox selbst aufweisen:

VirtualBox 4.2 Oracle VM VirtualBox Extension Pack …

Hat man den Downloadlink identifiziert kann’s losgehen:

# wget http://download.virtualbox.org/virtualbox/4.2.0/Oracle_VM_VirtualBox_Extension_Pack-4.2.0-80737.vbox-extpack
# sudo VBoxManage extpack install Oracle_VM_VirtualBox_Extension_Pack-4.2.0-80737.vbox-extpack

Nun muß nur noch der Benutzer zur Gruppe vboxusers hinzugefügt werden:

# /usr/sbin/usermod -G vboxusers Benutzer

GPS und Linux

Posted on by
Kommentar

Auch wenn sich die meisten Aussagen ohne Änderung auf andere Linux-Distributionen übertragen lassen, bezieht sich dieser Artikel doch speziell auf die Konfiguration unter OpenSuSE 12.2 auf einem Lenovo Thinkpad T530 mit dem in einem Mini-PCI express slot installierten WWAN-Adapter Qualcomm Gobi 2000. Eine Vielzahl nützlicher Informationen zum Chipsatz von Qualcomm findet man im Thinkpad-Wiki, im Artikel
Qualcomm Gobi 2000.

Der Qualcomm-Chipsatz benötigt zum Betrieb eine Firmware, die erst zur Laufzeit des Betriebssystems in die Karte geladen wird. Aus Lizenzgründen gehört diese Firmware nicht zum allgemeinen Umfang von Linux-Distributionen. Ist auf dem Thinkpad keine parallel installierte Windows-Installation vorhanden, so kann die kurzzeitig notwendige Windows-Installation auch in einer Virtualisierungsumgebung mit USB-Unterstützung erfolgen, bspw. mit Oracle VirtualBox (zur Installation siehe einen weiteren Artikel von mir). Die Windows-Installationsmedien können unter www.unawave.de heruntergeladen werden. Es empfiehlt sich, das heruntergeladene Image mithilfe des eicfg-removal-utility zu patchen, um während der Installation zwischen den verschiedenen Windows-Installationen auswählen zu können. Für Windows 7 muß auch das Service Pack 1 heruntergeladen werden. Nach Installation von Windows 7 Professional sollte Windows Update vorerst ausgeschaltet werden, um die manuelle Installation der Lenovo-Treiber nicht zu stören. Anschließend muß das Service Pack 1 eingespielt werden. Nun muß der Qualcomm Gobi 2000 Wireless WAN Driver for Windows 7 heruntergeladen und installiert werden. Dieser Treiber bringt die Firmware für den Qualcomm-Adapter mit, sie befindet sich nach der Installation im Verzeichnis c:\Programme (x86)\QUALCOMM\Images\Lenovo. Die Firmware ist auf drei Dateien verteilt (amss.mbn, apps.mbn, UQCN.mbn), die ersten beiden Dateien entnimmt man dem Unterverzeichnis UMTS, die dritte Datei dem Unterverzeichnis 6. Alle drei Dateien legt man nun in dem Verzeichnis /usr/lib/firmware/gobi ab und installiert noch den Gobi-Loader. Durch Installation des des Gobi-Loaders wird die Firmware nun auch unter Linux korrekt geladen.

Um GPS unter Linux nutzen zu können ist die Installation der Firmware aber alleine nicht ausreichend. Dazu ist es notwendig unter Windows 7 die Software ThinkVantage GPS for Windows 7 zu installieren und diese anschließend über das Programmstart-Fenster durch Eingabe von ThinkVantage GPS auszuführen. Hier gibt es einen Button Auto tracking der eingeschaltet sein muß, nun kann man das GPS-Gerät auch unter Linux nutzen, Windows 7 ist dazu nicht mehr nötig und kann entfernt werden.

Der unter OpenSuSE 12.2 installierte Kernel erkennt die Qualcomm-Karte ohne weiteres und stellt folgende Geräte als Schnittstelle zur Verfügung:

# # /dev/ttyUSB0 -> Diagnostics
# # /dev/ttyUSB1 -> 3G Modem
# # /dev/ttyUSB2 -> NMEA GPS port

Die Numerierung der USB-Ports kann beim Vorhandensein weitere USB-Geräte anders lauten und ist evtl. mit

# dmesg | grep -E "Qualcomm USB modem converter now attached to ttyUSB?" | tail -n 3

zu ermitteln.

Nun kann GPS durch entsprechende Nachrichten an den ermittelten GPS-Port an- und ausgeschaltet werden:

# echo "\$GPS_START" > /dev/ttyUSB2
# # use GPS
# echo "\$GPS_STOP"  > /dev/ttyUSB2

Wurde GPS über $GPS_START eingeschaltet kann der GPS-Dämon testweise gestartet werden:

# /usr/sbin/gpsd -n -N -D4  /dev/ttyUSB2

Mit einem Client wie xgps sollte nun die Arbeitsweise überprüft werden (das Auffinden der Satelliten kann bei ungünstigen Empfangsverhältnissen sehr lange dauern).

Konnte die Positionsbestimmung erfolgreich durchgeführt werden, kann man eine Route z.B. mit dem Kommando gpxlogger aufzeichnen lassen. Um GPSD-Clients auch ohne gültiges GPS-Signal testen zu können (z.B. in Gebäuden), kann man das Programm gpsfake einsetzen.

OSM-Karten mit eigenen GPX-Tracks überlagern

Posted on by
Kommentar

OpenStreetMap-Karten lassen sich recht einfach mit eigenen erstellten Tracks im GPX-Format überlagern. Im OpenStreetMap-Wiki finden sich zu diesem Thema einige Einträge.
Schlüssel dazu ist die JavaScript-Bibliothek OpenLayers.js. Der folgende HTML-Kode demonstriert die vorgehensweise. In Zeile 8 wird das notwendige Script der OpenStreetMap-API geladen. In den Zeilen 16-18 wird das Zentrum und die Zoom-Stufe der Karte initialisiert. Der eigentliche GPX-Track wird mit dem Aufruf von OpenLayers.Layer.Vector übergeben, hier kann auch ein Bezeichner für den Track übergeben werden, auch die Farbe und die Durchsichtigkeit können hier eingestellt werden. Um den Kode auf dem heimischen Rechner zu testen. Sollte man im selben Verzeichnis, wo der Kode und der GPX-Track abgelegt ist einen Webserver starten, z.B. durch den Aufruf von: python -m SimpleHTTPServer 8082. Nun kann die Seite im Browser durch http://localhost:8082/OSM-Karte-overlays-GPX-Tracks.html aufgerufen werden, vorausgesetzt JavaScript ist im Browser (zumindest für die entsprechende Seite) eingeschaltet.
Verfügt man über eigenen Webspace, wie bspw. bei www.bplaced.net, so kann man die Dateien natürlich auch dort zur Verfügung stellen (im Dashboard von WordPress kann man übrigens keine GPX-Dateien uploaden, dieser Dateityp ist per Voreinstellung gesperrt, man muß den Umweg über ftp gehen und die Dateien unter dem Pfad wp-content/uploads/<year>/<month>/.. ablegen).
Fügt man dann einen Link auf die Datei in seinem Dokument ein, so kann die Karte von jedermann betrachtet werden.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

<html>
<head>
        <title>Simple OSM GPX Track</title>
        <!--  OpenLayers javascript library
                 Wir binden die  Bibliothek direkt aus dem Internet ein, 
                 die Datei kann bei Bedarf aber auch lokal abgespeichert werden)
         -->
        <script src="http://www.openlayers.org/api/OpenLayers.js"></script>
        <!-- OpenStreetMap OpenLayers layers.
                Diese Datei bevorzugt aus dem Internet laden um sie aktuell zu halten 
         -->
        <script src="http://www.openstreetmap.org/openlayers/OpenStreetMap.js"></script>
 
        <script type="text/javascript">
                // Startposition auf der Karte
                var lat=50.83398
                var lon=14.05214
                var zoom=13
 
                var map; //complex object of type OpenLayers.Map
 
                function init() {
                        map = new OpenLayers.Map ("map", {
                                controls:[
                                        new OpenLayers.Control.Navigation(),
                                        new OpenLayers.Control.PanZoomBar(),
                                        new OpenLayers.Control.LayerSwitcher(),
                                        new OpenLayers.Control.Attribution()],
                                maxExtent: new OpenLayers.Bounds(-20037508.34,-20037508.34,20037508.34,20037508.34),
                                maxResolution: 156543.0399,
                                numZoomLevels: 19,
                                units: 'm',
                                projection: new OpenLayers.Projection("EPSG:900913"),
                                displayProjection: new OpenLayers.Projection("EPSG:4326")
                        } );
 
                        // Define the map layer
                        // Here we use a predefined layer that will be kept up to date with URL changes
                        layerMapnik = new OpenLayers.Layer.OSM.Mapnik("Mapnik");
                        map.addLayer(layerMapnik);
                        layerCycleMap = new OpenLayers.Layer.OSM.CycleMap("CycleMap");
                        map.addLayer(layerCycleMap);
                        layerMarkers = new OpenLayers.Layer.Markers("Marker");
                        map.addLayer(layerMarkers);
 
                        // Layer mit GPX-Track Start
                        var lgpx = new OpenLayers.Layer.Vector("Mückentour", {
                                strategies: [new OpenLayers.Strategy.Fixed()],
                                protocol: new OpenLayers.Protocol.HTTP({
                                        url: "Mückentour.gpx",
                                        format: new OpenLayers.Format.GPX()
                                }),
                                style: {strokeColor: "black", strokeWidth: 5, strokeOpacity: 0.5},
                                projection: new OpenLayers.Projection("EPSG:4326")
                        });
                        map.addLayer(lgpx);
                        //Layer mit GPX-Track Ende
 
 
                        var lonLat = new OpenLayers.LonLat(lon, lat).transform(new OpenLayers.Projection("EPSG:4326"), map.getProjectionObject());
                        map.setCenter(lonLat, zoom);
 
                        var size = new OpenLayers.Size(21, 25);
                        var offset = new OpenLayers.Pixel(-(size.w/2), -size.h);
                        var icon = new OpenLayers.Icon('http://www.openstreetmap.org/openlayers/img/marker.png',size,offset);
                        layerMarkers.addMarker(new OpenLayers.Marker(lonLat,icon));
                }
        </script>
 
</head>
<!-- body.onload is called once the page is loaded (call the 'init' function) -->
<body onload="init();">
        <!-- define a DIV into which the map will appear. Make it take up the whole window -->
        <div style="width:90%; height:90%" id="map"></div>
</body>
</html>