From 626922b5b4032f0c60b561a1607955b289347b73 Mon Sep 17 00:00:00 2001 From: Henrikki Tenkanen Date: Thu, 5 Oct 2023 12:07:47 +0300 Subject: [PATCH] Add material about activating geometry source with set_geometry --- .../chapter-06/md/02-geometric-operations.md | 127 +++- .../nb/02-geometric-operations.ipynb | 699 +++++++++++++++--- 2 files changed, 716 insertions(+), 110 deletions(-) diff --git a/source/part2/chapter-06/md/02-geometric-operations.md b/source/part2/chapter-06/md/02-geometric-operations.md index 39380188..d1cfaefa 100644 --- a/source/part2/chapter-06/md/02-geometric-operations.md +++ b/source/part2/chapter-06/md/02-geometric-operations.md @@ -12,24 +12,20 @@ jupyter: name: python3 --- + # Common geometric operations + + +Geometric operations refer to a set of methods that can be used to process and analyze geometric features, like points, lines and polygons. In the context of geographic data analysis, these operations allow us, for instance, to ask questions about how two or more geographic objects relate to each other: Do they intersect, touch, or overlap? Are they adjacent to one another? How far apart are they? With the tools bundled in geopandas, it is easy to perform these kind of operations. As we delve into geometric operations, you'll discover they form the foundation of many geospatial analyses, enabling insights that are often difficult to discern from non-spatial data alone. -Here we demonstrate some of the most common geometry manipulation functions available in `geopandas`. We will continue exploring the census tract data from Austin, Texas. It is often useful to do geometric manipulations on administrative borders for further analysis and visualization purposes. We will learn how to generate centroids, different outlines and buffer zones for the polygons. +In the following, we demonstrate some of the most common geometric manipulation functions available in geopandas. We will do this by continuing to explore the census tract data from Austin, Texas. Geometric manipulations are often useful e.g. when working with data related to administrative boundaries, as we often might need to transform or manipulate the geographic data in one way or another for further analysis and visualization purposes. Next, we will learn how to generate centroids, different outlines and buffer zones for the polygons. Let's start by reading the census tract data into `GeoDataFrame`. In this case, we use data that we already manipulated a bit in the previous section (by calculating the area and population density): + -```python tags=["remove_cell"] -import os - -os.environ["USE_PYGEOS"] = "0" -``` - -```python +```python editable=true slideshow={"slide_type": ""} import geopandas as gpd -import matplotlib.pyplot as plt from pathlib import Path -``` -```python # Define path do the data data_folder = Path("data/Austin") fp = data_folder / "austin_pop_density_2019.gpkg" @@ -39,62 +35,145 @@ data = gpd.read_file(fp) data.head() ``` -For the purposes of geometric manipulations, we are mainly interested in the geometry column which contains the polygon geometries. Remember, that the data type of the geometry-column is `GeoSeries`. Individual geometries are eventually `shapely` objects and we can use all of `shapely`'s tools for geometry manipulation directly via `geopandas`. + +For the purposes of geometric manipulations, we are mainly interested in the geometry column which contains the polygon geometries. Remember, that the data type of the geometry-column is `GeoSeries`. As we have mentioned earlier, the individual geometries are ultimately shapely geometric objects (e.g. `Point`, `LineString`, `Polygon`), and we can use all of shapely's tools for geometric manipulations directly via geopandas. The following shows that the geometries in the `GeoSeries` are stored as `MultiPolygon` objects: + -```python -# Check contents of the geometry column +```python editable=true slideshow={"slide_type": ""} data["geometry"].head() ``` -```python +```python editable=true slideshow={"slide_type": ""} # Check data type of the geometry column type(data["geometry"]) ``` -```python +```python editable=true slideshow={"slide_type": ""} # Check data type of a value in the geometry column type(data["geometry"].values[0]) ``` -Let's first plot the original geometries. We can use the in-built plotting function in `geopandas` to plot the geometries, and `matplotlib.pyplot` to turn off axis lines and labels. + +Let's first plot the original geometries. We can use the built-in `.plot()` function in geopandas to plot the geometries, and `matplotlib.pyplot` to turn off axis lines and labels: + + +```python editable=true slideshow={"slide_type": ""} +import matplotlib.pyplot as plt -```python data.plot(facecolor="none", linewidth=0.2) plt.axis("off") plt.show() ``` + _**Figure 6.13**. Basic plot of the census tracts._ + - + ## Centroid -Extracting the centroid of geometric features is useful in many cases. Geometric centroid can, for example, be used for locating text labels in visualizations. We can extract the center point of each polygon via the `centroid`-attribute of the geometry-column. The data should be in a projected coordinate reference system when calculating the centroids. If trying to calculate centroids based on latitude and longitude information, `geopandas` will warn us that the results are likely incorrect. Our sample data are in WGS 84 / UTM zone 14N (EPSG:32614), which is a projected , and we can proceed to calculating the centroids. +The centroid of a geometry is the geometric center of a given geometry (line, polygon or a geometry collection). Extracting the centroid of geometric features is useful in many cases. Geometric centroid can, for example, be used for locating text labels in visualizations. We can extract the center point of each polygon via the `centroid` attribute of the `geometry` column. The data should be in a projected coordinate reference system when calculating the centroids. If trying to calculate centroids based on latitude and longitude information, geopandas will warn us that the results are likely (slightly) incorrect. Our `GeoDataFrame` is in WGS 84 / UTM zone 14N (EPSG:32614) coordinate reference system (CRS) which is a projected one (we will learn more about these in the next section). Thus, we can directly proceed to calculating the centroids: + -```python +```python editable=true slideshow={"slide_type": ""} data.crs.name ``` -```python +```python editable=true slideshow={"slide_type": ""} data["geometry"].centroid.head() ``` -We can also apply the method directly to the `GeoDataFrame` to achieve the same result using the syntax `data.centroid`. At the same time, we can also plot the centroids for a visual check. + +We can also apply the method directly to the `GeoDataFrame` to achieve the same result using the syntax `data.centroid`. At the same time, we can also plot the centroids for a visual check: + -```python +```python editable=true slideshow={"slide_type": ""} data.centroid.plot(markersize=1) plt.axis("off") plt.show() ``` + _**Figure 6.14**. Basic plot of census tract centroids._ + + + +## Updating the source for geometries in a GeoDataFrame + +Before diving into other examples of geometric operations, let's discuss briefly about different ways to update the source column which is used to represent the geometries in your `GeoDataFrame`. In some cases, such as when calculating the centroids as we did earlier, you might actually want to save the centroids into your `GeoDataFrame` and continue processing or analysing the data based on these centroids. This can be done easily with geopandas, and there are a couple of approaches how to do this: + +1. Overwrite the existing geometries in the `geometry` column by storing the centroids into it. +2. Create a new column (e.g. `centroid`) and store the centroid into this one. Then activate the column as the "source" for geometries in your `GeoDataFrame`. This means that you can have multiple simultaneous columns containing geometries in a `GeoDataFrame` which can be very handy! + +Some important remarks about these approaches: The option 1 is very easy to do, but the downside of it is the fact that you do not have access to the original geometries (e.g. polygons) anymore. The option 2 requires a couple of steps, but the good side of it, is that you can easily swap between the original geometries and the centroids in your data. However, when saving the geographic data into disk, you can only include one column with geometries. Hence, latest at this stage, you need to decide which column is used for representing the geometric features in your data. In the following, we demonstrate how to do both of these. Let's start by showing how you can overwrite the existing geometries with centroids: + + +```python editable=true slideshow={"slide_type": ""} +# Make a copy +option_1 = data.copy() + +option_1["geometry"].head(2) +``` + +```python editable=true slideshow={"slide_type": ""} +# Update the geometry column with centroids +option_1["geometry"] = option_1.centroid + +option_1.head(2) +``` + + +As we can see, now the geometries in the `geometry` column were replaced and populated with `Point` objects that represent the centroids of the polygons. With this approach, you cannot anymore access the original polygon geometries. + +The second option is to create a new column for storing the centroids and then use this column as the source for representing geometries of the given `GeoDataFrame`: + + +```python editable=true slideshow={"slide_type": ""} +# Make a copy +option_2 = data.copy() + +# Step 1: Create a column with centroids +option_2["centroid"] = data.centroid +option_2.head(2) +``` + + +Now we have two columns in our `GeoDataFrame` that contain geometries. By default, geopandas always uses the `geometry` column as a source for representing the geometries. However, we can easily change this with `.set_geometry()` method which can be used to tell geopandas to use another column with geometries as the geometry-source: + + +```python editable=true slideshow={"slide_type": ""} +# Use centroids as the GeoDataFrame geometries +option2 = option_2.set_geometry("centroid") +option2.head(2) +``` + + +Nothing seem to have changed in the data itself, which is good because we did not want to modify any data. However, when we take a look at the `.geometry.name` attribute of the `GeoDataFrame`, we can see that the name of the column used for representing geometries has actually changed: + + +```python editable=true slideshow={"slide_type": ""} +option2.geometry.name +``` + + +We can still confirm this by plotting our `GeoDataFrame` which now returns a map with points: + + +```python editable=true slideshow={"slide_type": ""} +option2.plot() +``` + +By following this approach, you can easily change the active `geometry` for your `GeoDataFrame`. This can be highly useful when manipulating geometries as you can store the geometries from different computational steps into a same `GeoDataFrame` without a need to make multiple copies of the data. However, we recommend to be a bit careful when storing multiple columns with geometries, as it is possible that you accidentally use a different source for geometries than what you have planned to do, which can cause confusion and problems with your analyses. Always remember the name the columns intuitively which can help avoiding issues and confusion in your analyses! + + ## Unary union We can generate a joint outline for the administrative areas through creating a geometric union among all geometries. This could be useful, for example, for visualizing the outlines of a study area. The `unary_union` returns a single geometry object, which is automatically visualized when running the code in a Jupyter Notebook. + ```python data.unary_union diff --git a/source/part2/chapter-06/nb/02-geometric-operations.ipynb b/source/part2/chapter-06/nb/02-geometric-operations.ipynb index 1a6562da..06f29f34 100644 --- a/source/part2/chapter-06/nb/02-geometric-operations.ipynb +++ b/source/part2/chapter-06/nb/02-geometric-operations.ipynb @@ -3,7 +3,13 @@ { "cell_type": "markdown", "id": "70db89f0", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "# Common geometric operations" ] @@ -11,44 +17,30 @@ { "cell_type": "markdown", "id": "5e8c8dab", - "metadata": {}, - "source": [ - "Here we demonstrate some of the most common geometry manipulation functions available in `geopandas`. We will continue exploring the census tract data from Austin, Texas. It is often useful to do geometric manipulations on administrative borders for further analysis and visualization purposes. We will learn how to generate centroids, different outlines and buffer zones for the polygons. " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2573c0ff-abee-4733-956d-25ca18773021", "metadata": { - "tags": [ - "remove_cell" - ] + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] }, - "outputs": [], "source": [ - "import os\n", + "Geometric operations refer to a set of methods that can be used to process and analyze geometric features, like points, lines and polygons. In the context of geographic data analysis, these operations allow us, for instance, to ask questions about how two or more geographic objects relate to each other: Do they intersect, touch, or overlap? Are they adjacent to one another? How far apart are they? With the tools bundled in geopandas, it is easy to perform these kind of operations. As we delve into geometric operations, you'll discover they form the foundation of many geospatial analyses, enabling insights that are often difficult to discern from non-spatial data alone.\n", "\n", - "os.environ[\"USE_PYGEOS\"] = \"0\"" + "In the following, we demonstrate some of the most common geometric manipulation functions available in geopandas. We will do this by continuing to explore the census tract data from Austin, Texas. Geometric manipulations are often useful e.g. when working with data related to administrative boundaries, as we often might need to transform or manipulate the geographic data in one way or another for further analysis and visualization purposes. Next, we will learn how to generate centroids, different outlines and buffer zones for the polygons. Let's start by reading the census tract data into `GeoDataFrame`. In this case, we use data that we already manipulated a bit in the previous section (by calculating the area and population density):" ] }, { "cell_type": "code", "execution_count": 2, - "id": "3035ea5e", - "metadata": {}, - "outputs": [], - "source": [ - "import geopandas as gpd\n", - "import matplotlib.pyplot as plt\n", - "from pathlib import Path" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "id": "7acca403-0eee-41cc-ba9c-9866ea5f1b8c", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -84,40 +76,40 @@ " 6070.0\n", " 002422\n", " 4.029772\n", - " 1506.288769\n", - " POLYGON ((615643.487 3338728.496, 615645.477 3...\n", + " 1506.288778\n", + " MULTIPOLYGON (((615643.488 3338728.496, 615645...\n", " \n", " \n", " 1\n", " 2203.0\n", " 001751\n", " 1.532030\n", - " 1437.961408\n", - " POLYGON ((618576.586 3359381.053, 618614.330 3...\n", + " 1437.961394\n", + " MULTIPOLYGON (((618576.586 3359381.053, 618614...\n", " \n", " \n", " 2\n", " 7419.0\n", " 002411\n", " 3.960344\n", - " 1873.322183\n", - " POLYGON ((619200.163 3341784.654, 619270.849 3...\n", + " 1873.322161\n", + " MULTIPOLYGON (((619200.163 3341784.654, 619270...\n", " \n", " \n", " 3\n", " 4229.0\n", " 000401\n", " 2.181762\n", - " 1938.341868\n", - " POLYGON ((621623.757 3350508.165, 621656.294 3...\n", + " 1938.341859\n", + " MULTIPOLYGON (((621623.757 3350508.165, 621656...\n", " \n", " \n", " 4\n", " 4589.0\n", " 002313\n", " 2.431208\n", - " 1887.538655\n", - " POLYGON ((621630.247 3345130.744, 621717.926 3...\n", + " 1887.538658\n", + " MULTIPOLYGON (((621630.247 3345130.744, 621717...\n", " \n", " \n", "\n", @@ -125,26 +117,29 @@ ], "text/plain": [ " pop2019 tract area_km2 pop_density_km2 \\\n", - "0 6070.0 002422 4.029772 1506.288769 \n", - "1 2203.0 001751 1.532030 1437.961408 \n", - "2 7419.0 002411 3.960344 1873.322183 \n", - "3 4229.0 000401 2.181762 1938.341868 \n", - "4 4589.0 002313 2.431208 1887.538655 \n", + "0 6070.0 002422 4.029772 1506.288778 \n", + "1 2203.0 001751 1.532030 1437.961394 \n", + "2 7419.0 002411 3.960344 1873.322161 \n", + "3 4229.0 000401 2.181762 1938.341859 \n", + "4 4589.0 002313 2.431208 1887.538658 \n", "\n", " geometry \n", - "0 POLYGON ((615643.487 3338728.496, 615645.477 3... \n", - "1 POLYGON ((618576.586 3359381.053, 618614.330 3... \n", - "2 POLYGON ((619200.163 3341784.654, 619270.849 3... \n", - "3 POLYGON ((621623.757 3350508.165, 621656.294 3... \n", - "4 POLYGON ((621630.247 3345130.744, 621717.926 3... " + "0 MULTIPOLYGON (((615643.488 3338728.496, 615645... \n", + "1 MULTIPOLYGON (((618576.586 3359381.053, 618614... \n", + "2 MULTIPOLYGON (((619200.163 3341784.654, 619270... \n", + "3 MULTIPOLYGON (((621623.757 3350508.165, 621656... \n", + "4 MULTIPOLYGON (((621630.247 3345130.744, 621717... " ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "import geopandas as gpd\n", + "from pathlib import Path\n", + "\n", "# Define path do the data\n", "data_folder = Path(\"data/Austin\")\n", "fp = data_folder / \"austin_pop_density_2019.gpkg\"\n", @@ -157,43 +152,60 @@ { "cell_type": "markdown", "id": "6f986ea3", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "For the purposes of geometric manipulations, we are mainly interested in the geometry column which contains the polygon geometries. Remember, that the data type of the geometry-column is `GeoSeries`. Individual geometries are eventually `shapely` objects and we can use all of `shapely`'s tools for geometry manipulation directly via `geopandas`." + "For the purposes of geometric manipulations, we are mainly interested in the geometry column which contains the polygon geometries. Remember, that the data type of the geometry-column is `GeoSeries`. As we have mentioned earlier, the individual geometries are ultimately shapely geometric objects (e.g. `Point`, `LineString`, `Polygon`), and we can use all of shapely's tools for geometric manipulations directly via geopandas. The following shows that the geometries in the `GeoSeries` are stored as `MultiPolygon` objects:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "id": "3c5b8fd0", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { "text/plain": [ - "0 POLYGON ((615643.487 3338728.496, 615645.477 3...\n", - "1 POLYGON ((618576.586 3359381.053, 618614.330 3...\n", - "2 POLYGON ((619200.163 3341784.654, 619270.849 3...\n", - "3 POLYGON ((621623.757 3350508.165, 621656.294 3...\n", - "4 POLYGON ((621630.247 3345130.744, 621717.926 3...\n", + "0 MULTIPOLYGON (((615643.488 3338728.496, 615645...\n", + "1 MULTIPOLYGON (((618576.586 3359381.053, 618614...\n", + "2 MULTIPOLYGON (((619200.163 3341784.654, 619270...\n", + "3 MULTIPOLYGON (((621623.757 3350508.165, 621656...\n", + "4 MULTIPOLYGON (((621630.247 3345130.744, 621717...\n", "Name: geometry, dtype: geometry" ] }, - "execution_count": 4, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Check contents of the geometry column\n", "data[\"geometry\"].head()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "id": "bf17c2a8", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -201,7 +213,7 @@ "geopandas.geoseries.GeoSeries" ] }, - "execution_count": 5, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -213,17 +225,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "id": "2640dc73", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { "text/plain": [ - "shapely.geometry.polygon.Polygon" + "shapely.geometry.multipolygon.MultiPolygon" ] }, - "execution_count": 6, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -236,20 +254,32 @@ { "cell_type": "markdown", "id": "e524d8e9", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "Let's first plot the original geometries. We can use the in-built plotting function in `geopandas` to plot the geometries, and `matplotlib.pyplot` to turn off axis lines and labels." + "Let's first plot the original geometries. We can use the built-in `.plot()` function in geopandas to plot the geometries, and `matplotlib.pyplot` to turn off axis lines and labels:" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "c8e4e801", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -259,6 +289,8 @@ } ], "source": [ + "import matplotlib.pyplot as plt\n", + "\n", "data.plot(facecolor=\"none\", linewidth=0.2)\n", "\n", "plt.axis(\"off\")\n", @@ -268,7 +300,13 @@ { "cell_type": "markdown", "id": "bb86c9ad-0465-4516-830f-84d52688fefc", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "_**Figure 6.13**. Basic plot of the census tracts._" ] @@ -277,19 +315,29 @@ "cell_type": "markdown", "id": "11e9d77c", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "source": [ "## Centroid\n", "\n", - "Extracting the centroid of geometric features is useful in many cases. Geometric centroid can, for example, be used for locating text labels in visualizations. We can extract the center point of each polygon via the `centroid`-attribute of the geometry-column. The data should be in a projected coordinate reference system when calculating the centroids. If trying to calculate centroids based on latitude and longitude information, `geopandas` will warn us that the results are likely incorrect. Our sample data are in WGS 84 / UTM zone 14N (EPSG:32614), which is a projected , and we can proceed to calculating the centroids." + "The centroid of a geometry is the geometric center of a given geometry (line, polygon or a geometry collection). Extracting the centroid of geometric features is useful in many cases. Geometric centroid can, for example, be used for locating text labels in visualizations. We can extract the center point of each polygon via the `centroid` attribute of the `geometry` column. The data should be in a projected coordinate reference system when calculating the centroids. If trying to calculate centroids based on latitude and longitude information, geopandas will warn us that the results are likely (slightly) incorrect. Our `GeoDataFrame` is in WGS 84 / UTM zone 14N (EPSG:32614) coordinate reference system (CRS) which is a projected one (we will learn more about these in the next section). Thus, we can directly proceed to calculating the centroids:" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "id": "2c71636e-13f3-4562-8e80-abfa3e6a6798", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -297,7 +345,7 @@ "'WGS 84 / UTM zone 14N'" ] }, - "execution_count": 8, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -308,9 +356,15 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "id": "513407ce", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -323,7 +377,7 @@ "dtype: geometry" ] }, - "execution_count": 9, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -335,16 +389,28 @@ { "cell_type": "markdown", "id": "d0446d74", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "We can also apply the method directly to the `GeoDataFrame` to achieve the same result using the syntax `data.centroid`. At the same time, we can also plot the centroids for a visual check." + "We can also apply the method directly to the `GeoDataFrame` to achieve the same result using the syntax `data.centroid`. At the same time, we can also plot the centroids for a visual check:" ] }, { "cell_type": "code", "execution_count": 10, "id": "20270dc2", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -367,15 +433,476 @@ { "cell_type": "markdown", "id": "d41ab0cb-7c22-4358-b098-85a167bec1c9", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "_**Figure 6.14**. Basic plot of census tract centroids._" ] }, + { + "cell_type": "markdown", + "id": "8eb48170-2bfd-48fe-82e1-7a3383fefcc4", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Updating the source for geometries in a GeoDataFrame\n", + "\n", + "Before diving into other examples of geometric operations, let's discuss briefly about different ways to update the source column which is used to represent the geometries in your `GeoDataFrame`. In some cases, such as when calculating the centroids as we did earlier, you might actually want to save the centroids into your `GeoDataFrame` and continue processing or analysing the data based on these centroids. This can be done easily with geopandas, and there are a couple of approaches how to do this:\n", + "\n", + "1. Overwrite the existing geometries in the `geometry` column by storing the centroids into it.\n", + "2. Create a new column (e.g. `centroid`) and store the centroid into this one. Then activate the column as the \"source\" for geometries in your `GeoDataFrame`. This means that you can have multiple simultaneous columns containing geometries in a `GeoDataFrame` which can be very handy!\n", + "\n", + "Some important remarks about these approaches: The option 1 is very easy to do, but the downside of it is the fact that you do not have access to the original geometries (e.g. polygons) anymore. The option 2 requires a couple of steps, but the good side of it, is that you can easily swap between the original geometries and the centroids in your data. However, when saving the geographic data into disk, you can only include one column with geometries. Hence, latest at this stage, you need to decide which column is used for representing the geometric features in your data. In the following, we demonstrate how to do both of these. Let's start by showing how you can overwrite the existing geometries with centroids:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "71e2c614-1b13-49a3-8bec-58202c11af76", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0 MULTIPOLYGON (((615643.488 3338728.496, 615645...\n", + "1 MULTIPOLYGON (((618576.586 3359381.053, 618614...\n", + "Name: geometry, dtype: geometry" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Make a copy\n", + "option_1 = data.copy()\n", + "\n", + "option_1[\"geometry\"].head(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ff952582-cc81-4d65-9251-0410c3b6921f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pop2019tractarea_km2pop_density_km2geometry
06070.00024224.0297721506.288778POINT (616990.190 3339736.002)
12203.00017511.5320301437.961394POINT (619378.303 3359650.002)
\n", + "
" + ], + "text/plain": [ + " pop2019 tract area_km2 pop_density_km2 geometry\n", + "0 6070.0 002422 4.029772 1506.288778 POINT (616990.190 3339736.002)\n", + "1 2203.0 001751 1.532030 1437.961394 POINT (619378.303 3359650.002)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Update the geometry column with centroids\n", + "option_1[\"geometry\"] = option_1.centroid\n", + "\n", + "option_1.head(2)" + ] + }, + { + "cell_type": "markdown", + "id": "a247571e-f8a0-4853-a05c-6b57a33ad79f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "As we can see, now the geometries in the `geometry` column were replaced and populated with `Point` objects that represent the centroids of the polygons. With this approach, you cannot anymore access the original polygon geometries.\n", + "\n", + "The second option is to create a new column for storing the centroids and then use this column as the source for representing geometries of the given `GeoDataFrame`:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a04c28a5-1abc-4089-8000-9efdadded03e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pop2019tractarea_km2pop_density_km2geometrycentroid
06070.00024224.0297721506.288778MULTIPOLYGON (((615643.488 3338728.496, 615645...POINT (616990.190 3339736.002)
12203.00017511.5320301437.961394MULTIPOLYGON (((618576.586 3359381.053, 618614...POINT (619378.303 3359650.002)
\n", + "
" + ], + "text/plain": [ + " pop2019 tract area_km2 pop_density_km2 \\\n", + "0 6070.0 002422 4.029772 1506.288778 \n", + "1 2203.0 001751 1.532030 1437.961394 \n", + "\n", + " geometry \\\n", + "0 MULTIPOLYGON (((615643.488 3338728.496, 615645... \n", + "1 MULTIPOLYGON (((618576.586 3359381.053, 618614... \n", + "\n", + " centroid \n", + "0 POINT (616990.190 3339736.002) \n", + "1 POINT (619378.303 3359650.002) " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Make a copy\n", + "option_2 = data.copy()\n", + "\n", + "# Step 1: Create a column with centroids\n", + "option_2[\"centroid\"] = data.centroid\n", + "option_2.head(2)" + ] + }, + { + "cell_type": "markdown", + "id": "12590b65-020d-4de1-8753-d89846e10afb", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Now we have two columns in our `GeoDataFrame` that contain geometries. By default, geopandas always uses the `geometry` column as a source for representing the geometries. However, we can easily change this with `.set_geometry()` method which can be used to tell geopandas to use another column with geometries as the geometry-source:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "ee2bc828-a4e7-429e-8c66-f01b1d9a0dee", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pop2019tractarea_km2pop_density_km2geometrycentroid
06070.00024224.0297721506.288778MULTIPOLYGON (((615643.488 3338728.496, 615645...POINT (616990.190 3339736.002)
12203.00017511.5320301437.961394MULTIPOLYGON (((618576.586 3359381.053, 618614...POINT (619378.303 3359650.002)
\n", + "
" + ], + "text/plain": [ + " pop2019 tract area_km2 pop_density_km2 \\\n", + "0 6070.0 002422 4.029772 1506.288778 \n", + "1 2203.0 001751 1.532030 1437.961394 \n", + "\n", + " geometry \\\n", + "0 MULTIPOLYGON (((615643.488 3338728.496, 615645... \n", + "1 MULTIPOLYGON (((618576.586 3359381.053, 618614... \n", + "\n", + " centroid \n", + "0 POINT (616990.190 3339736.002) \n", + "1 POINT (619378.303 3359650.002) " + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use centroids as the GeoDataFrame geometries\n", + "option2 = option_2.set_geometry(\"centroid\")\n", + "option2.head(2)" + ] + }, + { + "cell_type": "markdown", + "id": "0c4673de-11a9-4452-a9bf-38ac751fccf1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "Nothing seem to have changed in the data itself, which is good because we did not want to modify any data. However, when we take a look at the `.geometry.name` attribute of the `GeoDataFrame`, we can see that the name of the column used for representing geometries has actually changed:" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "79eac7fb-e43c-469f-a65d-6050031eff72", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'centroid'" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "option2.geometry.name" + ] + }, + { + "cell_type": "markdown", + "id": "f0cb2e98-796e-479a-8a98-0f7b3c46141d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "We can still confirm this by plotting our `GeoDataFrame` which now returns a map with points:" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "8ef2fe82-5fae-4436-a080-b12d7bb15136", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "option2.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "ddd5a720-810c-4910-9b94-76b34eb448ea", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "By following this approach, you can easily change the active `geometry` for your `GeoDataFrame`. This can be highly useful when manipulating geometries as you can store the geometries from different computational steps into a same `GeoDataFrame` without a need to make multiple copies of the data. However, we recommend to be a bit careful when storing multiple columns with geometries, as it is possible that you accidentally use a different source for geometries than what you have planned to do, which can cause confusion and problems with your analyses. Always remember the name the columns intuitively which can help avoiding issues and confusion in your analyses!" + ] + }, { "cell_type": "markdown", "id": "c055ea6a", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "## Unary union\n", "\n",