Sonntag, 20. September 2015

USA Urlaub 2015 - 5 National Parks in Utah

Unseren Sommerurlaub 2015 haben wir in den USA verbracht. Das Hauptziel waren fünf Nationalparks in Utah, nämlich:
Die Parks haben wir auch in dieser Reihenfolge besucht. Geflogen sind wir nach Los Angeles, von da aus ging's dann für zwei Tage nach Las Vegas und von dort aus weiter zu den Parks. Nach dem Capitol Reef waren wir dann nochmal einen Tag in Las Vegas und dann zum Abschluss südlich von Los Angeles, am Strand von Manhattan Beach.

Blick auf Manhattan Beach, südlich von LA
Gecacht haben wir natürlich auch, wobei der Schwerpunkt auf "Urlaub" lag und nicht "Cachen". In den Nationalparks gibt es so wie so keine Tradis (scheinbar sind die dort nicht erlaubt, zumindest nicht in denen, wo wir waren), somit standen primär Earthcaches und Virtuals auf dem Programm. Davon gibt es in jedem der Parks einige.

Natürlich könnten man zu allen Parks sehr viel schreiben. Wir beschränken uns hier aber auf ein bisschen Text und lassen die Fotos sprechen.

Zion Nationalpark

Hier waren wir im Zion Canyon, was quasi der "Hauptteil" (bzw. der meistbesuchte Teil) des Parks ist. Der Canyon ist charakterisiert durch seine steilen Wände aus rotem Gestein, gepaart mit dem Fluss und der Vegetation an der Talsohle, welche zusammen eine tolle Landschaft ergeben.

Blick in die Zion Narrows
Zion Nationalpark

Zion Nationalpark
Der Zion Park darf übrigens in der Hauptsaison nicht mit dem eigenen Auto befahren werden (in den anderen Parks ist das möglich bzw. normal). Im Zion gibt es aber kostenlose Pendelbusse, die regelmäßig im Park verkehren und verschiedene Haltepunkte haben.

Bei der Fahrt vom Zion zum Bryce Canyon führt die Straße übrigens durch einen anderen Teil des Park, wo es auch durchaus reizvolle Felsformationen gibt.

Felsformation in einem anderen Teil des Zion Nationalparks

Bryce Canyon

Der Bryce Canyon ist vor allen durch sein Kombination aus Felsen, Wald und besonders seinen Hoodoos bekannt. Letztere gibt es zu tausenden im Park.

Im Bryce Canyon befindet man sich immer oben auf einem Hochplateau und blickt hinab. Außer einer tollen Landschaft gibt es hier also auch grandiose Weitblicke.
Bryce Canyon war auch der höchste Punkt unserer Tour. Der Aussichtspunkt "Rainbow Point" befindet sich auf knapp 2800 m Höhe.
Aussicht im Bryce Canyon Nationpark

Blick auf die Hoodoos im Bryce Canyon

Blick auf noch mehr Hoodoos im Bryce Canyon

Hoodoos aus der Nähe
Arches

Der Arches Nationalpark zeichnet sich - wie der Name schon vermuten lässt - durch seine Steinbögen aus, die es hier an verschiedenen Stellen und in verschiedenen Größen gibt.
Leider war des Wetter an dem Tag des Besuch bescheiden. Erst Schauern und nachmittags dann so viel Regen, dass wir die Tour abgebrochen haben.

Landscape Arch - leider aufgrund des Hintergrunds schlecht zu sehen

Sand Dune Arch, einer der kleineren Bögen

Balanced Rock im Arches Nationalpark

die Window-Section im Arches Nationalpark

Der Arches Park ist der, den wir von den fünf Nationalparks am "schwächsten" fanden. Vielleicht lag's am Wetter oder daran, dass Steinbögen nicht unser Ding sind.
Wenn man den Canyonlands Park besucht, fährt man aber so wie am Arches vorbei, beide Parks liegen in der Nähe von Moab. Von daher waren wir so wie so in der Gegend.

