LoopStructural 1.6.1__py3-none-any.whl → 1.6.6__py3-none-any.whl

LoopStructural/modelling/input/process_data.py

@@ -165,8 +165,19 @@ class ProcessInputData:
             unit_id = 1
             val = self._stratigraphic_value()
             for name, sg in self._stratigraphic_order:
+                # set the oldest unit to be the basement.
+                # this has no observed basal contact and then
+                # top of the unit is the 0 isovalue.
+                # this is the minimum of the next unit
                 stratigraphic_column[name] = {}
-                for i, g in enumerate(reversed(sg)):
+                stratigraphic_column[name][sg[-1]] = {
+                    "max": 0,
+                    "min": -np.inf,
+                    "id": unit_id,
+                    "colour": self.colours[sg[-1]],
+                }
+                # iterate through the remaining units (in reverse)
+                for g in reversed(sg[:-1]):
                     if g in self.thicknesses:
                         stratigraphic_column[name][g] = {
                             "max": val[g] + self.thicknesses[g],
@@ -174,10 +185,6 @@ class ProcessInputData:
                             "id": unit_id,
                             "colour": self.colours[g],
                         }
-                        if i == 0:
-                            stratigraphic_column[name][g]["min"] = 0
-                        if i == len(sg) - 1:
-                            stratigraphic_column[name][g]["max"] = np.inf
 
                     unit_id += 1
             # add faults into the column
@@ -438,9 +445,22 @@ class ProcessInputData:
         stratigraphic_value = {}
         for _name, sg in self.stratigraphic_order:
             value = 0.0  # reset for each supergroup
-            for g in reversed(sg):
+            if sg[0] not in self.thicknesses or self.thicknesses[sg[0]] <= 0:
+                self.thicknesses[sg[0]] = (
+                    np.inf
+                )  # make the top unit infinite as it should extend to the top of the model
+            for g in reversed(
+                sg[:-1]
+            ):  # don't add the last unit as we never see the base of this unit.
+                # It should be "basement"
                 if g not in self.thicknesses:
                     logger.warning(f"No thicknesses for {g}")
+                    stratigraphic_value[g] = np.nan
+                if self.thicknesses[g] <= 0:
+                    logger.error(
+                        f"Thickness for {g} is less than or equal to 0\n Update the thickness value for {g} before continuing"
+                    )
+
                     stratigraphic_value[g] = np.nan
                 else:
                     stratigraphic_value[g] = value
@@ -463,30 +483,13 @@ class ProcessInputData:
 
     @property
     def contacts(self):
-        return self._contacts
-
-    @contacts.setter
-    def contacts(self, contacts):
-        """Function to convert input contact to loopstructural input
-
-        either uses the thickness values or assigns unique ids given
-        the units named in stratigraphic order
-
-        Returns
-        -------
-        DataFrame
-            data frame with x,y,y,val/interface,feature_name
-        """
-        if contacts is None:
-            return
-        contacts = contacts.copy()
-        self._update_feature_names(contacts)
+        contacts = self._contacts.copy()
         if self._use_thickness:
             contacts["val"] = np.nan
             for k, v in self._stratigraphic_value().items():
                 contacts.loc[contacts["name"] == k, "val"] = v
 
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["val"]), ["X", "Y", "Z", "feature_name", "val"]
             ]
         if not self._use_thickness:
@@ -494,10 +497,28 @@ class ProcessInputData:
             interface_val = 0
             for k in self._stratigraphic_value().keys():
                 contacts.loc[contacts["name"] == k, "interface"] = interface_val
-            self._contacts = contacts.loc[
+            contacts = contacts.loc[
                 ~np.isnan(contacts["interface"]),
                 ["X", "Y", "Z", "feature_name", "interface"],
             ]
+        return contacts
+
+    @contacts.setter
+    def contacts(self, contacts):
+        """Function to convert input contact to loopstructural input
+
+        either uses the thickness values or assigns unique ids given
+        the units named in stratigraphic order
+
+        Returns
+        -------
+        DataFrame
+            data frame with x,y,y,val/interface,feature_name
+        """
+        if contacts is None:
+            return
+        self._contacts = contacts.copy()
+        self._update_feature_names(self._contacts)
 
     @property
     def contact_orientations(self):

LoopStructural/modelling/input/project_file.py

@@ -22,7 +22,8 @@ class LoopProjectfileProcessor(ProcessInputData):
         orientations = self.projectfile.stratigraphyOrientations
         fault_orientations = self.projectfile.faultOrientations
         fault_locations = self.projectfile.faultLocations
-
+        fault_relationships = self.projectfile["eventRelationships"]
+        faultLog = self.projectfile.faultLog.set_index("eventId")
         orientations.rename(columns=column_map, inplace=True)
         contacts.rename(columns=column_map, inplace=True)
         fault_locations.rename(columns=column_map, inplace=True)
@@ -33,24 +34,48 @@ class LoopProjectfileProcessor(ProcessInputData):
                 projectfile["stratigraphicLog"].ThicknessMedian,
             )
         )
