0Pricing
R Academy · Lekcja

Złączenia i operacje przestrzenne

Stosuj st_join(), st_intersection(), st_buffer() i st_distance().

Złączenia i operacje przestrzenne to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Złączenia przestrzenne za pomocą st_join

st_join(x, y) wykonuje przestrzenne złączenie lewostronne: dla każdego obiektu w x wyszukuje obiekty w y spełniające predykat przestrzenny (domyślnie: st_intersects) i dołącza ich atrybuty. Wiele dopasowań powoduje utworzenie wielu wierszy.

library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Create random points within NC bounding box
set.seed(42)
bbox <- st_bbox(nc)
pts <- data.frame(
  lon = runif(20, bbox['xmin'], bbox['xmax']),
  lat = runif(20, bbox['ymin'], bbox['ymax'])
)
pts_sf <- st_as_sf(pts, coords = c('lon', 'lat'), crs = 4326)

# Spatial join: assign county attributes to each point
pts_with_county <- st_join(pts_sf, nc['NAME'])

cat('Points with county:\n')
print(head(pts_with_county[, c('NAME', 'geometry')], 5))

st_within: punkt w poligonie

st_within(x, y) zwraca rzadką macierz wartości logicznych wskazujących, czy każdy obiekt w x znajduje się całkowicie wewnątrz obiektu w y. Jest bardziej restrykcyjna niż st_intersects — stykanie się z granicą nie jest uwzględniane.

library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Random points
set.seed(7)
bbox <- st_bbox(nc)
pts_sf <- st_as_sf(
  data.frame(
    lon = runif(30, bbox['xmin'], bbox['xmax']),
    lat = runif(30, bbox['ymin'], bbox['ymax'])
  ),
  coords = c('lon', 'lat'), crs = 4326
)

# Which points are within NC at all?
within_nc <- st_within(pts_sf, st_union(nc), sparse = FALSE)[, 1]
cat('Points within NC:', sum(within_nc), '/ 30\n')

# Keep only points inside NC
pts_inside <- pts_sf[within_nc, ]
cat('Kept:', nrow(pts_inside), 'points\n')

st_intersects: sprawdzanie nakładania

st_intersects(x, y) zwraca TRUE, gdy obiekty mają wspólną dowolną część geometrii — granicę lub wnętrze. Jest to najbardziej liberalny predykat topologiczny. Przekaż sparse = FALSE, aby otrzymać macierz logiczną zamiast listy wektorów indeksów.

library(sf)

# Create two overlapping polygons
poly1 <- st_polygon(list(matrix(c(0,0, 2,0, 2,2, 0,2, 0,0), ncol=2, byrow=TRUE)))
poly2 <- st_polygon(list(matrix(c(1,1, 3,1, 3,3, 1,3, 1,1), ncol=2, byrow=TRUE)))
poly3 <- st_polygon(list(matrix(c(5,5, 6,5, 6,6, 5,6, 5,5), ncol=2, byrow=TRUE)))

sfc <- st_sfc(poly1, poly2, poly3, crs = 32119)

# Intersects matrix
mat <- st_intersects(sfc, sparse = FALSE)
cat('Intersects matrix:\n')
print(mat)
cat('\npoly1 intersects poly2:', mat[1, 2], '\n')
cat('poly1 intersects poly3:', mat[1, 3], '\n')

st_buffer: tworzenie buforów

st_buffer(sf_obj, dist) tworzy wokół każdego obiektu poligon bufora o określonej odległości. W geograficznym CRS odległość jest wyrażona w stopniach, a w odwzorowanym CRS — w metrach. Aby uzyskać dokładne wyniki, zawsze najpierw wykonaj odwzorowanie.

library(sf)

# City points in WGS84
cities <- data.frame(
  city = c('Raleigh', 'Charlotte', 'Greensboro'),
  lon  = c(-78.639, -80.843, -79.792),
  lat  = c(35.779,  35.227,  36.073)
)
cities_sf <- st_as_sf(cities, coords = c('lon', 'lat'), crs = 4326)

# Project to metres for accurate buffering (NC State Plane)
cities_proj <- st_transform(cities_sf, 32119)

# 25 km buffer around each city
buffers <- st_buffer(cities_proj, dist = 25000)

cat('Buffer geometry type:', unique(as.character(st_geometry_type(buffers))), '\n')
cat('Buffer area (km2):', round(as.numeric(st_area(buffers[1, ])) / 1e6, 2), '\n')
cat('Expected (pi*25^2):', round(pi * 25^2, 2), 'km2\n')

st_area: powierzchnie poligonów

st_area(sf_obj) oblicza powierzchnię każdego poligonu. W geograficznym CRS zwraca wartości w steradianach (nieprzydatne w tym zastosowaniu), a w odwzorowanym CRS z jednostkami metrowymi — w metrach kwadratowych. Wyniki zachowują jednostki z pakietu units.

