resqpy 4.14.2__py3-none-any.whl → 5.1.5__py3-none-any.whl

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
@@ -34,16 +36,22 @@ def find_faces_to_represent_surface_regular_wrapper(
         trimmed: bool = False,
         is_curtain = False,
         extend_fault_representation: bool = False,
-        flange_inner_ring = False,
-        saucer_parameter = None,
+        flange_inner_ring: bool = False,
+        saucer_parameter: Optional[float] = None,
         retriangulate: bool = False,
-        related_uuid = None,
+        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 = None) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
+        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:
@@ -92,10 +100,22 @@ def find_faces_to_represent_surface_regular_wrapper(
            the returned dictionary has the passed strings as keys and numpy arrays as values
         raw_bisector (bool, default False): if True and grid bisector is requested then it is left in a raw
            form without assessing which side is shallower (True values indicate same side as origin cell)
-        use_pack (bool, default False): if True, boolean properties will be stored in numpy packed format,
-           which will only be readable by resqpy based applications
+        use_pack (bool, default False): if True, boolean properties will be generated and stored in numpy
+           packed format, which will only be readable by resqpy based applications
         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
+        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:
@@ -105,18 +125,15 @@ def find_faces_to_represent_surface_regular_wrapper(
             - 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)
@@ -144,12 +161,20 @@ def find_faces_to_represent_surface_regular_wrapper(
     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)
@@ -175,7 +200,7 @@ def find_faces_to_represent_surface_regular_wrapper(
         surf = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         flange_bool = surf.set_from_point_set(pset,
                                               convexity_parameter = 2.0,
-                                              reorient = True,
+                                              reorient = reorient,
                                               extend_with_flange = extend_fault_representation,
                                               flange_inner_ring = flange_inner_ring,
                                               saucer_parameter = saucer_parameter,
@@ -189,19 +214,26 @@ def find_faces_to_represent_surface_regular_wrapper(
         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'):
@@ -209,12 +241,13 @@ def find_faces_to_represent_surface_regular_wrapper(
         surface = rqs.Surface(model, crs_uuid = grid.crs.uuid, title = surf_title)
         flange_bool = surface.set_from_point_set(pset,
                                                  convexity_parameter = 2.0,
-                                                 reorient = True,
+                                                 reorient = reorient,
                                                  extend_with_flange = extend_fault_representation,
                                                  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
@@ -235,9 +268,26 @@ def find_faces_to_represent_surface_regular_wrapper(
                                            property_kind = 'flange bool',
                                            find_local_property_kind = True,
                                            indexable_element = 'faces',
-                                           discrete = True)
+                                           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] < 127 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,
@@ -249,7 +299,10 @@ def find_faces_to_represent_surface_regular_wrapper(
                                                                      is_curtain,
                                                                      progress_fn,
                                                                      return_properties,
-                                                                     raw_bisector = raw_bisector)
+                                                                     raw_bisector = raw_bisector,
+                                                                     n_batches = n_threads,
+                                                                     packed_bisectors = use_pack,
+                                                                     patch_indices = patch_indices)
 
     success = False
 
@@ -279,6 +332,7 @@ def find_faces_to_represent_surface_regular_wrapper(
 
     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)
@@ -339,17 +393,18 @@ def find_faces_to_represent_surface_regular_wrapper(
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()
                     grid_pc.set_support(support = grid)
-                grid_pc.add_cached_array_to_imported_list(
-                    array,
-                    f"from find_faces function for {surface.title}",
-                    f'{surface.title} {p_name}',
-                    discrete = True,
-                    property_kind = "grid bisector",
-                    facet_type = 'direction',
-                    facet = 'raw' if raw_bisector else ('vertical' if is_curtain else 'sloping'),
-                    realization = realisation,
-                    indexable_element = "columns" if is_curtain else "cells",
-                )
+                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}',
+                                                          discrete = True,
+                                                          property_kind = "grid bisector",
+                                                          facet_type = 'direction',
+                                                          facet = 'raw' if raw_bisector else
+                                                          ('vertical' if is_curtain else 'sloping'),
+                                                          realization = realisation,
+                                                          indexable_element = "columns" if is_curtain else "cells",
+                                                          pre_packed = False if is_curtain else use_pack)
             elif p_name == 'grid shadow':
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()

resqpy/olio/read_nexus_fault.py

@@ -64,7 +64,10 @@ def load_nexus_fault_mult_table_from_list(file_as_list):
                         outdata[mask] = np.concatenate(d_elems)
                         df = pd.DataFrame(outdata)
                         for column in df.columns:
-                            df[column] = pd.to_numeric(df[column], errors = 'ignore')
+                            try:
+                                df[column] = pd.to_numeric(df[column], errors = "coerce")
+                            except ValueError:
+                                pass
                         df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
                         df['grid'] = grid
                         df['name'] = name
@@ -114,7 +117,10 @@ def load_nexus_fault_mult_table_from_list(file_as_list):
                 outdata[mask] = np.concatenate(d_elems)
                 df = pd.DataFrame(outdata)
                 for column in df.columns:
-                    df[column] = pd.to_numeric(df[column], errors = 'ignore')
+                    try:
+                        df[column] = pd.to_numeric(df[column], errors = "coerce")
+                    except ValueError:
+                        pass
                 df.columns = ['i1', 'i2', 'j1', 'j2', 'k1', 'k2', 'mult']
                 df['grid'] = grid
                 df['name'] = name

resqpy/olio/relperm.py

@@ -91,7 +91,7 @@ class RelPerm(DataFrame):
             processed_phase_combo_checks.get(processed_phase_combo)(df)
             # ensure that missing capillary pressure values are stored as np.nan
             if 'Pc' in df.columns:
-                df['Pc'].replace('None', np.nan, inplace = True)
+                df['Pc'] = df['Pc'].replace('None', np.nan)
             # convert all values in the dataframe to numeric type
             df[df.columns] = df[df.columns].apply(pd.to_numeric, errors = 'coerce')
             # ensure that no other column besides Pc has missing values

resqpy/olio/transmission.py

@@ -260,10 +260,10 @@ def half_cell_t_irregular(grid,
             zero_length_mask = np.logical_or(np.any(np.isnan(half_axis_vectors), axis = -1),
                                              half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_k * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_k * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         elif axis == 1:  # j
@@ -303,10 +303,10 @@ def half_cell_t_irregular(grid,
             half_axis_length_sqr = np.sum(half_axis_vectors * half_axis_vectors, axis = -1)
             zero_length_mask = (half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_j * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_j * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         else:  # i
@@ -345,10 +345,10 @@ def half_cell_t_irregular(grid,
             half_axis_length_sqr = np.sum(half_axis_vectors * half_axis_vectors, axis = -1)
             zero_length_mask = (half_axis_length_sqr < tolerance_sqr)
             minus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_i * np.sum(half_axis_vectors * minus_face_areas, axis = -1) / half_axis_length_sqr)
             plus_face_t = np.where(
-                zero_length_mask, np.NaN,
+                zero_length_mask, np.nan,
                 perm_i * np.sum(half_axis_vectors * plus_face_areas, axis = -1) / half_axis_length_sqr)
 
         if axis != 0 and ntg is not None:
@@ -417,14 +417,14 @@ def half_cell_t_vertical_prism(vpg,
     # compute transmissibilities
     tr = np.zeros((vpg.cell_count, 5), dtype = float)
     # vertical
-    tr[:, 0] = np.where(half_thickness < tolerance, np.NaN, (perm_k.reshape(
+    tr[:, 0] = np.where(half_thickness < tolerance, np.nan, (perm_k.reshape(
         (vpg.nk, -1)) * triangle_areas / half_thickness)).flatten()
     tr[:, 1] = tr[:, 0]
     # horizontal
     # TODO: compute dip adjustments for non-vertical transmissibilities
     dt_full = np.empty((vpg.nk, vpg.cell_count // vpg.nk, 3), dtype = float)
     dt_full[:] = d_t
-    tr[:, 2:] = np.where(dt_full < tolerance, np.NaN,
+    tr[:, 2:] = np.where(dt_full < tolerance, np.nan,
                          triple_perm_horizontal.reshape((vpg.nk, -1, 3)) * a_t.reshape((1, -1, 3)) / dt_full).reshape(
                              (-1, 3))
     if ntg is not None:

resqpy/olio/triangulation.py

@@ -25,7 +25,7 @@ import resqpy.olio.vector_utilities as vec
 
 def _dt_scipy(points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Calculates the Delaunay triangulation for an array of points and the convex hull indices.
-    
+
     arguments:
         points (np.ndarray): coordinates of the points to triangulate; array has shape
             (npoints, ndim)
@@ -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
@@ -115,7 +115,7 @@ def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = N
     if n_p < 3:
         return None, None  # not enough points
     elif n_p == 3:
-        return np.array([0, 1, 2], dtype = int).reshape((1, 3)), np.array([0, 1, 2], dtype = int)
+        return np.array([0, 1, 2], dtype = np.int32).reshape((1, 3)), np.array([0, 1, 2], dtype = np.int32)
 
     if progress_fn is not None:
         progress_fn(0.0)
@@ -133,19 +133,20 @@ def _dt_simple(po, plot_fn = None, progress_fn = None, container_size_factor = N
     p[-1] = (min_xy[0] + 0.5 * csf * dxy[0], max_xy[1] + 0.8 * csf * dxy[1])
 
     # triangle vertex indices
-    t = np.empty((2 * n_p + 2, 3), dtype = int)  # empty space for triangle vertex indices
+    t_type = np.int32 if n_p < 2_147_483_648 else np.int64
+    t = np.empty((2 * n_p + 2, 3), dtype = t_type)  # empty space for triangle vertex indices
     t[0] = (n_p, n_p + 1, n_p + 2)  # initial set of one containing triangle
     nt = 1  # number of triangles so far populated
 
     # edges: list of indices of triangles and edge within triangle; -1 indicates no triangle using edge
-    e = np.full((3 * n_p + 6, 2, 2), fill_value = -1, dtype = int)
+    e = np.full((3 * n_p + 6, 2, 2), fill_value = -1, dtype = t_type)
     e[:3, 0, 0] = 0
     for edge in range(3):
         e[edge, 0, 1] = edge
     ne = 3  # number of edges so far in use
 
     # edge indices (in e) for each triangle, first axis indexed in sync with t
-    te = np.empty((2 * n_p + 2, 3), dtype = int)  # empty space for triangle edge indices
+    te = np.empty((2 * n_p + 2, 3), dtype = t_type)  # empty space for triangle edge indices
     te[0] = (0, 1, 2)
 
     # mask tracking which edges have been flipped
@@ -233,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
@@ -252,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
 
@@ -260,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'
@@ -273,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
 
@@ -303,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
@@ -328,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 = []
@@ -501,7 +502,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
         return trimmed_ci
 
     def __veroni_cells(aoi_count, aoi_intersect_segments, b, c, c_count, ca_count, cah_count, caho_count, cahon_count,
-                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi):
+                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi, t_type):
         # list of voronoi cells (each a numpy list of node indices into c extended with aoi points etc)
         v = []
         # for each seed point build the voronoi cell
@@ -550,7 +551,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
                                                   ci_for_p, out_pair_intersect_segments)
 
             #  remove circumcircle centres that are outwith area of interest
-            ci_for_p = np.array([ti for ti in ci_for_p if ti >= c_count or ti not in tc_outwith_aoi], dtype = int)
+            ci_for_p = np.array([ti for ti in ci_for_p if ti >= c_count or ti not in tc_outwith_aoi], dtype = t_type)
 
             # find azimuths of vectors from seed point to circumcircle centres and aoi boundary points
             azi = [vec.azimuth(centre - p[p_i, :2]) for centre in c[ci_for_p, :2]]
@@ -581,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))
@@ -612,11 +613,12 @@ def voronoi(p, t, b, aoi: rql.Polyline):
     caho_count = cah_count + 2 * o_count
     cahon_count = caho_count + hull_count
     assert cahon_count + hull_count == len(c)
+    t_type = np.int32 if len(c) < 2_147_483_648 else np.int64
 
     #  compute intersection points between hull edge normals and aoi polyline
     # also extended virtual centres for hull edges
     extension_scaling = 1000.0 * np.sum((np.max(aoi.coordinates, axis = 0) - np.min(aoi.coordinates, axis = 0))[:2])
-    aoi_intersect_segments = np.empty((hull_count,), dtype = int)
+    aoi_intersect_segments = np.empty((hull_count,), dtype = t_type)
     for ei in range(hull_count):
         # use segment midpoint and normal methods of hull to project out
         m = hull.segment_midpoint(ei)[:2]  # midpoint
@@ -638,8 +640,8 @@ def voronoi(p, t, b, aoi: rql.Polyline):
         c[cahon_count + ei] = hull.coordinates[ei, :2] + extension_scaling * vector
 
     # where cicrumcircle centres are outwith aoi, compute intersections of normals of wing edges with aoi
-    out_pair_intersect_segments = np.empty((o_count, 2), dtype = int)
-    wing_hull_segments = np.empty((o_count, 2), dtype = int)
+    out_pair_intersect_segments = np.empty((o_count, 2), dtype = t_type)
+    wing_hull_segments = np.empty((o_count, 2), dtype = t_type)
     for oi, ti in enumerate(tc_outwith_aoi):
         tpi = __shorter_sides_p_i(p[t[ti]])
         for wing in range(2):
@@ -658,7 +660,7 @@ def voronoi(p, t, b, aoi: rql.Polyline):
             tpi = (tpi + 1) % 3
 
     v = __veroni_cells(aoi_count, aoi_intersect_segments, b, c, c_count, ca_count, cah_count, caho_count, cahon_count,
-                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi)
+                       hull_count, out_pair_intersect_segments, p, t, tc_outwith_aoi, t_type)
 
     return c[:caho_count], v
 
@@ -703,7 +705,8 @@ def triangulated_polygons(p, v, centres = None):
         points[len(p):] = centres
 
     t_count = sum([len(x) for x in v])
-    triangles = np.empty((t_count, 3), dtype = int)
+    t_type = np.int32 if len(points) < 2_147_483_648 else np.int64
+    triangles = np.empty((t_count, 3), dtype = t_type)
     t_index = 0
 
     for cell, poly_vertices in enumerate(v):
@@ -711,7 +714,7 @@ def triangulated_polygons(p, v, centres = None):
         centre_i = len(p) + cell
         if centres is None:
             polygon = rql.Polyline(model,
-                                   set_coord = p[np.array(poly_vertices, dtype = int)],
+                                   set_coord = p[np.array(poly_vertices, dtype = t_type)],
                                    is_closed = True,
                                    set_crs = crs.uuid,
                                    title = 'v cell')
@@ -747,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
@@ -865,9 +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
+       (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):
@@ -895,8 +900,8 @@ def surrounding_xy_ring(p,
         inner_radius = p_radius * 1.1
         assert radius > inner_radius
         in_ring = make_ring(2 * count, centre, inner_radius, saucer_angle)
-        return np.concatenate((in_ring, ring), axis = 0)
-    return ring
+        return np.concatenate((in_ring, ring), axis = 0), radius
+    return ring, radius
 
 
 def edges(t):
@@ -917,7 +922,7 @@ def edges(t):
     """
 
     assert t.ndim == 2 and t.shape[1] == 3
-    all_edges = np.empty((len(t), 3, 2), dtype = int)
+    all_edges = np.empty((len(t), 3, 2), dtype = t.dtype)
     all_edges[:, :, 0] = t
     all_edges[:, :2, 1] = t[:, 1:]
     all_edges[:, 2, 1] = t[:, 0]
@@ -946,6 +951,7 @@ def triangles_using_edges(t, edges):
     """Returns int array of shape (len(edges), 2) with indices of upto 2 triangles using each edge (-1 for unused)."""
 
     assert t.ndim == 2 and t.shape[1] == 3 and edges.ndim == 2 and edges.shape[1] == 2
+    t_type = np.int32 if len(t) < 2_147_483_648 else np.int64
     ti = np.full((len(edges), 2), -1, dtype = int)
     for i in range(len(edges)):
         te = triangles_using_edge(t, edges[i, 0], edges[i, 1])