diff --git a/autotest/t065_test_gridintersect.py b/autotest/t065_test_gridintersect.py index 502edeb5ee..d239e239de 100644 --- a/autotest/t065_test_gridintersect.py +++ b/autotest/t065_test_gridintersect.py @@ -1,5 +1,6 @@ -import os +import sys +sys.path.insert(1, "..") import matplotlib.pyplot as plt import numpy as np from descartes import PolygonPatch @@ -268,6 +269,21 @@ def test_rect_grid_multipoint_in_multiple_cells(): return result +def test_rect_grid_point_on_all_vertices_return_all_ix(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="structured", rtree=rtree) + n_intersections = [1, 2, 1, 2, 4, 2, 1, 2, 1] + for v, n in zip(gr.verts, n_intersections): + r = ix.intersect(Point(*v), return_all_intersections=True) + assert len(r) == n + return + + # %% test point shapely @@ -364,6 +380,21 @@ def test_rect_grid_multipoint_in_multiple_cells_shapely(rtree=True): return result +def test_rect_grid_point_on_all_vertices_return_all_ix_shapely(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="vertex", rtree=rtree) + n_intersections = [1, 2, 1, 2, 4, 2, 1, 2, 1] + for v, n in zip(gr.verts, n_intersections): + r = ix.intersect(Point(*v), return_all_intersections=True) + assert len(r) == n + return + + def test_tri_grid_point_outside(rtree=True): # avoid test fail when shapely not available try: @@ -444,6 +475,21 @@ def test_tri_grid_multipoint_in_multiple_cells(rtree=True): return result +def test_tri_grid_points_on_all_vertices_return_all_ix_shapely(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_tri_grid() + ix = GridIntersect(gr, method="vertex", rtree=rtree) + n_intersections = [2, 2, 2, 2, 8, 2, 2, 2, 2] + for v, n in zip(gr.verts, n_intersections): + r = ix.intersect(Point(*v), return_all_intersections=True) + assert len(r) == n + return + + # %% test linestring structured @@ -564,6 +610,38 @@ def test_rect_grid_linestring_in_and_out_of_cell2(): return result +def test_rect_grid_linestrings_on_boundaries_return_all_ix(): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="structured") + x, y = ix._rect_grid_to_shape_list()[0].exterior.xy + n_intersections = [1, 2, 2, 1] + for i in range(4): + ls = LineString([(x[i], y[i]), (x[i + 1], y[i + 1])]) + r = ix.intersect(ls, return_all_intersections=True) + assert len(r) == n_intersections[i] + return + + +def test_rect_grid_linestring_starting_on_vertex(): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="structured") + result = ix.intersect(LineString([(10.0, 10.0), (15.0, 5.0)])) + assert len(result) == 1 + assert np.allclose(result.lengths.sum(), np.sqrt(50)) + assert result.cellids[0] == (1, 1) + return result + + # %% test linestring shapely @@ -666,6 +744,23 @@ def test_rect_grid_linestring_in_and_out_of_cell_shapely(rtree=True): return result +def test_rect_grid_linestrings_on_boundaries_return_all_ix_shapely(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="vertex", rtree=rtree) + x, y = ix._rect_grid_to_shape_list()[0].exterior.xy + n_intersections = [1, 2, 2, 1] + for i in range(4): + ls = LineString([(x[i], y[i]), (x[i + 1], y[i + 1])]) + r = ix.intersect(ls, return_all_intersections=True) + assert len(r) == n_intersections[i] + return + + def test_tri_grid_linestring_outside(rtree=True): # avoid test fail when shapely not available try: @@ -759,6 +854,23 @@ def test_tri_grid_multilinestring_in_one_cell(rtree=True): return result +def test_tri_grid_linestrings_on_boundaries_return_all_ix(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + tgr = get_tri_grid() + ix = GridIntersect(tgr, method="vertex", rtree=rtree) + x, y = ix._vtx_grid_to_shape_list()[0].exterior.xy + n_intersections = [2, 1, 2] + for i in range(len(x) - 1): + ls = LineString([(x[i], y[i]), (x[i + 1], y[i + 1])]) + r = ix.intersect(ls, return_all_intersections=True) + assert len(r) == n_intersections[i] + return + + # %% test polygon structured @@ -806,6 +918,21 @@ def test_rect_grid_polygon_on_outer_boundary(): return result +def test_rect_grid_polygon_running_along_boundary(): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr, method="structured") + result = ix.intersect( + Polygon([(5.0, 5.0), (5.0, 10.0), (9.0, 10.0), (9.0, 15.0), + (1.0, 15.0), (1.0, 5.0)]) + ) + return result + + def test_rect_grid_polygon_on_inner_boundary(): # avoid test fail when shapely not available try: @@ -874,6 +1001,57 @@ def test_rect_grid_polygon_with_hole(): return result +def test_rect_grid_polygon_contains_centroid(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr) + p = Polygon( + [(6.0, 5.0), (4.0, 16.0), (25.0, 14.0), (25.0, -5.0), (6.0, -5.0)], + holes=[[(9.0, -1), (9, 11), (21, 11), (21, -1)]], + ) + result = ix.intersect(p, contains_centroid=True) + assert len(result) == 1 + return + + +def test_rect_grid_polygon_min_area(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr) + p = Polygon( + [(5.0, 5.0), (5.0, 15.0), (25.0, 15.0), (25.0, -5.0), (5.0, -5.0)], + holes=[[(9.0, -1), (9, 11), (21, 11), (21, -1)]], + ) + result = ix.intersect(p, min_area_fraction=0.4) + assert len(result) == 2 + return + + +def test_rect_grid_polygon_centroid_and_min_area(): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_rect_grid() + ix = GridIntersect(gr) + p = Polygon( + [(5.0, 5.0), (5.0, 15.0), (25.0, 14.0), (25.0, -5.0), (5.0, -5.0)], + holes=[[(9.0, -1), (9, 11), (21, 11), (21, -1)]], + ) + result = ix.intersect(p, min_area_fraction=0.35, contains_centroid=True) + assert len(result) == 1 + return + + # %% test polygon shapely @@ -1134,6 +1312,44 @@ def test_tri_grid_polygon_with_hole(rtree=True): return result +def test_tri_grid_polygon_min_area(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_tri_grid() + if gr == -1: + return + ix = GridIntersect(gr, rtree=rtree) + p = Polygon( + [(5.0, 5.0), (5.0, 15.0), (25.0, 15.0), (25.0, -5.0), (5.0, -5.0)], + holes=[[(9.0, -1), (9, 11), (21, 11), (21, -1)]], + ) + result = ix.intersect(p, min_area_fraction=0.5) + assert len(result) == 2 + return + + +def test_tri_grid_polygon_contains_centroid(rtree=True): + # avoid test fail when shapely not available + try: + import shapely + except: + return + gr = get_tri_grid() + if gr == -1: + return + ix = GridIntersect(gr, rtree=rtree) + p = Polygon( + [(5.0, 5.0), (6.0, 14.0), (25.0, 15.0), (25.0, -5.0), (5.0, -5.0)], + holes=[[(9.0, -1), (9, 11), (21, 11), (21, -1)]], + ) + result = ix.intersect(p, contains_centroid=True) + assert len(result) == 2 + return + + # %% test rotated offset grids @@ -1299,6 +1515,8 @@ def test_all_intersections_shapely_no_strtree(): def test_rasters(): + import os + import flopy as fp from flopy.utils import Raster @@ -1365,6 +1583,8 @@ def test_rasters(): def test_raster_sampling_methods(): + import os + import flopy as fp from flopy.utils import Raster @@ -1414,7 +1634,3 @@ def test_raster_sampling_methods(): raise AssertionError( f"{method} resampling returning incorrect values" ) - - -if __name__ == "__main__": - test_raster_sampling_methods() diff --git a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb index 8b49d664b2..151bafa446 100644 --- a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb +++ b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb @@ -6,9 +6,9 @@ "source": [ "# Intersecting model grids with shapes\n", "\n", - "_Note: This feature requires the shapely and descartes packages (which are not a FloPy dependency) so must be installed by the user._\n", + "_Note: This feature requires the shapely and descartes (for plotting) packages (which are not FloPy dependencies) so they must be installed by the user._\n", "\n", - "This notebook shows the grid intersection functionality in flopy. The intersection methods are available through the GridIntersect object. A flopy modelgrid is passed to instantiate the object. Then the modelgrid can be intersected with Points, LineStrings and Polygons through the different intersection methods. \n", + "This notebook shows the grid intersection functionality in flopy. The intersection methods are available through the `GridIntersect` object. A flopy modelgrid is passed to instantiate the object. Then the modelgrid can be intersected with Points, LineStrings and Polygons. \n", "\n", "There are three intersection modes: \n", "- the first (default mode) builds an STR-tree for fast spatial queries before calculating intersections, thereby reducing the number of grid cells it has to process. This method works for structured and vertex grids.\n", @@ -53,8 +53,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.9.7 (default, Sep 16 2021, 08:50:36) \n", - "[Clang 10.0.0 ]\n", + "3.9.7 | packaged by conda-forge | (default, Sep 29 2021, 19:20:46) \n", + "[GCC 9.4.0]\n", "numpy version: 1.21.2\n", "matplotlib version: 3.5.1\n", "flopy version: 3.3.5\n" @@ -62,14 +62,13 @@ } ], "source": [ - "import sys\n", "import os\n", "import platform\n", - "import numpy as np\n", + "import sys\n", + "\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", - "\n", - "sys.path.insert(1, \"../..\")\n", + "import numpy as np\n", "\n", "# run installed version of flopy or add local path\n", "try:\n", @@ -79,27 +78,20 @@ " from flopy.utils.gridintersect import GridIntersect\n", "except:\n", " fpth = os.path.abspath(os.path.join(\"..\", \"..\"))\n", - " sys.path.append(fpth)\n", + " sys.path.insert(1, fpth)\n", " import flopy\n", " import flopy.discretization as fgrid\n", " import flopy.plot as fplot\n", " from flopy.utils.gridintersect import GridIntersect\n", "\n", "import shapely\n", - "from shapely.geometry import (\n", - " Polygon,\n", - " Point,\n", - " LineString,\n", - " MultiLineString,\n", - " MultiPoint,\n", - " MultiPolygon,\n", - ")\n", - "from shapely.strtree import STRtree\n", + "from shapely.geometry import (LineString, MultiLineString, MultiPoint,\n", + " MultiPolygon, Point, Polygon)\n", "\n", "print(sys.version)\n", "print(\"numpy version: {}\".format(np.__version__))\n", "print(\"matplotlib version: {}\".format(mpl.__version__))\n", - "print(\"flopy version: {}\".format(flopy.__version__))" + "print(\"flopy version: {}\".format(flopy.__version__))\n" ] }, { @@ -110,14 +102,14 @@ "\n", "The GridIntersect class is constructed by passing a flopy modelgrid object to the constructor. There are options users can select to change how the intersection is calculated.\n", "\n", - "- `method`: either `\"vertex\"` (default) or `\"structured\"`. If `\"structured\"` is passed, the intersections are performed using structured methods. These methods use information about the regular grid to limit the search space for intersection calculations. \n", + "- `method`: derived from model grid type and can be either `\"vertex\"` or `\"structured\"`. If `\"structured\"` is passed, the intersections are performed using structured methods. These methods use information about the regular grid to limit the search space for intersection calculations. \n", "- `rtree`: either `True` (default) or `False`, only read when `method=\"vertex\"`. When True, an STR-tree is built, which allows for fast spatial queries. Building the STR-tree does take some time however. Setting the option to False avoids building the STR-tree but requires the intersection calculation to essentially loop through all grid cells.\n", "\n", - "In general the default option is robust (it always works) and fast and is therefore recommended in most situations. If you are working with a structured grid, then the `method=\"structured\"` can speed up intersection operations (especially for points and linestrings) with the added advantage of not having to build an STR-tree. In some cases with vertex grids, it might not be worth your time building the STR-tree, in which case it can be avoided by passing `rtree=False`.\n", + "In general the \"vertex\" option is robust and fast and is therefore recommended in most situations. If you are working with a structured grid, then the `method=\"structured\"` can speed up intersection operations in some situations (for points and linestrings) with the added advantage of not having to build an STR-tree. In some rare cases intersecting with vertex grids, it might not be worth your time building the STR-tree, in which case it can be avoided by passing `rtree=False`.\n", "\n", "The important methods in the GridIntersect object are:\n", - "- `intersects()`: returns cellids for gridcells that intersect a shape\n", - "- `intersect()`: for intersecting the modelgrid with point, linestrings, and polygon geometries (intersect can accept shapely geometry objects, flopy geometry object, shapefile.Shape objects, and geojson objects)\n", + "- `intersects()`: returns cellids for gridcells that intersect a shape (accepts shapely geometry objects, flopy geometry object, shapefile.Shape objects, and geojson objects)\n", + "- `intersect()`: for intersecting the modelgrid with point, linestrings, and polygon geometries (accepts shapely geometry objects, flopy geometry object, shapefile.Shape objects, and geojson objects)\n", "- `plot_point()`: for plotting point intersection results\n", "- `plot_linestring()`: for plotting linestring intersection results\n", "- `plot_polygon()`: for plotting polygon intersection results\n", @@ -185,7 +177,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -194,7 +186,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -248,26 +240,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Create the GridIntersect class for our modelgrid. The keyword arguments are shown below, but as these are the default options, they do not need to be passed necesssarily." + "Create the GridIntersect class for our modelgrid. The keyword arguments are shown below, but do not necessarily have to be passed as they represent the default options." ] }, { "cell_type": "code", "execution_count": 6, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:22.642289Z", - "iopub.status.busy": "2022-03-07T20:04:22.641320Z", - "iopub.status.idle": "2022-03-07T20:04:22.704823Z", - "shell.execute_reply": "2022-03-07T20:04:22.705444Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/jdhughes/Documents/Development/flopy_git/flopy_fork/examples/Notebooks/../../flopy/utils/gridintersect.py:276: ShapelyDeprecationWarning: Setting custom attributes on geometry objects is deprecated, and will raise an AttributeError in Shapely 2.0\n", + "/home/david/Github/flopy_db/examples/Notebooks/../../flopy/utils/gridintersect.py:316: ShapelyDeprecationWarning: Setting custom attributes on geometry objects is deprecated, and will raise an AttributeError in Shapely 2.0\n", " p.name = (i, j)\n" ] } @@ -286,25 +271,10 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:22.712262Z", - "iopub.status.busy": "2022-03-07T20:04:22.711375Z", - "iopub.status.idle": "2022-03-07T20:04:29.687906Z", - "shell.execute_reply": "2022-03-07T20:04:29.688367Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "8.48 ms ± 529 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ - "%timeit ix.intersect(p)" + "# %timeit ix.intersect(p)" ] }, { @@ -331,7 +301,7 @@ "- **cellids**: contains the cell ids of the intersected grid cells\n", "- **vertices**: contains the vertices of the intersected shape\n", "- **areas**: contains the area of the polygon in that grid cell (only for polygons)\n", - "- **lenghts**: contains the length of the linestring in that grid cell (only for linestrings)\n", + "- **lengths**: contains the length of the linestring in that grid cell (only for linestrings)\n", "- **ixshapes**: contains the shapely object representing the intersected shape (useful for plotting the result)\n", "\n", "Looking at the first few entries of the results of the polygon intersection (convert to pandas.DataFrame for prettier formatting)" @@ -352,11 +322,11 @@ { "data": { "text/plain": [ - "rec.array([((2, 3), (((35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0), (35.0, 80.0)),), 66.66666667, ),\n", - " ((2, 4), (((50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667), (50.0, 70.0)),), 33.33333333, ),\n", - " ((3, 2), (((30.0, 70.0), (30.0, 60.0), (25.0, 60.0), (30.0, 70.0)),), 25. , ),\n", - " ((3, 3), (((40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0), (40.0, 70.0)),), 100. , ),\n", - " ((3, 4), (((50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0), (50.0, 70.0)),), 100. , )],\n", + "rec.array([((2, 3), (((35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0), (35.0, 80.0)),), 66.66666667, ),\n", + " ((2, 4), (((50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667), (50.0, 70.0)),), 33.33333333, ),\n", + " ((3, 2), (((30.0, 70.0), (30.0, 60.0), (25.0, 60.0), (30.0, 70.0)),), 25. , ),\n", + " ((3, 3), (((40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0), (40.0, 70.0)),), 100. , ),\n", + " ((3, 4), (((50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0), (50.0, 70.0)),), 100. , )],\n", " dtype=[('cellids', 'O'), ('vertices', 'O'), ('areas', '" ] @@ -564,53 +506,146 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Alternatively, the intersection can be calculated using special methods optimized for structured grids. Access these methods by instantiating the GridIntersect class with the `method=\"structured\"` keyword argument." + "The `intersect()` method contains several keyword arguments that specifically deal with polygons:\n", + "\n", + "- `contains_centroid`: only store intersection result if cell centroid is contained within polygon\n", + "- `min_area_fraction`: minimal intersecting cell area (expressed as a fraction of the total cell area) to include cells in intersection result\n", + "\n", + "Two examples showing the usage of these keyword arguments are shown below.\n", + "\n", + "Example with `contains_centroid` set to True, only cells in which centroid is within the intersected polygon are stored. Note the difference with the previous result." ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:30.005069Z", - "iopub.status.busy": "2022-03-07T20:04:30.004433Z", - "iopub.status.idle": "2022-03-07T20:04:30.006653Z", - "shell.execute_reply": "2022-03-07T20:04:30.007234Z" + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/david/anaconda3/envs/artesia/lib/python3.9/site-packages/descartes/patch.py:62: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", + " vertices = concatenate([\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ - "ixs = GridIntersect(sgr, method=\"structured\")" + "# contains_centroid example\n", + "\n", + "result2 = ix.intersect(p, contains_centroid=True)\n", + "\n", + "# create a figure and plot the grid\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 8))\n", + "sgr.plot(ax=ax)\n", + "\n", + "# the intersection object contains some helpful plotting commands\n", + "ix.plot_polygon(result2, ax=ax)\n", + "\n", + "# add black x at cell centers\n", + "for irow, icol in result2.cellids:\n", + " (h2,) = ax.plot(\n", + " sgr.xcellcenters[0, icol],\n", + " sgr.ycellcenters[irow, 0],\n", + " \"kx\",\n", + " label=\"centroids of intersected gridcells\",\n", + " )\n", + "\n", + "# add legend\n", + "ax.legend([h2], [i.get_label() for i in [h2]], loc=\"best\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The methods are optimized for structured grids, but for certain types of polygons there is no benefit (as can be seen in this example)." + "Example with `min_area_threshold` set to 0.35, the intersection result in a cell should cover 35% or more of the cell area." ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:30.013496Z", - "iopub.status.busy": "2022-03-07T20:04:30.012857Z", - "iopub.status.idle": "2022-03-07T20:04:38.628178Z", - "shell.execute_reply": "2022-03-07T20:04:38.628618Z" - } - }, + "execution_count": 16, + "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "10.6 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "/home/david/anaconda3/envs/artesia/lib/python3.9/site-packages/descartes/patch.py:62: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", + " vertices = concatenate([\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ + "# min_area_threshold example\n", + "\n", + "result3 = ix.intersect(p, min_area_fraction=0.35)\n", + "\n", + "# create a figure and plot the grid\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 8))\n", + "sgr.plot(ax=ax)\n", + "\n", + "# the intersection object contains some helpful plotting commands\n", + "ix.plot_polygon(result3, ax=ax)\n", + "\n", + "# add black x at cell centers\n", + "for irow, icol in result3.cellids:\n", + " (h2,) = ax.plot(\n", + " sgr.xcellcenters[0, icol],\n", + " sgr.ycellcenters[irow, 0],\n", + " \"kx\",\n", + " label=\"centroids of intersected gridcells\",\n", + " )\n", + "\n", + "# add legend\n", + "ax.legend([h2], [i.get_label() for i in [h2]], loc=\"best\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, the intersection can be calculated using special methods optimized for structured grids. Access these methods by instantiating the GridIntersect class with the `method=\"structured\"` keyword argument." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "ixs = GridIntersect(sgr, method=\"structured\")" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "# The methods are optimized for structured grids, but for certain types of polygons there is no benefit (as can be seen in this example).\n", "%timeit ixs.intersect(p)" ] }, @@ -623,35 +658,21 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:38.633459Z", - "iopub.status.busy": "2022-03-07T20:04:38.632524Z", - "iopub.status.idle": "2022-03-07T20:04:38.647443Z", - "shell.execute_reply": "2022-03-07T20:04:38.647934Z" - } - }, + "execution_count": 18, + "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "rec.array([((2, 3), (((35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0), (35.0, 80.0)),), 66.66666667, ),\n", - " ((2, 4), (((50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667), (50.0, 70.0)),), 33.33333333, ),\n", - " ((3, 2), (((30.0, 70.0), (30.0, 60.0), (25.0, 60.0), (30.0, 70.0)),), 25. , ),\n", - " ((3, 3), (((40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0), (40.0, 70.0)),), 100. , ),\n", - " ((3, 4), (((50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0), (50.0, 70.0)),), 100. , )],\n", - " dtype=[('cellids', 'O'), ('vertices', 'O'), ('areas', '" ] @@ -786,42 +769,39 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:42.067668Z", - "iopub.status.busy": "2022-03-07T20:04:42.066825Z", - "iopub.status.idle": "2022-03-07T20:04:42.068912Z", - "shell.execute_reply": "2022-03-07T20:04:42.069350Z" - } - }, + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "ixs = GridIntersect(sgr, method=\"structured\")" ] }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "%timeit ixs.intersect(mls)" + ] + }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:42.074344Z", - "iopub.status.busy": "2022-03-07T20:04:42.073533Z", - "iopub.status.idle": "2022-03-07T20:04:47.590449Z", - "shell.execute_reply": "2022-03-07T20:04:47.590842Z" - } - }, + "execution_count": 18, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "6.79 ms ± 113 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + "Intersection result with method='structured' and method='vertex' are equal: True\n" ] } ], "source": [ - "%timeit ixs.intersect(mls)" + "result2 = ixs.intersect(mls)\n", + "\n", + "# ordering is different so compare sets to check equality\n", + "check = len(set(result2.cellids) - set(result.cellids)) == 0\n", + "print(f\"Intersection result with method='structured' and method='vertex' are equal: {check}\")" ] }, { @@ -835,15 +815,8 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:47.595418Z", - "iopub.status.busy": "2022-03-07T20:04:47.594851Z", - "iopub.status.idle": "2022-03-07T20:04:47.597409Z", - "shell.execute_reply": "2022-03-07T20:04:47.597791Z" - } - }, + "execution_count": 35, + "metadata": {}, "outputs": [], "source": [ "mp = MultiPoint(\n", @@ -857,75 +830,37 @@ ] }, { - "cell_type": "code", - "execution_count": 24, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:47.603588Z", - "iopub.status.busy": "2022-03-07T20:04:47.603041Z", - "iopub.status.idle": "2022-03-07T20:04:59.123476Z", - "shell.execute_reply": "2022-03-07T20:04:59.124287Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.48 ms ± 720 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" - ] - } - ], + "cell_type": "raw", + "metadata": {}, "source": [ "%timeit ix.intersect(mp)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For points and linestrings there is a keyword argument `return_all_intersections` which will return multiple intersection results for points or (parts of) linestrings on cell boundaries. As an example, the difference is shown with the MultiPoint intersection. Note the number of red \"+\" symbols indicating the centroids of intersected cells, in the bottom right case, there are 4 results because the point lies exactly on the intersection between 4 grid cells. " + ] + }, { "cell_type": "code", - "execution_count": 25, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:59.130769Z", - "iopub.status.busy": "2022-03-07T20:04:59.129732Z", - "iopub.status.idle": "2022-03-07T20:04:59.138101Z", - "shell.execute_reply": "2022-03-07T20:04:59.138885Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "rec.array([((5, 4), ((45.0, 45.0),), ),\n", - " ((8, 0), ((10.0, 10.0),), ),\n", - " ((9, 4), ((50.0, 0.0),), )],\n", - " dtype=[('cellids', 'O'), ('vertices', 'O'), ('ixshapes', 'O')])" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": 36, + "metadata": {}, + "outputs": [], "source": [ "result = ix.intersect(mp)\n", - "result" + "result_all =ix.intersect(mp, return_all_intersections=True)" ] }, { "cell_type": "code", - "execution_count": 26, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:59.159492Z", - "iopub.status.busy": "2022-03-07T20:04:59.152007Z", - "iopub.status.idle": "2022-03-07T20:04:59.277671Z", - "shell.execute_reply": "2022-03-07T20:04:59.278105Z" - } - }, + "execution_count": 37, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -939,17 +874,26 @@ "source": [ "fig, ax = plt.subplots(1, 1, figsize=(8, 8))\n", "sgr.plot(ax=ax)\n", - "ix.plot_point(result, ax=ax, s=50)\n", + "ix.plot_point(result, ax=ax, s=50, color=\"C0\")\n", + "ix.plot_point(result_all, ax=ax, s=50, marker=\".\", color=\"C3\")\n", "\n", "for irow, icol in result.cellids:\n", " (h2,) = ax.plot(\n", " sgr.xcellcenters[0, icol],\n", " sgr.ycellcenters[irow, 0],\n", - " \"kx\",\n", + " \"kx\", ms=15,\n", " label=\"centroids of intersected cells\",\n", " )\n", "\n", - "ax.legend([h2], [i.get_label() for i in [h2]], loc=\"best\");" + "for irow, icol in result_all.cellids:\n", + " (h3,) = ax.plot(\n", + " sgr.xcellcenters[0, icol],\n", + " sgr.ycellcenters[irow, 0],\n", + " \"C3+\", ms=15,\n", + " label=\"centroid with `return_all_intersections=True`\",\n", + " )\n", + " \n", + "ax.legend([h2, h3], [i.get_label() for i in [h2, h3]], loc=\"best\");" ] }, { @@ -961,72 +905,39 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:59.282124Z", - "iopub.status.busy": "2022-03-07T20:04:59.281349Z", - "iopub.status.idle": "2022-03-07T20:04:59.283486Z", - "shell.execute_reply": "2022-03-07T20:04:59.283870Z" - } - }, + "execution_count": 38, + "metadata": {}, "outputs": [], "source": [ "ixs = GridIntersect(sgr, method=\"structured\")" ] }, { - "cell_type": "code", - "execution_count": 28, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:04:59.289132Z", - "iopub.status.busy": "2022-03-07T20:04:59.288297Z", - "iopub.status.idle": "2022-03-07T20:05:06.858340Z", - "shell.execute_reply": "2022-03-07T20:05:06.858850Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "984 µs ± 567 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n" - ] - } - ], + "cell_type": "raw", + "metadata": {}, "source": [ "%timeit ixs.intersect(mp)" ] }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:06.863208Z", - "iopub.status.busy": "2022-03-07T20:05:06.862482Z", - "iopub.status.idle": "2022-03-07T20:05:06.867096Z", - "shell.execute_reply": "2022-03-07T20:05:06.867512Z" - } - }, + "execution_count": 39, + "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "rec.array([((9, 4), ),\n", - " ((5, 4), ),\n", - " ((8, 0), )],\n", - " dtype=[('cellids', 'O'), ('ixshapes', 'O')])" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Intersection result with method='structured' and method='vertex' are equal: True\n" + ] } ], "source": [ - "ixs.intersect(mp)" + "result2 = ixs.intersect(mp, return_all_intersections=False)\n", + "\n", + "# ordering is different so compare sets to check equality\n", + "check = len(set(result2.cellids) - set(result.cellids)) == 0\n", + "print(f\"Intersection result with method='structured' and method='vertex' are equal: {check}\")" ] }, { @@ -1038,15 +949,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:06.876167Z", - "iopub.status.busy": "2022-03-07T20:05:06.875445Z", - "iopub.status.idle": "2022-03-07T20:05:06.877408Z", - "shell.execute_reply": "2022-03-07T20:05:06.877809Z" - } - }, + "execution_count": 40, + "metadata": {}, "outputs": [], "source": [ "cell2d = [\n", @@ -1075,29 +979,22 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:06.897132Z", - "iopub.status.busy": "2022-03-07T20:05:06.896248Z", - "iopub.status.idle": "2022-03-07T20:05:06.987126Z", - "shell.execute_reply": "2022-03-07T20:05:06.987945Z" - } - }, + "execution_count": 41, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 31, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAHWCAYAAACmHPpfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAcMElEQVR4nO3db6xtd13n8c+Xe28RUNN2ZiDlFgImDYgkyp3GQZ0YY210FCxPJlMTTJky6RMY0Tgxl5kQMw+Y9IEh+mA0afDaJiqNQTJtjTKSqxNnkglOBTMClZSIA8VLixL/xAe9F+5vHpx96OntOfecvfdae/17vZJm7bX2Wuv88svteWftvc/a1VoLADCsFw09AABAkAFgFAQZAEZAkAFgBAQZAEZAkAFgBI4NclVdqKpnqupTB7bdXFUfq6onV8ubDjz33qr6XFV9tqp+uK+BA8CcnOQK+cEkP3LNtvNJLrbWbktycbWeqnpDkruTfMfqmF+uqlOdjRYAZurYILfW/ijJV6/ZfFeSh1aPH0rytgPbH26tPdta+3ySzyX57m6GCgDztel7yK9orV1KktXy5avtZ5N88cB+T622AQDXcbrj89Uh2w69N2dV3ZfkviR5yUte8s9vvPHGnDlzJi96kc+ZQdcuX76cJLnhhhsGHgnMz5UrV3L16tVcunTpr1tr/2zT82wa5Ker6pbW2qWquiXJM6vtTyV51YH9bk3yV4edoLX2QJIHkuTVr351e+c735kXvehFuffee3P2rItq6NL999+fJDl//vzAI4F5efjhh/PZz342p06dyvve977/t825Nr0cfTTJPavH9yR55MD2u6vqxVX12iS3Jfnj40526tSpvPWtb83Vq1dz4cKFfOlLX9pwWACwG/sx/pZv+Za88pWv3Pp8J/mzpw8l+d9JXldVT1XVO5Pcn+TOqnoyyZ2r9bTWPp3kt5J8JslHk7yrtfb1kwzk3LlzogzAJByM8bvf/e5O3m499iXr1tpPHPHUHUfs//4k799kMOfOnUuSPPbYY7lw4YKXrwEYnWtj3NVnM0b3CSpXygCMVV8xTkYY5ESUARifPmOcjDTIiSgDMB59xzgZcZATUQZgeLuIcTLyICeiDMBwdhXjZAJBTkQZgN3bZYyTiQQ5EWUAdmfXMU4mFORElAHo3xAxTiYW5ESUAejPUDFOJhjkRJQB6N6QMU4mGuRElAHoztAxTiYc5ESUAdjeGGKcTDzIiSgDsLmxxDiZQZATUQZgfWOKcTKTICeiDMDJjS3GyYyCnIgyAMcbY4yTmQU5EWUAjjbWGCczDHIiygC80JhjnMw0yIkoA/Ccscc4mXGQE1EGYBoxTmYe5ESUAZZsKjFOFhDkRJQBlmhKMU4WEuRElAGWZGoxThYU5ESUAZZgijFOFhbkRJQB5myqMU4WGORElAHmaMoxThYa5ESUAeZk6jFOFhzkRJQB5mAOMU4WHuRElAGmbC4xTgQ5iSgDTNGcYpwI8jeIMsB0zC3GiSA/jygDjN8cY5wI8guIMsB4zTXGiSAfSpQBxmfOMU4E+UiiDDAec49xIsjXJcoAw1tCjBNBPpYoAwxnKTFOBPlERBlg95YU40SQT0yUAXZnaTFOBHktogzQvyXGOBHktYkyQH+WGuNEkDciygDdW3KME0HemCgDdGfpMU4EeSuiDLA9Md4jyFsSZYDNifFzBLkDogywPjF+PkHuiCgDnJwYv5Agd0iUAY4nxocT5I6JMsDRxPhogtwDUQZ4ITG+PkHuiSgDPEeMjyfIPRJlADE+KUHumSgDSybGJyfIOyDKwBKJ8XoEeUdEGVgSMV6fIO+QKANLIMabEeQdE2VgzsR4c4I8AFEG5kiMtyPIAxFlYE7EeHuCPCBRBuZAjLshyAMTZWDKxLg7gjwCogxMkRh3S5BHQpSBKRHj7gnyiIgyMAVi3A9BHhlRBsZMjPsjyCMkysAYiXG/BHmkRBkYEzHunyCPmCgDYyDGuyHIIyfKwJDEeHcEeQJEGRiCGO+WIE+EKAO7JMa7J8gTIsrALojxMAR5YkQZ6JMYD0eQJ0iUgT6I8bAEeaJEGeiSGA9PkCdMlIEuiPE4CPLEiTKwDTEeD0GeAVEGNiHG47JVkKvqZ6rq01X1qar6UFV9U1XdXFUfq6onV8ubuhosRxNlYB1iPD4bB7mqzib5qSS3t9bemORUkruTnE9ysbV2W5KLq3V2QJSBkxDjcdr2JevTSV5SVaeTvDTJXyW5K8lDq+cfSvK2LX8GaxBl4HrEeLw2DnJr7UtJfiHJF5JcSvJ3rbXfT/KK1tql1T6Xkry8i4FycqIMHEaMx22bl6xvyt7V8GuTvDLJy6rq7Wscf19VPV5Vj1+5cmXTYXAEUQYOEuPx2+Yl6x9K8vnW2ldaa1eSfCTJ9yZ5uqpuSZLV8pnDDm6tPdBau721dvuZM2e2GAZHEWUgEeOp2CbIX0jy5qp6aVVVkjuSPJHk0ST3rPa5J8kj2w2RbYgyLJsYT8c27yF/PMmHk3wiyZ+tzvVAkvuT3FlVTya5c7XOgEQZlkmMp2WrT1m31n6+tfb61tobW2s/2Vp7trX2N621O1prt62WX+1qsGxOlGFZxHh63KlrQUQZlkGMp0mQF0aUYd7EeLoEeYFEGeZJjKdNkBdKlGFexHj6BHnBRBnmQYznQZAXTpRh2sR4PgQZUYaJEuN5EWSSiDJMjRjPjyDzDaIM0yDG8yTIPI8ow7iJ8XwJMi8gyjBOYjxvgsyhRBnGRYznT5A5kijDOIjxMggy1yXKMCwxXg5B5liiDMMQ42URZE5ElGG3xHh5BJkTE2XYDTFeJkFmLaIM/RLj5RJk1ibK0A8xXjZBZiOiDN0SYwSZjYkydEOMSQSZLYkybEeM2SfIbE2UYTNizEGCTCdEGdYjxlxLkOmMKMPJiDGHEWQ6JcpwfWLMUQSZzokyHE6MuR5BpheiDM8nxhxHkOmNKMMeMeYkBJleiTJLJ8aclCDTO1FmqcSYdQgyOyHKLI0Ysy5BZmdEmaUQYzYhyOyUKDN3YsymBJmdE2XmSozZhiAzCFFmbsSYbQkygxFl5kKM6YIgMyhRZurEmK4IMoMTZaZKjOmSIDMKoszUiDFdE2RGQ5SZCjGmD4LMqIgyYyfG9EWQGR1RZqzEmD4JMqMkyoyNGNM3QWa0RJmxEGN2QZAZNVFmaGLMrggyoyfKDEWM2SVBZhJEmV0TY3ZNkJkMUWZXxJghCDKTIsr0TYwZiiAzOaJMX8SYIQkykyTKdE2MGZogM1miTFfEmDEQZCZNlNmWGDMWgszkiTKbEmPGRJCZBVFmXWLM2AgysyHKnJQYM0aCzKyIMscRY8ZKkJkdUeYoYsyYCTKzJMpcS4wZO0FmtkSZfWLMFAgysybKiDFTIcjMnigvlxgzJYLMIojy8ogxUyPILIYoL4cYM0WCzKKI8vyJMVMlyCyOKM+XGDNlgswiifL8iDFTJ8gslijPhxgzB4LMoony9IkxcyHILJ4oT5cYMyeCDBHlKRJj5kaQYUWUp0OMmSNBhgNEefzEmLkSZLiGKI+XGDNnggyHEOXxEWPmTpDhCKI8HmLMEggyXIcoD0+MWYqtglxVN1bVh6vqz6vqiar6nqq6uao+VlVPrpY3dTVYGIIoD0eMWZJtr5B/KclHW2uvT/KdSZ5Icj7JxdbabUkurtZh0kR598SYpdk4yFX1rUm+P8mvJklr7XJr7W+T3JXkodVuDyV523ZDhHEQ5d0RY5Zomyvkb0vylSS/VlWfrKoPVtXLkryitXYpSVbLl3cwThgFUe6fGLNU2wT5dJJzSX6ltfamJP+YNV6erqr7qurxqnr8ypUrWwwDdkuU+yPGLNk2QX4qyVOttY+v1j+cvUA/XVW3JMlq+cxhB7fWHmit3d5au/3MmTNbDAN2T5S7J8Ys3cZBbq19OckXq+p1q013JPlMkkeT3LPadk+SR7YaIYyUKHdHjGH7T1n/+yS/UVX/N8l3JfkvSe5PcmdVPZnkztU6zJIob0+MYc/pbQ5urf1pktsPeeqObc4LU3Lu3LkkyWOPPZYLFy7k3nvvzdmzZwce1TSIMTzHnbqgA66U1yfG8HyCDB0R5ZMTY3ghQYYOifLxxBgOJ8jQMVE+mhjD0QQZeiDKLyTGcH2CDD0R5eeIMRxPkKFHoizGcFKCDD1bcpTFGE5OkGEHlhhlMYb1CDLsyJKiLMawPkGGHVpClMUYNiPIsGNzjrIYw+YEGQYwxyiLMWxHkGEgc4qyGMP2BBkGNIcoizF0Q5BhYFOOshhDdwQZRmCKURZj6JYgw0hMKcpiDN0TZBiRKURZjKEfggwjM+YoizH0R5BhhMYYZTGGfgkyjNSYoizG0D9BhhEbQ5TFGHZDkGHkhoyyGMPuCDJMwBBRFmPYLUGGidhllMUYdk+QYUJ2EWUxhmEIMkxMn1EWYxiOIMME9RFlMYZhCTJMVJdRFmMYniDDhHURZTGGcRBkmLhtoizGMB6CDDOwSZTFGMZFkGEm1omyGMP4CDLMyEmiLMYwToIMM3O9KIsxjNfpoQcAdO/cuXNJksceeywXLlzIqVOn8vWvf12MYcRGEeTLly/n/vvvH3oYMDv7Ib569eo3tj377LP5wAc+MOCoYH4uX7689Tm8ZA0zdvr06VTVkevAeIziCvmGG27I+fPnhx4GzM7+e8b7rl69mne84x05e/bsgKOC+XnwwQe3PocrZJipgx/gevGLX5xTp07t9PuUgfUIMszQtZ+mTvZert7V9ykD6xNkmJnr/WnTLr5PGdiMIMOMnOTvjEUZxkmQYSbWuemHKMP4CDLMwCZ34BJlGBdBhonb5naYogzjIcgwYV3cm1qUYRwEGSaqyy+KEGUYniDDBPXxrU2iDMMSZJiYPr9CUZRhOIIME7KL7zMWZRiGIMNE7CLG+0QZdk+QYQJ2GeN9ogy7JcgwckPEeJ8ow+4IMozYkDHeJ8qwG4IMIzWGGO8TZeifIMMIjSnG+0QZ+iXIMDJjjPE+UYb+CDKMyJhjvE+UoR+CDCMxhRjvE2XoniDDCEwpxvtEGbolyDCwKcZ4nyhDdwQZBjTlGO8TZeiGIMNA5hDjfaIM2xNkGMCcYrxPlGE7ggw7NscY7xNl2Jwgww7NOcb7RBk2I8iwI0uI8T5RhvUJMuzAkmK8T5RhPYIMPVtijPeJMpycIEOPlhzjfaIMJyPI0BMxfo4ow/EEGXogxi8kynB9ggwdE+OjiTIcTZChQ2J8PFGGwwkydESMT06U4YUEGTogxusTZXi+rYNcVaeq6pNV9Tur9Zur6mNV9eRqedP2w4TxEuPNiTI8p4sr5PckeeLA+vkkF1trtyW5uFqHWRLj7Yky7NkqyFV1a5IfS/LBA5vvSvLQ6vFDSd62zc+AsRLj7ogybH+F/ItJfi7J1QPbXtFau5Qkq+XLt/wZMDpi3D1RZuk2DnJVvSXJM621P9nw+Puq6vGqevzKlSubDgN2Toz7I8os2TZXyN+X5Mer6i+TPJzkB6vq15M8XVW3JMlq+cxhB7fWHmit3d5au/3MmTNbDAN2R4z7J8os1cZBbq29t7V2a2vtNUnuTvIHrbW3J3k0yT2r3e5J8sjWo4QREOPdEWWWqI+/Q74/yZ1V9WSSO1frMGlivHuizNJ0EuTW2v9orb1l9fhvWmt3tNZuWy2/2sXPgKGI8XBEmSVxpy64DjEeniizFIIMRxDj8RBllkCQ4RBiPD6izNwJMlxDjMdLlJkzQYYDxHj8RJm5EmRYEePpEGXmSJAhYjxFoszcCDKLJ8bTJcrMiSCzaGI8faLMXAgyiyXG8yHKzIEgs0hiPD+izNQJMosjxvMlykyZILMoYjx/osxUCTKLIcbLIcpMkSCzCGK8PKLM1AgysyfGyyXKTIkgM2tijCgzFYLMbIkx+0SZKRBkZkmMuZYoM3aCzOyIMUcRZcZMkJkVMeY4osxYCTKzIcaclCgzRoLMLIgx6xJlxkaQmTwxZlOizJgIMpMmxmxLlBkLQWayxJiuiDJjIMhMkhjTNVFmaILM5IgxfRFlhiTITIoY0zdRZiiCzGSIMbsiygxBkJkEMWbXRJldE2RGT4wZiiizS4LMqIkxQxNldkWQGS0xZixEmV0QZEZJjBkbUaZvgszoiDFjJcr0SZAZFTFm7ESZvggyoyHGTIUo0wdBZhTEmKkRZbomyAxOjJkqUaZLgsygxJipE2W6IsgMRoyZC1GmC4LMIMSYuRFltiXI7JwYM1eizDYEmZ0SY+ZOlNmUILMzYsxSiDKbEGR2QoxZGlFmXYJM78SYpRJl1iHI9EqMWTpR5qQEmd6IMewRZU5CkOmFGMPziTLHEWQ6J8ZwOFHmegSZTokxXJ8ocxRBpjNiDCcjyhxGkOmEGMN6RJlrCTJbE2PYjChzkCCzFTGG7Ygy+wSZjYkxdEOUSQSZDYkxdEuUEWTWJsbQD1FeNkFmLWIM/RLl5RJkTkyMYTdEeZkEmRMRY9gtUV4eQeZYYgzDEOVlEWSuS4xhWKK8HILMkcQYxkGUl0GQOZQYw7iI8vwJMi8gxjBOojxvgszziDGMmyjPlyDzDWIM0yDK8yTIJBFjmBpRnh9BRoxhokR5XgR54cQYpk2U50OQF0yMYR5EeR4EeaHEGOZFlKdPkBdIjGGeRHnaBHlhxBjmTZSnS5AXRIxhGUR5mjYOclW9qqr+sKqeqKpPV9V7VttvrqqPVdWTq+VN3Q2XTYkxLIsoT882V8hfS/KzrbVvT/LmJO+qqjckOZ/kYmvttiQXV+sMSIxhmUR5WjYOcmvtUmvtE6vH/5DkiSRnk9yV5KHVbg8leduWY2QLYgzLJsrT0cl7yFX1miRvSvLxJK9orV1K9qKd5OVd/AzWJ8ZAIspTsXWQq+qbk/x2kp9urf39GsfdV1WPV9XjV65c2XYYXEOMgYNEefy2CnJVnclejH+jtfaR1eanq+qW1fO3JHnmsGNbaw+01m5vrd1+5syZbYbBNcQYOIwoj9s2n7KuJL+a5InW2gcOPPVokntWj+9J8sjmw2NdYgxcjyiP1zZXyN+X5CeT/GBV/enqvx9Ncn+SO6vqySR3rtbZATEGTkKUx+n0pge21v5Xkjri6Ts2PS+bEWNgHefOnUuSPPbYY7lw4ULuvffenD17duBRLZs7dc2AGAObcKU8LoI8cWIMbEOUx0OQJ0yMgS6I8jgI8kSJMdAlUR6eIE+QGAN9EOVhCfLEiDHQJ1EejiBPiBgDuyDKwxDkiRBjYJdEefcEeQLEGBiCKO+WII+cGANDEuXdEeQRE2NgDER5NwR5pMQYGBNR7p8gj5AYA2Mkyv0S5JERY2DMRLk/gjwiYgxMgSj3Q5BHQoyBKRHl7gnyCIgxMEWi3C1BHpgYA1Mmyt0R5AGJMTAHotwNQR6IGANzIsrbE+QBiDEwR6K8HUHeMTEG5kyUNyfIOyTGwBKI8mYEeUfEGFgSUV6fIO+AGANLJMrrEeSeiTGwZKJ8coLcIzEGEOWTEuSeiDHAc0T5eILcAzEGeCFRvj5B7pgYAxxNlI8myB0SY4DjifLhBLkjYgxwcqL8QoLcATEGWJ8oP58gb0mMATYnys8R5C2IMcD2RHmPIG9IjAG6I8qCvBExBuje0qMsyGsSY4D+LDnKgrwGMQbo31KjLMgnJMYAu7PEKAvyCYgxwO4tLcqCfAwxBhjOkqIsyNchxgDDW0qUBfkIYgwwHkuIsiAfQowBxmfuURbka4gxwHjNOcqCfIAYA4zfXKMsyCtiDDAdc4yyIEeMAaZoblFefJDFGGC65hTlRQdZjAGmby5RXmyQxRhgPuYQ5UUGWYwB5mfqUV5ckMUYYL6mHOVFBVmMAeZvqlFeTJDFGGA5phjlRQRZjAGWZ2pRnn2QxRhguaYU5VkHWYwBmEqUZxtkMQZg3xSiPMsgizEA1xp7lGcXZDEG4ChjjvKsgizGABxnrFGeTZDFGICTGmOUZxFkMQZgXWOL8uSDLMYAbGpMUZ50kMUYgG2NJcqTDbIYA9CVMUR5kkEWYwC6NnSUJxdkMQagL0NGeVJBFmMA+jZUlCcTZDEGYFeGiPIkgizGAOzarqM8+iCLMQBD2WWURx1kMQZgaLuK8miDLMYAjMUuojzKIIsxAGPTd5RHF2QxBmCs+oxyb0Guqh+pqs9W1eeq6vxJjhFjAMauryj3EuSqOpXkvyb5V0nekOQnquoN1ztGjAGYimuj/Oyzz259zr6ukL87yedaa3/RWruc5OEkdx2185UrV8QYgEk5GOUvf/nLW5/vdAdjOszZJF88sP5Ukn9x1M5Xr17NqVOncuONN+Y3f/M3exoSLNfly5eTJA8++OCwA4EZuvnmm/PVr3516/P0FeQ6ZFt73g5V9yW5b7X67Pve975P9TSWpfunSf566EHMlLntj7ntj7ntz+u2ObivID+V5FUH1m9N8lcHd2itPZDkgSSpqsdba7f3NJZFM7f9Mbf9Mbf9Mbf9qarHtzm+r/eQ/0+S26rqtVV1Q5K7kzza088CgMnr5Qq5tfa1qnp3kv+e5FSSC621T/fxswBgDvp6yTqttd9N8rsn3P2BvsaBue2Rue2Pue2Pue3PVnNbrbXj9wIAejW6W2cCwBINHuRNbrHJ4arqVVX1h1X1RFV9uqres9p+c1V9rKqeXC1vGnqsU1RVp6rqk1X1O6t189qRqrqxqj5cVX+++vf7PeZ3e1X1M6vfBZ+qqg9V1TeZ181V1YWqeqaqPnVg25HzWVXvXbXts1X1w8edf9Agb3KLTa7ra0l+trX27UnenORdq/k8n+Ria+22JBdX66zvPUmeOLBuXrvzS0k+2lp7fZLvzN48m98tVNXZJD+V5PbW2huz9wHbu2Net/Fgkh+5Ztuh87n63Xt3ku9YHfPLq+Ydaegr5LVuscn1tdYutdY+sXr8D9n7pXY2e3P60Gq3h5K8bZABTlhV3Zrkx5J88MBm89qBqvrWJN+f5FeTpLV2ubX2tzG/XTid5CVVdTrJS7N3PwjzuqHW2h8lufaWXEfN511JHm6tPdta+3ySz2WveUcaOsiH3WLz7EBjmZWqek2SNyX5eJJXtNYuJXvRTvLyAYc2Vb+Y5OeSXD2wzbx249uSfCXJr63eEvhgVb0s5ncrrbUvJfmFJF9IcinJ37XWfj/mtWtHzefafRs6yMfeYpP1VdU3J/ntJD/dWvv7occzdVX1liTPtNb+ZOixzNTpJOeS/Epr7U1J/jFeRt3a6r3Mu5K8Nskrk7ysqt4+7KgWZe2+DR3kY2+xyXqq6kz2YvwbrbWPrDY/XVW3rJ6/JckzQ41vor4vyY9X1V9m722VH6yqX4957cpTSZ5qrX18tf7h7AXa/G7nh5J8vrX2ldbalSQfSfK9Ma9dO2o+1+7b0EF2i80OVVVl7324J1prHzjw1KNJ7lk9vifJI7se25S11t7bWru1tfaa7P0b/YPW2ttjXjvRWvtyki9W1f6N+e9I8pmY3219Icmbq+qlq98Nd2TvcyXmtVtHzeejSe6uqhdX1WuT3Jbkj693osFvDFJVP5q99+f2b7H5/kEHNGFV9S+T/M8kf5bn3uv8j9l7H/m3krw6e/+T/uvW2vbfFbZAVfUDSf5Da+0tVfVPYl47UVXflb0PzN2Q5C+S/NvsXTCY3y1U1X9O8m+y9xcYn0zy75J8c8zrRqrqQ0l+IHvfmPV0kp9P8t9yxHxW1X9Kcm/25v+nW2u/d93zDx1kAGD4l6wBgAgyAIyCIAPACAgyAIyAIAPACAgyAIyAIAPACAgyAIzA/wduQd0zDj+8iwAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1123,21 +1020,14 @@ }, { "cell_type": "code", - "execution_count": 32, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:06.993132Z", - "iopub.status.busy": "2022-03-07T20:05:06.992418Z", - "iopub.status.idle": "2022-03-07T20:05:06.995371Z", - "shell.execute_reply": "2022-03-07T20:05:06.995846Z" - } - }, + "execution_count": 42, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/jdhughes/Documents/Development/flopy_git/flopy_fork/examples/Notebooks/../../flopy/utils/gridintersect.py:337: ShapelyDeprecationWarning: Setting custom attributes on geometry objects is deprecated, and will raise an AttributeError in Shapely 2.0\n", + "/home/david/Github/flopy_db/examples/Notebooks/../../flopy/utils/gridintersect.py:377: ShapelyDeprecationWarning: Setting custom attributes on geometry objects is deprecated, and will raise an AttributeError in Shapely 2.0\n", " p.name = icell\n" ] } @@ -1148,15 +1038,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.000987Z", - "iopub.status.busy": "2022-03-07T20:05:07.000154Z", - "iopub.status.idle": "2022-03-07T20:05:07.005062Z", - "shell.execute_reply": "2022-03-07T20:05:07.005472Z" - } - }, + "execution_count": 43, + "metadata": {}, "outputs": [], "source": [ "result = ix2.intersect(p)" @@ -1164,27 +1047,20 @@ }, { "cell_type": "code", - "execution_count": 34, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.027543Z", - "iopub.status.busy": "2022-03-07T20:05:07.017631Z", - "iopub.status.idle": "2022-03-07T20:05:07.175551Z", - "shell.execute_reply": "2022-03-07T20:05:07.176227Z" - } - }, + "execution_count": 44, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/jdhughes/opt/anaconda3/lib/python3.9/site-packages/descartes/patch.py:62: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", + "/home/david/anaconda3/envs/artesia/lib/python3.9/site-packages/descartes/patch.py:62: ShapelyDeprecationWarning: The array interface is deprecated and will no longer work in Shapely 2.0. Convert the '.coords' to a numpy array instead.\n", " vertices = concatenate([\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1222,15 +1098,8 @@ }, { "cell_type": "code", - "execution_count": 35, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.181729Z", - "iopub.status.busy": "2022-03-07T20:05:07.180810Z", - "iopub.status.idle": "2022-03-07T20:05:07.185609Z", - "shell.execute_reply": "2022-03-07T20:05:07.186122Z" - } - }, + "execution_count": 45, + "metadata": {}, "outputs": [], "source": [ "result = ix2.intersect(mls)" @@ -1238,27 +1107,20 @@ }, { "cell_type": "code", - "execution_count": 36, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.268936Z", - "iopub.status.busy": "2022-03-07T20:05:07.268117Z", - "iopub.status.idle": "2022-03-07T20:05:07.396184Z", - "shell.execute_reply": "2022-03-07T20:05:07.396800Z" - } - }, + "execution_count": 46, + "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/jdhughes/Documents/Development/flopy_git/flopy_fork/examples/Notebooks/../../flopy/utils/gridintersect.py:1561: ShapelyDeprecationWarning: Iteration over multi-part geometries is deprecated and will be removed in Shapely 2.0. Use the `geoms` property to access the constituent parts of a multi-part geometry.\n", + "/home/david/Github/flopy_db/examples/Notebooks/../../flopy/utils/gridintersect.py:1781: ShapelyDeprecationWarning: Iteration over multi-part geometries is deprecated and will be removed in Shapely 2.0. Use the `geoms` property to access the constituent parts of a multi-part geometry.\n", " for part in ishp:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1295,41 +1157,28 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.402306Z", - "iopub.status.busy": "2022-03-07T20:05:07.401472Z", - "iopub.status.idle": "2022-03-07T20:05:07.405573Z", - "shell.execute_reply": "2022-03-07T20:05:07.406022Z" - } - }, + "execution_count": 51, + "metadata": {}, "outputs": [], "source": [ - "result = ix2.intersect(mp)" + "result = ix2.intersect(mp)\n", + "result_all = ix2.intersect(mp, return_all_intersections=True)" ] }, { "cell_type": "code", - "execution_count": 38, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.410982Z", - "iopub.status.busy": "2022-03-07T20:05:07.410224Z", - "iopub.status.idle": "2022-03-07T20:05:07.413211Z", - "shell.execute_reply": "2022-03-07T20:05:07.413619Z" - } - }, + "execution_count": 52, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "rec.array([(1, ((10.0, 10.0), (45.0, 45.0)), ),\n", - " (4, ((50.0, 0.0),), )],\n", + "rec.array([(1, ((10.0, 10.0), (45.0, 45.0)), ),\n", + " (4, ((50.0, 0.0),), )],\n", " dtype=[('cellids', 'O'), ('vertices', 'O'), ('ixshapes', 'O')])" ] }, - "execution_count": 38, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" } @@ -1340,19 +1189,12 @@ }, { "cell_type": "code", - "execution_count": 39, - "metadata": { - "execution": { - "iopub.execute_input": "2022-03-07T20:05:07.433507Z", - "iopub.status.busy": "2022-03-07T20:05:07.432644Z", - "iopub.status.idle": "2022-03-07T20:05:07.542937Z", - "shell.execute_reply": "2022-03-07T20:05:07.543350Z" - } - }, + "execution_count": 61, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1367,23 +1209,37 @@ "fig, ax = plt.subplots(1, 1, figsize=(8, 8))\n", "pmv = fplot.PlotMapView(ax=ax, modelgrid=tgr)\n", "pmv.plot_grid()\n", - "ix2.plot_point(result, ax=ax)\n", + "ix2.plot_point(result, ax=ax, color=\"k\", zorder=5, s=80)\n", "\n", "for cellid in result.cellids:\n", " (h2,) = ax.plot(\n", " tgr.xcellcenters[cellid],\n", " tgr.ycellcenters[cellid],\n", - " \"kx\",\n", + " \"kx\", ms=15,\n", " label=\"centroids of intersected cells\",\n", " )\n", + "for cellid in result_all.cellids:\n", + " (h3,) = ax.plot(\n", + " tgr.xcellcenters[cellid],\n", + " tgr.ycellcenters[cellid],\n", + " \"r+\", ms=15,\n", + " label=\"centroids with return_all_intersections=True\",\n", + " )\n", "\n", - "ax.legend([h2], [i.get_label() for i in [h2]], loc=\"best\");" + "ax.legend([h2, h3], [i.get_label() for i in [h2, h3]], loc=\"best\");" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1398,6 +1254,11 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" + }, + "vscode": { + "interpreter": { + "hash": "dace5e1b41a98a8e52d2a8eebc3b981caf2c12e7a76736ebfb89a489e3b62e79" + } } }, "nbformat": 4, diff --git a/flopy/utils/gridintersect.py b/flopy/utils/gridintersect.py index 0046c012ba..30030e2198 100644 --- a/flopy/utils/gridintersect.py +++ b/flopy/utils/gridintersect.py @@ -185,7 +185,14 @@ def __init__(self, mfgrid, method=None, rtree=True): ) def intersect( - self, shp, shapetype=None, sort_by_cellid=True, keepzerolengths=False + self, + shp, + shapetype=None, + sort_by_cellid=True, + keepzerolengths=False, + return_all_intersections=False, + contains_centroid=False, + min_area_fraction=None, ): """Method to intersect a shape with a model grid. @@ -194,16 +201,29 @@ def intersect( shp : shapely.geometry, geojson object, shapefile.Shape, or flopy geometry object shapetype : str, optional - type of shape (i.e. "point", "linestring", "polygon" or - their multi-variants), used by GeoSpatialUtil if shp is - passed as a list of vertices, default is None + type of shape (i.e. "point", "linestring", "polygon" or their + multi-variants), used by GeoSpatialUtil if shp is passed as a list + of vertices, default is None sort_by_cellid : bool - sort results by cellid, ensures cell with lowest cellid is - returned for boundary cases when using vertex methods, default - is True + sort results by cellid, ensures cell with lowest cellid is returned + for boundary cases when using vertex methods, default is True keepzerolengths : bool - boolean method to keep zero length intersections for - linestring intersection, used when shp is of type "linestring" + boolean method to keep zero length intersections for linestring + intersection, only used if shape type is "linestring" + return_all_intersections : bool, optional + if True, return multiple intersection results for points or + linestrings on grid cell boundaries (e.g. returns 2 intersection + results if a point lies on the boundary between two grid cells). + The default is False. Only used if shape type is "point" or + "linestring". + contains_centroid : bool, optional + if True, only store intersection result if cell centroid is + contained within intersection shape, only used if shape type is + "polygon" + min_area_fraction : float, optional + float defining minimum intersection area threshold, if intersection + area is smaller than min_frac_area * cell_area, do not store + intersection result, only used if shape type is "polygon" Returns ------- @@ -218,29 +238,49 @@ def intersect( self.method == "structured" and self.mfgrid.grid_type == "structured" ): - rec = self._intersect_point_structured(shp) + rec = self._intersect_point_structured( + shp, return_all_intersections=return_all_intersections + ) else: - rec = self._intersect_point_shapely(shp, sort_by_cellid) + rec = self._intersect_point_shapely( + shp, + sort_by_cellid=sort_by_cellid, + return_all_intersections=return_all_intersections, + ) elif gu.shapetype in ("LineString", "MultiLineString"): if ( self.method == "structured" and self.mfgrid.grid_type == "structured" ): rec = self._intersect_linestring_structured( - shp, keepzerolengths + shp, + keepzerolengths, + return_all_intersections=return_all_intersections, ) else: rec = self._intersect_linestring_shapely( - shp, keepzerolengths, sort_by_cellid + shp, + keepzerolengths, + sort_by_cellid=sort_by_cellid, + return_all_intersections=return_all_intersections, ) elif gu.shapetype in ("Polygon", "MultiPolygon"): if ( self.method == "structured" and self.mfgrid.grid_type == "structured" ): - rec = self._intersect_polygon_structured(shp) + rec = self._intersect_polygon_structured( + shp, + contains_centroid=contains_centroid, + min_area_fraction=min_area_fraction, + ) else: - rec = self._intersect_polygon_shapely(shp, sort_by_cellid) + rec = self._intersect_polygon_shapely( + shp, + sort_by_cellid=sort_by_cellid, + contains_centroid=contains_centroid, + min_area_fraction=min_area_fraction, + ) else: err = f"Shapetype {gu.shapetype} is not supported" raise TypeError(err) @@ -440,18 +480,27 @@ def sort_key(o): shapelist.sort(key=sort_key) return shapelist - def _intersect_point_shapely(self, shp, sort_by_cellid=True): + def _intersect_point_shapely( + self, shp, sort_by_cellid=True, return_all_intersections=False + ): """intersect grid with Point or MultiPoint. Parameters ---------- shp : Point or MultiPoint - shapely Point or MultiPoint to intersect with grid. Note, - it is generally faster to loop over a MultiPoint and intersect - per point than to intersect a MultiPoint directly. + + shapely Point or MultiPoint to intersect with grid. Note, it is + generally faster to loop over a MultiPoint and intersect per point + than to intersect a MultiPoint directly. sort_by_cellid : bool, optional - flag whether to sort cells by id, used to ensure node - with lowest id is returned, by default True + flag whether to sort cells by id, used to ensure node with lowest + id is returned, by default True + return_all_intersections : bool, optional + if True, return multiple intersection results for points on grid + cell boundaries (e.g. returns 2 intersection results if a point + lies on the boundary between two grid cells). The default is + False, which will return a single intersection result for boundary + cases. Returns ------- @@ -492,10 +541,12 @@ def _intersect_point_shapely(self, shp, sort_by_cellid=True): for c in collection: verts = c.__geo_interface__["coordinates"] # avoid returning multiple cells for points on boundaries - if verts in parsed_points: - continue + # if return_all_intersections is False + if not return_all_intersections: + if verts in parsed_points: + continue parsed_points.append(verts) - cell_shps.append(c) # collect only new points + cell_shps.append(c) # collect points cell_verts.append(verts) # if any new ix found if len(cell_shps) > 0: @@ -521,7 +572,11 @@ def _intersect_point_shapely(self, shp, sort_by_cellid=True): return rec def _intersect_linestring_shapely( - self, shp, keepzerolengths=False, sort_by_cellid=True + self, + shp, + keepzerolengths=False, + sort_by_cellid=True, + return_all_intersections=False, ): """intersect with LineString or MultiLineString. @@ -534,6 +589,12 @@ def _intersect_linestring_shapely( sort_by_cellid : bool, optional flag whether to sort cells by id, used to ensure node with lowest id is returned, by default True + return_all_intersections : bool, optional + if True, return multiple intersection results for linestrings on + grid cell boundaries (e.g. returns 2 intersection results if a + linestring lies on the boundary between two grid cells). The + default is False, which will return a single intersection result + for boundary cases. Returns ------- @@ -566,9 +627,11 @@ def _intersect_linestring_shapely( # loop over intersection result and store information for c in collection: verts = c.__geo_interface__["coordinates"] - # test if linestring was already processed (if on boundary) - if verts in vertices: - continue + # test if linestring was already processed (if on boundary), + # ignore if return_all_intersections is True + if not return_all_intersections: + if verts in vertices: + continue # if keep zero don't check length if not keepzerolengths: if c.length == 0.0: @@ -591,7 +654,13 @@ def _intersect_linestring_shapely( return rec - def _intersect_polygon_shapely(self, shp, sort_by_cellid=True): + def _intersect_polygon_shapely( + self, + shp, + sort_by_cellid=True, + contains_centroid=False, + min_area_fraction=None, + ): """intersect with Polygon or MultiPolygon. Parameters @@ -601,6 +670,13 @@ def _intersect_polygon_shapely(self, shp, sort_by_cellid=True): sort_by_cellid : bool, optional flag whether to sort cells by id, used to ensure node with lowest id is returned, by default True + contains_centroid : bool, optional + if True, only store intersection result if cell centroid is + contained within intersection shape + min_area_fraction : float, optional + float defining minimum intersection area threshold, if + intersection area is smaller than min_frac_area * cell_area, do + not store intersection result Returns ------- @@ -638,6 +714,17 @@ def _intersect_polygon_shapely(self, shp, sort_by_cellid=True): # don't store intersections with 0 area if c.area == 0.0: continue + # option: only store result if cell centroid is contained + # within intersection result + if contains_centroid: + if not c.intersects(r.centroid): + continue + # option: min_area_fraction, only store if intersected area + # is larger than fraction * cell_area + if min_area_fraction: + if c.area < (min_area_fraction * r.area): + continue + verts = c.__geo_interface__["coordinates"] isectshp.append(c) areas.append(c.area) @@ -688,13 +775,18 @@ def intersects(self, shp, shapetype=None): rec.cellids = cids return rec - def _intersect_point_structured(self, shp): + def _intersect_point_structured(self, shp, return_all_intersections=False): """intersection method for intersecting points with structured grids. Parameters ---------- shp : shapely.geometry.Point or MultiPoint point shape to intersect with grid + return_all_intersections : bool, optional + if True, return multiple intersection results for points on grid + cell boundaries (e.g. returns 2 intersection results if a point + lies on the boundary between two grid cells). The default is False, + which will return a single intersection result for boundary cases. Returns ------- @@ -739,31 +831,76 @@ def _intersect_point_structured(self, shp): ipos = ModflowGridIndices.find_position_in_array(Ye, ry) if jpos is not None and ipos is not None: + # use only first idx if return_all_intersections is False + if not return_all_intersections: + if isinstance(jpos, list): + jpos = jpos[0] + if isinstance(ipos, list): + ipos = ipos[0] # three dimensional point if p._ndim == 3: - # find k + # find k, if ipos or jpos on boundary, use first entry + if isinstance(jpos, list): + jj = jpos[0] + else: + jj = jpos + if isinstance(ipos, list): + ii = ipos[0] + else: + ii = ipos kpos = ModflowGridIndices.find_position_in_array( - self.mfgrid.botm[:, ipos, jpos], p.z + self.mfgrid.botm[:, ii, jj], p.z ) + # if z-position on boundary, use first k + if isinstance(kpos, list): + kpos = kpos[0] if kpos is not None: - nodelist.append((kpos, ipos, jpos)) - ixshapes.append(p) + # point on boundary, either jpos or ipos has len > 1 + if isinstance(ipos, list) or isinstance(jpos, list): + # convert to list if needed for loop + if not isinstance(ipos, list): + ipos = [ipos] + if not isinstance(jpos, list): + jpos = [jpos] + for ii in ipos: + for jj in jpos: + nodelist.append((kpos, ii, jj)) + ixshapes.append(p) + # point not on boundary + else: + nodelist.append((kpos, ipos, jpos)) + ixshapes.append(p) else: - nodelist.append((ipos, jpos)) - ixshapes.append(p) + # point on boundary, either jpos or ipos has len > 1 + if isinstance(ipos, list) or isinstance(jpos, list): + # convert to list if needed for loop + if not isinstance(ipos, list): + ipos = [ipos] + if not isinstance(jpos, list): + jpos = [jpos] + for ii in ipos: + for jj in jpos: + nodelist.append((ii, jj)) + ixshapes.append(p) + else: + nodelist.append((ipos, jpos)) + ixshapes.append(p) # remove duplicates - tempnodes = [] - tempshapes = [] - for node, ixs in zip(nodelist, ixshapes): - if node not in tempnodes: - tempnodes.append(node) - tempshapes.append(ixs) - else: - tempshapes[-1] = shapely_geo.MultiPoint([tempshapes[-1], ixs]) + if not return_all_intersections: + tempnodes = [] + tempshapes = [] + for node, ixs in zip(nodelist, ixshapes): + if node not in tempnodes: + tempnodes.append(node) + tempshapes.append(ixs) + else: + tempshapes[-1] = shapely_geo.MultiPoint( + [tempshapes[-1], ixs] + ) - ixshapes = tempshapes - nodelist = tempnodes + ixshapes = tempshapes + nodelist = tempnodes rec = np.recarray( len(nodelist), names=["cellids", "ixshapes"], formats=["O", "O"] @@ -773,7 +910,9 @@ def _intersect_point_structured(self, shp): rec.ixshapes = ixshapes return rec - def _intersect_linestring_structured(self, shp, keepzerolengths=False): + def _intersect_linestring_structured( + self, shp, keepzerolengths=False, return_all_intersections=False + ): """method for intersecting linestrings with structured grids. Parameters @@ -784,6 +923,12 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): if True keep intersection results with length=0, in other words, grid cells the linestring does not cross but does touch, by default False + return_all_intersections : bool, optional + if True, return multiple intersection results for linestrings on + grid cell boundaries (e.g. returns 2 intersection results if a + linestring lies on the boundary between two grid cells). The + default is False, which will return a single intersection result + for boundary cases. Returns ------- @@ -830,7 +975,9 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): nodelist, lengths, vertices = [], [], [] ixshapes = [] for ls in lineclip.geoms: - n, l, v, ixs = self._get_nodes_intersecting_linestring(ls) + n, l, v, ixs = self._get_nodes_intersecting_linestring( + ls, return_all_intersections=return_all_intersections + ) nodelist += n lengths += l # if necessary, transform coordinates back to real @@ -874,7 +1021,9 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): lengths, vertices, ixshapes, - ) = self._get_nodes_intersecting_linestring(lineclip) + ) = self._get_nodes_intersecting_linestring( + lineclip, return_all_intersections=return_all_intersections + ) # if necessary, transform coordinates back to real # world coordinates if ( @@ -913,8 +1062,12 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): tempverts = [] tempshapes = [] unique_nodes = list(set(nodelist)) + parsed_nodes = [] if len(unique_nodes) < len(nodelist): - for inode in unique_nodes: + for inode in nodelist: + # maintain order of nodes by keeping track of parsed nodes + if inode in parsed_nodes: + continue templengths.append( sum([l for l, i in zip(lengths, nodelist) if i == inode]) ) @@ -924,8 +1077,9 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): tempshapes.append( [ix for ix, i in zip(ixshapes, nodelist) if i == inode] ) + parsed_nodes.append(inode) - nodelist = unique_nodes + nodelist = parsed_nodes lengths = templengths vertices = tempverts ixshapes = tempshapes @@ -941,7 +1095,13 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): tempnodes.append(nodelist[i]) templengths.append(lengths[i]) tempverts.append(vertices[i]) - tempshapes.append(ixshapes[i]) + ishp = ixshapes[i] + if isinstance(ishp, list): + if len(ishp) > 1: + ishp = shapely_geo.MultiLineString(ishp) + else: + ishp = ishp[0] + tempshapes.append(ishp) nodelist = tempnodes lengths = templengths vertices = tempverts @@ -960,7 +1120,9 @@ def _intersect_linestring_structured(self, shp, keepzerolengths=False): return rec - def _get_nodes_intersecting_linestring(self, linestring): + def _get_nodes_intersecting_linestring( + self, linestring, return_all_intersections=False + ): """helper function, intersect the linestring with the a structured grid and return a list of node indices and the length of the line in that node. @@ -1047,7 +1209,13 @@ def _get_nodes_intersecting_linestring(self, linestring): for inode, ilength, ivert, ix in zip(node, length, verts, ixshape): if inode is not None: - if ivert not in vertices: + if not return_all_intersections: + if ivert not in vertices: + nodelist.append(inode) + lengths.append(ilength) + vertices.append(ivert) + ixshapes.append(ix) + else: nodelist.append(inode) lengths.append(ilength) vertices.append(ivert) @@ -1200,6 +1368,36 @@ def _check_adjacent_cells_intersecting_line( verts.append([(ixy[0], ixy[1]) for ixy in zip(x, y)]) node.append((ii, jj)) + # special case for linestrings intersecting in vertex and continuing + # towards bottom right, check diagonally to front-right, if no other + # neighbours found + if np.sum(length) == 0: + if (i < self.mfgrid.nrow - 1) and (j < self.mfgrid.ncol - 1): + ii = i + 1 + jj = j + 1 + if (ii, jj) not in nodelist: + xmin = Xe[jj] + xmax = Xe[jj + 1] + ymax = Ye[ii] + ymin = Ye[ii + 1] + pl = shapely_geo.box(xmin, ymin, xmax, ymax) + if linestring.intersects(pl): + intersect = linestring.intersection(pl) + ixshape.append(intersect) + length.append(intersect.length) + if hasattr(intersect, "geoms"): + x, y = [], [] + for igeom in intersect.geoms: + x.append(igeom.xy[0]) + y.append(igeom.xy[1]) + x = np.concatenate(x) + y = np.concatenate(y) + else: + x = intersect.xy[0] + y = intersect.xy[1] + verts.append([(ixy[0], ixy[1]) for ixy in zip(x, y)]) + node.append((ii, jj)) + return node, length, verts, ixshape def _intersect_rectangle_structured(self, rectangle): @@ -1285,7 +1483,9 @@ def _intersect_rectangle_structured(self, rectangle): return nodelist - def _intersect_polygon_structured(self, shp): + def _intersect_polygon_structured( + self, shp, contains_centroid=False, min_area_fraction=None + ): """intersect polygon with a structured grid. Uses bounding box of the Polygon to limit search space. @@ -1299,6 +1499,13 @@ def _intersect_polygon_structured(self, shp): ---------- shp : shapely.geometry.Polygon polygon to intersect with the grid + contains_centroid : bool, optional + if True, only store intersection result if cell centroid is + contained within intersection shape + min_area_fraction : float, optional + float defining minimum intersection area threshold, if + intersection area is smaller than min_frac_area * cell_area, do + not store intersection result Returns ------- @@ -1349,46 +1556,66 @@ def _intersect_polygon_structured(self, shp): node_polygon = shapely_geo.Polygon(cell_coords) if shp.intersects(node_polygon): intersect = shp.intersection(node_polygon) - if intersect.area > 0.0: - nodelist.append((i, j)) - areas.append(intersect.area) - - # if necessary, transform coordinates back to real - # world coordinates - if ( - self.mfgrid.angrot != 0.0 - or self.mfgrid.xoffset != 0.0 - or self.mfgrid.yoffset != 0.0 + + collection = parse_shapely_ix_result( + [], intersect, shptyps=["Polygon", "MultiPolygon"] + ) + if len(collection) == 0: + continue + if len(collection) > 1: + intersect = shapely_geo.MultiPolgon(collection) + else: + intersect = collection[0] + + # only store results if area > 0.0 + if intersect.area == 0.0: + continue + # option: only store result if cell centroid is contained + # within intersection result + if contains_centroid: + if not intersect.intersects(node_polygon.centroid): + continue + # option: min_area_fraction, only store if intersected area + # is larger than fraction * cell_area + if min_area_fraction: + if intersect.area < ( + min_area_fraction * node_polygon.area ): - v_realworld = [] - if intersect.geom_type.startswith("Multi"): - for ipoly in intersect: - v_realworld += ( - self._transform_geo_interface_polygon( - ipoly - ) - ) - else: + continue + + nodelist.append((i, j)) + areas.append(intersect.area) + + # if necessary, transform coordinates back to real + # world coordinates + if ( + self.mfgrid.angrot != 0.0 + or self.mfgrid.xoffset != 0.0 + or self.mfgrid.yoffset != 0.0 + ): + v_realworld = [] + if intersect.geom_type.startswith("Multi"): + for ipoly in intersect: v_realworld += ( - self._transform_geo_interface_polygon( - intersect - ) + self._transform_geo_interface_polygon(ipoly) ) - intersect_realworld = affinity_loc.rotate( - intersect, self.mfgrid.angrot, origin=(0.0, 0.0) - ) - intersect_realworld = affinity_loc.translate( - intersect_realworld, - self.mfgrid.xoffset, - self.mfgrid.yoffset, - ) else: - v_realworld = intersect.__geo_interface__[ - "coordinates" - ] - intersect_realworld = intersect - ixshapes.append(intersect_realworld) - vertices.append(v_realworld) + v_realworld += self._transform_geo_interface_polygon( + intersect + ) + intersect_realworld = affinity_loc.rotate( + intersect, self.mfgrid.angrot, origin=(0.0, 0.0) + ) + intersect_realworld = affinity_loc.translate( + intersect_realworld, + self.mfgrid.xoffset, + self.mfgrid.yoffset, + ) + else: + v_realworld = intersect.__geo_interface__["coordinates"] + intersect_realworld = intersect + ixshapes.append(intersect_realworld) + vertices.append(v_realworld) rec = np.recarray( len(nodelist), @@ -1493,6 +1720,7 @@ def plot_polygon(rec, ax=None, **kwargs): """ import matplotlib.pyplot as plt + from matplotlib.collections import PatchCollection import_optional_dependency("descartes") from descartes import PolygonPatch @@ -1500,13 +1728,16 @@ def plot_polygon(rec, ax=None, **kwargs): if ax is None: _, ax = plt.subplots() + patches = [] for i, ishp in enumerate(rec.ixshapes): if "facecolor" in kwargs: fc = kwargs.pop("facecolor") else: fc = f"C{i % 10}" ppi = PolygonPatch(ishp, facecolor=fc, **kwargs) - ax.add_patch(ppi) + patches.append(ppi) + pc = PatchCollection(patches, match_original=True) + ax.add_collection(pc) return ax @@ -1621,7 +1852,7 @@ def find_position_in_array(arr, x): x : float The x position to find in arr. """ - jpos = None + jpos = [] if x == arr[-1]: return len(arr) - 2 @@ -1639,10 +1870,13 @@ def find_position_in_array(arr, x): frac = (x - xl) / (xr - xl) if 0.0 <= frac <= 1.0: # if min(xl, xr) <= x < max(xl, xr): - jpos = j - return jpos - - return jpos + jpos.append(j) + if len(jpos) == 0: + return None + elif len(jpos) == 1: + return jpos[0] + else: + return jpos @staticmethod def kij_from_nodenumber(nodenumber, nlay, nrow, ncol):