LoopStructural 1.0.4__zip → 1.0.71.dev0__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/visualisation/model_visualisation.py

@@ -4,7 +4,8 @@ A wrapper for lavavu
 """
 
 import logging
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 try:
     import lavavu
@@ -12,8 +13,8 @@ try:
 except ImportError:
     logger.error("Please install lavavu: pip install lavavu")
 import numpy as np
-from skimage.measure import marching_cubes_lewiner as marching_cubes
-
+from skimage.measure import marching_cubes
+from LoopStructural.modelling.features import GeologicalFeature
 from LoopStructural.utils.helper import create_surface, get_vectors, create_box
 
 # adapted/copied from pyvista for sphinx scraper
@@ -125,8 +126,8 @@ class LavaVuModelViewer:
         self.lv.clear()
         self.lv.cleardata()
         pass
-
-    def add_section(self, geological_feature=None, axis='x', value=None, **kwargs):
+    
+    def add_section(self, geological_feature=None, axis='x', value=None,  **kwargs):
         """
 
         Plot a section/map thru the model and paint with a geological feature
@@ -146,29 +147,26 @@ class LavaVuModelViewer:
         -------
 
         """
-
         if axis == 'x':
             tri, yy, zz = create_surface(self.bounding_box[:, [1, 2]], self.nsteps[[1, 2]])
             xx = np.zeros(zz.shape)
             if value is None:
-                xx[:] = np.nanmean(self.bounding_box[:, 0])
-            else:
-                xx[:] = value
+                value = np.nanmean(self.bounding_box[:, 0])
+            xx[:] = value
         if axis == 'y':
             tri, xx, zz = create_surface(self.bounding_box[:, [0, 2]], self.nsteps[[0, 2]])
             yy = np.zeros(xx.shape)
             if value is None:
-                yy[:] = np.nanmean(self.bounding_box[:, 1])
-            else:
-                yy[:] = value
+                value = np.nanmean(self.bounding_box[:, 1])
+            yy[:] = value
         if axis == 'z':
             tri, xx, yy = create_surface(self.bounding_box[:, 0:2], self.nsteps[0:2])
             zz = np.zeros(xx.shape)
             if value is None:
-                zz[:] = np.nanmean(self.bounding_box[:, 2])
-            else:
-                zz[:] = value
-        name = kwargs.get('name', axis + '_slice')
+                value = np.nanmean(self.bounding_box[:, 2])
+            zz[:] = value
+        name = kwargs.get('name', geological_feature.name)
+        name = '{}_section_at_{}_of_{}'.format(axis,value,name)
         colour = kwargs.get('colour', 'red')
 
         # create an array to evaluate the feature on for the section
@@ -178,12 +176,13 @@ class LavaVuModelViewer:
         points[:, 2] = zz
 
         surf = self.lv.triangles(name)
-        surf.vertices(self.model.rescale(points))
+        surf.vertices(self.model.rescale(points,inplace=False))
         surf.indices(tri)
         logger.info("Adding %s section at %f" % (axis, value))
         if geological_feature is None:
             surf.colours(colour)
-        if geological_feature is not None:
+
+        if geological_feature is not None and type(geological_feature) == GeologicalFeature:
             if 'norm' in kwargs:
                 surf.values(np.linalg.norm(
                     geological_feature.evaluate_gradient(points), axis=1),
@@ -198,6 +197,15 @@ class LavaVuModelViewer:
             logger.info("Colouring section with %s min: %f, max: %f" % (
                 geological_feature.name, geological_feature.min(), geological_feature.max()))
             surf.colourmap(cmap, range=[geological_feature.min(), geological_feature.max()])
+        if geological_feature == 'model' and self.model is not None:
+            name = kwargs.get('name','model_section')
+            surf.values(self.model.evaluate_model(points,scale=True),
+                            name)
+            surf["colourby"] = name
+            cmap = lavavu.cubehelix(100)
+            if 'cmap' in kwargs:
+                cmap = kwargs['cmap']
+
 
     def add_isosurface(self, geological_feature, value = None, isovalue=None,
                      paint_with=None, slices=None, colour='red', nslices=None, 
@@ -236,7 +244,8 @@ class LavaVuModelViewer:
         [type]
             [description]
         """
-
+        if geological_feature is None:
+            logger.error("Cannot add isosurface GeologicalFeature does not exist")
         # update the feature to make sure its current
         if 'update' in kwargs:
             geological_feature.update()
