GPS getaggte Bilder auf einer Karte anzeigen

Über das Wochenende hatte ich einige GPS getagte Bilder geschossen und wollte diese auf einer Karte darstellen. Eine kurze Suche im Netz ergab, das so etwas in dieser Form nicht existierte (wobei hier natürlich ein Irrtum vorliegen kann). Also wurde das ganze auf Basis von Leaflet implementiert.

Die Webapplikation in Aktion

Die Webapplikation in Aktion

Leaflet ist ein Framework mit welchem man schnell Kartenapplikationen im Web realisieren kann. Um den „Gps Tagged Image Viewer“ zu benutzen, müssen die Dateien auf einem Webserver kopiert werden. Die Bilder werden dabei in den Ordner „images“ kopiert. Anschließend wird das PHP Skript „parseimages.php“ aus dem „utils“ Ordner ausgeführt. Dieses ließt die EXIF Daten aus den Bildern aus und erzeugt die entsprechenden Marker in einer Javascript Datei. Danach kann das ganze genutzt werden.

Die Karte ist dabei mit drei Kartenebenen versehen, einmal Bing Luftbilder (für welche ein API-Key registriert werden muss), sowie OpenStreetMap in zwei unterschiedlichen Renderings. Der Quelltext ist unter GPLv3 verfügbar und kann auf GitHub bezogen werden.

Probleme mit Chrome und lokalem Javascript

Da beginnt man den Tag mit dem gemütlichem Debuggen von Javascript Code und plötzlich bekommt man von Chrome folgende Meldung auf der Javascript-Konsole:

Cross origin requests are only supported for HTTP.

vorgesetzt. Da stellt sich natürlich die Frage was passiert ist. Die Antwort ist relativ einfach. Chrome unterbindet das die betreffende Webapplikation etwas von einem anderen Ursprung laden kann. Bei HTTP würde so etwas funktionieren. Wenn man das ganze über das „file:///“ Schema aufruft wird es etwas komplizierter. Dafür muss Chrome der Parameter „-allow-file-access-from-files“ übergeben werden, welcher das ganze dann wieder erlaubt. Unter Mac OS X könnte die Kommandozeile dann wie folgt aussehen:

open /Applications/Google\ Chrome.app/ --args -allow-file-access-from-files

Danach funktionieren die „Cross origin requests“ unter Chrome auch lokal.

Design Pattern für JavaScript

In JavaScript kann man vernünftig programmieren, wenn man die schlechten Teile weglässt. Nicht umsonst gibt es das Buch JavaScript: The Good Parts. Dabei haben sich im Laufe der Zeit einige „Best Practices“ entwickelt, welche unter anderem in Form von Design Patterns vorliegen. Auf der Webseite http://shichuan.github.com/javascript-patterns/ kann man sich diese anschauen und so sehen, was man in Zukunft besser machen kann. Das entsprechende GitHub Projekt ist dabei unter https://github.com/shichuan/javascript-patterns/ zu finden. Leider scheint es keine definierte Lizenz für das Projekt zu geben, so das der Lizenzstatus im Moment augenscheinlich noch ungeklärt ist.

Script#

Bei der Entwicklung wundert man sich ab und an, was für interessante Projekte in den Weiten des Netzes so umherschwirren. So unter anderem das Projekt Script#. Dabei handelt es sich um eine Erweiterung für das Visual Studio 2012 mit welcher es möglich ist C# Quelltext (so er gewissen Kriterien genügt) in JavaScript umzuwandeln, bzw. zu compilieren.

Die Erweiterung welche im Quelltext unter https://github.com/nikhilk/scriptsharp zu finden ist, steht dabei unter der Apache Lizenz und ist somit freie Software. Nach der Installation fügt sie dem Visual Studio neue Projekttypen hinzu, mit welchen man anschließend arbeiten kann. Leider gibt es von Script# keine MonoDevelop Variante, so das man im Moment zwingend an das Visual Studio gebunden ist. Allerdings findet sich in der Roadmap folgender Satz:

In terms of code contribution, it would be especially interesting to see the development of import libraries for common libraries, so they are easily usable right out of the box. It would also be interesting to see the development of complementary tools/addins, adding support to other IDEs (esp. MonoDevelop) and other such complementary projects. Or you might be interested in the very core, i.e. the compiler itself.

Also wenn sich jemand bemüßigt fühlt, das ganze für MonoDevelop in Angriff zu nehmen, der muss nun nicht mehr auf die Einladung warten. Die offizielle Projektseite von Script# ist unter http://scriptsharp.com/ zu finden.

melonJS ohne preload benutzen

Bei melonJS handelt es sich um eine Javascript Engine zur Spieleentwicklung im Browser mittels HTML5. Möchte man dort ein Level laden, so geschieht das in Form einer TMX Datei. In melonJS gibt es dabei zwei Methoden zum laden der entsprechenden Daten. Diese sind „me.loader.preload“ und „me.loader.load“. Alle Beispiele welche man im Netz so findet nutzen dabei immer die „preload“ Methode:

var g_resources= [
{ name: "desert1",          type: "image", src: "desert1.png" },
{ name: "desert",           type: "tmx",   src: "desert.tmx" },
{ name: "player_male_base", type: "image", src: "player_male_base.png" },
{ name: "fog",              type: "image", src: "fog.png" }
];

...

me.loader.preload(g_resources);

Das Problem ist das man bei größeren Spielen mit ein paar hundert MiB Spieldaten, das ganze schlecht komplett in den Speicher laden kann. Hierfür gibt es die „load“ Methode. Allerdings enthält diese einige Fehler welche das ganze erschweren. Die „preload“ Methode trägt jede TMX Datei in das Array „levels“ im „me.levelDirector“ ein. Bei der „load“ Methode passiert genau dies nicht. Deshalb muss man hier anders vorgehen (bis der Fehler behoben ist). Ein Minimalbeispiel zum laden eines Levels sieht damit so aus:

<!DOCTYPE html>
<html>
  <head>
    <title>melonJS minimal sample</title>
    <meta charset="utf-8" />
  </head>
  <body>
    <script type="text/javascript" src="melonJS.js"></script>

    <script type="text/javascript">
      var jsApp = {
        start: function() {
          if (!me.video.init('jsapp', 640, 480, false, '1', false))
          {
            alert("Sorry but your browser does not support html 5 canvas.");
            return;
          }

          me.loader.onload = this.loaded.bind(this);

          //lade manuell
          me.loader.load({name: "desert1",  type:"image",  src: "desert1.png"}, this.onload);
          me.loader.load({name: "desert",  type:"tmx",  src: "desert.tmx"}, this.onload);

          //zeige Ladebildschirm
          me.state.change(me.state.LOADING);
        },

        onload: function(data) {
          me.levelDirector.addTMXLevel("desert"); //Bugfix
          me.levelDirector.loadLevel("desert");
        },

        loaded: function() {
          me.state.set(me.state.PLAY, new PlayScreen());
          me.state.change(me.state.PLAY);
        }
      }

      var PlayScreen = me.ScreenObject.extend({
      });

      //starte wenn der Browser bereit ist
      window.onReady(function() {
        jsApp.start();
      });
    </script>
  </body>
</html>

Damit lädt man ein Level dynamisch, ohne auf die „preload“ Methode angewiesen zu sein. Möglich wird dies durch den kleinen Bugfix in der „onload“ Methode:

me.levelDirector.addTMXLevel("desert"); //Bugfix

Dieser sorgt dafür das der levelDirector über die entsprechende TMX Datei informiert wird und somit die Datei beim laden des Levels auch findet.