科研 Skill

多光谱遥感影像处理

rioxarray-remote-sensing

Reads, reprojects, and analyzes multispectral GeoTIFF imagery with rioxarray/rasterio: NDVI/EVI, cloud masking, mosaicking, Cloud-Optimized GeoTIFF export. Use for raster remote-sensing processing.

发布者 Codar安全审核通过v0.1.0更新于 2026-11-18

SKILL.md

rioxarray Remote Sensing Skill

One-line summary: This Skill helps researchers read, reproject, resample, and analyse multispectral satellite imagery using rioxarray/rasterio, suited for NDVI/EVI vegetation analysis, cloud masking, mosaicking, and COG export.


When to Use This Skill

Use this Skill in the following scenarios:

  • When you need to read and write GeoTIFF files with full CRS/metadata preservation.
  • When your raster data needs reprojection or resampling to match a target grid.
  • When you need to compute vegetation indices (NDVI, EVI) from multispectral bands.
  • When you are using Landsat or Sentinel imagery with QA bit-mask cloud masking.
  • When you need to mosaic multiple scenes into a single seamless raster.
  • When you need to produce Cloud-Optimized GeoTIFFs (COGs) for web delivery.
  • When you need to clip rasters to polygon boundaries (watersheds, administrative units).

Trigger keywords: rioxarray, rasterio, NDVI, EVI, GeoTIFF, COG, CRS reprojection, resampling, cloud masking, QA band, mosaicking, band math, clip to polygon.


Background & Key Concepts

Coordinate Reference Systems and Reprojection

A Coordinate Reference System (CRS) defines how 2-D map coordinates correspond to locations on the Earth's surface. Satellite imagery is delivered in a variety of projections — Landsat Collection 2 uses UTM zones, while global composites often use WGS-84 geographic coordinates (EPSG:4326). Reprojection transforms pixel data from one CRS to another by resampling values onto a new grid.

rioxarray wraps rasterio's GDAL-backed resampling. Available algorithms include:

AlgorithmUse case
Nearest neighbourCategorical data (land cover, QA bands)
BilinearContinuous data with moderate accuracy needs
CubicHigh-accuracy continuous data resampling
LanczosDownsampling with minimal aliasing

NDVI and EVI Formulae

The Normalized Difference Vegetation Index (NDVI) leverages the spectral contrast between the Near-Infrared (NIR) and Red bands:

$$ \text{NDVI} = \frac{\rho_{NIR} - \rho_{Red}}{\rho_{NIR} + \rho_{Red}} $$

Values range from -1 to +1; healthy vegetation typically falls between 0.3 and 0.8. Sparse vegetation, bare soil, and water produce values closer to 0 or negative.

The Enhanced Vegetation Index (EVI) reduces atmospheric and soil-background noise:

$$ \text{EVI} = G \cdot \frac{\rho_{NIR} - \rho_{Red}}{\rho_{NIR} + C_1 \cdot \rho_{Red} - C_2 \cdot \rho_{Blue} + L} $$

Where $G = 2.5$, $C_1 = 6$, $C_2 = 7.5$, $L = 1$ (standard MODIS coefficients).

Cloud Masking with QA Bits

Landsat Collection 2 Quality Assessment (QA_PIXEL) uses bit-packed integers. Bit 3 = cloud shadow, Bit 4 = cloud. Reading a specific bit:

$$ \text{bit}_k = \left\lfloor \frac{QA_PIXEL}{2^k} \right\rfloor \mod 2 $$

A pixel is considered cloud-contaminated when bit 3 OR bit 4 is set.

Comparison with Related Methods

MethodBest forKey assumptionLimitation
rioxarray + rasterioPython-native raster I/OGDAL-supported formatsPython memory limits for very large mosaics
GDAL CLI (gdalwarp)Batch reprojection, scriptingShell environmentNo Python integration
Google Earth EnginePetabyte-scale cloud processingInternet + GEE accountProprietary platform
xarray + rasterioNetCDF-heavy workflowsRectangular gridsLess direct raster support

Environment Setup

Install Dependencies

# Create a virtual environment (recommended)
python -m venv .venv
source .venv/bin/activate   # Linux/macOS
# .venv\Scripts\activate    # Windows

