resqpy 4.18.7__tar.gz → 4.18.9__tar.gz

{resqpy-4.18.7 → resqpy-4.18.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.18.7
+Version: 4.18.9
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT

{resqpy-4.18.7 → resqpy-4.18.9}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.18.7" # Set at build time
+version = "4.18.9" # Set at build time
 description = "Python API for working with RESQML models"
 authors = ["BP"]
 license = "MIT"

{resqpy-4.18.7 → resqpy-4.18.9}/resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.18.7"  # Set at build time
+__version__ = "4.18.9"  # Set at build time
 log = logging.getLogger(__name__)
 log.info(f"Imported resqpy version {__version__}")

{resqpy-4.18.7 → resqpy-4.18.9}/resqpy/grid/_grid.py

@@ -1498,7 +1498,7 @@ class Grid(BaseResqpy):
         """
         return z_corner_point_depths(self, order = order)
 
-    def frontier(self, set_z_zero = True, title = None, add_as_part = True):
+    def frontier(self, set_z_zero = True, title = None, add_as_part = True, mode = 'mean'):
         """Returns a frontier polygon (closed polyline) based on midpoints of edge coordinate lines, with z set to zero.
         
         arguments:
@@ -1507,35 +1507,59 @@ class Grid(BaseResqpy):
             - title (str, optional): the citation title for the polyline; if None, one is generated using the grid title
             - add_as_part (bool default True): if True, the xml is created for the polyline and it is added as a part to
               the model; if False, the create_xml() method is not called fot the polyline
-              
+            - mode (str, default 'mean'): one of 'mean', 'top', 'base', 'inner', 'outer' determining how a non-vertical
+              edge coordinate line is converted to a point to include in the frontier
+
         returns:
             - closed Polyline representing the frontier of the grid in plan view
         """
+
+        def get_point(clep, mode, centrum):
+            if mode == 'mean':
+                return np.nanmean(clep, axis = 0)
+            if mode == 'top':
+                return clep[0]
+            if mode == 'base':
+                return clep[-1]
+            assert mode in ['inner', 'outer'], f'unrecognised frontier mode: {mode}'
+            vp = clep - np.expand_dims(centrum, axis = 0)
+            dp = np.sum(vp * vp, axis = -1)
+            if (dp[0] < dp[1] and mode == 'inner') or (dp[0] > dp[1] and mode == 'outer'):
+                return clep[0]
+            return clep[-1]
+
+        assert mode in ['mean', 'top', 'base', 'inner', 'outer']
         coords = self.coordinate_line_end_points()
+        centrum = None
+        if mode in ['inner', 'outer']:
+            centrum = np.nanmean(np.concatenate((coords[0, 0], coords[0, -1], coords[-1, 0], coords[-1, -1]), axis = 0),
+                                 axis = 0)
+            assert not np.any(
+                np.isnan(centrum)), f'trying to make frontier polygon in mode {mode} when corners of grid not defined'
         nj = self.nj
         ni = self.ni
         frontier = np.zeros((2 * (nj + ni), 3), dtype = float)
         f_i = 0
         for i in range(self.ni):
-            c = np.nanmean(coords[0, i], axis = 0)
+            c = get_point(coords[0, i], mode, centrum)
             if np.any(np.isnan(c)):
                 continue
             frontier[f_i] = c
             f_i += 1
         for j in range(self.nj):
-            c = np.nanmean(coords[j, ni], axis = 0)
+            c = get_point(coords[j, ni], mode, centrum)
             if np.any(np.isnan(c)):
                 continue
             frontier[f_i] = c
             f_i += 1
         for i in range(self.ni, 0, -1):
-            c = np.nanmean(coords[nj, i], axis = 0)
+            c = get_point(coords[nj, i], mode, centrum)
             if np.any(np.isnan(c)):
                 continue
             frontier[f_i] = c
             f_i += 1
         for j in range(self.nj, 0, -1):
-            c = np.nanmean(coords[j, 0], axis = 0)
+            c = get_point(coords[j, 0], mode, centrum)
             if np.any(np.isnan(c)):
                 continue
             frontier[f_i] = c

{resqpy-4.18.7 → resqpy-4.18.9}/resqpy/surface/_surface.py

@@ -1169,6 +1169,33 @@ class Surface(rqsb.BaseSurface):
 
         return resampled
 
+    def resample_surface_unique_edges(self):
+        """Returns a new surface, with the same model, title and crs as the original surface, but with additional refined points along original surface tears and edges. 
+        
+        Each edge forming a tear or outer edge in the surface will have 3 additional points added, with 2 additional points on each edge of the original triangle. The output surface is re-triangulated using these new points (tears will be filled)
+
+        returns: 
+            resqpy.surface.Surface object with extra_metadata ('unique edges resampled from surface': uuid), where uuid is for the original surface uuid
+        """
+        _, op = self.triangles_and_points()
+        ref = self.resampled_surface()  # resample the original surface
+        rt, rp = ref.triangles_and_points()
+        de, dc = ref.distinct_edges_and_counts()  # find the distinct edges and counts for the resampled surface
+        de_edge = de[dc == 1]  # find edges that only appear once - tears or surface edges
+        edge_tri_index = np.sum(np.isin(rt, de_edge), axis = 1) == 2
+        edge_tris = rp[rt[edge_tri_index]]
+        mid = np.mean(rp[de_edge], axis = 1)  # get the midpoint of each surface edge
+        edge_ref_points = np.unique(np.concatenate([op, edge_tris.reshape(-1, 3), mid]), axis = 0)  # combine all points
+
+        points = rqs.PointSet(self.model, points_array = edge_ref_points, title = self.title,
+                              crs_uuid = self.crs_uuid)  # generate a pointset from these points
+
+        output = Surface(self.model, point_set = points,
+                         extra_metadata = {'resampled from surface': str(self.uuid)
+                                          })  # return a surface with generated from these points
+
+        return output
+
     def write_hdf5(self, file_name = None, mode = 'a'):
         """Create or append to an hdf5 file, writing datasets for the triangulated patches after caching arrays.