LoopStructural 1.6.5__py3-none-any.whl → 1.6.7__py3-none-any.whl

LoopStructural/modelling/core/geological_model.py

@@ -1182,7 +1182,7 @@ class GeologicalModel:
                 logger.debug(f"Reached unconformity {f.name}")
                 break
             logger.debug(f"Adding {uc_feature.name} as unconformity to {f.name}")
-            if f.type == FeatureType.FAULT:
+            if f.type == FeatureType.FAULT or f.type == FeatureType.INACTIVEFAULT:
                 continue
             if f == feature:
                 continue
@@ -1417,7 +1417,7 @@ class GeologicalModel:
         return fault
 
     # TODO move rescale to bounding box/transformer
-    def rescale(self, points: np.ndarray, inplace: bool = True) -> np.ndarray:
+    def rescale(self, points: np.ndarray, inplace: bool = False) -> np.ndarray:
         """
         Convert from model scale to real world scale - in the future this
         should also do transformations?
@@ -1440,7 +1440,7 @@ class GeologicalModel:
         return points
 
     # TODO move scale to bounding box/transformer
-    def scale(self, points: np.ndarray, inplace: bool = True) -> np.ndarray:
+    def scale(self, points: np.ndarray, inplace: bool = False) -> np.ndarray:
         """Take points in UTM coordinates and reproject
         into scaled model space
 
@@ -1824,6 +1824,7 @@ class GeologicalModel:
     ):
         path = pathlib.Path(filename)
         extension = path.suffix
+        parent = path.parent
         name = path.stem
         stratigraphic_surfaces = self.get_stratigraphic_surfaces()
         if fault_surfaces:
@@ -1832,19 +1833,19 @@ class GeologicalModel:
                 if extension == ".geoh5" or extension == '.omf':
                     s.save(filename)
                 else:
-                    s.save(f'{name}_{s.name}.{extension}')
+                    s.save(f'{parent}/{name}_{s.name}{extension}')
         if stratigraphic_surfaces:
             for s in self.get_stratigraphic_surfaces():
                 if extension == ".geoh5" or extension == '.omf':
                     s.save(filename)
                 else:
-                    s.save(f'{name}_{s.name}.{extension}')
+                    s.save(f'{parent}/{name}_{s.name}{extension}')
         if block_model:
             grid, ids = self.get_block_model()
             if extension == ".geoh5" or extension == '.omf':
                 grid.save(filename)
             else:
-                grid.save(f'{name}_block_model.{extension}')
+                grid.save(f'{parent}/{name}_block_model{extension}')
         if stratigraphic_data:
             if self.stratigraphic_column is not None:
                 for group in self.stratigraphic_column.keys():
@@ -1854,7 +1855,7 @@ class GeologicalModel:
                         if extension == ".geoh5" or extension == '.omf':
                             data.save(filename)
                         else:
-                            data.save(f'{name}_{group}_data.{extension}')
+                            data.save(f'{parent}/{name}_{group}_data{extension}')
         if fault_data:
             for f in self.fault_names():
                 for d in self.__getitem__(f).get_data():
@@ -1862,4 +1863,4 @@ class GeologicalModel:
 
                         d.save(filename)
                     else:
-                        d.save(f'{name}_{group}.{extension}')
+                        d.save(f'{parent}/{name}_{group}{extension}')

LoopStructural/modelling/features/__init__.py

@@ -30,3 +30,4 @@ from ._cross_product_geological_feature import CrossProductGeologicalFeature
 
 from ._unconformity_feature import UnconformityFeature
 from ._analytical_feature import AnalyticalGeologicalFeature
+from ._projected_vector_feature import ProjectedVectorFeature

LoopStructural/modelling/features/_analytical_feature.py

@@ -39,8 +39,16 @@ class AnalyticalGeologicalFeature(BaseFeature):
         builder=None,
     ):
         BaseFeature.__init__(self, name, model, faults, regions, builder)
-        self.vector = np.array(vector, dtype=float)
-        self.origin = np.array(origin, dtype=float)
+        try:
+            self.vector = np.array(vector, dtype=float).reshape(3)
+        except ValueError:
+            logger.error("AnalyticalGeologicalFeature: vector must be a 3 element array")
+            raise ValueError("vector must be a 3 element array")
+        try:
+            self.origin = np.array(origin, dtype=float).reshape(3)
+        except ValueError:
+            logger.error("AnalyticalGeologicalFeature: origin must be a 3 element array")
+            raise ValueError("origin must be a 3 element array")
         self.type = FeatureType.ANALYTICAL
 
     def to_json(self):
@@ -86,3 +94,16 @@ class AnalyticalGeologicalFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         return
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = self.name
+        return AnalyticalGeologicalFeature(
+            name,
+            self.vector.copy(),
+            self.origin.copy(),
+            list(self.regions),
+            list(self.faults),
+            self.model,
+            self.builder,
+        )

LoopStructural/modelling/features/_base_geological_feature.py

