Skip navigation
All Places > GeoDev Germany > Blog > 2017 > November
2017

Vom 3.-9.3. findet wieder der Esri Developer Summit in Palm Springs, Kalifornien, statt. Wir möchten Euch einladen, dort Eure Arbeit vorzustellen. Es ist wirklich eine einmalige Gelegenheit, vor so einem Publikum zu stehen und die eigenen Ergebnisse zu präsentieren. Letztlich lebt ein solches Event auch von Euren Beiträgen.

 

Ihr habt noch bis zum 12. Januar Zeit, Euren Vortrag einzureichen. Ihr könnt über Tools, Technologien, Innovationen, Lessons Learned, gelöste Probleme oder schlicht über Euer eigenes Projekt mit ArcGIS berichten.

 

Haben wir Euer Interesse geweckt? Dann geht es hier zur Anmeldung. Viel Glück! :-)

 

DevSummit Apps

Aus den am Ernst-Reuter-Platz in Berlin erhobenen Verkehrsdaten sollen Anwendungen entwickelt werden, die das Leben, Arbeiten oder den Verkehr vor Ort optimieren. Bis Mitte Dezember können Interessierte ihre Lösungen einreichen.

 

Gemeinsam mit der Berliner Senatsverwaltung für Wirtschaft, Energie und Betriebe und dem DAI-Labor der TU Berlin ruft Cisco jetzt zum Ideenwettbewerb „Smart City Berlin – Ernst-Reuter-Platz“ auf. Wie das Unternehmen mitteilt, richtet sich der mit 30.000 Euro dotierte Wettbewerb an Studierende und Startups aus Berlin. Sie sollen aus vorhandenen Daten Ideen entwickeln, die das Leben, Arbeiten oder den Verkehr vor Ort für alle besser machen. Bis zum 17. Dezember 2017 haben die Teilnehmer Zeit, ihre Lösungen einzureichen. Die Preisträger werden laut Cisco im Januar 2018 bekanntgegeben. Am Ernst-Reuter-Platz befindet sich das DAI-Labor.

 

Alle weiteren Infos könnt Ihr auf www.kommune21.de lesen (Originaltext).

 

Bildergebnis für ernst-reuter-platz

[Original erschienen auf GIS IQ]

Seit rund einem Jahr gibt es die ArcGIS API for Python zum Skripting fürs Web-GIS (ArcGIS Online und Portal for ArcGIS). In der aktuellen Version 1.2.4 ist die API um zahlreiche Funktionen erweitert worden. Einen Überblick über alle Module gibt es auf der Dokumentationsseite.

Zahlreiche neue Beispiele für räumliche Analysen mit Python

Seit meinem letzten Blogpost sind die Beispiele für GIS Analysten und Data Scientists deutlich mehr geworden. Mittlerweile gibt es Jupyter Notebooks zur Analyse von Feature-Erkennung aus Satellitendaten (siehe Abbildungen unten), Fahrzeitpolygonen, Kostenoberflächen aus Höhenmodellen oder der Suche nach dem nächsten Krankenhaus.

 

Diese Beispiele sind sehr gut geeignet, GIS-Studierenden einen leichten Einstieg in die umfangreichen Skripting-Möglichkeiten von Python zu bieten. Das ist insofern besonders interessant, als Python-Kenntnisse auf dem Arbeitsmarkt immer stärker als Skill nachgefragt werden.

Funktionalität für Administratoren: Zuweisung von ArcGIS Pro Lizenzen, Zugang zum Trainingsportal und Löschen inaktiver Nutzer

Neu ab der API-Version 1.2 ist die Funktionalität, mit dem Submodul arcgis.gis.admin auch zahlreiche administrative Aufgaben zu skripten – wie beispielsweise die Lizenzvergabe für ArcGIS Pro und andere Produkte. Die Lizenzvergabe war bislang nur über die Benutzeroberfläche (GUI) von ArcGIS Online oder Portal for ArcGIS möglich.So kann über den folgenden Codeblock beispielsweise allen Named Usern einer Subskription, die noch keine Lizenz haben, eine ArcGIS Pro Advanced Lizenz über ein paar Zeilen Python-Code zugewiesen werden:

 

