Google Static Maps

In manchen Situationen kann es von Vorteil sein, Kundenadressen optisch aufbereitet innerhalb der Applikation darzustellen. Dies kann beispielsweise die Planung von Einsätzen im Außendienst vereinfachen und zusätzlich zu einer besseren Orientierung führen.

Google bietet mit dem Static Maps API die Möglichkeit, ein Google Maps-Bild ohne JavaScript oder dynamische Seitenladefunktion in Ihre Applikation zu implementieren. Um eine Karte zu erstellen, muss, basierend auf URL-Parametern, eine Standard-HTTP-Anfrage gesendet werden. Diese Anfrage wird von dem Google Static Maps API verarbeitet und diese gibt die Karte als Bild wieder.
Hierbei müssen allerdings die von Google angegebenen Nutzungsbegrenzungen beachtet werden. So können täglich 25000 kostenlose Static Maps-Anfragen pro Anwendung abgesetzt werden. Genauere Informationen gibt es unter:
Google Static Maps – Nutzungsbegrenzungen
Das Google Static Maps API gibt nun als Antwort auf die HTTP-Anfrage über eine URL ein Bild im Format GIF, PNG oder JPEG zurück. Bei jeder Anfrage können nun der Kartenausschnitt sowie die Größe des Bildes, die Zoomstufe, der Kartentyp und die Platzierung optionaler Markierungen (Pins) angegeben werden. Desweiteren gibt es die Option den Labels zusätzlich ein alphanumerisches Zeichen zu übergeben.
Die URLs für das Google Static Maps API müssen folgende Form aufweisen:
http://maps.googleapis.com/maps/api/staticmap?parameters

Hierbei sind bestimmte URL-Parameter erforderlich, während andere optional sind. Wie bei URLs üblich, werden alle Parameter durch kaufmännische UND-Zeichen (&) voneinander getrennt.

Standortparameter

• center (erforderlich, wenn keine Markierungen vorhanden sind)
  definiert die Kartenmitte, mit gleichen Abstand von allen Rändern der Karte.
• zoom (erforderlich, wenn keine Markierungen vorhanden sind)
  definiert die Zoomstufe der Karte, die die Vergrößerungsstufe der Karte festlegt.

Im folgenden Beispiel wird eine Karte von Berlin erzeugt:

http://maps.googleapis.com/maps/api/staticmap?center=Berlin&zoom=14&size=400x400&sensor=false

Kartenparameter

• size (erforderlich)
  legt die Größe der rechteckigen Form des Kartenbildes fest.
• scale (optional)
  betrifft die Anzahl der zurückgegebenen Pixel. scale=2 gibt doppelt so viele Pixel zurück wie scale=1.
• format (optional)
  gibt das Format für das Bild an. Das Static Maps API erstellt standardmäßig PNG-Dateien.
• maptype (optional)
  legt den Typ der aufzubauenden Karte fest.
• language (optional)
  legt die Sprache fest, in der die Labels auf Kartenkacheln wiedergegeben werden.
• region (optional)
  definiert die anzuzeigenden Grenzen basierend auf geopolitischen Gegebenheiten.

Beispiel:
Es soll eine Karte erstellt werden, welche das Zentrum von Berlin als Hybridbild (Satelliten- und Straßenkartenbild) zeigt. Die Labels der Karte sollen in Englisch dargestellt werden und das Kartenbild soll im JPEG-Format zurückgegeben werden.

http://maps.googleapis.com/maps/api/staticmap?center=Berlin,DE&zoom=14&size=400x400&format=jpg&maptype=hybrid&language=EN&sensor=false

Funktionsparameter

• markers (optional)
  definiert eine oder mehrere Markierungen, die an den angegebenen Postionen zum Bild hinzugefügt werden.
• path (optional)
  legt einen einzelnen Pfad fest, der zwei oder mehrere Punkte miteinander verbindet und der bei angegebenen Standorten auf dem Bild dargestellt werden soll.
• visible (optional)
  gibt mindestens einen Standort an, der auf der Karte sichtbar bleiben soll, auch wenn keine Markierungen oder anderen Indikatoren angezeigt werden.
• style (optional)
  definiert einen benutzerdefinierten Stil, um die Darstellung eines bestimmten Elements der Karte zu ändern, etwa eine Straße oder einen Park.