-        fault_properties = self.projectfile.faultLog
-        fault_properties.rename(
-            columns={
-                "avgDisplacement": "displacement",
-                "influenceDistance": "minor_axis",
-                "verticalRadius": "intermediate_axis",
-                "horizontalRadius": "major_axis",
-                "name": "fault_name",
-            },
-            inplace=True,
-        )
-        fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_locations, on="eventId"
-        )
-        fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
-            fault_orientations, on="eventId"
-        )
-        fault_properties.set_index("fault_name", inplace=True)
+        fault_properties = None
+        fault_edges = None
+        fault_edge_properties = None
+        if self.projectfile.faultLog.shape[0] > 0:
+
+            fault_properties = self.projectfile.faultLog
+            fault_properties.rename(
+                columns={
+                    "avgDisplacement": "displacement",
+                    "influenceDistance": "minor_axis",
+                    "verticalRadius": "intermediate_axis",
+                    "horizontalRadius": "major_axis",
+                    "name": "fault_name",
+                },
+                inplace=True,
+            )
+            fault_locations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_locations, on="eventId"
+            )
+            fault_orientations = fault_properties.reset_index()[["fault_name", "eventId"]].merge(
+                fault_orientations, on="eventId"
+            )
+            fault_properties.set_index("fault_name", inplace=True)
+            for i in fault_relationships.index:
+                fault_relationships.loc[i, "Fault1"] = faultLog.loc[
+                    fault_relationships.loc[i, "eventId1"], "name"
+                ]
+                fault_relationships.loc[i, "Fault2"] = faultLog.loc[
+                    fault_relationships.loc[i, "eventId2"], "name"
+                ]
+            fault_edges = []
+            fault_edge_properties = []
+            for i in fault_relationships.index:
+                fault_edges.append(
+                    (fault_relationships.loc[i, "Fault1"], fault_relationships.loc[i, "Fault2"])
+                )
+                fault_edge_properties.append(
+                    {
+                        "type": fault_relationships.loc[i, "type"],
+                        "angle": fault_relationships.loc[i, "angle"],
+                    }
+                )
         colours = dict(
             zip(
                 self.projectfile.stratigraphicLog.name,
@@ -63,6 +88,7 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ],
             )
         )
+
         super().__init__(
             contacts=contacts,
             contact_orientations=orientations,
@@ -70,15 +96,15 @@ class LoopProjectfileProcessor(ProcessInputData):
                 ("sg", list(self.projectfile.stratigraphicLog.name))
             ],  # needs to be updated,
             thicknesses=thicknesses,
-            fault_orientations=fault_orientations,
-            fault_locations=fault_locations,
+            fault_orientations=fault_orientations if fault_orientations.shape[0] > 0 else None,
+            fault_locations=fault_locations if fault_locations.shape[0] > 0 else None,
             fault_properties=fault_properties,
-            fault_edges=[],  # list(fault_graph.edges),
+            fault_edges=fault_edges,  # list(fault_graph.edges),
             colours=colours,
             fault_stratigraphy=None,
             intrusions=None,
             use_thickness=use_thickness,
             origin=self.projectfile.origin,
             maximum=self.projectfile.maximum,
-            #                     fault_edge_properties=fault_edge_properties
+            fault_edge_properties=fault_edge_properties,
         )

LoopStructural/modelling/intrusions/intrusion_feature.py

@@ -408,3 +408,6 @@ class IntrusionFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         pass
+
+    def copy(self):
+        pass

LoopStructural/utils/__init__.py

@@ -36,3 +36,4 @@ import numpy as np
 rng = np.random.default_rng()
 
 from ._surface import LoopIsosurfacer, surface_list