@@ -296,9 +305,11 @@ class LavaVuModelViewer:
                 verts += np.array([self.bounding_box[0, 0], self.bounding_box[0, 1], self.bounding_box[1, 2]])
                 self.model.rescale(verts)
 
-            except ValueError:
-                logger.warning("no surface to mesh, skipping")
+            except (ValueError, RuntimeError) as e:
+                print(e)
+                logger.warning("Cannot isosurface {} at {}, skipping".format(geological_feature.name,isovalue))
                 continue
+
             
             name = geological_feature.name
             name = kwargs.get('name', name)
@@ -346,21 +357,28 @@ class LavaVuModelViewer:
                 vmax = kwargs.get('vmax', max_property_val)
                 surf.colourmap(cmap, range=(vmin, vmax))  # nodes.shape[0]))
         
-    def add_scalar_field(self, geological_feature, **kwargs):
-        """
+    def add_scalar_field(self, geological_feature, name=None, cmap='rainbow', vmin=None, vmax = None, **kwargs):
+        """Add a block the size of the model area painted with the scalar field value
 
         Parameters
         ----------
         geological_feature : GeologicalFeature
             the geological feature to colour the scalar field by
-        kwargs
-            kwargs for lavavu
-
-        Returns
-        -------
-
+        name : string, optional
+            Name of the object for lavavu, needs to be unique for the viewer object, by default uses feature name
+        cmap : str, optional
+            mpl colourmap reference, by default 'rainbow'
+        vmin : double, optional
+            minimum value of the colourmap, by default None
+        vmax : double, optional
+            maximum value of the colourmap, by default None
         """
-        name = kwargs.get('name', geological_feature.name + '_scalar_field')
+        if name == None:
+            if geological_feature is None:
+                name = 'unnamed scalar field'
+            else:
+                name = geological_feature.name + '_scalar_field'
+
         points, tri = create_box(self.bounding_box,self.nsteps)
 
         surf = self.lv.triangles(name)
@@ -369,15 +387,23 @@ class LavaVuModelViewer:
         val =geological_feature.evaluate_value(self.model.scale(points))
         surf.values(val, geological_feature.name)
         surf["colourby"] = geological_feature.name
-        cmap = kwargs.get('cmap',lavavu.cubehelix(100))
-
         logger.info("Adding scalar field of %s to viewer. Min: %f, max: %f" % (geological_feature.name,
                                                                                geological_feature.min(),
                                                                                geological_feature.max()))
-        vmin = kwargs.get('vmin', np.nanmin(val))
-        vmax = kwargs.get('vmax', np.nanmax(val))
+        if vmin == None:
+            vmin =np.nanmin(val)
+        if vmax == None:
+            vmax = np.nanmax(val)
         surf.colourmap(cmap, range=(vmin, vmax))
 
+    def add_box(self,bounding_box,name,colour='red'):
+        points, tri = create_box(bounding_box,self.nsteps)
+
+        surf = self.lv.triangles(name)
+        surf.vertices(self.model.rescale(points))
+        surf.indices(tri)
+        surf.colours(colour)
+
     def add_model(self, cmap = None, **kwargs):
         """Add a block model painted by stratigraphic id to the viewer
 
@@ -416,6 +442,8 @@ class LavaVuModelViewer:
             boundaries = []
             data = []
             for g in self.model.stratigraphic_column.keys():
+                if g == 'faults':
+                    continue
                 for u, v  in self.model.stratigraphic_column[g].items():
                     data.append((v['id'],v['colour']))
                     colours.append(v['colour'])
@@ -465,8 +493,22 @@ class LavaVuModelViewer:
         vmin = kwargs.get('vmin', np.nanmin(vals))
         vmax = kwargs.get('vmax', np.nanmax(vals))
         surf.colourmap(cmap, range=(vmin, vmax))
-
-    def add_model_surfaces(self, faults = True, cmap=None, **kwargs):
+        
+    def add_fault(self,fault,step=100):
+        self.add_isosurface(fault,value=0,name=fault.name)
+        self.add_vector_field(fault,locations=self.model.regular_grid()[::step])
+
+    def unfault_grid(self,feature,grid=None):
+        if grid is None:
+            grid = self.model.regular_grid()
+        # apply all faults associated with a feature to a regular grid
+        self.add_value_data(self.model.rescale(grid,inplace=False),grid[:,2],name='Regular grid before faults',pointsize=10,)
+   
+        for f in feature.faults:
+            grid = f.apply_to_points(grid)
+        self.add_value_data(self.model.rescale(grid,inplace=False),grid[:,2],name='Regular grid after faults',pointsize=10,)
+
+    def add_model_surfaces(self, strati=True, faults = True, cmap=None, fault_colour='black',**kwargs):
         """Add surfaces for all of the interfaces in the model
 
 
@@ -481,18 +523,29 @@ class LavaVuModelViewer:
         Other parameters are passed to self.add_isosurface() 
 
         """