Die verfügbaren Lizenzen für die Lizenzstufen und Erweiterungen lassen sich wie folgt aufrufen:

Genauso können nicht mehr aktive User über die Angabe eines gewissen zeitlichen Schwellenwerts aus der Subskription gelöscht werden.

Der Zugang zu My Esri und damit zum Trainingsportal kann mit den Skripten auf ArcGIS Online allen Mitgliedern zugewiesen werden. Auch hier ist die Idee, dass in dem Python-Skript lediglich Administrator-Benutzername und Passwort eingegeben werden müssen, damit man sich zu seinem jeweiligen Portal verbinden kann.

Wir arbeiten derzeit an Beispielskripten für Administratoren, die wir gerne zur Verfügung stellen! Bei Interesse können Sie uns gerne eine E-Mail schreiben und wir halten Sie auf dem Laufenden.

Jan Wilkening
Solution Engineer Education and Science

Die Deutsche Bahn AG hat umfangreiche Daten auf ihrem Portal als Open Data veröffentlicht.

Wir haben die ausgewählten Daten in ArcGIS Pro aufbereitet und über ArcGIS Online zur Verfügung gestellt.

Folgende Feature Service sind nun als ready-to-use verfügbar:

  • GeoNetz
  • INSPIRE Netz
  • Reisezentren
  • Haltestellen
  • Bauwerke
  • Kilometrierung
  • Netzradar
  • Luftschadstoffkataster
  • Stuttgart 21

 

Die Daten sind in unserer ArcGIS Online Gruppe ESRI DE Open Data: DB oder im Esri Deutschland Open Data Portal zu finden.

The twitter API provides access not only to the timeline of users or for creating and publishing tweets but also to collect tweets in a certain area or with defined search items.

In this post I would like to show you, how to collect tweets in real time as well as "historic" tweets. By historic we need to state that it is not possible to access tweets older then 2 weeks by default.

The Prerequisites

First of all we will fetch tweets using Python and the tweepy library. To use the tweepy library we will embed this as a Python toolbox into ArcGIS Pro. Additionally you will need a twitter account and an app with keys.

Installing Tweepy

Unfortunately Tweepy is not listed in the ArcGIS Pro Python Package Manager. But the Tweepy library is hosted on git and can be either installed from source as well as by using pip/easy install. In the latter you simply type

pip install tweepy

In the former, clone the repo and install install it:

git clone https://github.com/tweepy/tweepy.git
cd tweepy
python setup.py install

I would recommend to use the pip-install as pip also enables you to install other libraries by this beautiful single line and keeps track of all Prerequisites needed for installing a library.

Getting the Keys

To get the needed keys to authenticate your application you will need to create an app at the developer section of Twitter.

This short video explains how:

Creating the Toolbox

To create a Python Toolbox is quite simple: Click on the "Toolbox" icon within the "Insert" ribbon and select "New Python Toolbox".

Once you've done this, you're able to customize the toolbox regarding the needs of the workflow.

The Python Logic

First: let us create the inputs for our tweet collecting nightmare. As the code needs keywords, the API keys and some more inputs we should decide whether some parameters should be able to customize on the frontend or not. The list of parameters is as follows:

  • keywords
  • extent
  • switch for historic/live tweets
  • location type (physical location or "place")
  • output feature class name
  • API keys from the created Twitter app

All the parameters could be part of the GUI but in fact the GUI will be connected to a certain APP-id on the twitter account and keys will not change on a regular basis. Therefore we will design the parameter section (function getParameterInfo) of our Python-toolbox as follows:

