From b42b013efdeb306b6e01e7d5fdb6d2d7de4bc259 Mon Sep 17 00:00:00 2001 From: Tina Odaka <46813815+tinaok@users.noreply.github.com> Date: Fri, 29 May 2026 04:34:29 +0000 Subject: [PATCH 1/3] switch to polygon from bbox --- notebook/Create_ROI_from_bbox_with_O2.ipynb | 604 ++++++++++++++++++++ 1 file changed, 604 insertions(+) create mode 100644 notebook/Create_ROI_from_bbox_with_O2.ipynb diff --git a/notebook/Create_ROI_from_bbox_with_O2.ipynb b/notebook/Create_ROI_from_bbox_with_O2.ipynb new file mode 100644 index 0000000..26cc61f --- /dev/null +++ b/notebook/Create_ROI_from_bbox_with_O2.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b21a9518", + "metadata": {}, + "source": [ + "# Create ROI from a bounding box (EPSG:4326) → HEALPix ROI\n", + "\n", + "This notebook converts a lon/lat **bounding box** into a **HEALPix (nested) ROI**, using `healpix-geo`.\n", + "\n", + "## What you’ll get\n", + "- **child-level** HEALPix cell IDs that cover the bbox\n", + "- **parent-level** cell IDs (optional coarser ROI)\n", + "- a **boundary footprint** polygon for plotting / masking workflows\n", + "\n", + "\n", + "## Steps\n", + "1. **Imports & helper(s)** \n", + " Load dependencies and define helper function(s) used for boundary construction/plotting.\n", + "\n", + "2. **Define bbox and compute child-level coverage** \n", + " Set (lon_min, lat_min, lon_max, lat_max) and child_level, then define a polygon from lon/lat vertices to focus the coverage on the target coastal area. For this use case, we chose a polygon that mainly covers the coastal area within the hypoxigenic region.\n", + "\n", + "3. **Convert to parent level and save IDs** \n", + " Set `parent_level`, convert `child_ids → parent_ids`, deduplicate, and save to `parent_ids.npz`.\n", + "\n", + "4. **Build outer boundary ring and export footprint** \n", + " Choose `edge_level`, compute an outer ring around the ROI, build a boundary polygon, and export to `outer_boundary.geojson`.5. Build/plot a boundary footprint, save them to geojson\n", + "\n", + "## Tuning\n", + "If the ROI boundary looks “cut” or missing along edges, increase the boundary refinement.\n", + "Here we use :\n", + "- `edge_level = child_level - 2` \n", + "\n", + "## Output \n", + "Save exported ROI Parent cell IDs / Parent level(`parent_ids.npz`) and footprint GeoJSON (`outer_boundary.geojson`) so `Prep_regrid.ipynb` can reuse them for masking/subsetting.\n" + ] + }, + { + "cell_type": "markdown", + "id": "9783fcc3", + "metadata": {}, + "source": [ + "## Step 1 — Imports and helper functions\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1bdbe605-3dd8-41ac-ba7a-fdd7dfbf2936", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: grid4earth in /srv/conda/envs/notebook/lib/python3.12/site-packages (2026.5.5)\n", + "Requirement already satisfied: healpix-geo==0.1.2 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from grid4earth) (0.1.2)\n", + "Requirement already satisfied: healpix-plot==2026.5.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from grid4earth) (2026.5.1)\n", + "Requirement already satisfied: healpix-analyse==2026.5.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from grid4earth) (2026.5.1)\n", + "Requirement already satisfied: healpix-resample==2026.5.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from grid4earth) (2026.5.1)\n", + "Requirement already satisfied: numpy in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-analyse==2026.5.1->grid4earth) (2.3.5)\n", + "Requirement already satisfied: torch in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-analyse==2026.5.1->grid4earth) (2.12.0)\n", + "Requirement already satisfied: pyproj>=3.6 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-analyse==2026.5.1->grid4earth) (3.7.2)\n", + "Requirement already satisfied: matplotlib in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-plot==2026.5.1->grid4earth) (3.10.8)\n", + "Requirement already satisfied: cartopy in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-plot==2026.5.1->grid4earth) (0.25.0)\n", + "Requirement already satisfied: numpy_groupies in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-plot==2026.5.1->grid4earth) (0.11.3)\n", + "Requirement already satisfied: affine in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-plot==2026.5.1->grid4earth) (2.4.0)\n", + "Requirement already satisfied: scipy in /srv/conda/envs/notebook/lib/python3.12/site-packages (from healpix-plot==2026.5.1->grid4earth) (1.17.0)\n", + "Requirement already satisfied: certifi in /srv/conda/envs/notebook/lib/python3.12/site-packages (from pyproj>=3.6->healpix-analyse==2026.5.1->grid4earth) (2026.1.4)\n", + "Requirement already satisfied: shapely>=2.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cartopy->healpix-plot==2026.5.1->grid4earth) (2.1.2)\n", + "Requirement already satisfied: packaging>=21 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cartopy->healpix-plot==2026.5.1->grid4earth) (26.0)\n", + "Requirement already satisfied: pyshp>=2.3 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cartopy->healpix-plot==2026.5.1->grid4earth) (3.0.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (4.61.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (1.4.9)\n", + "Requirement already satisfied: pillow>=8 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (12.1.0)\n", + "Requirement already satisfied: pyparsing>=3 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from matplotlib->healpix-plot==2026.5.1->grid4earth) (2.9.0)\n", + "Requirement already satisfied: six>=1.5 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib->healpix-plot==2026.5.1->grid4earth) (1.17.0)\n", + "Requirement already satisfied: filelock in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (3.20.3)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (4.15.0)\n", + "Requirement already satisfied: setuptools<82 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (80.10.2)\n", + "Requirement already satisfied: sympy>=1.13.3 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (2026.1.0)\n", + "Requirement already satisfied: cuda-toolkit==13.0.2 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.2)\n", + "Requirement already satisfied: nvidia-cublas<=13.1.1.3,>=13.1.0.3 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (13.1.1.3)\n", + "Requirement already satisfied: cuda-bindings<14,>=13.0.3 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (13.3.0)\n", + "Requirement already satisfied: nvidia-cudnn-cu13==9.20.0.48 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (9.20.0.48)\n", + "Requirement already satisfied: nvidia-cusparselt-cu13==0.8.1 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (0.8.1)\n", + "Requirement already satisfied: nvidia-nccl-cu13==2.29.7 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (2.29.7)\n", + "Requirement already satisfied: nvidia-nvshmem-cu13==3.4.5 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (3.4.5)\n", + "Requirement already satisfied: triton==3.7.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from torch->healpix-analyse==2026.5.1->grid4earth) (3.7.0)\n", + "Requirement already satisfied: nvidia-cuda-runtime==13.0.96.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.96)\n", + "Requirement already satisfied: nvidia-cufft==12.0.0.61.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (12.0.0.61)\n", + "Requirement already satisfied: nvidia-cufile==1.15.1.6.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (1.15.1.6)\n", + "Requirement already satisfied: nvidia-cuda-cupti==13.0.85.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.85)\n", + "Requirement already satisfied: nvidia-curand==10.4.0.35.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (10.4.0.35)\n", + "Requirement already satisfied: nvidia-cusolver==12.0.4.66.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (12.0.4.66)\n", + "Requirement already satisfied: nvidia-cusparse==12.6.3.3.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (12.6.3.3)\n", + "Requirement already satisfied: nvidia-nvjitlink==13.0.88.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.88)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc==13.0.88.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.88)\n", + "Requirement already satisfied: nvidia-nvtx==13.0.85.* in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-toolkit[cudart,cufft,cufile,cupti,curand,cusolver,cusparse,nvjitlink,nvrtc,nvtx]==13.0.2; platform_system == \"Linux\"->torch->healpix-analyse==2026.5.1->grid4earth) (13.0.85)\n", + "Requirement already satisfied: cuda-pathfinder>=1.4.2 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from cuda-bindings<14,>=13.0.3->torch->healpix-analyse==2026.5.1->grid4earth) (1.5.5)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from sympy>=1.13.3->torch->healpix-analyse==2026.5.1->grid4earth) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /srv/conda/envs/notebook/lib/python3.12/site-packages (from jinja2->torch->healpix-analyse==2026.5.1->grid4earth) (3.0.3)\n" + ] + } + ], + "source": [ + "!pip install grid4earth" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9dbf9913-c18c-4c0c-a51f-fd701ef79fc0", + "metadata": {}, + "outputs": [], + "source": [ + "import geopandas as gpd\n", + "import healpix_geo\n", + "import numpy as np\n", + "from shapely.geometry import Polygon, box\n", + "from shapely.ops import transform, unary_union" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9e7cd105-4243-4b7f-8206-3388a6a09d7c", + "metadata": {}, + "outputs": [], + "source": [ + "def get_boundary(cell_ids, level, plot=False):\n", + " lonv, latv = healpix_geo.nested.vertices(cell_ids, depth=level, ellipsoid=\"WGS84\")\n", + "\n", + " def _unwrap_dateline(lons):\n", + " lons = np.asarray(lons, dtype=float).copy()\n", + " if (np.nanmax(lons) - np.nanmin(lons)) > 180:\n", + " lons[lons < 0] += 360\n", + " return lons\n", + "\n", + " polys = []\n", + " for i in range(lonv.shape[0]):\n", + " xs = _unwrap_dateline(lonv[i])\n", + " ys = latv[i]\n", + " # print(lonv[i],xs)\n", + " coords = list(zip(xs, ys))\n", + " if coords[0] != coords[-1]:\n", + " coords.append(coords[0])\n", + " polys.append(Polygon(coords))\n", + "\n", + " footprint = unary_union(polys) # Polygon or MultiPolygon\n", + "\n", + " # Wrap final footprint to [-180, 180] for plotting/overlay with lon=-180..180 data\n", + " footprint_180 = transform(wrap_lon_180, footprint)\n", + "\n", + " if plot:\n", + " gdf_fp = gpd.GeoDataFrame(\n", + " {\"name\": [\"footprint\"]},\n", + " geometry=[footprint_180],\n", + " crs=\"EPSG:4326\",\n", + " )\n", + " ax = gdf_fp.plot(edgecolor=\"k\", facecolor=\"none\", linewidth=2)\n", + " ax.set_aspect(\"equal\")\n", + "\n", + " return footprint_180\n", + "\n", + "\n", + "def wrap_lon_180(x, y, z=None):\n", + " x = ((np.asarray(x) + 180) % 360) - 180\n", + " return (x, y) if z is None else (x, y, z)" + ] + }, + { + "cell_type": "markdown", + "id": "3035095a", + "metadata": {}, + "source": [ + "## Step 2 — Define the ROI bounding box\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bf44fd10-b421-420e-b4c6-5dcb384cfe46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N level 13 cells covering former bbox: 3218\n", + "N level 13 cells covering bbox: 11966\n", + "N level 13 cells covering polygon: 6658\n" + ] + } + ], + "source": [ + "# Find out child (data projected ) cell_ids\n", + "\n", + "# Define The child_level\n", + "child_level = 13\n", + "\n", + "\n", + "# Define The ROI bbox in (lon/lat)\n", + "lon_min, lon_max = -2.8, -1.97333\n", + "lat_min, lat_max = 47.04367, 47.31558\n", + "bbox = (lon_min, lat_min, lon_max, lat_max)\n", + "\n", + "\n", + "child_ids, _, _ = healpix_geo.nested.zone_coverage(\n", + " bbox=bbox,\n", + " depth=child_level,\n", + " ellipsoid=\"WGS84\",\n", + " flat=True, # returns a 1D array of cell ids\n", + ")\n", + "print(f\"N level {child_level} cells covering former bbox: {child_ids.size}\")\n", + "\n", + "\n", + "\n", + "lon_min, lon_max = -3.3, -1.97333\n", + "lat_min, lat_max = 47.04367, 47.6\n", + "lat_min, lat_max = 47.04367, 47.7\n", + "\n", + "bbox = (lon_min, lat_min, lon_max, lat_max)\n", + "\n", + "\n", + "# Find out child (data projected ) cell_ids\n", + "\n", + "child_ids, _, _ = healpix_geo.nested.zone_coverage(\n", + " bbox=bbox,\n", + " depth=child_level,\n", + " ellipsoid=\"WGS84\",\n", + " flat=True, # returns a 1D array of cell ids\n", + ")\n", + "print(f\"N level {child_level} cells covering bbox: {child_ids.size}\")\n", + "\n", + "\n", + "# Convert bbox to polygon vertices: (lon, lat)\n", + "\n", + "# Important: close the polygon by repeating the first point at the end\n", + "\n", + "vertices = np.array([\n", + "\n", + " [lon_min, lat_min],\n", + "\n", + " [lon_max, lat_min],\n", + "\n", + " [lon_max, lat_max],\n", + "\n", + " [lon_min, lat_max],\n", + "\n", + " [lon_min, lat_min],\n", + "\n", + "])\n", + "\n", + "vertices = np.array([\n", + "\n", + " [-3.30, 47.48], # left / northwest\n", + "\n", + " [-3.24, 47.58],\n", + "\n", + " [-3.15, 47.66],\n", + "\n", + " [-3.02, 47.70],\n", + "\n", + " [-2.86, 47.68],\n", + "\n", + " [-2.65, 47.61],\n", + "\n", + " [-2.42, 47.50],\n", + "\n", + " [-2.22, 47.42],\n", + "\n", + " [-2.02, 47.34],\n", + "\n", + " [-1.90, 47.25],\n", + "\n", + " [-1.94, 47.12],\n", + "\n", + " [-2.10, 47.04],\n", + "\n", + " [-2.35, 47.08],\n", + "\n", + " [-2.58, 47.16],\n", + "\n", + " [-2.78, 47.24],\n", + "\n", + " [-3.00, 47.30],\n", + "\n", + " [-3.20, 47.38],\n", + "\n", + " [-3.30, 47.48], # close polygon\n", + "\n", + "])\n", + "\n", + "# Find child HEALPix cell ids covering the polygon\n", + "\n", + "child_ids, depths, fully_covered = healpix_geo.nested.polygon_coverage(\n", + "\n", + " vertices=vertices,\n", + "\n", + " depth=child_level,\n", + "\n", + " ellipsoid=\"WGS84\",\n", + "\n", + " flat=True,\n", + "\n", + ")\n", + "print(f\"N level {child_level} cells covering polygon: {child_ids.size}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5888c079", + "metadata": {}, + "source": [ + "## Step 3 — Compute HEALPix coverage (child → parent) and save IDs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "756137ec-5821-45e2-97fc-dd8ff97983f0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N parent level 10 cells: 140\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Find out full parent cell id corresponding to the child (data projected ) cell_ids\n", + "\n", + "parent_level = 10\n", + "\n", + "# 2) Map child ids to parent ids\n", + "parent_ids = healpix_geo.nested.zoom_to(\n", + " child_ids,\n", + " depth=child_level,\n", + " new_depth=parent_level,\n", + ")\n", + "parent_ids, counts = np.unique(parent_ids, return_counts=True)\n", + "\n", + "print(f\"N parent level {parent_level} cells: {parent_ids.size}\")\n", + "# save parent_ids\n", + "np.savez(\n", + " \"parent_ids.npz\",\n", + " parent_ids=parent_ids,\n", + " parent_level=parent_level,\n", + ")\n", + "# plot the parent cell ids\n", + "get_boundary(parent_ids, parent_level)" + ] + }, + { + "cell_type": "markdown", + "id": "3f9cbb76-6d50-4d63-9d18-9d0151cffc3b", + "metadata": {}, + "source": [ + "## Step 4 — Build boundary footprint (parent + outer ring) and export GeoJSON\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "61876ce1-6048-4f27-b8f3-78772bff487e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "boundary region is in level 11\n", + "N edges level 11 cells: 560\n" + ] + } + ], + "source": [ + "# translate these parent_cell ids in edge_level.\n", + "edge_level = child_level - 2\n", + "print(\"boundary region is in level\", edge_level)\n", + "##keep only the outer boundary cells from edges_ids\n", + "# edges_ids = healpix_geo.nested.internal_boundary(edge_level, edges_ids)\n", + "edges_ids = healpix_geo.nested.zoom_to(\n", + " # boundary_parents_ids,\n", + " parent_ids,\n", + " depth=parent_level,\n", + " new_depth=edge_level,\n", + ")\n", + "edges_ids = np.unique(edges_ids, return_counts=False)\n", + "print(f\"N edges level {edge_level} cells: {edges_ids.size}\")\n", + "\n", + "# get_boundary(edges_ids,edge_level)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0c797482-c437-4222-8fdf-9cbd1a2fa5e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N edges level 11 outer edges cells: 720\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# find N+1 neighbour in edge_level\n", + "outer_edges_ids = np.unique(\n", + " healpix_geo.nested.kth_neighbourhood(\n", + " edges_ids, edge_level, ring=1, num_threads=0\n", + " ), # return_counts=True\n", + ")\n", + "print(f\"N edges level {edge_level} outer edges cells: {outer_edges_ids.size}\")\n", + "outer_boundary = get_boundary(outer_edges_ids, edge_level)\n", + "outer_boundary" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "df4e3918-2ca8-401b-9e26-33bdff72f19c", + "metadata": {}, + "outputs": [], + "source": [ + "gdf = gpd.GeoDataFrame(\n", + " {\"name\": [\"outer_boundary\"]},\n", + " geometry=[outer_boundary],\n", + " crs=\"EPSG:4326\",\n", + ")\n", + "\n", + "gdf.to_file(\"outer_boundary.geojson\", driver=\"GeoJSON\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9bd68e11-5795-4930-b86b-5fffa5c7ea52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import geopandas as gpd\n", + "from shapely.geometry import Polygon, box\n", + "\n", + "fig, ax = plt.subplots(\n", + " subplot_kw={\"projection\": ccrs.PlateCarree()},\n", + " figsize=(7, 7),\n", + ")\n", + "\n", + "gdf_fp = gpd.GeoDataFrame(\n", + " {\"name\": [\"parent_ids\"]},\n", + " geometry=[get_boundary(parent_ids, parent_level, plot=False)],\n", + " crs=\"EPSG:4326\",\n", + ")\n", + "gdf_fp.plot(ax=ax, edgecolor=\"red\", facecolor=\"none\", linewidth=2)\n", + "\n", + "gdf.plot(ax=ax, edgecolor=\"blue\", facecolor=\"none\", linewidth=2)\n", + "\n", + "gdf_bbox = gpd.GeoDataFrame(\n", + " {\"name\": [\"bbox\"]},\n", + " geometry=[box(*bbox)],\n", + " crs=\"EPSG:4326\",\n", + ")\n", + "gdf_bbox.plot(\n", + " ax=ax,\n", + " edgecolor=\"green\",\n", + " facecolor=\"none\",\n", + " linewidth=2,\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "gdf_polygon = gpd.GeoDataFrame(\n", + " {\"name\": [\"polygon\"]},\n", + " geometry=[Polygon(vertices)],\n", + " crs=\"EPSG:4326\",\n", + ")\n", + "gdf_polygon.plot(\n", + " ax=ax,\n", + " edgecolor=\"magenta\",\n", + " facecolor=\"none\",\n", + " linewidth=4,\n", + ")\n", + "\n", + "ax.scatter(\n", + " vertices[:, 0],\n", + " vertices[:, 1],\n", + " color=\"black\",\n", + " s=30,\n", + " zorder=10,\n", + ")\n", + "\n", + "ax.coastlines(resolution=\"10m\", linewidth=0.8)\n", + "ax.set_aspect(\"equal\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "984f3a86-328c-4f78-955b-4ef85de3b17f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "622dc345-532d-4df3-8a23-566c4e6b7e30", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6d91895-6333-4a4b-b483-dc366a542e84", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 5d4439a79009c77a7fe380891999fc1a18e1e8f8 Mon Sep 17 00:00:00 2001 From: Anne Fouilloux Date: Fri, 29 May 2026 12:01:43 +0200 Subject: [PATCH 2/3] fix ruff: drop duplicate imports in Create_ROI_from_bbox_with_O2 Polygon, box and gpd are already imported in the earlier cell, and the remaining cartopy/geopandas/matplotlib imports are now sorted. Co-Authored-By: Claude Opus 4.7 (1M context) --- notebook/Create_ROI_from_bbox_with_O2.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/notebook/Create_ROI_from_bbox_with_O2.ipynb b/notebook/Create_ROI_from_bbox_with_O2.ipynb index 26cc61f..008445f 100644 --- a/notebook/Create_ROI_from_bbox_with_O2.ipynb +++ b/notebook/Create_ROI_from_bbox_with_O2.ipynb @@ -500,9 +500,8 @@ ], "source": [ "import cartopy.crs as ccrs\n", - "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", - "from shapely.geometry import Polygon, box\n", + "import matplotlib.pyplot as plt\n", "\n", "fig, ax = plt.subplots(\n", " subplot_kw={\"projection\": ccrs.PlateCarree()},\n", From 627b6862dc4d1916370290d89b1f4e74869e34fd Mon Sep 17 00:00:00 2001 From: Anne Fouilloux Date: Fri, 29 May 2026 12:05:35 +0200 Subject: [PATCH 3/3] ruff format: drop blank lines inside cell 6 Whitespace-only change to satisfy `ruff format --check`. Co-Authored-By: Claude Opus 4.7 (1M context) --- notebook/Create_ROI_from_bbox_with_O2.ipynb | 91 ++++++++------------- 1 file changed, 32 insertions(+), 59 deletions(-) diff --git a/notebook/Create_ROI_from_bbox_with_O2.ipynb b/notebook/Create_ROI_from_bbox_with_O2.ipynb index 008445f..80a36a8 100644 --- a/notebook/Create_ROI_from_bbox_with_O2.ipynb +++ b/notebook/Create_ROI_from_bbox_with_O2.ipynb @@ -223,7 +223,6 @@ "print(f\"N level {child_level} cells covering former bbox: {child_ids.size}\")\n", "\n", "\n", - "\n", "lon_min, lon_max = -3.3, -1.97333\n", "lat_min, lat_max = 47.04367, 47.6\n", "lat_min, lat_max = 47.04367, 47.7\n", @@ -246,74 +245,48 @@ "\n", "# Important: close the polygon by repeating the first point at the end\n", "\n", - "vertices = np.array([\n", - "\n", - " [lon_min, lat_min],\n", - "\n", - " [lon_max, lat_min],\n", - "\n", - " [lon_max, lat_max],\n", - "\n", - " [lon_min, lat_max],\n", - "\n", - " [lon_min, lat_min],\n", - "\n", - "])\n", - "\n", - "vertices = np.array([\n", - "\n", - " [-3.30, 47.48], # left / northwest\n", - "\n", - " [-3.24, 47.58],\n", - "\n", - " [-3.15, 47.66],\n", - "\n", - " [-3.02, 47.70],\n", - "\n", - " [-2.86, 47.68],\n", - "\n", - " [-2.65, 47.61],\n", - "\n", - " [-2.42, 47.50],\n", - "\n", - " [-2.22, 47.42],\n", - "\n", - " [-2.02, 47.34],\n", - "\n", - " [-1.90, 47.25],\n", - "\n", - " [-1.94, 47.12],\n", - "\n", - " [-2.10, 47.04],\n", - "\n", - " [-2.35, 47.08],\n", - "\n", - " [-2.58, 47.16],\n", - "\n", - " [-2.78, 47.24],\n", - "\n", - " [-3.00, 47.30],\n", - "\n", - " [-3.20, 47.38],\n", - "\n", - " [-3.30, 47.48], # close polygon\n", + "vertices = np.array(\n", + " [\n", + " [lon_min, lat_min],\n", + " [lon_max, lat_min],\n", + " [lon_max, lat_max],\n", + " [lon_min, lat_max],\n", + " [lon_min, lat_min],\n", + " ]\n", + ")\n", "\n", - "])\n", + "vertices = np.array(\n", + " [\n", + " [-3.30, 47.48], # left / northwest\n", + " [-3.24, 47.58],\n", + " [-3.15, 47.66],\n", + " [-3.02, 47.70],\n", + " [-2.86, 47.68],\n", + " [-2.65, 47.61],\n", + " [-2.42, 47.50],\n", + " [-2.22, 47.42],\n", + " [-2.02, 47.34],\n", + " [-1.90, 47.25],\n", + " [-1.94, 47.12],\n", + " [-2.10, 47.04],\n", + " [-2.35, 47.08],\n", + " [-2.58, 47.16],\n", + " [-2.78, 47.24],\n", + " [-3.00, 47.30],\n", + " [-3.20, 47.38],\n", + " [-3.30, 47.48], # close polygon\n", + " ]\n", + ")\n", "\n", "# Find child HEALPix cell ids covering the polygon\n", "\n", "child_ids, depths, fully_covered = healpix_geo.nested.polygon_coverage(\n", - "\n", " vertices=vertices,\n", - "\n", " depth=child_level,\n", - "\n", " ellipsoid=\"WGS84\",\n", - "\n", " flat=True,\n", - "\n", ")\n", - "print(f\"N level {child_level} cells covering polygon: {child_ids.size}\")\n" + "print(f\"N level {child_level} cells covering polygon: {child_ids.size}\")" ] }, {