resqpy 4.18.11__py3-none-any.whl → 5.1.0__py3-none-any.whl

resqpy/surface/_surface.py

@@ -8,6 +8,7 @@ import logging
 log = logging.getLogger(__name__)
 
 import numpy as np
+import math as maths
 
 import resqpy.crs as rqc
 import resqpy.lines as rql
@@ -47,7 +48,7 @@ class Surface(rqsb.BaseSurface):
                  originator = None,
                  extra_metadata = {}):
         """Create an empty Surface object (RESQML TriangulatedSetRepresentation).
-        
+
         Optionally populates from xml, point set or mesh.
 
         arguments:
@@ -124,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.
@@ -318,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
@@ -368,9 +471,11 @@ 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)
@@ -385,6 +490,18 @@ class Surface(rqsb.BaseSurface):
             patch.crs_uuid = self.crs_uuid
         self.triangles = None  # clear cached arrays for surface
         self.points = None
+        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
 
@@ -579,7 +696,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:
@@ -588,9 +706,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
@@ -608,10 +727,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,
@@ -619,23 +740,18 @@ class Surface(rqsb.BaseSurface):
            suitable for adding as a property for the surface, with indexable element 'faces';
            when flange extension occurs, the radius is the greater of the values determined from the radial factor
            and radial distance arguments;
-           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
+           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;
+           normal_vector, if supplied, should be in the crs of the point set
         """
 
         simple_saucer_angle = None
-        if saucer_parameter is not None and (saucer_parameter > 1.0 or saucer_parameter < 0.0):
+        if saucer_parameter is not None:
             assert -90.0 < saucer_parameter < 90.0, f'simple saucer angle parameter must be less than 90 degrees; too big: {saucer_parameter}'
             simple_saucer_angle = saucer_parameter
             saucer_parameter = None
-        assert saucer_parameter is None or 0.0 <= saucer_parameter < 1.0
         crs = rqc.Crs(self.model, uuid = point_set.crs_uuid)
         p = point_set.full_array_ref()
         assert p.ndim >= 2
@@ -648,37 +764,44 @@ class Surface(rqsb.BaseSurface):
                 f'removing {len(p) - np.count_nonzero(row_mask)} NaN points from point set {point_set.title} prior to surface triangulation'
             )
             p = p[row_mask, :]
-        if crs.xy_units == crs.z_units or not reorient:
+        if crs.xy_units == crs.z_units:
             unit_adjusted_p = p
         else:
             unit_adjusted_p = p.copy()
             wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
-        if reorient:
+            # note: normal vector should already be for a crs with common xy  & z units
+        # reorient the points to the fault normal vector
+        if normal_vector is None:
             p_xy, self.normal_vector, reorient_matrix = triangulate.reorient(unit_adjusted_p,
                                                                              max_dip = reorient_max_dip)
         else:
-            p_xy = unit_adjusted_p
+            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:
-            if not reorient:
-                assert saucer_parameter is None and simple_saucer_angle is None,  \
-                    'flange saucer mode only available with reorientation active'
-                log.warning('extending point set with flange without reorientation')
-            flange_points = triangulate.surrounding_xy_ring(p_xy,
-                                                            count = flange_point_count,
-                                                            radial_factor = flange_radial_factor,
-                                                            radial_distance = flange_radial_distance,
-                                                            inner_ring = flange_inner_ring,
-                                                            saucer_angle = simple_saucer_angle)
-            p_xy_e = np.concatenate((p_xy, flange_points), axis = 0)
+            flange_points, radius = triangulate.surrounding_xy_ring(p_xy,
+                                                                    count = flange_point_count,
+                                                                    radial_factor = flange_radial_factor,
+                                                                    radial_distance = flange_radial_distance,
+                                                                    inner_ring = flange_inner_ring,
+                                                                    saucer_angle = 0.0)
+            flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
             if reorient:
-                # reorient back extenstion points into original p space
-                flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
-                p_e = np.concatenate((unit_adjusted_p, flange_points_reverse_oriented), axis = 0)
+                p_xy_e = np.concatenate((p_xy, flange_points), axis = 0)
             else:
-                p_e = p_xy_e
+                p_xy_e = np.concatenate((unit_adjusted_p, flange_points_reverse_oriented), axis = 0)
+
         else:
-            p_xy_e = p_xy
-            p_e = unit_adjusted_p
+            p_xy_e = unit_adjusted_p
             flange_array = None
         log.debug('number of points going into dt: ' + str(len(p_xy_e)))
         success = False
@@ -693,19 +816,214 @@ class Surface(rqsb.BaseSurface):
             t = triangulate.dt(p_xy_e[:, :2], container_size_factor = convexity_parameter * 1.1)
         log.debug('number of triangles: ' + str(len(t)))
         if make_clockwise:
-            triangulate.make_all_clockwise_xy(t, p_e)  # modifies t in situ
+            triangulate.make_all_clockwise_xy(t, p_xy_e)  # modifies t in situ
         if extend_with_flange:
             flange_array = np.zeros(len(t), dtype = bool)
             flange_array[:] = np.where(np.any(t >= len(p), axis = 1), True, False)
-            if saucer_parameter is not None:
-                _adjust_flange_z(self.model, self.crs_uuid, p_xy_e, len(p), t, flange_array, saucer_parameter)
-                p_e = vec.rotate_array(reorient_matrix.T, p_xy_e)
-        if crs.xy_units != crs.z_units and reorient:
-            wam.convert_lengths(p_e[:, 2], crs.xy_units, crs.z_units)
+            if simple_saucer_angle is not None:
+                assert abs(simple_saucer_angle) < 90.0
+                z_shift = radius * maths.tan(vec.radians_from_degrees(simple_saucer_angle))
+                flange_points[:, 2] -= z_shift
+                flange_points_reverse_oriented = vec.rotate_array(reorient_matrix.T, flange_points)
+            if crs.xy_units != crs.z_units:
+                wam.convert_lengths(flange_points_reverse_oriented[:, 2], crs.xy_units, crs.z_units)
+            p_e = np.concatenate((p, flange_points_reverse_oriented))
+        else:
+            p_e = p
         self.crs_uuid = point_set.crs_uuid
         self.set_from_triangles_and_points(t, p_e)
         return flange_array
 