def getParameterInfo(self):
    '''Define parameter definitions'''
    hashtags = arcpy.Parameter(
        displayName='Search String',
        name='hashtags',
        datatype='GPString',
        parameterType='Optional',
        direction='Input')
    out_feature = arcpy.Parameter(
        displayName='Output Point Feature Class Name',
        name='out_feature',
        datatype='GPString',
        parameterType='Required',
        direction='Output')
    Extent = arcpy.Parameter(
        displayName='Extent',
        name='Lat',
        datatype='GPExtent',
        parameterType='Optional',
        direction='Input')
    locationType = arcpy.Parameter(
        displayName='Location Type',
        name='locType',
        datatype='GPString',
        parameterType='Required',
        direction='Input')
    locationType.filter.type = 'ValueList'
    locationType.filter.list = ['user location', 'place location']
    locationType.value = locationType.filter.list[0]
    collType= arcpy.Parameter(
        displayName='Collection Type',
        name='colType',
        datatype='GPString',
        parameterType='Required',
        direction='Input')
    collType.filter.type = 'ValueList'
    collType.filter.list = ['historic', 'real time']
    collType.value = collType.filter.list[0]
    numberOfTweets= arcpy.Parameter(
        displayName='Number of Tweets',
        name='numberOfTweets',
        datatype='GPLong',
        parameterType='required',
        direction='Input')
    numberOfTweets.value = 100
    timeForTweets= arcpy.Parameter(
        displayName='max. duration [s] of realtime stream',
        name='Duration',
        datatype='GPLong',
        parameterType='required',
        direction='Input')
    timeForTweets.value = 60 #the time to wait for new tweets
    params = [hashtags, out_feature, Extent, locationType, collType, numberOfTweets, timeForTweets]
    return params

Unfortunately we need to keep in mind that the streaming of tweets is only possible either by keywords or by location. Therefore we will validate our parameters:

def updateParameters(self, parameters):
    """Modify the values and properties of parameters before internal
    validation is performed. This method is called whenever a parameter
    has been changed."""

    if parameters[0].valueAsText and parameters[4].value=="real time":
        if parameters[2].value: #extent was set!
            parameters[0].value="" #use no keywords!
    return

As we do have the needed inputs we can have a look on the Tweepy magic.

Tweepy Authentication

As the plugin needs to work with Tweepy we will first check, whether or not the library is installed and:

def execute(self, parameters, messages):
    """The source code of the tool."""
    try:
        import tweepy
    except:
        arcpy.AddError("Tweepy was not found!")
    return

After the check is successful we can go ahead and authenticate ourselves against Twitter:

#setting the authentication:
consumerKey = "set your key here"
consumerSecret = "set your key here"
accessToken = "set your key here"
accessTokenSecret = "set your key here"
key = tweepy.OAuthHandler(consumerKey ,consumerSecret)
key.set_access_token(accessToken, accessTokenSecret)       
api = tweepy.API(key, wait_on_rate_limit=True,wait_on_rate_limit_notify=True) #access the API

Now we can access the Twitter API.

Some Arcpy Helper Functions

But as we are working with spatial data we might need some helping functions prior getting the tweets. As We will store the data in a feature class we will need at least a feature class creator as well as an add feature to feature class function. We will define them by ourselves:

def createFC(name):
      sr = arcpy.SpatialReference(4326)
      arcpy.CreateFeatureclass_management(arcpy.env.workspace, name, 'POINT',"", "", "", sr)
      arcpy.AddField_management(name, "username", "TEXT", "", "", 255, "username", "NON_NULLABLE", "REQUIRED")
      arcpy.AddField_management(name, "tweet", "TEXT", "", "", 255, "tweet", "NON_NULLABLE", "REQUIRED")
      arcpy.AddField_management(name, "time", "DATE", "", "", "", "time", "NON_NULLABLE", "REQUIRED")
      arcpy.AddField_management(name, "place", "TEXT", "", "", 255, "place_name", "NULLABLE", "NON_REQUIRED")
      arcpy.AddField_management(name, "id", "TEXT", "", "", 255, "id", "NON_NULLABLE", "REQUIRED") #unfortunately ids of tweets are veryyy long integers
      return

Now the add feature function:

def insertRecord(tuple, name):
      import os
      cursor = arcpy.da.InsertCursor(arcpy.env.workspace + os.sep + name,['username', 'tweet', 'time', 'place', 'id', 'SHAPE@XY'])
      try:
          cursor.insertRow(tuple)
      except Exception as e:
          arcpy.AddError(e)
      del cursor
      return

Now let's go back to the main function: we will create a new feature class with a distinct name by using the time stamp:

#create a featureClass:
import time
name = parameters[1].value + str(time.time()).split('.')[0] # we will only use the seconds since 01.01.1970
createFC(name)

As the feature class is ready to receive the data, let's apply the Tweepy logic.

Reading Historic Tweets

The main difference in our toolbox is whether or not we will apply a historic or real time view. Therefore we will first look at the historic part:

if parameters[4].value == "historic":
    arcpy.AddMessage("start: collecting historic tweets")
    tweetsPerQry = 100 # that is the maximum possible
    tweetCount = 0
    max_id = 0 # here is the id of the oldest tweet of the number of recieved tweets stored
    while tweetCount <= parameters[5].value:
        try:
            tweetInResponse = 0
            if (max_id <= 0):
                new_tweets = api.search(q=str(parameters[0].value), count=tweetsPerQry, geocode=geo)
            else:
                new_tweets = api.search(q=str(parameters[0].value), count=tweetsPerQry, geocode=geo, max_id=str(max_id - 1))
            max_id = new_tweets[-1].id # we will update the id number with the id of the oldest tweet
            for tweet in new_tweets:
                tweetInResponse += accessTweet(tweet, parameters[3].value, tweetCount, name)
        except:
            arcpy.AddError("no other tweets found!")
            tweetCount += 1
            break
        tweetCount += tweetInResponse

In line 10 and 12 we are evaluating the extent provided. So the extent will be provided with XMin, XMax, YMin and YMax values if you not select some layer or defined an input. The search API uses a "Lat,Lon,radius" approach. So we need to work with the input:

if parameters[2].value:
    rectangle = [[parameters[2].value.XMin,parameters[2].value.YMin],[parameters[2].value.XMin,parameters[2].value.YMax],[parameters[2].value.XMax,parameters[2].value.YMax],[parameters[2].value.XMax,parameters[2].value.YMin]]
    extent=arcpy.Polygon(arcpy.Array([arcpy.Point(*coords) for coords in rectangle])) #create a polygon from the extent
    arcpy.AddMessage("search in a region!")
    LL = arcpy.PointGeometry(arcpy.Point(parameters[2].value.XMin, parameters[2].value.YMin),arcpy.SpatialReference(4326))
    UR = arcpy.PointGeometry(arcpy.Point(parameters[2].value.XMax, parameters[2].value.YMax),arcpy.SpatialReference(4326))
    radius=UR.angleAndDistanceTo(LL, method="GEODESIC")[1]/2000 # describes a circle from LL to UR with radius half the size of inputs
    geo=str(extent.centroid.Y) + "," + str(extent.centroid.X) + "," + str(radius) + "km"
else :
    arcpy.AddMessage("worlwide search!") 
    geo=""

As you can see in line 15 of the "historic" logic, we will call a special function as all tweets we are gathering contain some sort of spatial information:

  • the location of the device
  • the place the user tagged when creating the tweet
  • the place a user defined in his profile

Most of the tweets contain only the profile location which is not very helpful in our use case. So we will loop through the received results (approx. 100) and insert each tweet in our feature class if it has place or location information:

def accessTweet(inTweet, locationType, resultingNumbers, name):
#tweets have three types of location: user, place, account. we are just interested in the first two.
    from datetime import datetime
    numberIncreaser = 0
    if locationType == "place location":             
        if inTweet.place != None:
        #places are displayed with bounding boxes:
            tweetTuple = (inTweet.user.name, inTweet.text, inTweet.created_at.strftime('%Y-%m-%d %H:%M'), inTweet.place.full_name, str(inTweet.id),((inTweet.place.bounding_box.coordinates[0][2][0] + inTweet.place.bounding_box.coordinates[0][0][0]) / 2, (inTweet.place.bounding_box.coordinates[0][2][1] + inTweet.place.bounding_box.coordinates[0][0][1]) / 2))
            insertRecord(tweetTuple, name)
            numberIncreaser = 1
    if locationType == "user location":        
        if inTweet.coordinates != None:
            #places are displayed with bounding boxes:
            tweetTuple = (inTweet.user.name, inTweet.text, inTweet.created_at.strftime('%Y-%m-%d %H:%M'), "device coordinates", str(inTweet.id),(inTweet.coordinates['coordinates'][0], inTweet.coordinates['coordinates'][1]))
            insertRecord(tweetTuple, name)
            numberIncreaser = 1
    return numberIncreaser

