From f391bb17cde0f23bd90770f9e8e8d6eff1865d50 Mon Sep 17 00:00:00 2001
From: Joshua Larsen <jlarsen@usgs.gov>
Date: Thu, 15 Oct 2020 11:46:54 -0700
Subject: [PATCH 1/2] *Added GeoSpatialUtil for geospatial conversions *Added
 GeoSpatialCollection for batch conversion of "Collection" objects

*Updated geometry.py and added additional geometry types to geometry.py

*updates to gridgen, shapefile_utils, triangle, rasters, and gridintersect modules that allow the user to supply any supported shape object to these geospatial methods. Supported shape objects are, geojson, shapely, shapefile, flopy.utils.geometry, and lists of vertices.

*Added t074_test_geospatial_util.py

issue #772
---
 autotest/t065_test_gridintersect.py   | 105 ++++++
 autotest/t074_test_geospatial_util.py | 462 ++++++++++++++++++++++++++
 flopy/export/shapefile_utils.py       |  45 ++-
 flopy/utils/geometry.py               | 457 +++++++++++++++++++++----
 flopy/utils/geospatial_utils.py       | 435 ++++++++++++++++++++++++
 flopy/utils/gridgen.py                |  95 ++++--
 flopy/utils/gridintersect.py          |  64 +++-
 flopy/utils/rasters.py                | 139 ++++----
 flopy/utils/triangle.py               |  21 +-
 9 files changed, 1648 insertions(+), 175 deletions(-)
 create mode 100644 autotest/t074_test_geospatial_util.py
 create mode 100644 flopy/utils/geospatial_utils.py

diff --git a/autotest/t065_test_gridintersect.py b/autotest/t065_test_gridintersect.py
index efa4518f24..09be9ea555 100644
--- a/autotest/t065_test_gridintersect.py
+++ b/autotest/t065_test_gridintersect.py
@@ -130,6 +130,9 @@ def test_rect_grid_3d_point_outside():
     ix = GridIntersect(gr, method="structured")
     result = ix.intersect_point(Point(25., 25., .5))
     assert len(result) == 0
+    # test with general intersect method
+    result = ix.intersect(Point(25., 25., .5))
+    assert len(result) == 0
     return result
 
 
@@ -144,6 +147,9 @@ def test_rect_grid_3d_point_inside():
     ix = GridIntersect(gr, method="structured")
     result = ix.intersect_point(Point(2., 2., .2))
     assert result.cellids[0] == (1, 1, 0)
+    # test general intersect method
+    result = ix.intersect(Point(2., 2., .2))
+    assert result.cellids[0] == (1, 1, 0)
     return result
 
 
@@ -158,6 +164,9 @@ def test_rect_grid_3d_point_above():
     ix = GridIntersect(gr, method="structured")
     result = ix.intersect_point(Point(2., 2., 2))
     assert len(result) == 0
+    # test general intersect method
+    result = ix.intersect(Point(2., 2., 2))
+    assert len(result) == 0
     return result
 
 
@@ -171,6 +180,8 @@ def test_rect_grid_point_outside():
     ix = GridIntersect(gr, method="structured")
     result = ix.intersect_point(Point(25., 25.))
     assert len(result) == 0
+    result = ix.intersect(Point(25., 25.))
+    assert len(result) == 0
     return result
 
 
@@ -185,6 +196,10 @@ def test_rect_grid_point_on_outer_boundary():
     result = ix.intersect_point(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 1))
+
+    result = ix.intersect(Point(20., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == (0, 1))
     return result
 
 
@@ -199,6 +214,10 @@ def test_rect_grid_point_on_inner_boundary():
     result = ix.intersect_point(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 0))
+
+    result = ix.intersect(Point(10., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == (0, 0))
     return result
 
 
@@ -213,6 +232,10 @@ def test_rect_grid_multipoint_in_one_cell():
     result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == (1, 0)
+
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
+    assert len(result) == 1
+    assert result.cellids[0] == (1, 0)
     return result
 
 
@@ -228,6 +251,11 @@ def test_rect_grid_multipoint_in_multiple_cells():
     assert len(result) == 2
     assert result.cellids[0] == (1, 0)
     assert result.cellids[1] == (0, 1)
+
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(12., 12.)]))
+    assert len(result) == 2
+    assert result.cellids[0] == (1, 0)
+    assert result.cellids[1] == (0, 1)
     return result
 
 
@@ -244,6 +272,9 @@ def test_rect_grid_point_outside_shapely(rtree=True):
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
     result = ix.intersect_point(Point(25., 25.))
     assert len(result) == 0
+
+    result = ix.intersect(Point(25., 25.))
+    assert len(result) == 0
     return result
 
 
@@ -258,6 +289,10 @@ def test_rect_grid_point_on_outer_boundary_shapely(rtree=True):
     result = ix.intersect_point(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 1))
+
+    result = ix.intersect(Point(20., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == (0, 1))
     return result
 
 
@@ -272,6 +307,10 @@ def test_rect_grid_point_on_inner_boundary_shapely(rtree=True):
     result = ix.intersect_point(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 0))
+
+    result = ix.intersect(Point(10., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == (0, 0))
     return result
 
 
@@ -309,6 +348,10 @@ def test_rect_grid_multipoint_in_one_cell_shapely(rtree=True):
     result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == (1, 0)
+
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
+    assert len(result) == 1
+    assert result.cellids[0] == (1, 0)
     return result
 
 
@@ -324,6 +367,11 @@ def test_rect_grid_multipoint_in_multiple_cells_shapely(rtree=True):
     assert len(result) == 2
     assert result.cellids[0] == (0, 1)
     assert result.cellids[1] == (1, 0)
+
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(12., 12.)]))
+    assert len(result) == 2
+    assert result.cellids[0] == (0, 1)
+    assert result.cellids[1] == (1, 0)
     return result
 
 
@@ -339,6 +387,9 @@ def test_tri_grid_point_outside(rtree=True):
     ix = GridIntersect(gr, rtree=rtree)
     result = ix.intersect_point(Point(25., 25.))
     assert len(result) == 0
+
+    result = ix.intersect(Point(25., 25.))
+    assert len(result) == 0
     return result
 
 
@@ -355,6 +406,10 @@ def test_tri_grid_point_on_outer_boundary(rtree=True):
     result = ix.intersect_point(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == 0)
+
+    result = ix.intersect(Point(20., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == 0)
     return result
 
 
@@ -371,6 +426,10 @@ def test_tri_grid_point_on_inner_boundary(rtree=True):
     result = ix.intersect_point(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == 0)
+
+    result = ix.intersect(Point(10., 10.))
+    assert len(result) == 1
+    assert np.all(result.cellids[0] == 0)
     return result
 
 
@@ -387,6 +446,10 @@ def test_tri_grid_multipoint_in_one_cell(rtree=True):
     result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == 1
+
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
+    assert len(result) == 1
+    assert result.cellids[0] == 1
     return result
 
 
@@ -420,6 +483,9 @@ def test_rect_grid_linestring_outside():
     ix = GridIntersect(gr, method="structured")
     result = ix.intersect_linestring(LineString([(25., 25.), (21., 5.)]))
     assert len(result) == 0
+
+    result = ix.intersect(LineString([(25., 25.), (21., 5.)]))
+    assert len(result) == 0
     return result
 
 
@@ -436,6 +502,12 @@ def test_rect_grid_linestring_in_2cells():
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == (1, 0)
     assert result.cellids[1] == (1, 1)
+
+    result = ix.intersect(LineString([(5., 5.), (15., 5.)]))
+    assert len(result) == 2
+    assert result.lengths.sum() == 10.
+    assert result.cellids[0] == (1, 0)
+    assert result.cellids[1] == (1, 1)
     return result
 
 
@@ -648,6 +720,12 @@ def test_tri_grid_linestring_in_2cells(rtree=True):
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == 1
     assert result.cellids[1] == 3
+
+    result = ix.intersect(LineString([(5., 5.), (5., 15.)]))
+    assert len(result) == 2
+    assert result.lengths.sum() == 10.
+    assert result.cellids[0] == 1
+    assert result.cellids[1] == 3
     return result
 
 
@@ -702,6 +780,12 @@ def test_tri_grid_multilinestring_in_one_cell(rtree=True):
     assert len(result) == 1
     assert result.lengths == 15.
     assert result.cellids[0] == 4
+
+    result = ix.intersect(MultiLineString(
+        [LineString([(1., 1), (9., 1.)]), LineString([(2., 2.), (9., 2.)])]))
+    assert len(result) == 1
+    assert result.lengths == 15.
+    assert result.cellids[0] == 4
     return result
 
 
@@ -719,6 +803,9 @@ def test_rect_grid_polygon_outside():
     result = ix.intersect_polygon(
         Polygon([(21., 11.), (23., 17.), (25., 11.)]))
     assert len(result) == 0
+
+    result = ix.intersect(Polygon([(21., 11.), (23., 17.), (25., 11.)]))
+    assert len(result) == 0
     return result
 
 
@@ -734,6 +821,11 @@ def test_rect_grid_polygon_in_2cells():
         Polygon([(2.5, 5.0), (7.5, 5.0), (7.5, 15.), (2.5, 15.)]))
     assert len(result) == 2
     assert result.areas.sum() == 50.
+
+    result = ix.intersect(
+        Polygon([(2.5, 5.0), (7.5, 5.0), (7.5, 15.), (2.5, 15.)]))
+    assert len(result) == 2
+    assert result.areas.sum() == 50.
     return result
 
 
@@ -813,6 +905,10 @@ def test_rect_grid_polygon_with_hole():
     result = ix.intersect_polygon(p)
     assert len(result) == 3
     assert result.areas.sum() == 104.
+
+    result = ix.intersect(p)
+    assert len(result) == 3
+    assert result.areas.sum() == 104.
     return result
 
 
@@ -973,6 +1069,11 @@ def test_tri_grid_polygon_in_2cells(rtree=True):
         Polygon([(2.5, 5.0), (5.0, 5.0), (5.0, 15.), (2.5, 15.)]))
     assert len(result) == 2
     assert result.areas.sum() == 25.
+
+    result = ix.intersect(
+        Polygon([(2.5, 5.0), (5.0, 5.0), (5.0, 15.), (2.5, 15.)]))
+    assert len(result) == 2
+    assert result.areas.sum() == 25.
     return result
 
 
@@ -1020,6 +1121,10 @@ def test_tri_grid_multipolygon_in_one_cell(rtree=True):
     result = ix.intersect_polygon(p)
     assert len(result) == 1
     assert result.areas.sum() == 16.5
+
+    result = ix.intersect(p)
+    assert len(result) == 1
+    assert result.areas.sum() == 16.5
     return result
 
 