library(sf)
library(units)

nc <- read_sf(system.file('shape/nc.shp', package = 'sf'))
nc_proj <- st_transform(nc, 32119)  # NC State Plane, metres

# Area in m2 with units
nc_proj$area_m2 <- st_area(nc_proj)

# Convert to km2
nc_proj$area_km2 <- set_units(nc_proj$area_m2, 'km^2')

# Summary statistics
cat('Smallest county:', nc_proj$NAME[which.min(nc_proj$area_km2)],
    round(min(as.numeric(nc_proj$area_km2)), 1), 'km2\n')
cat('Largest county: ', nc_proj$NAME[which.max(nc_proj$area_km2)],
    round(max(as.numeric(nc_proj$area_km2)), 1), 'km2\n')

st_distance: odległości parami

st_distance(x, y) oblicza macierz odległości między wszystkimi obiektami w x i wszystkimi obiektami w y. W WGS84 używa odległości geodezyjnych, a w odwzorowanym CRS — odległości euklidesowych. Wyniki zawierają metadane units.

library(sf)

cities <- data.frame(
  city = c('Raleigh', 'Charlotte', 'Greensboro', 'Wilmington'),
  lon  = c(-78.639, -80.843, -79.792, -77.909),
  lat  = c(35.779,  35.227,  36.073,  34.226)
)
cities_sf <- st_as_sf(cities, coords = c('lon', 'lat'), crs = 4326)

# Geodesic distance matrix (metres)
dist_m <- st_distance(cities_sf)
dist_km <- round(dist_m / 1000)

rownames(dist_km) <- cities$city
colnames(dist_km) <- cities$city

cat('Distance matrix (km):\n')
print(dist_km)

# Nearest neighbour for Raleigh
raleigh_dist <- as.numeric(dist_km['Raleigh', -1])
cat('\nNearest to Raleigh:',
    cities$city[-1][which.min(raleigh_dist)],
    min(raleigh_dist), 'km\n')

st_union: rozpuszczanie granic geometrii

st_union(sf_obj) scala wszystkie obiekty w jedną geometrię, usuwając granice wewnętrzne. Funkcja jest przydatna do utworzenia pojedynczego poligonu obrysu z wielu poligonów powiatów lub do połączenia zestawu buforów.

library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 32119
)

# Dissolve all counties into the NC state outline
nc_state <- st_union(nc)

cat('Counties before union:', nrow(nc), '\n')
cat('Features after union:', length(nc_state), '(single geometry)\n')
cat('Geometry type:', as.character(st_geometry_type(nc_state)), '\n')

# Area check: sum of counties == state area
county_area_sum <- sum(as.numeric(st_area(nc)))
state_area     <- as.numeric(st_area(nc_state))
cat('Sum of county areas:', round(county_area_sum / 1e9, 2), 'km2\n')
cat('State area:         ', round(state_area     / 1e9, 2), 'km2\n')

st_intersection: przycinanie

st_intersection(x, y) zwraca przecięcie geometryczne każdej pary obiektów — obszar wspólny dla obu geometrii. Funkcja służy do przycinania jednej warstwy do zasięgu drugiej.

library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Clip NC counties to a bounding rectangle (eastern NC)
clip_box <- st_as_sfc(st_bbox(c(
  xmin = -78, xmax = -75,
  ymin = 33.5, ymax = 36.5
), crs = 4326))

eastern_nc <- st_intersection(nc, clip_box)
cat('Original features:', nrow(nc), '\n')
cat('Clipped features: ', nrow(eastern_nc), '\n')
cat('Geometry types:   ', paste(unique(as.character(st_geometry_type(eastern_nc))), collapse = ', '), '\n')

Agregacja przestrzenna za pomocą dplyr

Połącz st_join() z dplyr::group_by() i summarise(), aby agregować dane punktowe według poligonów. Podczas grupowania obiektu sf kolumna geometrii jest automatycznie agregowana (domyślnie przez połączenie geometrii).

library(sf)
library(dplyr)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Generate random sales events in NC
set.seed(99)
bbox <- st_bbox(nc)
pts <- st_as_sf(
  data.frame(
    lon   = runif(200, bbox['xmin'], bbox['xmax']),
    lat   = runif(200, bbox['ymin'], bbox['ymax']),
    sales = runif(200, 100, 1000)
  ),
  coords = c('lon', 'lat'), crs = 4326
)

# Join then aggregate
result <- st_join(pts, nc['NAME']) |>
  filter(!is.na(NAME)) |>
  st_drop_geometry() |>
  group_by(NAME) |>
  summarise(total_sales = sum(sales), n_events = n()) |>
  arrange(desc(total_sales))

cat('Top 5 counties by sales:\n')
print(head(result, 5))

st_nearest_feature

st_nearest_feature(x, y) zwraca indeks najbliższego obiektu w y dla każdego obiektu w x. W połączeniu z st_distance() pozwala uzyskać zarówno najbliższy obiekt, jak i jego odległość — co jest przydatne w zadaniach przypisywania.

library(sf)

# Hospitals (facilities)
hospitals <- data.frame(
  name = c('Hospital A', 'Hospital B', 'Hospital C'),
  lon  = c(-79.5, -80.2, -78.8),
  lat  = c(35.8,  35.3,  36.1)
)
hosp_sf <- st_as_sf(hospitals, coords = c('lon', 'lat'), crs = 4326)

# Patient locations
patients <- data.frame(
  id  = 1:5,
  lon = c(-79.9, -80.5, -79.0, -78.5, -80.1),
  lat = c(35.7,  35.2,  35.9,  35.5,  36.0)
)
pt_sf <- st_as_sf(patients, coords = c('lon', 'lat'), crs = 4326)

# Find nearest hospital for each patient
nearest_idx <- st_nearest_feature(pt_sf, hosp_sf)
pt_sf$nearest_hospital <- hospitals$name[nearest_idx]

print(st_drop_geometry(pt_sf))

Praktyczny przebieg pracy: buforowanie i zliczanie

Częsty schemat w praktycznych zastosowaniach: utwórz bufory wokół zestawu obiektów (np. szkół), a następnie za pomocą st_join() i dplyr::count() policz, ile punktów zainteresowania (np. przystanków autobusowych) znajduje się w każdym buforze.

library(sf)
library(dplyr)

# Schools as points
schools <- data.frame(
  id  = 1:3,
  lon = c(-79.8, -80.2, -79.4),
  lat = c(35.9,  35.5,  36.1)
)
schools_sf <- st_as_sf(schools, coords = c('lon', 'lat'), crs = 4326) |>
  st_transform(32119)  # project to metres

# Random bus stops
set.seed(5)
stops <- data.frame(
  stop_id = 1:50,
  lon = rnorm(50, -79.8, 0.3),
  lat = rnorm(50,  35.8, 0.2)
) |>
  st_as_sf(coords = c('lon', 'lat'), crs = 4326) |>
  st_transform(32119)

# 2 km buffer around each school
buffers <- st_buffer(schools_sf, dist = 2000)
buffers$school_id <- schools$id

# Count bus stops within each school buffer
joined <- st_join(stops, buffers['school_id'])
counts <- count(st_drop_geometry(joined), school_id)
cat('Bus stops within 2km:\n')
print(counts)

Szybkie sprawdzenie

Chcesz znaleźć wszystkie obiekty poligonowe z warstwy B, które nakładają się na każdy poligon w warstwie A, i dołączyć atrybuty warstwy B do warstwy A. Której funkcji należy użyć?

Podsumowanie: złączenia i operacje przestrzenne

Najważniejsze informacje:

  • st_join(x, y) — przestrzenne złączenie lewostronne z użyciem predykatu (domyślnie: st_intersects)
  • st_within() — TRUE, gdy x znajduje się całkowicie wewnątrz y (granica jest wykluczona)
  • st_intersects() — TRUE, gdy dowolna część x dotyka y (najbardziej liberalny predykat)
  • st_buffer(sf_obj, dist) — tworzenie buforów; w celu uzyskania dokładności metrycznej używaj odwzorowanego CRS
  • st_area() / st_distance() — obliczanie powierzchni i odległości (najpierw wykonaj odwzorowanie dla większej dokładności)
  • st_union() — rozpuszczanie granic wszystkich obiektów; st_intersection() — przycinanie jednej warstwy do drugiej
  • st_nearest_feature(x, y) — wyszukiwanie najbliższego sąsiada
library(sf)
nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 32119
)

# Quick operations summary
cat('Largest county:', nc$NAME[which.max(st_area(nc))], '\n')
nc_outline <- st_union(nc)
cat('State area km2:', round(as.numeric(st_area(nc_outline)) / 1e6, 0), '\n')

Często zadawane pytania

Czy lekcja „Złączenia i operacje przestrzenne” jest bezpłatna?

Tak — pełny tekst „Złączenia i operacje przestrzenne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Złączenia i operacje przestrzenne”?

Stosuj st_join(), st_intersection(), st_buffer() i st_distance(). Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Złączenia i operacje przestrzenne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Proste obiekty przestrzenne za pomocą pakietu sf
  2. Układy odniesienia współrzędnych i odwzorowania
  3. Złączenia i operacje przestrzenne
  4. Interaktywne mapy za pomocą leaflet
← Powrót do R Academy