pyopenrivercam 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

pyorc/api/frames.py

@@ -273,54 +273,13 @@ class Frames(ORCBase):
             {"xs": xs, "ys": ys, "lon": lons, "lat": lats}, coords, const.GEOGRAPHICAL_ATTRS
         )
         if "rgb" in da_proj.dims and len(da_proj.dims) == 4:
-            # ensure that "rgb" is the last dimension
+            # ensure that "rgb" is the last dimension and dtype is int
             da_proj = da_proj.transpose("time", "y", "x", "rgb")
+            da_proj = da_proj.astype("uint8")
         # in case resolution was changed, overrule the camera_config attribute
         da_proj.attrs.update(camera_config=cc.to_json())
         return da_proj
 
-    def landmask(self, dilate_iter=10, samples=15):
-        """Attempt to mask out land from water.
-
-        This is done by assuming that the time standard deviation over mean of land is much
-        higher than that of water. An automatic threshold using Otsu thresholding is used to separate and a dilation
-        operation is used to make the land mask slightly larger than the exact defined pixels.
-
-        Parameters
-        ----------
-        dilate_iter : int, optional
-            number of dilation iterations to use, to dilate land mask (Default value = 10)
-        samples : int, optional
-            amount of samples to retrieve from frames for estimating standard deviation and mean. Set to a lower
-            number to speed up calculation (Default value = 15)
-
-        Returns
-        -------
-        da : xr.DataArray
-            filtered frames
-
-        """
-        time_interval = round(len(self._obj) / samples)
-        assert time_interval != 0, f"Amount of frames is too small to provide {samples} samples"
-        # ensure attributes are kept
-        xr.set_options(keep_attrs=True)
-        # compute standard deviation over mean, assuming this value is low over water, and high over land
-        std_norm = (self._obj[::time_interval].std(axis=0) / self._obj[::time_interval].mean(axis=0)).load()
-        # retrieve a simple 3x3 equal weight kernel
-        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
-        # dilate the std_norm by some dilation iterations
-        dilate_std_norm = cv2.dilate(std_norm.values, kernel, iterations=dilate_iter)
-        # rescale result to typical uint8 0-255 range
-        img = cv2.normalize(
-            dilate_std_norm, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F
-        ).astype(np.uint8)
-        # threshold with Otsu thresholding
-        ret, thres = cv2.threshold(img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        # mask is where thres is
-        mask = thres != 255
-        # make mask 3-dimensional
-        return self._obj * mask
-
     def normalize(self, samples=15):
         """Remove the temporal mean of sampled frames.
 
@@ -406,6 +365,23 @@ class Frames(ORCBase):
         """
         return np.maximum(np.minimum(self._obj, max), min)
 
+    def range(self):
+        """Return the range of pixel values through time.
+
+        Returned array does not have a time dimension. This filter is typically used to detect
+        widely changing pixels, e.g. to distinguish moving water from land.
+
+        Returns
+        -------
+        xr.DataArray
+            Single image (with coordinates) with minimum-maximum range in time [x, y]
+
+        """
+        range_da = (self._obj.max(dim="time", keep_attrs=True) - self._obj.min(dim="time", keep_attrs=True)).astype(
+            self._obj.dtype
+        )  # ensure dtype out is same as dtype in
+        return range_da
+
     def reduce_rolling(self, samples=25):
         """Remove a rolling mean from the frames.
 
@@ -601,21 +577,6 @@ class Frames(ORCBase):
 
                     out.write(img)
                     pbar.update(1)
-        #
-        # pbar = tqdm(self._obj, position=0, leave=True)
-        # pbar.set_description("Writing frames")
-        # for n, f in enumerate(pbar):
-        #     if len(f.shape) == 3:
-        #         img = cv2.cvtColor(np.uint8(f.values), cv2.COLOR_RGB2BGR)
-        #     else:
-        #         img = f.values
-        #         if n == 0:
-        #             # make a scale between 0 and 255, only with first frame
-        #             img_min = img.min(axis=0).min(axis=0)
-        #             img_max = img.max(axis=0).max(axis=0)
-        #         img = np.uint8(255 * ((img - img_min) / (img_max - img_min)))
-        #         img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-        #     out.write(img)
         out.release()
 
     plot = _frames_plot

pyorc/api/plot.py

@@ -6,8 +6,7 @@ import functools
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mticker
 import numpy as np
-from matplotlib import patheffects
-from matplotlib.collections import QuadMesh
+from matplotlib import colors, patheffects
 
 from pyorc import helpers
 
@@ -132,7 +131,7 @@ def _base_plot(plot_func):
 
         # check if dataset is a transect or not
         is_transect = True if "points" in ref._obj.dims else False
-
+        kwargs = set_default_kwargs(kwargs, method=plot_func.__name__, mode=mode)
         assert mode in ["local", "geographical", "camera"], 'Mode must be "local", "geographical" or "camera"'
         if mode == "local":
             x = ref._obj["x"].values
@@ -185,16 +184,26 @@ def _base_plot(plot_func):
                         planar=False,
                         bottom=False,
                     )
-                    ref._obj.transect.cross_section.plot_water_level(
-                        h=ref._obj.transect.h_a,
-                        length=2.0,
-                        linewidth=3.0,
-                        ax=ax,
-                        camera=True,
-                        swap_y_coords=True,
-                        color="r",
-                        label="water level",
+                    # check if water level is above the lowest level
+                    check_low = (
+                        ref._obj.transect.camera_config.h_to_z(ref._obj.transect.h_a)
+                        > ref._obj.transect.cross_section.z.min()
                     )
+                    check_high = (
+                        ref._obj.transect.camera_config.h_to_z(ref._obj.transect.h_a)
+                        < ref._obj.transect.cross_section.z.max()
+                    )
+                    if check_low and check_high:
+                        ref._obj.transect.cross_section.plot_water_level(
+                            h=ref._obj.transect.h_a,
+                            length=2.0,
+                            linewidth=3.0,
+                            ax=ax,
+                            camera=True,
+                            swap_y_coords=True,
+                            color="r",
+                            label="water level",
+                        )
 
                     # draw some depth lines for better visual interpretation.
                     depth_lines = ref._obj.transect.get_depth_perspective(h=ref._obj.transect.h_a)
@@ -279,23 +288,22 @@ def _frames_plot(ref, ax=None, mode="local", **kwargs):
         x = "xp"
         y = "yp"
     assert all(v in ref._obj.coords for v in [x, y]), f'required coordinates "{x}" and/or "{y}" are not available'
-    if len(ref._obj.shape) == 3 and ref._obj.shape[-1] == 3:
-        # looking at an rgb image
-        facecolors = ref._obj.values.reshape(ref._obj.shape[0] * ref._obj.shape[1], 3) / 255
-        facecolors = np.hstack([facecolors, np.ones((len(facecolors), 1))])
-        primitive = ax.pcolormesh(
-            ref._obj[x],
-            ref._obj[y],
-            ref._obj.mean(dim="rgb"),
-            shading="nearest",
-            facecolors=facecolors,
-            **kwargs,
-        )
-        # remove array values, override .set_array, needed in case GeoAxes is provided, because GeoAxes asserts if
-        # array has dims
-        QuadMesh.set_array(primitive, None)
-    else:
+    if x == "x":
+        # use a simple imshow, much faster
+        dx = abs(float(ref._obj[x][1] - ref._obj[x][0]))  # x grid cell size
+        dy = abs(float(ref._obj[y][1] - ref._obj[y][0]))  # y grid cell size
+        # Calculate extent with half grid cell expansion
+        extent = [
+            ref._obj[x].min().item() - 0.5 * dx,
+            ref._obj[x].max().item() + 0.5 * dx,
+            ref._obj[y].min().item() - 0.5 * dy,
+            ref._obj[y].max().item() + 0.5 * dy,
+        ]
+
+    if x != "x":
         primitive = ax.pcolormesh(ref._obj[x], ref._obj[y], ref._obj, **kwargs)
+    else:
+        primitive = ax.imshow(ref._obj, origin="upper", extent=extent, aspect="auto", **kwargs)
     # fix axis limits to min and max of extent of frames
     if mode == "geographical":
         ax.set_extent(
@@ -371,7 +379,8 @@ class _Transect_PlotMethods:
         _u = self._obj[v_eff] * np.sin(self._obj[v_dir])
         _v = self._obj[v_eff] * np.cos(self._obj[v_dir])
         s = np.abs(self._obj[v_eff].values)
-        x_moved, y_moved = x + _u * dt, y + _v * dt
+        # x_moved, y_moved = x + _u * dt, y + _v * dt
+        x_moved, y_moved = x + _u, y + _v
         # transform to real-world
         cols_moved, rows_moved = x_moved / camera_config.resolution, y_moved / camera_config.resolution
         rows_moved = camera_config.shape[0] - rows_moved
@@ -496,9 +505,11 @@ class _Velocimetry_PlotMethods:
         """
         # select lon and lat variables as coordinates
         velocimetry = self._obj.velocimetry
-        u = self._obj["v_x"]
-        v = -self._obj["v_y"]
-        s = (u**2 + v**2) ** 0.5
+        v_x = self._obj["v_x"].values
+        v_y = self._obj["v_y"].values
+        u = v_x / (2 * 1e5)  # 1e5 is aobut the amount of meters per degree
+        v = -v_y / (2 * 1e5)
+        s = (v_x**2 + v_y**2) ** 0.5
         aff = velocimetry.camera_config.transform
         theta = np.arctan2(aff.d, aff.a)
         # rotate velocity vectors along angle theta to match the requested projection. this only changes values
@@ -519,9 +530,14 @@ class _Velocimetry_PlotMethods:
             scalar velocity
 
         """
-        u = self._obj["v_x"].values
-        v = -self._obj["v_y"].values
-        s = (u**2 + v**2) ** 0.5
+        # u and v should be scaled to a nice proportionality for local plots. This is typically about 2x smaller
+        # than the m/s values
+        v_x = self._obj["v_x"].values
+        v_y = self._obj["v_y"].values
+
+        u = v_x / 2
+        v = -v_y / 2
+        s = (v_x**2 + v_y**2) ** 0.5
         return u, v, s
 
     def get_uv_camera(self, dt=0.1):
@@ -552,7 +568,8 @@ class _Velocimetry_PlotMethods:
         yi = np.flipud(yi)
 
         # follow the velocity vector over a short distance (dt*velocity)
-        x_moved, y_moved = xi + self._obj["v_x"] * dt, yi + self._obj["v_y"] * dt
+        # x_moved, y_moved = xi + self._obj["v_x"] * dt, yi + self._obj["v_y"] * dt
+        x_moved, y_moved = xi + self._obj["v_x"] / 2, yi + self._obj["v_y"] / 2
         # transform to real-world
         cols_moved, rows_moved = x_moved / camera_config.resolution, y_moved / camera_config.resolution
         xs_moved, ys_moved = helpers.get_xs_ys(cols_moved, rows_moved, camera_config.transform)
@@ -578,10 +595,51 @@ class _Velocimetry_PlotMethods:
         return u, v, s
 
 
+def set_default_kwargs(kwargs, method="quiver", mode="local"):
+    """Set color mapping default kwargs if no vmin and/or vmax is supplied."""
+    if mode == "local":
+        # width scale is in cm
+        width_scale = 0.02
+    elif mode == "geographical":
+        # widths are in degrees
+        width_scale = 0.00000025
+    elif mode == "camera":
+        # widths in pixels
+        width_scale = 3.0
+    else:
+        raise ValueError("mode must be one of 'local', 'geographical' or 'camera'")
+    if "cmap" not in kwargs:
+        kwargs["cmap"] = "rainbow"  # the famous rainbow colormap!
+    if "vmin" not in kwargs and "vmax" not in kwargs and "norm" not in kwargs:
+        # set a normalization array
+        norm = [0, 0.05, 0.1, 0.2, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]
+        kwargs["norm"] = colors.BoundaryNorm(norm, ncolors=256, extend="max")
+    if method == "quiver":
+        if "scale" not in kwargs:
+            kwargs["scale"] = 1  # larger quiver arrows
+        if "units" not in kwargs:
+            kwargs["units"] = "xy"
+        # for width, it will matter a lot what mode is used, width should be a dimensionless number
+        if "width" not in kwargs:
+            kwargs["width"] = width_scale
+        else:
+            kwargs["width"] *= width_scale  # multiply
+
+    return kwargs
+
+
 @_base_plot
 def quiver(_, x, y, u, v, s=None, ax=None, **kwargs):
     """Create quiver plot from velocimetry results on new or existing axes.
 
+    Note that the `width` parameter is always in a unitless scale, with `1` providing a nice-looking default value
+    for all plot modes. The default value is usually very nice. If you do want to change:
+
+    The `scale` parameter defaults to 1, providing a nice looking arrow length. With a smaller (larger) value,
+    quivers will become longer (shorter).
+
+    The `width` parameter is in a unitless scale, with `1` providing a nice-looking default value.
+
     Wraps :py:func:`matplotlib:matplotlib.pyplot.quiver`.
     """
     if "color" in kwargs:

pyorc/cli/cli_utils.py

@@ -136,7 +136,12 @@ def get_gcps_optimized_fit(src, dst, height, width, c=2.0, camera_matrix=None, d
     src_est, jacobian = cv2.projectPoints(_dst, rvec, tvec, camera_matrix, np.array(dist_coeffs))
     src_est = np.array([list(point[0]) for point in src_est])
     dst_est = cv.unproject_points(_src, _dst[:, -1], rvec, tvec, camera_matrix, dist_coeffs)
+    # add mean coordinates to estimated locations
     dst_est = np.array(dst_est)[:, 0 : len(coord_mean)] + coord_mean
+    # also reverse rvec and tvec to real-world (rw), add mean coordinate, and reverse again.
+    rvec_cam, tvec_cam = cv.pose_world_to_camera(rvec, tvec)
+    tvec_cam += coord_mean
+    rvec, tvec = cv.pose_world_to_camera(rvec_cam, tvec_cam)
     return src_est, dst_est, camera_matrix, dist_coeffs, rvec, tvec, err
 
 
@@ -324,15 +329,8 @@ def read_shape_as_gdf(fn=None, geojson=None, gdf=None):
             crs = None
         gdf = gpd.GeoDataFrame().from_features(geojson, crs=crs)
     else:
-        gdf = gpd.read_file(fn)
-        crs = gdf.crs if hasattr(gdf, "crs") else None
-        # also read raw json, and check if crs attribute exists
-        with open(fn, "r") as f:
-            raw_json = json.load(f)
-        if "crs" not in raw_json:
-            # override the crs
-            crs = None
-            gdf = gdf.set_crs(None, allow_override=True)
+        gdf = helpers.read_shape_safe_crs(fn)
+        crs = gdf.crs
     # check if all geometries are points
     assert all([isinstance(geom, Point) for geom in gdf.geometry]), (
         "shapefile may only contain geometries of type " '"Point"'

pyorc/cli/main.py

@@ -312,9 +312,17 @@ def camera_config(
 @click.option(
     "--cross",
     type=click.Path(exists=True, resolve_path=True, dir_okay=False, file_okay=True),
+    help="Cross section file (*.geojson). This will be used for discharge estimation if the `transect` "
+    " section is provided in your recipe.",
+    callback=cli_utils.parse_cross_section_gdf,
+    required=False,
+)
+@click.option(
+    "--cross_wl",
+    type=click.Path(exists=True, resolve_path=True, dir_okay=False, file_okay=True),
     help="Cross section file (*.geojson). If you provide this, you may add water level retrieval settings to the"
-    " recipe section video: water_level: For more information see"
-    " [PyORC docs](https://localdevices.github.io/pyorc/user-guide/video/index.html)",
+    " recipe in the section `water_level`. For more information see"
+    " [PyORC docs](https://localdevices.github.io/pyorc/user-guide/cross_section/index.html)",
     callback=cli_utils.parse_cross_section_gdf,
     required=False,
 )
@@ -333,7 +341,7 @@ def camera_config(
 )
 @verbose_opt
 @click.pass_context
-def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross, update, lowmem, verbose):
+def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross, cross_wl, update, lowmem, verbose):
     """CLI subcommand for velocimetry."""
     log_level = max(10, 20 - 10 * verbose)
     logger = log.setuplog("velocimetry", os.path.abspath("pyorc.log"), append=False, log_level=log_level)
@@ -345,6 +353,7 @@ def velocimetry(ctx, output, videofile, recipe, cameraconfig, prefix, h_a, cross
         cameraconfig=cameraconfig,
         h_a=h_a,
         cross=cross,
+        cross_wl=cross_wl,
         prefix=prefix,
         output=output,
         update=update,

pyorc/cv.py

@@ -9,7 +9,7 @@ import numpy as np
 import rasterio
 from scipy import optimize
 from shapely.affinity import rotate
-from shapely.geometry import LineString, Polygon
+from shapely.geometry import LineString, Point, Polygon
 from tqdm import tqdm
 
 from . import helpers
@@ -88,6 +88,56 @@ def _combine_m(m1, m2):
     return m_combi
 
 
+def _get_aoi_corners(dst_corners, resolution=None):
+    polygon = Polygon(dst_corners)
+    coords = np.array(polygon.exterior.coords)
+    # estimate the angle of the bounding box
+    # retrieve average line across AOI
+    point1 = (coords[0] + coords[3]) / 2
+    point2 = (coords[1] + coords[2]) / 2
+    diff = point2 - point1
+    angle = np.arctan2(diff[1], diff[0])
+    # rotate the polygon over this angle to get a proper bounding box
+    polygon_rotate = rotate(polygon, -angle, origin=tuple(dst_corners[0]), use_radians=True)
+
+    xmin, ymin, xmax, ymax = polygon_rotate.bounds
+    if resolution is not None:
+        xmin = helpers.round_to_multiple(xmin, resolution)
+        xmax = helpers.round_to_multiple(xmax, resolution)
+        ymin = helpers.round_to_multiple(ymin, resolution)
+        ymax = helpers.round_to_multiple(ymax, resolution)
+
+    bbox_coords = [(xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin), (xmin, ymax)]
+    bbox = Polygon(bbox_coords)
+    # now rotate back
+    bbox = rotate(bbox, angle, origin=tuple(dst_corners[0]), use_radians=True)
+    return bbox
+
+
+def _get_aoi_width_length(dst_corners):
+    points = [Point(x, y) for x, y, _ in dst_corners]
+    linecross = LineString([points[0], points[1]])
+    # linecross = LineString(dst_corners[0:2])
+    length = np.abs(_get_perpendicular_distance(points[-1], linecross))
+    point1 = np.array(dst_corners[0][0:2])
+    point2 = np.array(dst_corners[1][0:2])
+    diff = np.array(point2 - point1)
+    angle = np.arctan2(diff[1], diff[0])
+
+    # compute xy distance from line to other line making up the bounding box
+    xy_diff = np.array([np.sin(-angle) * length, np.cos(angle) * length])
+    points_pol = np.array([point1 - xy_diff, point1 + xy_diff, point2 + xy_diff, point2 - xy_diff])
+    # always make sure the order of the points of upstream-left, downstream-left, downstream-right, upstream-right
+    # if length <= 0:
+    #     # negative length means the selected length is selected upstream of left-right cross section
+    #     points_pol = np.array([point1 + xy_diff, point1, point2, point2 + xy_diff])
+    # else:
+    #     # postive means it is selected downstream of left-right cross section
+    #     points_pol = np.array([point1, point1 + xy_diff, point2 + xy_diff, point2])
+
+    return Polygon(points_pol)
+
+
 def _smooth(img, stride):
     """Blur image through gaussian smoothing.
 
@@ -152,6 +202,52 @@ def _get_dist_coefs(k1):
     return dist
 
 
+def _get_perpendicular_distance(point, line):
+    """Calculate perpendicular distance from point to line.
+
+    Line is extended if perpendicular distance is larger than the distance to the endpoints.
+
+    Parameters
+    ----------
+    point : shapely.geometry.Point
+        x, y coordinates of point
+    line : shapely.geometry.LineString
+        line to calculate distance to
+
+    Returns
+    -------
+    float
+        perpendicular distance from point to line
+
+    """
+    # Get coordinates of line endpoints
+    p1 = np.array(line.coords[0])
+    p2 = np.array(line.coords[1])
+    # Convert point to numpy array
+    p3 = np.array(point.coords[0])
+
+    # Calculate line vector
+    line_vector = p2 - p1
+    # Calculate vector from point to line start
+    point_vector = p3 - p1
+
+    # Calculate unit vector of line
+    unit_line = line_vector / np.linalg.norm(line_vector)
+
+    # Calculate projection length
+    projection_length = np.dot(point_vector, unit_line)
+
+    # Calculate perpendicular vector
+    perpendicular_vector = point_vector - projection_length * unit_line
+    perpendicular_distance = np.linalg.norm(perpendicular_vector)
+
+    # Use cross product to calculate side
+    cross_product = np.cross(line_vector, point_vector)
+
+    # Determine the sign of the perpendicular distance
+    return perpendicular_distance if cross_product > 0 else -perpendicular_distance
+
+
 def get_cam_mtx(height, width, c=2.0, focal_length=None):
     """Compute camera matrix based on the given parameters for height, width, scaling factor, and focal length.
 
@@ -907,15 +1003,19 @@ def get_ortho(img, M, shape, flags=cv2.INTER_AREA):
     return cv2.warpPerspective(img, M, shape, flags=flags)
 
 
-def get_aoi(dst_corners, resolution=None):
-    """Get rectangular AOI from 4 user defined points within frames.
+def get_aoi(dst_corners, resolution=None, method="corners"):
+    """Get rectangular AOI from 3 or 4 user defined points within frames.
 
     Parameters
     ----------
     dst_corners : np.ndarray
-        corners of aoi, in order: upstream-left, downstream-left, downstream-right, upstream-right
+        corners of aoi, with `method="width_length"` in order: left-bank, right-bank, up/downstream point,
+        with `method="corners"` in order: upstream-left, downstream-left, downstream-right, upstream-right.
     resolution : float
         resolution of intended reprojection, used to round the bbox to a whole number of intended pixels
+    method : str
+        can be "corners" or "width_length". With "corners", the AOI is defined by the four corners of the rectangle.
+        With "width" length, the AOI is defined by the width (2 points) and length (1 point) of the rectangle.
 
     Returns
     -------
@@ -923,27 +1023,14 @@ def get_aoi(dst_corners, resolution=None):
         bounding box of aoi (with rotated affine)
 
     """
-    polygon = Polygon(dst_corners)
-    coords = np.array(polygon.exterior.coords)
-    # estimate the angle of the bounding box
-    # retrieve average line across AOI
-    point1 = (coords[0] + coords[3]) / 2
-    point2 = (coords[1] + coords[2]) / 2
-    diff = point2 - point1
-    angle = np.arctan2(diff[1], diff[0])
-    # rotate the polygon over this angle to get a proper bounding box
-    polygon_rotate = rotate(polygon, -angle, origin=tuple(dst_corners[0]), use_radians=True)
-    xmin, ymin, xmax, ymax = polygon_rotate.bounds
-    if resolution is not None:
-        xmin = helpers.round_to_multiple(xmin, resolution)
-        xmax = helpers.round_to_multiple(xmax, resolution)
-        ymin = helpers.round_to_multiple(ymin, resolution)
-        ymax = helpers.round_to_multiple(ymax, resolution)
+    if method == "corners":
+        bbox = _get_aoi_corners(dst_corners, resolution)
+    elif method == "width_length":
+        bbox = _get_aoi_width_length(dst_corners)
+
+    else:
+        raise ValueError("method must be 'corners' or 'width_length'")
 
-    bbox_coords = [(xmin, ymax), (xmax, ymax), (xmax, ymin), (xmin, ymin), (xmin, ymax)]
-    bbox = Polygon(bbox_coords)
-    # now rotate back
-    bbox = rotate(bbox, angle, origin=tuple(dst_corners[0]), use_radians=True)
     return bbox
 
 

pyorc/helpers.py

@@ -2,8 +2,10 @@
 
 import copy
 import importlib.util
+import json
 
 import cv2
+import geopandas as gpd
 import matplotlib.pyplot as plt
 import numpy as np
 import xarray as xr
@@ -582,6 +584,27 @@ def optimize_log_profile(
     return {"z0": z0, "k_max": k_max, "s0": s0, "s1": s1}
 
 
+def read_shape_safe_crs(fn):
+    """Read a shapefile with geopandas, but ensure that CRS is set to None when not available.
+
+    This function is required in cases where geometries must be read that do not have a specified CRS. Geopandas
+    defaults to WGS84 EPSG 4326 if the CRS is not specified.
+    """
+    gdf = gpd.read_file(fn)
+    # also read raw json, and check if crs attribute exists
+    if isinstance(fn, str):
+        with open(fn, "r") as f:
+            raw_json = json.load(f)
+    else:
+        # apparently a file object was provided
+        fn.seek(0)
+        raw_json = json.load(fn)
+    if "crs" not in raw_json:
+        # override the crs
+        gdf = gdf.set_crs(None, allow_override=True)
+    return gdf
+
+
 def rotate_u_v(u, v, theta, deg=False):
     """Rotate u and v components of vector counterclockwise by an amount of rotation.
 

pyorc/plot_helpers.py

@@ -2,10 +2,11 @@
 
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+from shapely import geometry
 
 
-def plot_3d_polygon(polygon, ax=None, **kwargs):
-    """Plot a shapely.geometry.Polygon on matplotlib 3d ax."""
+def _plot_3d_pol(polygon, ax=None, **kwargs):
+    """Plot single polygon on matplotlib 3d ax."""
     x, y, z = zip(*polygon.exterior.coords)
     verts = [list(zip(x, y, z))]
 
@@ -17,13 +18,27 @@ def plot_3d_polygon(polygon, ax=None, **kwargs):
     return p
 
 
+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)
+    else:
+        p = _plot_3d_pol(polygon, ax=ax, **kwargs)
+    return p
+
+
 def plot_polygon(polygon, ax=None, **kwargs):
-    """Plot a shapely.geometry.Polygon on matplotlib ax."""
-    # x, y = zip(*polygon.exterior.coords)
+    """Plot a shapely.geometry.Polygon or MultiPolygon on matplotlib ax."""
     if ax is None:
         ax = plt.axes()
-    patch = plt.Polygon(polygon.exterior.coords, **kwargs)
-    p = ax.add_patch(patch)
+    if isinstance(polygon, geometry.MultiPolygon):
+        for pol in polygon.geoms:
+            patch = plt.Polygon(pol.exterior.coords, **kwargs)
+            p = ax.add_patch(patch)
+    else:
+        patch = plt.Polygon(polygon.exterior.coords, **kwargs)
+        p = ax.add_patch(patch)
     return p