LoopStructural 1.6.2__tar.gz → 1.6.5__tar.gz

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/datatypes/_bounding_box.py

@@ -4,6 +4,7 @@ from LoopStructural.utils.exceptions import LoopValueError
 from LoopStructural.utils import rng
 from LoopStructural.datatypes._structured_grid import StructuredGrid
 import numpy as np
+import copy
 
 from LoopStructural.utils.logging import getLogger
 
@@ -147,7 +148,13 @@ class BoundingBox:
         ele_vol = box_vol / nelements
         # calculate the step vector of a regular cube
         step_vector = np.zeros(self.dimensions)
-        step_vector[:] = ele_vol ** (1.0 / 3.0)
+        if self.dimensions == 2:
+            step_vector[:] = ele_vol ** (1.0 / 2.0)
+        elif self.dimensions == 3:
+            step_vector[:] = ele_vol ** (1.0 / 3.0)
+        else:
+            logger.warning("Can only set nelements for 2d or 3D bounding box")
+            return
         # number of steps is the length of the box / step vector
         nsteps = np.ceil((self.maximum - self.origin) / step_vector).astype(int)
         self.nsteps = nsteps
@@ -269,7 +276,10 @@ class BoundingBox:
         origin = self.origin - buffer * (self.maximum - self.origin)
         maximum = self.maximum + buffer * (self.maximum - self.origin)
         return BoundingBox(
-            origin=origin, maximum=maximum, global_origin=self.global_origin + origin
+            origin=origin,
+            maximum=maximum,
+            global_origin=self.global_origin + origin,
+            dimensions=self.dimensions,
         )
 
     def get_value(self, name):
@@ -412,11 +422,16 @@ class BoundingBox:
     def structured_grid(
         self, cell_data: Dict[str, np.ndarray] = {}, vertex_data={}, name: str = "bounding_box"
     ):
+        # python is passing a reference to the cell_data, vertex_data dicts so we need to
+        # copy them to make sure that different instances of StructuredGrid are not sharing the same
+        # underlying objects
+        _cell_data = copy.deepcopy(cell_data)
+        _vertex_data = copy.deepcopy(vertex_data)
         return StructuredGrid(
             origin=self.global_origin,
             step_vector=self.step_vector,
             nsteps=self.nsteps,
-            cell_properties=cell_data,
-            properties=vertex_data,
+            cell_properties=_cell_data,
+            properties=_vertex_data,
             name=name,
         )

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/datatypes/_point.py

@@ -3,6 +3,9 @@ import numpy as np
 
 from typing import Optional, Union
 import io
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
 
 
 @dataclass
@@ -29,6 +32,20 @@ class ValuePoints:
         points["values"] = self.values
         return points
 
+    def plot(self, pyvista_kwargs={}):
+        """Calls pyvista plot on the vtk object
+
+        Parameters
+        ----------
+        pyvista_kwargs : dict, optional
+            kwargs passed to pyvista.DataSet.plot(), by default {}
+        """
+        try:
+            self.vtk().plot(**pyvista_kwargs)
+            return
+        except ImportError:
+            logger.error("pyvista is required for vtk")
+
     def save(self, filename: Union[str, io.StringIO], ext=None):
         if isinstance(filename, io.StringIO):
             if ext is None:
@@ -106,12 +123,15 @@ class VectorPoints:
     def from_dict(self, d):
         return VectorPoints(d['locations'], d['vectors'], d['name'], d.get('properties', None))
 
-    def vtk(self, geom='arrow', scale=1.0, scale_function=None, tolerance=0.05):
+    def vtk(self, geom='arrow', scale=1.0, scale_function=None, normalise=True, tolerance=0.05):
         import pyvista as pv
 
         vectors = np.copy(self.vectors)
+        if normalise:
+            norm = np.linalg.norm(vectors, axis=1)
+            vectors[norm > 0, :] /= norm[norm > 0][:, None]
         if scale_function is not None:
-            vectors /= np.linalg.norm(vectors, axis=1)[:, None]
+            # vectors /= np.linalg.norm(vectors, axis=1)[:, None]
             vectors *= scale_function(self.locations)[:, None]
         points = pv.PolyData(self.locations)
         points.point_data.set_vectors(vectors, 'vectors')