The numberIncreaser will tell our main function whether the tweet was a desired tweet according to our search parameters and will also insert the tweet in our feature class.

Real Time Tweets

We will use the same functions when searching for real time tweets. Yet the logic is a bit different:

if parameters[4].value == "real time":
    arcpy.AddMessage("start: collecting real time tweets")
    start_time = time.time() #start time
    class stream2lib(tweepy.StreamListener):
        def __init__(self, api=None):
            #api = tweepy.API(key)
            self.api = api
            self.n = 0
        def on_status(self, status):
            if status.geo != None and parameters[3].value == 'user location':
                self.n = self.n+1
                arcpy.AddMessage(str(self.n) + " tweets received...")
                arcpy.AddMessage(str(time.time() - start_time) + "s from " + str(parameters[6].value) + "s")
                accessTweet(status, parameters[3].value, self.n, name)
            if status.place != None and parameters[3].value == 'place location':
                self.n = self.n+1
                arcpy.AddMessage(str(self.n) + " tweets received...")
                arcpy.AddMessage(str(time.time() - start_time) + "s from " + str(parameters[6].value) + "s")
                #arcpy.AddMessage(status)
                accessTweet(status, parameters[3].value, self.n, name)
            if self.n >= parameters[5].value:
                arcpy.AddMessage("Desired number of tweets collected!")
                return False
            if (time.time() - start_time) >= parameters[6].value:
                arcpy.AddMessage("Time limit of " + str(parameters[6].value) + "s reached!" )
                return False
            if self.n < parameters[5].value:   
                return True
    stream = tweepy.streaming.Stream(key, stream2lib())
    if parameters[2].value:
        stream.filter(locations=[parameters[2].value.XMin,parameters[2].value.YMin,parameters[2].value.XMax,parameters[2].value.YMax])
    else:
        stream.filter(track=[parameters[0].value])

In the end you can gather tweets for your very own purpose but keep in mind: around 0.1% have some proper location information and the Tweepy API does not provide access to the firehose but to 1% of the full Twitter stream. Also keep in mind that you might collect also bots with the same location for every tweet (two radio stations are tweeting their playlist in Berlin ).

But you might get some really cool visuals:

If you want to work with the toolbox grab it from git. You can also work with the static version attached here.

Urlaub war traumhaft. Wenn auch nur in diversen Reiseblogs – visuell. Also digital. Aber eben nur abends. Aber immerhin.


So, Esri hat den „Plus“-Zugang zur Maps for Power BI freigeschaltet.

„Und was bringt mir der?“ wird sich nun der eine oder andere fragen.


Vor allem für BI-Anwender, die bisher noch nicht so viel Erfahrung mit GIS gemacht haben, bietet „Plus“ einen einfachen und tollen Einblick in die vielfältigen Möglichkeiten der GIS-Welt (bei Esri).

 

Plus subscriben

Standardmäßig können ja bereits vier Grundkarten im Esri-Power BI Visual verwendet werden. Jetzt kommen noch weitere acht hinzu, darunter Satellitenbilder und eine Geländekarte. Somit kann man seine Punkte oder Flächen nun auf einer besseren Kartengrundlage analysieren.

 

Heatmap Raster


Weiterhin können mehr Punkte on-the-fly geogecodet werden. Bei der kostenlosen Version sind dies 1.500 Punkte pro Karte, bei Plus sogar 5.000. Adresseinträge in Datasets werden also ohne Mehrkosten verortet. Das ist doch was.

 

Matrix

 

Zudem stehen dem geneigten Anwender die Daten aus dem Esri Living Atlas zur Verfügung. Dort findet sich eine Vielzahl an Daten, Apps und sonstigen Geo-relevanten Datensätzen, die auch in Power BI eingebunden werden können.


