LoopStructural 1.6.1__py3-none-any.whl

LoopStructural/utils/_transformation.py

@@ -0,0 +1,76 @@
+import numpy as np
+from sklearn import decomposition
+
+
+class EuclideanTransformation:
+    def __init__(self, dimensions=2):
+        """Transforms points into a new coordinate
+        system where the main eigenvector is aligned with x
+
+        Parameters
+        ----------
+        dimensions : int, optional
+            Do transformation in map view or on 3d volume, by default 2
+        """
+        self.rotation = None
+        self.translation = None
+        self.dimensions = dimensions
+        self.angle = 0
+
+    def fit(self, points: np.ndarray):
+        """Fit the transformation to a point cloud
+        This function will find the main eigenvector of the point cloud
+        and rotate the point cloud so that this is aligned with x
+
+
+        Parameters
+        ----------
+        points : np.ndarray
+            xyz points as as numpy array
+        """
+        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.mean(points, axis=0)
+        # find main eigenvector and and calculate the angle of this with x
+        pca = decomposition.PCA(n_components=self.dimensions).fit(
+            points[:, : self.dimensions] - self.translation[None, : self.dimensions]
+        )
+        coeffs = pca.components_
+        self.angle = -np.arccos(np.dot(coeffs[0, :], [1, 0]))
+        self.rotation = 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],
+            ]
+        )
+
+    def fit_transform(self, points: np.ndarray) -> np.ndarray:
+        self.fit(points)
+        return self.transform(points)
+
+    def transform(self, points: np.ndarray) -> np.ndarray:
+        """_summary_
+
+        Parameters
+        ----------
+        points : _type_
+            _description_
+
+        Returns
+        -------
+        _type_
+            _description_
+        """
+        return np.dot(points - self.translation, self.rotation)
+
+    def inverse_transform(self, points: np.ndarray) -> np.ndarray:
+        return np.dot(points, self._rotation(-self.angle)) + self.translation
+
+    def __call__(self, points: np.ndarray) -> np.ndarray:
+        return self.transform(points)

LoopStructural/utils/config.py

@@ -0,0 +1,18 @@
+class LoopStructuralConfig:
+    """
+    Class to store configuration settings.
+    """
+
+    __splay_fault_threshold = 30
+    __experimental = False
+    __default_interpolator = "FDI"
+    __default_nelements = 1e4
+    __default_solver = "cg"
+
+    # @property
+    # def experimental():
+    #     return __experimental
+
+    # @experimental.setter
+    # def experimental(self, value):
+    #     __experimental = value

LoopStructural/utils/dtm_creator.py

@@ -0,0 +1,17 @@
+from ctypes import Union
+from pathlib import Path
+
+
+def create_dtm_with_rasterio(dtm_path: Union[str, Path]):
+    try:
+        import rasterio
+    except ImportError:
+        print("rasterio not installed. Please install it and try again.")
+        return
+    try:
+        from map2loop.map import MapUtil
+
+        dtm_map = MapUtil(None, dtm=rasterio.open(dtm_path))
+        return lambda xyz: dtm_map.evaluate_dtm_at_points(xyz[:, :2])
+    except ImportError:
+        print("map2loop not installed. Please install it and try again")

LoopStructural/utils/exceptions.py

@@ -0,0 +1,31 @@
+from ..utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class LoopException(Exception):
+    """
+    Base loop exception
+    """
+
+
+class LoopImportError(LoopException):
+    """ """
+
+    def __init__(self, message, additional_information=None):
+        super().__init__(message)
+        self.additional_information = additional_information
+
+    pass
+
+
+class InterpolatorError(LoopException):
+    pass
+
+
+class LoopTypeError(LoopException):
+    pass
+
+
+class LoopValueError(LoopException):
+    pass

LoopStructural/utils/helper.py