# Install Python dependencies
pip install rioxarray>=0.15.0 rasterio>=1.3.9 earthpy>=0.9.4 \
            numpy>=1.24.0 matplotlib>=3.7.0 geopandas>=0.14.0 shapely>=2.0.0

# On conda (recommended for GDAL/rasterio native libs):
# conda install -c conda-forge rioxarray rasterio earthpy geopandas shapely matplotlib

Verify Installation

import rioxarray
import rasterio
import earthpy
import numpy as np
import matplotlib
import geopandas

print(f"rioxarray  : {rioxarray.__version__}")
print(f"rasterio   : {rasterio.__version__}")
print(f"numpy      : {np.__version__}")
print(f"geopandas  : {geopandas.__version__}")
# Expected: rioxarray >= 0.15, rasterio >= 1.3.9

Core Workflow

Step 1: Reading a GeoTIFF and CRS Inspection

rioxarray's open_rasterio returns an xarray.DataArray with a .rio accessor that exposes all CRS and spatial metadata.

import rioxarray as rxr
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path

# ------------------------------------------------------------------
# Synthetic example: create a small GeoTIFF with 4 bands simulating
# Landsat-8 Blue/Green/Red/NIR reflectance (SR, scale 0-10000)
# ------------------------------------------------------------------
import rasterio
from rasterio.transform import from_bounds
from rasterio.crs import CRS

# Synthetic 4-band scene  (64 x 64 pixels, 30 m resolution, UTM zone 32N)
np.random.seed(42)
n = 64
synthetic = np.random.randint(500, 8000, (4, n, n), dtype=np.int16)
# Band 4 (NIR) elevated over vegetation-like pixels
synthetic[3, 10:40, 10:40] = np.random.randint(5000, 9000, (30, 30))
synthetic[2, 10:40, 10:40] = np.random.randint(500,  2000, (30, 30))

transform = from_bounds(500000, 5700000, 501920, 5701920, n, n)
crs = CRS.from_epsg(32632)

scene_path = Path("synthetic_landsat_b2345.tif")
with rasterio.open(
    scene_path, "w", driver="GTiff",
    height=n, width=n, count=4, dtype="int16",
    crs=crs, transform=transform,
) as dst:
    dst.write(synthetic)
    dst.update_tags(1, name="Blue")
    dst.update_tags(2, name="Green")
    dst.update_tags(3, name="Red")
    dst.update_tags(4, name="NIR")

print(f"Wrote synthetic scene: {scene_path}")

# ------------------------------------------------------------------
# Read with rioxarray
# ------------------------------------------------------------------
da = rxr.open_rasterio(scene_path, masked=True)
print(f"Shape         : {da.shape}")           # (bands, rows, cols)
print(f"CRS           : {da.rio.crs}")
print(f"Resolution    : {da.rio.resolution()}")
print(f"Bounds        : {da.rio.bounds()}")
print(f"NoData value  : {da.rio.nodata}")
# Expected shape: (4, 64, 64); CRS: EPSG:32632

Data requirements:

  • band: integer band index starting at 1
  • y / x: spatial coordinate dimensions in the native CRS units
  • Recommended: floating-point or 16-bit integer reflectance values, scale factor noted

Step 2: Reprojection and Resampling

import rioxarray as rxr
from rasterio.enums import Resampling

da = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True)

# --- Reproject to WGS-84 geographic (EPSG:4326) using bilinear resampling ---
da_wgs84 = da.rio.reproject("EPSG:4326", resampling=Resampling.bilinear)
print(f"Reprojected CRS      : {da_wgs84.rio.crs}")
print(f"Reprojected bounds   : {da_wgs84.rio.bounds()}")

# --- Reproject to a specific resolution (e.g., 0.0003 deg ~ 30 m) ---
da_resampled = da.rio.reproject(
    "EPSG:4326",
    resolution=0.0003,
    resampling=Resampling.cubic,
)
print(f"Custom-resolution shape: {da_resampled.shape}")

# --- Match another raster's grid exactly (reproject_match) ---
# Useful when aligning multi-sensor data
reference = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True)
da_matched = da_wgs84.rio.reproject_match(reference)
print(f"Matched shape: {da_matched.shape}")