+from .colours import random_colour, random_hex_colour

LoopStructural/utils/_surface.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import Optional, Union, Callable, List
+from collections.abc import Iterable
 import numpy as np
 import numpy.typing as npt
 from LoopStructural.utils.logging import getLogger
@@ -15,7 +16,7 @@ except ImportError:
 # from LoopStructural.interpolators._geological_interpolator import GeologicalInterpolator
 from LoopStructural.datatypes import Surface, BoundingBox
 
-surface_list = dict[str, Surface]
+surface_list = List[Surface]
 
 
 class LoopIsosurfacer:
@@ -62,6 +63,7 @@ class LoopIsosurfacer:
         self,
         values: Optional[Union[list, int, float]],
         name: Optional[Union[List[str], str]] = None,
+        local=False
     ) -> surface_list:
         """Extract isosurfaces from the interpolator
 
@@ -72,6 +74,10 @@ class LoopIsosurfacer:
             to extract a single isosurface for, or an integer to extract that many
             isosurfaces evenly spaced between the minimum and maximum values of the
             interpolator.
+        name : Optional[Union[List[str], str]], optional
+            name of the isosurface, by default None
+        local : bool, optional
+            whether to use the local regular grid for the bounding box or global
 
         Returns
         -------
@@ -83,22 +89,28 @@ class LoopIsosurfacer:
             raise ValueError("No interpolator of callable function set")
 
         surfaces = []
-        all_values = self.callable(self.bounding_box.regular_grid(local=False))
+        all_values = self.callable(self.bounding_box.regular_grid(local=local))
         ## set value to mean value if its not specified
         if values is None:
-            values = [(np.nanmax(all_values) - np.nanmin(all_values)) / 2]
-        if isinstance(values, list):
+            values = [((np.nanmax(all_values) - np.nanmin(all_values)) / 2) + np.nanmin(all_values)]
+        if isinstance(values, Iterable):
             isovalues = values
         elif isinstance(values, float):
             isovalues = [values]
+        if isinstance(values, int) and values == 0:
+            values = 0.0  # assume 0 isosurface is meant to be a float
+
         elif isinstance(values, int) and values < 1:
             raise ValueError(
                 "Number of isosurfaces must be greater than 1. Either use a positive integer or provide a list or float for a specific isovalue."
             )
         elif isinstance(values, int):
+            var = np.nanmax(all_values) - np.nanmin(all_values)
+            # buffer slices by 5% to make sure that we don't get isosurface does't exist issues
+            buffer = var * 0.05
             isovalues = np.linspace(
-                np.nanmin(all_values) + np.finfo(float).eps,
-                np.nanmax(all_values) - np.finfo(float).eps,
+                np.nanmin(all_values) + buffer,
+                np.nanmax(all_values) - buffer,
                 values,
             )
         logger.info(f'Isosurfacing at values: {isovalues}')

LoopStructural/utils/_transformation.py

@@ -1,9 +1,13 @@
 import numpy as np
-from sklearn import decomposition
+from . import getLogger
+
+logger = getLogger(__name__)
 
 
 class EuclideanTransformation:
-    def __init__(self, dimensions=2):
+    def __init__(
+        self, dimensions: int = 2, angle: float = 0, translation: np.ndarray = np.zeros(3)
+    ):
         """Transforms points into a new coordinate
         system where the main eigenvector is aligned with x
 
@@ -11,11 +15,14 @@ class EuclideanTransformation:
         ----------
         dimensions : int, optional
             Do transformation in map view or on 3d volume, by default 2
+        angle : float, optional
+            Angle to rotate the points by, by default 0
+        translation : np.ndarray, default zeros
+            Translation to apply to the points, by default
         """
-        self.rotation = None
-        self.translation = None
+        self.translation = translation[:dimensions]
         self.dimensions = dimensions
-        self.angle = 0
+        self.angle = angle
 
     def fit(self, points: np.ndarray):
         """Fit the transformation to a point cloud
