Start Nutzung der Dienste
Nutzung der Dienste PDF Drucken E-Mail

{jcomments on}


Die Web Generalisierungsdienste des WebGen-Projektes können auf unterschiedliche Arten genutzt werden.

Einerseits besteht bislang weiterhin die Möglichkeit auf die Ursprungsimplementierung (WebGen) zuzugreifen wo sämtliche Dienste verfügbar sind und manuell über ein entsprechendes OpenJUMP-PlugIn aufgerufen werden können.

Andererseits wurde das gesamte Projekt auf den allgemein anerkannten WPS-Standard portiert (WebGen-WPS). Damit sind die verfügbaren Generalisierungsienste wesentlich generischer erreichbar und dadurch in automatisierte Prozessierungsketten integriert werden. Der manuelle Aufruf des WebGen-WPS ist jedoch ebenso über ein weiteres OpenJUMP-PlugIn sichergestellt.

 

Manuelle Anfrage und Ausführung der Dienste:


WPS-PlugIn: (GetCapabilities)

  • Dienst wählen
  • In der Registerkarte "Input" auf "Add" klicken
  • Auswahl des Layers in der Auswahlliste "Target Schema"
  • alle Attribute im Fenster "Source" bis auf GEOMETRY entfernen
  • "Ok" klicken
  • Spezifizierung aller benötigter Parameter im Reiter "Input"
  • Prozessierung starten mit "Execute"
  • ist die Prozessierung abgeschlossen, in der Registerkarte "Output" auf "Send" klicken
  • das Ergebnis wird in OpenJump als neuer Layer geladen

wps_inputmask1

Eingabemaske des WPS Plug-Ins

wps_inputmask2

Spezifizierung des Eingabedatensatzes. Nur Attribut "GEOMETRY" übernehmen!



WebGen06-PlugIn: (XML Info-Datei)

  • Dienst wählen
  • Auswahl des Layers und Spezifizierung der benötigten Parameter in der Eingabemaske
  • "Ok" klicken
  • das Ergebnis wird in OpenJump als neuer Layer geladen

webgen06_inputmask1

Auswahl des gewünschten Dienstes

webgen06_inputmask2

Beispiel Eingabemaske eines WebGen Dienstes

 

 

Generische Anfrage der Dienste

 

Wie bereits eingangs erwähnt, ermöglicht WebGen-WPS generische Aufrufe der vorhandenen Generalisierungsdienste, durch die Implementierung des OGC-WPS Standard. Damit ist die Einbindung in vollständig automatisierte Prozessierungsketten gegeben.

Im Folgenden werden einige Beispiele aufgezeigt, wie eine generische Anfrage des WebGen-WPS innerhalb eines Scripts implementiert werden kann:

 

Grundvoraussetzungen

Der OGC-WPS-Standard definiert 3 grundlegende Operationen, die vom Server ausgeführt werden (siehe WPS-Grundoperationen). Die entsprechenden Anfragen müssen sukzessive mittels Hypertext Transfer Protocoll an den Server übermittelt werden und liefern ein entsprechendes Antwortdokument (im XML-Format) zurück, welches die notwendigen Informationen für eine automatisierte Prozessierung beinhaltet.

Die notwendigen Schritte sehen folgendermaßen aus:

  1. Abfrage sämtlicher, am Server verfügbarer, Generalisierungsdienste durch Übermittlung des Argumentes 'GetCapabilities' (HTTP-GET)
  2. Auswertung der Antwort (XML)
  3. Auswahl eines Generalisierungsdienstes
  4. Abfrage der notwendigen Input-Parameter des gewählten Dienstes durch Übermittlung des Argumentes 'DescribeProcess' (HTTP-GET)
  5. Auswertung der Antwort (XML)
  6. Sammeln der Input-Parameter und Input-Geometrien durch Erstellen einer XML-Execute-Datei
  7. Starten des Generalisierungsdienstes (Prozessierung) durch Übermittlung des Argumentes 'Execute' (HTTP-POST)
  8. Auswerten der Antwort bzw. Extraktion der generalisierten Geometrien (XML bzw. GML)

 

Implementierung

 

Da die Argumentübertragungen mittels HTTP stattfindet benötigt man eine entsprechende Klassenbibliothek, welche diese Übertragung für die angewandte Programmiersprache zur Verfügung stellt. In den folgenden Beispielen wird die weit verbreitete Bibliothek 'libcurl' verwendet um die Implementierung exemplarischen zu verdeutlichen.

 

Die beiden Argumente 'GetCapabilities' und 'DescribeProcess' können durch die fundamentale Übertragungsmethode HTTP-GET an den Server übertragen werden. Diese ist auf maximal 255 Zeichen begrenzt und kann selbst über einen Webbrowser an den Server übertragen werden.

get

 

Die entsprechenden HTTP-Argumente sehen folgendermaßen aus:

  • 'GetCapabilities'     

--> URL = /webgen_wps/wps?service=WPS&Request=GetCapabilities

 

  • 'DescribeProcess' (Beispiel mit dem WebGen-WPS-Dienst 'LineSmoothing')

-->URL =  /webgen_wps/wps?service=WPS&Request=DescribeProcess&Service=WPS&Version=1.0.0&Identifier=ch.unizh.geo.webgen.service.LineSmoothing

 

In einem einfachen Script könnte dies folgendermaßen aussehen:

 

C Python
#include
#include

int main(void)
{
  CURL *curl;
  CURLcode res;
  char url[] = "replace by HTTP-argument";

  curl = curl_easy_init();
  if(curl) {
    curl_easy_setopt(curl, CURLOPT_URL, url);
    res = curl_easy_perform(curl);
    if(res != CURLE_OK)
      fprintf(stderr, "curl_easy_perform() failed: %s\n",
              curl_easy_strerror(res));

    curl_easy_cleanup(curl);
  }
  return 0;
}
import pycurl