@@ -296,7 +296,12 @@ class BaseFeature(metaclass=ABCMeta):
             self.regions = [
                 r for r in self.regions if r.name != self.name and r.parent.name != self.name
             ]
-            callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
+
+            callable = lambda xyz: (
+                self.evaluate_value(self.model.scale(xyz))
+                if self.model is not None
+                else self.evaluate_value(xyz)
+            )
             isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
             if name is None and self.name is not None:
                 name = self.name
@@ -375,3 +380,14 @@ class BaseFeature(metaclass=ABCMeta):
             dictionary of data
         """
         raise NotImplementedError
+
+    @abstractmethod
+    def copy(self, name: Optional[str] = None):
+        """Copy the feature
+
+        Returns
+        -------
+        BaseFeature
+            copied feature
+        """
+        raise NotImplementedError

LoopStructural/modelling/features/_cross_product_geological_feature.py

@@ -98,3 +98,10 @@ class CrossProductGeologicalFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         return
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = f'{self.name}_copy'
+        return CrossProductGeologicalFeature(
+            name, self.geological_feature_a, self.geological_feature_b
+        )

LoopStructural/modelling/features/_geological_feature.py

@@ -113,7 +113,9 @@ class GeologicalFeature(BaseFeature):
         # if evaluation_points is not a numpy array try and convert
         # otherwise error
         evaluation_points = np.asarray(pos)
-        self.builder.up_to_date()
+        # if there is a builder lets make sure that the feature is up to date
+        if self.builder is not None:
+            self.builder.up_to_date()
         # check if the points are within the display region
         v = np.zeros(evaluation_points.shape[0])
         v[:] = np.nan

LoopStructural/modelling/features/_projected_vector_feature.py

@@ -0,0 +1,112 @@
+"""
+"""
+
+import numpy as np
+from typing import Optional
+
+from ...modelling.features import BaseFeature
+
+from ...utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class ProjectedVectorFeature(BaseFeature):
+    def __init__(
+        self,
+        name: str,
+        vector: np.ndarray,
+        plane_feature: BaseFeature,
+    ):
+        """
+
+        Create a geological feature by projecting a vector onto a feature representing a plane
+        E.g. project a thickness vector onto an axial surface
+
+        Parameters
+        ----------
+        name: feature name
+        vector: the vector to project
+        plane_feature: the plane
+
+
+        Parameters
+        ----------
+        name : str
+            name of the feature
+        geological_feature_a : BaseFeature
+            Left hand side of cross product
+        geological_feature_b : BaseFeature
+            Right hand side of cross product
+        """
+        super().__init__(name)
+        self.plane_feature = plane_feature
+        self.vector = vector
+
+        self.value_feature = None
+
+    def evaluate_gradient(self, locations: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """
+        Calculate the gradient of the geological feature by using numpy to
+        calculate the cross
+        product between the two existing feature gradients.
+        This means both features have to be evaluated for the locations
+
+        Parameters
+        ----------
+        locations
+
+        Returns
+        -------
+
+        """
+
+        # project s0 onto axis plane B X A X B
+        plane_normal = self.plane_feature.evaluate_gradient(locations, ignore_regions)
+        vector = np.tile(self.vector, (locations.shape[0], 1))
+
+        projected_vector = np.cross(
+            plane_normal, np.cross(vector, plane_normal, axisa=1, axisb=1), axisa=1, axisb=1
+        )
+        return projected_vector
+
+    def evaluate_value(self, evaluation_points: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """
+        Return 0 because there is no value for this feature
+        Parameters
+        ----------
+        evaluation_points
+
+        Returns
+        -------
+
+        """
+        values = np.zeros(evaluation_points.shape[0])
+        if self.value_feature is not None:
+            values[:] = self.value_feature.evaluate_value(evaluation_points, ignore_regions)
+        return values
+
+    def mean(self):
+        if self.value_feature:
+            return self.value_feature.mean()
+        return 0.0
+
+    def min(self):
+        if self.value_feature:
+            return self.value_feature.min()
+        return 0.0
+
+    def max(self):
+        if self.value_feature:
+            return self.value_feature.max()
+        return 0.0
+
+    def get_data(self, value_map: Optional[dict] = None):
+        return
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = f'{self.name}_copy'
+        return ProjectedVectorFeature(
+            name=name, vector=self.vector, plane_feature=self.plane_feature
+        )

LoopStructural/modelling/features/_structural_frame.py

@@ -176,3 +176,9 @@ class StructuralFrame(BaseFeature):
         for f in self.features:
             data.extend(f.get_data(value_map))
         return data
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = f'{self.name}_copy'
+        # !TODO check if this needs to be a deep copy
+        return StructuralFrame(name, self.features, self.fold, self.model)

LoopStructural/modelling/features/builders/_folded_feature_builder.py

@@ -89,7 +89,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             fold_axis_rotation = get_fold_rotation_profile(self.axis_profile_type, far, fad)
             if "axis_function" in kwargs:
                 # allow predefined function to be used
-                fold_axis_rotation.set_function(kwargs["axis_function"])
+                logger.error("axis_function is deprecated, use a specific fold rotation angle profile type")
             else:
                 fold_axis_rotation.fit(params={'wavelength': kwargs.get("axis_wl", None)})
             self.fold.fold_axis_rotation = fold_axis_rotation
@@ -107,7 +107,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         fold_limb_rotation = get_fold_rotation_profile(self.limb_profile_type, flr, fld)
         if "limb_function" in kwargs:
             # allow for predefined functions to be used
-            fold_limb_rotation.set_function(kwargs["limb_function"])
+            logger.error("limb_function is deprecated, use a specific fold rotation angle profile type")
         else:
             fold_limb_rotation.fit(params={'wavelength': kwargs.get("limb_wl", None)})
 

LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -110,8 +110,8 @@ class StructuralFrameBuilder:
         )  # ,region=self.region))
 
         self._frame = frame(
-            self.name,
-            [
+            name=self.name,
+            features=[
                 self.builders[0].feature,
                 self.builders[1].feature,
                 self.builders[2].feature,

LoopStructural/modelling/features/fault/_fault_function_feature.py

@@ -80,3 +80,6 @@ class FaultDisplacementFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         pass
+
+    def copy(self, name: Optional[str] = None):
+        raise NotImplementedError("Not implemented yet")

LoopStructural/modelling/features/fault/_fault_segment.py

@@ -22,7 +22,14 @@ class FaultSegment(StructuralFrame):
     """
 
     def __init__(
-        self, features, name, faultfunction=None, steps=10, displacement=1.0, fold=None, model=None
+        self,
+        name: str,
+        features: list,
+        faultfunction=None,
+        steps=10,
+        displacement=1.0,
+        fold=None,
+        model=None,
     ):
         """
         A slip event of a fault
@@ -37,7 +44,7 @@ class FaultSegment(StructuralFrame):
             how many integration steps for faults
         kwargs
         """
-        StructuralFrame.__init__(self, features, name, fold, model)
+        StructuralFrame.__init__(self, name=name, features=features, fold=fold, model=model)
         self.type = FeatureType.FAULT
         self.displacement = displacement
         self._faultfunction = BaseFault().fault_displacement
@@ -261,6 +268,7 @@ class FaultSegment(StructuralFrame):
                 logger.error("nan slicing ")
         # need to scale with fault displacement
         v[mask, :] = self.__getitem__(1).evaluate_gradient(locations[mask, :])
+        v[mask, :] /= np.linalg.norm(v[mask, :], axis=1)[:, None]
         scale = self.displacementfeature.evaluate_value(locations[mask, :])
         v[mask, :] *= scale[:, None]
         return v

LoopStructural/modelling/input/process_data.py

@@ -78,7 +78,7 @@ class ProcessInputData:
         self.contacts = contacts
         self._contact_orientations = None
         self.contact_orientations = contact_orientations
-        self._fault_orientations = None
+        self._fault_orientations = pd.DataFrame(columns=["X", "Y", "Z", "gx", "gy", "gz", "coord", "feature_name"])
         self.fault_orientations = fault_orientations
         self._fault_locations = None
         self.fault_locations = fault_locations
@@ -313,10 +313,11 @@ class ProcessInputData:
                 pts = self.fault_orientations.loc[
                     self.fault_orientations["feature_name"] == fname, ["gx", "gy", "gz"]
                 ]
-                fault_properties.loc[
-                    fname,
-                    ["avgNormalEasting", "avgNormalNorthing", "avgNormalAltitude"],
-                ] = np.nanmean(pts, axis=0)
+                if len(pts)>0:
+                    fault_properties.loc[
+                        fname,
+                        ["avgNormalEasting", "avgNormalNorthing", "avgNormalAltitude"],
+                    ] = np.nanmean(pts, axis=0)
         if (
             "avgSlipDirEasting" not in fault_properties.columns
             or "avgSlipDirNorthing" not in fault_properties.columns
@@ -399,7 +400,7 @@ class ProcessInputData:
             dataframes.append(self.contacts)
         if self.contact_orientations is not None:
             dataframes.append(self.contact_orientations)
-        if self.fault_orientations is not None:
+        if len(self.fault_orientations) > 0:
             dataframes.append(self.fault_orientations)
         if self.fault_locations is not None:
             dataframes.append(self.fault_locations)

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,4 +36,4 @@ import numpy as np
 rng = np.random.default_rng()
 
 from ._surface import LoopIsosurfacer, surface_list
-from .colours import random_colour
+from .colours import random_colour, random_hex_colour

LoopStructural/utils/_surface.py

@@ -63,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
 
@@ -73,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
         -------
@@ -84,7 +89,7 @@ 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) + np.nanmin(all_values)]

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

@@ -17,10 +17,33 @@ def random_colour(n: int = 1, cmap='tab20'):
     list
         List of colours in the form of (r,g,b,a) tuples
     """
-    import matplotlib.cm as cm
-
+    from matplotlib import colormaps 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
+    """
+    from matplotlib import colormaps 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/version.py

@@ -1 +1 @@
-__version__ = "1.6.5"
+__version__ = "1.6.7"