Um den Public Preview von ArcGIS GeoAnalytics for Microsoft Fabric einzuläuten, werden wir eine Reihe von Blogbeiträgen veröffentlichen, die die Funktionalität von GeoAnalytics for Fabric erkunden. In diesem Beitrag werden wir die Grundlagen der Berechnung / Konstruktion neuer Geometrien wie Puffer, räumliche Bins und kürzeste Pfade untersuchen. Wir werden auch die Berechnung von Eigenschaften wie Länge und Fläche dieser neuen Geometrien betrachten.
Importieren von GeoAnalytics for Fabric
Wir beginnen mit einer Auffrischung, wie man GeoAnalytics for Fabric importiert und damit arbeitet. Um GeoAnalytics for Fabric zu importieren, müssen Sie einfach import geoanalytics_fabric in eine Zelle Ihres Notebooks einfügen. Weitere Informationen zur Aktivierung der Bibliothek finden Sie in der Getting started documentation.
Zur Vereinfachung empfehlen wir außerdem, die geospatial functions direkt zu importieren und ihnen einen leicht zu verwendenden Alias zur Referenz zu geben. Im folgenden Beispiel importieren wir die Bibliothek und die Funktionen mit dem Alias ST. Da jede der Funktionen ST.<function_name> heißt, sind sie leicht referenzierbar und als Spatial Type (ST) Funktionen erkennbar. Dies entspricht auch der Struktur der Beispiele in der gesamten ArcGIS GeoAnalytics Dokumentation. Ihre Zelle sieht dann so aus:
# import ArcGIS GeoAnalytics
import geoanalytics_fabric
import geoanalytics_fabric.sql.functions as ST
Zum Beispiel könnten Sie nach dem Import die ST_Buffer Funktion mit ST.buffer anstatt mit geoanalytics_fabric.sql.functions.bufferreferenzieren.
Berechnung neuer Geometrien
GeoAnalytics for Fabric enthält eine Reihe räumlicher Operationen zur Erzeugung neuer Geometrien basierend auf den Eingaben. Zum Beispiel werden wir in diesem Beitrag einige gängige Funktionen erkunden:
Während wir einige Funktionen im Detail betrachten, gibt es viele weitere in der GeoAnalytics for Fabric Bibliothek, die für Ihre Analyseprojekte interessant sein könnten. Sie können das Spektrum der Funktionen in der Dokumentation der SQL Functions erkunden.
Lassen Sie uns mit einigen Puffern beginnen!
ST_Buffer & ST_GeodesicBuffer
ST_Buffer und ST_GeodesicBuffer erstellen Polygone, die den Bereich darstellen, der kleiner oder gleich der angegebenen Entfernung um die Eingabegeometrie ist (z.B. die Region innerhalb von 10 Meilen um einen Punkt). Diese Funktionen erzeugen diesen Puffer um jede Entität in der Geometriespalte.
Um zu sehen, wie das funktioniert, beginnen wir damit, ein neues DataFrame mit einigen Schulstandorten im Raum Boston zu erstellen. Wir werden diese puffern, um visuell den Bereich um jede Schule zu betrachten. Hier ist ein Beispiel für das Erstellen eines neuen DataFrames mit einigen Punktstandorten:
# create a DataFrame with locations of several schools (in latitude and longitude)
df_schools = spark.createDataFrame([
(-71.0777, 42.3388, "Hurley K-8"),
(-71.0919,42.3176, "Higginson Elementary School"),
(-71.1016, 42.3164, "Mendell Elementary School")], ["longitude", "latitude", "name"])
# create a point geometry column ("geometry") from the latitude and longitude values
df_schools = df_schools\
.withColumn("geometry", ST.point("longitude", "latitude", sr=4326))
Hier sind die Ergebnisse:
Jetzt können wir Puffer um diese Schulen erstellen.
Die Entfernungseinheit für den Puffer entspricht den Einheiten der Eingabegeometrie. Wenn zum Beispiel die Daten im Web Mercator Koordinatensystem vorliegen, sind die Einheiten Meter; wenn Ihre Daten in einem geografischen Koordinatensystem vorliegen, sind die Einheiten Dezimalgrade.
Die ST_GeodesicBuffer Funktion kann verwendet werden, um Puffer unter Verwendung geodätischer Entfernungen in Metern zu erstellen. Lassen Sie uns einige Puffer erstellen und sie ansehen - und sehen, wie sich der planare Puffer und der geodätische Puffer unterscheiden.
# create example buffers using ST_Buffer and ST_GeodesicBuffer
# This example generates a buffer of 0.5 _decimal degrees_ (the units for the input data are latitude/longitude values!)
# It also created a geodesic buffer of 500 meters
df_schools = df_schools\
.withColumn("geometry_buffer", ST.buffer("geometry", 0.5))\
.withColumn("geometry_geodesic_buffer", ST.geodesic_buffer("geometry", 500))
Zuerst betrachten wir den planaren Puffer - dieser wurde in den Einheiten der Eingabegeometrie (Dezimalgrade) berechnet. Dies ist ein 0,5 Dezimalgrad-Puffer um die drei Schulen:
Beachten Sie, dass ich die Achsenbeschriftungen auf der Karte belassen habe, damit Sie sehen können, dass dies auf einer Basiskarte in Dezimalgraden dargestellt wird.
Und nun betrachten wir die geodätischen Puffer um die Schulen. Beachten Sie, dass auch dies auf einer Basiskarte in Dezimalgraden dargestellt wird. Wir sehen, dass die Puffer viel kleiner sind (500 m um jede Schule) und nicht kreisförmig sind. Lassen Sie uns erkunden warum das so ist...
Beim Plotten dieser Puffer gibt es einige wichtige Dinge zu beachten:
- Die Puffer im ersten Diagramm wirken riesig, während die Puffer im zweiten viel kleiner sind. Der "geometry_buffer" beträgt eine halbe Dezimalgrad-Einheit, während der "geometry_geodesic_buffer" nur 500 Meter beträgt. Ein Dezimalgrad ist deutlich länger als 500 Meter. Am Äquator entspricht ein Grad Breite oder Länge etwa 111 Meilen!
- Die Puffer im ersten Diagramm ("geometry_buffer") wirken kreisförmig, während die Puffer im zweiten Diagramm ("geometry_geodesic_buffer") oval aussehen. Warum ist das so? Beide Karten wurden generiert auf einer Karte basierend auf den Breiten- und Längengradkoordinaten. In diesen Darstellungen entspricht ein Grad Breite einer Länge von einem Grad Länge. Auf der Erde unterscheiden sich die Längen eines Breitengrades und eines Längengrades, wobei ein Längengrad immer kürzer wird, je näher man den Polen kommt. Der Wikipedia-Eintrag zu <\/SPAN>Longitude<\/A> <\/SPAN>erklärt dies ausführlich, falls Sie mehr Informationen wünschen. Wenn die geodätischen Puffer auf dieser speziellen Kartenprojektion dargestellt werden, erscheinen sie als ovale Formen, obwohl sie auf der Erdoberfläche kreisförmig wären.<\/LI><\/UL>Wenn wir den geodätischen Puffer in unserem lokalen Boston-Koordinatensystem (SRID 2249) darstellen würden, sehen die Puffer wie die erwarteten Kreise aus.<\/P>Wir können die Karte beim Plotten aktualisieren, indem wir einen <\/SPAN>sr<\/FONT> <\/SPAN>(räumlicher Bezug) Parameter hinzufügen. Der Beispielcode unten zeigt dies. Weitere Informationen zu den Parametern für <\/SPAN>st.plot<\/FONT> <\/SPAN>finden Sie in der <\/SPAN>API-Referenz<\/A>.<\/P>
<\/P>
# Darstellung des geometry_geodesic_buffer auf einer Karte mit räumlichem Bezug 2249
df_schools\\
.st.plot(basemap="streets", geometry="geometry_geodesic_buffer", alpha=0.5, edgecolor="black", sr=2249);<\/code><\/pre><P> <\/P><P>Im Allgemeinen ist es schneller, <SPAN> <A href="https:\/\/developers.arcgis.com\/geoanalytics-fabric\/sql-functions\/st_buffer\/" target="_blank" rel="noopener nofollow noreferrer">ST_Buffer<\/A><SPAN> </SPAN>als <SPAN> <A href="https:\/\/developers.arcgis.com\/geoanalytics-fabric\/sql-functions\/st_geodesic_buffer\/" target="_blank" rel="noopener nofollow noreferrer">ST_GeodesicBuffer<\/A><SPAN> </SPAN>auszuführen, da die Puffer mit planaren Koordinaten anstelle von geodätischen Koordinaten berechnet werden. Dies bedeutet jedoch, dass Sie vor der Verwendung von <SPAN> <A href="https:\/\/developers.arcgis.com\/geoanalytics-fabric\/sql-functions\/st_buffer\/" target="_blank" rel="noopener nofollow noreferrer">ST_Buffer<\/A> ein geeignetes lokales Koordinatensystem auswählen sollten.<\/P><P>Zum Beispiel können wir die auf Breiten- und Längengrad basierenden Punkte in ein lokales Koordinatensystem wie das Massachusetts State Plane Coordinate System (SRID: 2249) transformieren und dann unsere Puffer erstellen. Dies können wir mit der Funktion <SPAN> <A href="https:\/\/developers.arcgis.com\/geoanalytics-fabric\/sql-functions\/st_transform\/" target="_blank" rel="noopener nofollow noreferrer">ST_Transform<\/A><SPAN> </SPAN>im Rahmen der Puffererstellung tun. Hier zeigen wir ein Beispiel dafür:<\/P><P> <\/P><pre class="lia-code-sample language-python"><code># Erstellen von 500-Fuß-Puffern um die Schulkoordinaten mit einem lokalen Koordinatensystem
df_schools = df_schools\\
.withColumn("geometry_buffer_2249", ST.buffer(ST.transform("geometry", 2249), 500))<\/code><\/pre><P> <\/P><P>Beim Transformieren von Daten zwischen Koordinatensystemen ist es wichtig, die verwendeten Einheiten zu kennen. In diesem Fall sind die Einheiten Fuß. Sie können dies auf einer Website wie <SPAN> <A href="https:\/\/spatialreference.org\/" target="_blank" rel="noopener nofollow noreferrer">SpatialReference.org<\/A> nachschlagen. Hier ist der Eintrag für <SPAN> <A href="https:\/\/spatialreference.org\/ref\/epsg\/2249\/" target="_blank" rel="noopener nofollow noreferrer">SRID 2249.<\/A><\/P><P>Wir können diese Puffer dann darstellen und den Unterschied auf der Karte sehen. Beachten Sie, dass die Einheiten auf der Achse unterschiedlich sind - weil unsere Daten jetzt im Massachusetts State Plane Coordinate System (SRID: 2249) vorliegen.<\/P><P> <\/P><pre class="lia-code-sample language-python"><code># Darstellung des in Fuß berechneten Puffers
df_schools.st.plot(basemap="streets", geometry="geometry_buffer_2249", alpha=0.5, edgecolor="black");<\/code><\/pre><P> <\/P><P><span class="lia-inline-image-display-wrapper lia-image-align-inline" image-alt="SBattersby_4-1741106542832.png" style="width: 400px;"><img src="https:\/\/us.v-cdn.net\/_6038851\/_uploads\/_images\/_126900iA0731B9871062349\/_SBattersby_4-1741106542832.png" role="button" title="SBattersby_4-1741106542832.png" alt="SBattersby_4-1741106542832.png" \/></span><\/P><P>Jetzt, wo wir schöne Puffer haben, machen wir eine kleine Zwischenstation, bevor wir mit der Berechnung anderer interessanter Geometrien fortfahren. Schauen wir uns schnell an, wie wir diese Puffer für Analysen verwenden können.<\/P><P>Wir verwenden die Puffer, um 311 öffentliche Serviceanfragen aus der Stadt Boston zu identifizieren, die sich in der Nähe jeder Schule befinden. Zur Demonstration verwenden wir <SPAN>einen Datensatz von </SPAN><A href="https:\/\/learn.microsoft.com/en-us/azure/open-datasets/dataset-boston-safety" target="_blank" rel="noopener nofollow noreferrer">öffentlichen Sicherheitsdaten der Stadt Boston, MA<\/<A>} target="_blank" rel="noopener nofollow noreferrer">ST_H3Bin</A><SPAN> </SPAN>Funktion zur Identifizierung des<SPAN> </SPAN><A href="https://h3geo.org/" target="_blank" rel="noopener nofollow noreferrer">H3 bin</A><SPAN> </SPAN>, in dem sich jeder unserer Serviceanfragepunkte befindet. Anschließend verwenden wir eine PySPark<SPAN> </SPAN><A href="https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.groupBy.html" target="_blank" rel="noopener nofollow noreferrer">GroupBy</A><SPAN> </SPAN>Funktion, um ein vereinfachtes DataFrame zu erstellen, das die Anzahl der Punkte in jedem Bin auflistet.</P><P>Die Größe der H3 bins basiert auf einem Auflösungswert. Für dieses Beispiel verwenden wir eine Auflösung von 8, was einer durchschnittlichen hexagonalen Bin-Größe von 0,73 Quadratkilometern entspricht. Weitere Informationen zu<SPAN> </SPAN><A href="https://h3geo.org/docs/core-library/restable" target="_blank" rel="noopener nofollow noreferrer">H3 bin Auflösungen finden Sie hier</A>.</P><P>Das Hinzufügen der ID für einen Bin ist so einfach wie das Erstellen einer neuen Spalte für die Daten und die Verwendung der Bin-Funktion für den gewünschten Geometrietyp (hexagonal, quadratisch oder H3):</P><P> </P><pre class="lia-code-sample language-python"><code># füge eine Spalte mit der H3 bin _id_ hinzu, in der jeder Punkt liegt
df = df\
.withColumn("h3_bin", ST.h3_bin("geometry", 8))
Die
ST_H3Bin Funktion fügt jedem Datensatz eine bin id hinzu. Sie fügt nicht speziell die Geometrie hinzu, da es viele Duplikate der Geometrie geben würde (eines für jeden Punkt im Bin) und es effizienter ist, mit der ID zu arbeiten, bis wir die Geometrien für Analyse oder Visualisierung benötigen. Wir können diese neuen Bin-IDs in der untenstehenden Tabelle sehen:
Mit dem h3_bin ID-Feld können wir dann die Werte in unserer Tabelle gruppieren, um die Anzahl der Datensätze in jedem Bin zu zählen. # gruppiere das Serviceanfragen DataFrame nach der h3 bin ID und zähle alle Datensätze
df_by_bin = df.groupBy("h3_bin").count() Nach dem Gruppieren sehen wir, dass jede Bin-ID eine Anzahl der darin enthaltenen Punkte hat. Danach können wir die Bin-IDs in Geometrien umwandeln und die Ergebnisse visualisieren.
So fügen wir die Bin-Geometrie mit der ST_BinGeometry-Funktion in die Tabelle ein: # füge die Bin-Geometrie basierend auf der Bin-ID mit ST_BinGeometry hinzu
df_by_bin = df_by_bin\
.withColumn("geometry_bin", ST.bin_geometry("h3_bin")) Die Darstellung der Ergebnisse zeigt uns nun, wo die höchste Konzentration von Serviceanfragen liegt:
Kommen wir nun dazu, einige Linien und Entfernungen zwischen Standorten zu berechnen!ST_ShortestLine und ST_GeodesicLineST_ShortestLine gibt eine Linienstring-Spalte zurück, die die kürzeste Linie darstellt, welche zwei Geometrien berührt, unter Verwendung einer planaren Distanzberechnung. Diese Funktion gibt nur eine kürzeste Linie zurück, wenn mehr als eine zwischen den Standorten berechnet werden kann.Um eine kürzeste Linie unter Verwendung geodätischer Distanzberechnungen zu erstellen, verwenden Sie ST_GeodesicShortestLine.Als Beispiel betrachten wir die kürzeste Linie zwischen dem zuvor erstellten DataFrame "schools" und den nahegelegenen Serviceanfragen. Die kürzeste Linie verwendet zwei Geometriespalten als Eingabe, daher müssen sie im gleichen DataFrame sein.In den obigen Buffer-Beispielen haben wir ST_Contains verwendet, um alle Punkte innerhalb des Buffer-Polygons zu finden.In diesem Beispiel verwenden wir eine weitere räumliche Berechnung namens ST_DWithin(Abstand innerhalb), um alle Punkte innerhalb eines bestimmten Abstands von den Schulpunkten zu finden. Effektiv kann dies dasselbe Ergebnis liefern, jedoch ist DWithin oft leistungsfähiger als das Erstellen eines Buffers und das Durchführen eines räumlichen Joins. DWithin verwendet standardmäßig planare Berechnungen, daher sollten wir entweder die Geometrie in ein lokales Koordinatensystem transformieren oder den Parameter so einstellen, dass geodätische Berechnungen verwendet werden.In diesem Fall verwenden wir ST_Transform, um das Koordinatensystem für diese Berechnung zu aktualisieren. Wir machen dies in einer einzigen Berechnung, bei der wir die Schulen und Serviceanfragen verbinden und ein neues DataFrame mit den Ergebnissen erstellen: # finde alle Punkte innerhalb von 500 Fuß von jeder Schule
# verwende einen räumlichen Join, um jeden Punkt zu finden, der innerhalb des angegebenen Abstands zur Schule liegt
# da die Datensätze ursprünglich in Breiten-/Längengradkoordinaten vorliegen, transformieren wir zuerst in ein lokales Koordinatensystem
df_schools_requests = df.join(df_schools.select("name", F.col("geometry").alias("geometry_school")),
ST.dwithin(ST.transform("geometry", 2249), ST.transform("geometry_school", 2249), 500)) Da nun jede Schule sowohl die Geometrie der Schule als auch die nahegelegenen Punkte hat, können wir diese beiden Geometrien verwenden, um die kürzeste Linie zwischen jedem Serviceanfragepunkt und der Schule zu berechnen. # berechne die kürzeste Linie von jedem Punkt zu jeder Schule
df_schools_requests = df_schools_requests\
.withColumn("geometry_line", ST.shortest_line("geometry", "geometry_school")) Werfen wir einen Blick auf das Ergebnis für eine Schule: # zeichne die Verbindungsleitungen zwischen einer Schule und allen Punkten innerhalb von 500 Fuß dieses Standorts
df_schools_requests.filter(F.col("name") == "Hurley K-8").st.plot(basemap="streets", geometry="geometry_line", linewidth=0.5, alpha=0.7); 
Für kurze Entfernungen ist ST_ShortestLine eine gute Wahl, aber für längere Entfernungen sollten Sie vielleicht ST_GeodesicShortestLine verwenden, damit die erstellte Linie den kürzesten Weg auf der Kugel darstellt. Als Beispiel für den Unterschied zwischen der "kürzesten Linie" (planare Berechnung) und der geodätischen Linie können wir den Unterschied zwischen einer Verbindungslinie zwischen Los Angeles und London untersuchen. In diesem Beispiel erscheint die geodätische Linie (orange) gekrümmt und länger in dieser Projektion, aber sie ist tatsächlich die kürzeste Linie!
# geodätische Linie (geodesic) (in orange) vs. "kürzeste Linie" (planar) (in blau)
# die geodätische Linie erscheint gekrümmt und länger in dieser Projektion, ist aber tatsächlich die kürzeste!
# erstelle Punkte für zwei Standorte
data = [
("POINT (-118.2426 34.0549 )", "Los Angeles",
"POINT (0.1276 51.5072 )", "London")
]
# Erstellen Sie ein DataFrame mit den beiden Standorten
# Konvertieren Sie die Standorte von Well-Known Text in Geometrie
df_lines = spark.createDataFrame(data, ["wkt-origin", "city-origin", "wkt-dest", "city-dest"])\
.select("city-origin",
"city-dest",
ST.geom_from_text("wkt-origin", 4326).alias("geometry-origin"),
ST.geom_from_text("wkt-dest", 4326).alias("geometry-dest"))
# Plotten Sie die Ergebnisse, um die beiden generierten Linien zu vergleichen (geodätisch vs. kürzeste)
myplt = df_lines.select(ST.geodesic_shortest_line("geometry-origin", "geometry-dest")).st.plot(basemap="light", figsize=(10,10), color="orange")
df_lines.select(ST.shortest_line("geometry-origin", "geometry-dest")).st.plot(ax=myplt);
Entfernungs- und Längenberechnungen
Schauen wir uns nun Entfernung und Länge für diese Linien an...
- ST_Distance und ST_GeodesicDistance berechnen die Entfernung zwischen zwei Eingabestandorten. Die Einheit für ST_Distance ist dieselbe wie bei den Eingabegeometrien. Für ST_GeodesicDistance wird die Entfernung in Metern berechnet.
- ST_Length und ST_GeodesicLength berechnen die Länge eines Eingabeobjekts. Die Einheit für ST_Length ist dieselbe wie bei der Eingabegeometrie. Für ST_GeodesicLength wird die Länge in Metern berechnet.
Wir werden uns diese Berechnungen anhand der zuvor generierten Linien ansehen, die Schulstandorte mit nahegelegenen Serviceanfragen verbinden.
Mit der Entfernungsberechnung können wir auch eine besonders nützliche Funktion der GeoAnalytics-Bibliothek betrachten – Projektion on the fly. Wenn Sie eine Eigenschaft oder Beziehung mit zwei Geometrien berechnen möchten, die sich in unterschiedlichen Koordinatensystemen befinden, kann die Bibliothek diesen Unterschied oft für Sie ausgleichen, sodass Sie die Daten nicht transformieren müssen.
- Die geometry-Spalte (Serviceanfragen) befindet sich im Massachusetts State Plane Koordinatensystem (SRID 2249)
- Die geometry_school-Spalte (Schulstandorte) befindet sich in WGS84 Breiten- und Längengrad (SRID 4326)
Verwenden wir diese beiden Geometrien und berechnen verschiedene Entfernungen, um zu sehen, wie GeoAnalytics mit Geometrien in unterschiedlichen Koordinatensystemen arbeiten kann! In der folgenden Zelle berechnen wir:
- Entfernung zwischen den beiden Geometrien ohne Transformation der Koordinaten
- Entfernung zwischen den beiden Geometrien mit einer Transformation, um die geometry_school in Massachusetts State Plane (2249) zu konvertieren
- Geodätische Entfernung zwischen den beiden Geometrien ohne Transformation
Wir werden auch die Länge der Linie geometry_line berechnen, die wir zuvor erstellt haben, um die beiden Punktstandorte zu verbinden. Wir führen diese Berechnungen durch und zeigen die Ergebnisse als Beispiel an:
display(
df_schools_requests.select("geometry",
"geometry_school",
F.round(ST.distance("geometry", "geometry_school"), 2).alias("Entfernung (ohne Transformation)"),
F.round(ST.distance("geometry", ST.transform("geometry_school", 2249)),2).alias("Entfernung (mit Transformation)"),
F.round(ST.geodesic_distance("geometry", "geometry_school"),2).alias("Geodätische Entfernung (Meter)"),
"geometry_line",
F.round(ST.length("geometry_line"),2).alias("Länge (Fuß)"),
F.round(ST.geodesic_length("geometry_line"),2).alias("Geodätische Länge (Meter)")
)
)
Dies zeigt, wie Sie diese Berechnungen durchführen können, selbst mit Geometrien in unterschiedlichen Koordinatensystemen! GeoAnalytics for Fabric ist hervorragend darin, Unterschiede in Koordinatensystemen wo immer möglich auszugleichen.
Kommen wir nun zu einem letzten Blick auf einige Eigenschaften, die wir berechnen können, und erkunden das Thema Fläche.
ST_Area und ST_GeodesicArea
ST_Area - berechnet eine planare Fläche für jede Geometrie. Die Flächeneinheit entspricht der Einheit der Eingabegeometrien. Wenn Sie Fläche auf einem Datensatz in einem geografischen Koordinatensystem berechnen, sind die Einheiten Quadratgraddezimal. Dies ist keine empfohlene Einheit. Für die Verwendung der Funktion ST_Area ist es am besten, ein projiziertes Koordinatensystem zu verwenden. Weitere Informationen finden Sie im Dokument zum Kernkonzept Koordinatensysteme und Transformationen.
ST_GeodesicArea berechnet die Fläche jeder Geometrie in Quadratmetern und erfordert, dass eine räumliche Referenz auf der Eingabegeometriespalte gesetzt ist.
Für dieses Beispiel werden wir Flächen für US-Bundesstaaten berechnen, die wir von einem ArcGIS Feature-Service eingelesen haben.
# US-Bundesstaaten Feature-Service aus dem Esri Living Atlas of the World
# Für weitere Informationen zu diesem Datensatz: https://www.arcgis.com/home/item.html?id=774019f31f8549c39b5c72f149bbe74e
fs_url = "https://services.arcgis.com/P3ePLMYs2RVChkJx/arcgis/rest/services/USA_Census_States/FeatureServer/0"
df_states = spark.read.format('feature-service').load(fs_url)
Bevor wir die Fläche berechnen, sollten wir das Koordinatensystem der Daten überprüfen, damit wir mehr über die verwendeten Einheiten wissen und entscheiden können, ob wir ST_Area oder ST_GeodesicArea verwenden wollen. Dies können wir mit der Funktion get_spatial_reference() tun.
df_states.st.get_spatial_reference()
Dies gibt Informationen zurück, dass die Daten eine SRID von 4326 (WGS84-Koordinatensystem) haben.
SpatialReference(srid=4326, is_projected=False, unit='Degree', wkt='GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]')
Für diesen Datensatz betrachten wir die Werte, die durch ST_Area und ST_GeodesicArea berechnet werden.
Im folgenden Beispiel zeigen wir die Originaldaten für den Bundesstaatnamen und Quadratmeilen sowie drei neue berechnete Felder an, alle auf zwei Dezimalstellen gerundet zur besseren Lesbarkeit unter Verwendung von PySpark Round().
- Fläche mit ST_Area - da die räumliche Referenz 4326 mit der Einheit Grad ist, sind die Ergebnisse in Quadratgraddezimal, was keinen wirklich anwendbaren Wert hat
- Fläche mit ST_Area auf einer transformierten Geometrie unter Verwendung der USA Contiguous Albers Equal Area Projektion (102003). Diese Berechnung liefert Quadratmeter zurück, welche im folgenden Beispiel in Quadratmeilen umgerechnet werden
- Fläche mit ST_GeodesicArea auf der Originalgeometrie. Diese Berechnung liefert Quadratmeter zurück, welche in Quadratmeilen umgerechnet werden Beispiel unten
Die zurückgegebenen Werte liegen alle sehr nah beieinander, sind aber nicht genau gleich. Diese Abweichungen entstehen durch Verzerrungen bei der Flächenberechnung für große Regionen (das Coordinate Systems and Transformations core concept document bietet weitere Informationen zu Verzerrungen in Projektionen) sowie durch geringfügige Präzisionsunterschiede, die im Projektions- und Transformationsprozess auftreten können.
# Beim Lesen von Feature Services befindet sich die Geometrie in der Regel in einer Spalte namens "Shape." Dies kann durch Betrachten der oben angezeigten Tabelle bestätigt werden
display(
df_states.select("STATE_NAME",
"SQMI",
F.round(ST.area("Shape"), 2).alias("Area (sq decimal degrees"),
F.round(ST.area(ST.transform("Shape", 102003))/2.59e+6, 2).alias("Area (sqmi)"),
F.round(ST.geodesic_area("Shape")/2.59e+6, 2).alias("GeodesicArea (sqmi)")
)
)
Fazit
Wir hoffen, dass diese kurze Einführung zum Erstellen neuer Geometrien und zur Berechnung ihrer Eigenschaften hilfreich war. Wir werden weitere Inhalte veröffentlichen, um Ihnen den Einstieg zu erleichtern. Schauen Sie also regelmäßig in der Community vorbei! Und bitte lassen Sie uns wissen, welche Themen Sie gerne näher kennenlernen möchten!
