Koordinatenreferenzsysteme und Projektionen
Transformieren Sie CRS mit st_crs() und st_transform() korrekt ineinander
Koordinatenreferenzsysteme und Projektionen ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum das CRS wichtig ist
Ein Koordinatenreferenzsystem (CRS) gibt R an, was die Zahlen in Ihrer Geometriespalte bedeuten – Breiten- und Längengrade, Meter in einem projizierten Gitternetz oder etwas anderes. Wenn Sie Daten in unterschiedlichen CRS ohne Neuprojektion mischen, können räumliche Joins unbemerkt fehlschlagen und Entfernungsberechnungen falsche Ergebnisse liefern.
library(sf)
# Two sf objects in the same CRS: operations work
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
# sf will error or warn when CRS do not match during operations
# This is the CRS metadata attached to the object
crs <- st_crs(nc)
cat('EPSG:', crs$epsg, '\n')
cat('Input is geographic (lon/lat)?', st_is_longlat(nc), '\n')
cat('Units:', crs$units_gdal, '\n')st_crs: CRS-Informationen auslesen
st_crs(sf_obj) gibt ein crs-Objekt mit EPSG-Code, WKT-String, Proj4-String und Einheiteninformationen zurück. Sie können auch direkt einen ganzzahligen EPSG-Code übergeben, um die CRS-Definition abzurufen.
library(sf)
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
# Inspect the CRS object
crs <- st_crs(nc)
cat('Class:', class(crs), '\n')
cat('EPSG:', crs$epsg, '\n')
cat('Proj4:', substr(crs$proj4string, 1, 60), '...\n')
# Lookup a CRS by EPSG code
wgs84 <- st_crs(4326)
web_mercator <- st_crs(3857)
cat('\nWGS84 name:', wgs84$Name, '\n')
cat('Web Mercator name:', web_mercator$Name, '\n')EPSG:4326 — WGS84
EPSG:4326 ist das World Geodetic System 1984 – der Standard für GPS-Koordinaten. Die Koordinaten werden in Dezimalgrad angegeben: Der Längengrad (X) reicht von −180 bis 180, der Breitengrad (Y) von −90 bis 90. Es handelt sich um ein geografisches, nicht um ein projiziertes CRS.
library(sf)
# Create points in WGS84 (GPS coordinates)
cities <- data.frame(
city = c('London', 'Tokyo', 'Sydney', 'New York'),
lon = c(-0.118, 139.692, 151.209, -74.006),
lat = c(51.509, 35.689, -33.869, 40.713)
)
cities_sf <- st_as_sf(cities,
coords = c('lon', 'lat'),
crs = 4326
)
cat('CRS:', st_crs(cities_sf)$Name, '\n')
cat('Units:', st_crs(cities_sf)$units_gdal, '\n')
# Naive distance in degrees (not meaningful for real distances)
d <- st_distance(cities_sf[1, ], cities_sf[2, ])
cat('London-Tokyo distance (degrees):', round(as.numeric(d), 2), '\n')EPSG:3857 — Web Mercator
EPSG:3857 ist die von Google Maps, OpenStreetMap und Leaflet verwendete Web-Mercator-Projektion. Die Koordinaten werden in Metern angegeben und beziehen sich auf den Nullmeridian und den Äquator. Die Projektion verzerrt Flächen in Polnähe, eignet sich aber gut für die Webvisualisierung.
library(sf)
cities <- data.frame(
city = c('London', 'Tokyo'),
lon = c(-0.118, 139.692),
lat = c(51.509, 35.689)
)
cities_sf <- st_as_sf(cities, coords = c('lon', 'lat'), crs = 4326)
# Transform to Web Mercator
cities_merc <- st_transform(cities_sf, 3857)
cat('WGS84 coords (degrees):\n')
print(st_coordinates(cities_sf))
cat('\nWeb Mercator coords (metres):\n')
print(st_coordinates(cities_merc))
# Distance is now in metres
d <- st_distance(cities_merc[1, ], cities_merc[2, ])
cat('\nLondon-Tokyo distance (km):', round(as.numeric(d) / 1000, 0), '\n')st_set_crs: Ein CRS zuweisen
st_set_crs(sf_obj, crs) weist ein CRS zu, ohne Koordinaten zu transformieren. Verwenden Sie dies nur, wenn die CRS-Metadaten fehlen oder falsch sind. Wenn Sie Koordinaten in ein neues CRS reprojizieren möchten, verwenden Sie stattdessen st_transform().
library(sf)
# Create geometry with NO CRS
pts <- st_sfc(
st_point(c(-74.006, 40.713)),
st_point(c(-87.629, 41.878))
)
cat('CRS before:', is.na(st_crs(pts)), '(NA = no CRS)\n')
# Assign WGS84 (no coordinate transformation)
pts_wgs84 <- st_set_crs(pts, 4326)
cat('CRS after assignment:', st_crs(pts_wgs84)$epsg, '\n')
# Compare with st_transform (DOES transform coordinates)
pts_sf <- st_sf(id = 1:2, geometry = pts_wgs84)
pts_merc <- st_transform(pts_sf, 3857)
cat('Original lon:', st_coordinates(pts_sf)[1, 'X'], '\n')
cat('Mercator X: ', st_coordinates(pts_merc)[1, 'X'], '\n')st_transform: Reprojizieren
st_transform(sf_obj, crs) reprojiziert alle Geometrien von ihrem aktuellen CRS in das Ziel-CRS und wendet dabei die vollständige geodätische Transformation an. Das Argument crs akzeptiert eine EPSG-Ganzzahl, einen Proj4-String oder einen WKT-String.
library(sf)
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
cat('Original CRS:', st_crs(nc)$epsg, '\n')
# Re-project to WGS84
nc_wgs84 <- st_transform(nc, 4326)
cat('Transformed CRS:', st_crs(nc_wgs84)$epsg, '\n')
# Re-project to a local projected CRS (NC State Plane)
nc_stateplane <- st_transform(nc, 32119) # NAD83 / North Carolina
cat('State Plane CRS:', st_crs(nc_stateplane)$Name, '\n')
# Area calculation is more accurate in a projected CRS
area_deg <- st_area(nc[1, ])
area_m2 <- st_area(nc_stateplane[1, ])
cat('Area (degrees^2):', format(area_deg, big.mark = ','), '\n')
cat('Area (m^2): ', format(area_m2, big.mark = ','), '\n')Die richtige Projektion auswählen
Verschiedene Projektionen optimieren unterschiedliche Eigenschaften: flächentreue (z. B. Mollweide), winkeltreue (Mercator) oder längentreue Projektionen. Verwenden Sie für lokale Analysen ein projiziertes CRS mit Metern, für globale Übersichten eignet sich WGS84 und für Webkarten Web Mercator.
library(sf)
# Common EPSG codes cheat sheet
epsg_table <- data.frame(
EPSG = c(4326, 3857, 4269, 32637, 27700),
Name = c(
'WGS84 (GPS, global)',
'Web Mercator (web maps)',
'NAD83 (North America geographic)',
'UTM zone 37N (Middle East)',
'British National Grid (UK)'
),
Units = c('degrees', 'metres', 'degrees', 'metres', 'metres')
)
print(epsg_table, row.names = FALSE)
# Look up any EPSG online: https://epsg.io/<code>
cat('\nTip: use st_crs(epsg_code)$Name to verify a code\n')Proj4-Strings
Bevor EPSG-Codes zum Standard wurden, wurden CRS durch Proj4-Strings definiert – kompakte Parameterzeichenfolgen, die an die PROJ-Bibliothek übergeben wurden. Sie können diese weiterhin mit st_transform() verwenden, EPSG-Codes werden jedoch wegen ihrer Klarheit und zukünftigen Kompatibilität bevorzugt.
library(sf)
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
# WGS84 as Proj4 string
wgs84_proj4 <- '+proj=longlat +datum=WGS84 +no_defs'
nc_wgs84 <- st_transform(nc, crs = wgs84_proj4)
cat('Using Proj4 string:\n', wgs84_proj4, '\n')
cat('Result CRS EPSG:', st_crs(nc_wgs84)$epsg, '\n')
# Compare: equivalent to st_transform(nc, 4326)
cat('Same as EPSG 4326?',
identical(st_crs(nc_wgs84), st_crs(st_transform(nc, 4326))), '\n')Gleichheit von CRS prüfen
Prüfen Sie vor jedem räumlichen Join oder jeder Overlay-Operation mit st_crs(a) == st_crs(b), ob beide Objekte dasselbe CRS verwenden. Falls sie sich unterscheiden, transformieren Sie eines an das andere, bevor Sie fortfahren.
library(sf)
# Two objects in different CRS
nc_nad27 <- read_sf(system.file('shape/nc.shp', package = 'sf'))
nc_wgs84 <- st_transform(nc_nad27, 4326)
cat('Same CRS?', st_crs(nc_nad27) == st_crs(nc_wgs84), '\n')
# Always check before join/overlay
align_crs <- function(a, b) {
if (st_crs(a) != st_crs(b)) {
message('CRS mismatch! Transforming b to match a.')
b <- st_transform(b, st_crs(a))
}
list(a = a, b = b)
}
aligned <- align_crs(nc_nad27, nc_wgs84)
cat('After alignment - same CRS?',
st_crs(aligned$a) == st_crs(aligned$b), '\n')Entfernungen mit CRS berechnen
Entfernungen, die in einem geografischen CRS (Grad) berechnet werden, sind bedeutungslos. Reprojizieren Sie zunächst in ein längentreues oder flächentreues projiziertes CRS oder verwenden Sie die integrierte geodätische Entfernungsberechnung von sf, die WGS84 mithilfe der PROJ-Bibliothek korrekt verarbeitet.
library(sf)
# City points in WGS84
cities <- data.frame(
city = c('Paris', 'Berlin', 'Madrid', 'Rome'),
lon = c(2.350, 13.404, -3.702, 12.496),
lat = c(48.865, 52.520, 40.417, 41.902)
)
cities_sf <- st_as_sf(cities, coords = c('lon', 'lat'), crs = 4326)
# sf computes geodesic distances on WGS84 automatically
dist_matrix <- st_distance(cities_sf)
rownames(dist_matrix) <- cities$city
colnames(dist_matrix) <- cities$city
# Convert to km
dist_km <- round(as.numeric(dist_matrix) / 1000)
mat_km <- matrix(dist_km, 4, 4, dimnames = list(cities$city, cities$city))
print(mat_km)Ein vollständiger CRS-Workflow
Hier ist ein vollständiger Workflow: Laden Sie rohe GPS-Daten, weisen Sie WGS84 zu, reprojizieren Sie in ein lokales metrisches CRS für genaue Flächen- und Entfernungsberechnungen, führen Sie die Analyse durch und reprojizieren Sie die Ergebnisse für die Ausgabe in Webkarten zurück nach WGS84.
library(sf)
# Load and assign CRS
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
nc_wgs84 <- st_transform(nc, 4326)
# Re-project to NC State Plane (metres) for accurate areas
nc_proj <- st_transform(nc, 32119)
# Compute area per county in km2
nc_proj$area_km2 <- as.numeric(st_area(nc_proj)) / 1e6
# Top 5 largest counties
top5 <- nc_proj[order(-nc_proj$area_km2), c('NAME', 'area_km2')]
cat('5 Largest NC Counties (km2):\n')
print(head(as.data.frame(top5)[, c('NAME', 'area_km2')], 5))
# Back to WGS84 for output
nc_output <- st_transform(nc_proj, 4326)
cat('\nOutput CRS:', st_crs(nc_output)$epsg, '\n')Schnelltest
Sie müssen genaue Flächen (in Quadratmetern) für Polygon-Features berechnen, die derzeit in WGS84 (EPSG:4326) vorliegen. Was sollten Sie tun?
Zusammenfassung: CRS und Projektionen
Wichtigste Erkenntnisse:
st_crs(sf_obj)liest CRS-Metadaten aus; EPSG-Codes sind die bevorzugte Methode zur Angabe eines CRS- EPSG:4326 = WGS84 (Grad, für GPS); EPSG:3857 = Web Mercator (Meter, für Webkarten)
st_set_crs()weist ein CRS zu, ohne zu transformieren;st_transform()reprojiziert Koordinaten- Prüfen Sie vor räumlichen Operationen immer die CRS-Gleichheit mit
st_crs(a) == st_crs(b) - Für genaue Entfernungen und Flächen reprojizieren Sie zunächst in ein metrisches projiziertes CRS
- Proj4-Strings funktionieren weiterhin, EPSG-Codes sind jedoch übersichtlicher und besser lesbar
library(sf)
nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
# CRS pipeline
cat('Original:', st_crs(nc)$epsg, '\n')
nc_wgs84 <- st_transform(nc, 4326)
nc_proj <- st_transform(nc_wgs84, 32119)
cat('WGS84:', st_crs(nc_wgs84)$epsg, '\n')
cat('Projected:', st_crs(nc_proj)$epsg, '\n')
Lerne R mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 43
- Lektionen
- 159
Häufig gestellte Fragen
Ist die Lektion „Koordinatenreferenzsysteme und Projektionen“ kostenlos?
Ja — der vollständige Text von „Koordinatenreferenzsysteme und Projektionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Koordinatenreferenzsysteme und Projektionen“?
Transformieren Sie CRS mit st_crs() und st_transform() korrekt ineinander Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Koordinatenreferenzsysteme und Projektionen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Simple Features mit dem Paket sf
- Koordinatenreferenzsysteme und Projektionen
- Räumliche Joins und Operationen
- Interaktive Karten mit leaflet