![\"Overview](\"attachment:fig/E08/crop-raster-overview-raster-00.png\")
\n",
- "\n",
- "As we can see, the overview image is much smaller compared to the original true color image.\n",
- "\n",
- "To align the raster and vector data, we first check each coordinate system. For raster data, we use `pyproj.CRS`:"
+ "visual_href = item.assets['visual'].href"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "f952bf8f",
+ "execution_count": 4,
+ "id": "11b8548b",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.DataArray (band: 3, y: 4523, x: 4828)>\n", + "[65511132 values with dtype=uint8]\n", + "Coordinates:\n", + " * band (band) int64 1 2 3\n", + " * x (x) float64 5.615e+05 5.615e+05 ... 6.098e+05 6.098e+05\n", + " * y (y) float64 4.035e+06 4.035e+06 4.035e+06 ... 3.99e+06 3.99e+06\n", + " spatial_ref int64 0\n", + "Attributes:\n", + " AREA_OR_POINT: Area\n", + " OVR_RESAMPLING_ALG: AVERAGE\n", + " scale_factor: 1.0\n", + " add_offset: 0.0\n", + " _FillValue: 0
![\"Raster](\"attachment:fig/E08/crop-raster-crop-by-bb-02.png\")
\n",
- "\n",
- "This cropped image can be saved for later usage:"
+ "visual_clipbox = visual.rio.clip_box(*gdf_rhodes.total_bounds)\n",
+ "visual_clipbox"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "e1981928",
+ "execution_count": 11,
+ "id": "4ae4940b",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.DataArray (band: 3, y: 4522, x: 4827)>\n", + "array([[[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]],\n", + "\n", + " [[0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " ...,\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0],\n", + " [0, 0, 0, ..., 0, 0, 0]]], dtype=uint8)\n", + "Coordinates:\n", + " * band (band) int64 1 2 3\n", + " * x (x) float64 5.615e+05 5.615e+05 ... 6.098e+05 6.098e+05\n", + " * y (y) float64 4.035e+06 4.035e+06 4.035e+06 ... 3.99e+06 3.99e+06\n", + " spatial_ref int64 0\n", + "Attributes:\n", + " AREA_OR_POINT: Area\n", + " OVR_RESAMPLING_ALG: AVERAGE\n", + " scale_factor: 1.0\n", + " add_offset: 0.0\n", + " _FillValue: 0
![\"Ratser](\"attachment:fig/E08/crop-raster-crop-fields.png\")
\n",
- "\n",
- "## Exercise: crop raster data with a specific code\n",
- "\n",
- "In the column “gewascode” (translated as “crop code”) of `fields`, you can find the code representing the types of plants grown in each field. Can you:\n",
- "\n",
- "1. Select the fields with “gewascode” equal to `257`;\n",
- "2. Crop the raster `raster_clip_box` with the selected fields;\n",
- "3. Visualize the cropped image."
+ "## Match two rasters in different CRS and resolution"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "4fc04bbd",
+ "execution_count": 14,
+ "id": "2221b2f8",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.DataArray (band: 1, y: 2098, x: 2029)>\n", + "[4256842 values with dtype=float32]\n", + "Coordinates:\n", + " * band (band) int64 1\n", + " * x (x) float64 27.68 27.68 27.68 27.68 ... 28.25 28.25 28.25 28.25\n", + " * y (y) float64 36.46 36.46 36.46 36.46 ... 35.88 35.88 35.88 35.88\n", + " spatial_ref int64 0\n", + "Attributes:\n", + " AREA_OR_POINT: Point\n", + " _FillValue: nan\n", + " scale_factor: 1.0\n", + " add_offset: 0.0
![\"Raster](\"attachment:fig/E08/crop-raster-fields-gewascode.png\")
\n",
- "\n",
- "## Crop raster data using `reproject_match()` function\n",
- "\n",
- "So far we have learned how to crop raster images with vector data. We can also crop a raster with another raster data. In this section, we will demonstrate how to crop the `raster_clip_box` image using the `raster_clip_fields_gwascode` image. We will use the `reproject_match` function. As indicated by its name, it performs reprojection and clipping in one go.\n",
- "\n",
- "To demonstrate the reprojection, we will first reproject `raster_clip_fields_gwascode` to the RD CRS system, so it will be in a different CRS from `raster_clip_box`:"
+ "dem = rioxarray.open_rasterio('dem_rhodes.tif')\n",
+ "dem"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "07d6008a",
+ "execution_count": 15,
+ "id": "007bc433",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "CRS.from_epsg(4326)"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "# Reproject to RD to make the CRS different from the \"raster\"\n",
- "raster_clip_fields_gwascode = raster_clip_fields_gwascode.rio.reproject(\"EPSG:28992\")\n",
- "CRS(raster_clip_fields_gwascode.rio.crs)"
+ "dem.rio.crs"
]
},
{
- "cell_type": "markdown",
- "id": "c82aa43c",
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "5d9b670f",
"metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.DataArray (band: 1, y: 4522, x: 4827)>\n", + "array([[[nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " ...,\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.]]], dtype=float32)\n", + "Coordinates:\n", + " * band (band) int64 1\n", + " spatial_ref int64 0\n", + " * x (x) float64 5.615e+05 5.615e+05 ... 6.098e+05 6.098e+05\n", + " * y (y) float64 4.035e+06 4.035e+06 4.035e+06 ... 3.99e+06 3.99e+06\n", + "Attributes:\n", + " AREA_OR_POINT: Point\n", + " scale_factor: 1.0\n", + " add_offset: 0.0\n", + " _FillValue: nan
\n",
+ "
"
+ ],
+ "text/plain": [
+ "<xarray.DataArray (band: 1, y: 4522, x: 4827)>\n", + "array([[[nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " ...,\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.],\n", + " [nan, nan, nan, ..., 0., 0., 0.]]], dtype=float32)\n", + "Coordinates:\n", + " * band (band) int64 1\n", + " spatial_ref int64 0\n", + " * x (x) float64 5.615e+05 5.615e+05 ... 6.098e+05 6.098e+05\n", + " * y (y) float64 4.035e+06 4.035e+06 4.035e+06 ... 3.99e+06 3.99e+06\n", + "Attributes:\n", + " AREA_OR_POINT: Point\n", + " scale_factor: 1.0\n", + " add_offset: 0.0\n", + " _FillValue: nan
![\"Reproject](\"attachment:fig/E08/reprojectmatch-big-to-small.png\")
\n",
- "\n",
- "We can also use it to expand `raster_clip_fields_gwascode` to the extent of `raster_clip_box`:"
+ "dem_match.plot()"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "a6fd18c4",
+ "execution_count": 21,
+ "id": "9a58a84d",
"metadata": {},
"outputs": [],
"source": [
- "raster_reproject_match = raster_clip_fields_gwascode.rio.reproject_match(raster_clip_box)\n",
- "raster_reproject_match.plot.imshow(figsize=(8,8))"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "7b4efce6",
- "metadata": {},
- "source": [
- "![\"Reproject](\"attachment:fig/E08/reprojectmatch-small-to-big.png\")
\n",
- "\n",
- "In one line `reproject_match` does a lot of helpful things:\n",
- "\n",
- "1. It reprojects.\n",
- "2. It matches the extent using `nodata` values or by clipping the data.\n",
- "3. It sets `nodata` values. This means we can run calculations on those two images.\n",
- "\n",
- "## Code Tip\n",
- "\n",
- "As we saw before, there also exists a method called `reproject()`, which only reprojects one raster to another projection. If you want more control over how rasters are resampled, clipped, and/or reprojected, you can use the `reproject()` method and other `rioxarray` methods individually.\n",
- "\n",
- "- Use `clip_box` to crop a raster with a bounding box.\n",
- "- Use `clip` to crop a raster with a given polygon.\n",
- "- Use `reproject_match` to match two raster datasets."
+ "dem_match.rio.to_raster('dem_rhodes_match.tif', driver='COG')"
]
}
],
"metadata": {
"jupytext": {
"main_language": "python"
+ },
+ "kernelspec": {
+ "display_name": "geospatial",
+ "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.10.12"
}
},
"nbformat": 4,
diff --git a/notebooks/11-zonal-statistics.ipynb b/notebooks/11-zonal-statistics.ipynb
index 6921cf34..6bc6a19c 100644
--- a/notebooks/11-zonal-statistics.ipynb
+++ b/notebooks/11-zonal-statistics.ipynb
@@ -2,24 +2,10 @@
"cells": [
{
"cell_type": "markdown",
- "id": "45df8c24",
+ "id": "30435181",
"metadata": {},
"source": [
- "- How to compute raster statistics on different zones delineated by vector data?\n",
- "\n",
- "- Extract zones from the vector dataset\n",
- "- Convert vector data to raster\n",
- "- Calculate raster statistics over zones\n",
- "\n",
- "# Introduction\n",
- "\n",
- "Statistics on predefined zones of the raster data are commonly used for analysis and to better understand the data. These zones are often provided within a single vector dataset, identified by certain vector attributes. For example, in the previous episodes, we used the crop field polygon dataset. The fields with the same crop type can be identified as a “zone”, resulting in multiple zones in one vector dataset. One may be interested in performing statistical analysis over these crop zones.\n",
- "\n",
- "In this episode, we will explore how to calculate zonal statistics based on the types of crops in `fields_cropped.shp`. To do this, we will first identify zones from the vector data, then rasterize these vector zones. Finally the zonal statistics for `ndvi` will be calculated over the rasterized zones.\n",
- "\n",
- "# Making vector and raster data compatible\n",
- "\n",
- "First, let’s load the `NDVI.tif` file saved in the previous episode to obtained our calculated raster `ndvi` data. We also use the `squeeze()` function in order to reduce our raster data `ndvi` dimension to 2D by removing the singular `band` dimension - this is necessary for use with the `rasterize` and `zonal_stats` functions:"
+ "# Zonal statistics"
]
},
{
@@ -29,46 +15,60 @@
"metadata": {},
"outputs": [],
"source": [
+ "# Load raster\n",
"import rioxarray\n",
- "ndvi = rioxarray.open_rasterio(\"NDVI.tif\").squeeze()"
+ "burned = rioxarray.open_rasterio('burned.tif')\n",
+ "burned"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2026781c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import geopandas as gpd\n",
+ "assets = gpd.read_file('assets.gpkg')\n",
+ "assets"
]
},
{
"cell_type": "markdown",
- "id": "bf8bd297",
+ "id": "793dead9",
"metadata": {},
"source": [
- "Let’s also read the crop fields vector data from our saved `fields_cropped.shp` file."
+ "## Align the CRS of the two datasets"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "2026781c",
+ "id": "fbd0e97e",
"metadata": {},
"outputs": [],
"source": [
- "import geopandas as gpd\n",
- "fields = gpd.read_file('fields_cropped.shp')"
+ "burned.rio.crs"
]
},
{
- "cell_type": "markdown",
- "id": "597eb79c",
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3f0ae56f",
"metadata": {},
+ "outputs": [],
"source": [
- "In order to use the vector data as a classifier for our raster, we need to convert the vector data to the appropriate CRS. We can perform the CRS conversion from the vector CRS (EPSG:28992) to our raster `ndvi` CRS (EPSG:32631) with:"
+ "assets.crs"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "55deb6cf",
+ "id": "1dc381e9",
"metadata": {},
"outputs": [],
"source": [
- "# Uniform CRS\n",
- "fields_utm = fields.to_crs(ndvi.rio.crs)"
+ "assets = assets.to_crs(burned.rio.crs)"
]
},
{
@@ -76,11 +76,7 @@
"id": "b58fde0d",
"metadata": {},
"source": [
- "# Rasterizing the vector data\n",
- "\n",
- "Before calculating zonal statistics, we first need to rasterize our `fields_utm` vector geodataframe with the `rasterio.features.rasterize` function. With this function, we aim to produce a grid with numerical values representing the types of crops as defined by the column `gewascode` from `field_cropped` - `gewascode` stands for the crop codes as defined by the Netherlands Enterprise Agency (RVO) for different types of crop or `gewas` (Grassland, permanent; Grassland, temporary; corn fields; etc.). This grid of values thus defines the zones for the `xrspatial.zonal_stats` function, where each pixel in the zone grid overlaps with a corresponding pixel in our NDVI raster.\n",
- "\n",
- "We can generate the `geometry, gewascode` pairs for each vector feature to be used as the first argument to `rasterio.features.rasterize` as:"
+ "# Rasterizing the vector data"
]
},
{
@@ -90,101 +86,93 @@
"metadata": {},
"outputs": [],
"source": [
- "geom = fields_utm[['geometry', 'gewascode']].values.tolist()\n",
+ "geom = assets[['geometry', 'code']].values.tolist()\n",
"geom"
]
},
{
- "cell_type": "markdown",
- "id": "1d703e6a",
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "caedcf2b",
"metadata": {},
+ "outputs": [],
"source": [
- "``` output\n",
- "[[![\"rasterization](\"attachment:fig/E10/rasterization-results.png\")
\n",
- "\n",
- "We will convert the output to `xarray.DataArray` which will be used further. To do this, we will “borrow” the coordinates from `ndvi`, and fill in the rasterization data:"
+ "from matplotlib import pyplot as plt\n",
+ "plt.imshow(assets_rasterized)\n",
+ "plt.colorbar()"
]
},
{
@@ -194,26 +182,19 @@
"metadata": {},
"outputs": [],
"source": [
- "import xarray as xr\n",
- "fields_rasterized_xarr = ndvi.copy()\n",
- "fields_rasterized_xarr.data = fields_rasterized\n",
+ "assets_rasterized_xarr = burned_squeeze.copy()\n",
+ "assets_rasterized_xarr.data = assets_rasterized\n",
"\n",
- "# visualize\n",
- "fields_rasterized_xarr.plot(robust=True)"
+ "# visualize zones\n",
+ "assets_rasterized_xarr.plot()"
]
},
{
"cell_type": "markdown",
- "id": "2f9d2e9d",
+ "id": "6de4990d",
"metadata": {},
"source": [
- "![\"Rasterization](\"attachment:fig/E10/rasterization-results-xr.png\")
\n",
- "\n",
- "# Calculate zonal statistics\n",
- "\n",
- "In order to calculate the statistics for each crop zone, we call the function, `xrspatial.zonal_stats`. The `xrspatial.zonal_stats` function takes as input `zones`, a 2D `xarray.DataArray`, that defines different zones, and `values`, a 2D `xarray.DataArray` providing input values for calculating statistics.\n",
- "\n",
- "We call the `zonal_stats` function with `fields_rasterized_xarr` as our classifier and the 2D raster with our values of interest `ndvi` to obtain the NDVI statistics for each crop type:"
+ "## Perform Zonal Statistcs"
]
},
{
@@ -224,88 +205,79 @@
"outputs": [],
"source": [
"from xrspatial import zonal_stats\n",
- "zonal_stats(fields_rasterized_xarr, ndvi)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "fb61558c",
- "metadata": {},
- "source": [
- "``` output\n",
- "\tzone\tmean\tmax\tmin\tsum\tstd\tvar\tcount\n",
- "0\t0\t0.266531\t0.999579\t-0.998648\t38887.648438\t0.409970\t0.168075\t145903.0\n",
- "1\t259\t0.520282\t0.885242\t0.289196\t449.003052\t0.111205\t0.012366\t863.0\n",
- "2\t265\t0.775609\t0.925955\t0.060755\t66478.976562\t0.091089\t0.008297\t85712.0\n",
- "3\t266\t0.794128\t0.918048\t0.544686\t1037.925781\t0.074009\t0.005477\t1307.0\n",
- "4\t331\t0.703056\t0.905304\t0.142226\t10725.819336\t0.102255\t0.010456\t15256.0\n",
- "5\t332\t0.681699\t0.849158\t0.178113\t321.080261\t0.123633\t0.015285\t471.0\n",
- "6\t335\t0.648063\t0.865804\t0.239661\t313.662598\t0.146582\t0.021486\t484.0\n",
- "7\t863\t0.388575\t0.510572\t0.185987\t1.165724\t0.144245\t0.020807\t3.0\n",
- "```\n",
- "\n",
- "The `zonal_stats` function calculates the minimum, maximum, and sum for each zone along with statistical measures such as the mean, variance and standard deviation for each rasterized vector zone. In our raster dataset `zone = 0`, corresponding to non-crop areas, has the highest count followed by `zone = 265` which corresponds to ‘Grasland, blijvend’ or ‘Grassland, permanent’. The highest mean NDVI is observed for `zone = 266` for ‘Grasslands, temporary’ with the lowest mean, aside from non-crop area, going to `zone = 863` representing ‘Forest without replanting obligation’. Thus, the `zonal_stats` function can be used to analyze and understand different sections of our raster data. The definition of the zones can be derived from vector data or from classified raster data as presented in the challenge below:\n",
- "\n",
- "## Exercise: Calculate zonal statistics for zones defined by `ndvi_classified`\n",
- "\n",
- "Let’s calculate NDVI zonal statistics for the different zones as classified by `ndvi_classified` in the previous episode.\n",
- "\n",
- "Load both raster datasets: `NDVI.tif` and `NDVI_classified.tif`. Then, calculate zonal statistics for each `class_bins`. Inspect the output of the `zonal_stats` function.\n",
- "\n",
- "1. Load and convert raster data into suitable inputs for `zonal_stats`:"
+ "stats = zonal_stats(assets_rasterized_xarr, burned_squeeze)"
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "e59c81e2",
+ "id": "8951b7c1",
"metadata": {},
"outputs": [],
"source": [
- "ndvi = rioxarray.open_rasterio(\"NDVI.tif\").squeeze()\n",
- "ndvi_classified = rioxarray.open_rasterio(\"NDVI_classified.tif\").squeeze()"
+ "stats"
]
},
{
"cell_type": "markdown",
- "id": "c71b51fd",
+ "id": "c76c2cea",
"metadata": {},
"source": [
- "1. Create and display the zonal statistics table."
+ "Exercise: Zonal stats over slope zones\n",
+ "\n",
+ "In the previouse section, we calculated the slope over Rhodes Island. Can you perform zonal statistics over slope and non slope region? We define non slope area as `slope<0.3`.\n",
+ "\n",
+ "Hint:\n",
+ "1. Load slope data from 'slope_dask.tif'.\n",
+ "2. Convert slope data to zones using [`xr.where`](https://docs.xarray.dev/en/stable/generated/xarray.where.html) function.\n",
+ "3. Note that the slope data and burn index data are in different resolution."
]
},
{
"cell_type": "code",
"execution_count": null,
- "id": "a61b5479",
+ "id": "0c9e89d8",
"metadata": {},
"outputs": [],
"source": [
- "zonal_stats(ndvi_classified, ndvi)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d4ce21bc",
- "metadata": {},
- "source": [
- "``` output\n",
- "\tzone mean max min sum std var\t count \n",
- "0 1 -0.355660 -0.000257 -0.998648 -12838.253906 0.145916 0.021291 36097.0 \n",
- "1 2 0.110731 0.199839 0.000000 1754.752441 0.055864 0.003121 15847.0 \n",
- "2 3 0.507998 0.700000 0.200000 50410.167969 0.140193 0.019654 99233.0 \n",
- "3 4 0.798281 0.999579 0.700025 78888.523438 0.051730 0.002676 98823.0\n",
- "```\n",
+ "# Load data and remove redundant dimension\n",
+ "slope = rioxarray.open_rasterio('slope_dask.tif').squeeze()\n",
"\n",
- "- Zones can be extracted by attribute columns of a vector dataset\n",
- "- Zones can be rasterized using `rasterio.features.rasterize`\n",
- "- Calculate zonal statistics with `xrspatial.zonal_stats` over the rasterized zones."
+ "# Covert slope data to Zone data\n",
+ "import xarray as xr\n",
+ "slope2 = xr.where(slope.isnull(), 0, slope) # Set all NaN values to 0\n",
+ "slope_zones = xr.where(slope2 < 0.3, 0, 1)\n",
+ "slope_zones.rio.set_crs(slope.rio.crs)\n",
+ "\n",
+ "# Reproject burned to slope\n",
+ "burned = rioxarray.open_rasterio('burned.tif').squeeze()\n",
+ "burned_match = burned.rio.reproject_match(slope_zones)\n",
+ "\n",
+ "# Compute Zonal stats\n",
+ "stats = zonal_stats(slope_zones, burned_match)"
]
}
],
"metadata": {
"jupytext": {
"main_language": "python"
+ },
+ "kernelspec": {
+ "display_name": "geospatial",
+ "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.10.12"
}
},
"nbformat": 4,