Zu guter Letzt können in den Infografiken nun auch Daten weltweit abgerufen werden: darunter so spannende Informationen wie Ausgaben für Konsumgüter, Haushaltseinkommen oder Altersstufen pro PLZ-Gebiet.

Living Atlas in Power BI Plus

Ein sehr interessantes Angebot wie ich finde, um sowohl die Datengrundlagen die Esri bietet, erst mal kennen zu lernen, als auch einen einfachen Einstieg in die weite GIS-Welt zu bekommen. Und die ist ja bekanntlich schön und weit...

 

großes GIS-Welt

 

Plus kann 60 Tage lang getestet werden. Dazu muss nur eine Kreditkarte im eCommerce-Shop bei Esri hinterlegt werden. Wenn es nicht gefällt, und man innerhalb der 60 Tage kündigt, entstehen auch keine Kosten. Ah, hatte ich schon erwähnt, dass die vielfältigen Datengrundlagen in „Plus“ für nur $5 im Monat zu haben sind?

 

what?

Am 10. und 11. November fand in Münster der erste MÜNSTERHACK statt. Zu diesem Hackathon (MÜNSTERHACK - Hackathon für Münster ) kam die Tech-Szene in Münster zusammen und entwickelte gemeinsam Ideen und Prototypen, um die eigene Stadt noch lebenswerter zu machen. Insgesamt neun Ideenpitches wurden vorgestellt und anschließend in Gruppen bearbeitet. Begleitet wurden die Teilnehmer durch elf Mentoren von lokalen Unternehmen (u.a. auch Esri), die die Teams bei organisatorischen, technischen oder kaufmännischen Fragen unterstützten.

 

Am Ende der Veranstaltung am 11.11. (Helau! ) kamen alle Teilnehmer und Zuschauer zu einer großen Abendveranstaltung in den Räumen der Stadtwerke Münster zusammen, um die Ergebnisse zu präsentieren und die Sieger zu küren. Neben Ruhm und Ehre (und möglichen Folgeaktionen) gab es auch Geldpreise zu gewinnen.

 

Am Ende enschied sich die Jura für folgende Sieger des #MSHACK17:

 

1. Bus Reality

Die App berechnet aus den Soll- und Ist-Fahrtzeiten der städtischen Busse die aktuelle Verspätung und bietet zusätzlich die Möglichkeit, auch Prognosen für zukünftige Verspätungen unter Berücksichtigung von Wetter, Verkehr und Events zu berechnen. Als besonderes Feature wurde eine Augmented Reality Funktion entwickelt, die dem App Benutzer beim Warten vor einer Bushaltestelle die aktuellen Fahrgastinformationen und Verspätungen auf einer virtuellen Anzeigetafel live auf dem Kamerabild des Smartphones anzeigt.

 

2. Leih Leeze

Das Team der Leih Leeze entwickelte eine App, mit der Privatpersonen ihr Fahrrad ("Leeze") im Internet für Besucher oder Touristen anbieten können. Mit wenigen Klicks wird das Rad eingestellt und ist via Smartphone App sofort für jeden sichtbar. Eine integrierte Abrechnungsfunktion sorgt für die reibungslose Zahlung. Als Highlight wurde ein Alexa Skill entwickelt, mit dem man das Fahrrad auch via Spracheingabe suchen und reservieren kann.

 

3. Familen Dashboard

Das Familien Dashboard ist eine Informations-App für Bürger auf Stadtteilebene. Bürger können sich damit über aktuelle Baumaßnahmen, Veranstaltungen und Ereignisse in ihrem Viertel informieren. Das Highlight dieser App war vor allem die Nutzung von Open (Geo)Data als Datengrundlage.

 

Herzlichen Glückwunsch an alle Gewinner! 

Im Juli 2017 wurde das Major Release 2.0 des AppStudio for ArcGIS in einem neuen Look & Feel und mit aktualisierten Werkzeugen, verbesserten App-Templates und neuen App-Template-Samples veröffentlicht. Nun ist die Version 2.1 mit weiteren Neuerungen und Verbesserungen verfügbar.

 