Parameter reference:

ParameterMeaningRecommended valueNotes
resamplingPixel value interpolation methodbilinear for continuousUse nearest for categorical layers
resolutionTarget pixel size in CRS unitsMatch target datasetDegrees for geographic CRS, metres for projected
nodataFill value for areas outside original extentnp.nanSet via da.rio.write_nodata() before reprojection

Step 3: NDVI and EVI Calculation

import rioxarray as rxr
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

da = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True).astype(float)

# Landsat SR scale: divide by 10000 to get surface reflectance [0, 1]
blue = da.sel(band=1) / 10000.0
green = da.sel(band=2) / 10000.0
red   = da.sel(band=3) / 10000.0
nir   = da.sel(band=4) / 10000.0

# --- NDVI ---
ndvi = (nir - red) / (nir + red)
ndvi = ndvi.where(np.isfinite(ndvi))   # mask division-by-zero

# --- EVI (MODIS coefficients) ---
G, C1, C2, L = 2.5, 6.0, 7.5, 1.0
evi_denom = nir + C1 * red - C2 * blue + L
evi = G * (nir - red) / evi_denom
evi = evi.clip(-1.0, 1.0)

print(f"NDVI  min/mean/max : {float(ndvi.min()):.3f} / "
      f"{float(ndvi.mean()):.3f} / {float(ndvi.max()):.3f}")
print(f"EVI   min/mean/max : {float(evi.min()):.3f} / "
      f"{float(evi.mean()):.3f} / {float(evi.max()):.3f}")

# --- Plot side by side ---
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

im0 = axes[0].imshow(ndvi.values, cmap="RdYlGn", vmin=-0.2, vmax=0.9)
axes[0].set_title("NDVI")
axes[0].axis("off")
plt.colorbar(im0, ax=axes[0], fraction=0.046, pad=0.04)

im1 = axes[1].imshow(evi.values, cmap="RdYlGn", vmin=-0.2, vmax=0.9)
axes[1].set_title("EVI")
axes[1].axis("off")
plt.colorbar(im1, ax=axes[1], fraction=0.046, pad=0.04)

plt.suptitle("Vegetation Indices (synthetic Landsat-8 scene)")
plt.tight_layout()
plt.savefig("ndvi_evi_comparison.png", dpi=150, bbox_inches="tight")
plt.show()
print("Saved: ndvi_evi_comparison.png")

# --- Interpreting results ---
print("\nVegetation cover fractions:")
for label, lo, hi in [("Water/bare", -1.0, 0.1),
                       ("Sparse veg", 0.1, 0.3),
                       ("Moderate",   0.3, 0.6),
                       ("Dense veg",  0.6, 1.0)]:
    frac = float(((ndvi >= lo) & (ndvi < hi)).sum()) / ndvi.size
    print(f"  {label:<15}: {frac*100:5.1f} %")

Interpreting results:

  • NDVI > 0.6: dense, healthy vegetation canopy
  • NDVI 0.2–0.6: moderate/sparse vegetation
  • NDVI < 0.1: bare soil, rock, urban areas, or water

Advanced Usage

Cloud Masking with QA Band (Bit Manipulation)

Landsat Collection 2 QA_PIXEL band encodes quality flags as bit fields. Bits 3 (cloud shadow) and 4 (cloud) indicate unreliable pixels.

import rioxarray as rxr
import numpy as np
import rasterio
from rasterio.transform import from_bounds
from rasterio.crs import CRS
from pathlib import Path

# --- Synthesize a QA_PIXEL band ---
np.random.seed(0)
n = 64
qa_data = np.zeros((1, n, n), dtype=np.uint16)
# Set cloud bit (bit 4, value 16) for random pixels
cloud_mask_idx = np.random.choice(n * n, size=200, replace=False)
rows, cols = np.unravel_index(cloud_mask_idx, (n, n))
qa_data[0, rows, cols] |= (1 << 4)   # bit 4 = cloud
# Set cloud shadow (bit 3, value 8) for a few pixels
qa_data[0, 5:10, 5:10] |= (1 << 3)   # bit 3 = cloud shadow

