windfarm.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The notebook downloads Sentinel-1 RTC (Radiometrically Terrain Corrected) data and processes it over the specified bounding box. In this example, the bounding box is from a coast off Germany. The RTC achieves this by analyzing the light reflected back from the objects to the satellite sensor.\n",
    "\n",
    "*Disclaimer*: This notebook must run on the Microsoft Planetary Computer and the code is built upon this repo: https://gist.github.com/calebrob6/364506877a0ed011bb51a707fbc13ff3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import rasterio\n",
    "import rasterio.features\n",
    "import pystac_client\n",
    "import planetary_computer as pc\n",
    "import stackstac\n",
    "import rtree\n",
    "import fiona\n",
    "import fiona.transform\n",
    "import shapely.geometry\n",
    "\n",
    "from IPython.display import Image\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Importing these libraries enable the handling of satellite imagery:*\n",
    "rasterio- reading, writing geospatial data\n",
    "stackstac- stacking STAC (SpatioTemporal Asset Catalog) items into an xarray.Dataset\n",
    "shapely- providing geometric objects and operations on them\n",
    "fiona- used for reading and writing geospatial vector data\n",
    "numpy- general data processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 20 items\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<img src=\"https://planetarycomputer.microsoft.com/api/data/v1/item/preview.png?collection=sentinel-1-rtc&item=S1A_IW_GRDH_1SDV_20220818T172552_20220818T172617_044610_05532E_rtc&assets=vv&assets=vh&tile_format=png&expression=0.03+%2B+log+%2810e-4+-+log+%280.05+%2F+%280.02+%2B+2+%2A+vv%29%29%29%3B0.05+%2B+exp+%280.25+%2A+%28log+%280.01+%2B+2+%2A+vv%29+%2B+log+%280.02+%2B+5+%2A+vh%29%29%29%3B1+-+log+%280.05+%2F+%280.045+-+0.9+%2A+vv%29%29&asset_as_band=True&rescale=0%2C.8000&rescale=0%2C1.000&rescale=0%2C1.000&format=png\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "bbox = [5.7458, 53.7594, 7.1686, 54.1994]  # off the north coast of Germany\n",
    "# for more time steps of over same area\n",
    "date_ranges = [\"2022-07-19/2022-08-19\", \"2022-06-19/2022-07-19\", \"2022-05-19/2022-06-19\", \"2022-04-19/2022-05-19\"]\n",
    "\n",
    "catalog = pystac_client.Client.open(\n",
    "    \"https://planetarycomputer.microsoft.com/api/stac/v1\"\n",
    ")\n",
    "search = catalog.search(\n",
    "    collections=[\"sentinel-1-rtc\"], bbox=bbox, datetime=date_ranges\n",
    ")\n",
    "items = search.item_collection()\n",
    "print(f\"Found {len(items)} items\")\n",
    "item = items[0]\n",
    "\n",
    "Image(url=item.assets[\"rendered_preview\"].href)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the pystac_client and planetary_computer libraries, the script connects to Microsoft's Planetary Computer STAC API, and fetches Sentinel-1 RTC (Radar Topography Mission) data for the defined bounding box and for a specific period and displays the raw satellite image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = stackstac.stack(\n",
    "    pc.sign(items), bounds_latlon=bbox, epsg=item.properties['proj:epsg'], resolution=10\n",
    ")\n",
    "ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The images collection (which are multiple images covering the same area at different times) is stacked into a single 3D array (like a cube of images). Each slice of this cube is an image from a different time. The cube is then converted to a 2D array by taking the mean of the cube along the time dimension. This is called temporal mean compositing. The resulting image is a single image that represents the average of all the images in the cube. This is done to reduce the noise in the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "img = ds[0,0].values\n",
    "plt.figure(figsize=(13.5,7.5))\n",
    "plt.imshow(np.log(img), vmax=-3)\n",
    "plt.title(\"VV polarization\", fontsize=15)\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a figure by extracting the first band from the xarray.Dataset and then display the logarithm of the image values. This can be useful to spot differences in reflectivity that could be due to different types of objects on the ground."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(13.5,7.5))\n",
    "plt.imshow(img, vmax=0.1)\n",
    "plt.title(\"VV polarization\", fontsize=15)\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "plt.close()\n",
    "\n",
    "mask = ds > 0.3\n",
    "mask_nan = ds.notnull()\n",
    "vals = (mask & mask_nan).sum(axis=(0,1), dtype=float) / mask_nan.sum(axis=(0,1), dtype=float)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then create a binary mask of pixels where the reflectivity is greater than 0.3.\n",
    "Another mask to exclude any Not a Number values in the dataset.\n",
    "Then apply the mask to the image and display the masked image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "vals = vals.compute()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then compute the fraction of true pixels where the reflectivity is greater than 0.3. This is the fraction of pixels that are not water."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(13.5,7.5))\n",
    "plt.imshow(vals, vmin=0, vmax=0.3)\n",
    "plt.title(\"Fraction of observations in which a pixel has value > 0.3\", fontsize=15)\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now compute a binary mask of pixels where the reflectivity is greater than a specified threshold (0.3 in this case). The mask is True where the condition is met and False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modifying this list to include the dates for persistent polygons\n",
    "date_ranges = [\"2022-07-19/2022-08-19\", \"2022-06-19/2022-07-19\", \"2022-05-19/2022-06-19\"]\n",
    "\n",
    "persisting_polygons = []\n",
    "persisting_features = []\n",
    "elongation_threshold = 2.75 # more adjusting needed\n",
    "\n",
    "\n",
    "for date_range in date_ranges:\n",
    "    # repeat the search and polygon extraction process for each date range\n",
    "    search = catalog.search(\n",
    "        collections=[\"sentinel-1-rtc\"], bbox=bbox, datetime=date_range\n",
    "    )\n",
    "    items = search.item_collection()\n",
    "    print(f\"Found {len(items)} items\")\n",
    "    \n",
    "    # Stack all the items together into a single DataArray\n",
    "    ds = stackstac.stack(\n",
    "        pc.sign(items), bounds_latlon=bbox, epsg=item.properties['proj:epsg'], resolution=10\n",
    "    )\n",
    "\n",
    "    img = ds[0,0].values\n",
    "    # apply threshold\n",
    "    mask = ds > 0.3\n",
    "    mask_nan = ds.notnull()\n",
    "    vals = (mask & mask_nan).sum(axis=(0,1), dtype=float) / mask_nan.sum(axis=(0,1), dtype=float)\n",
    "\n",
    "    # creating binary image based on threshold\n",
    "    with rasterio.open(\"output_threshold.tif\", \"w\", **profile) as f:\n",
    "        f.write((vals>=0.3).astype(np.uint8), 1)\n",
    "\n",
    "    # Extracting the polygons from the binary image\n",
    "    features = []\n",
    "    shapes = []\n",
    "    original_shapes = []\n",
    "    areas = []\n",
    "    idx = rtree.index.Index()\n",
    "    i = 0\n",
    "    num_thrown_away = 0\n",
    "    with rasterio.open(\"output_threshold.tif\") as f:\n",
    "        t_features = list(rasterio.features.dataset_features(f, with_nodata=True, geographic=True))\n",
    "        for feature in t_features:\n",
    "            geom = fiona.transform.transform_geom(\"epsg:4326\", \"epsg:3857\", feature[\"geometry\"])\n",
    "            shape = shapely.geometry.shape(geom)\n",
    "            area = shape.area\n",
    "            compactness = shape.length**2 / (4 * np.pi * area)\n",
    "            \n",
    "            if feature[\"properties\"][\"val\"] == 1 and compactness > elongation_threshold:\n",
    "                feature[\"properties\"][\"area\"] = shape.area\n",
    "                feature[\"properties\"][\"idx\"] = i\n",
    "                features.append(feature)\n",
    "                areas.append(shape.area)\n",
    "                shapes.append(shape)\n",
    "                idx.insert(id=i, coordinates=shape.bounds)\n",
    "                i += 1\n",
    "            else:\n",
    "                num_thrown_away += 1\n",
    "    print(f\"Throwing away {num_thrown_away} polygons\")\n",
    "\n",
    "    # Merge polygons that are closer than a certain distance\n",
    "    merges = set()\n",
    "    merge_sets = dict()\n",
    "    for i, src_shape in enumerate(shapes):\n",
    "        if i not in merges:\n",
    "            to_merge = set([i])\n",
    "            for j in idx.nearest(src_shape.bounds, num_results=10):\n",
    "                dst_shape = shapes[j]\n",
    "                distance = src_shape.distance(dst_shape)\n",
    "                if i !=j and distance < 100:\n",
    "                    to_merge.add(j)\n",
    "                    merges.add(j)\n",
    "            if len(to_merge) > 1:\n",
    "                merge_sets[i] = to_merge\n",
    "\n",
    "    # Create new features after merging\n",
    "    new_features = []\n",
    "    new_shapes = []\n",
    "    for i, shape in enumerate(shapes):\n",
    "        if i in merge_sets:        \n",
    "            merge_shapes = [\n",
    "                shapes[j]\n",
    "                for j in merge_sets[i]\n",
    "            ]\n",
    "            new_shape = shapely.geometry.MultiPolygon(merge_shapes).convex_hull\n",
    "\n",
    "            geom = shapely.geometry.mapping(new_shape)\n",
    "            geom = fiona.transform.transform_geom(\"epsg:3857\", \"epsg:4326\", geom)\n",
    "\n",
    "            new_feature = features[i]\n",
    "            new_feature[\"properties\"][\"area\"] = new_shape.area\n",
    "            new_feature[\"geometry\"] = geom\n",
    "            new_features.append(new_feature)\n",
    "            new_shapes.append(new_shape)\n",
    "        elif i in merges:\n",
    "            pass\n",
    "        else:\n",
    "            new_features.append(features[i])\n",
    "            new_shapes.append(shape)\n",
    "\n",
    "    if not persisting_polygons:  # if it's the first date range\n",
    "        persisting_polygons = new_features\n",
    "    else:\n",
    "        persisting_polygons_temp = []\n",
    "        for feature in persisting_polygons:\n",
    "            if any(shapely.geometry.shape(feature['geometry']).equals(shapely.geometry.shape(current_feature['geometry'])) for current_feature in new_features):\n",
    "                persisting_polygons_temp.append(feature)\n",
    "        persisting_polygons = persisting_polygons_temp\n",
    "\n",
    "\n",
    "with fiona.open(\"output.geojson\", \"w\", driver=\"GeoJSON\", crs=\"EPSG:4326\", schema=schema) as f:\n",
    "    for feature in new_features:\n",
    "        f.write(feature)\n",
    "\n",
    "# Now persisting_polygons contains only polygons that appeared in all periods\n",
    "print(f\"Number of persisting wind turbines found: {len(persisting_polygons)}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The script simplifies polygons that are close together (within 100 meters) into single, larger polygons. This is done to reduce the complexity of the output and to group closeby objects together. The binary mask image is then read, and geometrical features (polygons) are created from areas where the mask is True.\n",
    "\n",
    "The final result is a GeoJSON file, a format for encoding a variety of geographic data structures, which contains the simplified polygons, each with its associated properties. One file holds the fraction data, and another holds the binary mask with a threshold applied. This file can be used in a geographic information system (GIS) to visualize and further analyze the results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "elongation_thresholds = [3.0, 2.75, 2.5, 2.4, 2.3, 2.2, 2.1, 2.0, 1.5, 1.0, 0.5]\n",
    "number_of_wind_turbines = [79, 165, 285, 361, 439, 484, 525, 556, 599, 615, 615]\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(number_of_wind_turbines, elongation_thresholds, marker='o')\n",
    "plt.title('Number of wind turbines vs Elongation threshold')\n",
    "plt.xlabel('Number of wind turbines ')\n",
    "plt.ylabel('Elongation threshold')\n",
    "plt.grid()\n",
    "plt.gca().invert_yaxis() \n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.11.1"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}