diff --git a/autotest/t074_test_geospatial_util.py b/autotest/t074_test_geospatial_util.py
new file mode 100644
index 0000000000..c3ea1cfa77
--- /dev/null
+++ b/autotest/t074_test_geospatial_util.py
@@ -0,0 +1,462 @@
+polygon = {'type': 'Polygon',
+           'coordinates': (((-121.389308, 38.560816),
+                            (-121.363391, 38.568835),
+                            (-121.358641, 38.565972),
+                            (-121.359327, 38.562767),
+                            (-121.369932, 38.560575),
+                            (-121.370609, 38.557232),
+                            (-121.385435, 38.555018),
+                            (-121.389308, 38.560816)),)}
+
+poly_w_hole = {'type': 'Polygon',
+               'coordinates': (((-121.383097, 38.565764),
+                                (-121.342866, 38.579086),
+                                (-121.342739, 38.578995),
+                                (-121.323309, 38.578953),
+                                (-121.358295, 38.561163),
+                                (-121.379047, 38.559053),
+                                (-121.382318, 38.562934),
+                                (-121.383097, 38.565764)),
+                               ((-121.367281, 38.567214),
+                                (-121.362633, 38.562622),
+                                (-121.345857, 38.570301),
+                                (-121.352168, 38.572258),
+                                (-121.367281, 38.567214)))}
+
+multipolygon = {'type': 'MultiPolygon',
+                'coordinates': [[((-121.433775, 38.544254),
+                                  (-121.424263, 38.547474),
+                                  (-121.422917, 38.540376),
+                                  (-121.433775, 38.544254))],
+                                [((-121.456113, 38.552220),
+                                  (-121.440092, 38.548303),
+                                  (-121.440053, 38.537820),
+                                  (-121.459991, 38.541350),
+                                  (-121.456113, 38.552220))]]}
+
+point = {'type': 'Point',
+         'coordinates': (-121.358560, 38.567760)}
+
+multipoint = {'type': 'MultiPoint',
+              'coordinates': ((-121.366489, 38.565485),
+                              (-121.365405, 38.563835),
+                              (-121.363352, 38.566422),
+                              (-121.362895, 38.564504),
+                              (-121.360556, 38.565530))}
+
+linestring = {'type': 'LineString',
+              'coordinates': ((-121.360899, 38.563478),
+                              (-121.358161, 38.566511),
+                              (-121.355936, 38.564727),
+                              (-121.354738, 38.567047),
+                              (-121.356678, 38.568741),
+                              (-121.361583, 38.568072),
+                              (-121.363066, 38.565530),
+                              (-121.364664, 38.567359))}
+
+multilinestring = {'type': 'MultiLineString',
+                   'coordinates': (((-121.370653, 38.566021),
+                                    (-121.368600, 38.563255),
+                                    (-121.364207, 38.563746),
+                                    (-121.364550, 38.561605)),
+                                   ((-121.370710, 38.560713),
+                                    (-121.371338, 38.561873),
+                                    (-121.370881, 38.563122),
+                                    (-121.372478, 38.563345),
+                                    (-121.373448, 38.560802),
+                                    (-121.374361, 38.562363),
+                                    (-121.373733, 38.564906),
+                                    (-121.371052, 38.567091)))}
+
+
+def test_import_geospatial_utils():
+
+    from flopy.utils.geospatial_utils import GeoSpatialUtil, \
+        GeoSpatialCollection
+
+    return
+
+
+def test_polygon():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, Polygon
+
+    poly = Shape.from_geojson(polygon)
+    gi1 = poly.__geo_interface__
+
+    if not isinstance(poly, Polygon):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(poly)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'polygon').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil polygon conversion error")
+
+
+def test_polygon_with_hole():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, Polygon
+
+    poly = Shape.from_geojson(poly_w_hole)
+    gi1 = poly.__geo_interface__
+
+    if not isinstance(poly, Polygon):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(poly)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'polygon').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil polygon conversion error")
+
+
+def test_multipolygon():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, MultiPolygon
+
+    poly = Shape.from_geojson(multipolygon)
+    gi1 = poly.__geo_interface__
+
+    if not isinstance(poly, MultiPolygon):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(poly)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'multipolygon').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil multipolygon "
+                                 "conversion error")
+
+
+def test_point():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, Point
+
+    pt = Shape.from_geojson(point)
+    gi1 = pt.__geo_interface__
+
+    if not isinstance(pt, Point):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(pt)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'point').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil point "
+                                 "conversion error")
+
+
+def test_multipoint():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, MultiPoint
+
+    mpt = Shape.from_geojson(multipoint)
+    gi1 = mpt.__geo_interface__
+
+    if not isinstance(mpt, MultiPoint):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(mpt)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'multipoint').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil multipoint "
+                                 "conversion error")
+
+
+def test_linestring():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, LineString
+
+    lstr = Shape.from_geojson(linestring)
+    gi1 = lstr.__geo_interface__
+
+    if not isinstance(lstr, LineString):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(lstr)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'linestring').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil linestring "
+                                 "conversion error")
+
+
+def test_multilinestring():
+    from flopy.utils.geospatial_utils import GeoSpatialUtil
+    from flopy.utils.geometry import Shape, MultiLineString
+
+    mlstr = Shape.from_geojson(multilinestring)
+    gi1 = mlstr.__geo_interface__
+
+    if not isinstance(mlstr, MultiLineString):
+        raise AssertionError()
+
+    gu = GeoSpatialUtil(mlstr)
+
+    shp = gu.shape
+    shply = gu.shapely
+    points = gu.points
+    geojson = gu.geojson
+    fp_geo = gu.flopy_geometry
+
+    geo_types = [shp, shply, points, geojson, fp_geo]
+
+    for geo in geo_types:
+        if geo is None:  # if shapely or geojson is not installed
+            continue
+        t = GeoSpatialUtil(geo, 'multilinestring').flopy_geometry
+        gi2 = t.__geo_interface__
+
+        is_equal = gi1 == gi2
+
+        if not is_equal:
+            raise AssertionError("GeoSpatialUtil multilinestring "
+                                 "conversion error")
+
+
+def test_polygon_collection():
+    from flopy.utils.geospatial_utils import GeoSpatialCollection
+    from flopy.utils.geometry import Shape, Collection
+
+    col = [Shape.from_geojson(polygon),
+           Shape.from_geojson(poly_w_hole),
+           Shape.from_geojson(multipolygon)]
+
+    gi1 = [i.__geo_interface__ for i in col]
+    col = Collection(col)
+
+    gc1 = GeoSpatialCollection(col)
+    shapetype = gc1.shapetype
+    shp = gc1.shape
+    shply = gc1.shapely
+    points = gc1.points
+    geojson = gc1.geojson
+    fp_geo = gc1.flopy_geometry
+    
+    collections = [shp, shply, points, geojson, fp_geo]
+    for col in collections:
+        if col is None:  # if geojson or shapely is not installed
+            continue
+
+        gc2 = GeoSpatialCollection(col, shapetype)
+        gi2 = [i.flopy_geometry.__geo_interface__ for i in gc2]
+
+        for ix, gi in enumerate(gi2):
+            is_equal = gi == gi1[ix]
+
+            if not is_equal:
+                raise AssertionError("GeoSpatialCollection Polygon "
+                                     "conversion error")
+
+
+def test_point_collection():
+    from flopy.utils.geospatial_utils import GeoSpatialCollection
+    from flopy.utils.geometry import Shape, Collection
+
+    col = [Shape.from_geojson(point),
+           Shape.from_geojson(multipoint)]
+
+    gi1 = [i.__geo_interface__ for i in col]
+    col = Collection(col)
+
+    gc1 = GeoSpatialCollection(col)
+    shapetype = gc1.shapetype
+    shp = gc1.shape
+    shply = gc1.shapely
+    points = gc1.points
+    geojson = gc1.geojson
+    fp_geo = gc1.flopy_geometry
+
+    collections = [shp, shply, points, geojson, fp_geo]
+    for col in collections:
+        if col is None:  # if geojson or shapely is not installed
+            continue
+
+        gc2 = GeoSpatialCollection(col, shapetype)
+        gi2 = [i.flopy_geometry.__geo_interface__ for i in gc2]
+
+        for ix, gi in enumerate(gi2):
+            is_equal = gi == gi1[ix]
+
+            if not is_equal:
+                raise AssertionError("GeoSpatialCollection Point "
+                                     "conversion error")
+
+
+def test_linestring_collection():
+    from flopy.utils.geospatial_utils import GeoSpatialCollection
+    from flopy.utils.geometry import Shape, Collection
+
+    col = [Shape.from_geojson(linestring),
+           Shape.from_geojson(multilinestring)]
+
+    gi1 = [i.__geo_interface__ for i in col]
+    col = Collection(col)
+
+    gc1 = GeoSpatialCollection(col)
+    shapetype = gc1.shapetype
+    shp = gc1.shape
+    shply = gc1.shapely
+    points = gc1.points
+    geojson = gc1.geojson
+    fp_geo = gc1.flopy_geometry
+
+    collections = [shp, shply, points, geojson, fp_geo]
+    for col in collections:
+        if col is None:  # if geojson or shapely is not installed
+            continue
+
+        gc2 = GeoSpatialCollection(col, shapetype)
+        gi2 = [i.flopy_geometry.__geo_interface__ for i in gc2]
+
+        for ix, gi in enumerate(gi2):
+            is_equal = gi == gi1[ix]
+
+            if not is_equal:
+                raise AssertionError("GeoSpatialCollection Linestring "
+                                     "conversion error")
+
+
+def test_mixed_collection():
+    from flopy.utils.geospatial_utils import GeoSpatialCollection
+    from flopy.utils.geometry import Shape, Collection
+
+    col = [Shape.from_geojson(polygon),
+           Shape.from_geojson(poly_w_hole),
+           Shape.from_geojson(multipolygon),
+           Shape.from_geojson(point),
+           Shape.from_geojson(multipoint),
+           Shape.from_geojson(linestring),
+           Shape.from_geojson(multilinestring)]
+
+    gi1 = [i.__geo_interface__ for i in col]
+    col = Collection(col)
+
+    gc1 = GeoSpatialCollection(col)
+    shapetype = gc1.shapetype
+    shp = gc1.shape
+    shply = gc1.shapely
+    points = gc1.points
+    geojson = gc1.geojson
+    fp_geo = gc1.flopy_geometry
+
+    collections = [shp, shply, points, geojson, fp_geo]
+    for col in collections:
+        if col is None:  # if geojson or shapely is not installed
+            continue
+
+        gc2 = GeoSpatialCollection(col, shapetype)
+        gi2 = [i.flopy_geometry.__geo_interface__ for i in gc2]
+
+        for ix, gi in enumerate(gi2):
+            is_equal = gi == gi1[ix]
+
+            if not is_equal:
+                raise AssertionError("GeoSpatialCollection conversion error")
+
+
+if __name__ == "__main__":
+    test_import_geospatial_utils()
+    test_polygon()
+    test_polygon_with_hole()
+    test_multipolygon()
+    test_point()
+    test_multipoint()
+    test_linestring()
+    test_multilinestring()
+    test_polygon_collection()
+    test_point_collection()
+    test_linestring_collection()
+    test_mixed_collection()
diff --git a/flopy/export/shapefile_utils.py b/flopy/export/shapefile_utils.py
index b0dd7fc264..f09c752923 100755
--- a/flopy/export/shapefile_utils.py
+++ b/flopy/export/shapefile_utils.py
@@ -90,7 +90,12 @@ def write_gridlines_shapefile(filename, mg):
 
 
 def write_grid_shapefile(
-    filename, mg, array_dict, nan_val=np.nan, epsg=None, prj=None  # -1.0e9,
+    filename,
+    mg,
+    array_dict,
+    nan_val=np.nan,
+    epsg=None,
+    prj=None,  # -1.0e9,
 ):
     """
     Method to write a shapefile of gridded input data
@@ -357,7 +362,8 @@ def model_attributes_to_shapefile(
                             for ilay in range(a.model.modelgrid.nlay):
                                 u2d = a[ilay]
                                 name = "{}_{}".format(
-                                    shape_attr_name(u2d.name), ilay + 1
+                                    shape_attr_name(u2d.name),
+                                    ilay + 1,
                                 )
                                 arr = u2d.array
                                 assert arr.shape == horz_shape
@@ -463,7 +469,12 @@ def get_pyshp_field_info(dtypename):
 
 def get_pyshp_field_dtypes(code):
     """Returns a numpy dtype for a pyshp field type."""
-    dtypes = {"N": np.int, "F": np.float, "L": np.bool, "C": np.object}
+    dtypes = {
+        "N": np.int,
+        "F": np.float,
+        "L": np.bool,
+        "C": np.object,
+    }
     return dtypes.get(code, np.object)
 
 
@@ -480,7 +491,7 @@ def shp2recarray(shpname):
     recarray : np.recarray
 
     """
-    from ..utils.geometry import shape
+    from ..utils.geospatial_utils import GeoSpatialCollection
 
     sf = import_shapefile(check_version=False)
 
@@ -489,7 +500,7 @@ def shp2recarray(shpname):
         (str(f[0]), get_pyshp_field_dtypes(f[1])) for f in sfobj.fields[1:]
     ]
 
-    geoms = [shape(s) for s in sfobj.iterShapes()]
+    geoms = GeoSpatialCollection(sfobj).flopy_geometry
     records = [
         tuple(r) + (geoms[i],) for i, r in enumerate(sfobj.iterRecords())
     ]
@@ -510,14 +521,18 @@ def recarray2shp(
 ):
     """
     Write a numpy record array to a shapefile, using a corresponding
-    list of geometries.
+    list of geometries. Method supports list of flopy geometry objects,
+    flopy Collection object, shapely Collection object, and geojson
+    Geometry Collection objects
 
     Parameters
     ----------
     recarray : np.recarray
         Numpy record array with attribute information that will go in the
         shapefile
-    geoms : list of flopy.utils.geometry objects
+    geoms : list of flopy.utils.geometry, shapely geometry collection,
+            flopy geometry collection, shapefile.Shapes,
+            list of shapefile.Shape objects, or geojson geometry collection
         The number of geometries in geoms must equal the number of records in
         recarray.
     shpname : str
@@ -536,6 +551,7 @@ def recarray2shp(
     subsequent use. See flopy.reference for more details.
 
     """
