pylot/QtPyLoT.py
Sebastian Wehling-Benatelli 27ecdb899b plotting scheme restructured: the same widgets are used for plotting the overview and the station plots, the plotting method has been moved to the widget side which makes more sense than having it on the data side;
new functions in utils module: prepTimeAxis returns a proper time axis array for a given start time and an obspy trace; getGlobalTimes returns the minimum start time and the maximum end time (edges) of a given obspy stream object
2015-03-29 08:07:46 +02:00

538 lines
21 KiB
Python
Executable File

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
PyLoT: Main program
===================
PyLoT is a seismic data processing software capable of picking seismic
phases (symmetric and asymmetric error assignment), exporting these to
several common phase data formats and post process the data, e.g. locating
events, via external localization software.
Additionally PyLoT is meant as an interface to autoPyLoT which can
automatically pick seismic phases, if the parameters have properly been
chosen for the particular data set.
Some icons are out of a free of charge icon set, which can be found here:
https://www.iconfinder.com/iconsets/flavour
:author:
Sebastian Wehling-Benatelli
:copyright:
The PyLoT Development Team (https://ariadne.geophysik.rub.de/trac/PyLoT)
:license:
GNU Lesser General Public License, Version 3
(http://www.gnu.org/copyleft/lesser.html)
"""
import sys
from PySide.QtCore import QCoreApplication, QSettings, Signal, QFile, \
QFileInfo, Qt
from PySide.QtGui import QMainWindow, QInputDialog, QIcon, QFileDialog, \
QWidget, QHBoxLayout, QStyle, QKeySequence, QLabel, QFrame, QAction, \
QDialog, QErrorMessage, QApplication
from obspy.core import UTCDateTime
from pylot.core.read import Data, FilterOptions
from pylot.core.util import _getVersionString, FILTERDEFAULTS, fnConstructor, \
checkurl, FormatError, FilterOptionsDialog, \
NewEventDlg, createEvent, MPLWidget, PropertiesDlg, HelpForm, \
DatastructureError, createAction, getLogin, createCreationInfo, PickDlg
from pylot.core.util.structure import DATASTRUCTURE
import qrc_resources
# Version information
__version__ = _getVersionString()
class MainWindow(QMainWindow):
closing = Signal()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.createAction = createAction
self.dirty = False
settings = QSettings()
if settings.value("user/FullName", None) is None:
fulluser = QInputDialog.getText(self, "Enter Name:", "Full name")
settings.setValue("user/FullName", fulluser)
settings.setValue("user/Login", getLogin())
if settings.value("agency_id", None) is None:
agency = QInputDialog.getText(self, "Enter authority name (e.g. BUG):", "Authority")
settings.setValue("agency_id", agency)
self.recentEvents = settings.value("data/recentEvents", [])
self.fnames = None
self.dataStructure = DATASTRUCTURE[
settings.value("data/Structure", "PILOT")]()
self.seismicPhase = str(settings.value("phase", "P"))
self.dispComponent = str(settings.value("plotting/dispComponent", "Z"))
if settings.value("data/dataRoot", None) is None:
dirname = QFileDialog().getExistingDirectory(
caption='Choose data root ...')
settings.setValue("data/dataRoot", dirname)
settings.sync()
self.filteroptions = {}
self.pickDlgs = {}
# UI has to be set up before(!) children widgets are about to show up
self.setupUi()
# initialize event data
if self.recentEvents:
lastEvent = self.getLastEvent()
self.data = Data(self, lastEvent)
else:
self.data = Data(self)
# load and display waveform data
self.loadWaveformData()
self.dirty = False
self.loadData()
self.updateFilterOptions()
def setupUi(self):
try:
self.startTime = min(
[tr.stats.starttime for tr in self.data.wfdata])
except:
self.startTime = UTCDateTime()
self.setWindowTitle("PyLoT - do seismic processing the python way")
self.setWindowIcon(QIcon(":/icon.ico"))
xlab = self.startTime.strftime('seconds since %Y/%m/%d %H:%M:%S (%Z)')
_widget = QWidget()
_widget.setCursor(Qt.CrossCursor)
_layout = QHBoxLayout()
plottitle = "Overview: {0} components ".format(self.getComponent())
# create central matplotlib figure canvas widget
self.DataPlot = MPLWidget(parent=self, xlabel=xlab, ylabel=None,
title=plottitle)
self.DataPlot.mpl_connect('button_press_event', self.pickOnStation)
_layout.addWidget(self.DataPlot)
openIcon = self.style().standardIcon(QStyle.SP_DirOpenIcon)
quitIcon = self.style().standardIcon(QStyle.SP_MediaStop)
saveIcon = self.style().standardIcon(QStyle.SP_DriveHDIcon)
helpIcon = self.style().standardIcon(QStyle.SP_DialogHelpButton)
newIcon = self.style().standardIcon(QStyle.SP_FileIcon)
pickIcon = QIcon(':/pick.png')
newEventAction = self.createAction(self, "&New event ...",
self.createNewEvent,
QKeySequence.New, newIcon,
"Create a new event.")
openEventAction = self.createAction(self, "&Open event ...",
self.loadData, QKeySequence.Open,
openIcon, "Open an event.")
openEventAction.setData(None)
saveEventAction = self.createAction(self, "&Save event ...",
self.saveData, QKeySequence.Save,
saveIcon, "Save actual event data.")
openWFDataAction = self.createAction(self, "Open &waveforms ...",
self.loadWaveformData,
"Ctrl+W", QIcon(":/wfIcon.png"),
"""Open waveform data (event will
be closed).""")
selectStation = self.createAction(self, "Select station",
self.pickOnStation, "Alt+P", pickIcon,
"Select a station from overview "
"plot for picking")
prefsEventAction = self.createAction(self, "Preferences",
self.PyLoTprefs,
QKeySequence.Preferences,
QIcon(None),
"Edit PyLoT app preferences.")
quitAction = self.createAction(self, "&Quit",
QCoreApplication.instance().quit,
QKeySequence.Close, quitIcon,
"Close event and quit PyLoT")
self.filterAction = self.createAction(self, "&Filter ...", self.filterWaveformData,
"Ctrl+F", QIcon(":/filter.png"),
"""Toggle un-/filtered waveforms
to be displayed, according to the
desired seismic phase.""", True)
filterEditAction = self.createAction(self, "&Filter parameter ...",
self.adjustFilterOptions,
"Alt+F", QIcon(None),
"""Adjust filter parameters.""")
self.selectPAction = self.createAction(self, "&P", self.alterPhase, "Alt+P",
QIcon(":/picon.png"),
"Toggle P phase.", True)
self.selectSAction = self.createAction(self, "&S", self.alterPhase, "Alt+S",
QIcon(":/sicon.png"),
"Toggle S phase", True)
printAction = self.createAction(self, "&Print event ...",
self.printEvent, QKeySequence.Print,
QIcon(":/printer.png"),
"Print waveform overview.")
helpAction = self.createAction(self, "&Help ...", self.helpHelp,
QKeySequence.HelpContents, helpIcon,
"""Show either the documentation
homepage (internet connection available),
or shipped documentation files.""")
self.fileMenu = self.menuBar().addMenu('&File')
self.fileMenuActions = (newEventAction, openEventAction,
saveEventAction, openWFDataAction, None,
prefsEventAction, quitAction)
self.fileMenu.aboutToShow.connect(self.updateFileMenu)
self.updateFileMenu()
self.editMenu = self.menuBar().addMenu('&Edit')
editActions = (self.filterAction, filterEditAction, None,
self.selectPAction, self.selectSAction, None,
printAction)
self.addActions(self.editMenu, editActions)
self.helpMenu = self.menuBar().addMenu('&Help')
helpActions = (helpAction, )
self.addActions(self.helpMenu, helpActions)
fileToolBar = self.addToolBar("FileTools")
fileToolActions = (newEventAction, openEventAction, saveEventAction)
fileToolBar.setObjectName("FileTools")
self.addActions(fileToolBar, fileToolActions)
phaseToolBar = self.addToolBar("PhaseTools")
phaseToolActions = (self.selectPAction, self.selectSAction)
phaseToolBar.setObjectName("PhaseTools")
self.addActions(phaseToolBar, phaseToolActions)
pickToolBar = self.addToolBar("PickTools")
pickToolActions = (selectStation, )
pickToolBar.setObjectName("PickTools")
self.addActions(pickToolBar, pickToolActions)
self.eventLabel = QLabel()
self.eventLabel.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
status = self.statusBar()
status.setSizeGripEnabled(False)
status.addPermanentWidget(self.eventLabel)
status.showMessage("Ready", 500)
_widget.setLayout(_layout)
_widget.showFullScreen()
self.setCentralWidget(_widget)
def updateFileMenu(self):
self.fileMenu.clear()
for action in self.fileMenuActions[:-1]:
if action is None:
self.fileMenu.addSeparator()
else:
self.fileMenu.addAction(action)
try:
current = self.data.getID()
except AttributeError:
current = None
recentEvents = []
for eventID in self.recentEvents:
fname = fnConstructor(eventID)
if eventID != current and QFile.exists(fname):
recentEvents.append(eventID)
recentEvents.reverse()
self.recentEvents = recentEvents[0:5]
settings = QSettings()
settings.setValue()
if recentEvents:
for i, eventID in enumerate(recentEvents):
fname = fnConstructor(eventID)
action = QAction(QIcon(":/icon.png"),
"&{0} {1}".format(i + 1,
QFileInfo(fname).fileName()),
self)
action.setData(fname)
self.connect(action, Signal("triggered()"),
self.loadData)
self.fileMenu.addAction(action)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.fileMenuActions[-1])
def loadData(self, fname=None):
if fname is None:
try:
self.data = Data(self, evtdata=self.fname)
except AttributeError:
action = self.sender()
if isinstance(action, QAction):
if action.data() is None:
filt = "Supported event formats (*.mat *.qml *.xml *.kor *.evt)"
caption = "Open an event file"
fname = QFileDialog().getOpenFileName(self,
caption=caption,
filter=filt)
self.fname = fname[0]
else:
self.fname = unicode(action.data().toString())
if not self.okToContinue():
return
else:
self.fname = fname
self.data = Data(self, evtdata=self.fname)
def getLastEvent(self):
return self.recentEvents[0]
def getWFFnames(self):
try:
evt = self.getData().getEvtData()
if evt.picks:
for pick in evt.picks:
try:
if pick.waveform_id is not None:
fname = pick.waveform_id.getSEEDstring()
if fname not in self.fnames:
self.fnames.append(fname)
except:
continue
else:
if self.dataStructure:
searchPath = self.dataStructure.expandDataPath()
fnames = QFileDialog.getOpenFileNames(self,
"Select waveform "
"files:",
dir=searchPath)
self.fnames = fnames[0]
else:
raise DatastructureError('not specified')
return self.fnames
except DatastructureError, e:
print e
props = PropertiesDlg(self)
if props.exec_() == QDialog.Accepted:
return self.getWFFnames()
else:
return
def saveData(self):
settings = QSettings()
exform = settings.value('data/exportFormat', 'None')
try:
self.data.exportEvent(self.fname, exform)
except FormatError:
return False
except AttributeError, e:
print 'warning: {0}'.format(e)
fname = QFileDialog.getSaveFileName(self, 'Save event')
fname = fname[0]
self.data.exportEvent(fname, exform)
return True
def getComponent(self):
return self.dispComponent
def getData(self):
return self.data
def getPlotWidget(self):
return self.DataPlot
def getWFID(self, event):
ycoord = event.ydata
statID = int(round(ycoord))
return statID
def addActions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def okToContinue(self):
if self.dirty:
return self.saveData()
return True
def loadWaveformData(self):
if self.fnames and self.okToContinue():
self.dirty = True
self.data.setWFData(self.fnames)
elif self.fnames is None and self.okToContinue():
self.data.setWFData(self.getWFFnames())
self.plotWaveformData()
def plotWaveformData(self):
zne_text = {'Z': 'vertical', 'N': 'north-south', 'E': 'east-west'}
comp = self.getComponent()
title = 'overview: {0} components'.format(zne_text[comp])
wfst = self.getData().getWFData().select(component=comp)
self.getPlotWidget().plotWFData(wfdata=wfst, title=title)
def filterWaveformData(self):
if self.getData():
def hasfreq(kwargs):
for key in kwargs.keys():
if not key.startswith('freq'):
return True
return False
if self.filterAction.isChecked():
kwargs = {}
freq = self.getFilterOptions().getFreq()
if freq is not None and len(freq) > 1:
kwargs['freqmin'] = freq[0]
kwargs['freqmax'] = freq[1]
elif freq is not None and len(freq) == 1:
kwargs['freq'] = freq
if hasfreq(kwargs):
kwargs['type'] = self.getFilterOptions().getFilterType()
kwargs['corners'] = self.getFilterOptions().getOrder()
self.getData().filterWFData(kwargs)
else:
self.getData().resetWFData()
self.plotWaveformData()
def adjustFilterOptions(self):
filteroptions = None
fstring = "Filter Options ({0})".format(self.getSeismicPhase())
filterDlg = FilterOptionsDialog(titleString=fstring,
parent=self,
filterOptions=self.getFilterOptions())
if filterDlg.exec_():
filteroptions = filterDlg.getFilterOptions()
self.setFilterOptions(filteroptions)
def getFilterOptions(self):
try:
return self.filteroptions[self.getSeismicPhase()]
except AttributeError, e:
print e
return FilterOptions(None, None, None)
def getFilters(self):
return self.filteroptions
def setFilterOptions(self, filterOptions, seismicPhase=None):
if seismicPhase is None:
self.getFilters()[self.getSeismicPhase()] = filterOptions
else:
self.getFilters()[seismicPhase] = filterOptions
def updateFilterOptions(self):
try:
settings = QSettings()
if settings.value("filterdefaults", None) is None and not self.getFilters():
for key, value in FILTERDEFAULTS.iteritems():
self.setFilterOptions(FilterOptions(**value), key)
elif settings.value("filterdefaults", None) is not None:
for key, value in settings.value("filterdefaults"):
self.setFilterOptions(FilterOptions(**value), key)
except Exception, e:
self.updateStatus('Error ...')
emsg = QErrorMessage(self)
emsg.showMessage('Error: {0}'.format(e))
else:
self.updateStatus('Filter loaded ... '
'[{0}: {1} Hz]'.format(self.getFilterOptions().getFilterType(), self.getFilterOptions().getFreq()))
if self.filterAction.isChecked():
self.filterWaveformData()
def getSeismicPhase(self):
return self.seismicPhase
def getStationName(self, wfID):
return self.getPlotWidget().getPlotDict()[wfID]
def alterPhase(self):
pass
def setSeismicPhase(self, phase):
self.seismicPhase = self.seismicPhaseButtonGroup.getValue()
self.updateStatus('Seismic phase changed to '
'{0}'.format(self.getSeismicPhase()))
def pickOnStation(self, event):
wfID = self.getWFID(event)
station = self.getStationName(wfID)
print 'picking on station {0}'.format(station)
data = self.getData().getWFData()
pickDlg = PickDlg(self, data=data.select(station=station),
station=station)
if pickDlg.exec_():
print 'picks accepted'
else:
print 'picks not saved and closed dialog'
def updateStatus(self, message):
self.statusBar().showMessage(message, 5000)
if self.getData() is not None:
if not self.getData().isNew():
self.setWindowTitle(
"PyLoT - processing event %s[*]" % self.getData().getID())
elif self.getData().isNew():
self.setWindowTitle("PyLoT - New event [*]")
else:
self.setWindowTitle(
"PyLoT - seismic processing the python way[*]")
self.setWindowModified(self.dirty)
def printEvent(self):
pass
def createNewEvent(self):
if self.okToContinue():
new = NewEventDlg()
if new.exec_() != QDialog.Rejected:
evtpar = new.getValues()
cinfo = createCreationInfo(agency_id=self.agency)
event = createEvent(evtpar['origintime'])
self.data = Data(self, evtdata=createEvent(**evtpar))
self.dirty = True
def closeEvent(self, event):
if self.okToContinue():
self.closing.emit()
QMainWindow.closeEvent(self, event)
def PyLoTprefs(self):
props = PropertiesDlg(self)
if props.exec_():
return
def helpHelp(self):
if checkurl():
form = HelpForm(
'https://ariadne.geophysik.ruhr-uni-bochum.de/trac/PyLoT/wiki')
else:
form = HelpForm(':/help.html')
form.show()
def main():
# create the Qt application
pylot_app = QApplication(sys.argv[0])
# set Application Information
pylot_app.setOrganizationName("Ruhr-University Bochum / MAGS2")
pylot_app.setOrganizationDomain("rub.de")
pylot_app.setApplicationName("PyLoT")
pylot_app.setWindowIcon(QIcon(":/icon.ico"))
# create the main window
pylot_form = MainWindow()
# Show main window and run the app
pylot_form.show()
pylot_app.exec_()
if __name__ == "__main__":
sys.exit(main())