import geopandas as gpd import matplotlib.pyplot as plt from geopy.geocoders import…
- User
import geopandas as gpd import matplotlib.pyplot as plt from geopy.geocoders import Nominatim import requests from bs4 import BeautifulSoup import re from tqdm import tqdm from shapely.geometry import Point import json import pandas as pd import numpy as np import rasterio import warnings from scipy.spatial import cKDTree from rasterio.transform import from_origin from rasterio.features import rasterize import os import rasterio.mask import matplotlib.colors as mcolors import matplotlib.patheffects as patheffects from pykrige.uk import UniversalKriging from sklearn.linear_model import HuberRegressor from scipy.stats import zscore from sklearn.ensemble import RandomForestRegressor from sklearn.preprocessing import StandardScaler from scipy.ndimage import gaussian_filter from datetime import datetime import pytz import math
os.environ['PROJ_LIB'] = r'C:\Users\Lenovo\Documents\conda\Library\share\proj'
warnings.filterwarnings("ignore")
Keywords to remove
keywords_to_remove = [ r"(centrum)", "rondo", "most", "Obwodnica", "obwodnica I", "obwodnica II", "obwodnica", "- Zawiszyn", "OUD Węzeł", "PPO", "Węzeł", "N (wąwóz)", "S (most)", "stacja", "z pomiarów", "min", "max", "średnia" ]
def clean_station_name(station_name): pattern = re.compile("|".join(keywords_to_remove), re.IGNORECASE) cleaned_name = pattern.sub("", station_name).strip() return cleaned_name
def get_masovian_boundary(): url = "https://raw.githubusercontent.com/ppatrzyk/polska-geojson/master/wojewodztwa/wojewodztwa-medium.geojson" # Fetch the content using requests response = requests.get(url) if response.status_code == 200: data = response.json() # Set the CRS to EPSG:4326 when creating the GeoDataFrame gdf = gpd.GeoDataFrame.from_features(data["features"], crs="EPSG:4326") masovian = gdf[gdf['nazwa'] == 'mazowieckie'] return masovian else: print(f"Error fetching GeoJSON data: {response.status_code}") return None
Global variable for Masovian boundary
masovian_boundary = get_masovian_boundary()
def is_in_masovian(lat, lon): point = gpd.GeoSeries([Point(lon, lat)], crs="EPSG:4326") masovian_geom = masovian_boundary.to_crs(epsg=2180).reset_index(drop=True) point_projected = point.to_crs(epsg=2180) return masovian_geom.contains(point_projected.buffer(100)).values[0]
def fetch_traxelektronik_data(): url = 'https://www.traxelektronik.pl/pogoda/zbiorcza.php?RejID=10' response = requests.get(url) soup = BeautifulSoup(response.text, 'html.parser')
stations = [] temperatures = [] table_rows = soup.find_all('tr')[2:] for row in table_rows: columns = row.find_all('td') if len(columns) > 1: station = columns[0].get_text(strip=True) temperature = columns[1].get_text(strip=True) if temperature != "-": stations.append(station) # Keep original station names temperatures.append(temperature) print(f"Fetched {len(stations)} stations with valid temperature data from Traxelektronik.") return stations, temperaturesdef fetch_netatmo_data(): url = "https://api.netatmo.com/api/getpublicdata" params = { "lat_ne": 53, "lon_ne": 22, "lat_sw": 51, "lon_sw": 19, "required_data": "temperature", "filter": "true", "access_token": "66e1e80975134797710422cd|49fa2dd65af161125b1ecfc747610748" }
response = requests.get(url, params=params) if response.status_code == 200: print("Successfully fetched data from Netatmo") else: print(f"Error fetching data: {response.status_code}") data = json.loads(response.text) stations = [] temperatures = [] coordinates = [] # List of cities to exclude excluded_cities = ["Płońsk", "Łochów"] for station in data.get('body', []): place = station.get('place', {}) location = place.get('location') if location: lon, lat = location if is_in_masovian(lat, lon): city = place.get('city', 'Unknown') if city in excluded_cities: # Skip this station continue for module, module_data in station.get('measures', {}).items(): if 'temperature' in module_data.get('type', []): res = module_data.get('res', {}) if res: latest_timestamp = max(res.keys()) temperature = res[latest_timestamp][0] stations.append(city) temperatures.append(temperature) coordinates.append((lat, lon)) break print(f"Fetched {len(stations)} stations with valid temperature data from Netatmo in Masovian Voivodeship.") return stations, temperatures, coordinatesdef fetch_imgw_data(): url = "https://rafalraczynski.com.pl/imgw/dane-imgw/getJSON.php?type=table&province=14&sort=temp&order=asc" response = requests.get(url) if response.status_code == 200: data = response.json() else: print(f"Error fetching IMGW data: {response.status_code}") return [], [], []
target_stations = [ "ANDRZEJEWO", "BORKOWO", "CZARNOWO", "KAZANÓW", "RUSZKOWICE", "RYBIENKO", "RZĄŚNIK WŁOŚCIAŃSKI", "WIELGOLAS" ] stations = [] temperatures = [] station_ids = [] for item in data: statName = item.get('statName') temp = item.get('temp') if statName and temp and statName.upper() in target_stations: stations.append(statName) temperatures.append(temp) station_ids.append(item.get('statId', 'Unknown')) print(f"Fetched {len(stations)} stations from IMGW data.") return stations, temperatures, station_idsdef get_coordinates(station_name, geolocator): try: location = geolocator.geocode(f"{station_name}, Masovian Voivodeship, Poland") if location: if is_in_masovian(location.latitude, location.longitude): print(f"Geocoded '{station_name}' to {location.latitude}, {location.longitude} (in Masovian).") return (location.latitude, location.longitude), False else: print(f"'{station_name}' is not in Masovian Voivodeship.") return None, False print(f"Failed to geocode '{station_name}'.") return None, False except Exception as e: print(f"Error geocoding {station_name}: {e}") return None, False
def clean_temperature(temp): cleaned_temp = re.sub(r'[↓↑\s]', '', temp) try: return float(cleaned_temp) except ValueError: return None
def remove_nearby_duplicates(trax_coords, trax_temperatures, netatmo_coords, netatmo_temperatures, distance_threshold=0.01): trax_points = np.array([(lon, lat) for station, (lat, lon) in trax_coords.items()]) netatmo_points = np.array([(lon, lat) for lat, lon in netatmo_coords]) trax_tree = cKDTree(trax_points)
netatmo_filtered_coords = [] netatmo_filtered_temperatures = [] for netatmo_point, netatmo_temp in zip(netatmo_points, netatmo_temperatures): distance, index = trax_tree.query(netatmo_point) if distance > distance_threshold: netatmo_filtered_coords.append(tuple(netatmo_point)) netatmo_filtered_temperatures.append(netatmo_temp) return netatmo_filtered_coords, netatmo_filtered_temperaturesdef hillshade(array, azimuth=315, angle_altitude=45): # Convert angles to radians azimuth_rad = np.radians(azimuth) altitude_rad = np.radians(angle_altitude)
# Calculate gradients in x and y directions x, y = np.gradient(array) # Calculate the slope and aspect slope = np.pi/2.0 - np.arctan(np.sqrt(x*x + y*y)) aspect = np.arctan2(-x, y) # Calculate shaded relief shaded = np.sin(altitude_rad) * np.sin(slope) + np.cos(altitude_rad) * np.cos(slope) * np.cos(azimuth_rad - aspect) # Normalize the shaded relief shaded = (shaded + 1) / 2 shaded = (shaded * 255).astype(np.uint8) return shadeddef gaussian_filter_nan(image, sigma): nan_mask = np.isnan(image) image_filled = np.where(nan_mask, 0, image) weights = np.where(nan_mask, 0, 1) image_filtered = gaussian_filter(image_filled, sigma=sigma, mode='nearest') weights_filtered = gaussian_filter(weights, sigma=sigma, mode='nearest') with np.errstate(divide='ignore', invalid='ignore'): image_final = image_filtered / weights_filtered image_final[nan_mask] = np.nan return image_final
def plot_stations_with_boundary_and_interpolation( trax_stations, trax_temperatures, trax_coords, netatmo_stations, netatmo_temperatures, netatmo_coords, imgw_stations, imgw_temperatures, imgw_coords): # Determine the current time in CET cet = pytz.timezone('CET') now_cet = datetime.now(cet) hour = now_cet.hour + now_cet.minute / 60.0
# Define daytime hours (6 AM to 6 PM) day_start = 11 day_end = 18 is_daytime = day_start <= hour <= day_end # List of Traxelektronik stations to exclude during daytime exclude_trax_stations_daytime = [ 'Ceranów', 'Baranów', 'Drobin', 'Kamion', 'Mińsk Mazowiecki', 'Mostówka', 'Paplin', 'Pilawa', 'Stromiec', 'Węzeł Łabiszyńska', 'Węzeł Marki', 'Węzeł Marynarska', 'Wilchta', 'Wiśniew' ] # Clean the exclude list for matching exclude_trax_stations_daytime_cleaned = [clean_station_name(name) for name in exclude_trax_stations_daytime] # Map station names to cleaned station names cleaned_station_dict = {station: clean_station_name(station) for station in trax_stations} # Process Traxelektronik data trax_filtered_stations = [] trax_filtered_temperatures = [] trax_geometries = [] # Filter and clean Traxelektronik data for station, temperature in zip(trax_stations, trax_temperatures): cleaned_station = cleaned_station_dict[station] # Exclude certain stations during daytime if is_daytime and cleaned_station in exclude_trax_stations_daytime_cleaned: continue # Skip this station cleaned_temperature = clean_temperature(temperature) if cleaned_station in trax_coords and cleaned_temperature is not None: lat, lon = trax_coords[cleaned_station] trax_filtered_stations.append(cleaned_station) trax_filtered_temperatures.append(cleaned_temperature) trax_geometries.append(Point(lon, lat)) # Create GeoDataFrame for Traxelektronik data trax_gdf = gpd.GeoDataFrame({ 'Station': trax_filtered_stations, 'Temperature': trax_filtered_temperatures, 'Source': 'Traxelektronik' }, geometry=trax_geometries, crs="EPSG:4326") # Handle Netatmo data netatmo_filtered_coords = [] netatmo_filtered_temperatures = [] netatmo_filtered_stations = [] for station, temperature, coord in zip(netatmo_stations, netatmo_temperatures, netatmo_coords): if isinstance(temperature, (int, float)) and coord is not None: netatmo_filtered_coords.append(coord) netatmo_filtered_temperatures.append(temperature) netatmo_filtered_stations.append(station) if len(netatmo_filtered_coords) > 0: netatmo_geometries = [Point(lon, lat) for lat, lon in netatmo_filtered_coords] netatmo_gdf = gpd.GeoDataFrame({ 'Station': netatmo_filtered_stations, 'Temperature': netatmo_filtered_temperatures, 'Source': 'Netatmo' }, geometry=netatmo_geometries, crs="EPSG:4326") else: netatmo_gdf = gpd.GeoDataFrame(columns=['Station', 'Temperature', 'Source', 'geometry'], crs="EPSG:4326") # Handle IMGW data imgw_filtered_stations = [] imgw_filtered_temperatures = [] imgw_geometries = [] # Clean and process IMGW data for station, temperature in zip(imgw_stations, imgw_temperatures): cleaned_temperature = clean_temperature(temperature) if station in imgw_coords and cleaned_temperature is not None: lat, lon = imgw_coords[station] imgw_filtered_stations.append(station) imgw_filtered_temperatures.append(cleaned_temperature) imgw_geometries.append(Point(lon, lat)) # Create GeoDataFrame for IMGW data imgw_gdf = gpd.GeoDataFrame({ 'Station': imgw_filtered_stations, 'Temperature': imgw_filtered_temperatures, 'Source': 'IMGW' }, geometry=imgw_geometries, crs="EPSG:4326") # Read and clip DEM dem_data, dem_transform = read_and_clip_dem(masovian_boundary) # Read and clip Forest Cover forest_data, forest_transform = read_and_clip_forest(masovian_boundary) # Read and clip Water Bodies water_data, water_transform = read_and_clip_water_bodies(masovian_boundary) # Read ECOSTRESS data ecostress_data, ecostress_transform = read_and_clip_ecostress(masovian_boundary) # Ensure geometries are in EPSG:4326 trax_gdf_dem_crs = trax_gdf.to_crs("EPSG:4326") netatmo_gdf_dem_crs = netatmo_gdf.to_crs("EPSG:4326") imgw_gdf_dem_crs = imgw_gdf.to_crs("EPSG:4326") # Get elevation at station points using dem_data and dem_transform trax_elevations = get_elevation_at_points( trax_gdf_dem_crs.geometry, dem_data=dem_data, dem_transform=dem_transform ) netatmo_elevations = get_elevation_at_points( netatmo_gdf_dem_crs.geometry, dem_data=dem_data, dem_transform=dem_transform ) imgw_elevations = get_elevation_at_points( imgw_gdf_dem_crs.geometry, dem_data=dem_data, dem_transform=dem_transform ) # Add elevation to the GeoDataFrames trax_gdf['Elevation'] = trax_elevations netatmo_gdf['Elevation'] = netatmo_elevations imgw_gdf['Elevation'] = imgw_elevations # Get tree cover density at station points using forest_data and forest_transform trax_forest = get_raster_value_at_points( trax_gdf_dem_crs.geometry, raster_data=forest_data, raster_transform=forest_transform ) netatmo_forest = get_raster_value_at_points( netatmo_gdf_dem_crs.geometry, raster_data=forest_data, raster_transform=forest_transform ) imgw_forest = get_raster_value_at_points( imgw_gdf_dem_crs.geometry, raster_data=forest_data, raster_transform=forest_transform ) # Add tree cover density to the GeoDataFrames trax_gdf['Tree_Cover'] = trax_forest netatmo_gdf['Tree_Cover'] = netatmo_forest imgw_gdf['Tree_Cover'] = imgw_forest # Get water body data at station points trax_water = get_water_body_at_points( trax_gdf_dem_crs.geometry, water_data=water_data, water_transform=water_transform ) netatmo_water = get_water_body_at_points( netatmo_gdf_dem_crs.geometry, water_data=water_data, water_transform=water_transform ) imgw_water = get_water_body_at_points( imgw_gdf_dem_crs.geometry, water_data=water_data, water_transform=water_transform ) # Add water body data to the GeoDataFrames trax_gdf['Water_Body'] = trax_water netatmo_gdf['Water_Body'] = netatmo_water imgw_gdf['Water_Body'] = imgw_water # Add 'Priority' column to each GeoDataFrame trax_gdf['Priority'] = 2 netatmo_gdf['Priority'] = 1 imgw_gdf['Priority'] = 3 # Higher priority # Combine GeoDataFrames stations_gdf = gpd.GeoDataFrame(pd.concat([trax_gdf, netatmo_gdf, imgw_gdf], ignore_index=True)) stations_gdf.crs = "EPSG:4326" stations_gdf = stations_gdf.dropna(subset=['Temperature', 'Elevation', 'Tree_Cover']) # Extract coordinates stations_gdf['X'] = stations_gdf.geometry.x stations_gdf['Y'] = stations_gdf.geometry.y # Prepare data for regression X = stations_gdf[['X', 'Y', 'Elevation', 'Tree_Cover', 'Water_Body']] y = stations_gdf['Temperature'] # Normalize covariates scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # Fit Random Forest Regression model print("Training Random Forest Regression model...") rf_model = RandomForestRegressor(n_estimators=100, random_state=42) rf_model.fit(X_scaled, y) # Predict temperatures and compute residuals stations_gdf['Predicted_Temperature'] = rf_model.predict(X_scaled) stations_gdf['Residual'] = stations_gdf['Temperature'] - stations_gdf['Predicted_Temperature'] # Outlier detection using Z-score stations_gdf['Residual_Z'] = zscore(stations_gdf['Residual']) z_threshold = 2 # Set your threshold stations_gdf_inliers = stations_gdf[np.abs(stations_gdf['Residual_Z']) <= z_threshold].copy() # Remove duplicates by prioritizing IMGW data data = stations_gdf_inliers.copy() # Sort by priority (higher priority first) data = data.sort_values('Priority', ascending=False) # Group by coordinates and keep the first record in each group (highest priority) data = data.groupby(['X', 'Y'], as_index=False).first() unique_points = data[['X', 'Y']].values unique_residuals = data['Residual'].values unique_elevation = data['Elevation'].values unique_tree_cover = data['Tree_Cover'].values unique_water_body = data['Water_Body'].values # Create grid in EPSG:4326 using rasterio's transform functions # Adjust grid_spacing as per your requirements grid_spacing = 0.0025 # Approximately ~5 km x_min, y_min, x_max, y_max = masovian_boundary.total_bounds # Compute the number of cols and rows with the new grid_spacing ncols = int(np.ceil((x_max - x_min) / grid_spacing)) nrows = int(np.ceil((y_max - y_min) / grid_spacing)) # Create the affine transform for the grid transform = from_origin(x_min, y_max, grid_spacing, grid_spacing) # Create arrays of row and column indices cols = np.arange(ncols) rows = np.arange(nrows) # Create a meshgrid of indices cols_indices, rows_indices = np.meshgrid(cols, rows) # Flatten the indices cols_flat = cols_indices.ravel() rows_flat = rows_indices.ravel() # Get the x and y coordinates for each grid cell center xs_flat, ys_flat = rasterio.transform.xy(transform, rows_flat, cols_flat) # Create grid dataframe grid_df = pd.DataFrame({ 'X': xs_flat, 'Y': ys_flat, 'row_idx': rows_flat, 'col_idx': cols_flat }) # Retrieve elevations from DEM grid_elevations = get_elevation_at_points( [Point(x, y) for x, y in zip(grid_df['X'], grid_df['Y'])], dem_data=dem_data, dem_transform=dem_transform ) grid_df['Elevation'] = grid_elevations # Retrieve tree cover density from forest cover raster grid_forest = get_raster_value_at_points( [Point(x, y) for x, y in zip(grid_df['X'], grid_df['Y'])], raster_data=forest_data, raster_transform=forest_transform ) grid_df['Tree_Cover'] = grid_forest # Retrieve water body data at grid points grid_water = get_water_body_at_points( [Point(x, y) for x, y in zip(grid_df['X'], grid_df['Y'])], water_data=water_data, water_transform=water_transform ) grid_df['Water_Body'] = grid_water # Remove grid points with NaN values (i.e., outside data coverage) grid_df = grid_df.dropna(subset=['Elevation', 'Tree_Cover']) # Prepare data for regression prediction X_grid = grid_df[['X', 'Y', 'Elevation', 'Tree_Cover', 'Water_Body']] X_grid_scaled = scaler.transform(X_grid) grid_df['Predicted_Temperature'] = rf_model.predict(X_grid_scaled) # Set up variogram model with adjusted parameters variogram_model = 'spherical' # Adjust these parameters based on your data; you'll need to experiment with them variogram_parameters = {'nugget': 0.2, 'sill': 1.0, 'range': 0.05} # Perform Universal Kriging print("Performing Universal Kriging interpolation for residuals with adjusted variogram parameters...") uk = UniversalKriging( x=data['X'].values, y=data['Y'].values, z=data['Residual'].values, variogram_model=variogram_model, variogram_parameters=variogram_parameters, nlags=20, verbose=True ) z, ss = uk.execute( 'points', grid_df['X'].values, grid_df['Y'].values ) grid_df['Residual'] = z grid_df['Kriging_Variance'] = ss # Handle NaNs in residuals by filling them with zero grid_df['Residual'].fillna(0, inplace=True) # Final temperature estimation grid_df['Temperature'] = grid_df['Predicted_Temperature'] + grid_df['Residual'] num_nans_in_predicted_temp = grid_df['Predicted_Temperature'].isnull().sum() print(f"Number of NaNs in Predicted Temperature: {num_nans_in_predicted_temp}") # Save a copy of the temperature before ECOSTRESS adjustments grid_df['Temperature_No_ECOSTRESS'] = grid_df['Temperature'].copy() # Handle NaNs in residuals by filling them with zero grid_df['Residual'].fillna(0, inplace=True) # Final temperature estimation (before topographic cooling) grid_df['Temperature'] = grid_df['Predicted_Temperature'] + grid_df['Residual'] # Save a copy of the temperature before any adjustments grid_df['Temperature_Before_Adjustments'] = grid_df['Temperature'].copy() # Compute hour angle for cosine function hour_angle = ((hour % 24) / 24) * 2 * math.pi # Convert hour to radians # Compute night_weight: maximum at midnight, zero at noon night_weight = (math.cos(hour_angle) + 1) / 2 # Ranges from 1 at midnight to 0 at noon # Topographic Cooling Effect max_cooling_effect = 3.0 # Maximum cooling effect in degrees Celsius # Normalize elevation to range from 0 to 1 elevation_min = grid_df['Elevation'].min() elevation_max = grid_df['Elevation'].max() grid_df['Normalized_Elevation'] = (grid_df['Elevation'] - elevation_min) / (elevation_max - elevation_min) # Compute the topographic cooling effect grid_df['Topographic_Cooling'] = grid_df['Normalized_Elevation'] * max_cooling_effect * night_weight # Ensure topographic cooling is not applied over water bodies grid_df.loc[grid_df['Water_Body'] == 1, 'Topographic_Cooling'] = 0 # Apply the topographic cooling effect to the temperature grid_df['Temperature'] -= grid_df['Topographic_Cooling'] # ECOSTRESS Adjustments Begin Here # Retrieve ECOSTRESS LST values at grid points (same as before) grid_ecostress = get_raster_value_at_points( [Point(x, y) for x, y in zip(grid_df['X'], grid_df['Y'])], raster_data=ecostress_data, raster_transform=ecostress_transform ) grid_df['ECOSTRESS_LST'] = grid_ecostress # Handle NaNs in ECOSTRESS_LST by filling with the mean value grid_df['ECOSTRESS_LST'].fillna(grid_df['ECOSTRESS_LST'].mean(), inplace=True) # Compute ECOSTRESS anomalies (deviation from mean) ecostress_mean = grid_df['ECOSTRESS_LST'].mean() grid_df['ECOSTRESS_Anomaly'] = grid_df['ECOSTRESS_LST'] - ecostress_mean # Normalize anomalies to range [-1, 1] ecostress_anomaly_min = grid_df['ECOSTRESS_Anomaly'].min() ecostress_anomaly_max = grid_df['ECOSTRESS_Anomaly'].max() grid_df['ECOSTRESS_Anomaly_Normalized'] = ( (grid_df['ECOSTRESS_Anomaly'] - ecostress_anomaly_min) / (ecostress_anomaly_max - ecostress_anomaly_min) * 2 - 1 ) # Increase the impact of ECOSTRESS LST data amplification_factor = 3.0 # Adjust as needed # Compute hour angle for cosine function hour_angle = ((hour % 24) / 24) * 2 * math.pi # Convert hour to radians # Compute night_weight: maximum at midnight, zero at noon night_weight = (math.cos(hour_angle) + 1) / 2 # Ranges from 1 at midnight to 0 at noon # Define threshold for coldest areas (e.g., where ECOSTRESS anomaly is significantly low) coldest_threshold = -0.5 # You can adjust this value coldest_areas_mask = grid_df['ECOSTRESS_Anomaly_Normalized'] <= coldest_threshold # Apply anomalies with the new night_weight and only to coldest areas adjustment = grid_df['ECOSTRESS_Anomaly_Normalized'] * amplification_factor * night_weight # Apply adjustments only in the coldest areas adjustment[coldest_areas_mask] = 0 # Prevent ECOSTRESS adjustments on water bodies adjustment[grid_df['Water_Body'] == 1] = 0 # Limit maximum adjustment to avoid over-adjusting max_adjustment = 5.0 # degrees Celsius adjustment = adjustment.clip(-max_adjustment, max_adjustment) # Apply adjustments to the interpolated temperatures grid_df['Temperature'] += adjustment # Apply cooling effect on water bodies cooling_effect = -2.0 # degrees Celsius grid_df.loc[grid_df['Water_Body'] == 1, 'Temperature'] += cooling_effect # Remove Gaussian smoothing from the interpolated temperature grid # First, create 2D arrays of temperatures without smoothing grid_temperature_no_ecostress = np.full((nrows, ncols), np.nan) grid_temperature_no_ecostress[grid_df['row_idx'], grid_df['col_idx']] = grid_df['Temperature_No_ECOSTRESS'].values grid_temperature_with_ecostress = np.full((nrows, ncols), np.nan) grid_temperature_with_ecostress[grid_df['row_idx'], grid_df['col_idx']] = grid_df['Temperature'].values # Mask the grid_temperature with the Masovian boundary masovian_shape = [masovian_boundary.geometry.unary_union] mask = rasterize( masovian_shape, out_shape=(nrows, ncols), transform=transform, fill=0, all_touched=True, default_value=1, dtype='uint8' ) # Apply the mask grid_temperature_no_ecostress = np.ma.array(grid_temperature_no_ecostress, mask=mask == 0) grid_temperature_with_ecostress = np.ma.array(grid_temperature_with_ecostress, mask=mask == 0) # Use the unsmoothed temperature grids temperature_no_ecostress = grid_temperature_no_ecostress temperature_with_ecostress = grid_temperature_with_ecostress # Also create grid_variance array (we'll skip smoothing variance for simplicity) grid_variance = np.full((nrows, ncols), np.nan) grid_variance[grid_df['row_idx'], grid_df['col_idx']] = grid_df['Kriging_Variance'] grid_variance = np.ma.array(grid_variance, mask=mask == 0) # Compute Standard Deviation from Variance grid_std_dev = np.sqrt(grid_variance) grid_std_dev = np.ma.array(grid_std_dev, mask=mask == 0) # Read the custom color scale from the CSV file color_scale_df = pd.read_csv('input/color_scale.csv') color_scale_df = color_scale_df.sort_values('value') values = color_scale_df['value'].values hex_colors = color_scale_df['color'].values # Ensure colors start with '#' hex_colors = [color if color.startswith('#') else f"#{color}" for color in hex_colors] # Create a custom colormap # Normalize the values to 0..1 vmin = values.min() vmax = values.max() normalized_values = (values - vmin) / (vmax - vmin) # Create a list of tuples (position, color) color_tuples = list(zip(normalized_values, hex_colors)) # Create a LinearSegmentedColormap cmap = mcolors.LinearSegmentedColormap.from_list('custom_cmap', color_tuples) # Set the normalization norm = mcolors.Normalize(vmin=vmin, vmax=vmax) with rasterio.open('input/masovian_dem.tif') as dem_src: # Reproject Masovian boundary to DEM CRS if necessary if masovian_boundary.crs != dem_src.crs: masovian_boundary_dem_crs = masovian_boundary.to_crs(dem_src.crs) else: masovian_boundary_dem_crs = masovian_boundary # Clip the DEM to the Masovian boundary dem_plot_data, dem_plot_transform = rasterio.mask.mask( dem_src, masovian_boundary_dem_crs.geometry, crop=True, filled=True, nodata=np.nan ) # Read the first band (assuming single-band DEM) dem_plot_data = dem_plot_data[0] # Since mask returns data as (bands, rows, cols) # Handle NaNs in the DEM data dem_plot_data = np.nan_to_num(dem_plot_data, nan=np.nanmin(dem_plot_data)) # Calculate the extent of the clipped DEM for plotting dem_left, dem_top = dem_plot_transform * (0, 0) dem_right, dem_bottom = dem_plot_transform * (dem_plot_data.shape[1], dem_plot_data.shape[0]) dem_extent = [dem_left, dem_right, dem_bottom, dem_top] # Compute extent for plotting (same as before) def get_extent(transform, array): x_min = transform.c y_max = transform.f x_max = x_min + transform.a * array.shape[1] y_min = y_max + transform.e * array.shape[0] return [x_min, x_max, y_min, y_max] hs = hillshade(dem_plot_data, azimuth=315, angle_altitude=45) extent = get_extent(transform, temperature_with_ecostress) dem_extent = get_extent(dem_plot_transform, dem_plot_data) # Plotting Temperature Map with ECOSTRESS Adjustments fig1, ax1 = plt.subplots(figsize=(15, 15)) # Plot the interpolated temperature grid with ECOSTRESS adjustments img1 = ax1.imshow(temperature_with_ecostress, extent=extent, origin='upper', cmap=cmap, norm=norm, alpha=1) # Plot hillshade on top ax1.imshow(hs, extent=dem_extent, cmap='gray', origin='upper', alpha=0.3) # Overlay water bodies water_mask = np.where(water_data > 0, 1, 0) # Adjust condition based on water_data values ax1.imshow(water_mask, extent=extent, origin='upper', cmap='Blues', alpha=0.5) # Increased alpha to 0.5 # Plot Masovian Voivodeship boundary with a light, dark stroke masovian_boundary.boundary.plot(ax=ax1, edgecolor='#333333', linewidth=1.5) # Plot stations stations_gdf.plot(ax=ax1, color='black', marker='s', markersize=5) # Remove axes for a minimalistic look ax1.axis('off') # Draw a light, dark stroke around the plot extent from matplotlib.patches import Rectangle rect = Rectangle( (extent[0], extent[2]), # Lower-left corner (x0, y0) extent[1] - extent[0], # Width extent[3] - extent[2], # Height linewidth=1.5, edgecolor='#333333', facecolor='none', transform=ax1.transData ) ax1.add_patch(rect) # Introduce a subtle background gradient from matplotlib.colors import LinearSegmentedColormap background_cmap = LinearSegmentedColormap.from_list( 'background_gradient', ['#ffffff', '#f0f0f0'], N=256) ax1.imshow( np.linspace(0, 1, 256).reshape(1, -1), cmap=background_cmap, extent=(extent[0], extent[1], extent[2], extent[3]), aspect='auto', alpha=0.2, zorder=-1 # Place it below other elements ) # Adjust font properties for a modern look plt.rcParams.update({ 'font.size': 14, # Base font size 'font.family': 'sans-serif', 'font.sans-serif': ['Arial', 'Helvetica', 'DejaVu Sans'], 'text.color': '#333333' }) # Enlarge and reposition the product name (Title) fig1.text( 0.5, 0.94, # Adjusted y-position for better placement "High-Resolution Mesoscale Temperature Analysis", fontsize=28, # Increased font size fontweight='bold', ha='center', va='top', fontname='DejaVu Sans', color='#333333' ) # Move the model name/resolution text closer to the product name text fig1.text( 0.5, 0.91, # Adjusted y-position to move it closer "Model: TempMeso v1.0 (Preview) | Resolution: 250 m", fontsize=18, # Increased font size ha='center', va='top', fontname='DejaVu Sans', color='#666666' ) # Adjust colorbar position and style from mpl_toolkits.axes_grid1 import make_axes_locatable divider = make_axes_locatable(ax1) cax = divider.append_axes("right", size="3%", pad=0.1) cbar1 = fig1.colorbar(img1, cax=cax) ticks = np.arange(np.floor(vmin / 5) * 5, np.ceil(vmax / 5) * 5 + 1, 5) cbar1.set_ticks(ticks) cbar1.set_ticklabels(ticks.astype(int)) cbar1.ax.tick_params(labelsize=14) # Enhance colorbar aesthetics cbar1.outline.set_visible(False) cbar1.ax.yaxis.set_tick_params(width=0.5) cbar1.ax.tick_params(labelsize=14, colors='#333333') # Move the logo to the bottom right corner, directly below the colorbar from matplotlib.offsetbox import OffsetImage, AnnotationBbox import matplotlib.image as mpimg # Read the logo image logo_path = 'input/logo.png' logo_img = mpimg.imread(logo_path) # Adjust the size of the logo logo_zoom = 0.25 imagebox = OffsetImage(logo_img, zoom=logo_zoom) # Get the position of the colorbar axes cbar_bbox = cax.get_position() cbar_x0 = cbar_bbox.x0 # Left cbar_x1 = cbar_bbox.x1 # Right # Calculate the x position for the logo (centered below the colorbar) logo_x = (cbar_x0 + cbar_x1) / 2 # Set the y position as low as possible, but ensure the logo is fully visible logo_y = 0.02 # Adjust this value if necessary ab = AnnotationBbox( imagebox, xy=(logo_x, logo_y), xycoords='figure fraction', frameon=False, box_alignment=(0.5, 0), # Centered horizontally, aligned at bottom ) fig1.add_artist(ab) # Adjust the bottom margin to ensure the logo is not cut off plt.subplots_adjust(left=0.05, right=0.95, top=0.88, bottom=0.05) # On the map, add texts at the coldest and warmest temperature locations # Find the locations of the minimum and maximum temperatures min_temp = np.nanmin(temperature_with_ecostress) max_temp = np.nanmax(temperature_with_ecostress) # Get the indices of the min and max temperatures min_indices = np.unravel_index(np.nanargmin(temperature_with_ecostress), temperature_with_ecostress.shape) max_indices = np.unravel_index(np.nanargmax(temperature_with_ecostress), temperature_with_ecostress.shape) # Convert grid indices to coordinates min_lon, min_lat = rasterio.transform.xy(transform, min_indices[0], min_indices[1]) max_lon, max_lat = rasterio.transform.xy(transform, max_indices[0], max_indices[1]) # Plot the temperature values on the map (without markers) # Use white text with a thick black stroke text_kwargs = dict( fontsize=18, # Increased font size fontname='Arial', ha='center', va='center', color='white', transform=ax1.transData, path_effects=[patheffects.withStroke(linewidth=3, foreground='black')] ) # Format temperature values with one decimal point ax1.text(min_lon, min_lat, f"{min_temp:.1f}", **text_kwargs) ax1.text(max_lon, max_lat, f"{max_temp:.1f}", **text_kwargs) # Save and show the plot plt.savefig('output/temperature_analysis_modern.png', dpi=300) plt.show() print("Updated temperature analysis plot created successfully.") # Now, create the second plot with contours added # Plotting Temperature Map with Contours fig2, ax2 = plt.subplots(figsize=(15, 15)) # Copy the plotting code from the first plot img2 = ax2.imshow(temperature_with_ecostress, extent=extent, origin='upper', cmap=cmap, norm=norm, alpha=1) # Plot hillshade on top ax2.imshow(hs, extent=dem_extent, cmap='gray', origin='upper', alpha=0.3) # Overlay water bodies ax2.imshow(water_mask, extent=extent, origin='upper', cmap='Blues', alpha=0.5) # Plot Masovian Voivodeship boundary with a light, dark stroke masovian_boundary.boundary.plot(ax=ax2, edgecolor='#333333', linewidth=1.5) # Plot stations stations_gdf.plot(ax=ax2, color='black', marker='s', markersize=5) # Remove axes for a minimalistic look ax2.axis('off') # Draw a light, dark stroke around the plot extent rect = Rectangle( (extent[0], extent[2]), # Lower-left corner (x0, y0) extent[1] - extent[0], # Width extent[3] - extent[2], # Height linewidth=1.5, edgecolor='#333333', facecolor='none', transform=ax2.transData ) ax2.add_patch(rect) # Introduce a subtle background gradient ax2.imshow( np.linspace(0, 1, 256).reshape(1, -1), cmap=background_cmap, extent=(extent[0], extent[1], extent[2], extent[3]), aspect='auto', alpha=0.2, zorder=-1 # Place it below other elements ) # Adjust font properties for a modern look plt.rcParams.update({ 'font.size': 14, # Base font size 'font.family': 'sans-serif', 'font.sans-serif': ['Arial', 'Helvetica', 'DejaVu Sans'], 'text.color': '#333333' }) # Enlarge and reposition the product name (Title) fig2.text( 0.5, 0.94, # Adjusted y-position for better placement "High-Resolution Mesoscale Temperature Analysis", fontsize=28, # Increased font size fontweight='bold', ha='center', va='top', fontname='DejaVu Sans', color='#333333' ) # Move the model name/resolution text closer to the product name text fig2.text( 0.5, 0.91, # Adjusted y-position to move it closer "Model: TempMeso v1.0 (Preview) | Resolution: 250 m", fontsize=18, # Increased font size ha='center', va='top', fontname='DejaVu Sans', color='#666666' ) # Adjust colorbar position and style divider = make_axes_locatable(ax2) cax2 = divider.append_axes("right", size="3%", pad=0.1) cbar2 = fig2.colorbar(img2, cax=cax2) cbar2.set_ticks(ticks) cbar2.set_ticklabels(ticks.astype(int)) cbar2.ax.tick_params(labelsize=14) # Enhance colorbar aesthetics cbar2.outline.set_visible(False) cbar2.ax.yaxis.set_tick_params(width=0.5) cbar2.ax.tick_params(labelsize=14, colors='#333333') # Move the logo to the bottom right corner, directly below the colorbar # Read the logo image again for the second plot logo_img2 = mpimg.imread(logo_path) # Adjust the size of the logo imagebox2 = OffsetImage(logo_img2, zoom=logo_zoom) # Get the position of the colorbar axes cbar_bbox2 = cax2.get_position() cbar_x0 = cbar_bbox2.x0 # Left cbar_x1 = cbar_bbox2.x1 # Right # Calculate the x position for the logo (centered below the colorbar) logo_x2 = (cbar_x0 + cbar_x1) / 2 # Set the y position as low as possible, but ensure the logo is fully visible logo_y2 = 0.02 # Adjust this value if necessary ab2 = AnnotationBbox( imagebox2, xy=(logo_x2, logo_y2), xycoords='figure fraction', frameon=False, box_alignment=(0.5, 0), # Centered horizontally, aligned at bottom ) fig2.add_artist(ab2) # Adjust the bottom margin to ensure the logo is not cut off plt.subplots_adjust(left=0.05, right=0.95, top=0.88, bottom=0.05) # On the map, add texts at the coldest and warmest temperature locations ax2.text(min_lon, min_lat, f"{min_temp:.1f}", **text_kwargs) ax2.text(max_lon, max_lat, f"{max_temp:.1f}", **text_kwargs) # Add contours to the plot min_temp_c = np.floor(np.nanmin(temperature_with_ecostress)) max_temp_c = np.ceil(np.nanmax(temperature_with_ecostress)) contour_levels = np.arange(min_temp_c, max_temp_c + 1, 1) contours = ax2.contour( temperature_with_ecostress, levels=contour_levels, colors='black', linewidths=0.5, extent=extent, origin='upper' ) contour_labels = ax2.clabel( contours, inline=False, fontsize=8, fmt='%d', colors='white', inline_spacing=4, manual=False ) for txt in contour_labels: txt.set_path_effects([ patheffects.Stroke(linewidth=3, foreground='black'), patheffects.Normal() ]) # Save and show the plot plt.savefig('output/temperature_analysis_with_contours.png', dpi=300) plt.show() print("Temperature analysis plot with contours created successfully.") return temperature_with_ecostress, transformdef get_elevation_at_points(geometry, dem_data=None, dem_transform=None): from rasterio.transform import rowcol
if dem_data is not None and dem_transform is not None: elevations = [] for point in geometry: x, y = point.x, point.y try: row, col = rowcol(dem_transform, x, y) row = int(row) col = int(col) elevation = dem_data[row, col] elevations.append(elevation) except (IndexError, ValueError): elevations.append(np.nan) return elevations else: raise ValueError("Provide dem_data and dem_transform.")def get_interpolated_temperature_at_point(lat, lon, temperature_grid, transform): """ Given a latitude and longitude, return the interpolated temperature value at that point.
Parameters: - lat, lon: Latitude and longitude of the point. - temperature_grid: The interpolated temperature grid (2D numpy array). - transform: Affine transform for the grid. Returns: - Interpolated temperature value at the point, or None if point is outside the grid. """ from rasterio.transform import rowcol try: row, col = rowcol(transform, lon, lat) # Note that rasterio uses (x, y), so (lon, lat) row = int(row) col = int(col) value = temperature_grid[row, col] if np.ma.is_masked(value) or np.isnan(value): # Value is masked or NaN, meaning outside the interpolated area return None else: return value.item() except (IndexError, ValueError): return None # Point is outside the griddef get_raster_value_at_points(geometry, raster_data=None, raster_transform=None): from rasterio.transform import rowcol
if raster_data is not None and raster_transform is not None: values = [] for point in geometry: x, y = point.x, point.y try: row, col = rowcol(raster_transform, x, y) row = int(row) col = int(col) if (0 <= row < raster_data.shape[0]) and (0 <= col < raster_data.shape[1]): value = raster_data[row, col] # Check for NaN in raster data if np.isnan(value): values.append(np.nan) else: values.append(value) else: values.append(np.nan) except (IndexError, ValueError): values.append(np.nan) return values else: raise ValueError("Provide raster_data and raster_transform.")def get_water_body_at_points(geometry, water_data=None, water_transform=None): from rasterio.transform import rowcol
if water_data is not None and water_transform is not None: water_bodies = [] for point in geometry: x, y = point.x, point.y try: row, col = rowcol(water_transform, x, y) row = int(row) col = int(col) if (0 <= row < water_data.shape[0]) and (0 <= col < water_data.shape[1]): value = water_data[row, col] # Adjust the condition based on your raster's water encoding # For binary raster where 1 = water, 0 = land water_bodies.append(1 if value else 0) else: water_bodies.append(0) except (IndexError, ValueError): water_bodies.append(0) return water_bodies else: raise ValueError("Provide water_data and water_transform.")def read_and_clip_dem(masovian_boundary): dem_path = 'input/masovian_dem.tif' with rasterio.open(dem_path) as src: print("Assuming DEM is in EPSG:4326; skipping reprojection.") dem_data = src.read(1, masked=True) dem_transform = src.transform return dem_data, dem_transform
def read_and_clip_forest(masovian_boundary): forest_path = 'input/forests.tif' with rasterio.open(forest_path) as src: print("Assuming forest cover raster is in EPSG:4326; skipping reprojection.") forest_data = src.read(1, masked=True) forest_data = np.where(forest_data == src.nodata, 0, forest_data) forest_transform = src.transform return forest_data, forest_transform
def read_and_clip_water_bodies(masovian_boundary): water_path = 'input/water_bodies.tif' with rasterio.open(water_path) as src: print("Reading and clipping water bodies raster to Masovian boundaries.")
# Ensure the Masovian boundary is in the same CRS as the water raster if masovian_boundary.crs != src.crs: masovian_boundary = masovian_boundary.to_crs(src.crs) print("Reprojected Masovian boundary to match water body raster CRS.") else: print("Masovian boundary CRS matches water body raster CRS.") # Perform the clipping clipped_water, water_transform = rasterio.mask.mask( src, masovian_boundary.geometry, crop=True, filled=True, nodata=0 ) # Read the first band (assuming single-band raster) water_data = clipped_water[0] # Handle NoData values by setting them to 0 (assuming 0 represents no water) water_data = np.where(water_data == src.nodata, 0, water_data) return water_data, water_transformdef read_and_clip_ecostress(masovian_boundary): ecostress_path = 'input/raw_ecostress.tif' with rasterio.open(ecostress_path) as src: print("Reading ECOSTRESS LST data (assumed to be in degrees Celsius).") # Read data ecostress_data = src.read(1, masked=True) ecostress_data = np.where(ecostress_data == src.nodata, np.nan, ecostress_data) ecostress_transform = src.transform return ecostress_data, ecostress_transform
Main execution flow
if name == "main": # Fetch Traxelektronik data trax_stations, trax_temperatures = fetch_traxelektronik_data()
# Geocode Traxelektronik stations geolocator = Nominatim(user_agent="geoapi") trax_coords = {} progress_bar = tqdm(total=len(trax_stations), desc="Geocoding Traxelektronik Stations", unit="station") for station in trax_stations: cleaned_station = clean_station_name(station) coords, was_cleaned = get_coordinates(cleaned_station, geolocator) if coords: trax_coords[cleaned_station] = coords # Use cleaned station names as keys progress_bar.update(1) progress_bar.close() # Fetch Netatmo data netatmo_stations, netatmo_temperatures, netatmo_coords = fetch_netatmo_data() # Fetch IMGW data imgw_stations, imgw_temperatures, imgw_station_ids = fetch_imgw_data() # Geocode IMGW stations imgw_coords = {} progress_bar = tqdm(total=len(imgw_stations), desc="Geocoding IMGW Stations", unit="station") for station in imgw_stations: coords, was_cleaned = get_coordinates(station, geolocator) if coords: imgw_coords[station] = coords progress_bar.update(1) progress_bar.close() # After plotting, get the interpolated temperature at specific coordinates # Coordinates to test test_lat = 51.40118 test_lon = 21.14805 smoothed_temperature, transform = plot_stations_with_boundary_and_interpolation( trax_stations, trax_temperatures, trax_coords, netatmo_stations, netatmo_temperatures, netatmo_coords, imgw_stations, imgw_temperatures, imgw_coords ) interpolated_temp = get_interpolated_temperature_at_point( test_lat, test_lon, smoothed_temperature, transform ) if interpolated_temp is not None: print(f"Interpolated temperature value at {test_lat}, {test_lon} is {interpolated_temp:.2f}°C") else: print(f"Coordinates {test_lat}, {test_lon} are outside the interpolated grid or have no data.")Can you make here so in the second plot that uses contours it will create the plot only for this bounding box: 20.188477,51.017203,22.061646,51.821759 (EPSG:4326 coordinates)?
- Assistant
Certainly! To modify the second plot to only display data within the specified bounding box
(xmin, ymin, xmax, ymax) = (20.188477, 51.017203, 22.061646, 51.821759), you need to adjust the plotting code to:- Extract the subset of the data arrays (
temperature_with_ecostress,hs,water_mask, etc.) that fall within the bounding box. - Adjust the affine transform to match the subset data.
- Filter your station data (
stations_gdf) to include only stations within the bounding box. - Plot using the subset data and adjusted transform.
Below is the step-by-step modification you need to make in your
plot_stations_with_boundary_and_interpolationfunction.Step 1: Modify the Second Plot in Your Function
Locate the section where you're creating the second plot (with contours). It should be towards the end of your
plot_stations_with_boundary_and_interpolationfunction. You'll adjust the code to:- Define the bounding box.
- Compute row and column indices corresponding to the bounding box.
- Extract subsets of your data arrays.
- Adjust the affine transform for the subsets.
- Filter the GeoDataFrames for stations and boundaries.
- Plot using the subsets.
Here's the modified code with detailed comments explaining each step:
def plot_stations_with_boundary_and_interpolation( trax_stations, trax_temperatures, trax_coords, netatmo_stations, netatmo_temperatures, netatmo_coords, imgw_stations, imgw_temperatures, imgw_coords): # ... [Your existing code above remains unchanged] # Now, create the second plot with contours added # *** Begin of modifications for bounding box *** # Bounding box coordinates (EPSG:4326) xmin, ymin, xmax, ymax = 20.188477, 51.017203, 22.061646, 51.821759 # Get the shape of the temperature_with_ecostress array nrows, ncols = temperature_with_ecostress.shape from rasterio.transform import rowcol # Compute the row and column indices for the upper-left and lower-right corners row_ul, col_ul = rowcol(transform, xmin, ymax) row_lr, col_lr = rowcol(transform, xmax, ymin) # Ensure indices are integers row_ul = int(row_ul) col_ul = int(col_ul) row_lr = int(row_lr) col_lr = int(col_lr) # Ensure indices are within valid ranges row_ul = max(0, min(nrows - 1, row_ul)) row_lr = max(0, min(nrows - 1, row_lr)) col_ul = max(0, min(ncols - 1, col_ul)) col_lr = max(0, min(ncols - 1, col_lr)) # Ensure row_ul <= row_lr and col_ul <= col_lr if row_ul > row_lr: row_ul, row_lr = row_lr, row_ul if col_ul > col_lr: col_ul, col_lr = col_lr, col_ul # Extract the subset arrays temperature_subset = temperature_with_ecostress[row_ul:row_lr+1, col_ul:col_lr+1] hs_subset = hs[row_ul:row_lr+1, col_ul:col_lr+1] water_mask_subset = water_mask[row_ul:row_lr+1, col_ul:col_lr+1] # Compute the new transform grid_spacing_x = transform.a # Positive grid spacing in x direction grid_spacing_y = transform.e # Negative grid spacing in y direction new_x_min = transform.c + col_ul * grid_spacing_x new_y_max = transform.f + row_ul * grid_spacing_y # grid_spacing_y is negative from rasterio.transform import from_origin new_transform = from_origin(new_x_min, new_y_max, grid_spacing_x, -grid_spacing_y) # Compute the new extent extent_subset = get_extent(new_transform, temperature_subset) # Filter stations within the bounding box from shapely.geometry import box bbox_polygon = box(xmin, ymin, xmax, ymax) stations_in_bbox = stations_gdf[stations_gdf.geometry.within(bbox_polygon)] # Clip the Masovian boundary to the bounding box masovian_boundary_clipped = masovian_boundary.clip(bbox_polygon) # *** End of modifications for bounding box *** # Plotting Temperature Map with Contours for the subset fig2, ax2 = plt.subplots(figsize=(15, 15)) # Plot the subset of the interpolated temperature grid with ECOSTRESS adjustments img2 = ax2.imshow(temperature_subset, extent=extent_subset, origin='upper', cmap=cmap, norm=norm, alpha=1) # Plot the subset hillshade on top ax2.imshow(hs_subset, extent=extent_subset, cmap='gray', origin='upper', alpha=0.3) # Overlay water bodies ax2.imshow(water_mask_subset, extent=extent_subset, origin='upper', cmap='Blues', alpha=0.5) # Plot the clipped Masovian Voivodeship boundary masovian_boundary_clipped.boundary.plot(ax=ax2, edgecolor='#333333', linewidth=1.5) # Plot stations within the bounding box stations_in_bbox.plot(ax=ax2, color='black', marker='s', markersize=5) # Remove axes for a minimalistic look ax2.axis('off') # Draw a light, dark stroke around the plot extent from matplotlib.patches import Rectangle rect = Rectangle( (extent_subset[0], extent_subset[2]), # Lower-left corner (x0, y0) extent_subset[1] - extent_subset[0], # Width extent_subset[3] - extent_subset[2], # Height linewidth=1.5, edgecolor='#333333', facecolor='none', transform=ax2.transData ) ax2.add_patch(rect) # ... [Rest of your plotting code remains unchanged, using the subset data] # On the map, add texts at the coldest and warmest temperature locations # Find the locations of the minimum and maximum temperatures in the subset min_temp = np.nanmin(temperature_subset) max_temp = np.nanmax(temperature_subset) # Get the indices of the min and max temperatures within the subset array min_indices = np.unravel_index(np.nanargmin(temperature_subset), temperature_subset.shape) max_indices = np.unravel_index(np.nanargmax(temperature_subset), temperature_subset.shape) # Convert grid indices to coordinates using the new_transform from rasterio.transform import xy min_lon, min_lat = xy(new_transform, min_indices[0], min_indices[1]) max_lon, max_lat = xy(new_transform, max_indices[0], max_indices[1]) # Plot the temperature values on the map (without markers) # Use white text with a thick black stroke text_kwargs = dict( fontsize=18, # Increased font size fontname='Arial', ha='center', va='center', color='white', transform=ax2.transData, path_effects=[patheffects.withStroke(linewidth=3, foreground='black')] ) # Format temperature values with one decimal point ax2.text(min_lon, min_lat, f"{min_temp:.1f}", **text_kwargs) ax2.text(max_lon, max_lat, f"{max_temp:.1f}", **text_kwargs) # Add contours to the plot min_temp_c = np.floor(min_temp) max_temp_c = np.ceil(max_temp) contour_levels = np.arange(min_temp_c, max_temp_c + 1, 1) contours = ax2.contour( temperature_subset, levels=contour_levels, colors='black', linewidths=0.5, extent=extent_subset, origin='upper' ) contour_labels = ax2.clabel( contours, inline=False, fontsize=8, fmt='%d', colors='white', inline_spacing=4, manual=False ) for txt in contour_labels: txt.set_path_effects([ patheffects.Stroke(linewidth=3, foreground='black'), patheffects.Normal() ]) # ... [Rest of your plotting code remains unchanged, adjusting any variables if necessary] # Save and show the plot plt.savefig('output/temperature_analysis_with_contours.png', dpi=300) plt.show() print("Temperature analysis plot with contours created successfully.") return temperature_with_ecostress, transformExplanation of the Modifications:
-
Defining the Bounding Box:
# Bounding box coordinates (EPSG:4326) xmin, ymin, xmax, ymax = 20.188477, 51.017203, 22.061646, 51.821759 -
Computing Row and Column Indices:
We use
rasterio.transform.rowcolto find the corresponding row and column indices in the array for the bounding box coordinates.row_ul, col_ul = rowcol(transform, xmin, ymax) row_lr, col_lr = rowcol(transform, xmax, ymin) -
Extracting Subsets of the Arrays:
We slice the arrays using the computed indices to obtain the data within the bounding box.
temperature_subset = temperature_with_ecostress[row_ul:row_lr+1, col_ul:col_lr+1] hs_subset = hs[row_ul:row_lr+1, col_ul:col_lr+1] water_mask_subset = water_mask[row_ul:row_lr+1, col_ul:col_lr+1] -
Adjusting the Transform:
We adjust the affine transform to match the subset by updating the origin point based on the indices.
new_x_min = transform.c + col_ul * grid_spacing_x new_y_max = transform.f + row_ul * grid_spacing_y new_transform = from_origin(new_x_min, new_y_max, grid_spacing_x, -grid_spacing_y) -
Computing the New Extent:
We compute the extent for the subset data to ensure accurate plotting.
extent_subset = get_extent(new_transform, temperature_subset) -
Filtering the Stations:
We filter the
stations_gdfGeoDataFrame to include only the stations within the bounding box.from shapely.geometry import box bbox_polygon = box(xmin, ymin, xmax, ymax) stations_in_bbox = stations_gdf[stations_gdf.geometry.within(bbox_polygon)] -
Plotting with Subset Data:
We proceed to plot using the subset data arrays and the adjusted transform. Be sure to use
extent_subsetand the subset arrays in your plotting calls.img2 = ax2.imshow(temperature_subset, extent=extent_subset, origin='upper', cmap=cmap, norm=norm, alpha=1) # ... and so on for other plot elements -
Adjusting Other Plot Elements:
Ensure that you use the subset data when adding contours, annotations, and other plot elements.
Important Notes:
-
Coordinate Systems: All coordinates are assumed to be in EPSG:4326. Ensure that all your data (arrays and GeoDataFrames) are in the same coordinate system to avoid misalignment.
-
Array Indexing: Remember that in image arrays, the first index corresponds to the row (y-axis), and the second to the column (x-axis). Also, array indices in Python start from 0.
-
Transform Adjustments: When slicing arrays and adjusting transforms, ensure that the pixel sizes (
grid_spacing_x,grid_spacing_y) and origins (new_x_min,new_y_max) are correctly computed based on the grid spacing and index positions. -
Clipping GeoDataFrames: The
clipmethod in GeoPandas can be used to clip a GeoDataFrame to a specified bounding box or polygon.
Final Steps:
After making these modifications, your second plot should display only the data within the specified bounding box, with all elements (temperature data, hillshade, water bodies, contours, stations, boundaries) correctly aligned and displayed within that region.
Testing:
-
Verify the Plot: After running the code, check that the second plot indeed shows only the area within the bounding box with accurate data.
-
Coordinate Validation: Optionally, add print statements or logs to confirm that the coordinates and indices are computed as expected.
Conclusion:
By following these steps and adjusting your code accordingly, you'll be able to produce the second plot limited to the specified bounding box.
Let me know if you have any questions or need further assistance!
- Extract the subset of the data arrays (