+    from ..utils.geospatial_utils import GeoSpatialCollection
 
     if len(recarray) != len(geoms):
         raise IndexError(
@@ -546,6 +562,9 @@ def recarray2shp(
         raise Exception("Recarray is empty")
 
     geomtype = None
+
+    geoms = GeoSpatialCollection(geoms).flopy_geometry
+
     for g in geoms:
         try:
             geomtype = g.shapeType
@@ -722,7 +741,10 @@ def grid_mapping_attribs(self):
         if self.wktstr is not None:
             sp = [
                 p
-                for p in [self.standard_parallel_1, self.standard_parallel_2]
+                for p in [
+                    self.standard_parallel_1,
+                    self.standard_parallel_2,
+                ]
                 if p is not None
             ]
             sp = sp if len(sp) > 0 else None
@@ -797,7 +819,12 @@ def _getvalue(self, k):
             end = s[strt:].find("]") + strt
             try:
                 return float(self.wktstr[strt:end].split(",")[1])
-            except (IndexError, TypeError, ValueError, AttributeError):
+            except (
+                IndexError,
+                TypeError,
+                ValueError,
+                AttributeError,
+            ):
                 pass
 
     def _getgcsparam(self, txt):
diff --git a/flopy/utils/geometry.py b/flopy/utils/geometry.py
index fc8633a77c..609f2abb03 100644
--- a/flopy/utils/geometry.py
+++ b/flopy/utils/geometry.py
@@ -4,7 +4,307 @@
 import numpy as np
 
 
-class Polygon:
+class Shape(object):
+    """
+    Parent class for handling geo interfacing, do not instantiate directly
+
+    Parameters:
+    ----------
+    type : str
+        shapetype string
+    coordinates : list or tuple
+        list of tuple of point or linestring coordinates
+    exterior : list or tuple
+        2d list of polygon coordinates
+    interiors : list or tuple
+        2d or 3d list of polygon interiors
+
+    """
+
+    def __init__(
+        self,
+        shapetype,
+        coordinates=None,
+        exterior=None,
+        interiors=None,
+    ):
+        self.__type = shapetype
+
+        if shapetype == "Polygon":
+            self.exterior = tuple(map(tuple, exterior))
+            self.interiors = (
+                tuple()
+                if interiors is None
+                else (tuple(map(tuple, i)) for i in interiors)
+            )
+            self.interiors = tuple(self.interiors)
+
+        elif shapetype == "LineString":
+            self.coords = list(map(tuple, coordinates))
+            if len(self.coords[0]) == 3:
+                self.has_z = True
+
+        elif shapetype == "Point":
+            while len(coordinates) == 1:
+                coordinates = coordinates[0]
+
+            self.coords = coordinates
+            if len(coordinates) == 3:
+                self.has_z = True
+        else:
+            err = (
+                "Supported shape types are Polygon, LineString, "
+                "and Point: Supplied shape type {}".format(shapetype)
+            )
+            raise TypeError(err)
+
+    @property
+    def __geo_interface__(self):
+        """
+        Creates the geojson standard representation of a shape
+
+        Returns
+        -------
+            dict
+        """
+        geo_interface = {}
+
+        if self.__type == "Polygon":
+            geo_interface = {
+                "coordinates": tuple(
+                    [self.exterior] + [i for i in self.interiors]
+                ),
+                "type": self.__type,
+            }
+
+        elif self.__type == "LineString":
+            geo_interface = {
+                "coordinates": tuple(self.coords),
+                "type": self.__type,
+            }
+
+        elif self.__type == "Point":
+            geo_interface = {
+                "coordinates": tuple(self.coords),
+                "type": self.__type,
+            }
+
+        return geo_interface
+
+    @property
+    def geojson(self):
+        return self.__geo_interface__
+
+    @staticmethod
+    def from_geojson(geo_interface):
+        """
+        Method to load from geojson
+
+        Parameters
+        ----------
+        geo_interface : geojson, dict
+            geojson compliant representation of a linestring
+
+        Returns
+        -------
+            Polygon, LineString, or Point
+        """
+        if geo_interface["type"] in ("Polygon", "MultiPolygon"):
+            coord_list = geo_interface["coordinates"]
+            if geo_interface["type"] == "Polygon":
+                coord_list = [coord_list]
+
+            geoms = []
+            for coords in coord_list:
+                exteriors = coords[0]
+                interiors = None
+                if len(coords) > 1:
+                    interiors = coords[1:]
+
+                geoms.append(Polygon(exteriors, interiors))
+
+            if len(geoms) == 1:
+                shape = geoms[0]
+            else:
+                shape = MultiPolygon(geoms)
+
+        elif geo_interface["type"] == "LineString":
+            shape = LineString(geo_interface["coordinates"])
+
+        elif geo_interface["type"] == "MultiLineString":
+            geoms = [
+                LineString(coords) for coords in geo_interface["coordinates"]
+            ]
+            shape = MultiLineString(geoms)
+
+        elif geo_interface["type"] == "Point":
+            shape = Point(geo_interface["coordinates"])
+
+        elif geo_interface["type"] == "MultiPoint":
+            geoms = [Point(coords) for coords in geo_interface["coordinates"]]
+            shape = MultiPoint(geoms)
+
+        else:
+            err = (
+                "Supported shape types are Polygon, LineString, and "
+                "Point: Supplied shape type {}".format(geo_interface["type"])
+            )
+            raise TypeError(err)
+
+        return shape
+
+
+class Collection(list):
+    """
+    The collection object is container for a group of flopy geometries
+
+    This class acts as a base class for MultiPoint, MultiLineString, and
+    MultiPolygon classes. This class can also accept a mix of geometries
+    and act as a stand alone container.
+
+    Parameters
+    ----------
+    geometries : list
+        list of flopy.util.geometry objects
+
+    """
+
+    def __init__(self, geometries=()):
+        super(Collection, self).__init__(geometries)
+
+    def __repr__(self):
+        return "Shapes: {}".format(list(self))
+
+    @property
+    def __geo_interface__(self):
+        return {
+            "type": "GeometryCollection",
+            "geometries": [g.__geo_interface__ for g in self],
+        }
+
+    @property
+    def bounds(self):
+        """
+        Method to calculate the bounding box of the collection
+
+        Returns
+        -------
+            tuple (xmin, ymin, xmax, ymax)
+        """
+        bbox = [geom.bounds for geom in self]
+        xmin, ymin = np.min(bbox, axis=0)[0:2]
+        xmax, ymax = np.max(bbox, axis=0)[2:]
+
+        return xmin, ymin, xmax, ymax
+
+    def plot(self, ax=None, **kwargs):
+        """
+        Plotting method for collection
+
+        Parameters
+        ----------
+        ax : matplotlib.axes object
+        kwargs : keyword arguments
+            matplotlib keyword arguments
+
+        Returns
+        -------
+            matplotlib.axes object
+        """
+        for g in self:
+            ax = g.plot(ax=ax, **kwargs)
+
+        xmin, ymin, xmax, ymax = self.bounds
+        ax.set_ylim([ymin - 0.005, ymax + 0.005])
+        ax.set_xlim([xmin - 0.005, xmax + 0.005])
+        return ax
+
+
+class MultiPolygon(Collection):
+    """
+    Container for housing and describing multipolygon geometries (e.g. to be
+        read or written to shapefiles or other geographic data formats)
+
+    Parameters:
+    ----------
+    polygons : list
+        list of flopy.utils.geometry.Polygon objects
+    """
+
+    def __init__(self, polygons=()):
+        for p in polygons:
+            if not isinstance(p, Polygon):
+                raise TypeError("Only Polygon instances are supported")
+            super(MultiPolygon, self).__init__(polygons)
+
+    def __repr__(self):
+        return "MultiPolygon: {}".format(list(self))
+
+    @property
+    def __geo_interface__(self):
+        return {
+            "type": "MultiPolygon",
+            "coordinates": [g.__geo_interface__["coordinates"] for g in self],
+        }
+
+
+class MultiLineString(Collection):
+    """
+    Container for housing and describing multilinestring geometries (e.g. to be
+        read or written to shapefiles or other geographic data formats)
+
+    Parameters:
+    ----------
+    polygons : list
+        list of flopy.utils.geometry.LineString objects
+    """
+
+    def __init__(self, linestrings=()):
+        for l in linestrings:
+            if not isinstance(l, LineString):
+                raise TypeError("Only LineString instances are supported")
+            super(MultiLineString, self).__init__(linestrings)
+
+    def __repr__(self):
+        return "LineString: {}".format(list(self))
+
+    @property
+    def __geo_interface__(self):
+        return {
+            "type": "MultiLineString",
+            "coordinates": [g.__geo_interface__["coordinates"] for g in self],
+        }
+
+
+class MultiPoint(Collection):
+    """
+    Container for housing and describing multipoint geometries (e.g. to be
+        read or written to shapefiles or other geographic data formats)
+
+    Parameters:
+    ----------
+    polygons : list
+        list of flopy.utils.geometry.Point objects
+    """
+
+    def __init__(self, points=()):
+        for p in points:
+            if not isinstance(p, Point):
+                raise TypeError("Only Point instances are supported")
+            super(MultiPoint, self).__init__(points)
+
+    def __repr__(self):
+        return "MultiPoint: {}".format(list(self))
+
+    @property
+    def __geo_interface__(self):
+        return {
+            "type": "MultiPoint",
+            "coordinates": [g.__geo_interface__["coordinates"] for g in self],
+        }
+
+
+class Polygon(Shape):
     type = "Polygon"
     shapeType = 5  # pyshp
 
@@ -48,11 +348,11 @@ def __init__(self, exterior, interiors=None):
         Multi-polygons not yet supported.
         z information is only stored if it was entered.
         """
-        self.exterior = tuple(map(tuple, exterior))
-        self.interiors = (
-            tuple()
-            if interiors is None
-            else (map(tuple, i) for i in interiors)
+        super(Polygon, self).__init__(
+            self.type,
+            coordinates=None,
+            exterior=exterior,
+            interiors=interiors,
         )
 
     def __eq__(self, other):
@@ -80,15 +380,6 @@ def bounds(self):
         xmax = np.max(self._exterior_x)
         return xmin, ymin, xmax, ymax
 
-    @property
-    def geojson(self):
-        return {
-            "coordinates": tuple(
-                [self.exterior] + [i for i in self.interiors]
-            ),
-            "type": self.type,
-        }
-
     @property
     def pyshp_parts(self):
         from ..export.shapefile_utils import import_shapefile
@@ -96,7 +387,7 @@ def pyshp_parts(self):
         # exterior ring must be clockwise (negative area)
         # interiors rings must be counter-clockwise (positive area)
 
-        shapefile = import_shapefile(check_version=False)
+        shapefile = import_shapefile()
 
         exterior = list(self.exterior)
         if shapefile.signed_area(exterior) > 0:
@@ -140,21 +431,22 @@ def plot(self, ax=None, **kwargs):
             import matplotlib.pyplot as plt
         except ImportError:
             print("This feature requires matplotlib.")
+
         if ax is None:
-            fig, ax = plt.subplots()
-        else:
-            fig = ax.figure
+            ax = plt.gca()
+
         try:
             ax.add_patch(self.get_patch(**kwargs))
             xmin, ymin, xmax, ymax = self.bounds
             ax.set_xlim(xmin, xmax)
             ax.set_ylim(ymin, ymax)
-            plt.show()
         except:
             print("could not plot polygon feature")
 
+        return ax
+
 
-class LineString:
+class LineString(Shape):
     type = "LineString"
     shapeType = 3
     has_z = False
@@ -192,9 +484,7 @@ def __init__(self, coordinates):
         z information is only stored if it was entered.
 
         """
-        self.coords = list(map(tuple, coordinates))
-        if len(self.coords[0]) == 3:
-            self.has_z = True
+        super(LineString, self).__init__(self.type, coordinates)
 
     def __eq__(self, other):
         if not isinstance(other, LineString):
@@ -227,10 +517,6 @@ def bounds(self):
         xmax = np.max(self.x)
         return xmin, ymin, xmax, ymax
 
-    @property
-    def geojson(self):
-        return {"coordinates": tuple(self.coords), "type": self.type}
-
     @property
     def pyshp_parts(self):
         return [self.coords]
@@ -240,18 +526,19 @@ def plot(self, ax=None, **kwargs):
             import matplotlib.pyplot as plt
         except ImportError:
             print("This feature requires matplotlib.")
+
         if ax is None:
-            fig, ax = plt.subplots()
-        else:
-            fig = ax.figure
-        plt.plot(self.x, self.y, **kwargs)
+            ax = plt.gca()
+
+        ax.plot(self.x, self.y, **kwargs)
         xmin, ymin, xmax, ymax = self.bounds
         ax.set_xlim(xmin, xmax)
         ax.set_ylim(ymin, ymax)
-        # plt.show()
+
+        return ax
 
 
-class Point:
+class Point(Shape):
     type = "Point"
     shapeType = 1
     has_z = False
@@ -296,12 +583,7 @@ def __init__(self, *coordinates):
         -----
         z information is only stored if it was entered.
         """
-        while len(coordinates) == 1:
-            coordinates = coordinates[0]
-
-        self.coords = coordinates
-        if len(coordinates) == 3:
-            self.has_z = True
+        super(Point, self).__init__(self.type, coordinates)
 
     def __eq__(self, other):
         if not isinstance(other, Point):
@@ -334,10 +616,6 @@ def bounds(self):
         xmax = np.max(self.x)
         return xmin, ymin, xmax, ymax
 
-    @property
-    def geojson(self):
-        return {"coordinates": tuple(self.coords), "type": self.type}
-
     @property
     def pyshp_parts(self):
         return self.coords
@@ -347,15 +625,17 @@ def plot(self, ax=None, **kwargs):
             import matplotlib.pyplot as plt
         except ImportError:
             print("This feature requires matplotlib.")
+
         if ax is None:
-            fig, ax = plt.subplots()
-        else:
-            fig = ax.figure
-        plt.scatter(self.x, self.y, **kwargs)
+            ax = plt.gca()
+
+        ax.scatter(self.x, self.y, **kwargs)
         xmin, ymin, xmax, ymax = self.bounds
         ax.set_xlim(xmin - 1, xmax + 1)  # singular bounds otherwise
         ax.set_ylim(ymin - 1, ymax + 1)
 
+        return ax
+
 
 def rotate(x, y, xoff, yoff, angrot_radians):
     """
@@ -383,7 +663,13 @@ def rotate(x, y, xoff, yoff, angrot_radians):
 
 
 def transform(
-    x, y, xoff, yoff, angrot_radians, length_multiplier=1.0, inverse=False
+    x,
+    y,
+    xoff,
+    yoff,
+    angrot_radians,
+    length_multiplier=1.0,
+    inverse=False,
 ):
     """
     Given x and y array-like values calculate the translation about an
@@ -439,19 +725,31 @@ def shape(pyshp_shpobj):
     >>> flopy_geom = shape(list(sfobj.iterShapes())[0])
 
     """
-    types = {5: Polygon, 3: LineString, 1: Point}
-    flopy_geometype = types[pyshp_shpobj.shapeType]
-    return flopy_geometype(pyshp_shpobj.points)
+    import warnings
+
+    warnings.warn(
+        "Method will be Deprecated, calling GeoSpatialUtil",
+        DeprecationWarning,
+    )
 
+    from .geospatial_utils import GeoSpatialUtil
 
-def get_polygon_area(verts):
+    return GeoSpatialUtil(pyshp_shpobj).flopy_geometry
+
+
+def get_polygon_area(geom):
     """
     Calculate the area of a closed polygon
 
     Parameters
     ----------
-    verts : numpy.ndarray
-        polygon vertices
+    geom : geospatial representation of polygon
+        accepted types:
+
+        vertices np.array([(x, y),....])
+        geojson.Polygon
+        shapely.Polygon
+        shapefile.Shape
 
     Returns
     -------
@@ -459,6 +757,14 @@ def get_polygon_area(verts):
         area of polygon centroid
 
     """
+    from .geospatial_utils import GeoSpatialUtil
+
+    if isinstance(geom, (list, tuple, np.ndarray)):
+        geom = [geom]
+
+    geom = GeoSpatialUtil(geom, shapetype="Polygon")
+    verts = np.array(geom.points[0])
+
     nverts = verts.shape[0]
     a = 0.0
     for iv in range(nverts - 1):
@@ -471,14 +777,19 @@ def get_polygon_area(verts):
     return a
 
 
-def get_polygon_centroid(verts):
+def get_polygon_centroid(geom):
     """
     Calculate the centroid of a closed polygon
 
     Parameters
     ----------
-    verts : numpy.ndarray
-        polygon vertices
+    geom : geospatial representation of polygon
+        accepted types:
+
+        vertices np.array([(x, y),....])
+        geojson.Polygon
+        shapely.Polygon
+        shapefile.Shape
 
     Returns
     -------
@@ -486,6 +797,14 @@ def get_polygon_centroid(verts):
         (x, y) of polygon centroid
 
     """
+    from .geospatial_utils import GeoSpatialUtil
+
+    if isinstance(geom, (list, tuple, np.ndarray)):
+        geom = [geom]
+
+    geom = GeoSpatialUtil(geom, shapetype="Polygon")
+    verts = np.array(geom.points[0])
+
     nverts = verts.shape[0]
     cx = 0.0
     cy = 0.0
@@ -502,16 +821,20 @@ def get_polygon_centroid(verts):
     return cx, cy
 
 
-def is_clockwise(x, y):
+def is_clockwise(*geom):
     """
     Determine if a ring is defined clockwise
 
     Parameters
     ----------
-    x : numpy ndarray
-        The x-coordinates of the ring
-    y : numpy ndarray
-        The y-coordinate of the ring
+    *geom : geospatial representation of polygon
+        accepted types:
+
+        vertices [(x, y),....]
+        geojson.Polygon
+        shapely.Polygon
+        shapefile.Shape
+        x and y vertices: [x1, x2, x3], [y1, y2, y3]
 
     Returns
     -------
@@ -519,6 +842,14 @@ def is_clockwise(x, y):
         True when the ring is defined clockwise, False otherwise
 
     """
+    from .geospatial_utils import GeoSpatialUtil
+
+    if len(geom) == 2:
+        x, y = geom
+    else:
+        geom = GeoSpatialUtil(geom, shapetype="Polygon")
+        x, y = np.array(geom.points[0]).T
+
     if not (x[0] == x[-1]) and (y[0] == y[-1]):
         # close the ring if needed
         x = np.append(x, x[-1])
diff --git a/flopy/utils/geospatial_utils.py b/flopy/utils/geospatial_utils.py
new file mode 100644
index 0000000000..b201af9841
--- /dev/null
+++ b/flopy/utils/geospatial_utils.py
@@ -0,0 +1,435 @@
+try:
+    import shapely
+    from shapely.geometry import (
+        MultiPolygon,
+        Polygon,
+        Point,
+        MultiPoint,
+        LineString,
+        MultiLineString,
+    )
+except ImportError:
+    shapely = None
+
+try:
+    import geojson
+except ImportError:
+    geojson = None
+
+import numpy as np
+from flopy.utils.geometry import Shape, Collection
+
+
+geojson_classes = {}
+if geojson is not None:
+    geojson_classes = {
+        "polygon": geojson.Polygon,
+        "multipolygon": geojson.MultiPolygon,
+        "point": geojson.Point,
+        "multipoint": geojson.MultiPoint,
+        "linestring": geojson.LineString,
+        "multilinestring": geojson.MultiLineString,
+    }
+
+shape_types = {
+    "multipolygon": "MultiPolygon",
+    "polygon": "Polygon",
+    "point": "Point",
+    "multipoint": "MultiPoint",
+    "linestring": "LineString",
+    "multilinestring": "MultiLineString",
+}
+
+
+class GeoSpatialUtil(object):
+    """
+    Geospatial utils are a unifying method to provide conversion between
+    commonly used geospatial input types
+
+    Parameters
+    ----------
+    obj : geospatial object
+        obj can accept any of the following objects:
+            shapefile.Shape object
+            flopy.utils.geometry objects
+            list of vertices
+            geojson geometry objects
+            shapely.geometry objects
+
+    shapetype : str
+        shapetype is required when a list of vertices is supplied for obj
+
+    """
+
+    def __init__(self, obj, shapetype=None):
+        from ..export.shapefile_utils import import_shapefile
+
+        self.__shapefile = import_shapefile()
+        self.__obj = obj
+        self.__geo_interface = {}
+        self._geojson = None
+        self._shapely = None
+        self._shape = None
+        self._flopy_geometry = None
+        self._points = None
+        self.__shapetype = None
+
+        if shapetype is not None:
+            shapetype = shapetype.lower()
+
+        if isinstance(obj, self.__shapefile.Shape):
+            self.__geo_interface = self.__obj.__geo_interface__
+
+        elif isinstance(obj, (Shape, Collection)):
+            geo_interface = obj.__geo_interface__
+            if geo_interface["type"] == "GeometryCollection":
+                raise TypeError("GeometryCollections are not supported")
+
+            self.__geo_interface = geo_interface
+
+        elif isinstance(obj, (np.ndarray, list, tuple)):
+            if shapetype is None or shapetype not in shape_types:
+                err = "shapetype must be one of the following: " + " , ".join(
+                    geojson_classes.keys()
+                )
+                raise AssertionError(err)
+
+            self.__geo_interface = {
+                "type": shape_types[shapetype],
+                "coordinates": list(obj),
+            }
+
+        if geojson is not None:
+            if isinstance(obj, geojson.Feature):
+                self.__geo_interface = {
+                    "type": obj.geometry.type,
+                    "coordinates": obj.geometry.coordinates,
+                }
+
+            elif isinstance(
+                obj,
+                (
+                    geojson.Point,
+                    geojson.MultiPoint,
+                    geojson.Polygon,
+                    geojson.MultiPolygon,
+                    geojson.LineString,
+                    geojson.MultiLineString,
+                ),
+            ):
+                self.__geo_interface = {
+                    "type": obj.type,
+                    "coordinates": obj.coordinates,
+                }
+
+        if shapely is not None:
+            if isinstance(
+                obj,
+                (
+                    Point,
+                    MultiPoint,
+                    Polygon,
+                    MultiPolygon,
+                    LineString,
+                    MultiLineString,
+                ),
+            ):
+                self.__geo_interface = obj.__geo_interface__
+
+    @property
+    def __geo_interface__(self):
+        """
+        Geojson standard representation of a geometry
+
+        Returns
+        -------
+            dict
+        """
+        return self.__geo_interface
+
+    @property
+    def shapetype(self):
+        """
+        Shapetype string for a geometry
+
+        Returns
+        -------
+            str
+        """
+        if self.__shapetype is None:
+            self.__shapetype = self.__geo_interface["type"]
+        return self.__shapetype
+
+    @property
+    def points(self):
+        """
+        Returns a list of vertices to the user
+
+        Returns
+        -------
+            list
+        """
+        if self._points is None:
+            self._points = self.__geo_interface["coordinates"]
+        return self._points
+
+    @property
+    def shapely(self):
+        """
+        Returns a shapely.geometry object to the user
+
+        Returns
+        -------
+            shapely.geometry.<shape>
+        """
+        if shapely is not None:
+            if self._shapely is None:
+                self._shapely = shapely.geometry.shape(self.__geo_interface)
+            return self._shapely
+
+    @property
+    def geojson(self):
+        """
+        Returns a geojson object to the user
+
+        Returns
+        -------
+            geojson.<shape>
+        """
+        if geojson is not None:
+            if self._geojson is None:
+                cls = geojson_classes[self.__geo_interface["type"].lower()]
+                self._geojson = cls(self.__geo_interface["coordinates"])
+            return self._geojson
+
+    @property
+    def shape(self):
+        """
+        Returns a shapefile.Shape object to the user
+
+        Returns
+        -------
+            shapefile.shape
+        """
+        if self._shape is None:
+            self._shape = self.__shapefile.Shape._from_geojson(
+                self.__geo_interface
+            )
+        return self._shape
+
+    @property
+    def flopy_geometry(self):
+        """
+        Returns a flopy geometry object to the user
+
+        Returns
+        -------
+            flopy.utils.geometry.<Shape>
+        """
+        if self._flopy_geometry is None:
+            self._flopy_geometry = Shape.from_geojson(self.__geo_interface)
+        return self._flopy_geometry
+
+
+class GeoSpatialCollection(object):
+    """
+    The GeoSpatialCollection class allows a user to convert between
+    Collection objects from common geospatial libraries.
+
+    Parameters
+    ----------
+    obj : collection object
+        obj can accept the following types
+
+        str : shapefile name
+        shapefile.Reader object
+        list of [shapefile.Shape, shapefile.Shape,]
+        shapefile.Shapes object
+        flopy.utils.geometry.Collection object
+        list of [flopy.utils.geometry, ...] objects
+        geojson.GeometryCollection object
+        geojson.FeatureCollection object
+        shapely.GeometryCollection object
+        list of [[vertices], ...]
+
+    shapetype : list
+        optional list of shapetypes that is required when vertices are
+        supplied to the class as the obj parameter
+
+    """
+
+    def __init__(self, obj, shapetype=None):
+        from ..export.shapefile_utils import import_shapefile
+
+        self.__shapefile = import_shapefile()
+        self.__obj = obj
+        self.__collection = []
+        self._geojson = None
+        self._shapely = None
+        self._shape = None
+        self._flopy_geometry = None
+        self._points = None
+        self.__shapetype = None
+
+        if isinstance(obj, str):
+            with self.__shapefile.Reader(obj) as r:
+                for shape in r.shapes():
+                    self.__collection.append(GeoSpatialUtil(shape))
+
+        elif isinstance(obj, self.__shapefile.Reader):
+            for shape in obj.shapes():
+                self.__collection.append(GeoSpatialUtil(shape))
+
+        elif isinstance(obj, self.__shapefile.Shapes):
+            for shape in obj:
+                self.__collection.append(GeoSpatialUtil(shape))
+
+        elif isinstance(obj, Collection):
+            for shape in obj:
+                self.__collection.append(GeoSpatialUtil(shape))
+
+        elif isinstance(obj, (np.ndarray, list, tuple)):
+            if isinstance(obj[0], (Shape, Collection, self.__shapefile.Shape)):
+                for shape in obj:
+                    self.__collection.append(GeoSpatialUtil(shape))
+
+            else:
+                if shapetype is None:
+                    err = "a list of shapetypes must be provided"
+                    raise AssertionError(err)
+
+                elif isinstance(shapetype, str):
+                    shapetype = [shapetype] * len(obj)
+
+                for ix, geom in enumerate(obj):
+                    self.__collection.append(
+                        GeoSpatialUtil(geom, shapetype[ix])
+                    )
+
+        if geojson is not None:
+            if isinstance(
+                obj,
+                (
+                    geojson.GeometryCollection,
+                    geojson.FeatureCollection,
+                    geojson.MultiLineString,
+                    geojson.MultiPoint,
+                    geojson.MultiPolygon,
+                ),
+            ):
+                for geom in obj.geometries:
+                    self.__collection.append(GeoSpatialUtil(geom))
+
+        if shapely is not None:
+            if isinstance(
+                obj,
+                (
+                    shapely.geometry.collection.GeometryCollection,
+                    MultiPoint,
+                    MultiLineString,
+                    MultiPolygon,
+                ),
+            ):
+                for geom in list(obj):
+                    self.__collection.append(GeoSpatialUtil(geom))
+
+    def __iter__(self):
+        """
+        Iterator method that allows the user to get a list of GeoSpatialUtil
+        objects from the GeoSpatialCollection object
+
+        Returns
+        -------
+            GeoSpatialUtil
+        """
+        yield from self.__collection
+
+    @property
+    def shapetype(self):
+        """
+        Returns a list of shapetypes to the user
+
+        Returns
+        -------
+            list of str
+        """
+        if self.__shapetype is None:
+            self.__shapetype = [i.shapetype for i in self.__collection]
+        return self.__shapetype
+
+    @property
+    def points(self):
+        """
+        Property returns a multidimensional list of vertices
+
+        Returns
+        -------
+            list of vertices
+        """
+        if self._points is None:
+            self._points = [i.points for i in self.__collection]
+        return self._points
+
+    @property
+    def shapely(self):
+        """
+        Property that returns a shapely.geometry.collection.GeometryCollection
+        object to the user
+
+        Returns
+        -------
+            shapely.geometry.collection.GeometryCollection object
+        """
+        if shapely is not None:
+            if self._shapely is None:
+                self._shapely = shapely.geometry.collection.GeometryCollection(
+                    [i.shapely for i in self.__collection]
+                )
+
+        return self._shapely
+
+    @property
+    def geojson(self):
+        """
+        Property that returns a geojson.GeometryCollection object to the user
+
+        Returns
+        -------
+            geojson.GeometryCollection
+        """
+        if geojson is not None:
+            if self._geojson is None:
+                self._geojson = geojson.GeometryCollection(
+                    [i.geojson for i in self.__collection]
+                )
+        return self._geojson
+
+    @property
+    def shape(self):
+        """
+        Property that returns a shapefile.Shapes object
+
+        Returns
+        -------
+            shapefile.Shapes object
+        """
+        if self._shape is None:
+            self._shape = self.__shapefile.Shapes()
+            for geom in self.__collection:
+                self._shape.append(geom.shape)
+        return self._shape
+
+    @property
+    def flopy_geometry(self):
+        """
+        Property that returns a flopy.util.geometry.Collection object
+
+        Returns
+        -------
+            flopy.util.geometry.Collectionnos object
+        """
+        if self._flopy_geometry is None:
+            self._flopy_geometry = Collection(
+                [i.flopy_geometry for i in self.__collection]
+            )
+        return self._flopy_geometry
diff --git a/flopy/utils/gridgen.py b/flopy/utils/gridgen.py
index 5cd3deb8e6..06303910b6 100644
--- a/flopy/utils/gridgen.py
+++ b/flopy/utils/gridgen.py
@@ -40,9 +40,16 @@ def features_to_shapefile(features, featuretype, filename):
     Parameters
     ----------
     features : list
-        List of point, line, or polygon features
+        point, line, or polygon features. Method accepts
+        feature can be:
+             a list of geometries
+             flopy.utils.geometry.Collection object
+             shapely.geometry.Collection object
+             geojson.GeometryCollection object
+             list of shapefile.Shape objects
+             shapefile.Shapes object
     featuretype : str
-        Must be 'point', 'line', or 'polygon'
+        Must be 'point', 'line', 'linestring', or 'polygon'
     filename : string
         name of the shapefile to write
 
@@ -51,30 +58,42 @@ def features_to_shapefile(features, featuretype, filename):
     None
 
     """
+    from .geospatial_utils import GeoSpatialCollection
+
     shapefile = import_shapefile(check_version=True)
 
-    if featuretype.lower() not in ["point", "line", "polygon"]:
+    if featuretype.lower() == "line":
+        featuretype = "LineString"
+
+    features = GeoSpatialCollection(features, featuretype).flopy_geometry
+
+    if featuretype.lower() not in [
+        "point",
+        "line",
+        "linestring",
+        "polygon",
+    ]:
         raise Exception("Unrecognized feature type: {}".format(featuretype))
 
-    if featuretype.lower() == "line":
+    if featuretype.lower() in ("line", "linestring"):
         wr = shapefile.Writer(filename, shapeType=shapefile.POLYLINE)
         wr.field("SHAPEID", "N", 20, 0)
         for i, line in enumerate(features):
-            wr.line(line)
+            wr.line(line.__geo_interface__["coordinates"])
             wr.record(i)
 
     elif featuretype.lower() == "point":
         wr = shapefile.Writer(filename, shapeType=shapefile.POINT)
         wr.field("SHAPEID", "N", 20, 0)
         for i, point in enumerate(features):
-            wr.point(point[0], point[1])
+            wr.point(*point.__geo_interface__["coordinates"])
             wr.record(i)
 
     elif featuretype.lower() == "polygon":
         wr = shapefile.Writer(filename, shapeType=shapefile.POLYGON)
         wr.field("SHAPEID", "N", 20, 0)
         for i, polygon in enumerate(features):
-            wr.poly(polygon)
+            wr.poly(polygon.__geo_interface__["coordinates"])
             wr.record(i)
 
     wr.close()
@@ -270,8 +289,14 @@ def add_active_domain(self, feature, layers):
         Parameters
         ----------
         feature : str or list
-            feature can be either a string containing the name of a polygon
-            shapefile or it can be a list of polygons
+            feature can be:
+                 a string containing the name of a polygon
+                 a list of polygons
+                 flopy.utils.geometry.Collection object of Polygons
+                 shapely.geometry.Collection object of Polygons
+                 geojson.GeometryCollection object of Polygons
+                 list of shapefile.Shape objects
+                 shapefile.Shapes object
         layers : list
             A list of layers (zero based) for which this active domain
             applies.
@@ -308,9 +333,16 @@ def add_refinement_features(self, features, featuretype, level, layers):
         """
         Parameters
         ----------
-        features : str or list
-            features can be either a string containing the name of a shapefile
-            or it can be a list of points, lines, or polygons
+        features : str, list, or collection object
+            features can be
+                a string containing the name of a shapefile
+                a list of points, lines, or polygons
+                flopy.utils.geometry.Collection object
+                a list of flopy.utils.geometry objects
+                shapely.geometry.Collection object
+                geojson.GeometryCollection object
+                a list of shapefile.Shape objects
+                shapefile.Shapes object
         featuretype : str
             Must be either 'point', 'line', or 'polygon'
         level : int
@@ -385,7 +417,11 @@ def build(self, verbose=False):
         qtgfname = os.path.join(self.model_ws, "quadtreegrid.dfn")
         if os.path.isfile(qtgfname):
             os.remove(qtgfname)
-        cmds = [self.exe_name, "quadtreebuilder", "_gridgen_build.dfn"]
+        cmds = [
+            self.exe_name,
+            "quadtreebuilder",
+            "_gridgen_build.dfn",
+        ]
         buff = subprocess.check_output(cmds, cwd=self.model_ws)
         if verbose:
             print(buff)
@@ -473,7 +509,11 @@ def export(self, verbose=False):
         ), "Could not create export dfn file: {}".format(fname)
 
         # Export shapefiles
-        cmds = [self.exe_name, "grid_to_shapefile_poly", "_gridgen_export.dfn"]
+        cmds = [
+            self.exe_name,
+            "grid_to_shapefile_poly",
+            "_gridgen_export.dfn",
+        ]
         buff = []
         try:
             buff = subprocess.check_output(cmds, cwd=self.model_ws)
@@ -482,7 +522,10 @@ def export(self, verbose=False):
             fn = os.path.join(self.model_ws, "qtgrid.shp")
             assert os.path.isfile(fn)
         except:
-            print("Error.  Failed to export polygon shapefile of grid", buff)
+            print(
+                "Error.  Failed to export polygon shapefile of grid",
+                buff,
+            )
 
         cmds = [
             self.exe_name,
@@ -497,10 +540,17 @@ def export(self, verbose=False):
             fn = os.path.join(self.model_ws, "qtgrid_pt.shp")
             assert os.path.isfile(fn)
         except:
-            print("Error.  Failed to export polygon shapefile of grid", buff)
+            print(
+                "Error.  Failed to export polygon shapefile of grid",
+                buff,
+            )
 
         # Export the usg data
-        cmds = [self.exe_name, "grid_to_usgdata", "_gridgen_export.dfn"]
+        cmds = [
+            self.exe_name,
+            "grid_to_usgdata",
+            "_gridgen_export.dfn",
+        ]
         buff = []
         try:
             buff = subprocess.check_output(cmds, cwd=self.model_ws)
@@ -523,7 +573,11 @@ def export(self, verbose=False):
         except:
             print("Error.  Failed to export vtk file", buff)
 
-        cmds = [self.exe_name, "grid_to_vtk_sv", "_gridgen_export.dfn"]
+        cmds = [
+            self.exe_name,
+            "grid_to_vtk_sv",
+            "_gridgen_export.dfn",
+        ]
         buff = []
         try:
             buff = subprocess.check_output(cmds, cwd=self.model_ws)
@@ -532,7 +586,10 @@ def export(self, verbose=False):
             fn = os.path.join(self.model_ws, "qtg_sv.vtu")
             assert os.path.isfile(fn)
         except:
-            print("Error.  Failed to export shared vertex vtk file", buff)
+            print(
+                "Error.  Failed to export shared vertex vtk file",
+                buff,
+            )
 
         return
 
diff --git a/flopy/utils/gridintersect.py b/flopy/utils/gridintersect.py
index 83364755c2..5023a47294 100644
--- a/flopy/utils/gridintersect.py
+++ b/flopy/utils/gridintersect.py
@@ -6,6 +6,7 @@
     plt = None
 
 from .geometry import transform
+from .geospatial_utils import GeoSpatialUtil
 
 try:
     from shapely.geometry import (
@@ -155,6 +156,64 @@ def __init__(self, mfgrid, method=None, rtree=True):
                 )
             )
 
+    def intersect(self, shp, **kwargs):
+        """
+        Method to intersect a shape with a model grid
+
+        Parameters
+        ----------
+        shp : shapely.geometry, geojson object, shapefile.Shape,
+              or flopy geomerty object
+        sort_by_cellid : bool
+            Sort results by cellid
+        keepzerolengths : bool
+            boolean method to keep zero length intersections for
+            linestring intersection
+
+        Returns
+        -------
+        numpy.recarray
+            a record array containing information about the intersection
+        """
+        gu = GeoSpatialUtil(shp)
+        shp = gu.shapely
+        sort_by_cellid = kwargs.pop("sort_by_cellid", True)
+        keepzerolengths = kwargs.pop("keepzerolengths", False)
+
+        if gu.shapetype in ("Point", "MultiPoint"):
+            if (
+                self.method == "structured"
+                and self.mfgrid.grid_type == "structured"
+            ):
+                rec = self._intersect_point_structured(shp)
+            else:
+                rec = self._intersect_point_shapely(shp, sort_by_cellid)
+        elif gu.shapetype in ("LineString", "MultiLineString"):
+            if (
+                self.method == "structured"
+                and self.mfgrid.grid_type == "structured"
+            ):
+                rec = self._intersect_linestring_structured(
+                    shp, keepzerolengths
+                )
+            else:
+                rec = self._intersect_linestring_shapely(
+                    shp, keepzerolengths, sort_by_cellid
+                )
+        elif gu.shapetype in ("Polygon", "MultiPolygon"):
+            if (
+                self.method == "structured"
+                and self.mfgrid.grid_type == "structured"
+            ):
+                rec = self._intersect_polygon_structured(shp)
+            else:
+                rec = self._intersect_polygon_shapely(shp, sort_by_cellid)
+        else:
+            err = "Shapetype {} is not supported".format(gu.shapetype)
+            raise TypeError(err)
+
+        return rec
+
     def _set_method_get_gridshapes(self):
         """internal method, set self._get_gridshapes to the certain method for
         obtaining gridcells."""
@@ -557,7 +616,8 @@ def intersects(self, shp):
 
         Parameters
         ----------
-        shp : shapely.geometry
+        shp : shapely.geometry, geojson geometry, shapefile.shape,
+              or flopy geometry object
             shape to intersect with the grid
 
         Returns
@@ -567,6 +627,8 @@ def intersects(self, shp):
             the shape intersects with
         """
         # query grid
+        shp = GeoSpatialUtil(shp).shapely
+
         qresult = self.query_grid(shp)
         # filter result further if possible (only strtree and filter methods)
         qfiltered = self.filter_query_result(qresult, shp)
diff --git a/flopy/utils/rasters.py b/flopy/utils/rasters.py
index 7318398408..8bf8bfb004 100644
--- a/flopy/utils/rasters.py
+++ b/flopy/utils/rasters.py
@@ -15,11 +15,6 @@
 except ImportError:
     scipy = None
 
-try:
-    import shapely
-except ImportError:
-    shapely = None
-
 
 class Raster(object):
     """
@@ -234,17 +229,21 @@ def __xycenters(self):
         y = np.linspace(y1, y0, ylen)
         self.__xcenters, self.__ycenters = np.meshgrid(x, y)
 
-    def sample_point(self, x, y, band):
+    def sample_point(self, *point, band=1):
         """
         Method to get nearest raster value at a user provided
         point
 
         Parameters
         ----------
-        x : float
-            x coordinate
-        y : float
-            y coordinate
+        *point : point geometry representation
+            accepted data types:
+            x, y values : ex. sample_point(1, 3, band=1)
+            tuple of x, y: ex sample_point((1, 3), band=1)
+            shapely.geometry.Point
+            geojson.Point
+            flopy.geometry.Point
+
         band : int
             raster band to re-sample
 
@@ -252,6 +251,15 @@ def sample_point(self, x, y, band):
         -------
             value : float
         """
+        from .geospatial_utils import GeoSpatialUtil
+
+        if isinstance(point[0], (tuple, list, np.ndarray)):
+            point = point[0]
+
+        geom = GeoSpatialUtil(point, shapetype="Point")
+
+        x, y = geom.points
+
         # 1: get grid.
         rxc = self.xcenters
         ryc = self.ycenters
@@ -282,14 +290,14 @@ def sample_polygon(self, polygon, band, invert=False):
 
         Parameters
         ----------
-        polygon : (shapely.geometry.Polygon or GeoJSON-like dict)
-            The values should be a GeoJSON-like dict or object
-            implements the Python geo interface protocal.
+        polygon : list, geojson, shapely.geometry, shapefile.Shape
+            sample_polygon method accepts any of these geometries:
 
-            Alternatively if the user supplies the vectors
-            of a polygon in the format [(x0, y0), ..., (xn, yn)]
-            a single shapely polygon will be created for
-            cropping the data
+            a list of (x, y) points, ex. [(x1, y1), ...]
+            geojson Polygon object
+            shapely Polygon object
+            shapefile Polygon shape
+            flopy Polygon shape
 
         band : int
             raster band to re-sample
@@ -399,14 +407,14 @@ def crop(self, polygon, invert=False):
 
         Parameters
         ----------
-        polygon : (shapely.geometry.Polygon or GeoJSON-like dict)
-            The values should be a GeoJSON-like dict or object
-            implements the Python geo interface protocal.
+        polygon : list, geojson, shapely.geometry, shapefile.Shape
+            crop method accepts any of these geometries:
 
-            Alternatively if the user supplies the vectors
-            of a polygon in the format [(x0, y0), ..., (xn, yn)]
-            a single shapely polygon will be created for
-            cropping the data
+            a list of (x, y) points, ex. [(x1, y1), ...]
+            geojson Polygon object
+            shapely Polygon object
+            shapefile Polygon shape
+            flopy Polygon shape
 
         invert : bool
             Default value is False. If invert is True then the
@@ -519,14 +527,14 @@ def _sample_rio_dataset(self, polygon, invert):
 
         Parameters
         ----------
-        polygon : (shapely.geometry.Polygon or GeoJSON-like dict)
-            The values should be a GeoJSON-like dict or object
-            implements the Python geo interface protocal.
+        polygon : list, geojson, shapely.geometry, shapefile.Shape
+            _sample_rio_dataset method accepts any of these geometries:
 
-            Alternatively if the user supplies the vectors
-            of a polygon in the format [(x0, y0), ..., (xn, yn)]
-            a single shapely polygon will be created for
-            cropping the data
+            a list of (x, y) points, ex. [(x1, y1), ...]
+            geojson Polygon object
+            shapely Polygon object
+            shapefile Polygon shape
+            flopy Polygon shape
 
         invert : bool
             Default value is False. If invert is True then the
@@ -546,20 +554,13 @@ def _sample_rio_dataset(self, polygon, invert):
         else:
             from rasterio.mask import mask
 
-        if shapely is None:
-            msg = (
-                "Raster()._sample_rio_dataset(): error "
-                + 'importing shapely - try "pip install shapely"'
-            )
-            raise ImportError(msg)
-        else:
-            from shapely import geometry
+        from .geospatial_utils import GeoSpatialUtil
 
-        if isinstance(polygon, list) or isinstance(polygon, np.ndarray):
-            shapes = [geometry.Polygon([[x, y] for x, y in polygon])]
+        if isinstance(polygon, (list, tuple, np.ndarray)):
+            polygon = [polygon]
 
-        else:
-            shapes = [polygon]
+        geom = GeoSpatialUtil(polygon, shapetype="Polygon")
+        shapes = [geom]
 
         rstr_crp, rstr_crp_affine = mask(
             self._dataset, shapes, crop=True, invert=invert
@@ -586,14 +587,14 @@ def _intersection(self, polygon, invert):
 
         Parameters
         ----------
-        polygon : (shapely.geometry.Polygon or GeoJSON-like dict)
-            The values should be a GeoJSON-like dict or object
-            implements the Python geo interface protocal.
+        polygon : list, geojson, shapely.geometry, shapefile.Shape
+            _intersection method accepts any of these geometries:
 
-            Alternatively if the user supplies the vectors
-            of a polygon in the format [(x0, y0), ..., (xn, yn)]
-            a single shapely polygon will be created for
-            cropping the data
+            a list of (x, y) points, ex. [(x1, y1), ...]
+            geojson Polygon object
+            shapely Polygon object
+            shapefile Polygon shape
+            flopy Polygon shape
 
         invert : bool
             Default value is False. If invert is True then the
@@ -604,36 +605,14 @@ def _intersection(self, polygon, invert):
             mask : np.ndarray (dtype = bool)
 
         """
-        if shapely is None:
-            msg = (
-                "Raster()._intersection(): error "
-                + 'importing shapely try "pip install shapely"'
-            )
-            raise ImportError(msg)
-        else:
-            from shapely import geometry
+        from .geospatial_utils import GeoSpatialUtil
 
-        # step 1: check the data type in shapes
-        if isinstance(polygon, geometry.Polygon):
-            polygon = list(polygon.exterior.coords)
+        if isinstance(polygon, (list, tuple, np.ndarray)):
+            polygon = [polygon]
 
-        elif isinstance(polygon, dict):
-            # geojson, get coordinates=
-            if polygon["geometry"]["type"].lower() == "polygon":
-                polygon = [
-                    [x, y] for x, y in polygon["geometry"]["coordinates"]
-                ]
+        geom = GeoSpatialUtil(polygon, shapetype="Polygon")
 
-            else:
-                raise TypeError("Shape type must be a polygon")
-
-        elif isinstance(polygon, np.ndarray):
-            # numpy array, change to a list
-            polygon = list(polygon)
-
-        else:
-            # this is a list of coordinates
-            pass
+        polygon = geom.points[0]
 
         # step 2: create a grid of centoids
         xc = self.xcenters
@@ -756,8 +735,8 @@ def write(self, name):
             for band, arr in self.__arr_dict.items():
                 foo.write(arr, band)
 
-    @classmethod
-    def load(cls, raster):
+    @staticmethod
+    def load(raster):
         """
         Static method to load a raster file
         into the raster object
@@ -783,7 +762,7 @@ def load(cls, raster):
         bands = dataset.indexes
         meta = dataset.meta
 
-        return cls(
+        return Raster(
             array,
             bands,
             meta["crs"],
diff --git a/flopy/utils/triangle.py b/flopy/utils/triangle.py
index 10cba19c1c..7076bcb432 100644
--- a/flopy/utils/triangle.py
+++ b/flopy/utils/triangle.py
@@ -4,6 +4,7 @@
 from ..mbase import which
 from ..utils.cvfdutil import centroid_of_polygon
 from ..plot.plotutil import plot_cvfd
+from ..utils.geospatial_utils import GeoSpatialUtil
 
 
 class Triangle(object):
@@ -59,15 +60,29 @@ def add_polygon(self, polygon):
 
         Parameters
         ----------
-        polygon : list
-            polygon is a list of (x, y) points
+        polygon : list, geojson, shapely.geometry, shapefile.Shape
+            add polygon method accepts any of these geometries:
+
+            a list of (x, y) points
+            geojson Polygon object
+            shapely Polygon object
+            shapefile Polygon shape
+            flopy.utils.geometry.Polygon object
 
         Returns
         -------
         None
 
         """
-        self._polygons.append(polygon)
+        if isinstance(polygon, (list, tuple, np.ndarray)):
+            polygon = [polygon]
+
+        geom = GeoSpatialUtil(polygon, shapetype="Polygon")
+        polygon = geom.points
+        self._polygons.append(polygon[0])
+        if len(polygon) > 1:
+            for hole in polygon[1:]:
+                self.add_hole(hole)
         return
 
     def add_hole(self, hole):

From 51fdd6aac662a5b7f239a3fbabc4ac5e3ab248e6 Mon Sep 17 00:00:00 2001
From: Joshua Larsen <jlarsen@usgs.gov>
Date: Fri, 16 Oct 2020 10:26:59 -0700
Subject: [PATCH 2/2] remove intersect_linestring, intersect_point, and
 intersect_polygon from GridIntersect.

*Refactored t065_test_gridintersect.py for intersect() method
*Updated flopy3_grid_intersection_demo.ipynb for intersect() method
---
 autotest/t065_test_gridintersect.py           | 191 ++++--------------
 .../flopy3_grid_intersection_demo.ipynb       | 132 ++++++------
 flopy/utils/gridintersect.py                  |  11 +-
 3 files changed, 109 insertions(+), 225 deletions(-)

diff --git a/autotest/t065_test_gridintersect.py b/autotest/t065_test_gridintersect.py
index 09be9ea555..118f957218 100644
--- a/autotest/t065_test_gridintersect.py
+++ b/autotest/t065_test_gridintersect.py
@@ -128,9 +128,6 @@ def test_rect_grid_3d_point_outside():
     botm = np.concatenate([np.ones(4), np.zeros(4)]).reshape(2, 2, 2)
     gr = get_rect_grid(top=np.ones(4), botm=botm)
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(25., 25., .5))
-    assert len(result) == 0
-    # test with general intersect method
     result = ix.intersect(Point(25., 25., .5))
     assert len(result) == 0
     return result
@@ -145,9 +142,6 @@ def test_rect_grid_3d_point_inside():
     botm = np.concatenate([np.ones(4), .5 * np.ones(4), np.zeros(4)]).reshape(3, 2, 2)
     gr = get_rect_grid(top=np.ones(4), botm=botm)
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(2., 2., .2))
-    assert result.cellids[0] == (1, 1, 0)
-    # test general intersect method
     result = ix.intersect(Point(2., 2., .2))
     assert result.cellids[0] == (1, 1, 0)
     return result
@@ -162,9 +156,6 @@ def test_rect_grid_3d_point_above():
     botm = np.concatenate([np.ones(4), np.zeros(4)]).reshape(2, 2, 2)
     gr = get_rect_grid(top=np.ones(4), botm=botm)
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(2., 2., 2))
-    assert len(result) == 0
-    # test general intersect method
     result = ix.intersect(Point(2., 2., 2))
     assert len(result) == 0
     return result
@@ -178,8 +169,6 @@ def test_rect_grid_point_outside():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(25., 25.))
-    assert len(result) == 0
     result = ix.intersect(Point(25., 25.))
     assert len(result) == 0
     return result
@@ -193,10 +182,6 @@ def test_rect_grid_point_on_outer_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(20., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == (0, 1))
-
     result = ix.intersect(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 1))
@@ -211,10 +196,6 @@ def test_rect_grid_point_on_inner_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(Point(10., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == (0, 0))
-
     result = ix.intersect(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 0))
@@ -229,10 +210,6 @@ def test_rect_grid_multipoint_in_one_cell():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
-    assert len(result) == 1
-    assert result.cellids[0] == (1, 0)
-
     result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == (1, 0)
@@ -247,11 +224,6 @@ def test_rect_grid_multipoint_in_multiple_cells():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(12., 12.)]))
-    assert len(result) == 2
-    assert result.cellids[0] == (1, 0)
-    assert result.cellids[1] == (0, 1)
-
     result = ix.intersect(MultiPoint([Point(1., 1.), Point(12., 12.)]))
     assert len(result) == 2
     assert result.cellids[0] == (1, 0)
@@ -270,9 +242,6 @@ def test_rect_grid_point_outside_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(Point(25., 25.))
-    assert len(result) == 0
-
     result = ix.intersect(Point(25., 25.))
     assert len(result) == 0
     return result
@@ -286,10 +255,6 @@ def test_rect_grid_point_on_outer_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(Point(20., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == (0, 1))
-
     result = ix.intersect(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 1))
@@ -304,10 +269,6 @@ def test_rect_grid_point_on_inner_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(Point(10., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == (0, 0))
-
     result = ix.intersect(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == (0, 0))
@@ -322,16 +283,16 @@ def test_rect_vertex_grid_point_in_one_cell_shapely(rtree=True):
         return
     gr = get_rect_vertex_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(Point(4., 4.))
+    result = ix.intersect(Point(4., 4.))
     assert len(result) == 1
     assert result.cellids[0] == 0
-    result = ix.intersect_point(Point(4., 6.))
+    result = ix.intersect(Point(4., 6.))
     assert len(result) == 1
     assert result.cellids[0] == 0
-    result = ix.intersect_point(Point(6., 6.))
+    result = ix.intersect(Point(6., 6.))
     assert len(result) == 1
     assert result.cellids[0] == 0
-    result = ix.intersect_point(Point(6., 4.))
+    result = ix.intersect(Point(6., 4.))
     assert len(result) == 1
     assert result.cellids[0] == 0
     return result
@@ -345,10 +306,6 @@ def test_rect_grid_multipoint_in_one_cell_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
-    assert len(result) == 1
-    assert result.cellids[0] == (1, 0)
-
     result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == (1, 0)
@@ -363,11 +320,6 @@ def test_rect_grid_multipoint_in_multiple_cells_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(12., 12.)]))
-    assert len(result) == 2
-    assert result.cellids[0] == (0, 1)
-    assert result.cellids[1] == (1, 0)
-
     result = ix.intersect(MultiPoint([Point(1., 1.), Point(12., 12.)]))
     assert len(result) == 2
     assert result.cellids[0] == (0, 1)
@@ -385,9 +337,6 @@ def test_tri_grid_point_outside(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_point(Point(25., 25.))
-    assert len(result) == 0
-
     result = ix.intersect(Point(25., 25.))
     assert len(result) == 0
     return result
@@ -403,10 +352,6 @@ def test_tri_grid_point_on_outer_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_point(Point(20., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == 0)
-
     result = ix.intersect(Point(20., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == 0)
@@ -423,10 +368,6 @@ def test_tri_grid_point_on_inner_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_point(Point(10., 10.))
-    assert len(result) == 1
-    assert np.all(result.cellids[0] == 0)
-
     result = ix.intersect(Point(10., 10.))
     assert len(result) == 1
     assert np.all(result.cellids[0] == 0)
@@ -443,10 +384,6 @@ def test_tri_grid_multipoint_in_one_cell(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(2., 2.)]))
-    assert len(result) == 1
-    assert result.cellids[0] == 1
-
     result = ix.intersect(MultiPoint([Point(1., 1.), Point(2., 2.)]))
     assert len(result) == 1
     assert result.cellids[0] == 1
@@ -463,7 +400,7 @@ def test_tri_grid_multipoint_in_multiple_cells(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_point(MultiPoint([Point(1., 1.), Point(12., 12.)]))
+    result = ix.intersect(MultiPoint([Point(1., 1.), Point(12., 12.)]))
     assert len(result) == 2
     assert result.cellids[0] == 0
     assert result.cellids[1] == 1
@@ -481,9 +418,6 @@ def test_rect_grid_linestring_outside():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(LineString([(25., 25.), (21., 5.)]))
-    assert len(result) == 0
-
     result = ix.intersect(LineString([(25., 25.), (21., 5.)]))
     assert len(result) == 0
     return result
@@ -497,12 +431,6 @@ def test_rect_grid_linestring_in_2cells():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(LineString([(5., 5.), (15., 5.)]))
-    assert len(result) == 2
-    assert result.lengths.sum() == 10.
-    assert result.cellids[0] == (1, 0)
-    assert result.cellids[1] == (1, 1)
-
     result = ix.intersect(LineString([(5., 5.), (15., 5.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
@@ -519,7 +447,7 @@ def test_rect_grid_linestring_on_outer_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(LineString([(15., 20.), (5., 20.)]))
+    result = ix.intersect(LineString([(15., 20.), (5., 20.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[1] == (0, 0)
@@ -535,7 +463,7 @@ def test_rect_grid_linestring_on_inner_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(LineString([(5., 10.), (15., 10.)]))
+    result = ix.intersect(LineString([(5., 10.), (15., 10.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == (0, 0)
@@ -551,7 +479,7 @@ def test_rect_grid_multilinestring_in_one_cell():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(MultiLineString(
+    result = ix.intersect(MultiLineString(
         [LineString([(1., 1), (9., 1.)]), LineString([(1., 9.), (9., 9.)])]))
     assert len(result) == 1
     assert result.lengths == 16.
@@ -567,7 +495,7 @@ def test_rect_grid_linestring_in_and_out_of_cell():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(
+    result = ix.intersect(
         LineString([(5., 9), (15., 5.), (5., 1.)]))
     assert len(result) == 2
     assert result.cellids[0] == (1, 0)
@@ -584,7 +512,7 @@ def test_rect_grid_linestring_in_and_out_of_cell2():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_linestring(LineString(
+    result = ix.intersect(LineString(
         [(5, 15), (5., 9), (15., 5.), (5., 1.)]))
     assert len(result) == 3
     # assert result.cellids[0] == (1, 0)
@@ -604,7 +532,7 @@ def test_rect_grid_linestring_outside_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(LineString([(25., 25.), (21., 5.)]))
+    result = ix.intersect(LineString([(25., 25.), (21., 5.)]))
     assert len(result) == 0
     return result
 
@@ -617,7 +545,7 @@ def test_rect_grid_linestring_in_2cells_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(LineString([(5., 5.), (15., 5.)]))
+    result = ix.intersect(LineString([(5., 5.), (15., 5.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == (1, 0)
@@ -633,7 +561,7 @@ def test_rect_grid_linestring_on_outer_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(LineString([(15., 20.), (5., 20.)]))
+    result = ix.intersect(LineString([(15., 20.), (5., 20.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == (0, 0)
@@ -649,7 +577,7 @@ def test_rect_grid_linestring_on_inner_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(LineString([(5., 10.), (15., 10.)]))
+    result = ix.intersect(LineString([(5., 10.), (15., 10.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == (0, 0)
@@ -665,7 +593,7 @@ def test_rect_grid_multilinestring_in_one_cell_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(MultiLineString(
+    result = ix.intersect(MultiLineString(
         [LineString([(1., 1), (9., 1.)]), LineString([(1., 9.), (9., 9.)])]))
     assert len(result) == 1
     assert result.lengths == 16.
@@ -681,7 +609,7 @@ def test_rect_grid_linestring_in_and_out_of_cell_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_linestring(
+    result = ix.intersect(
         LineString([(5., 9), (15., 5.), (5., 1.)]))
     assert len(result) == 2
     assert result.cellids[0] == (1, 0)
@@ -700,7 +628,7 @@ def test_tri_grid_linestring_outside(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_linestring(LineString([(25., 25.), (21., 5.)]))
+    result = ix.intersect(LineString([(25., 25.), (21., 5.)]))
     assert len(result) == 0
     return result
 
@@ -715,12 +643,6 @@ def test_tri_grid_linestring_in_2cells(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_linestring(LineString([(5., 5.), (5., 15.)]))
-    assert len(result) == 2
-    assert result.lengths.sum() == 10.
-    assert result.cellids[0] == 1
-    assert result.cellids[1] == 3
-
     result = ix.intersect(LineString([(5., 5.), (5., 15.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
@@ -739,7 +661,7 @@ def test_tri_grid_linestring_on_outer_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_linestring(LineString([(15., 20.), (5., 20.)]))
+    result = ix.intersect(LineString([(15., 20.), (5., 20.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == 2
@@ -757,7 +679,7 @@ def test_tri_grid_linestring_on_inner_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_linestring(LineString([(5., 10.), (15., 10.)]))
+    result = ix.intersect(LineString([(5., 10.), (15., 10.)]))
     assert len(result) == 2
     assert result.lengths.sum() == 10.
     assert result.cellids[0] == 0
@@ -775,12 +697,6 @@ def test_tri_grid_multilinestring_in_one_cell(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_linestring(MultiLineString(
-        [LineString([(1., 1), (9., 1.)]), LineString([(2., 2.), (9., 2.)])]))
-    assert len(result) == 1
-    assert result.lengths == 15.
-    assert result.cellids[0] == 4
-
     result = ix.intersect(MultiLineString(
         [LineString([(1., 1), (9., 1.)]), LineString([(2., 2.), (9., 2.)])]))
     assert len(result) == 1
@@ -800,12 +716,9 @@ def test_rect_grid_polygon_outside():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(21., 11.), (23., 17.), (25., 11.)]))
     assert len(result) == 0
-
-    result = ix.intersect(Polygon([(21., 11.), (23., 17.), (25., 11.)]))
-    assert len(result) == 0
     return result
 
 
@@ -817,11 +730,6 @@ def test_rect_grid_polygon_in_2cells():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_polygon(
-        Polygon([(2.5, 5.0), (7.5, 5.0), (7.5, 15.), (2.5, 15.)]))
-    assert len(result) == 2
-    assert result.areas.sum() == 50.
-
     result = ix.intersect(
         Polygon([(2.5, 5.0), (7.5, 5.0), (7.5, 15.), (2.5, 15.)]))
     assert len(result) == 2
@@ -837,7 +745,7 @@ def test_rect_grid_polygon_on_outer_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(20., 5.0), (25., 5.0), (25., 15.), (20., 15.)]))
     assert len(result) == 0
     return result
@@ -851,7 +759,7 @@ def test_rect_grid_polygon_on_inner_boundary():
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method="structured")
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(5., 10.0), (15., 10.0), (15., 5.), (5., 5.)]))
     assert len(result) == 2
     assert result.areas.sum() == 50.
@@ -869,7 +777,7 @@ def test_rect_grid_multipolygon_in_one_cell():
     p1 = Polygon([(1., 1.), (8., 1.), (8., 3.), (1., 3.)])
     p2 = Polygon([(1., 9.), (8., 9.), (8., 7.), (1., 7.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 1
     assert result.areas.sum() == 28.
     return result
@@ -886,7 +794,7 @@ def test_rect_grid_multipolygon_in_multiple_cells():
     p1 = Polygon([(1., 1.), (19., 1.), (19., 3.), (1., 3.)])
     p2 = Polygon([(1., 9.), (19., 9.), (19., 7.), (1., 7.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 2
     assert result.areas.sum() == 72.
     return result
@@ -902,10 +810,6 @@ def test_rect_grid_polygon_with_hole():
     ix = GridIntersect(gr, method="structured")
     p = Polygon([(5., 5.), (5., 15.), (25., 15.), (25., -5.),
                  (5., -5.)], holes=[[(9., -1), (9, 11), (21, 11), (21, -1)]])
-    result = ix.intersect_polygon(p)
-    assert len(result) == 3
-    assert result.areas.sum() == 104.
-
     result = ix.intersect(p)
     assert len(result) == 3
     assert result.areas.sum() == 104.
@@ -923,7 +827,7 @@ def test_rect_grid_polygon_outside_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(21., 11.), (23., 17.), (25., 11.)]))
     assert len(result) == 0
     return result
@@ -937,7 +841,7 @@ def test_rect_grid_polygon_in_2cells_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(2.5, 5.0), (7.5, 5.0), (7.5, 15.), (2.5, 15.)]))
     assert len(result) == 2
     assert result.areas.sum() == 50.
@@ -952,7 +856,7 @@ def test_rect_grid_polygon_on_outer_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(20., 5.0), (25., 5.0), (25., 15.), (20., 15.)]))
     assert len(result) == 0
     return result
@@ -966,7 +870,7 @@ def test_rect_grid_polygon_on_inner_boundary_shapely(rtree=True):
         return
     gr = get_rect_grid()
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(5., 10.0), (15., 10.0), (15., 5.), (5., 5.)]))
     assert len(result) == 2
     assert result.areas.sum() == 50.
@@ -984,7 +888,7 @@ def test_rect_grid_multipolygon_in_one_cell_shapely(rtree=True):
     p1 = Polygon([(1., 1.), (8., 1.), (8., 3.), (1., 3.)])
     p2 = Polygon([(1., 9.), (8., 9.), (8., 7.), (1., 7.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 1
     assert result.areas.sum() == 28.
     return result
@@ -1001,7 +905,7 @@ def test_rect_grid_multipolygon_in_multiple_cells_shapely(rtree=True):
     p1 = Polygon([(1., 1.), (19., 1.), (19., 3.), (1., 3.)])
     p2 = Polygon([(1., 9.), (19., 9.), (19., 7.), (1., 7.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 2
     assert result.areas.sum() == 72.
     return result
@@ -1017,7 +921,7 @@ def test_rect_grid_polygon_with_hole_shapely(rtree=True):
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
     p = Polygon([(5., 5.), (5., 15.), (25., 15.), (25., -5.),
                  (5., -5.)], holes=[[(9., -1), (9, 11), (21, 11), (21, -1)]])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 3
     assert result.areas.sum() == 104.
     return result
@@ -1033,7 +937,7 @@ def test_rect_grid_polygon_in_edge_in_cell(rtree=True):
     ix = GridIntersect(gr, method='vertex', rtree=rtree)
     p = Polygon([(0., 5.), (3., 0.), (7., 0.),
                  (10., 5.), (10., -1.), (0., -1.)])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 1
     assert result.areas.sum() == 15.
     return result
@@ -1049,7 +953,7 @@ def test_tri_grid_polygon_outside(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(21., 11.), (23., 17.), (25., 11.)]))
     assert len(result) == 0
     return result
@@ -1065,11 +969,6 @@ def test_tri_grid_polygon_in_2cells(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_polygon(
-        Polygon([(2.5, 5.0), (5.0, 5.0), (5.0, 15.), (2.5, 15.)]))
-    assert len(result) == 2
-    assert result.areas.sum() == 25.
-
     result = ix.intersect(
         Polygon([(2.5, 5.0), (5.0, 5.0), (5.0, 15.), (2.5, 15.)]))
     assert len(result) == 2
@@ -1087,7 +986,7 @@ def test_tri_grid_polygon_on_outer_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(20., 5.0), (25., 5.0), (25., 15.), (20., 15.)]))
     assert len(result) == 0
     return result
@@ -1098,7 +997,7 @@ def test_tri_grid_polygon_on_inner_boundary(rtree=True):
     if gr == -1:
         return
     ix = GridIntersect(gr, rtree=rtree)
-    result = ix.intersect_polygon(
+    result = ix.intersect(
         Polygon([(5., 10.0), (15., 10.0), (15., 5.), (5., 5.)]))
     assert len(result) == 4
     assert result.areas.sum() == 50.
@@ -1118,10 +1017,6 @@ def test_tri_grid_multipolygon_in_one_cell(rtree=True):
     p1 = Polygon([(1., 1.), (8., 1.), (8., 3.), (3., 3.)])
     p2 = Polygon([(5., 5.), (8., 5.), (8., 8.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
-    assert len(result) == 1
-    assert result.areas.sum() == 16.5
-
     result = ix.intersect(p)
     assert len(result) == 1
     assert result.areas.sum() == 16.5
@@ -1141,7 +1036,7 @@ def test_tri_grid_multipolygon_in_multiple_cells(rtree=True):
     p1 = Polygon([(1., 1.), (19., 1.), (19., 3.), (1., 3.)])
     p2 = Polygon([(1., 9.), (19., 9.), (19., 7.), (1., 7.)])
     p = MultiPolygon([p1, p2])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 4
     assert result.areas.sum() == 72.
     return result
@@ -1159,7 +1054,7 @@ def test_tri_grid_polygon_with_hole(rtree=True):
     ix = GridIntersect(gr, rtree=rtree)
     p = Polygon([(5., 5.), (5., 15.), (25., 15.), (25., -5.),
                  (5., -5.)], holes=[[(9., -1), (9, 11), (21, 11), (21, -1)]])
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     assert len(result) == 6
     assert result.areas.sum() == 104.
     return result
@@ -1177,7 +1072,7 @@ def test_point_offset_rot_structured_grid():
     sgr = get_rect_grid(angrot=45., xyoffset=10.)
     p = Point(10., 10 + np.sqrt(200.))
     ix = GridIntersect(sgr, method="structured")
-    result = ix.intersect_point(p)
+    result = ix.intersect(p)
     # assert len(result) == 1.
     return result
 
@@ -1191,7 +1086,7 @@ def test_linestring_offset_rot_structured_grid():
     sgr = get_rect_grid(angrot=45., xyoffset=10.)
     ls = LineString([(5, 10. + np.sqrt(200.)), (15, 10. + np.sqrt(200.))])
     ix = GridIntersect(sgr, method="structured")
-    result = ix.intersect_linestring(ls)
+    result = ix.intersect(ls)
     # assert len(result) == 2.
     return result
 
@@ -1208,7 +1103,7 @@ def test_polygon_offset_rot_structured_grid():
                  (15, 10. + 1.5 * np.sqrt(200.)),
                  (5, 10. + 1.5 * np.sqrt(200.))])
     ix = GridIntersect(sgr, method="structured")
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     # assert len(result) == 3.
     return result
 
@@ -1222,7 +1117,7 @@ def test_point_offset_rot_structured_grid_shapely(rtree=True):
     sgr = get_rect_grid(angrot=45., xyoffset=10.)
     p = Point(10., 10 + np.sqrt(200.))
     ix = GridIntersect(sgr, method="vertex", rtree=rtree)
-    result = ix.intersect_point(p)
+    result = ix.intersect(p)
     # assert len(result) == 1.
     return result
 
@@ -1236,7 +1131,7 @@ def test_linestring_offset_rot_structured_grid_shapely(rtree=True):
     sgr = get_rect_grid(angrot=45., xyoffset=10.)
     ls = LineString([(5, 10. + np.sqrt(200.)), (15, 10. + np.sqrt(200.))])
     ix = GridIntersect(sgr, method="vertex", rtree=rtree)
-    result = ix.intersect_linestring(ls)
+    result = ix.intersect(ls)
     # assert len(result) == 2.
     return result
 
@@ -1253,7 +1148,7 @@ def test_polygon_offset_rot_structured_grid_shapely(rtree=True):
                  (15, 10. + 1.5 * np.sqrt(200.)),
                  (5, 10. + 1.5 * np.sqrt(200.))])
     ix = GridIntersect(sgr, method="vertex", rtree=rtree)
-    result = ix.intersect_polygon(p)
+    result = ix.intersect(p)
     # assert len(result) == 3.
     return result
 
diff --git a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb
index 73550aaeaa..57c4125449 100644
--- a/examples/Notebooks/flopy3_grid_intersection_demo.ipynb
+++ b/examples/Notebooks/flopy3_grid_intersection_demo.ipynb
@@ -46,12 +46,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "flopy is installed in /Users/jdhughes/Documents/Development/flopy_git/flopy_fork/flopy\n",
-      "3.7.3 | packaged by conda-forge | (default, Jul  1 2019, 14:38:56) \n",
-      "[Clang 4.0.1 (tags/RELEASE_401/final)]\n",
-      "numpy version: 1.17.3\n",
-      "matplotlib version: 3.1.1\n",
-      "flopy version: 3.3.1\n"
+      "3.7.4 (default, Aug  9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]\n",
+      "numpy version: 1.18.1\n",
+      "matplotlib version: 3.1.2\n",
+      "flopy version: 3.3.2\n"
      ]
     }
    ],
@@ -104,9 +102,7 @@
     "\n",
     "The important methods in the GridIntersect object are:\n",
     "- `intersects()`: returns cellids for gridcells that intersect a shape\n",
-    "- `intersect_point()`: for intersecting the modelgrid with point geometries\n",
-    "- `intersect_linestring()`: for intersecting the modelgrid with linestrings\n",
-    "- `intersect_polygon()`: for intersecting the modelgrid with polygons\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",
     "- `plot_point()`: for plotting point intersection results\n",
     "- `plot_linestring()`: for plotting linestring intersection results\n",
     "- `plot_polygon()`: for plotting polygon intersection results\n",
@@ -151,7 +147,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.collections.LineCollection at 0x12898ebe0>"
+       "<matplotlib.collections.LineCollection at 0x14cadf94788>"
       ]
      },
      "execution_count": 4,
@@ -160,7 +156,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -226,12 +222,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "9.82 ms ± 95.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "6.98 ms ± 25.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ix.intersect_polygon(p)"
+    "%timeit ix.intersect(p)"
    ]
   },
   {
@@ -240,7 +236,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = ix.intersect_polygon(p)"
+    "result = ix.intersect(p)"
    ]
   },
   {
@@ -265,11 +261,11 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([((2, 3), (((30.0, 70.0), (35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0)),),  66.66666667, <shapely.geometry.polygon.Polygon object at 0x10fddc278>),\n",
-       "           ((2, 4), (((40.0, 76.66666666666667), (50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667)),),  33.33333333, <shapely.geometry.polygon.Polygon object at 0x10fddc5f8>),\n",
-       "           ((3, 2), (((25.0, 60.0), (30.0, 70.0), (30.0, 60.0), (25.0, 60.0)),),  25.        , <shapely.geometry.polygon.Polygon object at 0x10fddc2e8>),\n",
-       "           ((3, 3), (((30.0, 70.0), (40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x10fddc5c0>),\n",
-       "           ((3, 4), (((40.0, 70.0), (50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x10fddc240>)],\n",
+       "rec.array([((2, 3), (((30.0, 70.0), (35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0)),),  66.66666667, <shapely.geometry.polygon.Polygon object at 0x0000014CABF1EE88>),\n",
+       "           ((2, 4), (((40.0, 76.66666666666667), (50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667)),),  33.33333333, <shapely.geometry.polygon.Polygon object at 0x0000014CADFC2148>),\n",
+       "           ((3, 2), (((25.0, 60.0), (30.0, 70.0), (30.0, 60.0), (25.0, 60.0)),),  25.        , <shapely.geometry.polygon.Polygon object at 0x0000014C8A7A1608>),\n",
+       "           ((3, 3), (((30.0, 70.0), (40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x0000014CABF1E548>),\n",
+       "           ((3, 4), (((40.0, 70.0), (50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x0000014CAA34C548>)],\n",
        "          dtype=[('cellids', 'O'), ('vertices', 'O'), ('areas', '<f8'), ('ixshapes', 'O')])"
       ]
      },
@@ -366,16 +362,16 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([((9, 4),), ((9, 3),), ((9, 2),), ((8, 5),), ((8, 4),),\n",
-       "           ((8, 3),), ((8, 2),), ((8, 1),), ((7, 6),), ((7, 5),),\n",
-       "           ((7, 4),), ((7, 3),), ((7, 2),), ((7, 1),), ((6, 8),),\n",
-       "           ((6, 7),), ((6, 6),), ((6, 5),), ((6, 4),), ((6, 2),),\n",
-       "           ((6, 1),), ((5, 1),), ((5, 2),), ((5, 3),), ((5, 4),),\n",
-       "           ((5, 5),), ((5, 6),), ((5, 7),), ((5, 8),), ((4, 1),),\n",
-       "           ((4, 2),), ((4, 3),), ((4, 4),), ((4, 5),), ((4, 6),),\n",
-       "           ((4, 7),), ((4, 8),), ((3, 6),), ((3, 5),), ((3, 4),),\n",
-       "           ((3, 3),), ((3, 2),), ((2, 5),), ((2, 4),), ((2, 3),),\n",
-       "           ((2, 2),), ((1, 3),)],\n",
+       "rec.array([((9, 4),), ((9, 3),), ((9, 2),), ((8, 1),), ((8, 2),),\n",
+       "           ((8, 3),), ((8, 4),), ((8, 5),), ((7, 6),), ((7, 5),),\n",
+       "           ((7, 4),), ((7, 3),), ((7, 2),), ((7, 1),), ((6, 1),),\n",
+       "           ((6, 4),), ((6, 5),), ((6, 6),), ((6, 7),), ((6, 8),),\n",
+       "           ((6, 2),), ((5, 1),), ((5, 2),), ((5, 3),), ((5, 4),),\n",
+       "           ((5, 5),), ((5, 6),), ((5, 7),), ((5, 8),), ((4, 8),),\n",
+       "           ((4, 7),), ((4, 6),), ((4, 5),), ((4, 4),), ((4, 3),),\n",
+       "           ((4, 2),), ((4, 1),), ((3, 6),), ((3, 5),), ((3, 4),),\n",
+       "           ((3, 2),), ((3, 3),), ((2, 5),), ((2, 3),), ((2, 2),),\n",
+       "           ((2, 4),), ((1, 3),)],\n",
        "          dtype=[('cellids', 'O')])"
       ]
      },
@@ -405,7 +401,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -465,12 +461,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "12.6 ms ± 139 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "9.04 ms ± 184 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ixs.intersect_polygon(p)"
+    "%timeit ixs.intersect(p)"
    ]
   },
   {
@@ -488,11 +484,11 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([((2, 3), (((30.0, 70.0), (35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0)),),  66.66666667, <shapely.geometry.polygon.Polygon object at 0x130d11400>),\n",
-       "           ((2, 4), (((40.0, 76.66666666666667), (50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667)),),  33.33333333, <shapely.geometry.polygon.Polygon object at 0x130d11860>),\n",
-       "           ((3, 2), (((25.0, 60.0), (30.0, 70.0), (30.0, 60.0), (25.0, 60.0)),),  25.        , <shapely.geometry.polygon.Polygon object at 0x130d117f0>),\n",
-       "           ((3, 3), (((30.0, 70.0), (40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x130d11da0>),\n",
-       "           ((3, 4), (((40.0, 70.0), (50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x130d117b8>)],\n",
+       "rec.array([((2, 3), (((30.0, 70.0), (35.0, 80.0), (40.0, 76.66666666666667), (40.0, 70.0), (30.0, 70.0)),),  66.66666667, <shapely.geometry.polygon.Polygon object at 0x0000014CAF1401C8>),\n",
+       "           ((2, 4), (((40.0, 76.66666666666667), (50.0, 70.0), (40.0, 70.0), (40.0, 76.66666666666667)),),  33.33333333, <shapely.geometry.polygon.Polygon object at 0x0000014CAF2A3C88>),\n",
+       "           ((3, 2), (((25.0, 60.0), (30.0, 70.0), (30.0, 60.0), (25.0, 60.0)),),  25.        , <shapely.geometry.polygon.Polygon object at 0x0000014CAF140B08>),\n",
+       "           ((3, 3), (((30.0, 70.0), (40.0, 70.0), (40.0, 60.0), (30.0, 60.0), (30.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x0000014CAF12D508>),\n",
+       "           ((3, 4), (((40.0, 70.0), (50.0, 70.0), (50.0, 60.0), (40.0, 60.0), (40.0, 70.0)),), 100.        , <shapely.geometry.polygon.Polygon object at 0x0000014CAF12DD08>)],\n",
        "          dtype=[('cellids', 'O'), ('vertices', 'O'), ('areas', '<f8'), ('ixshapes', 'O')])"
       ]
      },
@@ -502,7 +498,7 @@
     }
    ],
    "source": [
-    "result2 = ixs.intersect_polygon(p)\n",
+    "result2 = ixs.intersect(p)\n",
     "result2[:5]"
    ]
   },
@@ -535,12 +531,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "6.72 ms ± 104 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "4.56 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ix.intersect_linestring(mls)"
+    "%timeit ix.intersect(mls)"
    ]
   },
   {
@@ -549,7 +545,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = ix.intersect_linestring(mls)"
+    "result = ix.intersect(mls)"
    ]
   },
   {
@@ -566,7 +562,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -613,12 +609,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "7.48 ms ± 88.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "5 ms ± 132 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ixs.intersect_linestring(mls)"
+    "%timeit ixs.intersect(mls)"
    ]
   },
   {
@@ -649,12 +645,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1.23 ms ± 7.16 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      "973 µs ± 16.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ix.intersect_point(mp)"
+    "%timeit ix.intersect(mp)"
    ]
   },
   {
@@ -665,9 +661,9 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([((5, 4), ((45.0, 45.0),), <shapely.geometry.point.Point object at 0x130e357b8>),\n",
-       "           ((8, 0), ((10.0, 10.0),), <shapely.geometry.point.Point object at 0x130e355f8>),\n",
-       "           ((9, 4), ((50.0, 0.0),), <shapely.geometry.point.Point object at 0x130e358d0>)],\n",
+       "rec.array([((5, 4), ((45.0, 45.0),), <shapely.geometry.point.Point object at 0x0000014CAF272288>),\n",
+       "           ((8, 0), ((10.0, 10.0),), <shapely.geometry.point.Point object at 0x0000014CAF183C08>),\n",
+       "           ((9, 4), ((50.0, 0.0),), <shapely.geometry.point.Point object at 0x0000014CABF2B388>)],\n",
        "          dtype=[('cellids', 'O'), ('vertices', 'O'), ('ixshapes', 'O')])"
       ]
      },
@@ -677,7 +673,7 @@
     }
    ],
    "source": [
-    "result = ix.intersect_point(mp)\n",
+    "result = ix.intersect(mp)\n",
     "result"
    ]
   },
@@ -688,7 +684,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -735,12 +731,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "218 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      "269 µs ± 6.35 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
      ]
     }
    ],
    "source": [
-    "%timeit ixs.intersect_point(mp)"
+    "%timeit ixs.intersect(mp)"
    ]
   },
   {
@@ -751,9 +747,9 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([((9, 4), <shapely.geometry.point.Point object at 0x130f86358>),\n",
-       "           ((5, 4), <shapely.geometry.point.Point object at 0x130f86160>),\n",
-       "           ((8, 0), <shapely.geometry.point.Point object at 0x130f86fd0>)],\n",
+       "rec.array([((9, 4), <shapely.geometry.point.Point object at 0x0000014CAF4A44C8>),\n",
+       "           ((5, 4), <shapely.geometry.point.Point object at 0x0000014CAF2BD988>),\n",
+       "           ((8, 0), <shapely.geometry.point.Point object at 0x0000014CAF26DFC8>)],\n",
        "          dtype=[('cellids', 'O'), ('ixshapes', 'O')])"
       ]
      },
@@ -763,7 +759,7 @@
     }
    ],
    "source": [
-    "ixs.intersect_point(mp)"
+    "ixs.intersect(mp)"
    ]
   },
   {
@@ -807,7 +803,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.collections.LineCollection at 0x131097208>"
+       "<matplotlib.collections.LineCollection at 0x14caf3367c8>"
       ]
      },
      "execution_count": 31,
@@ -816,7 +812,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -855,7 +851,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = ix2.intersect_polygon(p)"
+    "result = ix2.intersect(p)"
    ]
   },
   {
@@ -865,7 +861,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -902,7 +898,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = ix2.intersect_linestring(mls)"
+    "result = ix2.intersect(mls)"
    ]
   },
   {
@@ -912,7 +908,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -948,7 +944,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = ix2.intersect_point(mp)"
+    "result = ix2.intersect(mp)"
    ]
   },
   {
@@ -959,8 +955,8 @@
     {
      "data": {
       "text/plain": [
-       "rec.array([(1, ((10.0, 10.0), (45.0, 45.0)), <shapely.geometry.multipoint.MultiPoint object at 0x131397e10>),\n",
-       "           (4, ((50.0, 0.0),), <shapely.geometry.point.Point object at 0x131227fd0>)],\n",
+       "rec.array([(1, ((10.0, 10.0), (45.0, 45.0)), <shapely.geometry.multipoint.MultiPoint object at 0x0000014CAF6531C8>),\n",
+       "           (4, ((50.0, 0.0),), <shapely.geometry.point.Point object at 0x0000014CAF653A88>)],\n",
        "          dtype=[('cellids', 'O'), ('vertices', 'O'), ('ixshapes', 'O')])"
       ]
      },
@@ -980,7 +976,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x576 with 1 Axes>"
       ]
@@ -1021,7 +1017,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.3"
+   "version": "3.7.4"
   }
  },
  "nbformat": 4,
diff --git a/flopy/utils/gridintersect.py b/flopy/utils/gridintersect.py
index 5023a47294..b29a19ef5c 100644
--- a/flopy/utils/gridintersect.py
+++ b/flopy/utils/gridintersect.py
@@ -137,15 +137,8 @@ def __init__(self, mfgrid, method=None, rtree=True):
             if self.rtree:
                 self.strtree = STRtree(self._get_gridshapes())
 
-            # set interesection methods
-            self.intersect_point = self._intersect_point_shapely
-            self.intersect_linestring = self._intersect_linestring_shapely
-            self.intersect_polygon = self._intersect_polygon_shapely
-
         elif self.method == "structured" and mfgrid.grid_type == "structured":
-            self.intersect_point = self._intersect_point_structured
-            self.intersect_linestring = self._intersect_linestring_structured
-            self.intersect_polygon = self._intersect_polygon_structured
+            pass
 
         else:
             raise ValueError(
@@ -943,7 +936,7 @@ def _get_nodes_intersecting_linestring(self, linestring):
             x0 = [x[0]]
             y0 = [y[0]]
 
-        (i, j) = self.intersect_point(Point(x0[0], y0[0])).cellids[0]
+        (i, j) = self.intersect(Point(x0[0], y0[0])).cellids[0]
         Xe, Ye = self.mfgrid.xyedges
         xmin = Xe[j]
         xmax = Xe[j + 1]