@@ -0,0 +1,292 @@
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import PCA
+
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
+
+
+def get_data_bounding_box_map(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    # find the aligned coordinates box using pca
+    modelpca = PCA(n_components=3)
+    modelpca.fit(xyz)
+    # transform the data to this new coordinate then find extents
+    # transformed_xyz = modelpca.transform(xyz)
+    minx = np.min(xyz[:, 0])
+    maxx = np.max(xyz[:, 0])
+    miny = np.min(xyz[:, 1])
+    maxy = np.max(xyz[:, 1])
+    minz = np.min(xyz[:, 2])
+    maxz = np.max(xyz[:, 2])
+
+    # length = np.max([xlen, ylen, zlen])
+    minx -= buffer
+    maxx += buffer
+
+    miny -= buffer
+    maxy += buffer
+
+    minz -= buffer
+    maxz += buffer
+
+    bb = np.array([[minx, miny, minz], [maxx, maxy, maxz]])
+
+    def region(xyz):
+        b = np.ones(xyz.shape[0]).astype(bool)
+        b = np.logical_and(b, xyz[:, 0] > minx)
+        b = np.logical_and(b, xyz[:, 0] < maxx)
+        b = np.logical_and(b, xyz[:, 1] > miny)
+        b = np.logical_and(b, xyz[:, 1] < maxy)
+
+        return b
+
+    return bb, region
+
+
+def get_data_bounding_box(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    # find the aligned coordinates box using pca
+    modelpca = PCA(n_components=3)
+    modelpca.fit(xyz)
+    # transform the data to this new coordinate then find extents
+    # transformed_xyz = modelpca.transform(xyz)
+    minx = np.min(xyz[:, 0])
+    maxx = np.max(xyz[:, 0])
+    miny = np.min(xyz[:, 1])
+    maxy = np.max(xyz[:, 1])
+    minz = np.min(xyz[:, 2])
+    maxz = np.max(xyz[:, 2])
+
+    xlen = maxx - minx
+    ylen = maxy - miny
+    zlen = maxz - minz
+    length = np.max([xlen, ylen, zlen])
+    minx -= length * buffer
+    maxx += length * buffer
+
+    miny -= length * buffer
+    maxy += length * buffer
+
+    minz -= length * buffer
+    maxz += length * buffer
+
+    bb = np.array([[minx, miny, minz], [maxx, maxy, maxz]])
+
+    def region(xyz):
+        b = np.ones(xyz.shape[0]).astype(bool)
+        b = np.logical_and(b, xyz[:, 0] > minx)
+        b = np.logical_and(b, xyz[:, 0] < maxx)
+        b = np.logical_and(b, xyz[:, 1] > miny)
+        b = np.logical_and(b, xyz[:, 1] < maxy)
+        b = np.logical_and(b, xyz[:, 2] > minz)
+        b = np.logical_and(b, xyz[:, 2] < maxz)
+        return b
+
+    return bb, region
+
+
+# def azimuthplunge2vector(
+#     plunge: Union[np.ndarray, list], plunge_dir: Union[np.ndarray, list]
+# ) -> np.ndarray:
+#     """Convert plunge and plunge direction to a vector
+
+#     Parameters
+#     ----------
+#     plunge : Union[np.ndarray, list]
+#         array or array like of plunge values
+#     plunge_dir : Union[np.ndarray, list]
+#         array or array like of plunge direction values
+
+#     Returns
+#     -------
+#     np.array
+#         nx3 vector
+#     """
+#     plunge = np.deg2rad(plunge)
+#     plunge_dir = np.deg2rad(plunge_dir)
+#     vec = np.zeros(3)
+#     vec[0] = np.sin(plunge_dir) * np.cos(plunge)
+#     vec[1] = np.cos(plunge_dir) * np.cos(plunge)
+#     vec[2] = -np.sin(plunge)
+#     return vec
+
+
+def create_surface(bounding_box, nstep):
+    x = np.linspace(bounding_box[0, 0], bounding_box[1, 0], nstep[0])  #
+    y = np.linspace(bounding_box[0, 1], bounding_box[1, 1], nstep[1])
+    xx, yy = np.meshgrid(x, y, indexing="xy")
+
+    def gi(i, j):
+        return i + j * nstep[0]
+
+    corners = np.array([[0, 1, 0, 1], [0, 0, 1, 1]])
+    i = np.arange(0, nstep[0] - 1)
+
+    j = np.arange(0, nstep[1] - 1)
+    ii, jj = np.meshgrid(i, j, indexing="ij")
+    corner_gi = gi(
+        ii[:, :, None]
+        + corners[
+            None,
+            None,
+            0,
+            :,
+        ],
+        jj[:, :, None]
+        + corners[
+            None,
+            None,
+            1,
+            :,
+        ],
+    )
+    corner_gi = corner_gi.reshape((nstep[0] - 1) * (nstep[1] - 1), 4)
+    tri = np.vstack([corner_gi[:, :3], corner_gi[:, 1:]])
+    return tri, xx.flatten(), yy.flatten()
+
+
+def create_box(bounding_box, nsteps):
+    from LoopStructural.datatypes import BoundingBox
+
+    if isinstance(bounding_box, BoundingBox):
+        bounding_box = bounding_box.bb
+
+    tri, xx, yy = create_surface(bounding_box[0:2, :], nsteps[0:2])
+
+    zz = np.zeros(xx.shape)
+    zz[:] = bounding_box[1, 2]
+
+    tri = np.vstack([tri, tri + np.max(tri) + 1])
+    xx = np.hstack([xx, xx])
+    yy = np.hstack([yy, yy])
+
+    z = np.zeros(zz.shape)
+    z[:] = bounding_box[0, 2]
+    zz = np.hstack([zz, z])
+    # y faces
+    t, x, z = create_surface(bounding_box[:, [0, 2]], nsteps[[0, 2]])
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+
+    y = np.zeros(x.shape)
+    y[:] = bounding_box[0, 1]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    y[:] = bounding_box[1, 1]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    # x faces
+    t, y, z = create_surface(bounding_box[:, [1, 2]], nsteps[[1, 2]])
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    x = np.zeros(y.shape)
+    x[:] = bounding_box[0, 0]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    tri = np.vstack([tri, t + np.max(tri) + 1])
+    x[:] = bounding_box[1, 0]
+    xx = np.hstack([xx, x])
+    zz = np.hstack([zz, z])
+    yy = np.hstack([yy, y])
+
+    points = np.zeros((len(xx), 3))  #
+    points[:, 0] = xx
+    points[:, 1] = yy
+    points[:, 2] = zz
+    return points, tri
+
+
+def xyz_names():
+    return ["X", "Y", "Z"]
+
+
+def normal_vec_names():
+    return ["nx", "ny", "nz"]
+
+
+def tangent_vec_names():
+    return ["tx", "ty", "tz"]
+
+
+def gradient_vec_names():
+    return ["gx", "gy", "gz"]
+
+
+def weight_name():
+    return ["w"]
+
+
+def val_name():
+    return ["val"]
+
+
+def coord_name():
+    return ["coord"]
+
+
+def interface_name():
+    return ["interface"]
+
+
+def inequality_name():
+    return ["l", "u"]
+
+
+def feature_name():
+    return ["feature_name"]
+
+
+def polarity_name():
+    return ["polarity"]
+
+
+def pairs_name():
+    return ["pair_id"]
+
+
+def all_heading():
+    return (
+        xyz_names()
+        + normal_vec_names()
+        + tangent_vec_names()
+        + gradient_vec_names()
+        + weight_name()
+        + val_name()
+        + coord_name()
+        + feature_name()
+        + interface_name()
+        + polarity_name()
+        + inequality_name()
+        + pairs_name()
+    )
+
+
+def empty_dataframe():
+    return pd.DataFrame(columns=[all_heading()])

LoopStructural/utils/json_encoder.py

@@ -0,0 +1,18 @@
+import json
+
+
+class LoopJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        """All jsonable loop objects should have a tojson method
+
+        Parameters
+        ----------
+        obj : LoopStructuralObject
+            An object from loopstructural
+
+        Returns
+        -------
+        str
+            string representing the json encoding
+        """
+        return obj.__tojson__()

LoopStructural/utils/linalg.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+
+def normalise(v):
+    v = np.array(v)
+
+    np.linalg.norm(v, axis=1)
+    return v / np.linalg.norm(v)

LoopStructural/utils/logging.py

@@ -0,0 +1,79 @@
+import logging
+import LoopStructural
+import os
+
+
+def get_levels():
+    """dict for converting to logger levels from string
+
+
+    Returns
+    -------
+    dict
+        contains all strings with corresponding logging levels.
+    """
+    return {
+        "info": logging.INFO,
+        "warning": logging.WARNING,
+        "error": logging.ERROR,
+        "debug": logging.DEBUG,
+    }
+
+
+def getLogger(name):
+    logger = logging.getLogger(name)
+    logger.addHandler(LoopStructural.ch)
+    # don't pass message back up the chain, what an odd default behavior
+    logger.propagate = False
+    # store the loopstructural loggers so we can change values
+    LoopStructural.loggers[name] = logger
+    return logger
+
+
+def log_to_file(filename, overwrite=True, level="info"):
+    """Set the logging parameters for log file
+
+
+    Parameters
+    ----------
+    filename : string
+        name of file or path to file
+    level : str, optional
+        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
+    """
+    logger = getLogger(__name__)
+    if os.path.isfile(filename):
+        logger.warning("Overwriting existing logfile. To avoid this, set overwrite=False")
+        os.remove(filename)
+    levels = get_levels()
+    level = levels.get(level, logging.WARNING)
+    fh = logging.FileHandler(filename)
+    fh.setFormatter(LoopStructural.formatter)
+    fh.setLevel(level)
+    for logger in LoopStructural.loggers.values():
+        for hdlr in logger.handlers[:]:  # remove the existing file handlers
+            if isinstance(hdlr, logging.FileHandler):  # fixed two typos here
+                logger.removeHandler(hdlr)
+        logger.addHandler(fh)
+        logger.setLevel(level)
+
+
+def log_to_console(level="warning"):
+    """Set the level of logging to the console
+
+
+    Parameters
+    ----------
+    level : str, optional
+        'info', 'warning', 'error', 'debug' mapped to logging levels, by default 'info'
+    """
+    levels = get_levels()
+    level = levels.get(level, logging.WARNING)
+    for logger in LoopStructural.loggers.values():
+        for hdlr in logger.handlers:
+            # both stream and file are base stream, so check if not a filehandler
+            if not isinstance(hdlr, logging.FileHandler):
+                logger.removeHandler(hdlr)
+                hdlr = LoopStructural.ch
+                hdlr.setLevel(level)
+                logger.addHandler(hdlr)