resqpy 4.5.0__py3-none-any.whl → 4.6.3__py3-none-any.whl

resqpy/olio/triangulation.py

@@ -751,9 +751,6 @@ def reorient(points, rough = True, max_dip = None, use_linalg = False):
        the numpy linear algebra option seems to be memory intensive, not recommended
     """
 
-    def z_range(p):
-        return np.nanmax(p[..., 2]) - np.nanmin(p[..., 2])
-
     def best_angles(points, mid_x, mid_y, steps, d_theta):
         best_range = None
         best_x_rotation = None
@@ -766,7 +763,7 @@ def reorient(points, rough = True, max_dip = None, use_linalg = False):
                 rotation_m = vec.rotation_3d_matrix((x_degrees, 0.0, y_degrees))
                 p = points.copy()
                 rotated_p = vec.rotate_array(rotation_m, p)
-                z_r = z_range(rotated_p)
+                z_r = np.nanmax(rotated_p[..., 2]) - np.nanmin(rotated_p[..., 2])
                 if best_range is None or z_r < best_range:
                     best_range = z_r
                     best_x_rotation = x_degrees
@@ -777,14 +774,13 @@ def reorient(points, rough = True, max_dip = None, use_linalg = False):
         assert p.ndim >= 2 and p.shape[-1] == 3
         p = p.reshape((-1, 3))
         centre = p.sum(axis = 0) / p.shape[0]
-        u, s, vh = np.linalg.svd(p - centre)
+        _, _, vh = np.linalg.svd(p - centre)
         # unit normal vector
         return vh[2, :]
 
     assert points.ndim >= 2 and points.shape[-1] == 3
 
     if use_linalg:
-
         normal_vector = linalg_normal_vector(points)
         incl = vec.inclination(normal_vector)
         if incl == 0.0:
@@ -792,10 +788,8 @@ def reorient(points, rough = True, max_dip = None, use_linalg = False):
         else:
             azi = vec.azimuth(normal_vector)
             rotation_m = vec.tilt_3d_matrix(azi, incl)
-
     else:
-
-        # coarse iteration trying a few different angles
+        # coarse iteration trying a few different angles
         best_x_rotation, best_y_rotation = best_angles(points, 0.0, 0.0, 7, 30.0)
 
         # finer iteration searching around the best coarse rotation
@@ -837,7 +831,7 @@ def make_all_clockwise_xy(t, p):
     return t
 
 
-def surrounding_xy_ring(p, count = 12, radial_factor = 10.0, radial_distance = None):
+def surrounding_xy_ring(p, count = 12, radial_factor = 10.0, radial_distance = None, inner_ring = False):
     """Creates a set of points surrounding the point set p, in the xy plane.
 
     arguments:
@@ -847,12 +841,23 @@ def surrounding_xy_ring(p, count = 12, radial_factor = 10.0, radial_distance = N
           the 'radius' of the outermost points in p
        radial_distance (float): if present, the radius of the ring of points, unless radial_factor
           results in a greater distance in which case that is used
+       inner_ring (bool, default False): if True, an inner ring of points, with double count, 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
 
     returns:
-       numpy float array of shape (count, 3) being xyz points in surrounding ring; z is set constant to
-       mean value of z in p
+       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; N is count if inner_ring is False, 3 * count if True
     """
 
+    def make_ring(count, centre, radius):
+        delta_theta = 2.0 * maths.pi / float(count)
+        ring = np.zeros((count, 3))
+        for i in range(count):
+            theta = float(i) * delta_theta
+            ring[i] = centre + radius * np.array([maths.cos(theta), maths.sin(theta), 0.0])
+        return ring
+
     assert p.shape[-1] == 3
     assert radial_factor >= 1.0
     centre = np.nanmean(p.reshape((-1, 3)), axis = 0)
@@ -861,11 +866,12 @@ def surrounding_xy_ring(p, count = 12, radial_factor = 10.0, radial_distance = N
     radius = p_radius * radial_factor
     if radial_distance is not None and radial_distance > radius:
         radius = radial_distance
-    delta_theta = 2.0 * maths.pi / float(count)
-    ring = np.zeros((count, 3))
-    for i in range(count):
-        theta = float(i) * delta_theta
-        ring[i] = centre + radius * np.array([maths.cos(theta), maths.sin(theta), 0.0])
+    ring = make_ring(count, centre, radius)
+    if inner_ring:
+        inner_radius = p_radius * 1.1
+        assert radius > inner_radius
+        in_ring = make_ring(2 * count, centre, inner_radius)
+        return np.concatenate((in_ring, ring), axis = 0)
     return ring
 
 
@@ -896,6 +902,36 @@ def edges(t):
     return np.unique(all_edges, axis = 0, return_counts = True)
 
 
+def triangles_using_point(t, point_index):
+    """Returns list-like 1D int array of indices of triangles using vertex identified by point_index."""
+
+    assert t.ndim == 2 and t.shape[1] == 3 and isinstance(point_index, int)
+    mask = np.any(t == point_index, axis = -1)
+    return np.where(mask)[0]
+
+
+def triangles_using_edge(t, p1, p2):
+    """Returns list-like 1D int array of indices of triangles using edge identified by pair of point indices."""
+
+    assert t.ndim == 2 and t.shape[1] == 3 and p1 != p2
+    mask = np.logical_and(np.any(t == p1, axis = -1), np.any(t == p2, axis = -1))
+    return np.where(mask)[0]
+
+
+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
+    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])
+        c = len(te)
+        assert 0 <= c <= 2
+        if c:
+            ti[i, :c] = te
+    return ti
+
+
 def rim_edges(all_edges, edge_counts):
     """Returns a subset of all edges where the edge count is 1."""
 
@@ -904,6 +940,14 @@ def rim_edges(all_edges, edge_counts):
     return all_edges[edge_counts == 1, :]
 
 
+def internal_edges(all_edges, edge_counts):
+    """Returns a subset of all edges where the edge count is 2."""
+
+    assert all_edges.ndim == 2 and all_edges.shape[1] == 2
+    assert edge_counts.ndim == 1 and edge_counts.size == len(all_edges)
+    return all_edges[edge_counts == 2, :]
+
+
 def rims(all_rim_edges):
     """Returns edge index and points index lists of distinct rims.
 
@@ -949,7 +993,7 @@ def rims(all_rim_edges):
     return rim_edges_list, rim_points_list
 
 
-@njit
+@njit  # pragma: no cover
 def _find_unused(ap: np.ndarray, used_mask: np.ndarray, v: int):  # type: ignore
     """Finds the first unused occurence of v in pair list ap, returning index and paired value."""
     for idx, val in np.ndenumerate(ap[:, 0]):
@@ -961,18 +1005,18 @@ def _find_unused(ap: np.ndarray, used_mask: np.ndarray, v: int):  # type: ignore
     return ap.shape[0], -1
 
 
-@njit
+@njit  # pragma: no cover
 def _first_false(array: np.ndarray) -> Optional[int]:  # type: ignore
-    """Returns the index of the first False value in the array."""
+    """Returns the index of the first False (or zero) value in the 1D array."""
     for idx, val in np.ndenumerate(array):
         if not val:
             return idx[0]
     return array.size
 
 
-@njit
+@njit  # pragma: no cover
 def _first_match(array: np.ndarray, v: int) -> Optional[int]:  # type: ignore
-    """Returns the index of the first True value in the array."""
+    """Returns the index of the first occurrence of value v in the 1D array."""
     for idx, val in np.ndenumerate(array):
         if val == v:
             return idx[0]

resqpy/olio/vector_utilities.py

@@ -75,10 +75,22 @@ def amplify(v, scaling):  # note: could just use numpy a * scalar facility
 def unit_vector(v):
     """Returns vector with same direction as v but with unit length."""
     assert 2 <= len(v) <= 3
-    v = np.array(v, dtype = float)
-    if np.all(v == 0.0):
+    v = np.array(v, dtype = np.float64)
+    norm = np.linalg.norm(v)
+    if norm == 0.0:
         return v
-    return v / maths.sqrt(np.sum(v * v))
+    v = v / norm
+    return v
+
+
+@njit
+def unit_vector_njit(v):  # pragma: no cover
+    """Returns vector with same direction as v but with unit length."""
+    norm = np.linalg.norm(v)
+    if norm == 0.0:
+        return v
+    v = v / norm
+    return v
 
 
 def unit_vectors(v):
@@ -189,6 +201,7 @@ def nan_inclinations(a, already_unit_vectors = False):
 
 def points_direction_vector(a, axis):
     """Returns an average direction vector based on first and last non-NaN points or slices in given axis."""
+    # note: as currently coded, might give poor results with some patterns of NaNs
 
     assert a.ndim > 1 and 0 <= axis < a.ndim - 1 and a.shape[-1] > 1 and a.shape[axis] > 1
     if np.all(np.isnan(a)):
@@ -196,17 +209,18 @@ def points_direction_vector(a, axis):
     start = 0
     start_slicing = [slice(None)] * a.ndim
     while True:
-        start_slicing[axis] = slice(start)
+        start_slicing[axis] = slice(start, start + 1)
         if not np.all(np.isnan(a[tuple(start_slicing)])):
             break
         start += 1
+        assert start < a.shape[axis]
     finish = a.shape[axis] - 1
     finish_slicing = [slice(None)] * a.ndim
     while True:
-        finish_slicing[axis] = slice(finish)
+        finish_slicing[axis] = slice(finish, finish + 1)
         if not np.all(np.isnan(a[tuple(finish_slicing)])):
             break
-        finish += 1
+        finish -= 1
     if start >= finish:
         return None
     if a.ndim > 2:
@@ -220,24 +234,24 @@ def points_direction_vector(a, axis):
     return finish_p - start_p
 
 
-def dot_product(a, b):
+def dot_product(a, b):  # pragma: no cover
     """Returns the dot product (scalar product) of the two vectors."""
     return np.dot(a, b)
 
 
-def dot_products(a, b):
+def dot_products(a, b):  # pragma: no cover
     """Returns the dot products of pairs of vectors; last axis covers element of a vector."""
     return np.sum(a * b, axis = -1)
 
 
-def cross_product(a, b):
+def cross_product(a, b):  # pragma: no cover
     """Returns the cross product (vector product) of the two vectors."""
     return np.cross(a, b)
 
 
-def naive_length(v):
+def naive_length(v):  # pragma: no cover
     """Returns the length of the vector assuming consistent units."""
-    return maths.sqrt(dot_product(v, v))
+    return np.linalg.norm(v)
 
 
 def naive_lengths(v):
@@ -245,9 +259,9 @@ def naive_lengths(v):
     return np.sqrt(np.sum(v * v, axis = -1))
 
 
-def naive_2d_length(v):
+def naive_2d_length(v):  # pragma: no cover
     """Returns the length of the vector projected onto xy plane, assuming consistent units."""
-    return maths.sqrt(dot_product(v[0:2], v[0:2]))
+    return np.linalg.norm(v[0:2])
 
 
 def naive_2d_lengths(v):
@@ -257,9 +271,20 @@ def naive_2d_lengths(v):
 
 
 def unit_corrected_length(v, unit_conversion):
-    """Returns the length of the vector v after applying the unit_conversion factors."""
-    # unit_conversion might be [1.0, 1.0, 0.3048] to convert z from feet to metres, for example
-    # or [3.28084, 3.28084, 1.0] to convert x and y from metres to feet
+    """Returns the length of the vector v after applying the unit_conversion factors.
+
+    arguments:
+        v (1D numpy float array): vector with mixed units of measure
+        unit_conversion (1D numpy float array): vector to multiply elements of v by, prior to finding length
+
+    returns:
+        float, being the length of v after adjustment by unit_conversion
+
+    notes:
+        example unit_conversion might be:
+        [1.0, 1.0, 0.3048] to convert z from feet to metres, or
+        [3.28084, 3.28084, 1.0] to convert x and y from metres to feet
+    """
     converted = elemental_multiply(v, unit_conversion)
     return naive_length(converted)
 
@@ -293,14 +318,12 @@ def rotation_matrix_3d_axial(axis, angle):
        this function follows the mathematical convention: a positive angle results in anti-clockwise rotation
        when viewed in direction of positive axis
     """
-
     axis_a = (axis + 1) % 3
     axis_b = (axis_a + 1) % 3
-    matrix = np.zeros((3, 3))
-    matrix[axis, axis] = 1.0
-    radians = radians_from_degrees(angle)
-    cosine = maths.cos(radians)
-    sine = maths.sin(radians)
+    matrix = np.eye(3)
+    radians = np.radians(angle)
+    cosine = np.cos(radians)
+    sine = np.sin(radians)
     matrix[axis_a, axis_a] = cosine
     matrix[axis_b, axis_b] = cosine
     matrix[axis_a, axis_b] = -sine  # left handed coordinate system, eg. UTM & depth
@@ -308,45 +331,66 @@ def rotation_matrix_3d_axial(axis, angle):
     return matrix
 
 
-def no_rotation_matrix():
-    """Returns a rotation matrix which will not move points."""
-    matrix = np.zeros((3, 3))
-    for axis in range(3):
-        matrix[axis, axis] = 1.0
-    return matrix
+def no_rotation_matrix():  # pragma: no cover
+    """Returns a rotation matrix which will not move points (identity matrix)."""
+    return np.eye(3)
 
 
 def rotation_3d_matrix(xzy_axis_angles):
-    """Returns a rotation matrix which will rotate points about 3 axes by angles in degrees."""
-
-    # matrix = np.zeros((3, 3))
-    # for axis in range(3):
-    #     matrix[axis, axis] = 1.0
-    # for axis in range(3):
-    #     matrix = np.dot(matrix, rotation_matrix_3d_axial(axis, xzy_axis_angles[axis]))
-    matrix = rotation_matrix_3d_axial(1, xzy_axis_angles[2])  # about y axis
-    matrix = np.dot(matrix, rotation_matrix_3d_axial(2, xzy_axis_angles[1]))  # about z axis
-    matrix = np.dot(matrix, rotation_matrix_3d_axial(0, xzy_axis_angles[0]))  # about x axis
-    return matrix
+    """Returns a rotation matrix which will rotate points about the x, z, then y axis by angles in degrees."""
+    angles = np.radians(xzy_axis_angles)
+    cos_c, cos_a, cos_b = np.cos(angles)
+    sin_c, sin_a, sin_b = np.sin(angles)
+
+    sin_a_sin_c = sin_a * sin_c
+    sin_a_cos_c = sin_a * cos_c
+
+    rotation_matrix = np.array([
+        [cos_a * cos_b, -sin_a_cos_c * cos_b + sin_b * sin_c, cos_b * sin_a_sin_c + sin_b * cos_c],
+        [sin_a, cos_a * cos_c, -sin_c * cos_a],
+        [-sin_b * cos_a, sin_a_cos_c * sin_b + cos_b * sin_c, -sin_b * sin_a_sin_c + cos_b * cos_c],
+    ])
+    return rotation_matrix
+
+
+@njit
+def rotation_3d_matrix_njit(xzy_axis_angles):  # pragma: no cover
+    """Returns a rotation matrix which will rotate points about the x, z, then y axis by angles in degrees."""
+    angles = np.radians(xzy_axis_angles)
+    cos_c, cos_a, cos_b = np.cos(angles)
+    sin_c, sin_a, sin_b = np.sin(angles)
+
+    sin_a_sin_c = sin_a * sin_c
+    sin_a_cos_c = sin_a * cos_c
 
+    rotation_matrix = np.array([
+        [cos_a * cos_b, -sin_a_cos_c * cos_b + sin_b * sin_c, cos_b * sin_a_sin_c + sin_b * cos_c],
+        [sin_a, cos_a * cos_c, -sin_c * cos_a],
+        [-sin_b * cos_a, sin_a_cos_c * sin_b + cos_b * sin_c, -sin_b * sin_a_sin_c + cos_b * cos_c],
+    ])
+    return rotation_matrix
 
-def reverse_rotation_3d_matrix(xzy_axis_angles):
-    """Returns a rotation matrix which will rotate back points about 3 axes by angles in degrees."""
+
+def reverse_rotation_3d_matrix(xzy_axis_angles):  # pragma: no cover
+    """Returns a rotation matrix which will rotate points about the y, z, then x axis by angles in degrees."""
 
     return rotation_3d_matrix(xzy_axis_angles).T
 
 
-def rotate_vector(rotation_matrix, vector):
+def rotate_vector(rotation_matrix, vector):  # pragma: no cover
     """Returns the rotated vector."""
-
     return np.dot(rotation_matrix, vector)
 
 
 def rotate_array(rotation_matrix, a):
     """Returns a copy of array a with each vector rotated by the rotation matrix."""
+    return np.matmul(rotation_matrix, a.reshape(-1, 3).T).T.reshape(a.shape)
 
-    s = a.shape
-    return np.matmul(rotation_matrix, a.reshape(-1, 3).T).T.reshape(s)
+
+@njit
+def rotate_array_njit(rotation_matrix, a):  # pragma: no cover
+    """Returns a copy of array a with each vector rotated by the rotation matrix."""
+    return np.dot(rotation_matrix, a.reshape(-1, 3).T).T.reshape(a.shape)
 
 
 def rotate_xyz_array_around_z_axis(a, target_xy_vector):
@@ -399,15 +443,32 @@ def tilt_3d_matrix(azimuth, dip):
 
 
 def rotation_matrix_3d_vector(v):
+    """Returns a rotation matrix which will rotate vector v to the vertical (z) axis.
+
+    note:
+       the returned matrix will map a positive z axis vector onto v
+    """
+    v = v / np.linalg.norm(v)
+    kmat = np.array([[0, 0, -v[0]], [0, 0, -v[1]], [v[0], v[1], 0]])
+    rotation_matrix = np.eye(3) + kmat + kmat.dot(kmat) * (1 / (1 + v[2]))
+
+    rotation_matrix[:2] = -rotation_matrix[:2]
+    return rotation_matrix
+
+
+@njit
+def rotation_matrix_3d_vector_njit(v):  # pragma: no cover
     """Returns a rotation matrix which will rotate points by inclination and azimuth of vector.
 
     note:
        the returned matrix will map a positive z axis vector onto v
     """
+    v = v / np.linalg.norm(v)
+    kmat = np.array([[0, 0, -v[0]], [0, 0, -v[1]], [v[0], v[1], 0]])
+    rotation_matrix = np.eye(3) + kmat + kmat.dot(kmat) * (1 / (1 + v[2]))
 
-    m = tilt_3d_matrix(azimuth(v), inclination(v))
-    m[:2, :] = -m[:2, :]  # todo: should this change be in the tilt matrix?
-    return m
+    rotation_matrix[:2] = -rotation_matrix[:2]
+    return rotation_matrix
 
 
 def tilt_points(pivot_xyz, azimuth, dip, points):
@@ -562,7 +623,7 @@ def points_in_triangles(p, t, da, projection = 'xy', edged = False):
 
 
 @njit
-def point_in_polygon(x, y, polygon):
+def point_in_polygon(x, y, polygon):  # pragma: no cover
     """Calculates if a point in within a polygon in 2D.
     
     arguments:
@@ -576,14 +637,14 @@ def point_in_polygon(x, y, polygon):
     note:
         the polygon is assumed closed, the closing point should not be repeated
     """
-    polygon_vertices = len(polygon)
+    n = len(polygon)
     inside = False
     p2x = 0.0
     p2y = 0.0
     xints = 0.0
     p1x, p1y = polygon[0]
-    for i in numba.prange(polygon_vertices + 1):
-        p2x, p2y = polygon[i % polygon_vertices]
+    for i in range(n + 1):
+        p2x, p2y = polygon[i % n]
         if y > min(p1y, p2y):
             if y <= max(p1y, p2y):
                 if x <= max(p1x, p2x):
@@ -592,11 +653,12 @@ def point_in_polygon(x, y, polygon):
                     if p1x == p2x or x <= xints:
                         inside = not inside
         p1x, p1y = p2x, p2y
+
     return inside
 
 
 @njit
-def point_in_triangle(x, y, triangle):
+def point_in_triangle(x, y, triangle):  # pragma: no cover
     """Calculates if a point in within a triangle in 2D.
 
     arguments:
@@ -666,7 +728,7 @@ def point_in_triangle(x, y, triangle):
     return inside
 
 
-@njit
+@njit(parallel = True)  # pragma: no cover
 def points_in_polygon(points: np.ndarray, polygon: np.ndarray, points_xlen: int, polygon_num: int = 0) -> np.ndarray:
     """Calculates which points are within a polygon in 2D.
 
@@ -683,17 +745,18 @@ def points_in_polygon(points: np.ndarray, polygon: np.ndarray, points_xlen: int,
     note:
         the polygon is assumed closed, the closing point should not be repeated
     """
-    polygon_points = np.empty((0, 3), dtype = numba.int32)
+    polygon_points = np.full((len(points), 3), -1, dtype = np.int32)
     for point_num in numba.prange(len(points)):
-        p = point_in_polygon(points[point_num, 0], points[point_num, 1], polygon)
+        x, y = points[point_num]
+        p = point_in_polygon(x, y, polygon)
         if p is True:
             j, i = divmod(point_num, points_xlen)
-            polygon_points = np.append(polygon_points, np.array([[polygon_num, j, i]], dtype = numba.int32), axis = 0)
+            polygon_points[point_num] = [polygon_num, j, i]
 
-    return polygon_points
+    return polygon_points[polygon_points[:, 0] != -1]
 
 
-@njit
+@njit  # pragma: no cover
 def points_in_triangle(points: np.ndarray, triangle: np.ndarray, points_xlen: int, triangle_num: int = 0) -> np.ndarray:
     """Calculates which points are within a triangle in 2D.
 
@@ -707,19 +770,17 @@ def points_in_triangle(points: np.ndarray, triangle: np.ndarray, points_xlen: in
         triangle_points (np.ndarray): 2D array containing only the points within the triangle,
             with each row being the triangle number, points y index, and points x index.
     """
-    triangle_points = np.empty((0, 3), dtype = numba.int32)
+    triangle_points = np.full((len(points), 3), -1, dtype = np.int32)
     for point_num in numba.prange(len(points)):
         p = point_in_triangle(points[point_num, 0], points[point_num, 1], triangle)
         if p is True:
             yi, xi = divmod(point_num, points_xlen)
-            triangle_points = np.append(triangle_points,
-                                        np.array([[triangle_num, yi, xi]], dtype = numba.int32),
-                                        axis = 0)
+            triangle_points[point_num] = [triangle_num, yi, xi]
 
-    return triangle_points
+    return triangle_points[triangle_points[:, 0] != -1]
 
 
-@njit
+@njit  # pragma: no cover
 def mesh_points_in_triangle(triangle: np.ndarray,
                             points_xlen: int,
                             points_ylen: int,
@@ -751,7 +812,7 @@ def mesh_points_in_triangle(triangle: np.ndarray,
     return triangle_points
 
 
-@njit
+@njit  # pragma: no cover
 def points_in_polygons(points: np.ndarray, polygons: np.ndarray, points_xlen: int) -> np.ndarray:
     """Calculates which points are within which polygons in 2D.
 
@@ -793,7 +854,7 @@ def points_in_triangles_njit(points: np.ndarray, triangles: np.ndarray, points_x
     return triangles_points
 
 
-@njit
+@njit  # pragma: no cover
 def meshgrid(x: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Returns coordinate matrices from coordinate vectors x and y.
 
@@ -861,7 +922,7 @@ def points_in_triangles_aligned(nx: int, ny: int, dx: float, dy: float, triangle
     return triangles_points
 
 
-@njit
+@njit  # pragma: no cover
 def triangle_box(triangle: np.ndarray) -> Tuple[float, float, float, float]:
     """Finds the minimum and maximum x and y values of a single traingle.
 
@@ -907,7 +968,7 @@ def vertical_intercept(x: float, x_values: np.ndarray, y_values: np.ndarray) ->
     return y
 
 
-@njit
+@njit  # pragma: no cover
 def points_in_triangles_aligned_optimised(nx: int, ny: int, dx: float, dy: float, triangles: np.ndarray) -> np.ndarray:
     """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
 
@@ -961,7 +1022,7 @@ def triangle_normal_vector(p3):
 
 
 @njit
-def triangle_normal_vector_numba(points):
+def triangle_normal_vector_numba(points):  # pragma: no cover
     """For a triangle in 3D space, defined by 3 vertex points, returns a unit vector normal to the plane of the triangle.
 
     note:
@@ -1120,13 +1181,56 @@ def xy_sorted(p, axis = None):
     """
     assert p.ndim >= 2 and p.shape[-1] >= 2
     p = p.reshape((-1, p.shape[-1]))
-    xy_range = np.nanmax(p, axis = 0) - np.nanmin(p, axis = 0)
     if axis is None:
+        xy_range = np.nanmax(p, axis = 0) - np.nanmin(p, axis = 0)
         axis = (1 if xy_range[1] > xy_range[0] else 0)
     spi = np.argsort(p[:, axis])
     return p[spi], axis
 
 
+@njit
+def xy_sorted_njit(p, axis = -1):  # pragma: no cover
+    """Returns copy of points p sorted according to x or y (whichever has greater range)."""
+    assert p.ndim >= 2 and p.shape[-1] >= 2
+    p = p.reshape((-1, p.shape[-1]))
+    if axis == -1:
+        xy_range = _nanmax(p) - _nanmin(p)
+        axis = (1 if xy_range[1] > xy_range[0] else 0)
+    points = p[:, axis]
+    spi = np.argsort(points)
+    return p[spi], axis
+
+
+@njit
+def _nanmax(array):  # pragma: no cover
+    """Numba implementation of np.nanmax with axis = 0."""
+    len0 = array.shape[1]
+    max_array = np.empty(len0)
+    for col in range(len0):
+        col_array = array[:, col]
+        max_val = col_array[0]
+        for val in col_array:
+            if val > max_val and not np.isnan(val):
+                max_val = val
+        max_array[col] = max_val
+    return max_array
+
+
+@njit
+def _nanmin(array):  # pragma: no cover
+    """Numba implementation of np.nanmin with axis = 0."""
+    len0 = array.shape[1]
+    min_array = np.empty(len0)
+    for col in range(len0):
+        col_array = array[:, col]
+        min_val = col_array[0]
+        for val in col_array:
+            if val < min_val and not np.isnan(val):
+                min_val = val
+        min_array[col] = min_val
+    return min_array
+
+
 def _projected_xyz_axes(projection):
     assert projection in ['xy', 'xz', 'yz'], f'invalid projection {projection}'
     a0 = 'xyz'.index(projection[0])

resqpy/olio/wellspec_keywords.py

@@ -382,6 +382,7 @@ def get_well_pointers(
             words = line.split()
             assert len(words) >= 2, "Missing date after TIME keyword."
             date = words[1]
+            date_obj = None
             if '(' in date:
                 # sometimes user specifies (HH:MM:SS) along with date - can separate time from date with this check
                 date = date.split('(')[0]
@@ -390,13 +391,13 @@ def get_well_pointers(
                     date_obj = datetime.datetime.strptime(date, "%m/%d/%Y").date()
                 else:
                     date_obj = datetime.datetime.strptime(date, "%d/%m/%Y").date()
-                if no_date_replacement is not None and date_obj < no_date_replacement:
-                    raise ValueError(
-                        f"The Zero Date {no_date_replacement} must be before the first wellspec TIME {date_obj}.")
-                date = date_obj.isoformat()
             except ValueError:
                 raise ValueError(f"The date found '{date}' does not match the correct format (usa_date_format "
                                  f"is {usa_date_format}).")
+            if no_date_replacement is not None and date_obj < no_date_replacement:
+                raise ValueError(
+                    f"The Zero Date {no_date_replacement} must be before the first wellspec TIME {date_obj}.")
+            date = date_obj.isoformat()
             time_pointers[file.tell()] = date
 
     current_date = None  # Before first TIME