From 1114c93d1c52de862e00a594d41f5d724d91f358 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dav=C3=ADd=20Brakenhoff?= Date: Fri, 23 Dec 2022 08:51:05 +0100 Subject: [PATCH] perf(Gridintersect): optimize intersection methods for shapely 2.0 (#1666) --- CITATION.cff | 3 +- autotest/test_gridintersect.py | 154 +++----- .../flopy3_grid_intersection_demo.ipynb | 317 ++++++++-------- flopy/utils/gridintersect.py | 351 ++++++++++++++++-- 4 files changed, 526 insertions(+), 299 deletions(-) diff --git a/CITATION.cff b/CITATION.cff index 5c3ca75c6..3e4557d11 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -51,7 +51,8 @@ authors: given-names: Jon Jeffrey orcid: https://orcid.org/0000-0001-5909-0010 - family-names: Brakenhoff - given-names: Davíd + given-names: Davíd A. + orcid: https://orcid.org/0000-0002-2993-2202 - family-names: Bonelli given-names: Wesley P. orcid: https://orcid.org/0000-0002-2665-5078 diff --git a/autotest/test_gridintersect.py b/autotest/test_gridintersect.py index 43adebd80..98c983498 100644 --- a/autotest/test_gridintersect.py +++ b/autotest/test_gridintersect.py @@ -120,42 +120,6 @@ def get_rect_vertex_grid(angrot=0.0, xyoffset=0.0): return tgr -def plot_structured_grid(sgr): - _, ax = plt.subplots(1, 1, figsize=(8, 8)) - sgr.plot(ax=ax) - return ax - - -def plot_vertex_grid(tgr): - _, ax = plt.subplots(1, 1, figsize=(8, 8)) - pmv = fplot.PlotMapView(modelgrid=tgr) - pmv.plot_grid(ax=ax) - return ax - - -def plot_ix_polygon_result(rec, ax): - from descartes import PolygonPatch - - for i, ishp in enumerate(rec.ixshapes): - ppi = PolygonPatch(ishp, facecolor=f"C{i % 10}") - ax.add_patch(ppi) - - -def plot_ix_linestring_result(rec, ax): - for i, ishp in enumerate(rec.ixshapes): - if ishp.type == "MultiLineString": - for part in ishp: - ax.plot(part.xy[0], part.xy[1], ls="-", c=f"C{i % 10}") - else: - ax.plot(ishp.xy[0], ishp.xy[1], ls="-", c=f"C{i % 10}") - - -def plot_ix_point_result(rec, ax): - x = [ip.x for ip in rec.ixshapes] - y = [ip.y for ip in rec.ixshapes] - ax.scatter(x, y) - - # %% test point structured @@ -597,6 +561,26 @@ def test_rect_grid_linestrings_on_boundaries_return_all_ix_shapely(rtree): assert len(r) == n_intersections[i] +@requires_pkg("shapely") +@rtree_toggle +def test_rect_grid_linestring_cell_boundary_shapely(rtree): + gr = get_rect_grid() + ix = GridIntersect(gr, method="vertex", rtree=rtree) + ls = LineString(ix._rect_grid_to_geoms_cellids()[0][0].exterior.coords) + r = ix.intersect(ls, return_all_intersections=False) + assert len(r) == 1 + + +@requires_pkg("shapely") +@rtree_toggle +def test_rect_grid_linestring_cell_boundary_return_all_ix_shapely(rtree): + gr = get_rect_grid() + ix = GridIntersect(gr, method="vertex", rtree=rtree) + ls = LineString(ix._rect_grid_to_geoms_cellids()[0][0].exterior.coords) + r = ix.intersect(ls, return_all_intersections=True) + assert len(r) == 3 + + @requires_pkg("shapely") @rtree_toggle def test_tri_grid_linestring_outside(rtree): @@ -681,7 +665,26 @@ def test_tri_grid_linestrings_on_boundaries_return_all_ix(rtree): 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 + + +@requires_pkg("shapely") +@rtree_toggle +def test_tri_grid_linestring_cell_boundary_shapely(rtree): + tgr = get_tri_grid() + ix = GridIntersect(tgr, method="vertex", rtree=rtree) + ls = LineString(ix._vtx_grid_to_geoms_cellids()[0][0].exterior.coords) + r = ix.intersect(ls, return_all_intersections=False) + assert len(r) == 1 + + +@requires_pkg("shapely") +@rtree_toggle +def test_tri_grid_linestring_cell_boundary_return_all_ix_shapely(rtree): + tgr = get_tri_grid() + ix = GridIntersect(tgr, method="vertex", rtree=rtree) + ls = LineString(ix._vtx_grid_to_geoms_cellids()[0][0].exterior.coords) + r = ix.intersect(ls, return_all_intersections=True) + assert len(r) == 3 # %% test polygon structured @@ -1064,7 +1067,7 @@ def test_point_offset_rot_structured_grid(): p = Point(10.0, 10 + np.sqrt(200.0)) ix = GridIntersect(sgr, method="structured") result = ix.intersect(p) - # assert len(result) == 1. + assert len(result) == 1 @requires_pkg("shapely") @@ -1073,7 +1076,8 @@ def test_linestring_offset_rot_structured_grid(): ls = LineString([(5, 10.0 + np.sqrt(200.0)), (15, 10.0 + np.sqrt(200.0))]) ix = GridIntersect(sgr, method="structured") result = ix.intersect(ls) - # assert len(result) == 2. + # NOTE: in shapely 2.0, this returns a Linestring with length 10^-15 in cell (0, 1) + assert len(result) == 2 or len(result) == 3 @requires_pkg("shapely") @@ -1089,7 +1093,7 @@ def test_polygon_offset_rot_structured_grid(): ) ix = GridIntersect(sgr, method="structured") result = ix.intersect(p) - # assert len(result) == 3. + assert len(result) == 3 @requires_pkg("shapely") @@ -1099,7 +1103,7 @@ def test_point_offset_rot_structured_grid_shapely(rtree): p = Point(10.0, 10 + np.sqrt(200.0)) ix = GridIntersect(sgr, method="vertex", rtree=rtree) result = ix.intersect(p) - # assert len(result) == 1. + assert len(result) == 1 @requires_pkg("shapely") @@ -1109,7 +1113,7 @@ def test_linestring_offset_rot_structured_grid_shapely(rtree): ls = LineString([(5, 10.0 + np.sqrt(200.0)), (15, 10.0 + np.sqrt(200.0))]) ix = GridIntersect(sgr, method="vertex", rtree=rtree) result = ix.intersect(ls) - # assert len(result) == 2. + assert len(result) == 2 @requires_pkg("shapely") @@ -1126,66 +1130,7 @@ def test_polygon_offset_rot_structured_grid_shapely(rtree): ) ix = GridIntersect(sgr, method="vertex", rtree=rtree) result = ix.intersect(p) - # assert len(result) == 3. - - -# %% test non strtree shapely intersect - - -@requires_pkg("shapely") -def test_all_intersections_shapely_no_strtree(): - """avoid adding separate tests for rtree=False""" - # Points - # regular grid - test_rect_grid_point_on_inner_boundary_shapely(rtree=False) - test_rect_grid_point_on_outer_boundary_shapely(rtree=False) - test_rect_grid_point_outside_shapely(rtree=False) - test_rect_grid_multipoint_in_one_cell_shapely(rtree=False) - test_rect_grid_multipoint_in_multiple_cells_shapely(rtree=False) - # vertex grid - test_tri_grid_point_on_inner_boundary(rtree=False) - test_tri_grid_point_on_outer_boundary(rtree=False) - test_tri_grid_point_outside(rtree=False) - test_tri_grid_multipoint_in_multiple_cells(rtree=False) - test_tri_grid_multipoint_in_one_cell(rtree=False) - - # LineStrings - # regular grid - test_rect_grid_linestring_on_inner_boundary_shapely(rtree=False) - test_rect_grid_linestring_on_outer_boundary_shapely(rtree=False) - test_rect_grid_linestring_outside_shapely(rtree=False) - test_rect_grid_linestring_in_2cells_shapely(rtree=False) - test_rect_grid_linestring_in_and_out_of_cell_shapely(rtree=False) - test_rect_grid_multilinestring_in_one_cell_shapely(rtree=False) - # vertex grid - test_tri_grid_linestring_on_inner_boundary(rtree=False) - test_tri_grid_linestring_on_outer_boundary(rtree=False) - test_tri_grid_linestring_outside(rtree=False) - test_tri_grid_linestring_in_2cells(rtree=False) - test_tri_grid_multilinestring_in_one_cell(rtree=False) - - # Polygons - # regular grid - test_rect_grid_polygon_on_inner_boundary_shapely(rtree=False) - test_rect_grid_polygon_on_outer_boundary_shapely(rtree=False) - test_rect_grid_polygon_outside_shapely(rtree=False) - test_rect_grid_polygon_in_2cells_shapely(rtree=False) - test_rect_grid_polygon_with_hole_shapely(rtree=False) - test_rect_grid_multipolygon_in_one_cell_shapely(rtree=False) - test_rect_grid_multipolygon_in_multiple_cells_shapely(rtree=False) - # vertex grid - test_tri_grid_polygon_on_inner_boundary(rtree=False) - test_tri_grid_polygon_on_outer_boundary(rtree=False) - test_tri_grid_polygon_outside(rtree=False) - test_tri_grid_polygon_in_2cells(rtree=False) - test_tri_grid_polygon_with_hole(rtree=False) - test_tri_grid_multipolygon_in_multiple_cells(rtree=False) - test_tri_grid_multipolygon_in_one_cell(rtree=False) - - # offset and rotated grids - test_point_offset_rot_structured_grid_shapely(rtree=False) - test_linestring_offset_rot_structured_grid_shapely(rtree=False) - test_polygon_offset_rot_structured_grid_shapely(rtree=False) + assert len(result) == 3 # %% test rasters @@ -1298,8 +1243,3 @@ def test_raster_sampling_methods(example_data_path): raise AssertionError( f"{method} resampling returning incorrect values" ) - - -if __name__ == "__main__": - - test_all_intersections_shapely_no_strtree() diff --git a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb index 304fe9d88..248848982 100644 --- a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb +++ b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb @@ -1,22 +1,18 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Intersecting model grids with shapes\n", "\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. \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", - "- the second method does not construct the STR-tree, and loops through all gridcells to determine the intersection between the grid and the shape. This method also works for structured and vertex grids.\n", - "- the third method only works for structured grids and uses information from the structured grid to limit the search space for intersections.\n", - "\n", - "This notebook showcases the functionality of the GridIntersect class. \n", + "_Note: This feature requires the shapely package (which is an optional FloPy dependency)._\n", "\n", + "This notebook shows the grid intersection functionality in flopy. The\n", + "intersection methods are available through the `GridIntersect` object. A flopy\n", + "modelgrid is passed to instantiate the object. Then the modelgrid can be\n", + "intersected with Points, LineStrings and Polygons and their Multi variants.\n", "\n", "### Table of Contents\n", "- [GridIntersect Class](#gridclass)\n", @@ -31,10 +27,11 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Import some stuff" + "Import packages" ] }, { @@ -53,11 +50,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "3.7.15 (default, Oct 18 2022, 09:36:49) \n", - "[GCC 11.2.0]\n", - "numpy version: 1.21.6\n", - "matplotlib version: 3.5.3\n", - "flopy version: 3.3.6\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.6.1\n", + "flopy version: 3.3.6\n", + "shapely version: 2.0.0\n" ] } ], @@ -68,52 +66,71 @@ "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "\n", - "# run installed version of flopy or add local path\n", - "try:\n", - " import flopy\n", - " import flopy.discretization as fgrid\n", - " import flopy.plot as fplot\n", - " from flopy.utils.gridintersect import GridIntersect\n", - "except:\n", - " fpth = os.path.abspath(os.path.join(\"..\", \"..\"))\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 (LineString, MultiLineString, MultiPoint,\n", - " MultiPolygon, Point, Polygon)\n", + "from shapely.geometry import (\n", + " LineString,\n", + " MultiLineString,\n", + " MultiPoint,\n", + " MultiPolygon,\n", + " Point,\n", + " Polygon,\n", + ")\n", + "\n", + "import flopy\n", + "import flopy.discretization as fgrid\n", + "import flopy.plot as fplot\n", + "from flopy.utils import GridIntersect\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__))\n" + "print(\"flopy version: {}\".format(flopy.__version__))\n", + "print(\"shapely version: {}\".format(shapely.__version__))" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## [GridIntersect Class](#top)\n", "\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", + "The GridIntersect class is constructed by passing a flopy modelgrid object to\n", + "the constructor. There are options users can select to change how the\n", + "intersection is calculated.\n", "\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", + "- `method`: derived from model grid type or defined by the user: can be either `\"vertex\"` or\n", + "`\"structured\"`. If `\"structured\"` is passed, the intersections are performed\n", + "using structured methods. These methods use information about the regular grid\n", + "to limit the search space for intersection calculations. Note that `method=\"vertex\"` \n", + "also works for structured grids.\n", + "- `rtree`: either `True` (default) or `False`, only read when\n", + "`method=\"vertex\"`. When True, an STR-tree is built, which allows for fast\n", + "spatial queries. Building the STR-tree does take some time however. Setting the\n", + "option to False avoids building the STR-tree but requires the intersection\n", + "calculation to loop through all grid cells.\n", "\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", + "In general the \"vertex\" option is robust and fast and is therefore recommended\n", + "in most situations. In some rare cases building the STR-tree might not be worth\n", + "the time, in which case it can be avoided by passing `rtree=False`. If you are\n", + "working with a structured grid, then the `method=\"structured\"` can speed up\n", + "intersection operations in some situations (e.g. for (multi)points) with the added\n", + "advantage of not having to build an STR-tree.\n", "\n", "The important methods in the GridIntersect object are:\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", + "\n", + "- `intersects()`: returns cellids for gridcells that intersect a shape (accepts\n", + "shapely geometry objects, flopy geometry object, shapefile.Shape objects, and\n", + "geojson objects)\n", + "- `intersect()`: for intersecting the modelgrid with point, linestrings, and\n", + "polygon geometries (accepts shapely geometry objects, flopy geometry object,\n", + "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", "\n", - "In the following sections examples of intersections are shown for structured and vertex grids for different types of shapes (Polygon, LineString and Point)." + "In the following sections examples of intersections are shown for structured\n", + "and vertex grids for different types of shapes (Polygon, LineString and Point)." ] }, { @@ -175,27 +192,19 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], "source": [ - "sgr.plot()" + "sgr.plot();" ] }, { @@ -234,10 +243,11 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "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." + "Create the GridIntersect class for our modelgrid. The `method` kwarg is passed to force GridIntersect to use the `\"vertex\"` intersection methods." ] }, { @@ -253,7 +263,7 @@ }, "outputs": [], "source": [ - "ix = GridIntersect(sgr, method=\"vertex\", rtree=True)" + "ix = GridIntersect(sgr, method=\"vertex\")" ] }, { @@ -276,8 +286,7 @@ }, "outputs": [], "source": [ - "result = ix.intersect(p)\n", - "# %timeit ix.intersect(p)" + "result = ix.intersect(p)" ] }, { @@ -309,12 +318,12 @@ { "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', ', 66.66666667),\n", + " ((2, 4), , 33.33333333),\n", + " ((3, 2), , 25. ),\n", + " ((3, 3), , 100. ),\n", + " ((3, 4), , 100. )],\n", + " dtype=[('cellids', 'O'), ('ixshapes', 'O'), ('areas', '" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -531,12 +546,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -586,12 +603,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -673,13 +692,12 @@ "source": [ "result4 = ixs.intersect(p)\n", "\n", - "# The methods are optimized for structured grids, but for certain\n", - "# types of polygons there is no benefit (as can be seen in this example).\n", - "# %timeit ixs.intersect(p)\n", + "check = (result4[[\"cellids\", \"ixshapes\", \"areas\"]] == result).all()[()]\n", "\n", - "print(\"Intersection result with method='structured' and \"\n", - " f\"method='vertex' are equal: {(result4 == result).all()[()]}\"\n", - " )\n" + "print(\n", + " \"Intersection result with method='structured' and \"\n", + " f\"method='vertex' are equal: {check}\"\n", + ")" ] }, { @@ -722,8 +740,7 @@ }, "outputs": [], "source": [ - "result = ix.intersect(mls)\n", - "# %timeit ix.intersect(mls)" + "result = ix.intersect(mls)" ] }, { @@ -747,12 +764,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -818,12 +837,12 @@ "source": [ "result2 = ixs.intersect(mls)\n", "\n", - "# %timeit 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(\"Intersection result with method='structured' and \"\n", - " f\"method='vertex' are equal: {check}\")\n" + "print(\n", + " \"Intersection result with method='structured' and \"\n", + " f\"method='vertex' are equal: {check}\"\n", + ")" ] }, { @@ -879,8 +898,7 @@ "outputs": [], "source": [ "result = ix.intersect(mp)\n", - "# %timeit ix.intersect(mp)\n", - "result_all =ix.intersect(mp, return_all_intersections=True)" + "result_all = ix.intersect(mp, return_all_intersections=True)" ] }, { @@ -897,12 +915,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -916,7 +936,8 @@ " (h2,) = ax.plot(\n", " sgr.xcellcenters[0, icol],\n", " sgr.ycellcenters[irow, 0],\n", - " \"kx\", ms=15,\n", + " \"kx\",\n", + " ms=15,\n", " label=\"centroids of intersected cells\",\n", " )\n", "\n", @@ -924,18 +945,20 @@ " (h3,) = ax.plot(\n", " sgr.xcellcenters[0, icol],\n", " sgr.ycellcenters[irow, 0],\n", - " \"C3+\", ms=15,\n", + " \"C3+\",\n", + " ms=15,\n", " label=\"centroids with `return_all_intersections=True`\",\n", " )\n", - " \n", + "\n", "ax.legend([h2, h3], [i.get_label() for i in [h2, h3]], loc=\"best\");" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Same as before, the intersect for structured grids can also be performed with a different method optimized for structured grids" + "Same as before, the intersect for structured grids can also be performed with a different method written specifically for structured grids." ] }, { @@ -976,12 +999,13 @@ ], "source": [ "result2 = ixs.intersect(mp, return_all_intersections=False)\n", - "# %timeit ixs.intersect(mp)\n", "\n", "# ordering is different so compare sets to check equality\n", "check = len(set(result2.cellids) - set(result.cellids)) == 0\n", - "print(\"Intersection result with method='structured' and \"\n", - " f\"method='vertex' are equal: {check}\")\n" + "print(\n", + " \"Intersection result with method='structured' and \"\n", + " f\"method='vertex' are equal: {check}\"\n", + ")" ] }, { @@ -1042,29 +1066,21 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq0AAAKZCAYAAACStxIQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzCElEQVR4nO3dfYxddZ348c+UtjO1pS2t6Uy7Uu0aTXF5sKVYR4w/IyOoQEBYs5iqhCV21VZpuytLd6VGRCvdFQjYUDWKGEGURFiKgU23YAlrKVBEUbCwK2u74kxXa6dQ6IPM+f2Bc2XaaTt35px7z8PrlZxk5pxzz/1Mv2F45+TOvS1JkiQBAAA5NqrZAwAAwJGIVgAAck+0AgCQe6IVAIDcE60AAOSeaAUAIPdEKwAAuSdaAQDIPdEKAEDuiVYAAHKv7mi9//774+yzz44ZM2ZES0tL3HHHHQOOJ0kSK1asiOnTp8e4ceOiq6srnn766QHn7NixIxYsWBATJ06MyZMnx8UXXxzPP//8iH4QAADKq+5o3b17d5x00kmxevXqQY+vWrUqrrvuulizZk1s2rQpxo8fH2eccUbs2bOnds6CBQviF7/4Raxbty7uuuuuuP/++2PhwoXD/ykAACi1liRJkmE/uKUlbr/99jj33HMj4uW7rDNmzIi///u/j3/4h3+IiIje3t5ob2+Pb33rW3HBBRfEk08+GW9605vi4Ycfjnnz5kVExD333BPve9/74n//939jxowZI/+pAAAoldFpXuyZZ56J7u7u6Orqqu2bNGlSzJ8/PzZu3BgXXHBBbNy4MSZPnlwL1oiIrq6uGDVqVGzatCne//73H3TdvXv3xt69e2vf9/X1xY4dO2Lq1KnR0tKS5o8AAMAwJEkSzz33XMyYMSNGjUr/z6ZSjdbu7u6IiGhvbx+wv729vXasu7s7pk2bNnCI0aNjypQptXMOtHLlyvjc5z6X5qgAAGRg27Zt8ZrXvCb166YarVlZvnx5LFu2rPZ9b29vzJw5M5YuXRoTJ06Miy66KMaPH9/ECQHqt3v37lizZk1ERHzsYx/zewwonL6+vrjppptix44dsXfv3rjmmmvi6KOPzuS5Uo3Wjo6OiIjo6emJ6dOn1/b39PTEm9/85to527dvH/C4P/7xj7Fjx47a4w/U2toara2tg+5vaWmJ7373u7F48eKYMGFCSj8JQPba2tqira0tIiKmTp3qdxhQKH19fXHDDTfECy+8UPtdFhGZvXQz1RcczJo1Kzo6OmL9+vW1fbt27YpNmzZFZ2dnRER0dnbGzp07Y/PmzbVz7r333ujr64v58+fX9Xzvfve7I+Ll17x+5Stf8bZZAAAN0B+sv/vd7yIiYs6cOZk/Z93R+vzzz8djjz0Wjz32WES8/MdXjz32WGzdujVaWlpiyZIlceWVV8add94Zjz/+eHzkIx+JGTNm1N5h4Ljjjov3vOc98dGPfjQeeuih+M///M9YvHhxXHDBBXW/c8CJJ54YZ599dkQIVwCARjgwWE8++eR4z3vek/nz1h2tjzzySMyZM6dW1MuWLYs5c+bEihUrIiLi0ksvjU9+8pOxcOHCOOWUU+L555+Pe+65Z8Bt45tvvjlmz54dp512Wrzvfe+Lt7/97fG1r31tWD/A3LlzhSsAQAMMFqxnnXVWQ5677te0vvOd74zDvbVrS0tLXHHFFXHFFVcc8pwpU6bELbfcUu9TH9LcuXMjImLt2rW1cPUaVwCA9DQzWCNSfk1rM7njCgCQjWYHa0SJojVCuAIApC0PwRpRsmiNEK4AAGnJS7BGlDBaI4QrAMBI5SlYI0oarRHCFQBguPIWrBEljtYI4QoAUK88BmtEyaM1QrgCAAxVXoM1ogLRGiFcAQCOJM/BGlGRaI0QrgAAh5L3YI2oULRGCFcAgAMVIVgjKhatEcIVAKBfUYI1ooLRGiFcAQCKFKwRFY3WCOEKAFRX0YI1osLRGiFcAYDqKWKwRlQ8WiOEKwBQHUUN1gjRGhHCFQAovyIHa4RorRGuAEBZFT1YI0TrAMIVACibMgRrhGg9iHAFAMqiLMEaIVoHJVwBgKIrU7BGiNZDEq4AQFGVLVgjROthCVcAoGjKGKwRovWIhCsAUBRlDdYI0TokwhUAyLsyB2uEaB0y4QoA5FXZgzVCtNZFuAIAeVOFYI0QrXUTrgBAXlQlWCNE67AIVwCg2aoUrBGiddiEKwDQLFUL1gjROiLCFQBotCoGa4RoHTHhCgA0SlWDNUK0pkK4AgBZq3KwRojW1AhXACArVQ/WCNGaKuEKAKRNsL5MtKZMuAIAaRGsfyZaMyBcAYCREqwDidaMCFcAYLgE68FEa4aEKwBQL8E6ONGaMeEKAAyVYD000doAwhUAOBLBeniitUGEKwBwKIL1yERrAwlXAOBAgnVoRGuDCVcAoJ9gHTrR2gTCFQAQrPURrU0iXAGgugRr/URrEwlXAKgewTo8orXJhCsAVIdgHT7RmgPCFQDKT7COjGjNCeEKAOUlWEdOtOaIcAWA8hGs6RCtOSNcAaA8BGt6RGsOCVcAKD7Bmi7RmlPCFQCKS7CmT7TmmHAFgOIRrNkQrTknXAGgOARrdkRrAQhXAMg/wZot0VoQwhUA8kuwZk+0FohwBYD8EayNIVoLRrgCQH4I1sYRrQUkXAGg+QRrY4nWghKuANA8grXxRGuBCVcAaDzB2hyiteCEKwA0jmBtHtFaAsIVALInWJtLtJaEcAWA7AjW5hOtJSJcASB9gjUfRGvJCFcASI9gzQ/RWkLCFQBGTrDmi2gtKeEKAMMnWPNHtJaYcAWA+gnWfBKtJSdcAWDoBGt+idYKEK4AcGSCNd9Ea0UIVwA4NMGaf6K1QoQrABxMsBaDaK0Y4QoAfyZYi0O0VpBwBQDBWjSitaKEKwBVJliLR7RWmHAFoIoEazGJ1ooTrgBUiWAtLtGKcAWgEgRrsYlWIkK4AlBugrX4RCs1whWAMhKs5SBaGUC4AlAmgrU8RCsHEa4AlIFgLRfRyqCEKwBFJljLR7RySMIVgCISrOUkWjks4QpAkQjW8hKtHJFwBaAIBGu5iVaGRLgCkGeCtfxEK0MmXAHII8FaDaKVughXAPJEsFaHaKVuwhWAPBCs1SJaGRbhCkAzCdbqEa0Mm3AFoBkEazWJVkZEuALQSIK1ukQrIyZcAWgEwVptopVUCFcAsiRYEa2kRrgCkAXBSoRoJWXCFYA0CVb6iVZSJ1wBSINg5ZVEK5kQrgCMhGDlQKKVzAhXAIZDsDIY0UqmhCsA9RCsHIpoJXPCFYChEKwcjmilIYQrAIcjWDkS0UrDCFcABiNYGQrRSkMJVwBeSbAyVKKVhhOuAEQIVuojWmkK4QpQbYKVeolWmka4AlSTYGU4RCtNJVwBqkWwMlyilaYTrgDVIFgZidSj9aWXXorLL788Zs2aFePGjYvXv/718fnPfz6SJKmdkyRJrFixIqZPnx7jxo2Lrq6uePrpp9MehQIRrgDlJlgZqdSj9aqrroobbrghvvKVr8STTz4ZV111VaxatSquv/762jmrVq2K6667LtasWRObNm2K8ePHxxlnnBF79uxJexwKRLgClJNgJQ2pR+uPf/zjOOecc+LMM8+M173udfHXf/3Xcfrpp8dDDz0UES/fZb322mvjM5/5TJxzzjlx4oknxre//e149tln44477kh7HApGuAKUi2AlLalH69ve9rZYv359PPXUUxER8dOf/jQeeOCBeO973xsREc8880x0d3dHV1dX7TGTJk2K+fPnx8aNGwe95t69e2PXrl0DNspLuAKUg2AlTalH62WXXRYXXHBBzJ49O8aMGRNz5syJJUuWxIIFCyIioru7OyIi2tvbBzyuvb29duxAK1eujEmTJtW2Y489Nu2xyRnhClBsgpW0pR6t3//+9+Pmm2+OW265JR599NG46aab4l//9V/jpptuGvY1ly9fHr29vbVt27ZtKU5MXglXgGISrGQh9Wj99Kc/XbvbesIJJ8SHP/zhWLp0aaxcuTIiIjo6OiIioqenZ8Djenp6ascO1NraGhMnThywUQ3CFaBYBCtZST1aX3jhhRg1auBljzrqqOjr64uIiFmzZkVHR0esX7++dnzXrl2xadOm6OzsTHscSkC4AhSDYCVLqUfr2WefHV/4whfihz/8YfzP//xP3H777XH11VfH+9///oiIaGlpiSVLlsSVV14Zd955Zzz++OPxkY98JGbMmBHnnntu2uNQEsIVIN8EK1kbnfYFr7/++rj88svjE5/4RGzfvj1mzJgRf/d3fxcrVqyonXPppZfG7t27Y+HChbFz5854+9vfHvfcc0+0tbWlPQ4lMnfu3IiIWLt2bS1cFy9eHBMmTGjyZADVJlhphNTvtB599NFx7bXXxq9//et48cUX47//+7/jyiuvjLFjx9bOaWlpiSuuuCK6u7tjz5498R//8R/xxje+Me1RKCF3XAHyRbDSKKlHK2RNuALkg2ClkUQrhSRcAZpLsNJoopXCEq4AzSFYaQbRSqEJV4DGEqw0i2il8IQrQGMIVppJtFIKwhUgW4KVZhOtlIZwBciGYCUPRCulIlwB0iVYyQvRSukIV4B0CFbyRLRSSsIVYGQEK3kjWikt4QowPIKVPBKtlJpwBaiPYCWvRCulJ1wBhkawkmeilUoQrgCHJ1jJO9FKZQhXgMEJVopAtFIpwhVgIMFKUYhWKke4ArxMsFIkopVKEq5A1QlWika0UlnCFagqwUoRiVYqTbgCVSNYKSrRSuUJV6AqBCtFJlohhCtQfoKVohOt8CfCFSgrwUoZiFZ4BeEKlI1gpSxEKxxAuAJlIVgpE9EKgxCuQNEJVspGtMIhCFegqAQrZSRa4TCEK1A0gpWyEq1wBMIVKArBSpmJVhgC4QrknWCl7EQrDJFwBfJKsFIFohXqIFyBvBGsVIVohToJVyAvBCtVIlphGIQr0GyClaoRrTBMwhVoFsFKFYlWGAHhCjSaYKWqRCuMkHAFGkWwUmWiFVIgXIGsCVaqTrRCSoQrkBXBCqIVUiVcgbQJVniZaIWUCVcgLYIV/ky0QgaEKzBSghUGEq2QEeEKDJdghYOJVsiQcAXqJVhhcKIVMiZcgaESrHBoohUaQLgCRyJY4fBEKzSIcAUORbDCkYlWaCDhChxIsMLQiFZoMOEK9BOsMHSiFZpAuAKCFeojWqFJhCtUl2CF+olWaCLhCtUjWGF4RCs0mXCF6hCsMHyiFXJAuEL5CVYYGdEKOSFcobwEK4ycaIUcEa5QPoIV0iFaIWeEK5SHYIX0iFbIIeEKxSdYIV2iFXJKuEJxCVZIn2iFHBOuUDyCFbIhWiHnhCsUh2CF7IhWKADhCvknWCFbohUKQrhCfglWyJ5ohQIRrpA/ghUaQ7RCwQhXyA/BCo0jWqGAhCs0n2CFxhKtUFDCFZpHsELjiVYoMOEKjSdYoTlEKxSccIXGEazQPKIVSkC4QvYEKzSXaIWSEK6QHcEKzSdaoUSEK6RPsEI+iFYoGeEK6RGskB+iFUpIuMLICVbIF9EKJSVcYfgEK+SPaIUSE65QP8EK+SRaoeSEKwydYIX8Eq1QAcIVjkywQr6JVqgI4QqHJlgh/0QrVIhwhYMJVigG0QoVI1zhzwQrFIdohQoSriBYoWhEK1SUcKXKBCsUj2iFChOuVJFghWISrVBxwpUqEaxQXKIVEK5UgmCFYhOtQEQIV8pNsELxiVagRrhSRoIVykG0AgMIV8pEsEJ5iFbgIMKVMhCsUC6iFRiUcKXIBCuUj2gFDkm4UkSCFcpJtAKHJVwpEsEK5SVagSMSrhSBYIVyE63AkAhX8kywQvmJVmDIhCt5JFihGkQrUBfhSp4IVqgO0QrUTbiSB4IVqkW0AsMiXGkmwQrVI1qBYROuNINghWoSrcCICFcaSbBCdYlWYMSEK40gWKHaRCuQCuFKlgQrIFqB1AhXsiBYgQjRCqRMuJImwQr0E61A6oQraRCswCuJViATwpWREKzAgUQrkBnhynAIVmAwohXIlHClHoIVOBTRCmROuDIUghU4HNEKNIRw5XAEK3AkohVoGOHKYAQrMBSZROtvfvOb+NCHPhRTp06NcePGxQknnBCPPPJI7XiSJLFixYqYPn16jBs3Lrq6uuLpp5/OYhQgZ4QrryRYgaFKPVr/8Ic/xKmnnhpjxoyJu+++O5544on48pe/HMccc0ztnFWrVsV1110Xa9asiU2bNsX48ePjjDPOiD179qQ9DpBDwpUIwQrUZ3TaF7zqqqvi2GOPjRtvvLG2b9asWbWvkySJa6+9Nj7zmc/EOeecExER3/72t6O9vT3uuOOOuOCCC9IeCcihuXPnRkTE2rVra+G6ePHimDBhQpMnoxEEK1Cv1O+03nnnnTFv3rz4wAc+ENOmTYs5c+bE17/+9drxZ555Jrq7u6Orq6u2b9KkSTF//vzYuHFj2uMAOeaOazUJVmA4Uo/WX/3qV3HDDTfEG97whvj3f//3+PjHPx6f+tSn4qabboqIiO7u7oiIaG9vH/C49vb22rED7d27N3bt2jVgA8pBuFaLYAWGK/Vo7evri7lz58YXv/jFmDNnTixcuDA++tGPxpo1a4Z9zZUrV8akSZNq27HHHpvixECzCddqEKzASKQerdOnT483velNA/Ydd9xxsXXr1oiI6OjoiIiInp6eAef09PTUjh1o+fLl0dvbW9u2bduW9thAkwnXchOswEilHq2nnnpqbNmyZcC+p556Kl772tdGxMt/lNXR0RHr16+vHd+1a1ds2rQpOjs7B71ma2trTJw4ccAGlI9wLSfBCqQh9WhdunRpPPjgg/HFL34x/uu//ituueWW+NrXvhaLFi2KiIiWlpZYsmRJXHnllXHnnXfG448/Hh/5yEdixowZce6556Y9DlAwwrVcBCuQltSj9ZRTTonbb789vvvd78bxxx8fn//85+Paa6+NBQsW1M659NJL45Of/GQsXLgwTjnllHj++efjnnvuiba2trTHAQpIuJaDYAXSlPr7tEZEnHXWWYf9xdTS0hJXXHFFXHHFFVk8PVAC3se12AQrkLZMPsYVIA3uuBaTYAWyIFqBXBOuxSJYgayIViD3hGsxCFYgS6IVKAThmm+CFciaaAUKQ7jmk2AFGkG0AoUiXPNFsAKNIlqBwhGu+SBYgUYSrUAhCdfmEqxAo4lWoLCEa3MIVqAZRCtQaMK1sQQr0CyiFSg84doYghVoJtEKlIJwzZZgBZpNtAKlIVyzIViBPBCtQKkI13QJViAvRCtQOsI1HYIVyBPRCpSScB0ZwQrkjWgFSku4Do9gBfJItAKlJlzrI1iBvBKtQOkJ16ERrECeiVagEoTr4QlWIO9EK1AZwnVwghUoAtEKVIpwHUiwAkUhWoHKEa4vE6xAkYhWoJKqHq6CFSga0QpUVlXDVbACRSRagUqrWrgKVqCoRCtQeVUJV8EKFJloBYjyh6tgBYpOtAL8SVnDVbACZSBaAV6hbOEqWIGyEK0AByhLuApWoExEK8Agih6ughUoG9EKcAhFDVfBCpSRaAU4jKKFq2AFykq0AhxBUcJVsAJlJloBhiDv4SpYgbITrQBDlNdwFaxAFYhWgDrkLVwFK1AVohWgTnkJV8EKVIloBRiGZoerYAWqRrQCDFOzwlWwAlUkWgFGoNHhKliBqhKtACPUqHAVrECViVaAFGQdroIVqDrRCpCSrMJVsAKIVoBUpR2ughXgZaIVIGVphatgBfgz0QqQgZGGq2AFGEi0AmRkuOEqWAEOJloBMlRvuApWgMGJVoCMDTVcBSvAoYlWgAYYLFxfeOGF2nHBCnB4o5s9AEBVzJ07NyIi1q5dG3v37o1vfOMbtWM33XRT7NixIyIEK8BgCh2tu3fvjra2tmaPATBkb3zjG+Pd7353rFu3Lvbt21fb3x+sJ554Yrzzne/M5GNgAbKyf//+zJ+j0NG6Zs0a0QqUys9+9rP42c9+1uwxAHLHa1oBAMi9Qt9p/djHPhZTp05t9hgAdenr6xvwGtZ+Y8eOjYsvvjhe9apXNWkygOHZv39/rFq1KtPnKHS0jh8/PiZMmNDsMQCGrP9dAg4M1oiIffv2xTe/+c1YvHix321AobzyNfpZ8fIAgAY58G2tTjzxxNqxd7/73RExvI98BagC0QrQAIO9D2t/qEa8HLDD+chXgKoQrQAZG+oHB9T7ka8AVSJaATJU7yddCVeAwYlWgIwM96NZhSvAwUQrQAaGG6z9hCvAQKIVIGUjDdZ+whXgz0QrQIrSCtZ+whXgZaIVICVpB2s/4QogWgFSkVWw9hOuQNWJVoARyjpY+wlXoMpEK8AINCpY+wlXoKpEK8AwNTpY+wlXoIpEK8AwNCtY+wlXoGpEK0Cdmh2s/YQrUCWiFaAOeQnWfsIVqArRCjBEeQvWfsIVqALRCjAEeQ3WfsIVKDvRCnAEeQ/WfsIVKDPRCnAYRQnWfsIVKCvRCnAIRQvWfsIVKCPRCjCIogZrP+EKlI1oBThA0YO1n3AFykS0ArxCWYK1n3AFykK0AvxJ2YK1n3AFykC0AkR5g7WfcAWKTrQClVf2YO0nXIEiE61ApVUlWPsJV6CoRCtQWVUL1n7CFSgi0QpUUlWDtZ9wBYpGtAKVU/Vg7SdcgSIRrUClCNaBhCtQFKIVqAzBOjjhChSBaAUqQbAennAF8k60AqUnWIdGuAJ5JlqBUhOs9RGuQF6JVqC0BOvwCFcgj0QrUEqCdWSEK5A3ohUoHcGaDuEK5IloBUpFsKZLuAJ5IVqB0hCs2RCuQB6IVqAUBGu2hCvQbKIVKDzB2hjCFWgm0QoUmmBtLOEKNItoBQpLsDaHcAWaQbQChSRYm0u4Ao0mWoHCEaz5IFyBRhKtQKEI1nwRrkCjiFagMARrPglXoBFEK1AIgjXfhCuQNdEK5J5gLQbhCmRJtAK5JliLRbgCWRGtQG4J1mISrkAWRCuQS4K12IQrkDbRCuSOYC0H4QqkKfNo/dKXvhQtLS2xZMmS2r49e/bEokWLYurUqTFhwoQ4//zzo6enJ+tRgAIQrOUiXIG0ZBqtDz/8cHz1q1+NE088ccD+pUuXxtq1a+O2226LDRs2xLPPPhvnnXdelqMABSBYy0m4AmnILFqff/75WLBgQXz961+PY445pra/t7c3vvGNb8TVV18d73rXu+Lkk0+OG2+8MX784x/Hgw8+mNU4QM4J1nITrsBIZRatixYtijPPPDO6uroG7N+8eXPs379/wP7Zs2fHzJkzY+PGjYNea+/evbFr164BG1AegrUahCswEplE66233hqPPvporFy58qBj3d3dMXbs2Jg8efKA/e3t7dHd3T3o9VauXBmTJk2qbccee2wWYwNNIFirRbgCw5V6tG7bti0uueSSuPnmm6OtrS2Vay5fvjx6e3tr27Zt21K5LtBcgrWahCswHKlH6+bNm2P79u0xd+7cGD16dIwePTo2bNgQ1113XYwePTra29tj3759sXPnzgGP6+npiY6OjkGv2draGhMnThywAcUmWKtNuAL1Sj1aTzvttHj88cfjscceq23z5s2LBQsW1L4eM2ZMrF+/vvaYLVu2xNatW6OzszPtcYAcEqxECFegPqPTvuDRRx8dxx9//IB948ePj6lTp9b2X3zxxbFs2bKYMmVKTJw4MT75yU9GZ2dnvPWtb017HCBnBCuvNHfu3IiIWLt2bS1cFy9eHBMmTGjyZEDeNOUTsa655po466yz4vzzz493vOMd0dHRET/4wQ+aMQrQQIKVwbjjCgxF6ndaB/OjH/1owPdtbW2xevXqWL16dSOeHsgBwcrhuOMKHElT7rQC1SJYGQp3XIHDEa1ApgQr9RCuwKGIViAzgpXhEK7AYEQrkAnBykgIV+BAohVInWAlDcIVeCXRCqRKsJIm4Qr0E61AagQrWRCuQIRoBVIiWMmScAVEKzBigpVGEK5QbaIVGBHBSiMJV6gu0QoMm2ClGYQrVJNoBYZFsNJMwhWqR7QCdROs5IFwhWoRrUBdBCt5IlyhOkQrMGSClTwSrlANohUYEsFKnglXKD/RChyRYKUIhCuUm2gFDkuwUiTCFcpLtAKHJFgpIuEK5SRagUEJVopMuEL5iFbgIIKVMhCuUC6iFRhAsFImwhXKQ7QCNYKVMhKuUA6iFYgIwUq5CVcoPtEKCFYqQbhCsYlWqDjBSpUIVygu0QoVJlipIuEKxSRaoaIEK1UmXKF4RCtUkGAF4QpFI1qhYgQr/JlwheIQrVAhghUOJlyhGEQrVIRghUMTrpB/ohUqQLDCkQlXyDfRCiUnWGHohCvkl2iFEhOsUD/hCvkkWqGkBCsMn3CF/BGtUEKCFUZOuEK+iFYoGcEK6RGukB+iFUpEsEL6hCvkg2iFkhCskB3hCs0nWqEEBCtkT7hCc4lWKDjBCo0jXKF5RCsUmGCFxhOu0ByiFQpKsELzCFdoPNEKBSRYofmEKzSWaIWCEayQH8IVGke0QoEIVsgf4QqNIVqhIAQr5JdwheyJVigAwQr5J1whW6IVck6wQnEIV8iOaIUcE6xQPMIVsiFaIacEKxSXcIX0iVbIIcEKxSdcIV2iFXJGsEJ5CFdIj2iFHBGsUD7CFdIhWiEnBCuUl3CFkROtkAOCFcpPuMLIiFZoMsEK1SFcYfhEKzSRYIXqEa4wPKIVmkSwQnUJV6ifaIUmEKyAcIX6iFZoMMEK9BOuMHSiFRpIsAIHEq4wNKIVGkSwAociXOHIRCs0gGAFjkS4wuGJVsiYYAWGSrjCoYlWyJBgBeolXGFwohUyIliB4RKucDDRChkQrMBICVcYSLRCygQrkBbhCn8mWiFFghVIm3CFl4lWSIlgBbIiXEG0QioEK5A14UrViVYYIcEKNIpwpcpEK4yAYAUaTbhSVaIVhkmwAs0iXKki0QrDIFiBZhOuVI1ohToJViAvhCtVIlqhDoIVyBvhSlWIVhgiwQrklXClCkQrDIFgBfJOuFJ2ohWOQLACRSFcKTPRCochWIGiEa6UlWiFQxCsQFEJV8pItMIgBCtQdMKVshGtcADBCpSFcKVMRCu8gmAFyka4UhaiFf5EsAJlJVwpA9EKIViB8hOuFJ1opfIEK1AVwpUiE61UmmAFqka4UlSilcoSrEBVCVeKSLRSSYIVqDrhStGIVipHsAK8TLhSJKKVShGsAAMJV4pCtFIZghVgcMKVIhCtVIJgBTg84UreiVZKT7ACDI1wJc9EK6UmWAHqI1zJK9FKaQlWgOERruSRaKWUBCvAyAhX8ka0UjqCFSAdwpU8Ea2UimAFSJdwJS9EK6UhWAGyIVzJA9FKKQhWgGwJV5pNtFJ4ghWgMYQrzSRaKTTBCtBYwpVmEa0UlmAFaA7hSjOIVgpJsAI0l3Cl0UQrhSNYAfJBuNJIopVCEawA+SJcaRTRSmEIVoB8Eq40QurRunLlyjjllFPi6KOPjmnTpsW5554bW7ZsGXDOnj17YtGiRTF16tSYMGFCnH/++dHT05P2KJSIYAXIN+FK1lKP1g0bNsSiRYviwQcfjHXr1sX+/fvj9NNPj927d9fOWbp0aaxduzZuu+222LBhQzz77LNx3nnnpT0KJSFYAYpBuJKl0Wlf8J577hnw/be+9a2YNm1abN68Od7xjndEb29vfOMb34hbbrkl3vWud0VExI033hjHHXdcPPjgg/HWt7417ZEoMMEKUCxz586NiIi1a9fWwnXx4sUxYcKEJk9G0WX+mtbe3t6IiJgyZUpERGzevDn2798fXV1dtXNmz54dM2fOjI0bNw56jb1798auXbsGbJSfYAUoJndcyUKm0drX1xdLliyJU089NY4//viIiOju7o6xY8fG5MmTB5zb3t4e3d3dg15n5cqVMWnSpNp27LHHZjk2OSBYAYpNuJK2TKN10aJF8fOf/zxuvfXWEV1n+fLl0dvbW9u2bduW0oTkkWAFKAfhSpoyi9bFixfHXXfdFffdd1+85jWvqe3v6OiIffv2xc6dOwec39PTEx0dHYNeq7W1NSZOnDhgo5wEK0C5CFfSknq0JkkSixcvjttvvz3uvffemDVr1oDjJ598cowZMybWr19f27dly5bYunVrdHZ2pj0OBSJYAcpJuJKG1KN10aJF8Z3vfCduueWWOProo6O7uzu6u7vjxRdfjIiISZMmxcUXXxzLli2L++67LzZv3hwXXXRRdHZ2eueAChOsAOUmXBmp1KP1hhtuiN7e3njnO98Z06dPr23f+973audcc801cdZZZ8X5558f73jHO6KjoyN+8IMfpD0KBSFYAapBuDISqb9Pa5IkRzynra0tVq9eHatXr0776SkYwQpQLd7HleHK/H1a4VAEK0A1uePKcIhWmkKwAlSbcKVeopWGE6wARAhX6iNaaSjBCsArCVeGSrTSMIIVgMEIV4ZCtNIQghWAwxGuHIloJXOCFYChEK4cjmglU4IVgHoIVw5FtJIZwQrAcAhXBiNayYRgBWAkhCsHEq2kTrACkAbhyiuJVlIlWAFIk3Cln2glNYIVgCwIVyJEKykRrABkSbgiWhkxwQpAIwjXahOtjIhgBaCRhGt1iVaGTbAC0AzCtZpEK8MiWAFoJuFaPaKVuglWAPJAuFaLaKUughWAPBGu1SFaGTLBCkAeCddqEK0MiWAFIM+Ea/mJVo5IsAJQBMK13EQrhyVYASgS4VpeopVDEqwAFJFwLSfRyqAEKwBFJlzLR7RyEMEKQBkI13IRrQwgWAEoE+FaHqKVGsEKQBkJ13IQrUSEYAWg3IRr8YlWBCsAlSBci020VpxgBaBKhGtxidYKE6wAVJFwLSbRWlGCFYAqE67FI1orSLACgHAtGtFaMYIVAP5MuBaHaK0QwQoABxOuxSBaK0KwAsChCdf8E60VIFgB4MiEa76J1pITrAAwdMI1v0RriQlWAKifcM0n0VpSghUAhk+45o9oLSHBCgAjJ1zzRbSWjGAFgPQI1/wQrSUiWAEgfcI1H0RrSQhWAMiOcG0+0VoCghUAsidcm0u0FpxgBYDGEa7NI1oLTLACQOMJ1+YQrQUlWAGgeYRr44nWAhKsANB8wrWxRGvBCFYAyA/h2jiitUAEKwDkj3BtDNFaEIIVAPJLuGZPtBaAYAWA/BOu2RKtOSdYAaA4hGt2RGuOCVYAKB7hmg3RmlOCFQCKS7imT7TmkGAFgOITrukSrTkjWAGgPIRrekRrjghWACgf4ZoO0ZoTghUAyku4jpxozQHBCgDlJ1xHRrQ2mWAFgOoQrsMnWptIsAJA9QjX4RGtTSJYAaC6hGv9RGsTCFYAQLjWR7Q2mGAFAPoJ16ETrQ0kWAGAAwnXoRGtDSJYAYBDEa5HJlobQLACAEciXA9PtGZMsAIAQyVcD020ZkiwAgD1Eq6DE60ZEawAwHAJ14OJ1gwIVgBgpITrQKI1ZYIVAEiLcP0z0ZoiwQoApE24vky0pkSwAgBZEa6iNRWCFQDIWtXDVbSOkGAFABqlyuEqWkdAsAIAjVbVcBWtwyRYAYBmqWK4itZhEKwAQLNVLVxFa50EKwCQF1UKV9FaB8EKAORNVcJVtA6RYAUA8qoK4Spah0CwAgB5V/ZwFa1HIFgBgKIoc7iK1sMQrABA0ZQ1XEXrIQhWAKCoyhiuonUQghUAKLqyhatoPYBgBQDKokzhKlpfQbACAGVTlnAVrX8iWAGAsipDuIrWEKwAQPkVPVwrH62CFQCoiiKHa6WjVbACAFVT1HCtbLQKVgCgqooYrpWMVsEKAFRd0cK1ctEqWAEAXlakcK1UtApWAICBihKulYlWwQoAMLgihGslolWwAgAcXt7DtfTRKlgBAIYmz+Fa6mgVrAAA9clruJY2WgUrAMDw5DFcSxmtghUAYGTyFq6li1bBCgCQjjyFa6miVbACAKQrL+FammgVrAAA2chDuJYiWgUrAEC2mh2uhY9WwQoA0BjNDNemRevq1avjda97XbS1tcX8+fPjoYceqvsaghUAoLEGC9fdu3dn/rxNidbvfe97sWzZsvjsZz8bjz76aJx00klxxhlnxPbt2+u6zk033SRYAQAa7MBw/epXv5r5c47O/BkGcfXVV8dHP/rRuOiiiyIiYs2aNfHDH/4wvvnNb8Zll1025Ovs2LEj2traYs6cOXH66afHvn37shoZIHX79+8f8LXfYUCRHH/88fHHP/4x7r777ti7d2/mz9fwaN23b19s3rw5li9fXts3atSo6Orqio0bNw76mL179w74x+jt7a3tj4jYuHHjIR8LUASrVq1q9ggAI9LfZUmSZHL9hkfr7373u3jppZeivb19wP729vb45S9/OehjVq5cGZ/73OcO2n/NNddkMiMAAMPz+9//PiZNmpT6dZvy8oB6LV++PJYtW1b7fufOnfHa1742tm7dmsk/Cvmxa9euOPbYY2Pbtm0xceLEZo9Dhqx1tVjv6rDW1dHb2xszZ86MKVOmZHL9hkfrq1/96jjqqKOip6dnwP6enp7o6OgY9DGtra3R2tp60P5Jkyb5D6AiJk6caK0rwlpXi/WuDmtdHaNGZfN3/g1/94CxY8fGySefHOvXr6/t6+vri/Xr10dnZ2ejxwEAoACa8vKAZcuWxYUXXhjz5s2Lt7zlLXHttdfG7t27a+8mAAAAr9SUaP2bv/mb+L//+79YsWJFdHd3x5vf/Oa45557DvrjrENpbW2Nz372s4O+ZIBysdbVYa2rxXpXh7WujqzXuiXJ6n0JAAAgJU37GFcAABgq0QoAQO6JVgAAck+0AgCQe4WM1tWrV8frXve6aGtri/nz58dDDz3U7JEYoZUrV8Ypp5wSRx99dEybNi3OPffc2LJly4Bz9uzZE4sWLYqpU6fGhAkT4vzzzz/oQyooli996UvR0tISS5Ysqe2zzuXym9/8Jj70oQ/F1KlTY9y4cXHCCSfEI488UjueJEmsWLEipk+fHuPGjYuurq54+umnmzgxw/HSSy/F5ZdfHrNmzYpx48bF61//+vj85z8/4DPorXUx3X///XH22WfHjBkzoqWlJe64444Bx4eyrjt27IgFCxbExIkTY/LkyXHxxRfH888/X/cshYvW733ve7Fs2bL47Gc/G48++micdNJJccYZZ8T27dubPRojsGHDhli0aFE8+OCDsW7duti/f3+cfvrpsXv37to5S5cujbVr18Ztt90WGzZsiGeffTbOO++8Jk7NSDz88MPx1a9+NU488cQB+61zefzhD3+IU089NcaMGRN33313PPHEE/HlL385jjnmmNo5q1atiuuuuy7WrFkTmzZtivHjx8cZZ5wRe/bsaeLk1Ouqq66KG264Ib7yla/Ek08+GVdddVWsWrUqrr/++to51rqYdu/eHSeddFKsXr160ONDWdcFCxbEL37xi1i3bl3cddddcf/998fChQvrHyYpmLe85S3JokWLat+/9NJLyYwZM5KVK1c2cSrStn379iQikg0bNiRJkiQ7d+5MxowZk9x22221c5588skkIpKNGzc2a0yG6bnnnkve8IY3JOvWrUv+3//7f8kll1ySJIl1Lpt//Md/TN7+9rcf8nhfX1/S0dGR/Mu//Ett386dO5PW1tbku9/9biNGJCVnnnlm8rd/+7cD9p133nnJggULkiSx1mUREcntt99e+34o6/rEE08kEZE8/PDDtXPuvvvupKWlJfnNb35T1/MX6k7rvn37YvPmzdHV1VXbN2rUqOjq6oqNGzc2cTLS1tvbGxERU6ZMiYiIzZs3x/79+wes/ezZs2PmzJnWvoAWLVoUZ5555oD1jLDOZXPnnXfGvHnz4gMf+EBMmzYt5syZE1//+tdrx5955pno7u4esN6TJk2K+fPnW++Cedvb3hbr16+Pp556KiIifvrTn8YDDzwQ733veyPCWpfVUNZ148aNMXny5Jg3b17tnK6urhg1alRs2rSprudryidiDdfvfve7eOmllw765Kz29vb45S9/2aSpSFtfX18sWbIkTj311Dj++OMjIqK7uzvGjh0bkydPHnBue3t7dHd3N2FKhuvWW2+NRx99NB5++OGDjlnncvnVr34VN9xwQyxbtiz+6Z/+KR5++OH41Kc+FWPHjo0LL7ywtqaD/U633sVy2WWXxa5du2L27Nlx1FFHxUsvvRRf+MIXYsGCBRER1rqkhrKu3d3dMW3atAHHR48eHVOmTKl77QsVrVTDokWL4uc//3k88MADzR6FlG3bti0uueSSWLduXbS1tTV7HDLW19cX8+bNiy9+8YsRETFnzpz4+c9/HmvWrIkLL7ywydORpu9///tx8803xy233BJ/9Vd/FY899lgsWbIkZsyYYa1JTaFeHvDqV786jjrqqIP+krinpyc6OjqaNBVpWrx4cdx1111x3333xWte85ra/o6Ojti3b1/s3LlzwPnWvlg2b94c27dvj7lz58bo0aNj9OjRsWHDhrjuuuti9OjR0d7ebp1LZPr06fGmN71pwL7jjjsutm7dGhFRW1O/04vv05/+dFx22WVxwQUXxAknnBAf/vCHY+nSpbFy5cqIsNZlNZR17ejoOOiP5f/4xz/Gjh076l77QkXr2LFj4+STT47169fX9vX19cX69eujs7OziZMxUkmSxOLFi+P222+Pe++9N2bNmjXg+MknnxxjxowZsPZbtmyJrVu3WvsCOe200+Lxxx+Pxx57rLbNmzcvFixYUPvaOpfHqaeeetBb1z311FPx2te+NiIiZs2aFR0dHQPWe9euXbFp0ybrXTAvvPBCjBo1MCmOOuqo6OvriwhrXVZDWdfOzs7YuXNnbN68uXbOvffeG319fTF//vz6nnBEf0bWBLfeemvS2tqafOtb30qeeOKJZOHChcnkyZOT7u7uZo/GCHz84x9PJk2alPzoRz9Kfvvb39a2F154oXbOxz72sWTmzJnJvffemzzyyCNJZ2dn0tnZ2cSpScMr3z0gSaxzmTz00EPJ6NGjky984QvJ008/ndx8883Jq171quQ73/lO7ZwvfelLyeTJk5N/+7d/S372s58l55xzTjJr1qzkxRdfbOLk1OvCCy9M/uIv/iK56667kmeeeSb5wQ9+kLz61a9OLr300to51rqYnnvuueQnP/lJ8pOf/CSJiOTqq69OfvKTnyS//vWvkyQZ2rq+5z3vSebMmZNs2rQpeeCBB5I3vOENyQc/+MG6ZylctCZJklx//fXJzJkzk7FjxyZvectbkgcffLDZIzFCETHoduONN9bOefHFF5NPfOITyTHHHJO86lWvSt7//vcnv/3tb5s3NKk4MFqtc7msXbs2Of7445PW1tZk9uzZyde+9rUBx/v6+pLLL788aW9vT1pbW5PTTjst2bJlS5OmZbh27dqVXHLJJcnMmTOTtra25C//8i+Tf/7nf0727t1bO8daF9N999036P+fL7zwwiRJhrauv//975MPfvCDyYQJE5KJEycmF110UfLcc8/VPUtLkrzi4yoAACCHCvWaVgAAqkm0AgCQe6IVAIDcE60AAOSeaAUAIPdEKwAAuSdaAQDIPdEKAEDuiVYAAHJPtAIAkHuiFQCA3BOtAADk3v8Hiz7NQaffKUoAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] + "metadata": { + "needs_background": "light" }, - "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1, 1, figsize=(8, 8))\n", "pmv = fplot.PlotMapView(modelgrid=tgr)\n", - "pmv.plot_grid(ax=ax)" + "pmv.plot_grid(ax=ax);" ] }, { @@ -1120,12 +1136,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1184,12 +1202,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1237,35 +1257,6 @@ { "cell_type": "code", "execution_count": 35, - "metadata": { - "execution": { - "iopub.execute_input": "2022-12-15T13:10:37.474427Z", - "iopub.status.busy": "2022-12-15T13:10:37.473858Z", - "iopub.status.idle": "2022-12-15T13:10:37.480704Z", - "shell.execute_reply": "2022-12-15T13:10:37.479652Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "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": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "result" - ] - }, - { - "cell_type": "code", - "execution_count": 36, "metadata": { "execution": { "iopub.execute_input": "2022-12-15T13:10:37.486223Z", @@ -1277,12 +1268,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1296,14 +1289,16 @@ " (h2,) = ax.plot(\n", " tgr.xcellcenters[cellid],\n", " tgr.ycellcenters[cellid],\n", - " \"kx\", ms=15,\n", + " \"kx\",\n", + " 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", + " \"r+\",\n", + " ms=15,\n", " label=\"centroids with return_all_intersections=True\",\n", " )\n", "\n", @@ -1327,7 +1322,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.15" + "version": "3.9.7" }, "vscode": { "interpreter": { diff --git a/flopy/utils/gridintersect.py b/flopy/utils/gridintersect.py index 8a26a5438..ff0ec3673 100644 --- a/flopy/utils/gridintersect.py +++ b/flopy/utils/gridintersect.py @@ -203,6 +203,7 @@ def intersect( return_all_intersections=False, contains_centroid=False, min_area_fraction=None, + shapely2=True, ): """Method to intersect a shape with a model grid. @@ -234,6 +235,10 @@ def intersect( 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" + shapely2 : bool, optional + temporary flag to determine whether to use methods optimized for + shapely 2.0. Useful for comparison performance between the old + (shapely 1.8) and new (shapely 2.0) implementations. Returns ------- @@ -252,11 +257,18 @@ def intersect( shp, return_all_intersections=return_all_intersections ) else: - rec = self._intersect_point_shapely( - shp, - sort_by_cellid=sort_by_cellid, - return_all_intersections=return_all_intersections, - ) + if SHAPELY_GE_20 and shapely2: + rec = self._intersect_point_shapely2( + shp, + sort_by_cellid=sort_by_cellid, + return_all_intersections=return_all_intersections, + ) + else: + 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" @@ -268,12 +280,20 @@ def intersect( return_all_intersections=return_all_intersections, ) else: - rec = self._intersect_linestring_shapely( - shp, - keepzerolengths, - sort_by_cellid=sort_by_cellid, - return_all_intersections=return_all_intersections, - ) + if SHAPELY_GE_20 and shapely2: + rec = self._intersect_linestring_shapely2( + shp, + keepzerolengths, + sort_by_cellid=sort_by_cellid, + return_all_intersections=return_all_intersections, + ) + else: + rec = self._intersect_linestring_shapely( + shp, + keepzerolengths, + sort_by_cellid=sort_by_cellid, + return_all_intersections=return_all_intersections, + ) elif gu.shapetype in ("Polygon", "MultiPolygon"): if ( self.method == "structured" @@ -285,12 +305,20 @@ def intersect( min_area_fraction=min_area_fraction, ) else: - rec = self._intersect_polygon_shapely( - shp, - sort_by_cellid=sort_by_cellid, - contains_centroid=contains_centroid, - min_area_fraction=min_area_fraction, - ) + if SHAPELY_GE_20 and shapely2: + rec = self._intersect_polygon_shapely2( + shp, + sort_by_cellid=sort_by_cellid, + contains_centroid=contains_centroid, + min_area_fraction=min_area_fraction, + ) + else: + rec = self._intersect_polygon_shapely( + shp, + sort_by_cellid=sort_by_cellid, + contains_centroid=contains_centroid, + min_area_fraction=min_area_fraction, + ) else: raise TypeError(f"Shapetype {gu.shapetype} is not supported") @@ -701,6 +729,7 @@ def _intersect_linestring_shapely( isectshp = [] cellids = [] vertices = [] + vertices_check = [] lengths = [] # loop over cells returned by filtered spatial query @@ -718,7 +747,7 @@ def _intersect_linestring_shapely( # 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: + if verts in vertices_check: continue # if keep zero don't check length if not keepzerolengths: @@ -727,6 +756,11 @@ def _intersect_linestring_shapely( isectshp.append(c) lengths.append(c.length) vertices.append(verts) + # unpack mutlilinestring for checking if linestring already parsed + if c.geom_type.startswith("Multi"): + vertices_check += [iv for iv in verts] + else: + vertices_check.append(verts) # if structured calculate (i, j) cell address if self.mfgrid.grid_type == "structured": cid = self.mfgrid.get_lrc([cid])[0][1:] @@ -842,8 +876,255 @@ def _intersect_polygon_shapely( return rec + def _intersect_point_shapely2( + self, + shp, + sort_by_cellid=True, + return_all_intersections=False, + ): + if self.rtree: + qcellids = self.strtree.query(shp, predicate="intersects") + else: + qcellids = self.filter_query_result(self.cellids, shp) + + if sort_by_cellid: + qcellids = np.sort(qcellids) + + ixresult = shapely.intersection(shp, self.geoms[qcellids]) + # discard empty intersection results + mask_empty = shapely.is_empty(ixresult) + # keep only Point and MultiPoint + mask_type = np.isin(shapely.get_type_id(ixresult), [0, 4]) + ixresult = ixresult[~mask_empty & mask_type] + qcellids = qcellids[~mask_empty & mask_type] + + if not return_all_intersections: + keep_cid = [] + keep_pts = [] + parsed = [] + for (ishp, cid) in zip(ixresult, qcellids): + points = [] + for pnt in shapely.get_parts(ishp): + if tuple(pnt.coords)[0] not in parsed: + points.append(pnt) + parsed.append(tuple(pnt.coords)[0]) + + if len(points) > 1: + keep_pts.append(shapely.MultiPoint(points)) + keep_cid.append(cid) + elif len(points) == 1: + keep_pts.append(points[0]) + keep_cid.append(cid) + else: + keep_pts = ixresult + keep_cid = qcellids + + names = ["cellids", "ixshapes"] + # self.mfgrid.grid_type == "structured": + # cid_dtype = "i" + # else: + # cid_dtype = "O" + formats = ["O", "O"] + rec = np.recarray(len(keep_pts), names=names, formats=formats) + + # if structured calculate (i, j) cell address + if self.mfgrid.grid_type == "structured": + rec.cellids = list( + zip(*self.mfgrid.get_lrc([self.cellids[keep_cid]])[0][1:]) + ) + else: + rec.cellids = self.cellids[keep_cid] + rec.ixshapes = keep_pts + + return rec + + def _intersect_linestring_shapely2( + self, + shp, + keepzerolengths=False, + sort_by_cellid=True, + return_all_intersections=False, + ): + if keepzerolengths: + warnings.warn( + "`keepzerolengths` is deprecated. For obtaining all cellids that " + "intersect with a LineString, use `intersects()`.", + DeprecationWarning, + ) + + if self.rtree: + qcellids = self.strtree.query(shp, predicate="intersects") + else: + qcellids = self.filter_query_result(self.cellids, shp) + + if sort_by_cellid: + qcellids = np.sort(qcellids) + + ixresult = shapely.intersection(shp, self.geoms[qcellids]) + # discard empty intersection results + mask_empty = shapely.is_empty(ixresult) + # keep only Linestring and MultiLineString + geomtype_ids = shapely.get_type_id(ixresult) + mask_type = np.isin(geomtype_ids, [1, 5, 7]) + ixresult = ixresult[~mask_empty & mask_type] + qcellids = qcellids[~mask_empty & mask_type] + + # parse geometry collections (i.e. when part of linestring touches a cell edge, + # resulting in a point intersection result) + if 7 in geomtype_ids: + + def parse_linestrings_in_geom_collection(gc): + parts = shapely.get_parts(gc) + parts = parts[np.isin(shapely.get_type_id(parts), [1, 5])] + if len(parts) > 1: + p = shapely.multilinestring(parts) + elif len(parts) == 0: + p = shapely.LineString() + else: + p = parts[0] + return p + + mask_gc = geomtype_ids[~mask_empty & mask_type] == 7 + ixresult[mask_gc] = np.apply_along_axis( + parse_linestrings_in_geom_collection, + axis=0, + arr=ixresult[mask_gc], + ) + + if not return_all_intersections: + # intersection with grid cell boundaries + ixbounds = shapely.intersection( + shp, shapely.get_exterior_ring(self.geoms[qcellids]) + ) + mask_bnds_empty = shapely.is_empty(ixbounds) + mask_bnds_type = np.isin(shapely.get_type_id(ixbounds), [1, 5]) + # get ids of boundary intersections + idxs = np.nonzero(~mask_bnds_empty & mask_bnds_type)[0] + + # loop through results, starting with highest cellid + for i in idxs[::-1]: + # calculate intersection with results w potential boundary + # intersections + isect = ixresult[i].intersection(ixresult[idxs]) + + # masks to obtain overlapping intersection result + mask_self = idxs == i # select not self + mask_bnds_empty = shapely.is_empty( + isect + ) # select boundary ix result + mask_overlap = np.isin(shapely.get_type_id(isect), [1, 5]) + + # calculate difference between self and overlapping result + diff = shapely.difference( + ixresult[i], + isect[mask_overlap & ~mask_self & ~mask_bnds_empty], + ) + # update intersection result if necessary + if len(diff) > 0: + ixresult[idxs[i]] = diff[0] + + # mask out empty results + mask_keep = ~shapely.is_empty(ixresult) + ixresult = ixresult[mask_keep] + qcellids = qcellids[mask_keep] + + names = ["cellids", "ixshapes", "lengths"] + formats = ["O", "O", "f8"] + + rec = np.recarray(len(ixresult), names=names, formats=formats) + # if structured grid calculate (i, j) cell address + if self.mfgrid.grid_type == "structured": + rec.cellids = list( + zip(*self.mfgrid.get_lrc([self.cellids[qcellids]])[0][1:]) + ) + else: + rec.cellids = self.cellids[qcellids] + rec.ixshapes = ixresult + rec.lengths = shapely.length(ixresult) + + return rec + + def _intersect_polygon_shapely2( + self, + shp, + sort_by_cellid=True, + contains_centroid=False, + min_area_fraction=None, + ): + if self.rtree: + qcellids = self.strtree.query(shp, predicate="intersects") + else: + qcellids = self.filter_query_result(self.cellids, shp) + + if sort_by_cellid: + qcellids = np.sort(qcellids) + + ixresult = shapely.intersection(shp, self.geoms[qcellids]) + # discard empty intersection results + mask_empty = shapely.is_empty(ixresult) + # keep only Polygons and MultiPolygons + geomtype_ids = shapely.get_type_id(ixresult) + mask_type = np.isin(geomtype_ids, [3, 6, 7]) + ixresult = ixresult[~mask_empty & mask_type] + qcellids = qcellids[~mask_empty & mask_type] + + # parse geometry collections (i.e. when part of polygon lies on cell edge, + # resulting in a linestring intersection result) + if 7 in geomtype_ids: + + def parse_polygons_in_geom_collection(gc): + parts = shapely.get_parts(gc) + parts = parts[np.isin(shapely.get_type_id(parts), [3, 6])] + if len(parts) > 1: + p = shapely.multipolygons(parts) + elif len(parts) == 0: + p = shapely.Polygon() + else: + p = parts[0] + return p + + mask_gc = geomtype_ids[~mask_empty & mask_type] == 7 + ixresult[mask_gc] = np.apply_along_axis( + parse_polygons_in_geom_collection, + axis=0, + arr=ixresult[mask_gc], + ) + + # check centroids + if contains_centroid: + centroids = shapely.centroid(self.geoms[qcellids]) + mask_centroid = shapely.contains( + ixresult, centroids + ) | shapely.touches(ixresult, centroids) + ixresult = ixresult[mask_centroid] + qcellids = qcellids[mask_centroid] + + # check intersection area + if min_area_fraction: + ix_areas = shapely.area(ixresult) + cell_areas = shapely.area(self.geoms[qcellids]) + mask_area_frac = (ix_areas / cell_areas) >= min_area_fraction + ixresult = ixresult[mask_area_frac] + qcellids = qcellids[mask_area_frac] + + # fill rec array + names = ["cellids", "ixshapes", "areas"] + formats = ["O", "O", "f8"] + rec = np.recarray(len(ixresult), names=names, formats=formats) + # if structured calculate (i, j) cell address + if self.mfgrid.grid_type == "structured": + rec.cellids = list( + zip(*self.mfgrid.get_lrc([self.cellids[qcellids]])[0][1:]) + ) + else: + rec.cellids = self.cellids[qcellids] + rec.ixshapes = ixresult + rec.areas = shapely.area(ixresult) + + return rec + def intersects(self, shp, shapetype=None): - """Return cellIDs for shapes that intersect with shape. + """Return cellids for grid cells that intersect with shape. Parameters ---------- @@ -861,19 +1142,26 @@ def intersects(self, shp, shapetype=None): a record array containing cell IDs of the gridcells the shape intersects with """ - # query grid shp = GeoSpatialUtil(shp, shapetype=shapetype).shapely - qcellids = self.query_grid(shp) - if len(qcellids) > 0: - # filter result further if possible (only strtree and filter methods) - qfiltered = self.filter_query_result(qcellids, shp) + if SHAPELY_GE_20: + qfiltered = self.strtree.query(shp, predicate="intersects") else: - # query result is empty - qfiltered = qcellids + # query grid + qcellids = self.query_grid(shp) + if len(qcellids) > 0: + # filter result further if possible (only strtree and filter methods) + qfiltered = self.filter_query_result(qcellids, shp) + else: + # query result is empty + qfiltered = qcellids + # build rec-array rec = np.recarray(len(qfiltered), names=["cellids"], formats=["O"]) - rec.cellids = qfiltered + if self.mfgrid.grid_type == "structured": + rec.cellids = list(zip(*self.mfgrid.get_lrc([qfiltered])[0][1:])) + else: + rec.cellids = qfiltered return rec def _intersect_point_structured(self, shp, return_all_intersections=False): @@ -1827,10 +2115,13 @@ def plot_polygon(rec, ax=None, **kwargs): _, ax = plt.subplots() patches = [] + if "facecolor" in kwargs: + use_facecolor = True + fc = kwargs.pop("facecolor") + else: + use_facecolor = None for i, ishp in enumerate(rec.ixshapes): - if "facecolor" in kwargs: - fc = kwargs.pop("facecolor") - else: + if not use_facecolor: fc = f"C{i % 10}" ppi = _polygon_patch(ishp, facecolor=fc, **kwargs) patches.append(ppi)