@@ -123,6 +143,20 @@ class VectorPoints:
         # Perform the glyph
         return points.glyph(orient="vectors", geom=geom, tolerance=tolerance)
 
+    def plot(self, pyvista_kwargs={}):
+        """Calls pyvista plot on the vtk object
+
+        Parameters
+        ----------
+        pyvista_kwargs : dict, optional
+            kwargs passed to pyvista.DataSet.plot(), by default {}
+        """
+        try:
+            self.vtk().plot(**pyvista_kwargs)
+            return
+        except ImportError:
+            logger.error("pyvista is required for vtk")
+
     def save(self, filename):
         filename = str(filename)
         ext = filename.split('.')[-1]

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/datatypes/_structured_grid.py

@@ -1,6 +1,9 @@
 from typing import Dict
 import numpy as np
 from dataclasses import dataclass
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
 
 
 @dataclass
@@ -46,6 +49,20 @@ class StructuredGrid:
             grid.cell_data[name] = data.flatten(order="F")
         return grid
 
+    def plot(self, pyvista_kwargs={}):
+        """Calls pyvista plot on the vtk object
+
+        Parameters
+        ----------
+        pyvista_kwargs : dict, optional
+            kwargs passed to pyvista.DataSet.plot(), by default {}
+        """
+        try:
+            self.vtk().plot(**pyvista_kwargs)
+            return
+        except ImportError:
+            logger.error("pyvista is required for vtk")
+
     def merge(self, other):
         if not np.all(np.isclose(self.origin, other.origin)):
             raise ValueError("Origin of grids must be the same")

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/datatypes/_surface.py

@@ -2,6 +2,9 @@ from dataclasses import dataclass
 from typing import Optional
 import numpy as np
 import io
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
 
 
 @dataclass
@@ -85,6 +88,20 @@ class Surface:
                 surface.cell_data[k] = np.array(v)
         return surface
 
+    def plot(self, pyvista_kwargs={}):
+        """Calls pyvista plot on the vtk object
+
+        Parameters
+        ----------
+        pyvista_kwargs : dict, optional
+            kwargs passed to pyvista.DataSet.plot(), by default {}
+        """
+        try:
+            self.vtk().plot(**pyvista_kwargs)
+            return
+        except ImportError:
+            logger.error("pyvista is required for vtk")
+
     def to_dict(self, flatten=False):
         triangles = self.triangles
         vertices = self.vertices

loopstructural-1.6.5/LoopStructural/export/omf_wrapper.py