Dead Horse Point

Dead Horse Point ist kein Nationalpark, sondern "nur" ein Statepark. Wenn man von Moab Richtung Canyonlands fahrt kommt man unmittelbar an der Stichstraße vorbei, die zum Dead HorsePoint führt. Der "Umweg" beträgt nur 10 km - und die lohnen sich. Vom Dead Horse Point hat man einen grandiosen Ausblick auf eine Schleife des Colorado River. Der Aussichtspunkt befindet sich ca. 600 m höher als der Fluss.

Blick vom Dead Horse Point auf den Colorado River
Canyonlands

Auch hier ist der Name Programm: man befindet sich auf einem Hochplateau und hat immer wieder spektakuläre Ausblicke auf die umliegenden Canyons.
Canyonlands, Blick in den Schafer Canyon

Mesa Arch im Canyonlands Nationpark

auf dem Mesa Arch

Blick vom Grand View Point, Canyonlands Nationalpark
 Captiol Reef
 
Der Capitol Reef Nationalpark ist zwar ziemlich groß bzw. langgestreckt, da die Straße aber quer durch schmalen Teil des Parks führt, hat man den Park ziemlich zügig durchquert. Kernstück des Parks ist eine ca. 150 km lange Verwerfung der Erdkurste.
Im Gegensatz zu den anderen vier Parks ist es im Capitol Reef ruhiger, weil hier (viel) weniger Besucher unterwegs sind.

Capitol Reef Nationalpark

Hickmann Bridge im Capitol Reef Park

Blick auf die Verwerfung im Capitol Reef National Park
Zusammenfassung & ein paar Tipps

Schön war's auf jeden Fall, wir haben tolle Landschaften gesehen und super Ausblicke genossen.

Wer wander-affin ist kann übrigens in allen Parks gut Touren machen. Es gibt etliche Trails von kurz (< 1 km) bis lang (20 km oder mehr). Außerdem gibt es in allen Parks reichlich Campingsplätze.
Wir haben in allen Parks auch Touren gemacht, aber eher kürzer, so ca. maximal 5 km.
Wer wandern geht, gerade in den Sommermonaten, sollte unbedingt genug Wasser mitnehmen! Den trotz der Höhe ist es ziemlich warm (30-35°C) und Schatten ist auch nur bedingt vorhanden.
Wir haben selbst auf Touren von "nur" 1,5 h mit vier Leuten 1,25 - 1,5 Liter Wasser getrunken. Wer länger unterwegs ist sollte die Empfehlung der Park Ranger ernst nehmen und mindestens 4 Liter pro Tag und Person mitnehmen.

Auch wenn die Parks alle im gleichen Bundesstaat liegen und nach amerikanischen Verhältnissen nicht weit auseinander, sollte man sich vorher die Entfernung ansehen und entsprechend viel Fahrzeit einplanen.
auf der Landtraße Richtung Captiol Reef
Das gute ist immer, dass auf den Straßen ziemlich wenig Verkehr ist, wenn man erst mal Las Vegas hinter sich gelassen hat.

Wer eine ähnlich Tour plant oder einen der Parks besuchen möchten, der kann uns gerne für weitere Infos oder Fragen per Mail kontaktieren.

Samstag, 12. September 2015

Anderer Cache - eine Bastelanleitung

Die meisten (bedosten) Caches bestehen aus einen wie auch immer gearteten Cachebehälter, in dem ein Logbuch aus Papier ist.

Das ist gängig, aber man kann auch einen Cache mit Logbuch ohne Dose und ohne Papier bauen. Einen "anderen Cache" halt. Wie, das wird im folgenden beschrieben.

Als Material braucht man:
  • eine Dachlatte, ca. 4x2 cm Querschnitt
  • zwei kurze Spax-Schrauben mit großem Kopfdurchmesser (z.B. 4,5x12 oder 4,5x16)
  • zwei Rundmagnete, 10 mm Durchmesser, Dicke 5 mm