+        import time
         from matplotlib import cm
         from matplotlib import colors
+        from tqdm.auto import tqdm
+        start = time.time()
         n_units = 0 #count how many discrete colours
         for g in self.model.stratigraphic_column.keys():
-            for u in self.model.stratigraphic_column[g].keys():
-                n_units+=1
-        if cmap is None:
-            import matplotlib.colors as colors
+            if g in self.model.feature_name_index:
+                for u in self.model.stratigraphic_column[g].keys():
+                    n_units+=1
+        n_faults = 0
+        for f in self.model.features:
+            if f.type=='fault':
+                n_faults+=1
+        
+        if cmap is None:            
             colours = []
             boundaries = []
             data = []
             for g in self.model.stratigraphic_column.keys():
+                if g == 'faults':
+                    # skip anything saved in faults here
+                    continue
                 for u, v  in self.model.stratigraphic_column[g].items():
                     data.append((v['id'],v['colour']))
                     colours.append(v['colour'])
@@ -502,50 +555,47 @@ class LavaVuModelViewer:
             cmap = cm.get_cmap(cmap,n_units)
         ci = 0
         cmap_colours = colors.to_rgba_array(cmap.colors)
-        for g in self.model.stratigraphic_column.keys():
-            if g in self.model.feature_name_index:
-                feature = self.model.features[self.model.feature_name_index[g]]
-                names = []
-                values = []
-                colours = []
-                for u, vals in self.model.stratigraphic_column[g].items():
-                    names.append(u)
-                    values.append(vals['min'])
-                    colours.append(cmap_colours[ci,:])
-                    ci+=1
-                self.add_isosurface(feature, slices=values,names=names,colours=colours,**kwargs)
-
+        n_surfaces = 0
+        if strati:
+            n_surfaces+=n_units
         if faults:
-            for f in self.model.features:
-                if f.type == 'fault':
-                    def mask(x):
-                        val = f.displacementfeature.evaluate_value(x)
-                        val[np.isnan(val)] = 0
-                        maskv = np.zeros(val.shape).astype(bool)
-                        maskv[np.abs(val) > 0.001] = 1
-                        return maskv
-                    self.add_isosurface(f,isovalue=0,region=mask,**kwargs)
-
-    # def add_model_data(self, cmap='tab20',**kwargs):
-    #     from matplotlib import cm
-    #     n_units = 0 #count how many discrete colours
-    #     for g in self.model.stratigraphic_column.keys():
-    #         for u in self.model.stratigraphic_column[g].keys():
-    #             n_units+=1
-    #     tab = cm.get_cmap(cmap,n_units)
-    #     ci = 0
-
-    #     for g in self.model.stratigraphic_column.keys():
-    #         if g in self.model.feature_name_index:
-    #             feature = self.model.features[self.model.feature_name_index[g]]
-    #             for u, vals in self.model.stratigraphic_column[g].items():
-    #                 self.add_isosurface(feature, isovalue=vals['max'],name=u,colour=tab.colors[ci,:],**kwargs)
-    #                 ci+=1
-    #     if faults:
-    #         for f in self.model.features:
-    #             if f.type == 'fault':
-    #                 self.add_isosurface(f,isovalue=0,**kwargs)
+            n_surfaces+=n_faults
+        with tqdm(total=n_surfaces) as pbar:
+
+            if strati:
+                for g in self.model.stratigraphic_column.keys():
+                    if g in self.model.feature_name_index:
+                        feature = self.model.features[self.model.feature_name_index[g]]
+                        names = []
+                        values = []
+                        colours = []
+                        for u, vals in self.model.stratigraphic_column[g].items():
+                            names.append(u)
+                            values.append(vals['min'])
+                            colours.append(cmap_colours[ci,:])
+                            ci+=1
+                        pbar.set_description('Isosurfacing {}'.format(feature.name))
+                        self.add_isosurface(feature, slices=values,names=names,colours=colours,**kwargs)
+                        pbar.update(len(values))
+            
 