@@ -0,0 +1,116 @@
+try:
+    import omf
+except ImportError:
+    raise ImportError(
+        "You need to install the omf package to use this feature. "
+        "You can install it with: pip install mira-omf"
+    )
+import numpy as np
+import datetime
+import os
+
+
+def get_project(filename):
+    if os.path.exists(filename):
+
+        try:
+            reader = omf.OMFReader(filename)
+            project = reader.get_project()
+        except (FileNotFoundError, ValueError):
+            project = omf.Project(name='LoopStructural Model')
+        return project
+    else:
+        return omf.Project(name='LoopStructural Model')
+
+
+def get_cell_attributes(loopobject):
+    attributes = []
+    if loopobject.cell_properties:
+        for k, v in loopobject.cell_properties.items():
+            v = np.array(v)
+            if len(v.shape) > 1 and v.shape[1] > 1:
+                for i in range(v.shape[1]):
+                    attributes.append(
+                        omf.ScalarData(name=f'{k}_{i}', array=v[:, i], location="faces")
+                    )
+            else:
+                attributes.append(omf.ScalarData(name=k, array=v, location="faces"))
+
+    return attributes
+
+
+def get_point_attributed(loopobject):
+    attributes = []
+    if loopobject.properties:
+        for k, v in loopobject.properties.items():
+            v = np.array(v)
+            if len(v.shape) > 1 and v.shape[1] > 1:
+                for i in range(v.shape[1]):
+                    attributes.append(
+                        omf.ScalarData(name=f'{k}_{i}', array=v[:, i], location="vertices")
+                    )
+            else:
+                attributes.append(omf.ScalarData(name=k, array=v, location="vertices"))
+
+    return attributes
+
+
+def add_surface_to_omf(surface, filename):
+
+    attributes = []
+    attributes += get_cell_attributes(surface)
+    attributes += get_point_attributed(surface)
+    surface = omf.SurfaceElement(
+        geometry=omf.SurfaceGeometry(
+            vertices=surface.vertices,
+            triangles=surface.triangles,
+        ),
+        data=attributes,
+        name=surface.name,
+    )
+    project = get_project(filename)
+
+    project.elements += [surface]
+    project.metadata = {
+        "coordinate_reference_system": "epsg 3857",
+        "date_created": datetime.datetime.utcnow(),
+        "version": "v1.3",
+        "revision": "10",
+    }
+    omf.OMFWriter(project, filename)
+
+
+def add_pointset_to_omf(points, filename):
+
+    attributes = []
+    attributes += get_point_attributed(points)
+
+    points = omf.PointSetElement(
+        vertices=points.locations,
+        attributes=attributes,
+        name=points.name,
+    )
+
+    project = get_project(filename)
+    project.elements += [points]
+    omf.OMFWriter(project, filename)
+
+
+def add_structured_grid_to_omf(grid, filename):
+    print('Open Mining Format cannot store structured grids')
+    return
+    # attributes = []
+    # attributes += get_cell_attributes(grid)
+    # attributes += get_point_attributed(grid)
+
+    # vol = omf.TensorGridBlockModel(
+    #     name=grid.name,
+    #     tensor_u=np.ones(grid.nsteps[0]).astype(float),
+    #     tensor_v=np.ones(grid.nsteps[0]).astype(float),
+    #     tensor_w=np.ones(grid.nsteps[0]).astype(float),
+    #     origin=grid.origin,
+    #     attributes=attributes,
+    # )
+    # project = get_project(filename)
+    # project.elements += [vol]
+    # omf.save(project, filename, mode='w')

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/interpolators/__init__.py

@@ -52,6 +52,7 @@ interpolator_string_map = {
     "P2": InterpolatorType.PIECEWISE_QUADRATIC,
     "P1": InterpolatorType.PIECEWISE_LINEAR,
     "DFI": InterpolatorType.DISCRETE_FOLD,
+    'surfe': InterpolatorType.SURFE,
 }
 from ..interpolators._geological_interpolator import GeologicalInterpolator
 from ..interpolators._discrete_interpolator import DiscreteInterpolator
