LoopStructural 1.0.1__zip

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

@@ -0,0 +1,373 @@
+import logging
+
+import numpy as np
+from sklearn.decomposition import PCA
+
+logger = logging.getLogger(__name__)
+
+
+def get_data_axis_aligned_bounding_box(xyz, buffer):
+    """
+
+    Parameters
+    ----------
+    xyz
+    buffer
+
+    Returns
+    -------
+
+    """
+    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):
+        """
+
+        Parameters
+        ----------
+        xyz
+
+        Returns
+        -------
+
+        """
+        # print(xyz)
+        # print(bb)
+        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 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])
+
+    xlen = maxx - minx
+    ylen = maxy - miny
+    zlen = maxz - minz
+    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 plunge_and_plunge_dir_to_vector(plunge, plunge_dir):
+    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):
+    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 get_vectors(normal):
+    normal /= np.linalg.norm(normal,axis=1)[:,None]
+    strikedip = normal_vector_to_strike_and_dip(normal)
+    strike_vec = get_strike_vector(strikedip[:, 0])
+    strike_vec /= np.linalg.norm(strike_vec,axis=0)[None,:]
+    dip_vec = np.cross(strike_vec, normal, axisa=0, axisb=1).T  # (strikedip[:, 0], strikedip[:, 1])
+    dip_vec /= np.linalg.norm(dip_vec,axis=0)[None,:]
+    return strike_vec, dip_vec
+
+
+def get_strike_vector(strike):
+    """
+
+    Parameters
+    ----------
+    strike
+
+    Returns
+    -------
+
+    """
+
+    v = np.array([np.sin(np.deg2rad(-strike)),
+                  -np.cos(np.deg2rad(-strike)),
+                  np.zeros(strike.shape[0])
+                  ])
+
+    return v
+
+
+def get_dip_vector(strike, dip):
+    v = np.array([-np.cos(np.deg2rad(-strike)) * np.cos(-np.deg2rad(dip)),
+                  np.sin(np.deg2rad(-strike)) * np.cos(-np.deg2rad(dip)),
+                  np.sin(-np.deg2rad(dip))
+                  ])
+    return v
+
+
+def rotation(axis, angle):
+    c = np.cos(np.deg2rad(angle))
+    s = np.sin((np.deg2rad(angle)))
+    C = 1.0 - c
+    x = axis[0]
+    y = axis[1]
+    z = axis[2]
+    xs = x * s
+    ys = y * s
+    zs = z * s
+    xC = x * C
+    yC = y * C
+    zC = z * C
+    xyC = x * yC
+    yzC = y * zC
+    zxC = z * xC
+    rotation_mat = np.zeros((3, 3))
+    rotation_mat[0][0] = x * xC + c
+    rotation_mat[0][1] = xyC - zs
+    rotation_mat[0][2] = zxC + ys
+
+    rotation_mat[1][0] = xyC + zs
+    rotation_mat[1][1] = y * yC + c
+    rotation_mat[1][2] = yzC - xs
+
+    rotation_mat[2][0] = zxC - ys
+    rotation_mat[2][1] = yzC + xs
+    rotation_mat[2][2] = z * zC + c
+    return rotation_mat
+
+
+def strike_dip_vector(strike, dip):
+    vec = np.zeros((len(strike), 3))
+    s_r = np.deg2rad(strike)
+    d_r = np.deg2rad((dip))
+    vec[:, 0] = np.sin(d_r) * np.cos(s_r)
+    vec[:, 1] = -np.sin(d_r) * np.sin(s_r)
+    vec[:, 2] = np.cos(d_r)
+    vec /= np.linalg.norm(vec, axis=1)[:, None]
+    return vec
+
+
+def normal_vector_to_strike_and_dip(normal_vector):
+    normal_vector /= np.linalg.norm(normal_vector, axis=1)[:, None]
+    dip = np.rad2deg(np.arccos(normal_vector[:, 2]))
+    strike = -np.rad2deg(np.arctan2(normal_vector[:, 1], normal_vector[:,
+                                                         0]))  # atan2(v2[1],v2[0])*rad2deg;
+
+    return np.array([strike, dip]).T
+
+
+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 feature_name():
+    return ['feature_name']
+
+def all_heading():
+    return xyz_names() + normal_vec_names() + tangent_vec_names() + \
+           gradient_vec_names() + weight_name() + val_name() + coord_name() + feature_name()

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

@@ -0,0 +1,229 @@
+import pandas as pd
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+def process_map2loop(m2l_directory, flags={}):
+    """
+    Extracts relevant information from map2loop outputs
+
+    Parameters
+    ----------
+    m2l_directory : string
+        absolute path to a directory containing map2loop outputs
+    Returns
+    -------
+    m2l_data : dict
+        a dictionary containing the extracted and collated data
+    """
+    tangents = pd.read_csv(m2l_directory + '/tmp/raw_contacts.csv')
+    groups = pd.read_csv(m2l_directory + '/tmp/all_sorts.csv', index_col=0)
+    contact_orientations = pd.read_csv(m2l_directory + '/output/orientations.csv')
+    formation_thickness = pd.read_csv(m2l_directory + '/output/formation_thicknesses.csv')
+    contacts = pd.read_csv(m2l_directory + '/output/contacts4.csv')
+    displacements = pd.read_csv(m2l_directory + '/output/fault_displacements3.csv')
+    fault_orientations = pd.read_csv(m2l_directory + '/output/fault_orientations.csv')
+    fault_locations = pd.read_csv(m2l_directory + '/output/faults.csv')
+    fault_fault_relations = pd.read_csv(m2l_directory + '/output/fault-fault-relationships.csv')
+    fault_strat_relations = pd.read_csv(m2l_directory + '/output/group-fault-relationships.csv')
+    supergroups = {}
+    sgi = 0
+    try:
+        with open(m2l_directory + '/tmp/super_groups.csv') as    f:
+            for l in f:
+                for g in l.split(','):
+                    g = g.replace('-','_').replace(' ','_')
+                    if g.find('\n') > 0:
+                        g = g[:g.find('\n')]
+                    supergroups[g] = 'supergroup_{}'.format(sgi)
+                    if g == '\n':
+                        sgi += 1
+                        break
+    except:
+        for g in groups['group'].unique():
+            supergroups[g] = g
+    supergroups.pop('\n')
+
+    
+
+    bb = pd.read_csv(m2l_directory+'/tmp/bbox.csv')
+
+    # process tangent data to be tx, ty, tz
+    tangents['tz'] = 0
+    tangents['tx'] = tangents['lsx']
+    tangents['ty'] = tangents['lsy']
+    tangents.drop(['angle', 'lsx', 'lsy'], inplace=True, axis=1)
+
+    # convert azimuth and dip to gx, gy, gz
+    from LoopStructural.utils.helper import strike_dip_vector
+    contact_orientations['strike'] = contact_orientations['azimuth'] - 90
+    contact_orientations['gx'] = np.nan
+    contact_orientations['gy'] = np.nan
+    contact_orientations['gz'] = np.nan
+    contact_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(contact_orientations['strike'],
+                                                                 contact_orientations['dip'])
+    contact_orientations.drop(['strike', 'dip', 'azimuth'], inplace=True, axis=1)
+
+    # calculate scalar field values
+    thickness = {}
+    for f in formation_thickness['formation'].unique():
+        thickness[f] = np.mean(formation_thickness[formation_thickness['formation'] == f]['thickness'])
+
+    strat_val = {}
+    stratigraphic_column = {}
+    unit_id = 0
+    val = {}
+    for i in groups['group number'].unique():
+        g = supergroups[groups.loc[groups['group number'] == i, 'group'].iloc[0]]
+        if g not in stratigraphic_column:
+            stratigraphic_column[g] = {}
+            val[g] = 0
+
+        for c in groups.loc[groups['group number'] == i, 'code']:
+            strat_val[c] = np.nan
+            if c in thickness:
+                stratigraphic_column[g][c] = {'min': val[g], 'max': val[g] + thickness[c], 'id': unit_id}
+                unit_id += 1
+                strat_val[c] = val[g]
+                val[g] += thickness[c]
+    group_name = None
+    for g, i in stratigraphic_column.items():
+        if len(i) ==0:
+            for gr, sg in supergroups.items():
+                if sg == g:
+                    group_name = gr
+                    break
+            try:
+                if group_name is None:
+                    continue
+                c=groups.loc[groups['group']==group_name,'code'].to_numpy()[0]
+                strat_val[c] = 0
+                stratigraphic_column[g] = {c:{'min':0,'max':9999,'id':unit_id}}
+                unit_id+=1
+                group_name = None
+            except:
+                print('Couldnt process {}'.format(g))
+    contacts['val'] = np.nan
+    for o in strat_val:
+        contacts.loc[contacts['formation'] == o, 'val'] = strat_val[o]
+
+    tangents['feature_name'] = tangents['group']
+    contact_orientations['feature_name'] = None
+    contacts['feature_name'] = None
+    for g in groups['group'].unique():
+        val = 0
+        for c in groups.loc[groups['group'] == g, 'code']:
+            contact_orientations.loc[contact_orientations['formation'] == c, 'feature_name'] = supergroups[g]
+            contacts.loc[contacts['formation'] == c, 'feature_name'] = supergroups[g]
+    displacements['dip_dir'] = np.nan
+    for fname in fault_orientations['formation'].unique():
+        displacements.loc[displacements['fname'] == fname, 'dip_dir'] = np.mean(
+            fault_orientations.loc[fault_orientations['formation'] == fname, 'DipDirection'])
+    max_displacement = {}
+    for f in displacements['fname'].unique():
+        displacements_numpy = displacements.loc[
+            displacements['fname'] == f, ['vertical_displacement', 'downthrow_dir', 'dip_dir']].to_numpy()
+        # index = np.argmax(np.abs(displacements_numpy[:, 0]), )
+        index = np.argsort(np.abs(displacements_numpy[:, 0]))[len(np.abs(displacements_numpy[:, 0]))//2]
+
+        max_displacement[f] = displacements_numpy[
+            index, 0]
+        if displacements_numpy[index, 1] - displacements_numpy[index, 2] > 90:
+            fault_orientations.loc[fault_orientations['formation'] == fname, 'DipDirection'] = displacements_numpy[
+                index, 1]
+        # .loc[displacements['fname'] == f,'vertical_displacement'].max()
+    for g in groups['group'].unique():
+        groups.loc[groups['group']==g,'group'] = supergroups[g]
+    fault_orientations['strike'] = fault_orientations['DipDirection'] - 90
+    fault_orientations['gx'] = np.nan
+    fault_orientations['gy'] = np.nan
+    fault_orientations['gz'] = np.nan
+
+    fault_orientations[['gx', 'gy', 'gz']] = strike_dip_vector(fault_orientations['strike'], fault_orientations['dip'])
+    fault_orientations.drop(['strike', 'DipDirection', 'dip', 'DipPolarity'], inplace=True, axis=1)
+    fault_orientations['feature_name'] = fault_orientations['formation']
+
+    fault_locations['val'] = 0
+    fault_locations['feature_name'] = fault_locations['formation']
+
+
+    data = pd.concat([tangents, contact_orientations, contacts, fault_orientations, fault_locations])
+    data.reset_index()
+
+    return {'data': data,
+            'groups': groups,
+            'max_displacement': max_displacement,
+            'fault_fault': fault_fault_relations,
+            'stratigraphic_column': stratigraphic_column,
+            'bounding_box':bb,
+            'strat_va':strat_val}
+
+def build_model(m2l_data, skip_faults = False, unconformities=False, fault_params = None, foliation_params=None):
+    """[summary]
+
+    [extended_summary]
+
+    Parameters
+    ----------
+    m2l_data : dict
+        [description]
+    skip_faults : bool, optional
+        [description], by default False
+    fault_params : dict, optional
+        [description], by default None
+    foliation_params : dict, optional
+        [description], by default None
+
+    Returns
+    -------
+    [type]
+        [description]
+    """
+    from LoopStructural import GeologicalModel
+
+
+    boundary_points = np.zeros((2, 3))
+    boundary_points[0, 0] = m2l_data['bounding_box']['minx']
+    boundary_points[0, 1] = m2l_data['bounding_box']['miny']
+    boundary_points[0, 2] = m2l_data['bounding_box']['lower']
+    boundary_points[1, 0] = m2l_data['bounding_box']['maxx']
+    boundary_points[1, 1] = m2l_data['bounding_box']['maxy']
+    boundary_points[1, 2] = m2l_data['bounding_box']['upper']
+
+    model = GeologicalModel(boundary_points[0, :], boundary_points[1, :])
+    model.set_model_data(m2l_data['data'])
+    if not skip_faults:
+        faults = []
+        for f in m2l_data['max_displacement'].keys():
+            if model.data[model.data['feature_name'] == f].shape[0] == 0:
+                continue
+            fault_id = f
+            overprints = []
+            try:
+                overprint_id = m2l_data['fault_fault'][m2l_data['fault_fault'][fault_id] == 1]['fault_id'].to_numpy()
+                for i in overprint_id:
+                    overprints.append(i)
+                logger.info('Adding fault overprints {}'.format(f))
+            except:
+                logger.info('No entry for %s in fault_fault_relations' % f)
+        #     continue
+            faults.append(model.create_and_add_fault(f,
+                                                    -m2l_data['max_displacement'][f],
+                                                    faultfunction='BaseFault',
+                                                    overprints=overprints,
+                                                    **fault_params,
+                                                    )
+                        )
+
+    ## loop through all of the groups and add them to the model in youngest to oldest.
+    group_features = []
+    for i in np.sort(m2l_data['groups']['group number'].unique()):
+        g = m2l_data['groups'].loc[m2l_data['groups']['group number'] == i, 'group'].unique()[0]
+        group_features.append(model.create_and_add_foliation(g,
+                                                            **foliation_params))
+        # if the group was successfully added (not null) then lets add the base (0 to be unconformity)
+        if group_features[-1] and unconformities:
+            model.add_unconformity(group_features[-1], 0)
+    model.set_stratigraphic_column(m2l_data['stratigraphic_column'])
+    return model

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

@@ -0,0 +1,76 @@
+import logging
+
+import numpy as np
+
+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)

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