transform = from_bounds(500000, 5700000, 501920, 5701920, n, n)
qa_path = Path("synthetic_qa_pixel.tif")
with rasterio.open(
    qa_path, "w", driver="GTiff",
    height=n, width=n, count=1, dtype="uint16",
    crs=CRS.from_epsg(32632), transform=transform,
) as dst:
    dst.write(qa_data)

# --- Apply cloud mask ---
qa = rxr.open_rasterio(qa_path, masked=False).squeeze()   # 2-D array
qa_np = qa.values.astype(np.uint16)

cloud_bit        = 4   # bit index
cloud_shadow_bit = 3

cloud_flag        = (qa_np >> cloud_bit)        & 1
cloud_shadow_flag = (qa_np >> cloud_shadow_bit) & 1
bad_pixel_mask    = (cloud_flag | cloud_shadow_flag).astype(bool)

print(f"Flagged pixels: {bad_pixel_mask.sum()} / {bad_pixel_mask.size} "
      f"({bad_pixel_mask.mean()*100:.1f}%)")

# Apply mask to NDVI
da = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True).astype(float)
ndvi = (da.sel(band=4) - da.sel(band=3)) / (da.sel(band=4) + da.sel(band=3))
ndvi_masked = ndvi.where(~bad_pixel_mask)

print(f"NDVI valid pixels after cloud masking: "
      f"{int(np.isfinite(ndvi_masked.values).sum())}")

Clip Raster to Polygon Boundary

import rioxarray as rxr
import geopandas as gpd
from shapely.geometry import box, mapping
import numpy as np

# --- Create a synthetic polygon (AOI) in UTM zone 32N ---
aoi = gpd.GeoDataFrame(
    geometry=[box(500300, 5700300, 501600, 5701600)],
    crs="EPSG:32632",
)

da = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True)

# Ensure CRS matches before clipping
aoi = aoi.to_crs(da.rio.crs)

da_clipped = da.rio.clip(aoi.geometry.apply(mapping), aoi.crs, drop=True)
print(f"Original shape : {da.shape}")
print(f"Clipped shape  : {da_clipped.shape}")
print(f"Clipped bounds : {da_clipped.rio.bounds()}")

Mosaicking Multiple Scenes

When a study area spans multiple raster tiles, merge them into a single seamless image.

import rioxarray as rxr
from rioxarray.merge import merge_arrays
import rasterio
import numpy as np
from rasterio.transform import from_bounds
from rasterio.crs import CRS
from pathlib import Path

# --- Synthesize two adjacent tiles ---
def make_tile(path, x_min, x_max, n=64):
    np.random.seed(int(x_min))
    data = np.random.randint(500, 8000, (4, n, n), dtype=np.int16)
    transform = from_bounds(x_min, 5700000, x_max, 5701920, n, n)
    with rasterio.open(
        path, "w", driver="GTiff",
        height=n, width=n, count=4, dtype="int16",
        crs=CRS.from_epsg(32632), transform=transform,
    ) as dst:
        dst.write(data)

make_tile("tile_west.tif", 500000, 501920)
make_tile("tile_east.tif", 501920, 503840)

tile_w = rxr.open_rasterio("tile_west.tif", masked=True)
tile_e = rxr.open_rasterio("tile_east.tif", masked=True)

# merge_arrays handles overlapping regions with first-in priority by default
mosaic = merge_arrays([tile_w, tile_e])
print(f"West tile shape : {tile_w.shape}")
print(f"East tile shape : {tile_e.shape}")
print(f"Mosaic shape    : {mosaic.shape}")
print(f"Mosaic bounds   : {mosaic.rio.bounds()}")

Export as Cloud-Optimized GeoTIFF (COG)

COGs store overviews and use tiled storage for efficient HTTP range-request access.

import rioxarray as rxr
import numpy as np

da = rxr.open_rasterio("synthetic_landsat_b2345.tif", masked=True)

# Compute NDVI as float32 single-band output
nir = da.sel(band=4).astype("float32")
red = da.sel(band=3).astype("float32")
ndvi = (nir - red) / (nir + red + 1e-9)
ndvi = ndvi.expand_dims("band")  # add band dimension back