def simpleGetRequest(url):
    buf = cStringIO.StringIO()
 
    c = pycurl.Curl()
    c.setopt(c.URL, url)
       c.setopt(c.WRITEFUNCTION, buf.write)
    c.perform()
    
    response = buf.getvalue()
    buf.close()
    return response








 

 

 

Generische Ausführung der Dienste

 

Die Ausführung bzw. das Starten der Dienste am Server muss über die Request Methode HTTP-POST ausgeführt werden, da so größere Datenmengen an den Server übertragbar sind.

Dazu müssen sämtliche geometrischen Daten sowie die zusätzlichen Eingangsparameter des Dienstes in einer XML-Datei definiert werden, welche anschließend über einen HTTP-POST-Request an den WebGen-WPS übertragen werden kann.

Ein Beispiel einer solchen Datei, für den WebGen-WPS-Dienst 'BuildingSimplification' und die Prozessierung eines Polygons, kann hier eingesehen werden: execute.xml

 

Diese Datei kann daraufhin innerhalb eines Scripts geöffnet und an den Server gesandt werden.

Ein entsprechendes Script könnte folgendermaßen aussehen:

 

C++ Python
#include  
 #include
 #include  
 #include "curl/curl.h"

using namespace std;  
    
   // This is the writer call back function used by curl 
   static int writer(char *data, size_t size, size_t nmemb, std::string *buffer) 
   { 
     // What we will return 
     int result = 0;     
     // Is there anything in the buffer? 
     if (buffer != NULL) 
     { 
       // Append the data to the buffer 
       buffer->append(data, size * nmemb);    
       // How much did we write? 
       result = size * nmemb; 
     }     
     return result; 
   } 

int main()
{
// main processes for datafile   
    //read the XML-File & write to a string
    fstream f;   
    f.open("./execute.xml", ios::in);
    string s, datei = "";
    while (!f.eof())         
            {
            getline(f, s);       
        datei = datei + s;     

            }
        f.close();
    //transform string to char (cause curl doesn't read string)       
    const char *data;
    data = datei.c_str();
       
// main part where curl is used
    //set up serveradress
    const char *url;
    //url = "http://localhost:8080/wps-dev/wps";
    url = "/webgen_wps/wps";

    //initialise curl
           CURL *curl; 
           CURLcode result;
    string buffer;

    // initialise curl handling 
           curl = curl_easy_init();

    // set up all curl-options
    if (curl) 
               {
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_HEADER, "Content-Type: text/xml");
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writer);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);    
        }
    // perform server request 
        result = curl_easy_perform(curl);

    // cleanup 
        curl_easy_cleanup(curl);
   
    // print the response to commandline
    cout << buffer << "\n";
}

Download full version
import pycurl
import time

filename = "execute.xml"
location = "./"
#server = "http://localhost:8080/wps-dev/wps"
server = "/webgen_wps/wps"

#Functions
#*********
#wps() sends the request via pycURL to the server
def wps(url):   
    #open the datafile
    data = open(location+filename).read()
    #print data
   
    #set pycURL
    c = pycurl.Curl()
    c.setopt(pycurl.URL, url)
    c.setopt(pycurl.HTTPHEADER, ["Content-Type: text/xml"])
    c.setopt(pycurl.POSTFIELDS, data)
   
    import StringIO
    b = StringIO.StringIO()
    c.setopt(pycurl.WRITEFUNCTION, b.write)
    c.setopt(pycurl.FOLLOWLOCATION, 1)
    c.setopt(pycurl.MAXREDIRS, 5)
    c.perform()
    #print b.getvalue()
    response = b.getvalue()

    return response

#find() returns a string that is between a tag (2 strings)
def find(string, before, behind):   
    e = string.partition(before)
    f = e[2].partition(behind)
    found = f[0]
    #print f[0]

    return found

#Main programm
#*********
print 'Request the WPS-Servers via pycURL'

#send the execute command
print server
response = wps(server)
print response

#find the url of status-xml
found = find(response,'statusLocation="','" xmlns:wps')

status_xml = found
print "Status-xml: ", status_xml


















Download full verion

 

Das Senden des 'Execute'-Argumentes liefert die URL einer XML-Datei zurück welche den Prozessierungsstatus des angefragten Generalisierungsdienstes wiedergibt. Dementsprechend muss diese 'Status-XML' wiederholt aufgerufen und der entsprechende 'tag' ausgewertet werden, bis dieser auf 'Process finished successfully.' steht.

In Python könnte diese Schleife folgendermaßen aussehen:

 

#read the status-xml
response = ""
finished = False
count = 0
while finished is False:
    response = wps(status_xml)
    #print response
   
    found = find(response,'','')   
   
    if  count == 0:
        print found
        count = count+1
    if found == "Request is in progress...":
        finished = False
    else:
        finished = True
        found = find(response,'','')
        if found == "Process finished successfully.":
            print found
        else:
            print "Any problem occured!!!"
    time.sleep(1)

 

!Hinweis: Es empfiehlt sich die Anfrage der 'Status-XML' mit einer zeitlichen Verzögerung durchzuführen!

 

Ist die Prozessierung des angesprochenen Generalisierungsdienstes erfolgreich abgeschlossen, liefert die 'Status-XML' die URL Datei mit den generalisierten Geometrien zurück. 

Ein Beispiel einer solchen Datei, als Ergebnis der Prozessierung der zuvor aufgeführten execute.xml, kann hier eingesehen werden: result.xml

Zuletzt aktualisiert am Mittwoch, den 08. März 2017 um 13:16 Uhr