Bei den Magneten sollte man darauf achten, dass man starke, wie z.B. Neodym-Magnete nimmt - weil an diesen Magneten später die Lochbuch (bzw. die Loglatte) befestigt wird. Solche Magnete bieten diverse Geocaching-Shops an, der Preis liegt in der Regel bei moderaten ca. 0,50 Euro pro Magnet

Als Werkzeug braucht man:
  • eine Säge
  • einen 10 mm Holzbohrer
  • einen Senker
  • einen Schraubendreher
Und man braucht noch einen geeigneten Kleber, der die Magnete im Holz verkleben kann. Sehr gut bewährt dafür hat sich bei uns Patex 100% Repair Gel, welches man in jedem Baumarkt bekommt.

Material und Werkzeug für einen "anderen" Cache
Hat man alle Materialien zusammen, dann kann man mit dem Basteln loslegen. Von der Dachlatte sägt man ein 40 cm langes und ein ca. 60 cm langes Stück ab. Das 40 cm lange Stück wird das Logbuch, das 60 cm lange Stück der Logbuchhalter.

Letzter wird dann wie folgt gebaut: Man bohrt im Abstand von 10 cm und 30 cm von der Oberkante der Latte ein 5 mm tiefes Sackloch horizontal mittig in das Holz. Darin verklebt man dann die Magnete mit Hilfe des Klebers.
Außerdem empfiehlt es sich, das untere Ende der Dachlatte etwas anzuspitzen, damit man sie später besser in die Erde stecken kann. Damit ist der Logbuchhalter schon fertig.

der Logbuchhalter

die Magnete sind bündig in der Dachlatte versenkt
Der Bau des Logbuchs ist ebenso einfach: Hier bohrt man ebenfalls im Abstand von 10 cm und 30 cm von der Oberkante horizontal mittig mit dem Senker die Dachlatte an, so der Kopf der Schraube später genau bündig mit der Oberfläche des Holzes abschließt. Danach werden die beiden Schrauben eingeschraubt. Damit ist das Logbuch auch fertig gebaut. Jetzt sollte man es noch beschriften, z.B. in dem man mit einem dünnen, wasserfesten Marker zumindest den Namen des Caches darauf schreibt.

das Logbuch / die Loglatte
Die Schrauben in der Loglatte werden von den beiden Magneten angezogen, so hält diese auf dem Loglattenhalter. Der Cache ist fertig und kann platziert werden.

der fertige Cache
Wie gezeigt ist der Bau eines solchen Caches nicht weiter schwierig und dauert auch nicht lange. Am längsten dauert das Austrocknen des Klebers, dem man schon mindestens eine Nacht geben sollte.

Und das ganze ist auch praxistauglich. Wir selber haben genau so einen Cache seit dem 1.7.2015 im Einsatz - und das völlig problemlos. Vor kurzem haben wir zum ersten Mal den Logbuchhalter getauscht. Präventiv. Und nicht, weil es wirklich nötig gewesen wäre. Die Haltbarkeit ist also auch gegeben.

Wer also mal einen Cache und "klassische Dose" und Papierlogbuch platzieren möchte. der kann z.B. diesen Cache so oder auf ähnliche Weise nachbauen.
Wer einen solchen Cache auslegt sollte übrigens im Listing noch erwähnen, dass die suchenden Cacher zum Loggen am besten eine Kuli, Marker oder Bleistift mitbringen sollen. Tintenroller und Faserschreiber schreiben nämlich unter Umständen schlecht bis gar nicht auf Holz.

Sonntag, 6. September 2015

Anzahl der Fund, DNFs, Wartungen etc der eigenen Caches auslesen

Statistiken gibt es beim Geocaching viele in jeglicher Ausprägung. Allerdings sind diese fast immer auf (eigene) Funde fokussiert.

