Mengapa Cartopy untuk Peta Meteorologi
Data cuaca pada dasarnya hanyalah angka — array suhu, tekanan, kelembapan yang tersusun dalam grid lat/lon. Tapi angka-angka itu baru bermakna ketika kita bisa melihatnya di atas peta yang benar. Pola tekanan, jalur siklon, distribusi curah hujan — semua itu tersembunyi dalam array NumPy sampai kita memetakannya dengan proyeksi yang tepat.
Cartopy adalah library Python untuk geospatial data processing yang menjadi standar de-facto visualisasi meteorologi. Awalnya dikembangkan di UK Met Office agar para ilmuwan bisa memvisualisasikan data mereka di atas peta dengan cepat, mudah, dan akurat. Cartopy dibangun di atas PROJ, NumPy, dan Shapely. Library ini menyediakan interface yang bersih ke matplotlib untuk menghasilkan peta berkualitas publikasi.
Untuk pembaca yang sudah familiar dengan Python dan NumPy, tutorial ini menunjukkan cara kerja Cartopy dari dasar — mulai dari CRS object, GeoAxes, hingga mereprojeksi array data ERA5 ke peta yang siap digunakan. Integrasi Cartopy dengan xarray dan workflow ERA5 menjadikannya pilihan utama di komunitas meteorologi global maupun lokal.
Memahami Coordinate Reference System dan Proyeksi
Konsep terpenting dalam Cartopy adalah perbedaan antara data CRS dan display projection. Keduanya sama-sama objek CRS, tapi punya peran yang berbeda.
Data CRS adalah sistem koordinat tempat data kita disimpan. Hampir semua output model NWP dan reanalysis seperti ERA5 menggunakan PlateCarree — lat/lon biasa dengan derajat yang spasi-nya merata. Ketika kita buka file NetCDF ERA5, koordinatnya sudah dalam format ini.
Display projection adalah proyeksi yang kita pilih untuk merender peta. Cartopy menyediakan lebih dari 40 proyeksi melalui modul cartopy.crs. Beberapa yang paling relevan untuk meteorologi:
ccrs.PlateCarree()— equirectangular, standar untuk wilayah tropis dan ekuatorialccrs.LambertConformal()— conic conformal, banyak dipakai dalam meteorologi operasional NWS/NOAAccrs.Mercator()— silindris, populer untuk peta laut dan web map
Proyeksi lain seperti Stereographic (polar) dan Geostationary (data Himawari-9) juga tersedia untuk kebutuhan spesifik. Untuk Indonesia, ccrs.PlateCarree() sudah cukup sebagai display projection karena kita berada di kawasan ekuatorial. Satu hal penting: set_extent() selalu menggunakan koordinat PlateCarree terlepas dari display projection yang dipilih, dan Cartopy melakukan reprojeksi secara internal.
Mari kita inspect beberapa CRS object:
import cartopy.crs as ccrs
projections = [
("PlateCarree", ccrs.PlateCarree()),
("LambertConformal", ccrs.LambertConformal()),
("Mercator", ccrs.Mercator()),
("Orthographic (Indonesia)", ccrs.Orthographic(central_longitude=120, central_latitude=-2)),
]
for name, proj in projections:
class_name = type(proj).__name__
try:
proj4 = proj.proj4_init
print(f"{name}: class={class_name}, proj4={proj4}")
except AttributeError:
try:
proj4 = proj.proj4_params
print(f"{name}: class={class_name}, proj4_params={proj4}")
except Exception as e:
print(f"{name}: class={class_name}, proj4 not available ({e})")
PlateCarree: class=PlateCarree, proj4=+ellps=WGS84 +a=6378137.0 +proj=eqc +lon_0=0.0 +to_meter=111319.4907932736 +vto_meter=1 +no_defs
LambertConformal: class=LambertConformal, proj4=+ellps=WGS84 +proj=lcc +lon_0=-96.0 +lat_0=39.0 +x_0=0.0 +y_0=0.0 +lat_1=33 +lat_2=45 +no_defs
Mercator: class=Mercator, proj4=+ellps=WGS84 +proj=merc +lon_0=0.0 +x_0=0.0 +y_0=0.0 +units=m +no_defs
Orthographic (Indonesia): class=Orthographic, proj4=+a=6378137.0 +proj=ortho +lon_0=120 +lat_0=-2 +alpha=0.0 +no_defs
Membuat GeoAxes dan Menambahkan Fitur Peta
Ketika kita pass parameter projection=ccrs.PlateCarree() ke plt.axes(), matplotlib mengembalikan objek GeoAxes — bukan Axes biasa. GeoAxes inilah yang membuka akses ke method-method kartografis seperti set_extent(), add_feature(), dan coastlines().
Dua pendekatan untuk menambahkan garis pantai: method cepat ax.coastlines() yang pakai default resolution, atau ax.add_feature(cfeature.COASTLINE, linewidth=0.5) yang lebih fleksibel. Untuk peta meteorologi yang serius, add_feature() lebih direkomendasikan karena kita bisa mengatur resolution, warna, dan style.
Cartopy mengambil shapefile Natural Earth dari naturalearthdata.com pada pertama kali dijalankan, dalam tiga resolusi: '10m' (detail tinggi), '50m' (menengah), dan '110m' (kasar). Untuk render awal atau preview, '110m' sudah cukup dan lebih cepat. Perlu dicatat bahwa proses download shapefile ini membutuhkan koneksi internet — jalankan di environment lokal, bukan di sandbox yang offline.
Snippet berikut mencetak extent yang akan kita gunakan dan daftar feature constants yang tersedia:
import cartopy.crs as ccrs
import cartopy.feature as cfeature
crs = ccrs.PlateCarree()
extent = [90, 145, -15, 15] # Indonesia: [lonW, lonE, latS, latN]
print(f"Data CRS: {type(crs).__name__}")
print(f"Extent Indonesia: lonW={extent[0]}, lonE={extent[1]}, latS={extent[2]}, latN={extent[3]}")
print(f"Lebar domain: {extent[1]-extent[0]}° lon x {extent[3]-extent[2]}° lat")
print()
feature_names = [
("COASTLINE", cfeature.COASTLINE),
("BORDERS", cfeature.BORDERS),
("LAND", cfeature.LAND),
("OCEAN", cfeature.OCEAN),
("LAKES", cfeature.LAKES),
("RIVERS", cfeature.RIVERS),
]
print("Cartopy feature constants:")
for name, feat in feature_names:
print(f" cfeature.{name}: {type(feat).__name__}")
Data CRS: PlateCarree
Extent Indonesia: lonW=90, lonE=145, latS=-15, latN=15
Lebar domain: 55° lon x 30° lat
Cartopy feature constants:
cfeature.COASTLINE: NaturalEarthFeature
cfeature.BORDERS: NaturalEarthFeature
cfeature.LAND: NaturalEarthFeature
cfeature.OCEAN: NaturalEarthFeature
cfeature.LAKES: NaturalEarthFeature
cfeature.RIVERS: NaturalEarthFeature
Berikut ilustrasi alur kerja pembuatan peta dengan Cartopy:
Mereprojeksi Data Cuaca ke Peta
Ini adalah sumber kesalahan paling umum bagi pemula: lupa menyertakan parameter transform. Ketika kita punya array suhu ERA5 dalam grid lat/lon dan ingin memetakannya ke display projection apa pun, kita harus memberi tahu Cartopy bahwa data aslinya dalam PlateCarree.
Caranya: ax.pcolormesh(lon, lat, T, transform=ccrs.PlateCarree()). Tanpa transform, Cartopy menganggap koordinat data sudah dalam native projection — hasilnya data akan terplot di posisi geografis yang salah.
Parameter transform ini berlaku untuk semua fungsi plot 2D: pcolormesh(), contourf(), contour(), maupun scatter(). Prinsipnya sama: data CRS selalu PlateCarree untuk gridded model data, display projection boleh apa saja.
Untuk memahami cara kerja reprojeksi secara numerik, kita bisa gunakan transform_point(). Method ini mengkonversi satu titik (lon, lat) dari satu CRS ke CRS lain — berguna untuk debugging atau memverifikasi transformasi koordinat:
import cartopy.crs as ccrs
cities = [
("Jakarta", 106.85, -6.21),
("Medan", 98.67, 3.59),
("Denpasar", 115.22, -8.65),
]
src_crs = ccrs.PlateCarree()
tgt_crs = ccrs.Orthographic(central_longitude=120, central_latitude=-2)
print("Transformasi koordinat: PlateCarree → Orthographic (center: 120°E, 2°S)")
print(f"{'Kota':<12} {'Lon':>8} {'Lat':>7} → {'X (m)':>14} {'Y (m)':>14}")
print("-" * 60)
for city, lon, lat in cities:
x, y = tgt_crs.transform_point(lon, lat, src_crs)
print(f"{city:<12} {lon:>8.2f}° {lat:>6.2f}° → {x:>14.0f} {y:>14.0f}")
Transformasi koordinat: PlateCarree → Orthographic (center: 120°E, 2°S)
Kota Lon Lat → X (m) Y (m)
------------------------------------------------------------
Jakarta 106.85° -6.21° → -1442519 -474036
Medan 98.67° 3.59° → -2315425 606072
Denpasar 115.22° -8.65° → -525445 -739379
Hasil transform_point() dalam satuan meter — itulah native coordinate system dari Orthographic projection. Jakarta yang ada di barat-daya dari pusat proyeksi (120°E, 2°S) akan punya nilai X negatif dan Y negatif.
Contoh Lengkap Peta Suhu ERA5
Dalam workflow nyata, kita load data ERA5 dari file NetCDF menggunakan xarray — ds = xr.open_dataset("era5_temperature.nc") — lalu ambil array suhu, koordinat lat/lon-nya, dan plot dengan Cartopy. Untuk tutorial ini kita mock data tersebut dengan NumPy agar snippet bisa diverifikasi di sandbox.
Data ERA5 suhu permukaan untuk kawasan Indonesia umumnya berkisar 25–30 °C dengan gradien yang dipengaruhi topografi dan konveksi. Snippet berikut membangun mock array yang bentuknya realistis:
import numpy as np
# Grid Indonesia: 21 titik lat (-15 s.d. 15), 31 titik lon (90 s.d. 145)
lat = np.linspace(-15, 15, 21)
lon = np.linspace(90, 145, 31)
LON, LAT = np.meshgrid(lon, lat)
# Mock suhu permukaan (°C): hangat di ekuator, sedikit modulasi longitudinal
T = 28 - 0.05 * np.abs(LAT) ** 2 + 0.5 * np.sin(np.deg2rad(LON * 2))
print(f"Shape array T: {T.shape} (lat x lon)")
print(f"Extent: lon {lon.min():.1f}°–{lon.max():.1f}°E, lat {lat.min():.1f}°–{lat.max():.1f}°")
print()
print("Statistik suhu permukaan mock ERA5 (°C):")
print(f" Min : {T.min():.2f}")
print(f" Max : {T.max():.2f}")
print(f" Mean : {T.mean():.2f}")
print(f" Std : {T.std():.2f}")
print()
Shape array T: (21, 31) (lat x lon)
Extent: lon 90.0°–145.0°E, lat -15.0°–15.0°
Statistik suhu permukaan mock ERA5 (°C):
Min : 16.25
Max : 28.00
Mean : 23.53
Std : 3.68
Untuk merender peta lokal, gunakan matplotlib + Cartopy seperti berikut:
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.feature as cfeature
from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
fig, ax = plt.subplots(subplot_kw={'projection': ccrs.PlateCarree()})
ax.set_extent([90, 145, -15, 15], crs=ccrs.PlateCarree())
mesh = ax.pcolormesh(LON, LAT, T, transform=ccrs.PlateCarree(), cmap='RdYlBu_r')
ax.add_feature(cfeature.COASTLINE, linewidth=0.5)
ax.add_feature(cfeature.BORDERS, linewidth=0.3)
gl = ax.gridlines(draw_labels=True)
gl.xformatter = LONGITUDE_FORMATTER
gl.yformatter = LATITUDE_FORMATTER
plt.colorbar(mesh, ax=ax, label='Suhu (°C)')
plt.show()
Untuk workflow ERA5 yang sesungguhnya menggunakan Cartopy dan xarray, kita juga perlu menambahkan gridlines berlabel. Pertama, import LONGITUDE_FORMATTER dan LATITUDE_FORMATTER dari cartopy.mpl.gridliner. Selanjutnya, panggil gl = ax.gridlines(draw_labels=True) lalu set gl.xformatter = LONGITUDE_FORMATTER dan gl.yformatter = LATITUDE_FORMATTER. Cartopy 0.25 sudah mendukung label gridline untuk hampir semua proyeksi.
Satu hal yang perlu diperhatikan: untuk display projection non-PlateCarree seperti ccrs.LambertConformal() — yang banyak dipakai untuk peta meteorologi operasional — pastikan setiap call pcolormesh() atau contourf() selalu menyertakan transform=ccrs.PlateCarree(). Ini adalah aturan yang sama, berlaku konsisten.
Langkah Selanjutnya
Setelah memahami fondasi CRS, GeoAxes, dan parameter transform, langkah selanjutnya adalah mengaplikasikannya ke data riil. Untuk download ERA5, gunakan cdsapi dari ECMWF — request data dalam format NetCDF, lalu buka dengan xr.open_dataset(). Untuk data GFS real-time, xarray.open_dataset() via URL OPeNDAP dari NOMADS juga bekerja langsung.
Untuk analisis meteorologis yang lebih dalam, pertimbangkan integrasi MetPy dari Unidata. MetPy bekerja di atas Cartopy untuk handle proyeksi dan transform, sehingga kita bisa fokus pada kalkulasi meteorologi — dewpoint, CAPE, vorticity — tanpa harus mengurus CRS secara manual.
Beberapa proyeksi yang layak dieksplorasi berikutnya: ccrs.Geostationary(central_longitude=140.7) untuk data Himawari-9, ccrs.TransverseMercator() untuk peta lokal resolusi tinggi, dan ccrs.NorthPolarStereo() untuk analisis polar. Referensi lengkap semua 40+ proyeksi ada di Cartopy projection list.
Untuk tutorial yang lebih mendalam, Project Pythia's Cartopy tutorial adalah referensi komunitas yang sangat baik — mencakup gridlines, quiver plots untuk angin, dan overlaying station data di atas model output.
Eksplorasi artikel meteorologi lainnya di meteo.my.id — kunjungi https://meteo.my.id untuk telusur lebih lanjut.
Referensi
- Cartopy Documentation — SciTools — dokumentasi resmi Cartopy, library Python geospatial mapping yang dikembangkan oleh UK Met Office.
- Introduction to Cartopy — Project Pythia — tutorial komunitas geosains yang komprehensif mencakup GeoAxes, proyeksi, dan feature overlay.
- Cartopy Projection Reference — referensi lengkap 40+ proyeksi kartografis yang tersedia di
cartopy.crs. - Tutorial on Climatologies using C3S Climate Data — ECMWF — tutorial resmi ECMWF/C3S menggunakan Cartopy dan xarray untuk visualisasi data ERA5.
- Getting Started with MetPy — Unidata — panduan MetPy menjelaskan integrasi dengan Cartopy untuk pembuatan peta meteorologi operasional.
Tidak ada komentar:
Posting Komentar