# Write COG using rasterio's GDAL driver options
ndvi.rio.to_raster(
    "ndvi_cog.tif",
    driver="GTiff",
    dtype="float32",
    compress="deflate",
    predictor=2,          # horizontal differencing (good for floating point with predictor=3)
    tiled=True,
    blockxsize=512,
    blockysize=512,
    copy_src_overwrite=True,
)
print("Exported Cloud-Optimized GeoTIFF: ndvi_cog.tif")

# Verify the file is valid
import rasterio
with rasterio.open("ndvi_cog.tif") as src:
    print(f"  Driver   : {src.driver}")
    print(f"  CRS      : {src.crs}")
    print(f"  Shape    : {src.width} x {src.height}")
    print(f"  Profile  : {src.profile}")

Performance Optimization

import rioxarray as rxr
import dask

# Open very large GeoTIFF lazily with dask chunks
# chunks={'x': 1024, 'y': 1024} keeps each chunk ~4 MB for float32
da_lazy = rxr.open_rasterio(
    "large_scene.tif",   # replace with actual large file
    masked=True,
    chunks={"band": 1, "x": 1024, "y": 1024},
    lock=False,           # allow parallel reads
)

print(f"Dask DataArray: {da_lazy}")
print(f"Chunk sizes   : {da_lazy.chunks}")

# Compute only the spatial extent you need
da_subset = da_lazy.isel(x=slice(0, 2048), y=slice(0, 2048)).compute()
print(f"Subset shape  : {da_subset.shape}")

Troubleshooting

Error: CRSError: Invalid projection: EPSG:XXXX

Cause: EPSG code not found in local PROJ database; proj.db may be outdated.

Fix:

# Update proj.db via conda-forge (preferred)
conda install -c conda-forge proj>=9.0
# Or reinstall rasterio with bundled PROJ
pip install --force-reinstall rasterio

Error: NoDataError after clipping

Cause: The clip polygon does not overlap the raster extent, or CRS mismatch.

Fix:

import rioxarray as rxr
import geopandas as gpd

da = rxr.open_rasterio("my_raster.tif")
gdf = gpd.read_file("my_polygon.shp")

# Always reproject the polygon to match the raster CRS
gdf_reproj = gdf.to_crs(da.rio.crs)
print(f"Raster CRS  : {da.rio.crs}")
print(f"Polygon CRS : {gdf_reproj.crs}")
print(f"Raster bounds  : {da.rio.bounds()}")
print(f"Polygon bounds : {gdf_reproj.total_bounds}")
# Inspect for overlap before calling .rio.clip()

Issue: NDVI values outside [-1, 1]

Cause: Unscaled integer reflectance values (e.g., Landsat SR 0–10000 range) passed directly into the NDVI formula.

Fix: Divide by the scale factor (10000 for Landsat C2 L2 SR) before computing band math.

Version Compatibility

PackageTested versionsKnown issues
rioxarray0.15.x, 0.16.xreproject_match signature changed in 0.14; use keyword args
rasterio1.3.x, 1.4.xWindows wheels require GDAL ≥ 3.7; use conda on Windows
GDAL (system)3.7–3.9COG creation requires GDAL ≥ 3.1
numpy1.24–2.0Boolean indexing behaviour stable across versions

External Resources

Official Documentation

Key Papers

  • Rouse et al. (1974). Monitoring Vegetation Systems in the Great Plains with ERTS. NASA.
  • Huete et al. (2002). Overview of the radiometric and biophysical performance of the MODIS vegetation indices. Remote Sensing of Environment, 83, 195–213.
  • Cloud Optimized GeoTIFF specification: https://cogeo.org/

Tutorials

Data Sources


Examples

Example 1: Full NDVI Processing Pipeline for a Landsat Scene

Scenario: Compute cloud-masked NDVI for a Landsat-8 Collection 2 Level-2 scene, clip to an agricultural region of interest, and export as COG.

Input data: Landsat-8 Collection 2 Level-2 SR bands (B2–B5) + QA_PIXEL band. The example below uses synthetic data to be fully runnable without downloading.

# =============================================
# End-to-end example: NDVI pipeline
# Requirements: Python 3.10+; rioxarray, rasterio, numpy, matplotlib
# =============================================

import numpy as np
import rasterio
import rioxarray as rxr
from rasterio.transform import from_bounds
from rasterio.crs import CRS
from rioxarray.merge import merge_arrays
import geopandas as gpd
from shapely.geometry import box, mapping
import matplotlib.pyplot as plt
from pathlib import Path
import warnings
warnings.filterwarnings("ignore")

# ---- 1. Synthesize Landsat-like 4-band reflectance + QA ----
np.random.seed(123)
n = 128
transform = from_bounds(500000, 5700000, 503840, 5703840, n, n)
crs = CRS.from_epsg(32632)

reflectance = np.random.randint(200, 4000, (4, n, n), dtype=np.int16)
# Simulate a vegetated patch (high NIR, low Red)
reflectance[3, 30:80, 30:80] = np.random.randint(6000, 9500, (50, 50))
reflectance[2, 30:80, 30:80] = np.random.randint(300, 1200, (50, 50))

qa = np.zeros((1, n, n), dtype=np.uint16)
cloud_y, cloud_x = np.random.choice(n, 300), np.random.choice(n, 300)
qa[0, cloud_y, cloud_x] |= (1 << 4)   # cloud bit

for fname, data, dtype in [
    ("ls8_sr.tif", reflectance, "int16"),
    ("ls8_qa.tif", qa,          "uint16"),
]:
    with rasterio.open(fname, "w", driver="GTiff",
                       height=n, width=n,
                       count=data.shape[0], dtype=dtype,
                       crs=crs, transform=transform) as dst:
        dst.write(data)

# ---- 2. Load reflectance and QA ----
da = rxr.open_rasterio("ls8_sr.tif", masked=True).astype("float32")
qa_da = rxr.open_rasterio("ls8_qa.tif", masked=False).squeeze()

# ---- 3. Cloud mask ----
qa_np = qa_da.values.astype(np.uint16)
cloud_flag = (qa_np >> 4) & 1
cloud_shadow_flag = (qa_np >> 3) & 1
bad = (cloud_flag | cloud_shadow_flag).astype(bool)
print(f"Cloud/shadow pixels: {bad.sum()} ({bad.mean()*100:.1f}%)")

# ---- 4. NDVI ----
nir = da.sel(band=4) / 10000.0
red = da.sel(band=3) / 10000.0
ndvi = (nir - red) / (nir + red)
ndvi_clean = ndvi.where(~bad)

# ---- 5. Clip to AOI polygon ----
aoi = gpd.GeoDataFrame(geometry=[box(500500, 5700500, 503000, 5703000)], crs=crs)
ndvi_aoi = ndvi_clean.expand_dims("band").rio.clip(
    aoi.geometry.apply(mapping), aoi.crs, drop=True
).squeeze("band")

# ---- 6. Plot result ----
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].imshow(ndvi_clean.values, cmap="RdYlGn", vmin=-0.1, vmax=0.9)
axes[0].set_title("NDVI (cloud-masked, full scene)")
axes[0].axis("off")
axes[1].imshow(ndvi_aoi.values, cmap="RdYlGn", vmin=-0.1, vmax=0.9)
axes[1].set_title("NDVI (clipped to AOI)")
axes[1].axis("off")
plt.tight_layout()
plt.savefig("ndvi_pipeline_output.png", dpi=150)
plt.show()

# ---- 7. Export COG ----
ndvi_aoi.expand_dims("band").rio.to_raster(
    "ndvi_aoi_cog.tif",
    driver="GTiff", dtype="float32",
    compress="deflate", tiled=True, blockxsize=256, blockysize=256,
)
print(f"NDVI stats (AOI): min={float(ndvi_aoi.min()):.3f}, "
      f"mean={float(ndvi_aoi.mean()):.3f}, max={float(ndvi_aoi.max()):.3f}")
print("Exported: ndvi_aoi_cog.tif")
# Expected: NDVI mean ~0.4–0.6 in the vegetated patch area