@@ -28,10 +35,16 @@ class EuclideanTransformation:
         points : np.ndarray
             xyz points as as numpy array
         """
+        try:
+            from sklearn import decomposition
+        except ImportError:
+            logger.error('scikit-learn is required for this function')
+            return
         points = np.array(points)
         if points.shape[1] < self.dimensions:
             raise ValueError("Points must have at least {} dimensions".format(self.dimensions))
         # standardise the points so that centre is 0
+        # self.translation = np.zeros(3)
         self.translation = np.mean(points, axis=0)
         # find main eigenvector and and calculate the angle of this with x
         pca = decomposition.PCA(n_components=self.dimensions).fit(
@@ -39,38 +52,109 @@ class EuclideanTransformation:
         )
         coeffs = pca.components_
         self.angle = -np.arccos(np.dot(coeffs[0, :], [1, 0]))
-        self.rotation = self._rotation(self.angle)
+        return self
+
+    @property
+    def rotation(self):
+        return self._rotation(self.angle)
+
+    @property
+    def inverse_rotation(self):
+        return self._rotation(-self.angle)
 
     def _rotation(self, angle):
         return np.array(
             [
                 [np.cos(angle), -np.sin(angle), 0],
                 [np.sin(angle), np.cos(angle), 0],
-                [0, 0, 1],
+                [0, 0, -1],
             ]
         )
 
     def fit_transform(self, points: np.ndarray) -> np.ndarray:
+        """Fit the transformation and transform the points"""
+
         self.fit(points)
         return self.transform(points)
 
     def transform(self, points: np.ndarray) -> np.ndarray:
-        """_summary_
+        """Transform points using the transformation and rotation
 
         Parameters
         ----------
-        points : _type_
-            _description_
+        points : np.ndarray
+            xyz points as as numpy array
 
         Returns
         -------
-        _type_
-            _description_
+        np.ndarray
+            xyz points in the transformed coordinate system
         """
-        return np.dot(points - self.translation, self.rotation)
+        points = np.array(points)
+        if points.shape[1] < self.dimensions:
+            raise ValueError("Points must have at least {} dimensions".format(self.dimensions))
+        centred = points - self.translation
+
+        return np.einsum(
+            'ik,jk->ij',
+            centred,
+            self.rotation[: self.dimensions, : self.dimensions],
+        )
 
     def inverse_transform(self, points: np.ndarray) -> np.ndarray:
-        return np.dot(points, self._rotation(-self.angle)) + self.translation
+        """
+        Transform points back to the original coordinate system
+
+        Parameters
+        ----------
+        points : np.ndarray
+            xyz points as as numpy array
+
+        Returns
+        -------
+        np.ndarray
+            xyz points in the original coordinate system
+        """
+
+        return (
+            np.einsum(
+                'ik,jk->ij',
+                points,
+                self.inverse_rotation[: self.dimensions, : self.dimensions],
+            )
+            + self.translation
+        )
 
     def __call__(self, points: np.ndarray) -> np.ndarray:
+        """
+        Transform points into the transformed space
+
+        Parameters
+        ----------
+        points : np.ndarray
+            xyz points as as numpy array
+
+        Returns
+        -------
+        np.ndarray
+            xyz points in the transformed coordinate system
+        """
+
         return self.transform(points)
+
+    def _repr_html_(self):
+        """
+        Provides an HTML representation of the TransRotator.
+        """
+        html_str = """
+        <div class="collapsible">
+          <button class="collapsible-button">{self.__class__.__name__}</button>
+          <div class="content">
+            <p>Translation: {self.translation}</p>
+            <p>Rotation Angle: {self.angle} degrees</p>
+          </div>
+        </div>
+        """.format(
+            self=self
+        )
+        return html_str

LoopStructural/utils/colours.py

@@ -0,0 +1,50 @@
+from LoopStructural.utils import rng
+
+
+def random_colour(n: int = 1, cmap='tab20'):
+    """
+    Generate a list of random colours
+
+    Parameters
+    ----------
+    n : int
+        Number of colours to generate
+    cmap : str, optional
+        Name of the matplotlib colour map to use, by default 'tab20'
+
+    Returns
+    -------
+    list
+        List of colours in the form of (r,g,b,a) tuples
+    """
+    import matplotlib.cm as cm
+
+    colours = []
+    for _i in range(n):
+        colours.append(cm.get_cmap(cmap)(rng.random()))
+
+    return colours
+
+def random_hex_colour(n: int = 1, cmap='tab20'):
+    """
+    Generate a list of random colours
+
+    Parameters
+    ----------
+    n : int
+        Number of colours to generate
+    cmap : str, optional
+        Name of the matplotlib colour map to use, by default 'tab20'
+
+    Returns
+    -------
+    list
+        List of colours in the form of hex strings
+    """
+    import matplotlib.cm as cm
+
+    colours = []
+    for _i in range(n):
+        colours.append(cm.get_cmap(cmap)(rng.random()))
+
+    return [f'#{int(c[0]*255):02x}{int(c[1]*255):02x}{int(c[2]*255):02x}' for c in colours]