Wer als Cacheowner z.B. wissen will, wie viele Funde die eigenen gelegten Caches haben, der schaut erst Mal in die Röhre. Jedenfalls gibt es keine uns bekannte Möglichkeit, dies zu sehen.
Wer "nur" eine handvoll Caches gelegt hat, kann dies natürlich noch relativ einfach und schnell von Hand erledigen. Für Cacheowner mit mehr als ein paar Caches, würde dies händisch viel zu lange dauern, etliche Dutzend Listings von Hand aufzurufen.

Da uns diese Zahlen aber interessieren, wurde - selbst ist der Geocacher - ein Python-Skript (für Python 3) geschrieben, welches die Anzahl der "Found it", "Didn't find it", "Write note", "Need Maintenance", "Owner Maintenance", "Temporarily Disable Listing", "Enable Listing" und "Needs Archived" Logs aus den Cachelistings extrahiert, zusammenrechnet und am Ende am Bildschirm ausgibt.

Die gewünschten Daten sind in jedem Listing bei geocaching.com zu finden und für jeden sichtbar, d.h. man muss nicht auf der Webseite eingelogt sein.

Was das Skript macht ist folgendes:
Es wird zuerst eine Datei cache_list.txt (die im selben Verzeichnis liegen muss die das Skript selbst) eingelesen, in der zeilenweise die GC-Nummer der abzurufenden Caches hinterlegt sind. Die Struktur der Datei ist also

GC2X3F0
GC3M3R8
GC3PGDD
GC3PM4E
...

Für jeden dieser Caches lädt das Skript die Webseite des Listing in den Speicher, parst das HTML der Webseite und extrahiert daraus die Logzahlen.
Während das Skript arbeitet werden die Daten für den jeweiligen Cache auf dem Bildschirm ausgegeben:

...
reading: GC4DRB0
Found it:  166 - Write note:  1 - Owner Maintenance:  1 -
---------------------------------------
reading: GC4EA6J
Found it:  99 - Didn't find it:  1 - Write note:  2 - Owner Maintenance:  2 -
----------------------------------------
...

Nachdem alle Listings abgerufen und geparst wurden, wird das Ergebnis ausgegeben.

Der komplette Python-Code des Skripts sieht so aus:

from urllib.request import Request, urlopen
from urllib.error import URLError, HTTPError
from html.parser import HTMLParser
from datetime import datetime


