pyopenrivercam 0.9.2__py3-none-any.whl → 0.9.3__py3-none-any.whl

{pyopenrivercam-0.9.2.dist-info → pyopenrivercam-0.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenrivercam
-Version: 0.9.2
+Version: 0.9.3
 Summary: pyorc: free and open-source image-based surface velocity and discharge.
 Author-email: Hessel Winsemius <winsemius@rainbowsensing.com>
 Requires-Python: >=3.9

{pyopenrivercam-0.9.2.dist-info → pyopenrivercam-0.9.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
-pyorc/__init__.py,sha256=UQuU9xy-pxY7XonoYJqzQU1RinDVb6mgc3FAsaWrA0g,523
+pyorc/__init__.py,sha256=1lhSZ9vOEHMu0j54z2mVnf14JyHHoCSLxAGnh6Lf0hY,523
 pyorc/const.py,sha256=Ia0KRkm-E1lJk4NxQVPDIfN38EBB7BKvxmwIHJrGPUY,2597
-pyorc/cv.py,sha256=t2ZR4eyGbiwlIaGHysOheWdaDQuqpWLKjcTiAUzWAR0,50261
+pyorc/cv.py,sha256=0U7Bwe29tRLSJXIpAxStrwGElheBt54_GslexREcw50,50953
 pyorc/helpers.py,sha256=jed0YyywnpvsZS-8mcA7Lfzn9np1MTlmVLE_PDn2QY0,30454
-pyorc/plot_helpers.py,sha256=gLKslspsF_Z4jib5jkBv2wRjKnHTbuRFgkp_PCmv-uU,1803
+pyorc/plot_helpers.py,sha256=mlDsiTqd2VMJTvUFOnnAcW_EIOVtChX37F-zISP__-M,1921
 pyorc/project.py,sha256=CGKfICkQEpFRmh_ZeDEfbQ-wefJt7teWJd6B5IPF038,7747
 pyorc/pyorc.sh,sha256=-xOSUNnMAwVbdNkjKNKMZMaBljWsGLhadG-j0DNlJP4,5
 pyorc/sample_data.py,sha256=AhQgYozpbMcSxtNyi6WfHSKHeSRgDQqFhLO0-VrQKiU,3171
 pyorc/api/__init__.py,sha256=k2OQQH4NrtXTuVm23d0g_SX6H5DhnKC9_kDyzJ4dWdk,428
-pyorc/api/cameraconfig.py,sha256=NP9F7LhPO3aO6FRWkrGl6XpX8O3K59zfTtaYR3Kujqw,65419
-pyorc/api/cross_section.py,sha256=MH0AEw5K1Kc1ClZeQRBUYkShZYVk41fshLn6GzCZAas,65212
+pyorc/api/cameraconfig.py,sha256=6cEhPGf55H_zLu7K3wKAFz3-zide4jFgddYnycZuZ1c,65449
+pyorc/api/cross_section.py,sha256=eS2tiZ9kMiVlFGBfpz5qTHXAw7Bb6UPURJu4zmAhBjM,75029
 pyorc/api/frames.py,sha256=BnglhmHdbKlIip5tym3x-aICOpQRmm853109A7JkWk8,23189
 pyorc/api/mask.py,sha256=A3TRMqi30L4N491C4FoYY0zvV1GwQ1U31OEkCJp_Nzc,16698
 pyorc/api/orcbase.py,sha256=C23QTKOyxHUafyJsq_t7xn_BzAEvf4DDfzlYAopons8,4189
@@ -26,8 +26,8 @@ pyorc/service/camera_config.py,sha256=OsRLpe5jd-lu6HT4Vx5wEg554CMS-IKz-q62ir4VbP
 pyorc/service/velocimetry.py,sha256=bPI1OdN_fi0gZES08mb7yqCS_4I-lKSZ2JvWSGTRD1E,34434
 pyorc/velocimetry/__init__.py,sha256=5oShoMocCalcCZuIsBqlZlqQuKJgDDBUvXQIo-uqFPA,88
 pyorc/velocimetry/ffpiv.py,sha256=92XDgzCW4mEZ5ow82zV0APOhfDc1OVftBjKqYdw1zzc,17494
-pyopenrivercam-0.9.2.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
-pyopenrivercam-0.9.2.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-pyopenrivercam-0.9.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyopenrivercam-0.9.2.dist-info/METADATA,sha256=LjzGioSQjEn7ku6f8v6N0jti7SiJvMw7Le1HQwboeas,12566
-pyopenrivercam-0.9.2.dist-info/RECORD,,
+pyopenrivercam-0.9.3.dist-info/entry_points.txt,sha256=Cv_WI2Y6QLnPiNCXGli0gS4WAOAeMoprha1rAR3vdRE,44
+pyopenrivercam-0.9.3.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+pyopenrivercam-0.9.3.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyopenrivercam-0.9.3.dist-info/METADATA,sha256=253-bK9Du3taufc0fAYU9QnZemPfRqUJm2NjbrFKBAU,12566
+pyopenrivercam-0.9.3.dist-info/RECORD,,

pyorc/__init__.py

@@ -1,6 +1,6 @@
 """pyorc: free and open-source image-based surface velocity and discharge."""
 
-__version__ = "0.9.2"
+__version__ = "0.9.3"
 
 from .api import CameraConfig, CrossSection, Frames, Transect, Velocimetry, Video, get_camera_config, load_camera_config  # noqa
 from .project import *  # noqa

pyorc/api/cameraconfig.py

@@ -459,6 +459,7 @@ class CameraConfig:
         z_a: Optional[float] = None,
         within_image: Optional[bool] = False,
         expand_exterior=True,
+        exterior_split=400,
     ) -> Polygon:
         """Get bounding box.
 
@@ -485,6 +486,8 @@ class CameraConfig:
             Set to True to make an attempt to remove parts of the polygon that lie outside of the image field of view
         expand_exterior : bool, optional
             Set to True to expand the corner points to more points. This is particularly useful for plotting purposes.
+        exterior_split : int, optional
+            Amount of subline segments to split bounding box in
 
         Returns
         -------
@@ -516,7 +519,7 @@ class CameraConfig:
             # distortion on image frame, and to plot partial coverage in the real-world coordinates
             coords_expand = np.zeros((0, 2))
             for n in range(0, len(coords) - 1):
-                new_coords = np.linspace(coords[n], coords[n + 1], 100)
+                new_coords = np.linspace(coords[n], coords[n + 1], exterior_split // 4)
                 coords_expand = np.r_[coords_expand, new_coords]
             coords = coords_expand
         if not z_a:
@@ -915,9 +918,9 @@ class CameraConfig:
         angle : float, optional
             Rotation angle in radians (anti-clockwise) around the center of the bounding box
         xoff : float, optional
-            Translation distance in x direction in CRS units
+            Translation distance in x direction in m.
         yoff : float, optional
-            Translation distance in y direction in CRS units
+            Translation distance in y direction in m.
 
         Returns
         -------
@@ -935,9 +938,6 @@ class CameraConfig:
 
         # Apply rotation if specified
         if angle is not None:
-            print(angle)
-            # # Convert to radians
-            # angle = np.radians(rotation)
             # Get centroid as origin
             centroid = bbox.centroid
             # Apply rotation around centroid

pyorc/api/cross_section.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import copy
 import warnings
 from typing import Dict, List, Literal, Optional, Tuple, Union
 
@@ -12,10 +13,11 @@ import numpy as np
 from matplotlib import patheffects
 from scipy.interpolate import interp1d
 from scipy.optimize import differential_evolution
-from shapely import affinity, geometry
+from shapely import affinity, force_2d, force_3d, geometry
+from shapely.affinity import rotate, translate
 from shapely.ops import polygonize, split
 
-from pyorc import cv, plot_helpers
+from .cameraconfig import CameraConfig, cv, plot_helpers
 
 MODES = Literal["camera", "geographic", "cross_section"]
 PATH_EFFECTS = [
@@ -36,6 +38,37 @@ WETTED_KWARGS = {
 }
 
 
+def _fit_line(x, y):
+    """Fit straight (xy direction) line to points in a LineString.
+
+    Parameters
+    ----------
+    x : list[float]
+        x-coordinates of points forming a line
+    y : list[float]
+        y-coordinates of points forming a line
+
+    Returns
+    -------
+    slope, intercept, angle: float, float, float
+        line characteristics, angle is in radians
+
+    """
+    # Use PCA to fit the best line
+    ps = np.column_stack([x, y])
+    centr = ps.mean(axis=0)
+    ps_centered = ps - centr
+
+    # SVD to find principal direction
+    _, _, vh = np.linalg.svd(ps_centered)
+    direc = vh[0]  # First principal component is the line direction
+
+    # Calculate angle of the line
+    ang = np.arctan2(direc[1], direc[0])
+
+    return centr, direc, ang
+
+
 def _make_angle_lines(csl_points, angle_perp, length, offset):
     """Make lines at cross section points, perpendicular to cross section orientation using angle and offset."""
     # move points
@@ -98,7 +131,7 @@ class CrossSection:
     def __repr__(self):
         return str(self.cs_linestring)
 
-    def __init__(self, camera_config, cross_section: Union[gpd.GeoDataFrame, List[List]]):
+    def __init__(self, camera_config: CameraConfig, cross_section: Union[gpd.GeoDataFrame, List[List]]):
         """Initialize a cross-section representation.
 
         The object is geographically aware through the camera configuration.
@@ -107,7 +140,7 @@ class CrossSection:
 
         Parameters
         ----------
-        camera_config : object
+        camera_config : pyorc.CameraConfig
             Defines the camera configuration, including potential CRS used for processing
             geographic data consistency.
         cross_section : GeoDataFrame or list of lists
@@ -268,7 +301,15 @@ class CrossSection:
         # check if cross section is visible within the image objective
         pix = self.camera_config.project_points(np.array(list(map(list, self.cs_linestring.coords))), within_image=True)
         # check which points fall within the image objective
-        within_image = np.all([pix[:, 0] >= 0, pix[:, 0] < 1920, pix[:, 1] >= 0, pix[:, 1] < 1080], axis=0)
+        within_image = np.all(
+            [
+                pix[:, 0] >= 0,
+                pix[:, 0] < self.camera_config.width,
+                pix[:, 1] >= 0,
+                pix[:, 1] < self.camera_config.height,
+            ],
+            axis=0,
+        )
         # check if there are any points within the image objective and return result
         return bool(np.any(within_image))
 
@@ -375,6 +416,8 @@ class CrossSection:
                 raise ValueError(
                     "Cross section is not crossed by water level. Check if water level is within the cross section."
                 )
+            # sort the cross_sz points to go from s=0 to s max.
+            cross_sz = sorted(cross_sz, key=lambda p: p.x)
             # find xyz real-world coordinates and turn in to POINT Z list
             cross = [
                 geometry.Point(self.interp_x_from_s(c.xy[0]), self.interp_y_from_s(c.xy[0]), c.xy[1]) for c in cross_sz
@@ -519,7 +562,84 @@ class CrossSection:
         polygons = [geometry.Polygon(coords) for coords in csl_pol_coords]
         return polygons
 
-    def get_bottom_surface(self, length: float = 2.0, offset: float = 0.0, camera: bool = False, swap_y_coords=False):
+    def get_bbox_dry_wet(
+        self,
+        h: float,
+        camera: bool = False,
+        swap_y_coords: bool = False,
+        dry: bool = False,
+        expand_exterior: bool = True,
+        exterior_split: int = 100,
+    ):
+        """Get wet (or dry) part of bounding box, by extending the water line perpendicular to the cross section.
+
+        Parameters
+        ----------
+        h : float
+            water level [m]
+        camera : bool, optional
+            If set, return 2D projected polygon, by default False. Note that any plotting does not provide shading or
+            ray tracing hence plotting a 2D polygon is not recommended.
+        swap_y_coords : bool, optional
+            if set, all y-coordinates are swapped so that they fit on a flipped version of the image. This is useful
+            in case you plot on ascending y-coordinate axis background images (default: False)
+        dry : bool, optional
+            If set, the dry parts will be returned, by default False, thus returning wet.
+        expand_exterior : bool, optional
+            Set to True to expand the corner points to more points. This is particularly useful for plotting purposes.
+        exterior_split : int, optional
+            Amount of subline segments to split bounding box in
+
+        Returns
+        -------
+        shapely.geometry.MultiPolygon
+            multipolygon representing the dry or wet part of the bounding box of the camera config (2d if camera=True,
+            3d if camera=False).
+
+        See Also
+        --------
+        CrossSection.plot_bbox_dry_wet : Plot the dry and wet parts of the bounding box resulting from this method.
+
+
+
+        """
+        if self.camera_config.bbox is None:
+            raise ValueError("CameraConfig must have a bounding box to use this method.")
+        z_water = self.camera_config.h_to_z(h)  # 92.1 is exactly hitting a local peak
+        geom_plan_2d = force_2d(self.get_planar_surface(h=h, length=10000))
+
+        if dry:
+            # dry pols
+            pols = force_3d(self.camera_config.bbox.difference(geom_plan_2d), z=z_water)
+        else:
+            # wet pol(s)
+            pols = force_3d(self.camera_config.bbox.intersection(geom_plan_2d), z=z_water)
+        if isinstance(pols, geometry.MultiPolygon):
+            pols = pols.geoms
+        else:
+            pols = [pols]
+        pols_proj = []
+        for pol in pols:
+            coords = [[*p] for p in pol.exterior.coords]
+            if camera and len(coords) > 0:
+                # also split if required
+                if expand_exterior:
+                    coords_expand = np.zeros((0, 3))
+                    for n in range(0, len(coords) - 1):
+                        new_coords = np.linspace(coords[n], coords[n + 1], exterior_split // 4)
+                        coords_expand = np.r_[coords_expand, new_coords]
+                    # set expanded coords to original variable
+                    coords = coords_expand
+
+                coords_proj = self.camera_config.project_points(coords, swap_y_coords=swap_y_coords, within_image=True)
+                pols_proj.append(geometry.Polygon(coords_proj))
+            else:
+                pols_proj.append(geometry.Polygon(coords))
+        return geometry.MultiPolygon(pols_proj)
+
+    def get_bottom_surface(
+        self, length: float = 2.0, offset: float = 0.0, camera: bool = False, swap_y_coords: bool = False
+    ):
         """Retrieve a bottom surface polygon for the entire cross section, expanded over a length.
 
         Returns a 2D Polygon if camera is True, 3D if False. Useful in particular for 3d situation plots.
@@ -578,7 +698,7 @@ class CrossSection:
 
     def get_planar_surface(
         self, h: float, length: float = 2.0, offset: float = 0.0, camera: bool = False, swap_y_coords=False
-    ) -> geometry.Polygon:
+    ) -> Union[geometry.Polygon, geometry.MultiPolygon]:
         """Retrieve a planar water surface for a given water level, as a geometry.Polygon.
 
         Returns a 2D Polygon if camera is True, 3D if False
@@ -608,10 +728,50 @@ class CrossSection:
         CrossSection.plot_planar_surface : Plot the planar surface resulting from this method.
 
         """
+        # Get the water level crossing points (not camera projected for validation)
+        csl_points = self.get_csl_point(h=h, camera=False)
+        if len(csl_points) < 2:
+            raise ValueError(
+                f"Cross section must have at least two points to estimate a planar surface ({len(csl_points)} found)."
+            )
         wls = self.get_csl_line(h=h, offset=offset, length=length, camera=camera, swap_y_coords=swap_y_coords)
-        if len(wls) != 2:
-            raise ValueError("Amount of water line crossings must be 2 for a planar surface estimate.")
-        return geometry.Polygon(list(wls[0].coords) + list(wls[1].coords[::-1]))
+
+        valid_pairs = []
+        for p1, p2, l1, l2 in zip(csl_points[0:-1], csl_points[1:], wls[0:-1], wls[1:]):
+            # get s-coordinates
+            s1 = self.cs_linestring.project(geometry.Point(p1.x, p1.y))
+            s2 = self.cs_linestring.project(geometry.Point(p2.x, p2.y))
+
+            # check bottom elevation at midpoint
+            s_mid = (s1 + s2) / 2
+            z_bottom_mid = self.interp_z_from_s(s_mid)
+            if z_bottom_mid < p1.z:
+                valid_pairs.append((l1, l2))
+        if len(valid_pairs) == 0:
+            raise ValueError(
+                "No valid water level crossings found. Check if water level is within the cross section and if "
+                "the cross section is crossed by water."
+            )
+
+        # build the polygons
+        polygons = []
+        for l1, l2 in valid_pairs:
+            pol = geometry.Polygon(list(l1.coords) + list(l2.coords[::-1]))
+            if pol.is_valid and not pol.is_empty:
+                polygons.append(pol)
+
+        if len(polygons) == 0:
+            raise ValueError(
+                "No valid polygons found. Check if water level is within the cross section and if "
+                "the cross section is crossed by water."
+            )
+        elif len(polygons) == 1:
+            return polygons[0]
+        else:
+            return geometry.MultiPolygon(polygons)
+        # if len(wls) != 2:
+        #     raise ValueError("Amount of water line crossings must be 2 for a planar surface estimate.")
+        # return geometry.Polygon(list(wls[0].coords) + list(wls[1].coords[::-1]))
 
     def get_wetted_surface_sz(
         self, h: float, perimeter: bool = False
@@ -968,6 +1128,35 @@ class CrossSection:
                 stacklevel=2,
             )
 
+    def plot_bbox_dry_wet(
+        self,
+        h: float,
+        camera: bool = False,
+        ax=None,
+        swap_y_coords: bool = False,
+        kwargs_wet: Optional[Dict] = None,
+        kwargs_dry: Optional[Dict] = None,
+    ):
+        """Plot the bounding box of the dry and wet surfaces for a given water level."""
+        if kwargs_wet is None:
+            kwargs_wet = dict(color="b", label="wet")
+        if kwargs_dry is None:
+            kwargs_dry = dict(color="g", label="dry")
+        if ax is None:
+            if camera:
+                ax = plt.axes()
+            else:
+                ax = plt.axes(projection="3d")
+        dry_pols = self.get_bbox_dry_wet(h=h, dry=True, camera=camera, swap_y_coords=swap_y_coords)
+        wet_pols = self.get_bbox_dry_wet(h=h, dry=False, camera=camera, swap_y_coords=swap_y_coords)
+        if camera:
+            _ = plot_helpers.plot_polygon(wet_pols, ax=ax, **kwargs_wet)
+            p = plot_helpers.plot_polygon(dry_pols, ax=ax, **kwargs_dry)
+        else:
+            _ = plot_helpers.plot_3d_polygon(wet_pols, ax=ax, **kwargs_wet)
+            p = plot_helpers.plot_3d_polygon(dry_pols, ax=ax, **kwargs_dry)
+        return p.axes
+
     def plot_bottom_surface(
         self, length: float = 2.0, offset: float = 0.0, camera: bool = False, ax=None, swap_y_coords=False, **kwargs
     ) -> mpl.axes.Axes:
@@ -1099,6 +1288,73 @@ class CrossSection:
             )
         return ax
 
+    def rotate_translate(self, angle: Optional[float] = None, xoff: float = 0.0, yoff: float = 0.0, zoff: float = 0.0):
+        """Rotate and translate cross section to match config.
+
+        Parameters
+        ----------
+        angle : float, optional
+            Rotation angle in radians (anti-clockwise) around the center of the bounding box
+        xoff : float, optional
+            Translation distance in x direction in m.
+        yoff : float, optional
+            Translation distance in y direction in m.
+        zoff : float, optional
+            Translation distance in z direction in m.
+
+        Returns
+        -------
+        CrossSection
+            New transformed cross section instance.
+
+        """
+        # Apply rotation if specified
+        if angle is not None:
+            # Get centroid as origin
+            centroid = self.cs_linestring.centroid
+            # Apply rotation around centroid
+            new_line = rotate(
+                self.cs_linestring,
+                angle,
+                origin=centroid,
+                use_radians=True,
+            )
+        else:
+            new_line = copy.deepcopy(self.cs_linestring)
+        # now translate
+        new_line = translate(new_line, xoff=xoff, yoff=yoff, zoff=zoff)
+        # create a new cross section object
+        return CrossSection(self.camera_config, list(new_line.coords))
+
+    def linearize(self):
+        """Snap cross-section points to a best-fit straight line while preserving Z values.
+
+        The points are projected onto the line, maintaining their relative positions along it.
+
+        Returns
+        -------
+        CrossSection
+            New straightened cross section instance.
+
+        """
+        # Fit straight line
+        centroid, direction, angle = _fit_line(self.x, self.y)
+
+        # Project each point onto the line closest-distance
+        coords = np.column_stack([self.x, self.y])
+        coords_centered = coords - centroid
+
+        # Project onto the line direction
+        projections = np.dot(coords_centered, direction)
+
+        # Calculate new coordinates on the line
+        new_x = centroid[0] + projections * direction[0]
+        new_y = centroid[1] + projections * direction[1]
+
+        # Create new geometries with Z preserved
+        new_points = [[_x, _y, _z] for _x, _y, _z in zip(new_x, new_y, self.z)]
+        return CrossSection(self.camera_config, new_points)
+
     def _preprocess_level_range(
         self,
         min_h: Optional[float] = None,

pyorc/cv.py

@@ -1163,11 +1163,17 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None, camer
             k2 = x[param_nr + 1]
             dist_coeffs_sample[0][0] = k1
             dist_coeffs_sample[1][0] = k2
+            fx = camera_matrix_sample[0, 2]
+            fy = camera_matrix_sample[1, 2]
+            r_max = np.sqrt(fx**2 + fy**2) * camera_matrix_sample[0, 0]
+            penalty_k1k2 = radial_monotonicity_penalty(k1, k2, r_max)
+
         else:
             # take the existing distortion coefficients
             dist_coeffs_sample = dist_coeffs.copy()
             k1 = dist_coeffs_sample[0][0]
             k2 = dist_coeffs_sample[1][0]
+            penalty_k1k2 = 0.0
 
         # initialize error
         err = 100
@@ -1195,8 +1201,18 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None, camer
                 cam_err = ((_lens_pos - lens_pos2.flatten()) ** 2).sum() ** 0.5
                 # TODO: for now camera errors are weighted with 10% needs further investigation
             err = float(0.1 * cam_err + gcp_err) if cam_err is not None else gcp_err
+        # penalize non monotonically increasing functions
+        err += 100 * penalty_k1k2
         return err  # assuming gcp pixel distance is about 5 cm
 
+    def radial_monotonicity_penalty(k1, k2, r_max):
+        """Penalty in case radii do not monotonically increase towards the border."""
+        rs = np.linspace(0, r_max, 50)
+        deriv = 1 + 3 * k1 * rs**2 + 5 * k2 * rs**4
+        # penalize negative slope
+        penalty = np.sum(np.clip(-deriv, 0, None))
+        return penalty
+
     # determine optimization bounds
     bounds = []
     if camera_matrix is not None and dist_coeffs is not None:
@@ -1205,8 +1221,8 @@ def optimize_intrinsic(src, dst, height, width, c=2.0, lens_position=None, camer
     if camera_matrix is None:
         bounds.append([float(0.25), float(2)])
     if len(dst) > 4 and dist_coeffs is None:
-        bounds.append([-0.9, 0.9])  # k1
-        bounds.append([-0.5, 0.5])  # k2
+        bounds.append([-0.5, 0.5])  # k1
+        bounds.append([-0.1, 0.1])  # k2
     else:
         # set a warning if dist_coeffs is provided without sufficient ground control
         if dist_coeffs:

pyorc/plot_helpers.py

@@ -22,7 +22,8 @@ def plot_3d_polygon(polygon, ax=None, **kwargs):
     """Plot a shapely.geometry.Polygon or MultiPolygon on matplotlib 3d ax."""
     if isinstance(polygon, geometry.MultiPolygon):
         for pol in polygon.geoms:
-            p = _plot_3d_pol(pol, ax=ax, **kwargs)
+            label = kwargs.pop("label", None)
+            p = _plot_3d_pol(pol, ax=ax, label=label, **kwargs)
     else:
         p = _plot_3d_pol(polygon, ax=ax, **kwargs)
     return p
@@ -34,7 +35,8 @@ def plot_polygon(polygon, ax=None, **kwargs):
         ax = plt.axes()
     if isinstance(polygon, geometry.MultiPolygon):
         for pol in polygon.geoms:
-            patch = plt.Polygon(pol.exterior.coords, **kwargs)
+            label = kwargs.pop("label", None)
+            patch = plt.Polygon(pol.exterior.coords, label=label, **kwargs)
             p = ax.add_patch(patch)
     else:
         patch = plt.Polygon(polygon.exterior.coords, **kwargs)