@@ -79,6 +80,11 @@ from ..interpolators._discrete_fold_interpolator import (
 from ..interpolators._p2interpolator import P2Interpolator
 from ..interpolators._p1interpolator import P1Interpolator
 
+try:
+    from ..interpolators._surfe_wrapper import SurfeRBFInterpolator
+except ImportError:
+    logger.warning("Surfe is not installed, SurfeRBFInterpolator will not be available")
+    SurfeRBFInterpolator = None
 interpolator_map = {
     InterpolatorType.BASE: GeologicalInterpolator,
     InterpolatorType.BASE_DISCRETE: DiscreteInterpolator,
@@ -87,6 +93,7 @@ interpolator_map = {
     InterpolatorType.PIECEWISE_LINEAR: P1Interpolator,
     InterpolatorType.PIECEWISE_QUADRATIC: P2Interpolator,
     InterpolatorType.BASE_DATA_SUPPORTED: GeologicalInterpolator,
+    InterpolatorType.SURFE: SurfeRBFInterpolator,
 }
 
 support_interpolator_map = {
@@ -100,6 +107,12 @@ support_interpolator_map = {
         3: SupportType.P2UnstructuredTetMesh,
         2: SupportType.P2Unstructured2d,
     },
+    InterpolatorType.SURFE: {
+        3: SupportType.DataSupported,
+        2: SupportType.DataSupported,
+    },
 }
 
 from ._interpolator_factory import InterpolatorFactory
+
+# from ._api import LoopInterpolator

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/interpolators/_api.py

@@ -19,6 +19,8 @@ class LoopInterpolator:
         dimensions: int = 3,
         type=InterpolatorType.FINITE_DIFFERENCE,
         nelements: int = 1000,
+        interpolator_setup_kwargs={},
+        buffer: float = 0.2,
     ):
         """Scikitlearn like interface for LoopStructural interpolators
         useful for quickly building an interpolator to apply to a dataset
@@ -37,21 +39,22 @@ class LoopInterpolator:
         nelements : int, optional
             degrees of freedom for interpolator, by default 1000
         """
+        logger.warning("LoopInterpolator is experimental and the API is subject to change")
         self.dimensions = dimensions
         self.type = "FDI"
         self.bounding_box = bounding_box
         self.interpolator: GeologicalInterpolator = InterpolatorFactory.create_interpolator(
-            type,
-            bounding_box,
-            nelements,
+            type, bounding_box, nelements, buffer=buffer
         )
+        self.interpolator_setup_kwargs = interpolator_setup_kwargs
 
     def fit(
         self,
         values: Optional[np.ndarray] = None,
         tangent_vectors: Optional[np.ndarray] = None,
         normal_vectors: Optional[np.ndarray] = None,
-        inequality_constraints: Optional[np.ndarray] = None,
+        inequality_value_constraints: Optional[np.ndarray] = None,
+        inequality_pairs_constraints: Optional[np.ndarray] = None,
     ):
         """_summary_
 
@@ -66,16 +69,18 @@ class LoopInterpolator:
         inequality_constraints : Optional[np.ndarray], optional
             _description_, by default None
         """
+
         if values is not None:
             self.interpolator.set_value_constraints(values)
         if tangent_vectors is not None:
             self.interpolator.set_tangent_constraints(tangent_vectors)
         if normal_vectors is not None:
             self.interpolator.set_normal_constraints(normal_vectors)
-        if inequality_constraints:
-            pass
-
-        self.interpolator.setup()
+        if inequality_value_constraints is not None:
+            self.interpolator.set_value_inequality_constraints(inequality_value_constraints)
+        if inequality_pairs_constraints is not None:
+            self.interpolator.set_inequality_pairs_constraints(inequality_pairs_constraints)
+        self.interpolator.setup(**self.interpolator_setup_kwargs)
 
     def evaluate_scalar_value(self, locations: np.ndarray) -> np.ndarray:
         """Evaluate the value of the interpolator at locations
@@ -114,30 +119,93 @@ class LoopInterpolator:
         values: Optional[np.ndarray] = None,
         tangent_vectors: Optional[np.ndarray] = None,
         normal_vectors: Optional[np.ndarray] = None,
-        inequality_constraints: Optional[np.ndarray] = None,
+        inequality_value_constraints: Optional[np.ndarray] = None,
+        inequality_pairs_constraints: Optional[np.ndarray] = None,
     ):
         # get locations
         self.fit(
             values=values,
             tangent_vectors=tangent_vectors,
             normal_vectors=normal_vectors,
-            inequality_constraints=inequality_constraints,
+            inequality_value_constraints=inequality_value_constraints,
+            inequality_pairs_constraints=inequality_pairs_constraints,
         )
         locations = self.interpolator.get_data_locations()
-        return self.evalute_scalar_value(locations)
+        return self.evaluate_scalar_value(locations)
 
     def fit_and_evaluate_gradient(
         self,
         values: Optional[np.ndarray] = None,
         tangent_vectors: Optional[np.ndarray] = None,
         normal_vectors: Optional[np.ndarray] = None,
-        inequality_constraints: Optional[np.ndarray] = None,
+        inequality_value_constraints: Optional[np.ndarray] = None,
+        inequality_pairs_constraints: Optional[np.ndarray] = None,
     ):
         self.fit(
             values=values,
             tangent_vectors=tangent_vectors,
             normal_vectors=normal_vectors,
-            inequality_constraints=inequality_constraints,
+            inequality_value_constraints=inequality_value_constraints,
+            inequality_pairs_constraints=inequality_pairs_constraints,
         )
         locations = self.interpolator.get_data_locations()
         return self.evaluate_gradient(locations)
+
+    def fit_and_evaluate_value_and_gradient(
+        self,
+        values: Optional[np.ndarray] = None,
+        tangent_vectors: Optional[np.ndarray] = None,
+        normal_vectors: Optional[np.ndarray] = None,
+        inequality_value_constraints: Optional[np.ndarray] = None,
+        inequality_pairs_constraints: Optional[np.ndarray] = None,
+    ):
+        self.fit(
+            values=values,
+            tangent_vectors=tangent_vectors,
+            normal_vectors=normal_vectors,
+            inequality_value_constraints=inequality_value_constraints,
+            inequality_pairs_constraints=inequality_pairs_constraints,
+        )
+        locations = self.interpolator.get_data_locations()
+        return self.evaluate_scalar_value(locations), self.evaluate_gradient(locations)
+
+    def plot(self, ax=None, **kwargs):
+        """Plots a 2d map scalar field or 3d pyvista plot
+
+        Parameters
+        ----------
+        ax : matplotlib axes, optional
+            The axes you want to add the plot to, otherwise it will make one, by default None
+
+        Returns
+        -------
+        _type_
+            _description_
+        """
+        if self.dimensions == 3:
+            vtkgrid = self.interpolator.support.vtk()
+            vtkgrid['val'] = self.interpolator.c
+            vtkgrid.plot(**kwargs)
+            return vtkgrid
+        elif self.dimensions == 2:
+            if ax is None:
+                import matplotlib.pyplot as plt
+
+                fig, ax = plt.subplots()
+            val = self.interpolator.c
+            val = np.rot90(val.reshape(self.interpolator.support.nsteps, order='F'), 3)
+            ax.imshow(
+                val,
+                origin='lower',
+                extent=[
+                    self.bounding_box.origin[0],
+                    self.bounding_box.maximum[0],
+                    self.bounding_box.origin[1],
+                    self.bounding_box.maximum[1],
+                ],
+                **kwargs,
+            )
+            return val, ax
+
+    # def isovalue(self, value: float, **kwargs):
+    #     self.interpolator.isovalue(value, **kwargs)

{loopstructural-1.6.2 → loopstructural-1.6.5}/LoopStructural/interpolators/_discrete_fold_interpolator.py

@@ -2,7 +2,7 @@
 Piecewise linear interpolator using folds
 """
 
-from typing import Optional
+from typing import Optional, Callable
 
 import numpy as np
 
@@ -64,6 +64,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         fold_normalisation=1.0,
         fold_norm=1.0,
         step=2,
+        mask_fn: Optional[Callable] = None,
     ):
         """
 
@@ -104,6 +105,10 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
         # calculate element volume for weighting
         vecs = nodes[:, 1:, :] - nodes[:, 0, None, :]
         vol = np.abs(np.linalg.det(vecs)) / 6
+        weight = np.ones(self.support.n_elements, dtype=float)
+        if mask_fn is not None:
+            weight[mask_fn(self.support.barycentre)] = 0
+        weight = weight[::step]
         if fold_orientation is not None:
             """
             dot product between vector in deformed ori plane = 0
@@ -120,7 +125,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             B = np.zeros(A.shape[0])
             idc = self.support.get_elements()[element_idx[::step], :]
             self.add_constraints_to_least_squares(
-                A, B, idc, w=fold_orientation, name="fold orientation"
+                A, B, idc, w=weight * fold_orientation, name="fold orientation"
             )
 
         if fold_axis_w is not None:
@@ -139,7 +144,9 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             B = np.zeros(A.shape[0]).tolist()
             idc = self.support.get_elements()[element_idx[::step], :]
 
-            self.add_constraints_to_least_squares(A, B, idc, w=fold_axis_w, name="fold axis")
+            self.add_constraints_to_least_squares(
+                A, B, idc, w=weight * fold_axis_w, name="fold axis"
+            )
 
         if fold_normalisation is not None:
             """
@@ -160,7 +167,7 @@ class DiscreteFoldInterpolator(PiecewiseLinearInterpolator):
             idc = self.support.get_elements()[element_idx[::step], :]
 
             self.add_constraints_to_least_squares(
-                A, B, idc, w=fold_normalisation, name="fold normalisation"
+                A, B, idc, w=weight * fold_normalisation, name="fold normalisation"
             )
 
         if fold_regularisation is not None: