LoopStructural 1.0.4__zip

Miniconda/envs/loop/Lib/site-packages/LoopStructural/utils/utils.py

@@ -0,0 +1,120 @@
+import logging
+
+import numpy as np
+import re
+
+logger = logging.getLogger(__name__)
+
+
+def strike_symbol(strike):
+    R = np.zeros((2, 2))
+    R[0, 0] = np.cos(np.deg2rad(-strike))
+    R[0, 1] = -np.sin(np.deg2rad(-strike))
+    R[1, 0] = np.sin(np.deg2rad(-strike))
+    R[1, 1] = np.cos(np.deg2rad(-strike))
+    R = np.zeros((2, 2))
+    R[0, 0] = np.cos(np.deg2rad(-strike))
+    R[0, 1] = -np.sin(np.deg2rad(-strike))
+    R[1, 0] = np.sin(np.deg2rad(-strike))
+    R[1, 1] = np.cos(np.deg2rad(-strike))
+
+    vec = np.array([0, 1])
+    rotated = R @ vec
+    vec2 = np.array([-0.5, 0])
+    r2 = R @ vec2
+    return rotated, r2
+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 log_to_file(filename,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'
+    """
+    levels = get_levels()
+    level = levels.get(level,logging.WARNING)
+    logging.basicConfig(level=level,
+                    format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
+                    datefmt='%m-%d %H:%M',
+                    filename=filename,
+                    filemode='w')
+
+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)
+
+    changed_level = False
+    for h in logging.getLogger().handlers:
+        if type(h) is logging.StreamHandler:
+            h.setLevel(level)
+            changed_level = True
+    if not changed_level:
+        console = logging.StreamHandler()
+        console.setLevel(level)
+        # add the handler to the root logger
+        logging.getLogger().addHandler(console)
+
+def read_voxet(voxetname,propertyfile):
+    """
+    Read a gocad property file and the geometry information from the .vo file
+    voxetname - is the path to the voxet file
+    propertyfile is the path to the binary file
+    Returns
+    origin numpy array
+    voxet_extent - is the length of each axis of the voxet
+    N is the number of steps in the voxet
+    array is the property values
+    steps is the size of the step vector for the voxet 
+    """
+    array = np.fromfile(propertyfile,dtype='float32')
+    array = array.astype('<f4') # little endian
+    with open(voxetname,'r') as file:
+        for l in file:
+            if 'AXIS_O ' in l:
+                origin = np.array(re.findall(r"[-+]?\d*\.?\d+|[-+]?\d+",l)).astype(float)
+            if 'AXIS_U ' in l:
+                U = float(re.findall(r'[\d\.\d]+',l)[0])
+            if 'AXIS_V ' in l:
+                V = float(re.findall(r'[\d\.\d]+',l)[1])
+            if 'AXIS_W ' in l:
+                W = float(re.findall(r'[\d\.\d]+',l)[2])
+            if 'AXIS_N ' in l:
+                N = np.array(re.findall(r'[\d\.\d]+',l)).astype(int) 
+    voxet_extent = np.array([U,V,W])
+    steps = (voxet_extent ) / (N-1)
+    return origin, voxet_extent, N, array, steps
+
+def write_property_to_gocad_voxet(propertyfilename, propertyvalues):
+    """
+    This function writes a numpy array into the right format for a gocad
+    voxet property file. This assumet there is a property already added to the .vo file,
+    and is just updating the file.
+    propertyfile - string giving the path to the file to write
+    propertyvalues - numpy array nz,ny,nx ordering and in float format
+    """
+    propertyvalues = propertyvalues.astype('>f4') #big endian
+#     array = propertyvalues.newbyteorder()
+    propertyvalues.tofile(propertyfilename)
+    

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

@@ -0,0 +1,19 @@
+"""
+This is the base visualistion module for loop structural
+
+Submodules
+==========
+
+.. autosummary::
+    :toctree: _autosummary
+
+    map_viewer
+    model_visualisation
+    rotation_angle_plotter
+
+"""
+
+from .map_viewer import MapView
+from .model_visualisation import LavaVuModelViewer
+from .sphinx_scraper import _get_loop_visualisation_scraper
+from .rotation_angle_plotter import RotationAnglePlotter

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

@@ -0,0 +1,307 @@
+import logging
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class MapView:
+    """
+
+    """
+    def __init__(self, model = None, bounding_box=np.zeros((2,2)), nsteps=None, ax = None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        origin - lower left
+        maximum - upper right
+        nsteps - number of cells
+        kwargs
+        """
+        
+        self.xx = None
+        self.yy = None
+        
+        self._bounding_box = bounding_box
+        self._nsteps = nsteps
+        if self._nsteps is not None and self._bounding_box is not None:
+            self._update_grid()
+        if model is not None:
+            #make sure self._nsteps is 2d
+            self.model = model
+        self.ax = ax
+        if self.ax is None:
+            fig, self.ax = plt.subplots(1, figsize=(10, 10))
+        self.ax.set_aspect('equal', adjustable='box')
+
+        # set plot limits to model bounding box
+        self._xmin = self.bounding_box[0,0]
+        self._xmax = self.bounding_box[1,0]
+        self._ymin = self.bounding_box[0,1]
+        self._ymax = self.bounding_box[1,1]
+        self._update_plot_limits()
+    @property
+    def model(self):
+        return self._model
+
+    @model.setter
+    def model(self,model):
+        if model is not None:
+            bb = np.array([model.origin[:2],model.maximum[:2]])
+            self.bounding_box = bb#model.bounding_box
+            self.nsteps = model.nsteps[:2]
+            self._model = model
+            self._update_grid()
+
+    @property
+    def nsteps(self):
+        return self._nsteps
+    
+    @nsteps.setter
+    def nsteps(self,nsteps):
+        if len(nsteps) != 2:
+            logger.error("Can't update nsteps, needs to be 2D")
+            return
+        self._nsteps = nsteps
+        self._update_grid()
+        
+    @property
+    def bounding_box(self):
+        return self._bounding_box
+    @bounding_box.setter
+    def bounding_box(self,bounding_box):
+        self._bounding_box = bounding_box
+        self._update_grid()
+
+    @property
+    def xmin(self):
+        return self._xmin
+    
+    @xmin.setter
+    def xmin(self,xmin):
+        self._xmin = xmin
+        self._update_plot_limits()
+    
+    @property
+    def xmax(self):
+        return self._xmax
+    
+    @xmax.setter
+    def xmax(self,xmax):
+        self._xmax = xmax
+        self._update_plot_limits()
+
+    @property
+    def ymin(self):
+        return self._ymin
+    
+    @ymin.setter
+    def ymin(self,ymin):
+        self._ymin = ymin
+        self._update_plot_limits()
+
+    @property
+    def ymax(self):
+        return self._ymax
+    
+    @ymax.setter
+    def ymax(self,ymax):
+        self._ymax = ymax
+        self._update_plot_limits()
+
+    def _update_plot_limits(self):
+        self.ax.set_xlim([self._xmin,self._xmax])
+        self.ax.set_ylim([self._ymin,self._ymax])
+
+    
+    def _update_grid(self):
+        """Internal function to update the current grid when the bounding box
+        or number of steps changes
+        """
+        if self.nsteps is None or self.bounding_box is None:
+            return        
+        x = np.linspace(self.bounding_box[0,0], self.bounding_box[1,0], self.nsteps[0])
+        y = np.linspace(self.bounding_box[0,1], self.bounding_box[1,1], self.nsteps[1])
+        self.xx, self.yy = np.meshgrid(x, y, indexing='ij')
+        self.xx = self.xx.flatten()
+        self.yy = self.yy.flatten()
+
+    def add_data(self, feature, val=True, grad=True, unfault=False, dip=True, **kwargs):
+        """
+        Adds the data associated to the feature to the plot
+        Parameters
+        ----------
+        feature : GeologicalFeature
+            the feature whose data you want to add
+        val : bool
+            whether to add value data
+        grad : bool
+            whether to add gradient data
+        unfault : bool
+            plot points in their restored location
+        dip : bool
+            whether to annotate the dip, default False
+
+        kwargs are passed to matplotlib functions and draw strike
+        Returns
+        -------
+
+        """
+        # logger.warning("Plotting restored data locations")
+        ori_data = []
+        gradient_data = feature.builder.get_gradient_constraints()
+        if unfault:
+            gradient_data = feature.interpolator.get_gradient_constraints()
+
+        if gradient_data.shape[0] > 0:
+            ori_data.append(gradient_data)
+        norm_data = feature.builder.get_norm_constraints()
+        if unfault:
+            norm_data = feature.interpolator.get_norm_constraints()
+
+        if norm_data.shape[0] > 0:
+            ori_data.append(norm_data)
+        cmap = kwargs.pop('cmap','rainbow')
+        # if single colour then specify kwarg, otherwise use point value
+        if val:
+            value_data = np.copy(feature.builder.get_value_constraints())
+            if unfault:
+                value_data = np.copy(feature.interpolator.get_value_constraints())
+              
+            value_data[:,:3] = self.model.rescale(value_data[:,:3],inplace=False)
+            point_colour = kwargs.pop('point_colour',None)
+            if point_colour is None:
+                self.ax.scatter(value_data[:, 0], value_data[:, 1], c=value_data[:,3],
+                            vmin=feature.min(), vmax=feature.max(),cmap=cmap)
+            if point_colour is not None:
+                self.ax.scatter(value_data[:, 0], value_data[:, 1], c=point_colour)
+        if grad:
+            symb_colour = kwargs.pop('symb_colour','black')
+            symb_scale=kwargs.pop('symb_scale',1.)
+            gradient_data = np.hstack(ori_data)
+            gradient_data[:,:3] = self.model.rescale(gradient_data[:,:3],inplace=False)
+            gradient_data[:, 3:5] /= np.linalg.norm(gradient_data[:, 3:5], axis=1)[:, None]
+            t = gradient_data[:, [4, 3]] * np.array([1, -1]).T
+            n = gradient_data[:, 3:5]
+            t *= symb_scale
+            n *= 0.5*symb_scale
+            p1 = gradient_data[:, [0, 1]] - t
+            p2 = gradient_data[:, [0, 1]] + t
+            # plt.scatter(val[:,0],val[:,1],c='black')
+            self.ax.plot([p1[:, 0], p2[:, 0]], [p1[:, 1], p2[:, 1]], symb_colour)
+            p1 = gradient_data[:, [0, 1]]
+            p2 = gradient_data[:, [0, 1]] + n
+            self.ax.plot([p1[:, 0], p2[:, 0]], [p1[:, 1], p2[:, 1]], symb_colour)
+            if dip:
+                dip_v = np.rad2deg(np.arccos(gradient_data[:,5])).astype(int)
+                for d, xy, v in zip(dip_v,gradient_data[:,:2],gradient_data[:,3:6]):
+                    self.ax.annotate(d,xy,xytext=xy+v[:2]*.03,fontsize='small')
+
+    def add_scalar_field(self, feature, z=0, **kwargs):
+        """
+        Plot the scalar field value on a map
+
+        Parameters
+        ----------
+        feature : GeologicalFeature
+            which feature to plot on the map
+        z : double/np.array
+            height
+        kwargs
+
+        Returns
+        -------
+
+        """
+        zz = np.zeros(self.xx.shape)
+        zz[:] = z
+        v = feature.evaluate_value(self.model.scale(np.array([self.xx, self.yy, zz]).T,inplace=False))
+        return self.ax.imshow(v.reshape(self.nsteps).T,
+                       extent=[self.bounding_box[0,0], self.bounding_box[1,0], self.bounding_box[0,1],
+                               self.bounding_box[1,1]],
+                       vmin=feature.min(), vmax=feature.max(),
+                       origin='lower',
+                       **kwargs)
+
+    def add_contour(self, feature, values, z=0, mask = None, **kwargs):
+        """Add an isoline of a scalar field to the map
+
+        Parameters
+        ----------
+        feature : GeologicalFeature
+            the feature to isosurface
+        values : list 
+            list of values to contour
+        z : double/np.array, optional
+            elevation of map, by default 0
+        """        
+        zz = np.zeros(self.xx.shape)
+        zz[:] = z
+        v = feature.evaluate_value(self.model.scale(np.array([self.xx, self.yy, zz]).T,inplace=False))
+        if mask:
+            maskv = mask(self.model.scale(np.array([self.xx, self.yy, zz]).T,inplace=False))
+            v[~maskv] = np.nan
+        return self.ax.contour(v.reshape(self.nsteps).T,extent=[self.bounding_box[0,0], self.bounding_box[1,0], self.bounding_box[0,1],
+                                    self.bounding_box[1,1]],origin='lower',levels=values,**kwargs
+                       )
+
+        
+    
+    def add_model(self, z = 0,cmap=None):
+        """Plot the model onto a map
+
+        Parameters
+        ----------
+        z : int/numpy array, optional
+            height of the map surface (could also be a dem), by default 0
+        cmap : str/matplotlib colourmap, optional
+            specify a colour map, by default 'tab20'
+        """  
+        if cmap is None:
+            import matplotlib.colors as colors
+            colours = []
+            boundaries = []
+            data = []
+            for g in self.model.stratigraphic_column.keys():
+                for u, v  in self.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)
+
+        zz = np.zeros_like(self.xx)
+        zz[:] = z#self.bounding_box[1,2]
+        pts = np.vstack([self.xx.flatten(),self.yy.flatten(),zz.flatten()])
+        if self.model is None:
+            logger.error("Mapview needs a model assigned to plot model on map")
+            return 
+        vals = self.model.evaluate_model(pts.T,scale=True)
+        return self.ax.imshow(vals.reshape(self.nsteps).T,extent=[self.bounding_box[0,0], self.bounding_box[1,0], self.bounding_box[0,1],
+                                    self.bounding_box[1,1]],origin='lower',cmap=cmap)
+                                
+    def add_fault_displacements(self,z = 0, cmap='rainbow'):
+        
+        zz = np.zeros_like(self.xx)
+        zz[:] = z#self.bounding_box[1,2]
+        pts = np.vstack([self.xx.flatten(),self.yy.flatten(),zz.flatten()])
+        if self.model is None:
+            logger.error("Mapview needs a model assigned to plot model on map")
+            return 
+        vals = self.model.evaluate_fault_displacements(pts.T,scale=True)
+        return self.ax.imshow(vals.reshape(self.nsteps).T,extent=[self.bounding_box[0,0], self.bounding_box[1,0], self.bounding_box[0,1],
+                                    self.bounding_box[1,1]],origin='lower',cmap=cmap)
+
+    def add_faults(self,**kwargs):
+        for f in self.model.features:
+            if f.type=='fault':
+                # create a function to return true if displacement > 0
+                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_contour(f,0,mask=mask)

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

@@ -0,0 +1,16 @@
+# import logging
+#
+#
+# logger = logging.getLogger(__name__)
+#
+# class BaseModelPlotter:
+#     def __init__(self, model):
+#         """
+#
+#         Parameters
+#         ----------
+#         model
+#         """
+#         self.model = model
+#
+#     def