class MyHTMLParser(HTMLParser):

    def __init__(self):
        HTMLParser.__init__(self)
        self.recording = 0
        self.cache_data = {"Found it": 0,
                           "Didn't find it": 0,
                           "Write note": 0,
                           "Owner Maintenance": 0,
                           "Needs Maintenance": 0,
                           "Temporarily Disable Listing": 0,
                           "Enable Listing": 0,
                           "Needs Archived": 0}
        self.cur_value = None

    def handle_starttag(self, tag, attrs):
        if tag == "img":
            for name, value in attrs:
                if name == "title" and value == "Found it":
                    self.cur_value = "Found it"
                elif name == "title" and value == "Owner Maintenance":
                    self.cur_value = "Owner Maintenance"
                elif name == "title" and value == "Didn't find it":
                    self.cur_value = "Didn't find it"
                elif name == "title" and value == "Write note":
                    self.cur_value = "Write note"
                elif name == "title" and value == "Needs Maintenance":
                    self.cur_value = "Needs Maintenance"
                elif name == "title" and value == "Temporarily Disable Listing":
                    self.cur_value = "Temporarily Disable Listing"
                elif name == "title" and value == "Enable Listing":
                    self.cur_value = "Enable Listing"
                elif name == "title" and value == "Needs Archived":
                    self.cur_value = "Needs Archived"
                self.recording = 1

    def handle_data(self, data):
        if self.recording:
            if self.cur_value == "Owner Maintenance":
                self.cache_data["Owner Maintenance"] = \
                    self.cache_data["Owner Maintenance"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Needs Maintenance":
                self.cache_data["Needs Maintenance"] = \
                    self.cache_data["Needs Maintenance"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Found it":
                self.cache_data["Found it"] = \
                    self.cache_data["Found it"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Didn't find it":
                self.cache_data["Didn't find it"] = \
                    self.cache_data["Didn't find it"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Write note":
                self.cache_data["Write note"] = \
                    self.cache_data["Write note"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Needs Archived":
                self.cache_data["Needs Archived"] = \
                    self.cache_data["Needs Archived"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Temporarily Disable Listing":
                self.cache_data["Temporarily Disable Listing"] = \
                    self.cache_data["Temporarily Disable Listing"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            elif self.cur_value == "Enable Listing":
                self.cache_data["Enable Listing"] = \
                    self.cache_data["Enable Listing"] + int(data)
                print("{}: {} - ".format(self.cur_value, data), end="")
            self.cur_value = None
            self.recording = 0

p = MyHTMLParser()
print("Starting at {}".format(datetime.now()))
with open("cache_list.txt", "r") as f:
    for cache in f:
        print("reading: {}".format(cache), end="")
        req = Request("http://coord.info/{}".format(cache))
        try:
            response = urlopen(req)
        except HTTPError as e:
            if e.code == 404:
                print("...is an invalid GC-number!", end="")
            else:
                print("Got HTTPError code {} when trying to fetch data for {}"
                      .format(e.code, cache))
        else:
            html = response.read().decode("utf-8")
            p.feed(html)
        print()
        print("-"*40)
print("Data on caches:")
print("Found it logs: {}".format(p.cache_data["Found it"]))
print("Didn't find it logs: {}".format(p.cache_data["Didn't find it"]))
print("Write note logs: {}".format(p.cache_data["Write note"]))
print("Need Maintenance logs: {}".format(p.cache_data["Needs Maintenance"]))
print("Owner Maintenance logs: {}".format(p.cache_data["Owner Maintenance"]))
print("Needs Archived logs: {}".format(p.cache_data["Needs Archived"]))
print("Temporarily Disable Listing: {}"
      .format(p.cache_data['Temporarily Disable Listing']))
print("Enable Listing logs: {}".format(p.cache_data["Enable Listing"]))
p.close()
print("Finished at {}".format(datetime.now()))

Das Skript arbeitet die Liste der GC-Nummer übrigens "stumpf" ab, d.h. es erfolgt keinerlei Prüfung, ob die GC-Nummer auch wirklich ein eigener Cache ist - von daher sollte man beim Anlegen der Datei mit den GC-Nummern sorgfältig sein.
Sollte die Liste eine ungültige (=nicht existierende) GC-Nummer enthalten, so gibt es Skript einen Hinweis am Bildschirm aus und fährt dann mit dem nächsten Cache fort.

Das Ergebnis sieht dann so aus (heutiger Stand für unsere 89 aktiven Caches):

Data on caches:
Found it logs: 8094
Didn't find it logs: 22
Write note logs: 176
Need Maintenance logs: 16
Owner Maintenance logs: 118
Needs Archived logs: 0
Temporarily Disable Listing: 11
Enable Listing logs: 11

Das ganze dauert übrigens ein bisschen, da die Server von Groundspeak ja nicht so schnell sind (und wir außerdem zu Hause noch eine relative lahme Internetanbindung haben). Für die 89 Cache wurde ca. 11 Minuten benötigt.

Was aber nicht wirklich schlimm ist, weil man diese Statistik ja nicht so häufig benötigt. Außerdem könnte man die Abrufe der Webseiten bei Bedarf noch parallelisieren.

Anzumerken ist auch noch, dass Web Scraping nicht zur "feinen englische Art" gehört - auch, wenn hier "nur" die Daten zu eigenen Caches abgerufen werden.
Wenn also jemand eine bessere / "feinere" Art kennt, an die Daten zu kommen, kann das gerne in den Kommentaren beschrieben werden.

Und auch bei Fragen / Anmerkung zum Skript bitte direkt an uns wenden.