Beispiel:
Nun soll auf einer Karte von Frankfurt eine Markierung (Pin) gesetzt werden, diese soll als Beschriftung den Buchstaben ‚X‘ und die Farbe Lila erhalten. Die Anfrage besitzt nun folgendes Aussehen:

http://maps.googleapis.com/maps/api/staticmap?center=Frankfurt,DE&zoom=14&size=400x400&markers=color:purple|label:X|Frankfurt&sensor=false

Berichtsparameter

• sensor (erforderlich)
  legt fest, ob die Anwendung, die die statische Karte anfordert, einen Sensor verwendet, um den Standort des Nutzers zu ermitteln.

Um aus CONZEPT 16 heraus das Google Static Maps API zu verwenden muss als erstes über ein HTTP-Objekt eine Anfrage gesendet werden. Im Artikel HTTP-Kommunikation im Web wurde bereits auf die Verwendung des HTTP-Objektes eingegangen.

sub DownloadFile
(
  aURI                  : alpha(4096);
  aDestFile             : alpha;
)
: int;

  local
  {
    tHost               : alpha(128);     // Hostname
    tPath               : alpha(4096);    // Path
    tPos                : int;
    tError              : int;            // Errorcode

    tSck                : handle;         // Socket
    tReq                : handle;         // Request-Object
    tRsp                : handle;         // Response-Object
    tLst                : handle;         // HTTP-Header-List
    tFsi                : handle;         // File

    tCode               : alpha;
    tLen                : int;
  }

{

  if (!(aURI =* 'http://*'))
    return(_ErrData);

  // URI in Host und Pfad zerlegen
  tPos # StrFind(aURI,'/',8);
  if (tPos = 0)
  {
    tHost # StrCut(aURI,8,StrLen(aURI)-7);
    tPath # '/';
  }
  else
  {
    tHost # StrCut(aURI,8,tPos - 8);
    tPath # StrCut(aURI,tPos,StrLen(aURI) + 1 - tPos);
  }
  TRY
  {
    // Verbindung aufbauen
    tSck # SckConnect(tHost,80,0,20000);

    // Anfrage erzeugen
    tReq # HttpOpen(_HttpSendRequest,tSck);
    tLst # tReq->spHttpHeader;
    tReq->spURI      # tPath;
    tReq->spProtocol # 'HTTP/1.1';
    tLst->CteInsertItem('Host',0,tHost);
    tLst->CteInsertItem('Accept',0,'*/*');

    // Anfrage senden
    tReq->HttpClose(_HttpCloseConnection);
    tReq # 0;

    // Antwort abholen
    tRsp # HttpOpen(_HttpRecvResponse,tSck);

    tCode # tRsp->spStatusCode;
    tLen  # tRsp->spContentLength;

    if (tRsp->spStatusCode =* '200*')
    {
      tFsi # FsiOpen(aDestFile,_FsiStdWrite);
      // Datei speichern
      tRsp->HttpGetData(tFsi);
    }
  }

  tError # ErrGet();

  // angelegte Deskriptoren entfernen
    tReq->HttpClose(_HttpDiscard);
    tFsi->FsiClose();
    tRsp->HttpClose(0);
    tSck->SckClose();

  return(tError);
}

Der oben aufgeführten Funktion muss nun die URL mit den entsprechenden Parametern und der Pfad, in welchem das Bild gespeichert werden soll, übergeben werden.

sub GetStaticMap

  local
  {
    tRequest      : alpha(4096);
  }

{
   tRequest # 'http://maps.googleapis.com/maps/api/staticmap?maptype=roadmap&size=400x400&scale=2&markers=color:0xc90d0d|label:V|Heusenstamm,%20Seligenst%C3%A4dter%20Grund%202&zoom=15&sensor=false';

   DownloadFile(tRequest,_Sys->spPathMyPictures + '\Google_Static_Map.png');
}

Das von dem Google Static Maps API generierte Bild besitzt nun folgendes Aussehen und kann beispielsweise in ein PrtPicture-Objekt innerhalb eines Druckjobs eingefügt werden.

Mit Google Static Maps API erstelltes Bild

Weitere Informationen über das Google Static Maps API finden Sie unter:
Google Static Maps API