+    def extend_surface_with_flange(self,
+                                   convexity_parameter = 5.0,
+                                   reorient = False,
+                                   reorient_max_dip = None,
+                                   flange_point_count = 11,
+                                   flange_radial_factor = 10.0,
+                                   flange_radial_distance = None,
+                                   flange_inner_ring = False,
+                                   saucer_parameter = None,
+                                   make_clockwise = 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:
+            convexity_parameter (float, default 5.0): controls how likely the resulting triangulation is to be
+                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; 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; 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
+                factor of the maximum radial distance of the points themselves; ignored if extend_with_flange is False
+            flange_radial_distance (float, optional): if present, the minimum absolute distance of flange points from
+                centre of points; units are those of the crs
+            flange_inner_ring (bool, default False): if True, an inner ring of points, with double flange point counr,
+                is created at a radius just outside that of the furthest flung original point; this improves
+                triangulation of the extended point set when the original has a non-convex hull. Ignored if retriangulate
+                is False
+            saucer_parameter (float, optional): if present, and extend_with_flange is True, then a parameter
+                controlling the shift of flange points in a perpendicular direction away from the fault plane;
+                see notes for how this parameter is interpreted
+            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
+            retriangulate (bool, default False): if True, the surface will be generated with a retriangulation of
+                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
+            array is False on original triangle points, and True for extended flange triangles
+
+        notes:
+            a boolean array is created for the surface, with a value per triangle, set to False (zero) for non-flange
+            triangles and True (one) for flange triangles; this array is suitable for adding as a property for the
+            surface, with indexable element 'faces';
+            when flange extension occurs, the radius is the greater of the values determined from the radial factor
+            and radial distance arguments;
+            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;
+            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)
+        if retriangulate:
+            out_surf = Surface(self.model, crs_uuid = self.crs_uuid, title = self.title)
+            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, normal_vector)
+        else:
+            simple_saucer_angle = None
+            if saucer_parameter is not None and (saucer_parameter > 1.0 or saucer_parameter < 0.0):
+                assert -90.0 < saucer_parameter < 90.0, f'simple saucer angle parameter must be less than 90 degrees; too big: {saucer_parameter}'
+                simple_saucer_angle = saucer_parameter
+                saucer_parameter = None
+            assert saucer_parameter is None or 0.0 <= saucer_parameter < 1.0
+            crs = rqc.Crs(self.model, uuid = point_set.crs_uuid)
+            assert prev_p.ndim >= 2
+            assert prev_p.shape[-1] == 3
+            p = prev_p.reshape((-1, 3))
+            if crs.xy_units == crs.z_units or not reorient:
+                unit_adjusted_p = p
+            else:
+                unit_adjusted_p = p.copy()
+                wam.convert_lengths(unit_adjusted_p[:, 2], crs.z_units, crs.xy_units)
+            if reorient:
+                p_xy, normal, reorient_matrix = triangulate.reorient(unit_adjusted_p, max_dip = reorient_max_dip)
+            else:
+                p_xy = unit_adjusted_p
+                normal = self.normal()
+                reorient_matrix = None
+
+            centre_point = np.nanmean(p_xy.reshape((-1, 3)), axis = 0)  # work out the radius for the flange points
+            p_radius_v = np.nanmax(np.abs(p.reshape((-1, 3)) - np.expand_dims(centre_point, axis = 0)), axis = 0)[:2]
+            p_radius = maths.sqrt(np.sum(p_radius_v * p_radius_v))
+            radius = p_radius * flange_radial_factor
+            if flange_radial_distance is not None and flange_radial_distance > radius:
+                radius = flange_radial_distance
+
+            de, dc = self.distinct_edges_and_counts()  # find the distinct edges and counts
+            unique_edge = de[dc == 1]  # find hull edges (edges on only a single triangle)
+            hull_points = p_xy[unique_edge]  # find points defining the hull edges
+            hull_centres = np.mean(hull_points, axis = 1)  # find the centre of each edge
+
+            flange_points = np.empty(
+                shape = (hull_centres.shape), dtype = float
+            )  # loop over all the hull centres, generating a flange point and finding the azimuth from the centre to the hull centre point
+            az = np.empty(shape = len(hull_centres), dtype = float)
+            for i, c in enumerate(hull_centres):
+                v = [centre_point[0] - c[0], centre_point[1] - c[1], centre_point[2] - c[2]]
+                uv = -vec.unit_vector(v)
+                az[i] = vec.azimuth(uv)
+                flange_point = centre_point + radius * uv
+                if simple_saucer_angle is not None:
+                    z_shift = radius * maths.tan(vec.radians_from_degrees(simple_saucer_angle))
+                    if reorient:
+                        flange_point[2] -= z_shift
+                    else:
+                        flange_point -= (-vec.unit_vector(normal) * z_shift)
+                flange_points[i] = flange_point
+
+            sort_az_ind = np.argsort(np.array(az))  # sort by azimuth, to run through the hull points
+            new_points = np.empty(shape = (len(flange_points), 3), dtype = float)
+            new_triangles = np.empty(shape = (len(flange_points) * 2, 3), dtype = int)
+            point_offset = len(p_xy)  # the indices of the new triangles will begin after this
+            for i, ind in enumerate(sort_az_ind):  # loop over each point in azimuth order
+                new_points[i] = flange_points[ind]
+                this_hull_edge = unique_edge[ind]
+
+                def az_for_point(c):
+                    v = [centre_point[0] - c[0], centre_point[1] - c[1], centre_point[2] - c[2]]
+                    uv = -vec.unit_vector(v)
+                    return vec.azimuth(uv)
+
+                this_edge_az_sort = np.array(
+                    [az_for_point(p_xy[this_hull_edge[0]]),
+                     az_for_point(p_xy[this_hull_edge[1]])])
+                if np.min(this_edge_az_sort) < az[ind] < np.max(this_edge_az_sort):
+                    first, second = np.argsort(this_edge_az_sort)
+                else:
+                    second, first = np.argsort(this_edge_az_sort)
+                if i != len(sort_az_ind) - 1:
+                    new_triangles[2 * i] = np.array(
+                        [this_hull_edge[first], this_hull_edge[second],
+                         i + point_offset])  # add a triangle between the two hull points and the flange point
+                    new_triangles[(2 * i) + 1] = np.array(
+                        [this_hull_edge[second], i + point_offset,
+                         i + point_offset + 1])  # for all but the last point, hookup triangle to the next flange point
+                else:
+                    new_triangles[2 * i] = np.array(
+                        [this_hull_edge[first], this_hull_edge[second],
+                         i + point_offset])  # add a triangle between the two hull points and the first flange point
+                    new_triangles[(2 * i) + 1] = np.array(
+                        [this_hull_edge[second], point_offset,
+                         i + point_offset])  # add in the final triangle between the first and last flange points
+
+            all_points = np.concatenate((p_xy, new_points))  # concatenate triangle and points arrays
+            all_triangles = np.concatenate((prev_t, new_triangles))
+
+            flange_array = np.zeros(shape = all_triangles.shape[0], dtype = bool)
+            flange_array[
+                len(prev_t):] = True  # make a flange bool array, where all new triangles are flange and therefore True
+
+            assert len(all_points) == (
+                point_offset + len(flange_points)), "New point count should be old point count + flange point count"
+            assert len(all_triangles) == (
+                len(prev_t) +
+                2 * len(flange_points)), "New triangle count should be old triangle count + 2 x #flange points"
+
+            if saucer_parameter is not None:
+                _adjust_flange_z(self.model, crs.uuid, all_points, len(all_points), all_triangles, flange_array,
+                                 saucer_parameter)  # adjust the flange points if in saucer mode
+            if reorient:
+                all_points = vec.rotate_array(reorient_matrix.T, all_points)
+            if crs.xy_units != crs.z_units and reorient:
+                wam.convert_lengths(all_points[:, 2], crs.xy_units, crs.z_units)
+
+            if make_clockwise:
+                triangulate.make_all_clockwise_xy(all_triangles, all_points)  # modifies t in situ
+
+            out_surf = Surface(self.model, crs_uuid = self.crs_uuid, title = self.title)
+            out_surf.set_from_triangles_and_points(all_triangles, all_points)  # create the new surface
+            return out_surf, flange_array
+
     def make_all_clockwise_xy(self, reorient = False):
         """Reorders cached triangles data such that all triangles are clockwise when viewed from -ve z axis.
 
@@ -740,9 +1058,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)
@@ -845,7 +1164,7 @@ class Surface(rqsb.BaseSurface):
 
     def set_to_multi_cell_faces_from_corner_points(self, cp, quad_triangles = True):
         """Populates this (empty) surface to represent faces of a set of cells.