Interpreting these results: The vegetated patch (rows 30–80, cols 30–80) should show NDVI around 0.6–0.8. Cloud-masked pixels appear as NaN (white in the figure). The COG is ready for web map tile services.


Example 2: Multi-Scene Mosaic and EVI Map

Scenario: Combine two adjacent Landsat tiles and produce a gap-free EVI mosaic.

# =============================================
# End-to-end example 2: mosaic + EVI
# =============================================

import numpy as np
import rasterio
import rioxarray as rxr
from rioxarray.merge import merge_arrays
from rasterio.transform import from_bounds
from rasterio.crs import CRS
import matplotlib.pyplot as plt

def make_scene(path, x_min, x_max, seed=0):
    np.random.seed(seed)
    n = 64
    data = np.random.randint(200, 7000, (4, n, n), dtype=np.int16)
    # Sprinkle some vegetation
    data[3, 10:40, 10:40] = np.random.randint(5500, 9000, (30, 30))
    data[2, 10:40, 10:40] = np.random.randint(400, 1500, (30, 30))
    data[0, 10:40, 10:40] = np.random.randint(200, 700, (30, 30))  # Blue band
    t = from_bounds(x_min, 5700000, x_max, 5701920, n, n)
    with rasterio.open(path, "w", driver="GTiff",
                       height=n, width=n, count=4, dtype="int16",
                       crs=CRS.from_epsg(32632), transform=t) as dst:
        dst.write(data)

make_scene("scene_A.tif", 500000, 501920, seed=7)
make_scene("scene_B.tif", 501920, 503840, seed=13)

tiles = [rxr.open_rasterio(p, masked=True).astype("float32")
         for p in ["scene_A.tif", "scene_B.tif"]]

mosaic = merge_arrays(tiles)
print(f"Mosaic shape: {mosaic.shape}, bounds: {mosaic.rio.bounds()}")

# EVI calculation
blue = mosaic.sel(band=1) / 10000.0
red  = mosaic.sel(band=3) / 10000.0
nir  = mosaic.sel(band=4) / 10000.0
G, C1, C2, L = 2.5, 6.0, 7.5, 1.0
evi = G * (nir - red) / (nir + C1 * red - C2 * blue + L)
evi = evi.clip(-1.0, 1.0)

fig, ax = plt.subplots(figsize=(10, 4))
im = ax.imshow(evi.values, cmap="RdYlGn", vmin=-0.1, vmax=0.9, aspect="auto")
ax.set_title("EVI — Mosaicked Scene (2 tiles)")
ax.axis("off")
plt.colorbar(im, ax=ax, fraction=0.02, pad=0.04, label="EVI")
plt.tight_layout()
plt.savefig("evi_mosaic.png", dpi=150)
plt.show()

print(f"EVI: min={float(evi.min()):.3f}, mean={float(evi.mean()):.3f}, "
      f"max={float(evi.max()):.3f}")
# Expected: vegetated pixels around 0.5-0.8; background ~0.1-0.3

Interpreting these results: The mosaic seamlessly joins both tiles. EVI values in the simulated vegetation patches (top-left quadrant of each tile) should exceed 0.4. EVI is preferred over NDVI in dense canopy conditions because it saturates less in high-biomass areas.


Last updated: 2026-03-17 | Maintainer: @xjtulyc Issues: GitHub Issues

示例提示词

我想用rioxarray重投影这批GeoTIFF影像并计算NDVI云掩膜。

所属插件

地球与环境科学面向地学、大气、海洋与生态研究:ERA5/CDS 气象数据、气候趋势、遥感与 GIS、水文、地震、空气质量、生物多样性与海洋绘图。

安装该插件会一并获得同领域的 18 个 Skill / MCP。

同插件的其他科研 Skill

常见问题

多光谱遥感影像处理能做什么?

Reads, reprojects, and analyzes multispectral GeoTIFF imagery with rioxarray/rasterio: NDVI/EVI, cloud masking, mosaicking, Cloud-Optimized GeoTIFF export. Use for raster remote-sensing processing。

如何安装多光谱遥感影像处理?

在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「多光谱遥感影像处理」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。

多光谱遥感影像处理需要哪些权限?

该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。

多光谱遥感影像处理经过官方审核吗?

是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。