+            if faults:
+                for f in self.model.features:
+                    if f.type == 'fault':
+                        def mask(x):
+                            val = f.displacementfeature.evaluate_value(x)
+                            val[np.isnan(val)] = 0
+                            maskv = np.zeros(val.shape).astype(bool)
+                            maskv[np.abs(val) > 0.001] = 1
+                            return maskv
+                        if f.name in self.model.stratigraphic_column['faults']:
+                            fault_colour = self.model.stratigraphic_column['faults'][f.name].get('colour',['red'])
+                        pbar.set_description('Isosurfacing {}'.format(f.name))
+
+                        region = kwargs.pop('region',None) 
+                        self.add_isosurface(f,isovalue=0,region=mask,colour=fault_colour[0],name=f.name,**kwargs)
+                        pbar.update(1)
+            print("Adding surfaces took {} seconds".format(time.time()-start))
     def add_vector_field(self, geological_feature, **kwargs):
         """
 
@@ -633,6 +683,24 @@ class LavaVuModelViewer:
         if interface.shape[0] > 0 and add_interface:
             self.add_points(self.model.rescale(interface[:,:3],inplace=False), name + "_interface_cp")
 
+    def add_intersection_lineation(self, feature, **kwargs):
+        name = feature.name
+        if 'name' in kwargs:
+            name = kwargs['name']
+            del kwargs['name']
+        intersection = feature.fold.foldframe.calculate_intersection_lineation(
+            feature.builder)
+        gpoints = feature.builder.interpolator.get_gradient_constraints()[:,:6]
+        npoints = feature.builder.interpolator.get_norm_constraints()[:,:6]
+        points = []
+        if gpoints.shape[0] > 0:
+            points.append(gpoints)
+        if npoints.shape[0] > 0:
+            points.append(npoints)
+        points = np.vstack(points)
+        if intersection.shape[0] > 0:
+            self.add_vector_data(self.model.rescale(points[:,:3],inplace=False), intersection, name + "_intersection")
+        
     def add_points(self, points, name, **kwargs):
         """
 
@@ -698,7 +766,7 @@ class LavaVuModelViewer:
         if "pointsize" not in kwargs:
             kwargs["pointsize"] = 4
         # set the colour map to diverge unless user decides otherwise
-        cmap = kwargs.get('cmap', "spot")
+        cmap = kwargs.get('cmap', "rainbow")
         p = self.lv.points(name, **kwargs)
         p.vertices(position)
         p.values(value, "v")
@@ -708,7 +776,7 @@ class LavaVuModelViewer:
             logger.info('vmin {} and vmax {}'.format(kwargs['vmin'],kwargs['vmax']))
             p.colourmap(cmap, range=(kwargs['vmin'],kwargs['vmax']))
         else:
-            p.colourmap(cmap)
+            p.colourmap(cmap, range=(np.nanmin(value),np.nanmax(value)))
 
     def add_fold(self, fold, **kwargs):
         """

Miniconda/envs/loop/Lib/site-packages/LoopStructural/visualisation/rotation_angle_plotter.py

@@ -3,7 +3,8 @@ import logging
 import matplotlib.pyplot as plt
 import numpy as np
 
-logger = logging.getLogger(__name__)
+from LoopStructural.utils import getLogger
+logger = getLogger(__name__)
 
 
 class RotationAnglePlotter:

Miniconda/envs/loop/Lib/site-packages/LoopStructural/visualisation/stratigraphic_column.py

@@ -0,0 +1,60 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+from matplotlib.patches import Polygon
+from matplotlib.collections import PatchCollection
+
+class StratigraphicColumnView:
+    def __init__(self,model,ax=None,cmap=None, labels = None):
+        n_units = 0 #count how many discrete colours
+        xmin = 0
+        ymin = 0
+        ymax = 1
+        xmax = 1
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(2,10))
+        patches = []
+        for g in model.stratigraphic_column.keys():
+            if g == 'faults':
+                continue
+            for u in model.stratigraphic_column[g].keys():
+                n_units+=1
+                ymin = -model.stratigraphic_column[g][u]['min']
+                if np.isinf(model.stratigraphic_column[g][u]['min']):
+                    ymin = 0
+                ymax = -model.stratigraphic_column[g][u]['max']
+                if np.isinf(ymax):
+                    ymin = ymax + (ymax-ymin)*(1+np.random.rand())
+                polygon_points = np.array([[xmin,ymin],[xmax,ymin],[xmax,ymax],[xmin,ymax]])
+                patches.append(Polygon(polygon_points))
+                xy = (0,ymin+(ymax-ymin)/2)
+                if labels:
+                    ax.annotate(labels[u],xy)
+                else:
+                    ax.annotate(u,xy)
+        if cmap is None:
+            import matplotlib.colors as colors
+            colours = []
+            boundaries = []
+            data = []
+            for g in model.stratigraphic_column.keys():
+                if g == 'faults':
+                    continue
+                for u, v  in model.stratigraphic_column[g].items():
+                    data.append((v['id'],v['colour']))
+                    colours.append(v['colour'])
+                    boundaries.append(v['id'])#print(u,v)
+            cmap = colors.ListedColormap(colours)
+        else:
+            cmap = cm.get_cmap(cmap,n_units-1)
+        ci = 0
+        p = PatchCollection(patches, cmap=cmap)
+
+        colors = np.arange(len(patches))
+        p.set_array(np.array(colors))
+
+        ax.add_collection(p)
+
+        ax.set_ylim(ymax+(ymax-ymin)*-2,0)#ax.set_ylim(0,ymax)
+        ax.axis('off')
+        

Miniconda/envs/loop/Lib/site-packages/{LoopStructural-1.0.4-py3.7.egg-info → LoopStructural-1.0.71.dev0-py3.6.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: LoopStructural
-Version: 1.0.4
+Version: 1.0.71.dev0
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: UNKNOWN

Miniconda/envs/loop/Lib/site-packages/{LoopStructural-1.0.4-py3.7.egg-info → LoopStructural-1.0.71.dev0-py3.6.egg-info}/SOURCES.txt

@@ -10,6 +10,7 @@ LoopStructural/interpolators/cython/dsi_helper.c
 LoopStructural/datasets/__init__.py
 LoopStructural/datasets/_base.py
 LoopStructural/interpolators/__init__.py
+LoopStructural/interpolators/base_structured_3d_support.py
 LoopStructural/interpolators/discrete_fold_interpolator.py
 LoopStructural/interpolators/discrete_interpolator.py
 LoopStructural/interpolators/finite_difference_interpolator.py
@@ -24,7 +25,10 @@ LoopStructural/interpolators/cython/dsi_helper.c
 LoopStructural/modelling/__init__.py
 LoopStructural/modelling/core/__init__.py
 LoopStructural/modelling/core/geological_model.py
+LoopStructural/modelling/core/geological_model_graph.py
+LoopStructural/modelling/core/stratigraphic_column.py
 LoopStructural/modelling/fault/__init__.py
+LoopStructural/modelling/fault/fault_builder.py
 LoopStructural/modelling/fault/fault_function.py
 LoopStructural/modelling/fault/fault_function_feature.py
 LoopStructural/modelling/fault/fault_segment.py
@@ -32,6 +36,7 @@ LoopStructural/modelling/features/__init__.py
 LoopStructural/modelling/features/cross_product_geological_feature.py
 LoopStructural/modelling/features/geological_feature.py
 LoopStructural/modelling/features/geological_feature_builder.py
+LoopStructural/modelling/features/lambda_geological_feature.py
 LoopStructural/modelling/features/region_feature.py
 LoopStructural/modelling/features/structural_frame.py
 LoopStructural/modelling/features/structural_frame_builder.py
@@ -43,9 +48,12 @@ LoopStructural/modelling/fold/fold_rotation_angle_feature.py
 LoopStructural/modelling/fold/foldframe.py
 LoopStructural/modelling/fold/svariogram.py
 LoopStructural/utils/__init__.py
+LoopStructural/utils/bounding_box.py
 LoopStructural/utils/exceptions.py
 LoopStructural/utils/helper.py
+LoopStructural/utils/logging.py
 LoopStructural/utils/map2loop.py
+LoopStructural/utils/regions.py
 LoopStructural/utils/utils.py
 LoopStructural/visualisation/__init__.py
 LoopStructural/visualisation/map_viewer.py
@@ -53,8 +61,5 @@ LoopStructural/visualisation/model_plotter.py
 LoopStructural/visualisation/model_visualisation.py
 LoopStructural/visualisation/rotation_angle_plotter.py
 LoopStructural/visualisation/sphinx_scraper.py
-tests/__init__.py
-tests/test_faults.py
-tests/test_fold.py
-tests/test_interpolator.py
-tests/test_refolded.py
+LoopStructural/visualisation/stratigraphic_column.py
+tests/__init__.py

Miniconda/envs/loop/Lib/site-packages/{LoopStructural-1.0.4-py3.7.egg-info → LoopStructural-1.0.71.dev0-py3.6.egg-info}/requires.txt

@@ -3,6 +3,6 @@ numpy
 pandas
 scipy
 matplotlib
-lavavu
 scikit-image
 scikit-learn
+tqdm