-        
+
         From corner points of shape (N, 2, 2, 2, 3).
         """
         assert cp.size % 24 == 0
@@ -881,7 +1200,7 @@ class Surface(rqsb.BaseSurface):
 
     def set_to_horizontal_plane(self, depth, box_xyz, border = 0.0, quad_triangles = False):
         """Populate this (empty) surface with a patch of two triangles.
-        
+
         Triangles define a flat, horizontal plane at a given depth.
 
         arguments:
@@ -985,7 +1304,7 @@ class Surface(rqsb.BaseSurface):
 
     def vertical_rescale_points(self, ref_depth = None, scaling_factor = 1.0):
         """Modify the z values of points by rescaling.
-        
+
         Stretches the distance from reference depth by scaling factor.
         """
         if scaling_factor == 1.0:
@@ -1170,12 +1489,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. 
-        
-        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 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)
 
         returns: 
-            resqpy.surface.Surface object with extra_metadata ('unique edges resampled from surface': uuid), where uuid is for the original surface uuid
+            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
@@ -1246,7 +1569,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/time_series/_any_time_series.py

@@ -34,14 +34,15 @@ class AnyTimeSeries(BaseResqpy):
             dt_text = rqet.find_tag_text(child, 'DateTime')
             assert dt_text, 'missing DateTime field in xml for time series'
             year_offset = rqet.find_tag_int(child, 'YearOffset')
-            if year_offset is not None:
-                assert self.timeframe == 'geologic'
+            if self.timeframe == 'geologic' and year_offset is not None:
                 if year_offset > 0:
                     log.warning(f'positive year offset in xml indicates future geological time: {year_offset}')
                 self.timestamps.append(year_offset)  # todo: trim and check timestamp
-            else:
-                assert self.timeframe == 'human'
+            elif self.timeframe == 'human' and not year_offset:
+                # year_offset can be 0 for "human" time frames, indicating None.
                 self.timestamps.append(dt_text)  # todo: trim and check timestamp
+            else:
+                raise AssertionError(f'Invalid combination of timeframe {self.timeframe} and year_offset {year_offset}')
             self.timestamps.sort()
 
     def is_equivalent(self, other_ts):