LoopStructural/utils/features.py

@@ -0,0 +1,5 @@
+from ..modelling.features import LambdaGeologicalFeature
+
+X = LambdaGeologicalFeature(lambda pos: pos[:, 0], name="x")
+Y = LambdaGeologicalFeature(lambda pos: pos[:, 1], name="y")
+Z = LambdaGeologicalFeature(lambda pos: pos[:, 2], name="z")

LoopStructural/utils/maths.py

@@ -1,6 +1,7 @@
 from LoopStructural.utils.typing import NumericInput
 import numpy as np
 import numbers
+from typing import Tuple
 
 
 def strikedip2vector(strike: NumericInput, dip: NumericInput) -> np.ndarray:
@@ -177,7 +178,7 @@ def rotate(vector: NumericInput, axis: NumericInput, angle: NumericInput) -> np.
     # return vector
 
 
-def get_vectors(normal: NumericInput) -> tuple[np.ndarray, np.ndarray]:
+def get_vectors(normal: NumericInput) -> Tuple[np.ndarray, np.ndarray]:
     """Find strike and dip vectors for a normal vector.
     Makes assumption the strike vector is horizontal component and the dip is vertical.
     Found by calculating strike and and dip angle and then finding the appropriate vectors
@@ -243,3 +244,54 @@ def get_dip_vector(strike, dip):
         ]
     )
     return v
+
+
+def regular_tetraherdron_for_points(xyz, scale_parameter):
+    regular_tetrahedron = np.array(
+        [
+            [np.sqrt(8 / 9), 0, -1 / 3],
+            [-np.sqrt(2 / 9), np.sqrt(2 / 3), -1 / 3],
+            [-np.sqrt(2 / 9), -np.sqrt(2 / 3), -1 / 3],
+            [0, 0, 1],
+        ]
+    )
+    regular_tetrahedron *= scale_parameter
+    tetrahedron = np.zeros((xyz.shape[0], 4, 3))
+    tetrahedron[:] = xyz[:, None, :]
+    tetrahedron[:, :, :] += regular_tetrahedron[None, :, :]
+
+    return tetrahedron
+
+
+def gradient_from_tetrahedron(tetrahedron, value):
+    """
+    Calculate the gradient from a tetrahedron
+    """
+    tetrahedron = tetrahedron.reshape(-1, 4, 3)
+    m = np.array(
+        [
+            [
+                (tetrahedron[:, 1, 0] - tetrahedron[:, 0, 0]),
+                (tetrahedron[:, 1, 1] - tetrahedron[:, 0, 1]),
+                (tetrahedron[:, 1, 2] - tetrahedron[:, 0, 2]),
+            ],
+            [
+                (tetrahedron[:, 2, 0] - tetrahedron[:, 0, 0]),
+                (tetrahedron[:, 2, 1] - tetrahedron[:, 0, 1]),
+                (tetrahedron[:, 2, 2] - tetrahedron[:, 0, 2]),
+            ],
+            [
+                (tetrahedron[:, 3, 0] - tetrahedron[:, 0, 0]),
+                (tetrahedron[:, 3, 1] - tetrahedron[:, 0, 1]),
+                (tetrahedron[:, 3, 2] - tetrahedron[:, 0, 2]),
+            ],
+        ]
+    )
+    I = np.array([[-1.0, 1.0, 0.0, 0.0], [-1.0, 0.0, 1.0, 0.0], [-1.0, 0.0, 0.0, 1.0]])
+    m = np.swapaxes(m, 0, 2)
+    element_gradients = np.linalg.inv(m)
+
+    element_gradients = element_gradients.swapaxes(1, 2)
+    element_gradients = element_gradients @ I
+    v = np.sum(element_gradients * value[:, None, :], axis=2)
+    return v

LoopStructural/version.py

@@ -1 +1 @@
-__version__ = "1.6.1"
+__version__ = "1.6.6"