{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 03 Exploding Geometries\n", "\n", "It is necessary for some operations to explode or to split the existing geometries such as LineStrings, MultiLineStrings or Polygons in single parts. \n", "\n", "\n", "\n", "Source: Geological Map 1:50,000, Geological Survey NRW" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Set File Paths and download Tutorial Data\n", "\n", "If you downloaded the latest `GemGIS` version from the Github repository, append the path so that the package can be imported successfully. Otherwise, it is recommended to install `GemGIS` via `pip install gemgis` and import `GemGIS` using `import gemgis as gg`. In addition, the file path to the folder where the data is being stored is set. The tutorial data is downloaded using Pooch (https://www.fatiando.org/pooch/latest/index.html) and stored in the specified folder. Use `pip install pooch` if Pooch is not installed on your system yet." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2021-03-17T10:53:48.165578Z", "start_time": "2021-03-17T10:53:46.055041Z" } }, "outputs": [], "source": [ "import gemgis as gg\n", "\n", "file_path ='data/03_exploding_geometries/'" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-17T10:53:48.258748Z", "start_time": "2021-03-17T10:53:48.214818Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Downloading file '03_exploding_geometries.zip' from 'https://rwth-aachen.sciebo.de/s/AfXRsZywYDbUF34/download?path=%2F03_exploding_geometries.zip' to 'C:\\Users\\ale93371\\Documents\\gemgis\\docs\\getting_started\\tutorial\\data\\03_exploding_geometries'.\n" ] } ], "source": [ "gg.download_gemgis_data.download_tutorial_data(filename=\"03_exploding_geometries.zip\", dirpath=file_path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding LineStrings into single elements\n", "\n", "LineStrings can be exploded into a list of Shapely Points using the ``explode_linestring()`` function of the vector module. The function uses the built-in Shapely attribute `linestring.coords` to extract the vertices.\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:31:26.398945Z", "start_time": "2020-12-26T11:31:20.948939Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from shapely.geometry import LineString\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", "import pandas as pd\n", "import gemgis as gg\n", "\n", "linestring = LineString([(0,0), (5,5), (10,0), (15,5)])\n", "\n", "linestring" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exploding the LineString\n", "\n", "Exploding the LineString and returning a list of points. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2020-12-29T18:27:35.902122Z", "start_time": "2020-12-29T18:27:35.849815Z" } }, "outputs": [ { "data": { "text/plain": [ "[, , , ]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "point_list = gg.vector.explode_linestring(linestring=linestring)\n", "point_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting the elements of the returned list\n", "\n", "Each element of the list is a Shapely Point object." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-12-29T18:27:37.368012Z", "start_time": "2020-12-29T18:27:37.314071Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "point_list[0]" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2020-12-29T18:27:48.105039Z", "start_time": "2020-12-29T18:27:48.059974Z" } }, "outputs": [ { "data": { "text/plain": [ "'POINT (0 0)'" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "point_list[0].wkt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "A GeoDataFrame is created for better visualization." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.490488Z", "start_time": "2020-11-29T13:10:32.462460Z" } }, "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", "
geometry
0POINT (0.00000 0.00000)
1POINT (5.00000 5.00000)
2POINT (10.00000 0.00000)
3POINT (15.00000 5.00000)
\n", "
" ], "text/plain": [ " geometry\n", "0 POINT (0.00000 0.00000)\n", "1 POINT (5.00000 5.00000)\n", "2 POINT (10.00000 0.00000)\n", "3 POINT (15.00000 5.00000)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "point_gdf = gpd.GeoDataFrame(geometry=point_list)\n", "\n", "point_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the Data\n", "\n", "The extracted vertices of the lines can now be plotted using ``matplotlib``. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.745078Z", "start_time": "2020-11-29T13:10:32.509471Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "point_gdf.plot()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding LineStrings into single elements\n", "\n", "LineStrings can be split into a list of single LineStrings using the ``explode_linestring_to_element()`` function of the vector module. It is based on the Shapely `split()` function. \n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2020-12-29T18:30:30.704954Z", "start_time": "2020-12-29T18:30:30.690655Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from shapely.geometry import LineString\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", "import pandas as pd\n", "import gemgis as gg\n", "\n", "linestring = LineString([(0,0), (5,5), (10,0), (15,5)])\n", "\n", "linestring" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "Creating GeoDataFrame from LineString" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.825111Z", "start_time": "2020-11-29T13:10:32.796092Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
geometry
0LINESTRING (0.00000 0.00000, 5.00000 5.00000, ...
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 5.00000 5.00000, ..." ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_gdf = gpd.GeoDataFrame(geometry=[linestring])\n", "\n", "linestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Splitting the LineString\n", "\n", "A list of single LineStrings will be created when exploding the input LineString. This list can easily be converted to a GeoDataFrame. It can be seen that the input LineString was split into three parts and that the end points of each part coincide with the original LineString vertices.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.857101Z", "start_time": "2020-11-29T13:10:32.844099Z" } }, "outputs": [ { "data": { "text/plain": [ "[, , ]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list = gg.vector.explode_linestring_to_elements(linestring=linestring)\n", "\n", "linestring_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting the different elements of the returned list\n", "\n", "The different elements of the list are Shapely LineString." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.905130Z", "start_time": "2020-11-29T13:10:32.891110Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[0]" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (0 0, 5 5)'" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[0].wkt" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.937131Z", "start_time": "2020-11-29T13:10:32.923116Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[1]" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (5 5, 10 0)'" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[1].wkt" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:10:32.969127Z", "start_time": "2020-11-29T13:10:32.956123Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[2]" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (10 0, 15 5)'" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_list[2].wkt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "Creating a GeoDataFrame from the list of LineStrings." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:11:43.321045Z", "start_time": "2020-11-29T13:11:43.297442Z" } }, "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", "
geometryid
0LINESTRING (0.00000 0.00000, 5.00000 5.00000)1
1LINESTRING (5.00000 5.00000, 10.00000 0.00000)2
2LINESTRING (10.00000 0.00000, 15.00000 5.00000)3
\n", "
" ], "text/plain": [ " geometry id\n", "0 LINESTRING (0.00000 0.00000, 5.00000 5.00000) 1\n", "1 LINESTRING (5.00000 5.00000, 10.00000 0.00000) 2\n", "2 LINESTRING (10.00000 0.00000, 15.00000 5.00000) 3" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linestring_gdf = gpd.GeoDataFrame(geometry=linestring_list)\n", "\n", "linestring_gdf['id'] = ['1', '2', '3']\n", "linestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the Result\n", "\n", "Plotting the single LineStrings. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2020-11-29T13:11:43.793050Z", "start_time": "2020-11-29T13:11:43.478644Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "linestring_gdf.plot(column='id', legend=True, cmap='viridis')\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding MultiLineStrings\n", "\n", "MultiLineStrings can be split into a list of single LineStrings (with multiple vertices) using the ``explode_multilinestring()`` function of the vector module. This can also be achieved by accessing the LineStrings via `list(multilinestring.coords)`. If MultiLineStrings are provided as a GeoDataFrame, the function `explode_multilinestrings` can be used. This functions uses the built-in `gdf.explode()` function of GeoPandas. \n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from shapely.geometry import MultiLineString\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", "import gemgis as gg\n", "\n", "linestrings = [((0,0), (5,5)), ((10,0), (15,5))]\n", "\n", "multilinestring = MultiLineString(linestrings)\n", "multilinestring" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "Creating a GeoDataFrame from the MultiLineString." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
geometry
0MULTILINESTRING ((0.00000 0.00000, 5.00000 5.0...
\n", "
" ], "text/plain": [ " geometry\n", "0 MULTILINESTRING ((0.00000 0.00000, 5.00000 5.0..." ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_gdf = gpd.GeoDataFrame(geometry=[multilinestring])\n", "\n", "multilinestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Splitting the MultiLineString\n", "\n", "A list of single LineStrings (with multiple vertices) will be created when exploding the input MultiLineString. This list can easily be converted to a GeoDataFrame. It can be seen that the input MultiLineString was split into two single LineStrings and that the end points of each part coincide with the original MultiLineString vertices.\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[, ]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_list = gg.vector.explode_multilinestring(multilinestring=multilinestring)\n", "\n", "multilinestring_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting the elements of the returned list\n", "\n", "The elements of the created list are Shapely LineStrings." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_list[0]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (0 0, 5 5)'" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_list[0].wkt" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_list[1]" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (10 0, 15 5)'" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "multilinestring_list[1].wkt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "Creating a GeoDataFrame from the list of LineStrings." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
geometry
0LINESTRING (0.00000 0.00000, 5.00000 5.00000)
1LINESTRING (10.00000 0.00000, 15.00000 5.00000)
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", "1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gdf = gpd.GeoDataFrame(geometry=multilinestring_list)\n", "gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the Result\n", "\n", "Plotting the different LineStrings. " ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gdf.plot()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "A GeoDataFrame containig multiple MultiLineStrings can be exploded to LineStrings using `explode_multilinestrings(..)`." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "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", "
geometry
0LINESTRING (0.00000 0.00000, 5.00000 5.00000)
1LINESTRING (10.00000 0.00000, 15.00000 5.00000)
2LINESTRING (0.00000 0.00000, 5.00000 5.00000)
3LINESTRING (10.00000 0.00000, 15.00000 5.00000)
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", "1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)\n", "2 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", "3 LINESTRING (10.00000 0.00000, 15.00000 5.00000)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "splitted_multilinestring_gdf = gg.vector.explode_multilinestrings(pd.concat([multilinestring_gdf, multilinestring_gdf]).reset_index().drop('index', axis=1))\n", "splitted_multilinestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Additional Arguments\n", "\n", "Several additional arguments can be passed to adapt the functionality of the function. For further reference, see the [API Reference for extract_xy](https://gemgis.readthedocs.io/en/latest/api_reference/vector_data.html).\n", "\n", "* reset_index (bool)\n", "* drop_level0 (bool)\n", "* drop_level1 (bool)\n", "\n", "\n", "### Original Function\n", "Using the original function but not resetting the index." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "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", "
geometry
00LINESTRING (0.00000 0.00000, 5.00000 5.00000)
1LINESTRING (10.00000 0.00000, 15.00000 5.00000)
10LINESTRING (0.00000 0.00000, 5.00000 5.00000)
1LINESTRING (10.00000 0.00000, 15.00000 5.00000)
\n", "
" ], "text/plain": [ " geometry\n", "0 0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", " 1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)\n", "1 0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", " 1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "splitted_multilinestring_gdf = gg.vector.explode_multilinestrings(pd.concat([multilinestring_gdf, multilinestring_gdf]).reset_index().drop('index', axis=1),\n", " reset_index=False,\n", " drop_level0=False,\n", " drop_level1=False)\n", "splitted_multilinestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Resetting index but not additional columns\n", "\n", "Resetting the index but not dropping the additional columns that were created." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "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", " \n", " \n", " \n", "
level_0level_1geometry
000LINESTRING (0.00000 0.00000, 5.00000 5.00000)
101LINESTRING (10.00000 0.00000, 15.00000 5.00000)
210LINESTRING (0.00000 0.00000, 5.00000 5.00000)
311LINESTRING (10.00000 0.00000, 15.00000 5.00000)
\n", "
" ], "text/plain": [ " level_0 level_1 geometry\n", "0 0 0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", "1 0 1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)\n", "2 1 0 LINESTRING (0.00000 0.00000, 5.00000 5.00000)\n", "3 1 1 LINESTRING (10.00000 0.00000, 15.00000 5.00000)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "splitted_multilinestring_gdf = gg.vector.explode_multilinestrings(pd.concat([multilinestring_gdf, multilinestring_gdf]).reset_index().drop('index', axis=1),\n", " reset_index=True,\n", " drop_level0=False,\n", " drop_level1=False)\n", "splitted_multilinestring_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding Polygons\n", "\n", "Polygons can be split into a list of single Points using the ``explode_polygon()`` function of the vector module. If Polygons are provided as a GeoDataFrame, the function `explode_polygons` can be used. This functions uses the built-in `gdf.boundary` attribute of a GeoDataFrame to convert Polygons into LineStrings and MultiLineStrings." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from shapely.geometry import Polygon\n", "import matplotlib.pyplot as plt\n", "import geopandas as gpd\n", "import gemgis as gg\n", "\n", "polygon = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])\n", "polygon" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exploding the Polygon\n", "\n", "A list of single Points will be created when exploding the input Polygon. This list can easily be converted to a GeoDataFrame. It can be seen that the input Polygon was split into five single points corresponding to the corner points of the Polygon.\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[, , , , ]" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "points_list = gg.vector.explode_polygon(polygon=polygon)\n", "points_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting the elements of the returned list\n", "\n", "The elements of the created list are Shapely Points" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "points_list[0]" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "ExecuteTime": { "end_time": "2020-12-29T18:38:18.085850Z", "start_time": "2020-12-29T18:38:18.020813Z" } }, "outputs": [ { "data": { "text/plain": [ "'POINT (0 0)'" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "points_list[0].wkt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "Creating a GeoDataFrame from the list of points." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "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", "
geometry
0POINT (0.00000 0.00000)
1POINT (10.00000 0.00000)
2POINT (10.00000 10.00000)
3POINT (0.00000 10.00000)
4POINT (0.00000 0.00000)
\n", "
" ], "text/plain": [ " geometry\n", "0 POINT (0.00000 0.00000)\n", "1 POINT (10.00000 0.00000)\n", "2 POINT (10.00000 10.00000)\n", "3 POINT (0.00000 10.00000)\n", "4 POINT (0.00000 0.00000)" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gdf = gpd.GeoDataFrame(geometry=points_list)\n", "gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the Result\n", "\n", "Plotting the five points." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gdf.plot()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame\n", "\n", "A GeoDataFrame containig multiple polygons can be exploded to LineStrings and MultiLineStrings using `explode_polygons(..)`." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
geometry
0POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1...
1POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1...
\n", "
" ], "text/plain": [ " geometry\n", "0 POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1...\n", "1 POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1..." ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gdf = gpd.GeoDataFrame(geometry=[polygon, polygon])\n", "gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exploding the Polygons\n", "\n", "Exploding the polygons into LineStrings and MultiLineStrings." ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
geometry
0LINESTRING (0.00000 0.00000, 10.00000 0.00000,...
1LINESTRING (0.00000 0.00000, 10.00000 0.00000,...
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 10.00000 0.00000,...\n", "1 LINESTRING (0.00000 0.00000, 10.00000 0.00000,..." ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "boundary_gdf = gg.vector.explode_polygons(gdf=gdf)\n", "boundary_gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the Result\n", "\n", "Plotting the LineStrings." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "boundary_gdf.plot()\n", "plt.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding Geometry Collections\n", "\n", "Shapely Geometry Collections can be exploded into a list of Base Geometries using ``explode_geometry_collection(..)``." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:30:52.898035Z", "start_time": "2020-12-26T11:30:52.871382Z" } }, "outputs": [ { "data": { "text/plain": [ "shapely.geometry.collection.GeometryCollection" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from shapely.geometry import LineString\n", "a = LineString([(0, 0), (1, 1), (1, 2), (2, 2)])\n", "b = LineString([(0, 0), (1, 1), (2, 1), (2, 2)])\n", "collection = a.intersection(b)\n", "type(collection)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:31:01.515459Z", "start_time": "2020-12-26T11:31:01.500958Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Explode Geometry Collection\n", "\n", "The Shapely Geometry Collection can be exploded to a list of Base Geometries using ``explode_geometry_collection(..)``." ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:31:26.446197Z", "start_time": "2020-12-26T11:31:26.433934Z" } }, "outputs": [ { "data": { "text/plain": [ "[, ]" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection_exploded = gg.vector.explode_geometry_collection(collection=collection)\n", "collection_exploded" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting the elements in the returned list\n", "\n", "The elements of the returned list can be inspected to show the exploded geometries of the Geometry Collection." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:31:36.095849Z", "start_time": "2020-12-26T11:31:36.076850Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection_exploded[0]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'LINESTRING (0 0, 1 1)'" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection_exploded[0].wkt" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:31:40.818875Z", "start_time": "2020-12-26T11:31:40.801244Z" } }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection_exploded[1]" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'POINT (2 2)'" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collection_exploded[1].wkt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploding Collections of different Geometries in GeoDataFrame\n", "\n", "A GeoDataFrame containing different Base Geometries can be exploded to single Base Geometries. " ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:42:29.228995Z", "start_time": "2020-12-26T11:42:29.213816Z" } }, "outputs": [], "source": [ "from shapely.geometry import Polygon, LineString\n", "\n", "line1 = LineString([(0, 0), (1, 1), (1, 2), (2, 2)])\n", "line2 = LineString([(0, 0), (1, 1), (2, 1), (2, 2)])\n", "collection = a.intersection(b)\n", "polygon = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating GeoDataFrame" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:42:29.545299Z", "start_time": "2020-12-26T11:42:29.519318Z" } }, "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", "
geometry
0LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...
1LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...
2GEOMETRYCOLLECTION (LINESTRING (0.00000 0.0000...
3POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1...
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...\n", "1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...\n", "2 GEOMETRYCOLLECTION (LINESTRING (0.00000 0.0000...\n", "3 POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1..." ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gdf = gpd.GeoDataFrame(geometry=[line1, line2, collection, polygon])\n", "gdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exploding Geometry Collection GeoDataFrame\n", "\n", "A GeoDataFrame containing different Base Geometries or Geometry Collections can be exploded using ``explode_geometry_collections(..)``." ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "ExecuteTime": { "end_time": "2020-12-26T11:42:36.026368Z", "start_time": "2020-12-26T11:42:35.990669Z" } }, "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", "
geometry
0LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...
1LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...
2LINESTRING (0.00000 0.00000, 1.00000 1.00000)
3POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1...
\n", "
" ], "text/plain": [ " geometry\n", "0 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...\n", "1 LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...\n", "2 LINESTRING (0.00000 0.00000, 1.00000 1.00000)\n", "3 POLYGON ((0.00000 0.00000, 10.00000 0.00000, 1..." ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gdf_exploded = gg.vector.explode_geometry_collections(gdf=gdf)\n", "gdf_exploded" ] } ], "metadata": { "hide_input": false, "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.8.5" }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }