resqpy 5.0.0__py3-none-any.whl → 5.1.1__py3-none-any.whl

resqpy/__init__.py

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

resqpy/grid_surface/_find_faces.py

@@ -880,7 +880,8 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                                       return_properties = None,
                                                       raw_bisector = False,
                                                       n_batches = 20,
-                                                      packed_bisectors = False):
+                                                      packed_bisectors = False,
+                                                      patch_indices = None):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -916,11 +917,14 @@ def find_faces_to_represent_surface_regular_optimised(grid,
            threading allows some parallelism between the batches)
         packed_bisectors (bool, default False): if True and return properties include 'grid bisector' then
            non curtain bisectors are returned in packed form
+        patch_indices (numpy int array, optional): if present, an array over grid cells indicating which 
+           patch of surface is applicable in terms of a bisector, for each cell
 
     returns:
         gcs  or  (gcs, gcs_props)
         where gcs is a new GridConnectionSet with a single feature, not yet written to hdf5 nor xml created;
-        gcs_props is a dictionary mapping from requested return_properties string to numpy array
+        gcs_props is a dictionary mapping from requested return_properties string to numpy array (or tuple
+            of numpy array and curtain bool in the case of grid bisector)
 
     notes:
         this function is designed for aligned regular grids only;
@@ -929,7 +933,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         no trimming of the surface is carried out here: for computational efficiency, it is recommended
         to trim first;
         organisational objects for the feature are created if needed;
-        if the offset return property is requested, the implicit units will be the z units of the grid's crs
+        if the offset return property is requested, the implicit units will be the z units of the grid's crs;
+        if patch_indices is present and grid bisectors are being returned, a composite bisector array is returned
+        with elements set from individual bisectors for each patch of surface
     """
 
     assert isinstance(grid, grr.RegularGrid)
@@ -959,7 +965,10 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         return_flange_bool = "flange bool" in return_properties
         if return_flange_bool:
             return_triangles = True
-
+    patchwork = return_bisector and patch_indices is not None
+    if patchwork:
+        return_triangles = True  # triangle numbers are used to infer patch index
+        assert patch_indices.shape == tuple(grid.extent_kji)
     if title is None:
         title = name
 
@@ -1165,7 +1174,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                                                    k_faces_kji0 = k_faces_kji0,
                                                    j_faces_kji0 = j_faces_kji0,
                                                    i_faces_kji0 = i_faces_kji0,
-                                                   remove_duplicates = True,
+                                                   remove_duplicates = not patchwork,
                                                    k_properties = k_props,
                                                    j_properties = j_props,
                                                    i_properties = i_props,
@@ -1176,6 +1185,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # log.debug('finished coversion to gcs')
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_tris = None
     if return_triangles:
         # log.debug('preparing triangles array')
         k_triangles = np.empty((0,), dtype = np.int32) if k_props is None else k_props.pop(0)
@@ -1186,6 +1196,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_tris.shape == (gcs.count,)
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_depths = None
     if return_depths:
         # log.debug('preparing depths array')
         k_depths = np.empty((0,), dtype = np.float64) if k_props is None else k_props.pop(0)
@@ -1196,6 +1207,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_depths.shape == (gcs.count,)
 
     # NB. following assumes faces have been added to gcs in a particular order!
+    all_offsets = None
     if return_offsets:
         # log.debug('preparing offsets array')
         k_offsets = np.empty((0,), dtype = np.float64) if k_props is None else k_props[0]
@@ -1205,6 +1217,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         # log.debug(f'gcs count: {gcs.count}; all offsets shape: {all_offsets.shape}')
         assert all_offsets.shape == (gcs.count,)
 
+    all_flange = None
     if return_flange_bool:
         # log.debug('preparing flange array')
         flange_bool_uuid = surface.model.uuid(title = "flange bool",
@@ -1217,8 +1230,9 @@ def find_faces_to_represent_surface_regular_optimised(grid,
         assert all_flange.shape == (gcs.count,)
 
     # note: following is a grid cells property, not a gcs property
+    bisector = None
     if return_bisector:
-        if is_curtain:
+        if is_curtain and not patchwork:
             log.debug("preparing columns bisector")
             if j_faces_kji0 is None:
                 j_faces_ji0 = np.empty((0, 2), dtype = np.int32)
@@ -1230,8 +1244,51 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                 i_faces_ji0 = i_faces_kji0[:, 1:]
             bisector = column_bisector_from_face_indices((grid.nj, grid.ni), j_faces_ji0, i_faces_ji0)
             # log.debug('finished preparing columns bisector')
+        elif patchwork:
+            n_patches = surface.number_of_patches()
+            nkf = len(k_faces_kji0)
+            njf = len(j_faces_kji0)
+            nif = len(i_faces_kji0)
+            # fetch patch indices for triangle hits
+            assert all_tris is not None and len(all_tris) == nkf + njf + nif
+            patch_indices_k = surface.patch_indices_for_triangle_indices(all_tris[:nkf])
+            patch_indices_j = surface.patch_indices_for_triangle_indices(all_tris[nkf:nkf + njf])
+            patch_indices_i = surface.patch_indices_for_triangle_indices(all_tris[nkf + njf:])
+            # add extra dimension to bisector array (at axis 0) for patches
+            pb_shape = tuple([n_patches] + list(grid.extent_kji))
+            if packed_bisectors:
+                bisector = np.ones(_shape_packed(grid.extent_kji), dtype = np.uint8)
+            else:
+                bisector = np.ones(tuple(grid.extent_kji), dtype = np.bool_)
+            # populate 4D bisector with an axis zero slice for each patch
+            for patch in range(n_patches):
+                mask = (patch_indices == patch)
+                if np.count_nonzero(mask) == 0:
+                    log.warning(f'patch {patch} of surface {surface.title} is not applicable to any cells in grid')
+                    continue
+                if packed_bisectors:
+                    mask = np.packbits(mask, axis = -1)
+                    patch_bisector, is_curtain =  \
+                        packed_bisector_from_face_indices(tuple(grid.extent_kji),
+                                                          k_faces_kji0[(patch_indices_k == patch).astype(bool)],
+                                                          j_faces_kji0[(patch_indices_j == patch).astype(bool)],
+                                                          i_faces_kji0[(patch_indices_i == patch).astype(bool)],
+                                                          raw_bisector)
+                    bisector = np.bitwise_or(np.bitwise_and(mask, patch_bisector), bisector)
+                else:
+                    patch_bisector, is_curtain =  \
+                        bisector_from_face_indices(tuple(grid.extent_kji),
+                                                   k_faces_kji0[(patch_indices_k == patch).astype(bool)],
+                                                   j_faces_kji0[(patch_indices_j == patch).astype(bool)],
+                                                   i_faces_kji0[(patch_indices_i == patch).astype(bool)],
+                                                   raw_bisector)
+                    bisector[mask] = patch_bisector[mask]
+                if is_curtain:
+                    # TODO: downgrade following to debug once downstream functionality tested
+                    log.warning(f'ignoring curtain nature of bisector for patch {patch} of surface: {surface.title}')
+                    is_curtain = False
         else:
-            log.debug("preparing cells bisector")
+            log.debug("preparing singlular cells bisector")
             if ((k_faces_kji0 is None or len(k_faces_kji0) == 0) and
                 (j_faces_kji0 is None or len(j_faces_kji0) == 0) and (i_faces_kji0 is None or len(i_faces_kji0) == 0)):
                 bisector = np.ones((grid.nj, grid.ni), dtype = bool)
@@ -1249,6 +1306,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
                     bisector = bisector[0]  # reduce to a columns property
 
     # note: following is a grid cells property, not a gcs property
+    shadow = None
     if return_shadow:
         log.debug("preparing cells shadow")
         shadow = shadow_from_face_indices(tuple(grid.extent_kji), k_faces_kji0)
@@ -1261,7 +1319,7 @@ def find_faces_to_represent_surface_regular_optimised(grid,
     # if returning properties, construct dictionary
     if return_properties:
         props_dict = {}
-        if return_triangles:
+        if 'triangle' in return_properties:
             props_dict["triangle"] = all_tris
         if return_depths:
             props_dict["depth"] = all_depths
@@ -1363,7 +1421,7 @@ def bisector_from_faces(  # type: ignore
         - the face sets must form a single 'sealed' cut of the grid (eg. not waving in and out of the grid)
         - any 'boxed in' parts of the grid (completely enclosed by bisecting faces) will be consistently
           assigned to either the True or False part
-        - this function is DEPRECATED, pending proving of newer indices based approach
+        - this function is DEPRECATED, use newer indices based approach instead: bisector_from_face_indices()
     """
     warnings.warn('DEPRECATED: grid_surface.bisector_from_faces() function; use bisector_from_face_indices() instead')
     assert len(grid_extent_kji) == 3