Neuigkeiten in AppStudio 2.1 (Auszug)

  • Unterstützt nun Universal Windows Platform (UWP)
  • Neues Community-Panel in AppStudio Desktop
  • Aktualisierte AppStudio-Templates
  • Neue AppFramework Plugins (Beta):
    • Biometrische Authentifizierung
    • Sichere Speicherung
    • Hochpräzise Positionierung
    • Interapp Communication (Text und URLs mit anderen Anwendungen austauschen)
  • AppStudio Player unterstützt biometrische Authentifizierung und integrierte Windows-Authentifizierung (IWA)
  • mehr...

 

      Neues Community-Panel in AppStudio Desktop

 

 

Ausführliche Informationen zu den Neuerungen von AppStudio for ArcGIS Version 2.1 findet Ihr in diesem News Blog von Esri Inc. und in der AppStudio GeoNet Gruppe.

PostgreSQL Datenbanken können durch die Implementierung der PostGIS Erweiterung um geografische Objekte und Funktionen ergänzt werden. 

 

Aber wie kann eine bestehende PostGIS Datenbank in einer ArcGIS-Umgebung eingebunden und genutzt werden?

Wie wird eine Enterprise Geodatabase mit PostGIS erstellt?

Was passiert mit meiner PostGIS Datenbank und meinen Daten, wenn ich aus diese in eine Enterprise Geodatabase umwandel?

 

Die Lösung zur ersten Frage rund um die Nutzung von vorhandene PostGIS Datenbank mit ArcGIS Pro und ArcGIS Enterprise kann in diesem ArcGIS Blogeintrag nachgelesen werden.

 

In diesem Blog wird kurz die Erstellung einer Enterprise Geodatabase mit PostGIS und den Unterschied zwischen dieser und der "Standard" - PostGIS erläutert.

 

Dazu sehen wir uns erstmal eine PostGIS Datenbank in pgAdmin III und in ArcGIS Pro an:

 

                        pgAdmin III                                                                        ArcGIS Pro

 

In den oben dargestellten Abbildungen, ist der Datenbankname „postgis_only“, die Schemas ‚public‘, ‚tiger‘, ‚tiger_data‘, ‚topology‘ (nur in pgAdmin) und Tabellen zu erkennen. Des Weiteren sind in pgAdmin III die Funktionen, die Trigger und die Sichten der PostGIS Erweiterung zu sehen.

 

Um aus der Standard PostGIS Datenbank eine Enterprise Geodatabase zu erstellen, muss in ArcGIS Pro das Datamanagement Tool „Create Enterprise Geodatabase“ ausgeführt werden.

 

 

Im Zuge der Konfiguration erstellt das Tool eine neue Rolle „sde“ und ein neues Schema „sde“ mit dazugehörigen Systemtabellen, Sichten, Funktionen und Prozeduren.

 

 

Das vorhandene Schema „public“ bleibt bestehen und die enthaltenen Geodaten können weiterhin genutzt werden. Wenn neue Daten in die konfigurierte Enterprise Geodatabase kopiert werden, werden diese aber automatisch ins Schema „sde“ geschrieben!

 

 

In der Abbildung sind die Geodaten (glascontainerbuffer) zu erkennen die vor der Enterprise Konfiguration vorhanden sind, diese liegen im Schema "public" (public.glascontainerbuffer) und die Geodaten (z.B. glascontainer) die erst nach der Konfiguration erstellt oder kopiert wurden, diese liegen im Schema "sde" (sde.glascontainer).

 

Damit ist  geklärt wie eine Enterprise Geodatabase aus einer PostGIS erstellt wird, was mit den vorhandenen Daten bei der Konfiguration passiert, was der Unterschied zwischen den beiden Datenbanken ist und wie diese in die ArcGIS Plattform eingebunden werden können!

 

Weitere Informationen:

Blog: "Integration von PostGIS Datenbanken in die ArcGIS Plattform"

Kurzvideos:  

"Herstellung einer Verbindung mit PostgreSQL von ArcGIS Pro"

 

"Schnelles Kopieren von Daten in eine verbundene PostgreSQL mit ArcGIS Pro"

 

"Registrierung einer PostgreSQL Datenbank im ArcGIS Server"

Filter Blog

By date: By tag: