def __init__(self, *args, **kwargs):
self.baseline_dir = kwargs.pop(
'baseline_dir',
# 'tests/baseline_images/matplotlib_{ver}'.format(ver=matplotlib.__version__).replace('.', '_')
os.path.normpath(os.path.join(TEST_DIR, 'baseline_images')))
self.result_dir = kwargs.pop(
'result_dir',
# 'tests/result_images/matplotlib_{ver}'.format(ver=matplotlib.__version__).replace('.', '_')
os.path.normpath(os.path.join(TEST_TEMP_DIR,
'image_compare_tests')))
self.filename = kwargs.pop('filename', None)
self.extensions = kwargs.pop('extensions', ['png'])
self.savefig_kwargs = kwargs.pop('savefig_kwargs', {'dpi': 80})
self.tolerance = kwargs.pop('tolerance', 2)
self.fig_size = kwargs.pop('fig_size', None)
self.is_compare_image = self.to_bool(
os.getenv('MTPY_TEST_COMPARE_IMAGE', False))
self._logger = MtPyLog().get_mtpy_logger(__name__)
self._logger.info("Image Comparison Test: {stat}".format(
stat="ENABLED" if self.is_compare_image else "DISABLED"))
self.on_fail = kwargs.pop('on_fail', None)
self.on_compare_fail = kwargs.pop("on_compare_fail", None)
self.on_empty_image = kwargs.pop("on_empty_image", None)
ImageCompare._thread_lock.acquire()
if not os.path.exists(self.result_dir):
os.mkdir(self.result_dir)
ImageCompare._thread_lock.release()
def reset_matplotlib():
# save some important params
interactive = matplotlib.rcParams['interactive']
backend = matplotlib.rcParams['backend']
# reset
matplotlib.rcdefaults() # reset the rcparams to default
# recover
matplotlib.rcParams['backend'] = backend
matplotlib.rcParams['interactive'] = interactive
logger = MtPyLog().get_mtpy_logger(__name__)
logger.info("Testing using matplotlib backend {}".format(matplotlib.rcParams['backend']))
def __init__(self, edilist=None, mt_objs=None, outdir=None, ptol=0.05):
""" constructor
:param edilist: a list of edifiles with full path, for read-only
:param outdir: computed result to be stored in outdir
:param ptol: period tolerance considered as equal, default 0.05 means 5 percent
this param controls what freqs/periods are grouped together:
10pct may result more double counting of freq/period data than 5pct.
eg: E:/Data/MT_Datasets/WenPingJiang_EDI 18528 rows vs 14654 rows
"""
#self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__) # will be EdiCollection
self._logger = MtPyLog.get_mtpy_logger(
__name__) # __name__ will be path.to.module OR __main__
self._logger.setLevel(INFO)
if edilist is not None:
self.edifiles = edilist
self._logger.info("number of edi files in this collection: %s",
len(self.edifiles))
elif mt_objs is not None:
self.edifiles = [mt_obj.fn for mt_obj in mt_objs]
assert len(self.edifiles) > 0
self.num_of_edifiles = len(self.edifiles) # number of stations
print("number of stations/edifiles = %s" % self.num_of_edifiles)
self.ptol = ptol
if edilist is not None:
# if edilist is provided, always create MT objects from the list
self._logger.debug("constructing MT objects from edi files")
self.mt_obj_list = [mt.MT(edi) for edi in self.edifiles]
elif mt_objs is not None:
# use the supplied mt_objs
self.mt_obj_list = list(mt_objs)
else:
self._logger.error("None Edi file set")
# get all frequencies from all edi files
self.all_frequencies = None
self.mt_periods = None
self.all_unique_periods = self._get_all_periods()
self.geopdf = self.create_mt_station_gdf()
self.bound_box_dict = self.get_bounding_box() # in orginal projection
# ensure that outdir is created if not exists.
if outdir is None:
#raise Exception("Error: OutputDir is not specified!!!")
pass
elif not os.path.exists(outdir):
os.mkdir(outdir)
self.outdir = outdir
return
def __init__(self, edilist=None, mt_objs=None, outdir=None, ptol=0.05):
"""
constructor
"""
#self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__) # will be EdiCollection
self._logger = MtPyLog.get_mtpy_logger(
__name__) # __name__ will be path.to.module OR __main__
self._logger.setLevel(INFO)
if edilist is not None:
self.edifiles = edilist
self._logger.info("number of edi files in this collection: %s",
len(self.edifiles))
elif mt_objs is not None:
self.edifiles = [mt_obj.fn for mt_obj in mt_objs]
assert len(self.edifiles) > 0
self.num_of_edifiles = len(self.edifiles) # number of stations
print("number of stations/edifiles = %s" % self.num_of_edifiles)
self.ptol = ptol
if edilist is not None:
# if edilist is provided, always create MT objects from the list
self._logger.debug("constructing MT objects from edi files")
self.mt_obj_list = [mt.MT(edi) for edi in self.edifiles]
elif mt_objs is not None:
# use the supplied mt_objs
self.mt_obj_list = list(mt_objs)
else:
self._logger.error("None Edi file set")
# get all frequencies from all edi files
self.all_frequencies = None
self.mt_periods = None
self.all_unique_periods = self._get_all_periods()
self.geopdf = self.create_mt_station_gdf()
self.bound_box_dict = self.get_bounding_box() # in orginal projection
# ensure that outdir is created if not exists.
if outdir is None:
#raise Exception("Error: OutputDir is not specified!!!")
pass
elif not os.path.exists(outdir):
os.mkdir(outdir)
self.outdir = outdir
return
def __init__(self, parent, file_handler, selected_files):
"""
:param parent:
:type parent: StartQt4
:param file_handler:
:type file_handler: FileHandler
:param selected_files:
:type selected_files: set
"""
QWidget.__init__(self, parent)
self._parent = parent
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self.file_handler = file_handler
self.selected_stations = selected_files
self._current_plot = None
self.ui = Ui_PlotOption()
self.ui.setupUi(self)
# hide cancel button
self.ui.pushButton_cancel.hide()
# populate dropdown menu
self.plotOptions = []
# print VisualizationBase.__subclasses__()
for child in VisualizationBase.__subclasses__():
name = child.plot_name()
if name not in self.plotOptions:
self.plotOptions.append(child)
self.ui.comboBoxSelect_Plot.addItem(name)
else:
raise Exception("Duplicated Plot Name: %s in class %s" % (name, child.__name__))
# busy overlay
self._busy_overlay = BusyOverlay(self)
self._busy_overlay.hide()
# connect signals
self.ui.comboBoxSelect_Plot.currentIndexChanged.connect(self._selection_changed)
self.ui.pushButton_plot.clicked.connect(self._create_plot)
self.ui.pushButton_cancel.clicked.connect(self._cancel_plot)
if VisualizationBase.__subclasses__():
self.ui.comboBoxSelect_Plot.setEnabled(True)
self.ui.comboBoxSelect_Plot.setCurrentIndex(0)
else:
self.ui.comboBoxSelect_Plot.setEnabled(False)
def __init__(self, parent, edi_list, select_period_kwargs, data_kwargs, mesh_kwargs, topo_args, covariance_kwargs,
show=False):
QtCore.QThread.__init__(self, parent)
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self._edi_list = edi_list
self._select_period_kwargs = select_period_kwargs
self._data_kwargs = data_kwargs
self._mesh_kwagrs = mesh_kwargs
self._topo_args = topo_args
self._covariance_kwargs = covariance_kwargs
self.output_dir = self._data_kwargs['save_path']
self.show = show
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self._file_handler = FileHandler()
self._is_file_dialog_opened = False
self.ui = Ui_SmartMT_MainWindow()
# init gui
self.ui.setupUi(self)
self.setup_menu()
# export dialogs
self._export_dialog = ExportDialog(self)
self._export_dialog_modem = ExportDialogModEm(self)
# set station viewer
self._station_viewer = StationViewer(self,
file_handler=self._file_handler)
self._station_viewer.ui.pushButton_plot.clicked.connect(
self.plot_selected_station)
self._station_viewer.selection_changed.connect(
self._selected_station_changed)
self.ui.stackedWidget.addWidget(self._station_viewer)
# set plot option widget
self._plot_option = PlotOption(self, self._file_handler,
self._station_viewer.selected_stations)
self._plot_option.ui.pushButton_back.clicked.connect(
lambda x: self.ui.stackedWidget.setCurrentWidget(self.
_station_viewer))
self._station_viewer.selection_changed.connect(
self._plot_option.data_changed)
self.ui.stackedWidget.addWidget(self._plot_option)
self.ui.stackedWidget.setCurrentWidget(self._station_viewer)
self._subwindow_counter = 0
self._station_summary = None
self._progress_bar = ProgressBar(title='Loading files...')
self.subwindows = {}
# enable export if the activated subwindow is a image window
self.ui.mdiArea.subWindowActivated.connect(self._subwindow_activated)
self.setWindowState(QtCore.Qt.WindowMaximized)
def __init__(self, parent):
"""
set up ui and attributes here
this function sets up the empty gui area for adding gui components that defines information necessary
for visualization
:param parent:
"""
QtCore.QThread.__init__(self, parent)
self._parent = parent
self._mt_objs = None
self._fig = None
self._plotting_object = None
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self._parameter_ui = PlotParameter(self._parent)
# add plot common setting gui
# self._common_ui = CommonSettings(self._parameter_ui)
# apply default common settings
self.default_common_settings()
def __init__(self, grid_dimensions=None, **kwargs):
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self.grid_dimensions = grid_dimensions
self.smoothing_east = 0.3
self.smoothing_north = 0.3
self.smoothing_z = 0.3
self.smoothing_num = 1
self.exception_list = []
self.mask_arr = None
self.save_path = os.getcwd()
self.cov_fn_basename = 'covariance.cov'
self.cov_fn = None
self._header_str = '\n'.join([
'+{0}+'.format('-' * 77),
'| This file defines model covariance for a recursive autoregression scheme. |',
'| The model space may be divided into distinct areas using integer masks. |',
'| Mask 0 is reserved for air; mask 9 is reserved for ocean. Smoothing between |',
'| air, ocean and the rest of the model is turned off automatically. You can |',
'| also define exceptions to override smoothing between any two model areas. |',
'| To turn off smoothing set it to zero. This header is 16 lines long. |',
'| 1. Grid dimensions excluding air layers (Nx, Ny, NzEarth) |',
'| 2. Smoothing in the X direction (NzEarth real values) |',
'| 3. Smoothing in the Y direction (NzEarth real values) |',
'| 4. Vertical smoothing (1 real value) |',
'| 5. Number of times the smoothing should be applied (1 integer >= 0) |',
'| 6. Number of exceptions (1 integer >= 0) |',
'| 7. Exceptions in the for e.g. 2 3 0. (to turn off smoothing between 3 & 4) |',
'| 8. Two integer layer indices and Nx x Ny block of masks, repeated as needed.|',
'+{0}+'.format('-' * 77)
])
for key in list(kwargs.keys()):
if hasattr(self, key):
setattr(self, key, kwargs[key])
else:
self._logger.warn(
"Argument {}={} is not supportted thus not been set.".
format(key, kwargs[key]))
def __init__(self, **kwargs):
"""
Initialise the object
:param kwargs: keyword-value pairs
"""
super(PlotResPhaseMaps, self).__init__(**kwargs)
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
fn_list = kwargs.pop('fn_list', [])
if(len(fn_list)==0): raise NameError('File list is empty.')
# ----set attributes for the class-------------------------
self.mt_list = mtpl.get_mtlist(fn_list=fn_list)
# read in map scale
self.mapscale = kwargs.pop('mapscale', 'deg')
if self.mapscale == 'km':
self.dscale = 1000.
elif self.mapscale == 'm':
self.dscale = 1.
# end if
self.plot_title = kwargs.pop('plot_title', None)
self.fig_dpi = kwargs.pop('fig_dpi', 100)
self.fig_size = kwargs.pop('fig_size', [8, 6])
self.font_size = kwargs.pop('font_size', 7)
self.plot_yn = kwargs.pop('plot_yn', 'y')
self.save_fn = kwargs.pop('save_fn', "/c/tmp")
# By this stage all keyword arguments meant to be set as class properties will have
# been processed. Popping all class properties that still exist in kwargs
self.kwargs = kwargs
for key in vars(self):
self.kwargs.pop(key, None)
self.axesList = []
class gdal_data_check(object):
_has_checked = False
_gdal_data_found = False
_logger = MtPyLog.get_mtpy_logger(__name__)
def __init__(self, func):
"""
this decorator should only be used for the function that requres gdal and gdal-data
to function correctly.
the decorator will check if the GDAL_DATA is set and the path in GDAL_DATA is exist.
If GDAL_DATA is not set, then try to use external program "gdal-config --datadir" to
findout where the data files are installed.
If failed to find the data file, then ImportError will be raised.
:param func: function to be decorated
"""
self._func = func
if not self._has_checked:
self._gdal_data_found = self._check_gdal_data()
self._has_checked = True
if not self._gdal_data_found:
raise ImportError("GDAL_DATA environment variable not set. Please see "
"https://trac.osgeo.org/gdal/wiki/FAQInstallationAndBuilding#HowtosetGDAL_DATAvariable for "
"more information.")
def __call__(self, *args, **kwargs): # pragma: no cover
return self._func(*args, **kwargs)
def _check_gdal_data(self):
if 'GDAL_DATA' not in os.environ:
# gdal data not defined, try to define
from subprocess import Popen, PIPE
self._logger.warn("GDAL_DATA environment variable is not set")
try:
# try to find out gdal_data path using gdal-config
self._logger.info("Trying to find gdal-data path ...")
process = Popen(['gdal-config', '--datadir'], stdout=PIPE)
(output, err) = process.communicate()
exit_code = process.wait()
output = output.strip()
if exit_code == 0 and os.path.exists(output):
os.environ['GDAL_DATA'] = output
self._logger.info("Found gdal-data path: {}".format(output))
return True
else:
self._logger.error(
"\tCannot find gdal-data path. Please find the gdal-data path of your installation and set it to "
"\"GDAL_DATA\" environment variable. Please see "
"https://trac.osgeo.org/gdal/wiki/FAQInstallationAndBuilding#HowtosetGDAL_DATAvariable for "
"more information.")
return False
except Exception:
return False
else:
if os.path.exists(os.environ['GDAL_DATA']):
self._logger.info("GDAL_DATA is set to: {}".format(os.environ['GDAL_DATA']))
return True
else:
self._logger.error("GDAL_DATA is set to: {}, but the path does not exist.".format(os.environ['GDAL_DATA']))
return False
class ImageCompare(object):
"""
- to enable the image comparison tests in the code, add @ImageCompare(**kwargs)
to the function that generates image with matplotlib, by default, the new image
will be saved and check if the image is an empty image. to
- enable the image comparison tests against the baseline image stored, set environment variable
MTPY_TEST_COMPARE_IMAGE = True
"""
def __init__(self, *args, **kwargs):
self.baseline_dir = kwargs.pop(
'baseline_dir',
# 'tests/baseline_images/matplotlib_{ver}'.format(ver=matplotlib.__version__).replace('.', '_')
os.path.normpath(os.path.join(TEST_DIR, 'baseline_images')))
self.result_dir = kwargs.pop(
'result_dir',
# 'tests/result_images/matplotlib_{ver}'.format(ver=matplotlib.__version__).replace('.', '_')
os.path.normpath(os.path.join(TEST_TEMP_DIR,
'image_compare_tests')))
self.filename = kwargs.pop('filename', None)
self.extensions = kwargs.pop('extensions', ['png'])
self.savefig_kwargs = kwargs.pop('savefig_kwargs', {'dpi': 80})
self.tolerance = kwargs.pop('tolerance', 2)
self.fig_size = kwargs.pop('fig_size', None)
self.is_compare_image = self.to_bool(
os.getenv('MTPY_TEST_COMPARE_IMAGE', False))
self._logger = MtPyLog().get_mtpy_logger(__name__)
self._logger.info("Image Comparison Test: {stat}".format(
stat="ENABLED" if self.is_compare_image else "DISABLED"))
self.on_fail = kwargs.pop('on_fail', None)
self.on_compare_fail = kwargs.pop("on_compare_fail", None)
self.on_empty_image = kwargs.pop("on_empty_image", None)
ImageCompare._thread_lock.acquire()
if not os.path.exists(self.result_dir):
os.mkdir(self.result_dir)
ImageCompare._thread_lock.release()
def __call__(self, original):
import matplotlib.pyplot as plt
from matplotlib.testing.compare import compare_images
if self.filename is None:
filename = original.__name__
else:
filename = self.filename
filename = filename.replace('[', '_').replace(']',
'_').replace('/', '_')
filename = filename.strip(' _')
test_suite_name = original.__module__.split('.')[-1]
@functools.wraps(original)
def new_test_func(*args, **kwargs):
if inspect.ismethod(original):
result = original.__func__(*args, **kwargs)
else:
result = original(*args, **kwargs)
for baseline_image, test_image, baseline_rcparams, test_rcparams in self._get_baseline_result_pairs(
test_suite_name, filename, self.extensions):
# save image
fig = plt.gcf()
if fig is not None:
if self.fig_size is not None:
fig.set_size_inches(self.fig_size)
fig.set_tight_layout(True)
fig.savefig(test_image, **self.savefig_kwargs)
# save rcParams
with open(test_rcparams, "w") as rcfile:
from pprint import pprint
rc = matplotlib.rcParams.copy()
rc.pop("datapath") # hide datapath
pprint(rc, rcfile)
import pytest
if self.is_compare_image and os.path.exists(
baseline_image):
msg = compare_images(baseline_image,
test_image,
tol=self.tolerance)
if msg is not None:
msg += "\n"
msg += self.compare_rcParam(
baseline_rcparams, test_rcparams)
# print image in base64
# print("====================")
# print("Expected Image:")
# self._print_image_base64(baseline_image)
# print("Actual Image:")
# self._print_image_base64(test_image)
# print("====================")
self.print_image_testing_note(file=sys.stderr)
if self.on_compare_fail is not None:
self.on_compare_fail()
if self.on_fail is not None:
self.on_fail()
pytest.fail(msg, pytrace=False)
else:
# clearup the image as they are the same with the baseline
os.remove(test_image)
os.remove(test_rcparams)
if not os.listdir(os.path.dirname(test_image)):
os.rmdir(os.path.dirname(test_image))
else:
# checking if the created image is empty
verify(test_image)
actual_image = _png.read_png_int(test_image)
actual_image = actual_image[:, :, :
3] # remove the alpha channel (if exists)
import numpy as np
if np.any(actual_image):
self.print_image_testing_note(file=sys.stderr)
if self.is_compare_image:
pytest.skip(
"Image file not found for comparison test "
"(This is expected for new tests.)\nGenerated Image: "
"\n\t{test}".format(test=test_image))
else:
self._logger.info(
"\nGenerated Image: {test}".format(
test=test_image))
else:
# empty image created
if self.on_empty_image is not None:
self.on_empty_image()
if self.on_fail is not None:
self.on_fail()
pytest.fail(
"Image file not found for comparison test "
"(This is expected for new tests.),"
" but the new image created is empty.")
return result
return new_test_func
def _get_baseline_result_pairs(self, test_suite_name, fname, extensions):
if test_suite_name is None:
baseline = self.baseline_dir
result = self.result_dir
else:
baseline = os.path.join(self.baseline_dir, test_suite_name)
result = os.path.join(self.result_dir, test_suite_name)
if not os.path.exists(baseline):
os.makedirs(baseline)
if not os.path.exists(result):
os.makedirs(result)
for ext in extensions:
name = '{fname}.{ext}'.format(fname=fname, ext=ext)
rc_name = '{fname}_rcParams.txt'.format(fname=fname)
yield os.path.normpath(
os.path.join(baseline, name)), os.path.normpath(
os.path.join(result, name)), os.path.normpath(
os.path.join(baseline, rc_name)), os.path.normpath(
os.path.join(result, rc_name))
@staticmethod
def _print_image_base64(image_file_name):
with open(image_file_name, "rb") as image_file:
image_data = image_file.read()
print(
"<img src=\"data:image/{};base64,{}\" style=\"display:block; max-width:800px; width: auto; height: "
"auto;\" />".format(
os.path.splitext(image_file_name)[1].strip(" ."),
image_data.encode("base64")))
@staticmethod
def print_image_testing_note(file=sys.stdout):
print("====================", file=file)
print("matplotlib Version: " + matplotlib.__version__, file=file)
print(
"NOTE: The test result may be different in different versions of matplotlib.",
file=file)
print("====================", file=file)
@staticmethod
def compare_rcParam(baseline_rcparams, test_rcparams):
# check if the rcParams are different
msg = "Comparing matplotlib.rcParam:\n"
if os.path.isfile(baseline_rcparams):
with open(baseline_rcparams, "r") as fbaserc:
with open(test_rcparams, "r") as ftestrc:
import difflib
lines = [
line
for line in difflib.unified_diff(fbaserc.readlines(),
ftestrc.readlines(),
fromfile="baseline",
tofile="test",
n=0)
]
if lines:
msg += " Found differences:\n " + " ".join(
lines)
else:
msg += " NO differences found."
else:
msg += " Baseline rcParams file not found."
return msg
def to_bool(self, param):
if isinstance(param, str) and param:
param = param.lower()
if param in ('true', '1', 't'):
return True
elif param in ('false', 'f', '0'):
return False
else:
return bool(param)
from tests import TEST_DIR, make_temp_dir, TEST_TEMP_DIR
if os.name == "posix" and 'DISPLAY' not in os.environ:
print("MATPLOTLIB: No Display found, using non-interactive svg backend",
file=sys.stderr)
matplotlib.use('svg')
import matplotlib.pyplot as plt
MTPY_TEST_HAS_DISPLAY = False
else:
# matplotlib.use('svg')
import matplotlib.pyplot as plt
MTPY_TEST_HAS_DISPLAY = True
plt.ion()
MtPyLog.get_mtpy_logger(__name__).info(
"Testing using matplotlib backend {}".format(
matplotlib.rcParams['backend']))
def reset_matplotlib():
# save some important params
interactive = matplotlib.rcParams['interactive']
backend = matplotlib.rcParams['backend']
# reset
matplotlib.rcdefaults() # reset the rcparams to default
# recover
matplotlib.rcParams['backend'] = backend
matplotlib.rcParams['interactive'] = interactive
logger = MtPyLog().get_mtpy_logger(__name__)
logger.info("Testing using matplotlib backend {}".format(
matplotlib.rcParams['backend']))
import matplotlib.pyplot as plt
import numpy as np
import mtpy.core.mt as mt
from mtpy.imaging.penetration import get_index, load_edi_files, Depth3D
from mtpy.utils.decorator import deprecated
from mtpy.utils.mtpylog import MtPyLog
# mpl.rcParams['lines.linewidth'] = 2
# mpl.rcParams['lines.color'] = 'r'
# mpl.rcParams['figure.figsize'] = [20, 10]
# get a logger object for this module, using the utility class MtPyLog to
# config the logger
_logger = MtPyLog.get_mtpy_logger(__name__)
# logger =
# MtPyLog(path2configfile='logging.yml').get_mtpy_logger(__name__) #
# specific
# This is the major function to be maintained!!!
# use the Zcompotent=[det, zxy, zyx]
def plot_latlon_depth_profile(edi_dir,
period,
zcomponent='det',
showfig=True,
savefig=True,
savepath=None,
fig_dpi=400,
"""
import os
import sys
import csv
import glob
import numpy as np
import mtpy.core.mt as mt
import mtpy.imaging.mtplottools as mtplottools
from mtpy.utils.decorator import deprecated
from mtpy.utils.matplotlib_utils import gen_hist_bins
from logging import DEBUG, INFO, ERROR, WARNING
from mtpy.utils.mtpylog import MtPyLog
_logger = MtPyLog.get_mtpy_logger(
__name__) # __name__ will be path.to.module OR __main__
_logger.setLevel(INFO)
def get_resistivity_from_edi_file(edifile, rholist=['det']):
"""Compute the resistivity values of an edi file
:param edifile: input edifile
:param rholist: flag the method to compute penetration depth: det zxy zyx
:return: a tuple:(station_lat, statoin_lon, periods_list, pendepth_list)
"""
_logger.debug("processing the edi file %s", edifile)
mt_obj = mt.MT(edifile)
zeta = mt_obj.Z # the attribute Z represent the impedance tensor 2X2 matrix
freqs = zeta.freq # frequencies
# define mtpy release version below # see https://packaging.python.org/guides/single-sourcing-package-version/ __version__ = "1.1.3" # load mtpy default logging config from mtpy.utils.mtpylog import MtPyLog MtPyLog.load_configure()
TEST_DIR = os.path.normpath(os.path.abspath(os.path.dirname(__file__)))
TEST_TEMP_DIR = os.path.normpath(os.path.join(TEST_DIR, "temp"))
if not os.path.isdir(TEST_TEMP_DIR):
os.mkdir(TEST_TEMP_DIR)
def make_temp_dir(dir_name, base_dir=TEST_TEMP_DIR):
_temp_dir = os.path.normpath(os.path.join(base_dir, dir_name))
if os.path.isdir(_temp_dir):
shutil.rmtree(_temp_dir)
os.mkdir(_temp_dir)
return _temp_dir
EDI_DATA_DIR = os.path.normpath(
os.path.join(TEST_MTPY_ROOT, 'examples/data/edi_files'))
EDI_DATA_DIR2 = os.path.normpath(
os.path.join(TEST_MTPY_ROOT, 'examples/data/edi_files_2'))
AUS_TOPO_FILE = os.path.normpath(
os.path.join(TEST_MTPY_ROOT, 'examples/data/AussieContinent_etopo1.asc'))
SAMPLE_DIR = os.path.normpath(
os.path.join(
TEST_MTPY_ROOT,
'examples/model_files')) # r'E:\Githubz\mtpy\examples\model_files'
M2D_DIR = os.path.normpath(
os.path.join(TEST_MTPY_ROOT, 'examples/data/mare2dem'))
# set test logging configure
MtPyLog.load_configure(os.path.join(TEST_DIR, "logging.yml"))
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from mpl_toolkits.axes_grid1 import make_axes_locatable
from shapely.geometry import Point, Polygon, LineString, LinearRing
from mtpy.core.edi_collection import EdiCollection
from mtpy.utils.mtpy_decorator import deprecated
from mtpy.utils.mtpylog import MtPyLog
from mtpy.utils.edi_folders import recursive_glob
mpl.rcParams['lines.linewidth'] = 2
# mpl.rcParams['lines.color'] = 'r'
mpl.rcParams['figure.figsize'] = [10, 6]
_logger = MtPyLog.get_mtpy_logger(__name__) # logger inside this file/module
_logger.setLevel(logging.DEBUG) # set your logger level
class ShapefilesCreator(EdiCollection):
""" Extend the EdiCollection parent class,
create phase tensor and tipper shapefiles for a list of edifiles
:param edifile_list: [path2edi,...]
:param outdir: path2output dir, where the shp file will be written.
:param orig_crs = {'init': 'epsg:4283'} # GDA94
"""
def __init__(self, edifile_list, outdir, epsg_code=4326):
"""
loop through a list of edi files, create required shapefiles
def __init__(self):
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self._data = None
self._fig = None
def __init__(self):
self._station_dict = dict()
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
self._file_dict = dict()
self._group_dict = dict()
self._file_to_groups = dict()
# remove the window
del self._main_ui.subwindows[title]
else:
subwindow.hide()
@deprecated(
"This is an dummy action that should be used only when the required function hasn't been implemented"
)
def dummy_action(self, *args, **kwargs):
pass
if __name__ == "__main__":
if __debug__:
MtPyLog.load_configure(
os.path.join(os.path.abspath("tests"),
"logging.yml")) # debug only
# handle uncaught exceptions to log as since PYQT5.5 will not display any uncaught exceptions
# ref: http://pyqt.sourceforge.net/Docs/PyQt5/incompatibilities.html#unhandled-python-exceptions
logger = MtPyLog.get_mtpy_logger(__name__)
sys.excepthook = lambda exc_type, exc_value, exc_trace: logger.error(
"Uncaught exception", exc_info=(exc_type, exc_value, exc_trace))
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
smartMT = StartGUI()
smartMT.show()
# hack to fix the "python has stopped working" error,
# the possible cause is the QtGui4.dll crashes, need to test it on linux environment
def __init__(self, parent=None):
QWizard.__init__(self, parent)
self.ui = Ui_Wizard_esport_modem()
self.ui.setupUi(self)
self._logger = MtPyLog.get_mtpy_logger(self.__class__.__name__)
# setup gui
# self.setWindowTitle("ModEM input file generator")
# add math label
self._math_label_sign_impedances = MathTextLabel(
self,
self._math_label_sign_text.format(
"+" if self.ui.radioButton_impedance_sign_plus.isChecked() else "-"
)
)
self.ui.horizontalLayout_sign_impedance.addWidget(self._math_label_sign_impedances)
self._math_label_sign_vertical = MathTextLabel(
self,
self._math_label_sign_text.format(
"+" if self.ui.radioButton_vertical_sign_plus.isChecked() else "-"
)
)
self.ui.horizontalLayout_sign_vertical.addWidget(self._math_label_sign_vertical)
# add math formulae of each error type
self._math_label_elbert = MathTextLabel(
self,
"$E_{egbert}=e_Z\\times |Z_{xy}\\times Z_{yx}|^\\frac{1}{2}$",
)
self.ui.verticalLayout_error_types.addWidget(self._math_label_elbert)
self._math_label_mean = MathTextLabel(self, "$E_{mean} = e_Z\\times mean(|Z_{xy}, Z_{yx}|)$")
self._math_label_mean.setHidden(True)
self.ui.verticalLayout_error_types.addWidget(self._math_label_mean)
self._math_label_eigen = MathTextLabel(self, "$E_{eigen} = e_Z\\times eigenvalues(Z)$")
self._math_label_eigen.setHidden(True)
self.ui.verticalLayout_error_types.addWidget(self._math_label_eigen)
self._math_label_median = MathTextLabel(self, "$E_{median} = e_Z\\times median(|Z_{xx},Z_{xy},Z_{yx},Z_{yy}|)$")
self._math_label_median.setHidden(True)
self.ui.verticalLayout_error_types.addWidget(self._math_label_median)
self._math_label_error_type_note = MathTextLabel(self, "where $E$ is the error and $e$ is the error value (z).")
self.ui.verticalLayout_error_types.addWidget(self._math_label_error_type_note)
# add period selection
self._period_select_ui = FrequencySelection(
self.ui.wizardPage_period,
show_period=True,
show_frequency=False,
allow_range_select=True,
select_multiple=True
)
self._period_select_ui.ui.checkBox_show_existing.setChecked(True)
self._period_select_ui.setEnabled(False)
self._period_select_ui.setHidden(True)
self.ui.wizardPage_period.layout().addWidget(self._period_select_ui)
self._period_select_from_file_ui = FrequencySelectionFromFile(self.ui.wizardPage_period)
self._period_select_from_file_ui.setEnabled(False)
self._period_select_from_file_ui.setHidden(True)
self.ui.wizardPage_period.layout().addWidget(self._period_select_from_file_ui)
# add rotation
self._rotation_ui = Rotation(self.ui.wizardPage_data)
self._rotation_ui.setTitle('Data Rotation Angle')
self.ui.horizontalLayout_data.addWidget(self._rotation_ui)
self._mesh_rotation_ui = Rotation(self.ui.wizardPage_mesh)
self._mesh_rotation_ui.setTitle('Mesh Rotation Angle')
self.ui.gridLayout_mesh.addWidget(self._mesh_rotation_ui)
# hide error percents
self._component_error_type_z_changed()
# hide bottom in vertical mesh as it is not used in mesh gen
self.ui.doubleSpinBox_bottom.hide()
self.ui.label_bottom.hide()
# epsg
self.ui.comboBox_epsg.addItems(
[str(epsg) for epsg in sorted(epsg_dict.keys())]
)
# set validators
self._double_validator = QDoubleValidator(-np.inf, np.inf, 1000)
self._double_validator.setNotation(QDoubleValidator.ScientificNotation)
self.ui.lineEdit_resistivity_init.setValidator(self._double_validator)
self.ui.lineEdit_resistivity_air.setValidator(self._double_validator)
self.ui.lineEdit_resistivity_sea.setValidator(self._double_validator)
self._file_validator = FileValidator()
self.ui.comboBox_topography_file.lineEdit().setValidator(self._file_validator)
self.ui.comboBox_topography_file.lineEdit().setMaxLength(256)
self._dir_validator = DirectoryValidator()
self.ui.comboBox_directory.lineEdit().setValidator(self._dir_validator)
# setup directory and dir dialog
self._dir_dialog = QFileDialog(self)
# self._dir_dialog.setDirectory(os.path.expanduser("~"))
self.ui.comboBox_directory.addItem(os.path.expanduser("~"))
self._update_full_output()
# set maximum
# self.ui.spinBox_cell_num_ew.setMaximum(0xFFFFFFFF)
# self.ui.spinBox_cell_num_ns.setMaximum(0xFFFFFFFF)
# tooltip for error types
for index, tooltip in enumerate(self._error_type_z_tool_tip):
self.ui.comboBox_error_type_z.setItemData(index, tooltip, QtCore.Qt.ToolTipRole)
self.ui.comboBox_error_type_zxx.setItemData(index, tooltip, QtCore.Qt.ToolTipRole)
self.ui.comboBox_error_type_zxy.setItemData(index, tooltip, QtCore.Qt.ToolTipRole)
self.ui.comboBox_error_type_zyx.setItemData(index, tooltip, QtCore.Qt.ToolTipRole)
self.ui.comboBox_error_type_zyy.setItemData(index, tooltip, QtCore.Qt.ToolTipRole)
# hide parts
self.ui.groupBox_component_error_types.setHidden(True)
self.ui.label_component_error_types.setHidden(True)
# connect signals
self.ui.radioButton_impedance_sign_plus.toggled.connect(
lambda is_checked: self._math_label_sign_impedances.set_math_text(
self._math_label_sign_text.format("+" if is_checked else "-"))
)
self.ui.radioButton_vertical_sign_plus.toggled.connect(
lambda is_checked: self._math_label_sign_vertical.set_math_text(
self._math_label_sign_text.format("+" if is_checked else "-")
)
)
self.ui.radioButton_impedance_full.toggled.connect(self._impedance_full_toggled)
self.ui.radioButton_impedance_off_diagonal.toggled.connect(self._impedance_off_diagonal_toggled)
self.ui.radioButton_impedance_none.toggled.connect(self._impedance_none_toggled)
self.ui.radioButton_vertical_full.toggled.connect(self._vertical_full_toggled)
self.ui.comboBox_error_type_z.currentIndexChanged.connect(self._error_type_z_changed)
for component in self._impedance_components:
combobox = getattr(self.ui, 'comboBox_error_type_{}'.format(component))
checkbox = getattr(self.ui, 'checkBox_{}'.format(component))
combobox.currentIndexChanged.connect(self._component_error_type_z_changed)
checkbox.toggled.connect(self._error_component_checkbox_toggled(combobox))
self.ui.comboBox_output_name.currentIndexChanged.connect(self._update_full_output)
self.ui.comboBox_output_name.lineEdit().editingFinished.connect(self._output_name_changed)
self.ui.comboBox_output_name.editTextChanged.connect(self._update_full_output)
self.ui.comboBox_directory.currentIndexChanged.connect(self._update_full_output)
self.ui.comboBox_directory.lineEdit().editingFinished.connect(self._output_dir_changed)
self.ui.comboBox_directory.editTextChanged.connect(self._update_full_output)
self.ui.pushButton_browse.clicked.connect(self._browse)
# self.ui.doubleSpinBox_target_depth.valueChanged.connect(self._target_depth_changed)
self.ui.doubleSpinBox_target_depth.lineEdit().editingFinished.connect(self._target_depth_changed)
self.ui.doubleSpinBox_bottom.lineEdit().editingFinished.connect(self._bottom_changed)
# self.ui.doubleSpinBox_bottom.valueChanged.connect(self._bottom_changed)
# self.ui.comboBox_topography_file.currentIndexChanged.connect()
self.ui.comboBox_topography_file.lineEdit().editingFinished.connect(
self._topography_file_changed
)
self.ui.pushButton_browse_topography_file.clicked.connect(self._browse_topography_file)
self.ui.pushButton_test.clicked.connect(self._test_button_clicked)
self.ui.checkBox_cell_num_ew.stateChanged.connect(
lambda p_int: self.ui.spinBox_cell_num_ew.setEnabled(p_int != 0)
)
self.ui.checkBox_cell_num_ns.stateChanged.connect(
lambda p_int: self.ui.spinBox_cell_num_ns.setEnabled(p_int != 0)
)
self.ui.checkBox_component_error_types.setEnabled(False) # disabled due to missing implementations todo implement this option in modem.Data
self.ui.checkBox_component_error_types.toggled.connect(self._component_error_type_toggled)
self.ui.radioButton_select_period_percent.toggled.connect(
lambda checked: self.ui.doubleSpinBox_select_period_percent.setEnabled(checked))
self.ui.radioButton_select_period.toggled.connect(
lambda checked: self._period_select_ui.setEnabled(checked))
self.ui.radioButton_select_period.toggled.connect(
lambda checked: self._period_select_ui.setHidden(not checked))
self.ui.radioButton_select_by_file.toggled.connect(
lambda checked: self._period_select_from_file_ui.setEnabled(checked))
self.ui.radioButton_select_by_file.toggled.connect(
lambda checked: self._period_select_from_file_ui.setHidden(not checked))
# register fields
self.ui.wizardPage_output.registerField('output_path*', self.ui.lineEdit_full_output)
self.ui.wizardPage_topography.registerField('topography_file*', self.ui.comboBox_topography_file)
self.ui.wizardPage_topography.registerField('sea_resistivity',
self.ui.lineEdit_resistivity_sea)
self.ui.wizardPage_topography.registerField('air_resistivity',
self.ui.lineEdit_resistivity_air)
# attribute
self._mt_objs = None
self._progress_bar = ProgressBar()