@@ -1408,10 +1466,13 @@ def bisector_from_faces(  # type: ignore
     # check all array elements are not the same
     true_count = np.count_nonzero(array)
     cell_count = array.size
-    assert (0 < true_count < cell_count), "face set for surface is leaky or empty (surface does not intersect grid)"
-
-    # negate the array if it minimises the mean k and determine if the surface is a curtain
-    is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -1482,10 +1543,13 @@ def bisector_from_face_indices(  # type: ignore
     # check all array elements are not the same
     true_count = np.count_nonzero(array)
     cell_count = array.size
-    assert (0 < true_count < cell_count), "face set for surface is leaky or empty (surface does not intersect grid)"
-
-    # negate the array if it minimises the mean k and determine if the surface is a curtain
-    is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        is_curtain = _shallow_or_curtain(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -1572,12 +1636,14 @@ def packed_bisector_from_face_indices(  # type: ignore
     else:
         true_count = _bitwise_count_njit(array)  # note: will usually include some padding bits, so not so true!
     cell_count = np.prod(grid_extent_kji)
-    assert (0 < true_count < cell_count), "face set for surface is leaky or empty (surface does not intersect grid)"
-
-    # negate the array if it minimises the mean k and determine if the surface is a curtain
-    is_curtain = _packed_shallow_or_curtain_temp_bitwise_count(array, true_count, raw_bisector)
-    # todo: switch to numpy bitwise_count when numba supports it and resqpy has dropped older numpy versions
-    # is_curtain = _packed_shallow_or_curtain(array, true_count, raw_bisector)
+    if 0 < true_count < cell_count:
+        # negate the array if it minimises the mean k and determine if the surface is a curtain
+        # TODO: switch to _packed_shallow_or_curtain_temp_bitwise_count() when numba supports np.bitwise_count()
+        is_curtain = _packed_shallow_or_curtain_temp_bitwise_count(array, true_count, raw_bisector)
+    else:
+        assert raw_bisector, 'face set for surface is leaky or empty (surface does not intersect grid)'
+        log.error('face set for surface is leaky or empty (surface does not intersect grid)')
+        is_curtain = False
 
     return array, is_curtain
 
@@ -2227,12 +2293,12 @@ def get_boundary_from_indices(  # type: ignore
         k_faces_kji0: Union[np.ndarray, None], j_faces_kji0: Union[np.ndarray, None],
         i_faces_kji0: Union[np.ndarray, None], grid_extent_kji: Tuple[int, int, int]) -> np.ndarray:
     """Return python protocol box containing indices"""
-    k_min_kji0 = None if k_faces_kji0 is None else np.min(k_faces_kji0, axis = 0)
-    k_max_kji0 = None if k_faces_kji0 is None else np.max(k_faces_kji0, axis = 0)
-    j_min_kji0 = None if j_faces_kji0 is None else np.min(j_faces_kji0, axis = 0)
-    j_max_kji0 = None if j_faces_kji0 is None else np.max(j_faces_kji0, axis = 0)
-    i_min_kji0 = None if i_faces_kji0 is None else np.min(i_faces_kji0, axis = 0)
-    i_max_kji0 = None if i_faces_kji0 is None else np.max(i_faces_kji0, axis = 0)
+    k_min_kji0 = None if (k_faces_kji0 is None or k_faces_kji0.size == 0) else np.min(k_faces_kji0, axis = 0)
+    k_max_kji0 = None if (k_faces_kji0 is None or k_faces_kji0.size == 0) else np.max(k_faces_kji0, axis = 0)
+    j_min_kji0 = None if (j_faces_kji0 is None or j_faces_kji0.size == 0) else np.min(j_faces_kji0, axis = 0)
+    j_max_kji0 = None if (j_faces_kji0 is None or j_faces_kji0.size == 0) else np.max(j_faces_kji0, axis = 0)
+    i_min_kji0 = None if (i_faces_kji0 is None or i_faces_kji0.size == 0) else np.min(i_faces_kji0, axis = 0)
+    i_max_kji0 = None if (i_faces_kji0 is None or i_faces_kji0.size == 0) else np.max(i_faces_kji0, axis = 0)
     box = np.empty((2, 3), dtype = np.int32)
     box[0, :] = grid_extent_kji
     box[1, :] = -1

resqpy/model/_forestry.py

@@ -686,17 +686,23 @@ def _copy_referenced_parts(model, other_model, realization, consolidate, force,
             resident_uuid_int = model.consolidation.map[ref_uuid_int]
             assert resident_uuid_int is not None
             # find referring node for ref_uuid_int and modify its reference to resident_uuid_int
-            if reference_node_dict is None:
+            if reference_node_dict is None:  # now mapping uuid int to list of nodes
                 ref_nodes = rqet.list_obj_references(root_node)
                 reference_node_dict = {}
                 for ref_node in ref_nodes:
                     uuid_node = rqet.find_tag(ref_node, 'UUID')
                     uuid_int = bu.uuid_from_string(uuid_node.text).int
-                    reference_node_dict[uuid_int] = uuid_node
-            uuid_node = reference_node_dict[ref_uuid_int]
-            uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
-            reference_node_dict.pop(ref_uuid_int)
-            reference_node_dict[resident_uuid_int] = uuid_node
+                    if uuid_int in reference_node_dict:
+                        reference_node_dict[uuid_int].append(uuid_node)
+                    else:
+                        reference_node_dict[uuid_int] = [uuid_node]
+            uuid_node_list = reference_node_dict.pop(ref_uuid_int)
+            for uuid_node in uuid_node_list:
+                uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
+            if resident_uuid_int in reference_node_dict:
+                reference_node_dict[resident_uuid_int] += uuid_node_list
+            else:
+                reference_node_dict[resident_uuid_int] = uuid_node_list
 
 
 def _copy_relationships_for_present_targets(model, other_model, consolidate, force, resident_uuid, root_node):

resqpy/model/_model.py

@@ -2100,6 +2100,11 @@ class Model():
         if other_model is self:
             return part
         assert part is not None
+        # check whether already existing in this model
+        if part in self.parts_forest.keys():
+            return part
+        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
+            return None
         if realization is not None:
             assert isinstance(realization, int) and realization >= 0
         if force:
@@ -2110,13 +2115,6 @@ class Model():
             self_h5_file_name = self.h5_file_name(file_must_exist = False)
         hdf5_copy_needed = not os.path.samefile(self_h5_file_name, other_h5_file_name)
 
-        # check whether already existing in this model
-        if part in self.parts_forest.keys():
-            return part
-
-        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
-            return None
-
         return m_f._copy_part_from_other_model(self,
                                                other_model,
                                                part,

resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -4,8 +4,10 @@ import logging
 
 log = logging.getLogger(__name__)
 
+import os
 import numpy as np
 import uuid
+import ast
 from typing import Tuple, Union, List, Optional, Callable
 from pathlib import Path
 from uuid import UUID
@@ -18,33 +20,38 @@ import resqpy.surface as rqs
 import resqpy.olio.uuid as bu
 
 
-def find_faces_to_represent_surface_regular_wrapper(index: int,
-                                                    parent_tmp_dir: str,
-                                                    use_index_as_realisation: bool,
-                                                    grid_epc: str,
-                                                    grid_uuid: Union[UUID, str],
-                                                    surface_epc: str,
-                                                    surface_uuid: Union[UUID, str],
-                                                    name: str,
-                                                    title: Optional[str] = None,
-                                                    agitate: bool = False,
-                                                    random_agitation: bool = False,
-                                                    feature_type: str = 'fault',
-                                                    trimmed: bool = False,
-                                                    is_curtain = False,
-                                                    extend_fault_representation: bool = False,
-                                                    flange_inner_ring = False,
-                                                    saucer_parameter = None,
-                                                    retriangulate: bool = False,
-                                                    related_uuid = None,
-                                                    progress_fn: Optional[Callable] = None,
-                                                    extra_metadata = None,
-                                                    return_properties: Optional[List[str]] = None,
-                                                    raw_bisector: bool = False,
-                                                    use_pack: bool = False,
-                                                    flange_radius = None,
-                                                    reorient = True,
-                                                    n_threads = 20) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
+def find_faces_to_represent_surface_regular_wrapper(
+        index: int,
+        parent_tmp_dir: str,
+        use_index_as_realisation: bool,
+        grid_epc: str,
+        grid_uuid: Union[UUID, str],
+        surface_epc: str,
+        surface_uuid: Union[UUID, str],
+        name: str,
+        title: Optional[str] = None,
+        agitate: bool = False,
+        random_agitation: bool = False,
+        feature_type: str = 'fault',
+        trimmed: bool = False,
+        is_curtain = False,
+        extend_fault_representation: bool = False,
+        flange_inner_ring: bool = False,
+        saucer_parameter: Optional[float] = None,
+        retriangulate: bool = False,
+        related_uuid: Optional[Union[UUID, str]] = None,
+        progress_fn: Optional[Callable] = None,
+        extra_metadata = None,
+        return_properties: Optional[List[str]] = None,
+        raw_bisector: bool = False,
+        use_pack: bool = False,
+        flange_radius: Optional[float] = None,
+        reorient: bool = True,
+        n_threads: int = 20,
+        patchwork: bool = False,
+        grid_patching_property_uuid: Optional[Union[UUID, str]] = None,
+        surface_patching_property_uuid: Optional[Union[UUID, str]] = None) ->  \
+            Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
     arguments:
@@ -98,8 +105,17 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         flange_radius (float, optional): the radial distance to use for outer flange extension points; if None,
            a large value will be calculated from the grid size; units are xy units of grid crs
         reorient (bool, default True):  if True, the points are reoriented to minimise the
-              z range prior to retriangulation (ie. z axis is approximate normal to plane of points), to enhace the triangulation
+           z range prior to retriangulation (ie. z axis is approximate normal to plane of points), to enhace the triangulation
         n_threads (int, default 20): the number of parallel threads to use in numba points in triangles function
+        patchwork (bool, default False): if True and grid bisector is included in return properties, a compostite
+           bisector is generated, based on individual ones for each patch of the surface; the following two
+           arguments must be set if patchwork is True
+        grid_patching_property_uuid (uuid, optional): required if patchwork is True, the uuid of a discrete or
+           categorical cells property on the grid which will be used to determine which patch of the surface is
+           relevant to a cell
+        surface_patching_property_uuid (uuid, optional): required if patchwork is True, the uuid of a discrete or
+           categorical property on the patches of the surface, identifying the value of the grid patching property
+           that each patch relates to
 
     returns:
         Tuple containing:
@@ -109,18 +125,15 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
             - uuid_list (List[str]): list of UUIDs of relevant objects
 
     notes:
-        Use this function as argument to the multiprocessing function; it will create a new model that is saved
-        in a temporary epc file and returns the required values, which are used in the multiprocessing function to
-        recombine all the objects into a single epc file;
-        the saucer_parameter is interpreted in one of two ways: (1) +ve fractoinal values between zero and one
-        are the fractional distance from the centre of the points to its rim at which to sample the surface for
-        extrapolation and thereby modify the recumbent z of flange points; 0 will usually give shallower and
-        smoother saucer; larger values (must be less than one) will lead to stronger and more erratic saucer
-        shape in flange; (2) other values between -90.0 and 90.0 are interpreted as an angle to apply out of
-        the plane of the original points, to give a simple (and less computationally demanding) saucer shape;
-        +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
-        the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
-        to the average plane of the original points
+        - use this function as argument to the multiprocessing function; it will create a new model that is saved
+          in a temporary epc file and returns the required values, which are used in the multiprocessing function to
+          recombine all the objects into a single epc file
+        - the saucer_parameter is between -90.0 and 90.0 and is interpreted as an angle to apply out of
+          the plane of the original points, to give a simple saucer shape;
+          +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
+          the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
+          to the average plane of the original points
+        - patchwork is not compatible with re-triangulation
     """
     tmp_dir = Path(parent_tmp_dir) / f"{uuid.uuid4()}"
     tmp_dir.mkdir(parents = True, exist_ok = True)
@@ -148,12 +161,20 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
     if flange_radius is None:
         flange_radius = 5.0 * np.sum(np.array(grid.extent_kji, dtype = float) * np.array(grid.aligned_dxyz()))
     s_model = rq.Model(surface_epc, quiet = True)
-    model.copy_uuid_from_other_model(s_model, uuid = str(surface_uuid))
+    surface_uuid = str(surface_uuid)
+    model.copy_uuid_from_other_model(s_model, uuid = surface_uuid)
+    if surface_patching_property_uuid is not None:
+        model.copy_uuid_from_other_model(s_model, uuid = surface_patching_property_uuid)
+        uuid_list.append(surface_patching_property_uuid)
     repr_type = model.type_of_part(model.part(uuid = surface_uuid), strip_obj = True)
     assert repr_type in ['TriangulatedSetRepresentation', 'PointSetRepresentation']
+    assert repr_type == 'TriangulatedSetRepresentation' or not patchwork,  \
+        'patchwork only implemented for triangulated set surfaces'
+
     extended = False
     retriangulated = False
     flange_bool = None
+
     if repr_type == 'PointSetRepresentation':
         # trim pointset to grid xyz box
         pset = rqs.PointSet(model, uuid = surface_uuid)
@@ -193,19 +214,26 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
         inherit_interpretation_relationship(model, surface_uuid, surf.uuid)
         surface_uuid = surf.uuid
 
-    surface = rqs.Surface(parent_model = model, uuid = str(surface_uuid))
+    surface = rqs.Surface(parent_model = model, uuid = surface_uuid)
     surf_title = surface.title
     assert surf_title
     surface.change_crs(grid.crs)
+    normal_vector = None
+    if reorient:
+        normal_vector = surface.normal()
+    if patchwork:  # disable trimming as whole patches could be trimmed out, changing the patch indexing from that expected
+        trimmed = True
     if not trimmed and surface.triangle_count() > 100:
         if not surf_title.endswith('trimmed'):
             surf_title += ' trimmed'
         trimmed_surf = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         # trimmed_surf.set_to_trimmed_surface(surf, xyz_box = xyz_box, xy_polygon = parent_seg.polygon)
         trimmed_surf.set_to_trimmed_surface(surface, xyz_box = grid.xyz_box(local = True))
+        trimmed_surf.extra_metadata = surface.extra_metadata
         surface = trimmed_surf
         trimmed = True
     if (extend_fault_representation and not extended) or (retriangulate and not retriangulated):
+        assert not patchwork, 'extension or re-triangulation are not compatible with patchwork'
         _, p = surface.triangles_and_points()
         pset = rqs.PointSet(model, points_array = p, crs_uuid = grid.crs.uuid, title = surf_title)
         if extend_fault_representation and not surf_title.endswith('extended'):
@@ -218,7 +246,8 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                  flange_inner_ring = flange_inner_ring,
                                                  saucer_parameter = saucer_parameter,
                                                  flange_radial_distance = flange_radius,
-                                                 make_clockwise = False)
+                                                 make_clockwise = False,
+                                                 normal_vector = normal_vector)
         del pset
         extended = extend_fault_representation
         retriangulated = True
@@ -242,7 +271,23 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                            discrete = True,
                                            dtype = np.uint8)
         uuid_list.append(flange_p.uuid)
-    uuid_list.append(surface_uuid)
+
+    if not patchwork:
+        uuid_list.append(surface_uuid)
+
+    patch_indices = None
+    if patchwork:  # generate a patch indices array over grid cells based on supplied patching properties
+        assert grid_patching_property_uuid is not None and surface_patching_property_uuid is not None
+        g_patching_array = rqp.Property(g_model, uuid = grid_patching_property_uuid).array_ref()
+        assert g_patching_array.shape == tuple(grid.extent_kji)
+        s_patches_array = rqp.Property(model, uuid = surface_patching_property_uuid).array_ref()
+        patch_count = surface.number_of_patches()
+        assert s_patches_array.shape == (patch_count,)
+        p_dtype = (np.int8 if s_patches_array.shape[0] < 128 else np.int32)
+        patch_indices = np.full(g_patching_array.shape, -1, dtype = p_dtype)
+        for patch in range(patch_count):
+            gp = s_patches_array[patch]
+            patch_indices[(g_patching_array == gp).astype(bool)] = patch
 
     returns = rqgs.find_faces_to_represent_surface_regular_optimised(grid,
                                                                      surface,
@@ -256,7 +301,8 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                                                                      return_properties,
                                                                      raw_bisector = raw_bisector,
                                                                      n_batches = n_threads,
-                                                                     packed_bisectors = use_pack)
+                                                                     packed_bisectors = use_pack,
+                                                                     patch_indices = patch_indices)
 
     success = False
 
@@ -286,6 +332,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
 
     if success and return_properties is not None and len(return_properties):
         log.debug(f'{name} requested properties: {return_properties}')
+        assert isinstance(returns, tuple)
         properties = returns[1]
         realisation = index if use_index_as_realisation else None
         property_collection = rqp.PropertyCollection(support = gcs)
@@ -346,6 +393,7 @@ def find_faces_to_represent_surface_regular_wrapper(index: int,
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()
                     grid_pc.set_support(support = grid)
+                assert array.ndim == (2 if is_curtain else 3)
                 grid_pc.add_cached_array_to_imported_list(array,
                                                           f"from find_faces function for {surface.title}",
                                                           f'{surface.title} {p_name}',

resqpy/olio/triangulation.py

@@ -48,7 +48,7 @@ def _dt_scipy(points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
 
 
 def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = None):
-    # returns Delauney triangulation of po and list of hull point indices, using a simple algorithm
+    # returns Delaunay triangulation of po and list of hull point indices, using a simple algorithm
 
     def flip(ei):
         nonlocal fm, e, t, te, p, nt, p_i, ne
@@ -234,7 +234,7 @@ def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = N
 
 
 def dt(p, algorithm = "scipy", plot_fn = None, progress_fn = None, container_size_factor = 100.0, return_hull = False):
-    """Returns the Delauney Triangulation of 2D point set p.
+    """Returns the Delaunay Triangulation of 2D point set p.
 
     arguments:
        p (numpy float array of shape (N, 2): the x,y coordinates of the points
@@ -253,7 +253,7 @@ def dt(p, algorithm = "scipy", plot_fn = None, progress_fn = None, container_siz
 
     returns:
        numpy int array of shape (M, 3) - being the indices into the first axis of p of the 3 points
-          per triangle in the Delauney Triangulation - and if return_hull is True, another int array
+          per triangle in the Delaunay Triangulation - and if return_hull is True, another int array
           of shape (B,) - being indices into p of the clockwise ordered points on the boundary of
           the triangulation
 
@@ -261,7 +261,7 @@ def dt(p, algorithm = "scipy", plot_fn = None, progress_fn = None, container_siz
        the plot_fn, progress_fn and container_size_factor arguments are only used by the 'simple' algorithm;
        if points p are 3D, the projection onto the xy plane is used for the triangulation
     """
-    assert p.ndim == 2 and p.shape[1] >= 2, 'bad points shape for 2D Delauney Triangulation'
+    assert p.ndim == 2 and p.shape[1] >= 2, 'bad points shape for 2D Delaunay Triangulation'
 
     if not algorithm:
         algorithm = 'scipy'
@@ -274,7 +274,7 @@ def dt(p, algorithm = "scipy", plot_fn = None, progress_fn = None, container_siz
                                    progress_fn = progress_fn,
                                    container_size_factor = container_size_factor)
     else:
-        raise Exception(f'unrecognised Delauney Triangulation algorithm name: {algorithm}')
+        raise Exception(f'unrecognised Delaunay Triangulation algorithm name: {algorithm}')
 
     assert tri.ndim == 2 and tri.shape[1] == 3
 
@@ -304,11 +304,11 @@ def ccc(p1, p2, p3):
 
 
 def voronoi(p, t, b, aoi: rql.Polyline):
-    """Returns dual Voronoi diagram for a Delauney triangulation.
+    """Returns dual Voronoi diagram for a Delaunay triangulation.
 
     arguments:
-       p (numpy float array of shape (N, 2)): seed points used in the Delauney triangulation
-       t (numpy int array of shape (M, 3)): the Delauney triangulation of p as returned by dt()
+       p (numpy float array of shape (N, 2)): seed points used in the Delaunay triangulation
+       t (numpy int array of shape (M, 3)): the Delaunay triangulation of p as returned by dt()
        b (numpy int array of shape (B,)): clockwise sorted list of indices into p of the boundary
           points of the triangulation t
        aoi (lines.Polyline): area of interest; a closed clockwise polyline that must strictly contain
@@ -329,7 +329,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
 
     # this code assumes that the Voronoi polygon for a seed point visits the circumcentres of
     # all the triangles that make use of the point – currently understood to be always the case
-    # for a Delauney triangulation
+    # for a Delaunay triangulation
 
     def __aoi_intervening_nodes(aoi_count, c_count, seg_a, seg_c):
         nodes = []
@@ -582,7 +582,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
 
     # check for concavities in hull
     if not hull.is_convex():
-        log.warning('Delauney triangulation is not convex; Voronoi diagram construction might fail')
+        log.warning('Delaunay triangulation is not convex; Voronoi diagram construction might fail')
 
     # compute circumcircle centres
     c = np.zeros((t.shape[0], 2))
@@ -750,7 +750,7 @@ def reorient(points, rough = True, max_dip = None, use_linalg = True, sample = 5
     notes:
        the original points array is not modified by this function;
        implicit xy & z units for points are assumed to be the same;
-       the function may typically be called prior to the Delauney triangulation, which uses an xy projection to
+       the function may typically be called prior to the Delaunay triangulation, which uses an xy projection to
        determine the triangulation;
        the numpy linear algebra option seems to be memory intensive, not recommended;
        downsampling will occur (for normal vector determination) when the number of points exceeds double that
@@ -868,10 +868,11 @@ def surrounding_xy_ring(p,
           being an angle to determine a z offset for the ring(s); a +ve angle results in a -ve z shift
 
     returns:
-       numpy float array of shape (N, 3) being xyz points in surrounding ring(s); z is set constant to
-       mean value of z in p (optionally adjussted based on saucer_angle);
-       N is count if inner_ring is False, 3 * count if True
-       radius used for ring of additional points
+       (numpy float array, float) pair:
+       - numpy float array of shape (N, 3) being xyz points in surrounding ring(s); z is set constant to
+         mean value of z in p (optionally adjussted based on saucer_angle);
+         N is count if inner_ring is False, 3 * count if True
+       - radius used for ring of additional points
     """
 
     def make_ring(count, centre, radius, saucer_angle):

resqpy/property/_collection_get_attributes.py

@@ -509,6 +509,8 @@ def _supporting_shape_surface(support, indexable_element):
         shape_list = [support.triangle_count()]
     elif indexable_element == 'nodes':
         shape_list = [support.node_count()]
+    elif indexable_element == 'patches':
+        shape_list = [len(support.patch_list)]
     return shape_list
 
 

resqpy/surface/_surface.py

@@ -125,6 +125,75 @@ class Surface(rqsb.BaseSurface):
             self.set_from_tsurf_file(tsurf_file)
         self._load_normal_vector_from_extra_metadata()
 
+    @classmethod
+    def from_list_of_patches(cls, model, patch_list, title, crs_uuid = None, extra_metadata = None):
+        """Create a Surface from a prepared list of TriangulatedPatch objects.
+
+        arguments:
+            - model (Model): the model to which the surface will be associated
+            - patch_list (list of TriangulatedPatch): the list of patches to be combined to form the surface
+            - title (str): the citation title for the new surface
+            - crs_uuid (uuid, optional): the uuid of a crs in model which the points are deemed to be in
+            - extra_metadata (dict of (str: str), optional): extra metadata to add to the new surface
+
+        returns:
+            - new Surface comprised of a patch for each entry in the patch list
+
+        notes:
+            - the triangulated patch objects are used directly in the surface
+            - the patches should not have had their hdf5 data written yet
+            - the patch index values will be set, with any previous values ignored
+            - the patches will be hijacked to the target model if their model is different
+            - each patch will have its points converted in situ into the surface crs
+            - if the crs_uuid argument is None, the crs_uuid is taken from the first patch
+        """
+        assert len(patch_list) > 0, 'attempting to create Surface from empty patch list'
+        if crs_uuid is None:
+            crs_uuid = patch_list[0].crs_uuid
+            if model.uuid(uuid = crs_uuid) is None:
+                model.copy_uuid_from_other_model(patch_list[0].model, crs_uuid)
+        surf = cls(model, title = title, crs_uuid = crs_uuid, extra_metadata = extra_metadata)
+        surf.patch_list = patch_list
+        surf.crs_uuid = crs_uuid
+        crs = rqc.Crs(model, uuid = crs_uuid)
+        for i, patch in enumerate(surf.patch_list):
+            assert patch.points is not None, f'points missing in patch {i} when making surface {title}'
+            patch.index = i
+            patch._set_t_type()
+            if not bu.matching_uuids(patch.crs_uuid, crs_uuid):
+                p_crs = rqc.Crs(patch.model, uuid = patch.crs_uuid)
+                p_crs.convert_array_to(crs, patch.points)
+            patch.model = model
+        return surf
+
+    @classmethod
+    def from_list_of_patches_of_triangles_and_points(cls, model, t_p_list, title, crs_uuid, extra_metadata = None):
+        """Create a Surface from a prepared list of pairs of (triangles, points).
+
+        arguments:
+            - model (Model): the model to which the surface will be associated
+            - t_p_list (list of (numpy int array, numpy float array)): the list of patches of triangles and points;
+              the int arrays have shape (N, 3) being the triangle vertex indices of points; the float array has
+              shape (M, 3) being the xyx values for the points, in the crs identified by crs_uuid
+            - title (str): the citation title for the new surface
+            - crs_uuid (uuid): the uuid of a crs in model which the points are deemed to be in
+            - extra_metadata (dict of (str: str), optional): extra metadata to add to the new surface
+
+        returns:
+            - new Surface comprised of a patch for each entry in the list of pairs of triangles and points data
+
+        note:
+            - each entry in the t_p_list will have its own patch in the resulting surface, indexed in order of list
+        """
+        assert t_p_list, f'no triangles and points pairs in list when generating surface: {title}'
+        assert crs_uuid is not None
+        patch_list = []
+        for i, (t, p) in enumerate(t_p_list):
+            patch = rqs.TriangulatedPatch(model, patch_index = i, crs_uuid = crs_uuid)
+            patch.set_from_triangles_and_points(t, p)
+            patch_list.append(patch)
+        return cls.from_list_of_patches(model, patch_list, title, crs_uuid = crs_uuid, extra_metadata = extra_metadata)
+
     @classmethod
     def from_tri_mesh(cls, tri_mesh, exclude_nans = False):
         """Create a Surface from a TriMesh.
@@ -319,6 +388,39 @@ class Surface(rqsb.BaseSurface):
             ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches')
         return self.patch_list[patch].triangles_and_points(copy = copy)
 
+    def patch_index_for_triangle_index(self, triangle_index):
+        """Returns the patch index for a triangle index (as applicable to triangles_and_points() triangles)."""
+        if triangle_index is None or triangle_index < 0:
+            return None
+        self.extract_patches(self.root)
+        if not self.patch_list:
+            return None
+        for i, patch in enumerate(self.patch_list):
+            triangle_index -= patch.triangle_count
+            if triangle_index < 0:
+                return i
+        return None
+
+    def patch_indices_for_triangle_indices(self, triangle_indices, lazy = True):
+        """Returns array of patch indices for array of triangle indices (as applicable to triangles_and_points() triangles)."""
+        self.extract_patches(self.root)
+        if not self.patch_list:
+            return np.full(triangle_indices.shape, -1, dtype = np.int8)
+        patch_count = len(self.patch_list)
+        dtype = (np.int8 if patch_count < 127 else np.int32)
+        if lazy and patch_count == 1:
+            return np.zeros(triangle_indices.shape, dtype = np.int8)
+        patch_limits = np.zeros(patch_count, dtype = np.int32)
+        t_count = 0
+        for p_i in range(patch_count):
+            t_count += self.patch_list[p_i].triangle_count
+            patch_limits[p_i] = t_count
+        patches = np.empty(triangle_indices.shape, dtype = dtype)
+        patches[:] = np.digitize(triangle_indices, patch_limits, right = False)
+        if not lazy:
+            patches[np.logical_or(triangle_indices < 0, patches == patch_count)] = -1
+        return patches
+
     def decache_triangles_and_points(self):
         """Removes the cached composite triangles and points arrays."""
         self.points = None
@@ -369,23 +471,41 @@ class Surface(rqsb.BaseSurface):
     def change_crs(self, required_crs):
         """Changes the crs of the surface, also sets a new uuid if crs changed.
 
-        note:
+        notes:
            this method is usually used to change the coordinate system for a temporary resqpy object;
-           to add as a new part, call write_hdf5() and create_xml() methods
+           to add as a new part, call write_hdf5() and create_xml() methods;
+           patches are maintained by this method;
+           normal vector extra metadata item is updated if present; rotation matrix is removed
         """
 
         old_crs = rqc.Crs(self.model, uuid = self.crs_uuid)
         self.crs_uuid = required_crs.uuid
-        if required_crs == old_crs or not self.patch_list:
+        if bu.matching_uuids(required_crs.uuid, old_crs.uuid) or not self.patch_list:
             log.debug(f'no crs change needed for {self.title}')
             return
+        equivalent_crs = (required_crs == old_crs)
         log.debug(f'crs change needed for {self.title} from {old_crs.title} to {required_crs.title}')
         for patch in self.patch_list:
-            patch.triangles_and_points()
-            required_crs.convert_array_from(old_crs, patch.points)
+            assert bu.matching_uuids(patch.crs_uuid, old_crs.uuid)
+            if not equivalent_crs:
+                patch.triangles_and_points()
+                required_crs.convert_array_from(old_crs, patch.points)
             patch.crs_uuid = self.crs_uuid
         self.triangles = None  # clear cached arrays for surface
         self.points = None
+        if not equivalent_crs:
+            if self.extra_metadata.pop('rotation matrix', None) is not None:
+                log.warning(f'discarding rotation matrix extra metadata during crs change of: {self.title}')
+            self._load_normal_vector_from_extra_metadata()
+            if self.normal_vector is not None:
+                if required_crs.z_inc_down != old_crs.z_inc_down:
+                    self.normal_vector[2] = -self.normal_vector[2]
+                theta = (wam.convert(required_crs.rotation, required_crs.rotation_units, 'dega') -
+                         wam.convert(old_crs.rotation, old_crs.rotation_units, 'dega'))
+                if not maths.isclose(theta, 0.0):
+                    self.normal_vector = vec.rotate_vector(vec.rotation_matrix_3d_axial(2, theta), self.normal_vector)
+                self.extra_metadata['normal vector'] = str(
+                    f'{self.normal_vector[0]},{self.normal_vector[1]},{self.normal_vector[2]}')
         self.uuid = bu.new_uuid()  # hope this doesn't cause problems
         assert self.root is None
 
@@ -580,7 +700,8 @@ class Surface(rqsb.BaseSurface):
                            flange_radial_distance = None,
                            flange_inner_ring = False,
                            saucer_parameter = None,
-                           make_clockwise = False):
+                           make_clockwise = False,
+                           normal_vector = None):
         """Populate this (empty) Surface object with a Delaunay triangulation of points in a PointSet object.
 
         arguments:
@@ -589,9 +710,10 @@ class Surface(rqsb.BaseSurface):
               convex; reduce to 1.0 to allow slightly more concavities; increase to 100.0 or more for very little
               chance of even a slight concavity
            reorient (bool, default False): if True, a copy of the points is made and reoriented to minimise the
-              z range (ie. z axis is approximate normal to plane of points), to enhace the triangulation
+              z range (ie. z axis is approximate normal to plane of points), to enhace the triangulation; if a
+              normal_vector is supplied, the reorientation is based on that instead of minimising z
            reorient_max_dip (float, optional): if present, the reorientation of perspective off vertical is
-              limited to this angle in degrees
+              limited to this angle in degrees; ignored if normal_vector is specified
            extend_with_flange (bool, default False): if True, a ring of points is added around the outside of the
               points before the triangulation, effectively extending the surface with a flange
            flange_point_count (int, default 11): the number of points to generate in the flange ring; ignored if
@@ -609,10 +731,12 @@ class Surface(rqsb.BaseSurface):
            make_clockwise (bool, default False): if True, the returned triangles will all be clockwise when
               viewed in the direction -ve to +ve z axis; if reorient is also True, the clockwise aspect is
               enforced in the reoriented space
+           normal_vector (triple float, optional): if present and reorienting, the normal vector to use for reorientation;
+              if None, the reorientation is made so as to minimise the z range
 
         returns:
            if extend_with_flange is True, numpy bool array with a value per triangle indicating flange triangles;
-           if extent_with_flange is False, None
+           if extend_with_flange is False, None
 
         notes:
            if extend_with_flange is True, then a boolean array is created for the surface, with a value per triangle,
@@ -623,7 +747,8 @@ class Surface(rqsb.BaseSurface):
            the saucer_parameter must be between -90.0 and 90.0, and is interpreted as an angle to apply out of
            the plane of the original points, to give a simple saucer shape; +ve angles result in the shift being in 
            the direction of the -ve z hemisphere; -ve angles result in the shift being in the +ve z hemisphere; in 
-           either case the direction of the shift is perpendicular to the average plane of the original points
+           either case the direction of the shift is perpendicular to the average plane of the original points;
+           normal_vector, if supplied, should be in the crs of the point set
         """
 
         simple_saucer_angle = None
@@ -648,8 +773,24 @@ class Surface(rqsb.BaseSurface):
         else:
             unit_adjusted_p = p.copy()
             wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
+            # note: normal vector should already be for a crs with common xy  & z units
         # reorient the points to the fault normal vector
-        p_xy, self.normal_vector, reorient_matrix = triangulate.reorient(unit_adjusted_p, max_dip = reorient_max_dip)
+        if normal_vector is None:
+            p_xy, self.normal_vector, reorient_matrix = triangulate.reorient(unit_adjusted_p,
+                                                                             max_dip = reorient_max_dip)
+        else:
+            assert len(normal_vector) == 3
+            self.normal_vector = np.array(normal_vector, dtype = np.float64)
+            if self.normal_vector[2] < 0.0:
+                self.normal_vector = -self.normal_vector
+            incl = vec.inclination(normal_vector)
+            if maths.isclose(incl, 0.0):
+                reorient_matrix = vec.no_rotation_matrix()
+                p_xy = unit_adjusted_p
+            else:
+                azi = vec.azimuth(normal_vector)
+                reorient_matrix = vec.tilt_3d_matrix(azi, incl)
+                p_xy = vec.rotate_array(reorient_matrix, unit_adjusted_p)
         if extend_with_flange:
             flange_points, radius = triangulate.surrounding_xy_ring(p_xy,
                                                                     count = flange_point_count,
@@ -707,7 +848,8 @@ class Surface(rqsb.BaseSurface):
                                    flange_inner_ring = False,
                                    saucer_parameter = None,
                                    make_clockwise = False,
-                                   retriangulate = False):
+                                   retriangulate = False,
+                                   normal_vector = None):
         """Returns a new Surface object where the original surface has been extended with a flange with a Delaunay triangulation of points in a PointSet object.
 
         arguments:
@@ -715,9 +857,10 @@ class Surface(rqsb.BaseSurface):
                 convex; reduce to 1.0 to allow slightly more concavities; increase to 100.0 or more for very little
                 chance of even a slight concavity
             reorient (bool, default False): if True, a copy of the points is made and reoriented to minimise the
-                z range (ie. z axis is approximate normal to plane of points), to enhace the triangulation
+                z range (ie. z axis is approximate normal to plane of points), to enhace the triangulation; if
+                normal_vector is supplied that is used to determine the reorientation instead of minimising z
             reorient_max_dip (float, optional): if present, the reorientation of perspective off vertical is
-                limited to this angle in degrees
+                limited to this angle in degrees; ignored if normal_vector is specified
             flange_point_count (int, default 11): the number of points to generate in the flange ring; ignored if
                 retriangulate is False
             flange_radial_factor (float, default 10.0): distance of flange points from centre of points, as a
@@ -738,6 +881,8 @@ class Surface(rqsb.BaseSurface):
                 the existing points. If False, the surface will be generated by adding flange points and triangles directly
                 from the original surface edges, and will no retriangulate the input surface. If False the surface must not
                 contain tears
+            normal_vector (triple float, optional): if present and reorienting, the normal vector to use for reorientation;
+                if None, the reorientation is made so as to minimise the z range
 
         returns:
             a new surface, and a boolean array of length N, where N is the number of triangles on the surface. This boolean
@@ -757,7 +902,8 @@ class Surface(rqsb.BaseSurface):
             the plane of the original points, to give a simple (and less computationally demanding) saucer shape;
             +ve angles result in the shift being in the direction of the -ve z hemisphere; -ve angles result in
             the shift being in the +ve z hemisphere; in either case the direction of the shift is perpendicular
-            to the average plane of the original points
+            to the average plane of the original points;
+            normal_vector, if supplied, should be in the crs of this surface
         """
         prev_t, prev_p = self.triangles_and_points()
         point_set = rqs.PointSet(self.model, crs_uuid = self.crs_uuid, title = self.title, points_array = prev_p)
@@ -766,7 +912,7 @@ class Surface(rqsb.BaseSurface):
             return out_surf, out_surf.set_from_point_set(point_set, convexity_parameter, reorient, reorient_max_dip,
                                                          True, flange_point_count, flange_radial_factor,
                                                          flange_radial_distance, flange_inner_ring, saucer_parameter,
-                                                         make_clockwise)
+                                                         make_clockwise, normal_vector)
         else:
             simple_saucer_angle = None
             if saucer_parameter is not None and (saucer_parameter > 1.0 or saucer_parameter < 0.0):
@@ -916,9 +1062,10 @@ class Surface(rqsb.BaseSurface):
         notes:
            the result becomes more meaningless the less planar the surface is;
            even for a parfectly planar surface, the result is approximate;
-           true normal vector is found when xy & z units differ
+           true normal vector is found when xy & z units differ, ie. for consistent units
         """
 
+        self._load_normal_vector_from_extra_metadata()
         if self.normal_vector is None:
             p = self.unit_adjusted_points()
             _, self.normal_vector, _ = triangulate.reorient(p)
@@ -1346,12 +1493,16 @@ 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.
+        """Returns a new surface, with the same model, title and crs as the original, but with additional refined points along 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)
+        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
+        returns: 
+            new Surface object with extra_metadata ('unique edges resampled from surface': uuid), where uuid is for the original surface uuid
+            
+        note:
+            this method involves a tr-triangulation
         """
         _, op = self.triangles_and_points()
         ref = self.resampled_surface()  # resample the original surface
@@ -1422,7 +1573,8 @@ class Surface(rqsb.BaseSurface):
             self.title = 'surface'
 
         em = None
-        if self.normal_vector is not None:
+        if self.normal_vector is not None and (self.extra_metadata is None or
+                                               'normal vector' not in self.extra_metadata):
             assert len(self.normal_vector) == 3
             em = {'normal vector': f'{self.normal_vector[0]},{self.normal_vector[1]},{self.normal_vector[2]}'}
 

resqpy/surface/_tri_mesh.py

@@ -219,6 +219,7 @@ class TriMesh(rqs.Mesh):
             base edge towards point 2; f1 is component towards point 1; f0 is component towards point 0;
             the trilinear coordinates sum to one and can be used as weights to interpolate z values at points
         """
+        assert xy_array.ndim > 1 and 2 <= xy_array.shape[-1] <= 3
         x = xy_array[..., 0].copy()
         y = xy_array[..., 1].copy()
         if self.origin is not None:
@@ -236,7 +237,7 @@ class TriMesh(rqs.Mesh):
         mask = np.logical_or(mask, np.logical_or(i < 0, i >= self.ni - 1))
         fx = ip - i.astype(float)
         i *= 2
-        am = np.where(fx > 1.0 - fy)
+        am = (fx > 1.0 - fy).astype(bool)
         i[am] += 1
         fx[am] -= 1.0 - fy[am]
         fy[am] = 1.0 - fy[am]
@@ -275,6 +276,7 @@ class TriMesh(rqs.Mesh):
             of three vertices of triangles containing xy points; float triplets contain corresponding weights (summing to
             one per triangle) which can be used to interpolate z values at points xy_array
         """
+        assert xy_array.ndim > 1 and 2 <= xy_array.shape[-1] <= 3
         tji, tc = self.tji_tc_for_xy_array(xy_array)
         ji = self.tri_nodes_for_tji_array(tji)
         return (ji, tc)

{resqpy-5.0.0.dist-info → resqpy-5.1.1.dist-info}/METADATA

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

{resqpy-5.0.0.dist-info → resqpy-5.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=7QLJBGZRJzBFqxailgyyliMgfPLS0xUKGDr9BfDS-Oc,555
+resqpy/__init__.py,sha256=p9tTrsC5HfUexwsU8YYBIHq3nslCgVVqUH-tiqKHF7w,555
 resqpy/crs.py,sha256=R7DfcTP5xGv5pu9Y8RHA2WVM9DjBCSVMoHcz4RmQ7Yw,27646
 resqpy/derived_model/__init__.py,sha256=NFvMSOKI3cxmH7lAbddV43JjoUj-r2G7ExEfOqinD1I,1982
 resqpy/derived_model/_add_edges_per_column_property_array.py,sha256=cpW3gwp6MSYIrtvFmCjoJXcyUsgGuCDbgmwlJCJebUs,6410
@@ -47,7 +47,7 @@ resqpy/grid/_write_nexus_corp.py,sha256=yEVfiObsedEAXX6UG6ZTf56kZnQVkd3lLqE2NpL-
 resqpy/grid/_xyz.py,sha256=RLQWOdM_DRoCj4JypwB5gUJ78HTdk5JnZHSeAzuU634,13087
 resqpy/grid_surface/__init__.py,sha256=IlPwm6G7P_Vg_w7JHqSs-d_oxk2QmFtWGTk_vvr1qm8,2911
 resqpy/grid_surface/_blocked_well_populate.py,sha256=Lme1AR-nLWOUlNnmHMVThk6jEg_lAZxWWtL82Yksppw,35867
-resqpy/grid_surface/_find_faces.py,sha256=NBr0DF7rfBnPY5KtHJNp4oXW6N870mTGYXdu_jg04Yk,107108
+resqpy/grid_surface/_find_faces.py,sha256=YogiM8SIDZGtDIuA8Hyd8DOt3Po47CKHP7luE_jz93I,111556
 resqpy/grid_surface/_grid_skin.py,sha256=D0cjHkcuT5KCKb-8EZfXgh0GgJj3kzOBS2wVNXg4bfY,26056
 resqpy/grid_surface/_grid_surface.py,sha256=l2NJo7Kiucolbb_TlLPC7NGdksg_JahkihfsrJVq99w,14379
 resqpy/grid_surface/_trajectory_intersects.py,sha256=Och9cZYU9Y7ofovhPzsLyIblRUl2xj9_5nHH3fMZp-A,22498
@@ -59,16 +59,16 @@ resqpy/lines/_polyline_set.py,sha256=3K3z_G9l_3mfjLdCL-YVscyj1FA6DHh1uj9rXPtWFOY
 resqpy/model/__init__.py,sha256=hbxO-IpCOH_82TZqj6e1FjrWxO0tZu2gj2HCN9x-Svw,378
 resqpy/model/_catalogue.py,sha256=duvZlNlTPjAfXyqae0J9lMSEx_8-WIcrw2MYxnNEg_Q,30487
 resqpy/model/_context.py,sha256=0tLBVMcuuIj3i87Ig8lhFMLHE5GHgEA2PEl1NjKaohc,2840
-resqpy/model/_forestry.py,sha256=QYE3P9uSsh77J6ghcgp2cBQP6UKrs8edF-m05sqgboo,34518
+resqpy/model/_forestry.py,sha256=42dMwqdvxdRYYwqVSC4ky2iDp9hmqUEEtX2mxMVMLeA,34884
 resqpy/model/_grids.py,sha256=d7hRQRmni5pJrm1CY31D2icJV1XDar7xTmUexq_eVGY,3371
 resqpy/model/_hdf5.py,sha256=-dq2r3HzBKf0F43kwPy--MZOOjQZlDS4RJ6nG3VOeSs,14448
-resqpy/model/_model.py,sha256=YEcDgjs4l0lZ059UdV9v4y7FdFs4tS81moFzOteKhvY,106328
+resqpy/model/_model.py,sha256=ZhOkZ-n8k1cKBQODcDzASwq_JrBhmYcdIwOAVk7g9q4,106326
 resqpy/model/_xml.py,sha256=TiZKHZezMdcjRvHSa-HzzrYe9kyDdd8L4hacNV0bjEg,24402
 resqpy/multi_processing/__init__.py,sha256=ZRudHfN9aaZjxvat7t8BZr6mwMi9baiCNjczwwT0WjI,909
 resqpy/multi_processing/_multiprocessing.py,sha256=bnCKfSC1tWwvZmZ7BZqCyje0C93m6q7HZPxNpx8xoxA,7301
 resqpy/multi_processing/wrappers/__init__.py,sha256=7vjuTWdHnp3rN9Ud8ljpDnt1NbBAyhA08lv-sQ9Kf3o,72
 resqpy/multi_processing/wrappers/blocked_well_mp.py,sha256=_2fEsSmJVQCnbQIjTHqmnNEugfhN1KvX-o4ZbvtChdI,5952
-resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=mpv-EgtlRA5XIINdGU6UgnDTD_MhsrXAfqvMU6iBT6Y,25568
+resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=SkobxBOU-xnojll-TewNoiuVQA9IrG2DXGg8fq7IL14,27083
 resqpy/multi_processing/wrappers/mesh_mp.py,sha256=0VYoqtgBFfrlyYB6kkjbdrRQ5FKe6t5pHJO3wD9b8Fc,5793
 resqpy/olio/__init__.py,sha256=j2breqKYVufhw5k8qS2uZwB3tUKT7FhdZ23ninS75YA,84
 resqpy/olio/ab_toolbox.py,sha256=bZlAhOJVS0HvIYBW0Lg68re17N8eltoQhIUh0xuUyVc,2147
@@ -94,7 +94,7 @@ resqpy/olio/simple_lines.py,sha256=qaR11W5UPgRmtMeFQ-pXg0jOvkJZ_XPzSUpAXqeYtlc,1
 resqpy/olio/time.py,sha256=LtoSIf1A6wunHSpDgKsSGEr0rbcSQyy35TgJvY37PrI,760
 resqpy/olio/trademark.py,sha256=p_EWvUUnfalOA0RC94fSWMDgdGY9-FdZuGtAjg3wNcY,822
 resqpy/olio/transmission.py,sha256=auz_12TKtSPy6Fv3wmKn5lXPRAEnn2tYVyTQfsj37xU,61869
-resqpy/olio/triangulation.py,sha256=9G9GIBdhoRRRRzZwn-HV3dIJWF6idC7XVkxl6L9v_ic,45989
+resqpy/olio/triangulation.py,sha256=sBNP4MhSpY2bv6BYIn7890stqetkK5dag9pYNFiUs2g,46037
 resqpy/olio/uuid.py,sha256=JRMi-RZNeGm8tGNloIwTATzNtdj29lBQDV9OILboPRI,7324
 resqpy/olio/vdb.py,sha256=lQYuK1kr1Wnucq2EoKgT6lrR7vloCemnCKZktzBcLUc,45231
 resqpy/olio/vector_utilities.py,sha256=B354cr9-nqqPcb3SAx1jD9Uk51sjkV95xToAiF3-WHA,61127
@@ -129,7 +129,7 @@ resqpy/organize/wellbore_interpretation.py,sha256=jRAHq90tR2dCQSXsZicujXhSVHOEPo
 resqpy/property/__init__.py,sha256=gRnzjdn6bxCQStfHL5qMOs43okVRW168TjqU0C9oL2g,2360
 resqpy/property/_collection_add_part.py,sha256=uM64TWqJ0aBUwP1u1OJNTUhKLGlmOQj14fGPLG-2pRs,17156
 resqpy/property/_collection_create_xml.py,sha256=p9GASodhg4vQqDDvCOHScto_Qtz_nDADGtvZY92Dcu8,13001
-resqpy/property/_collection_get_attributes.py,sha256=whWG3O3fIXi2TetUKQWC4JPjrKI9tPrYmw0d51HkJgY,32609
+resqpy/property/_collection_get_attributes.py,sha256=9uHH9TW0Rty7BMclLqQivr6-uglKSjFZkpWdq47OgAo,32697
 resqpy/property/_collection_support.py,sha256=77_DG-0pzhMWdG_mNDiGfihXD7Pp-CvDSGCV8ZlDjj4,5889
 resqpy/property/_property.py,sha256=JcG7h6k4cJ4l3WC_VCsvoqHM3FBxrnUuxbIK2Ono1M0,24426
 resqpy/property/attribute_property_set.py,sha256=gATFe-vI00GrgaJNMHSKbM0xmlxIsO5DT1qRSU9snYI,12295
@@ -162,8 +162,8 @@ resqpy/surface/_base_surface.py,sha256=LsWrDrbuuaEVRgf2Dlbc-6ZvGQpjtrKuxF7Jjebvl
 resqpy/surface/_combined_surface.py,sha256=8TnNbSywjej6tW_vRr5zoVgBbvnadCaqWk6WyHWHTYQ,3082
 resqpy/surface/_mesh.py,sha256=yEFldNWT2g8MCGcU4mTeWzDrLHHGLLGLIle1gAjJ_lg,42352
 resqpy/surface/_pointset.py,sha256=niTkBik9hAvqrY8340K1TRG7mg4FMQbbp12WZiiXPMs,27416
-resqpy/surface/_surface.py,sha256=6Gq90nRWCuIoZ6S9XvOysXV7Z-lNbZsnz3Z45ZPqMwc,85155
-resqpy/surface/_tri_mesh.py,sha256=EmV4FhyjuusQFruW1SseufbnHF5YFoJ6Uvb07UJbH6s,26609
+resqpy/surface/_surface.py,sha256=w57Us5G7MYGXqTHE-VWFKgJ0M1sF5mHNJtMUV1mhUr8,94081
+resqpy/surface/_tri_mesh.py,sha256=f2BiGYNj5v8CgmWJKEZ7aKp1WX9iWX4myETCjVQ5dCA,26746
 resqpy/surface/_tri_mesh_stencil.py,sha256=eXt_HIKvsXGsjQ7nm_NbozR6ProQxPbeO52r79j80ig,16087
 resqpy/surface/_triangulated_patch.py,sha256=FKn_Irzp4aLFkkN_-tx1MLMKjEAiOLE8636sOA481TQ,26802
 resqpy/time_series/__init__.py,sha256=jiB3HJUWe47OOJTVmRJ4Gh5vm-XdMaMXmD52kAGr2zY,1074
@@ -193,7 +193,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=Rx8jwkCjchseDZaTttPkA1-f6l7W6vRGrxWtDHlEPx8,22560
 resqpy/well/well_object_funcs.py,sha256=1O4EVPuTn-kN3uT_V4TbSwehnMUMY0TX36XOUgasTcc,24689
 resqpy/well/well_utils.py,sha256=-g_pg2v5XD9g4SQz9sk7KK-x2xEQZHzWehCQqiEGo6M,7627
-resqpy-5.0.0.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-5.0.0.dist-info/METADATA,sha256=ZE6vaH5k2arTksxYGev-YVR-JKV4SRm0-XWRrYJyuHk,4026
-resqpy-5.0.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-resqpy-5.0.0.dist-info/RECORD,,
+resqpy-5.1.1.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-5.1.1.dist-info/METADATA,sha256=Cj9yg05wIMxdty_mNIuSG2kY_6NoHMvaRSoDM6C_7gs,4026
+resqpy-5.1.1.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+resqpy-5.1.1.dist-info/RECORD,,

{resqpy-5.0.0.dist-info → resqpy-5.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: true
 Tag: py3-none-any