Source code for pyrocko.gui.pile_viewer

# http://pyrocko.org - GPLv3
#
# The Pyrocko Developers, 21st Century
# ---|P------/S----------~Lg----------
from __future__ import absolute_import, print_function
from builtins import range

import sys
import os
import time
import calendar
import datetime
import re
import math
import logging
import operator
import copy
from itertools import groupby

import numpy as num
import pyrocko.model
import pyrocko.pile
import pyrocko.shadow_pile
import pyrocko.trace
import pyrocko.util
import pyrocko.plot
import pyrocko.gui.snuffling
import pyrocko.gui.snufflings
import pyrocko.gui.marker_editor

from pyrocko.util import hpfloat, gmtime_x, mystrftime

from .marker import associate_phases_to_events

from .util import (ValControl, LinValControl, Marker, EventMarker,
                   PhaseMarker, make_QPolygonF, draw_label, Label,
                   Progressbars)

from .qt_compat import qc, qg, qw, qgl, qsvg, use_pyqt5

import scipy.stats as sstats
import platform


[docs]def fnpatch(x): if use_pyqt5: return x else: return x, None
if sys.version_info[0] >= 3: qc.QString = str qfiledialog_options = qw.QFileDialog.DontUseNativeDialog | \ qw.QFileDialog.DontUseSheet if platform.mac_ver() != ('', ('', '', ''), ''): macosx = True else: macosx = False logger = logging.getLogger('pyrocko.gui.pile_viewer')
[docs]def detrend(x, y): slope, offset, _, _, _ = sstats.linregress(x, y) y_detrended = y - slope * x - offset return y_detrended, slope, offset
[docs]def retrend(x, y_detrended, slope, offset): return x * slope + y_detrended + offset
[docs]class Global(object): appOnDemand = None
[docs]class NSLC(object): def __init__(self, n, s, l=None, c=None): # noqa self.network = n self.station = s self.location = l self.channel = c
[docs]class m_float(float): def __str__(self): if abs(self) >= 10000.: return '%g km' % round(self/1000., 0) elif abs(self) >= 1000.: return '%g km' % round(self/1000., 1) else: return '%.5g m' % self def __lt__(self, other): if other is None: return True return float(self) < float(other) def __gt__(self, other): if other is None: return False return float(self) > float(other)
[docs]def m_float_or_none(x): if x is None: return None else: return m_float(x)
[docs]def make_chunks(items): """Split a list of integers into sublists of consecutive elements.""" return [list(map(operator.itemgetter(1), g)) for k, g in groupby( enumerate(items), (lambda x: x[1]-x[0]))]
[docs]class deg_float(float): def __str__(self): return '%4.0f' % self
[docs]def deg_float_or_none(x): if x is None: return None else: return deg_float(x)
[docs]class sector_int(int): def __str__(self): return '[%i]' % self
[docs]def num_to_html(num): snum = '%g' % num m = re.match(r'(.+)[eE]([+-]?\d+)$', snum) if m: snum = m.group(1) + ' &times; 10<sup>%i</sup>' % int(m.group(2)) return snum
gap_lap_tolerance = 5.
[docs]class Timer(object): def __init__(self): self._start = None self._stop = None
[docs] def start(self): self._start = os.times()
[docs] def stop(self): self._stop = os.times()
[docs] def get(self): a = self._start b = self._stop if a is not None and b is not None: return tuple([b[i] - a[i] for i in range(5)]) else: return tuple([0.] * 5)
def __sub__(self, other): a = self.get() b = other.get() return tuple([a[i] - b[i] for i in range(5)])
[docs]class Integrator(pyrocko.shadow_pile.ShadowPile):
[docs] def process(self, iblock, tmin, tmax, traces): for trace in traces: trace.ydata = trace.ydata - trace.ydata.mean() trace.ydata = num.cumsum(trace.ydata) return traces
[docs]class ObjectStyle(object): def __init__(self, frame_pen, fill_brush): self.frame_pen = frame_pen self.fill_brush = fill_brush
box_styles = [] box_alpha = 100 for color in 'orange skyblue butter chameleon chocolate plum ' \ 'scarletred'.split(): box_styles.append(ObjectStyle( qg.QPen(qg.QColor(*pyrocko.plot.tango_colors[color+'3'])), qg.QBrush(qg.QColor( *(pyrocko.plot.tango_colors[color+'1'] + (box_alpha,)))), )) sday = 60*60*24. # \ smonth = 60*60*24*30. # | only used as approx. intervals... syear = 60*60*24*365. # / acceptable_tincs = num.array([ 1, 2, 5, 10, 20, 30, 60, 60*5, 60*10, 60*20, 60*30, 60*60, 60*60*3, 60*60*6, 60*60*12, sday, smonth, syear], dtype=num.float)
[docs]def get_working_system_time_range(): now = time.time() hi = now for ignore in range(200): now += syear try: tt = time.gmtime(now) time.strftime('', tt) hi = now except Exception: break now = time.time() lo = now for ignore in range(200): now -= syear try: tt = time.gmtime(now) time.strftime('', tt) lo = now except Exception: break return lo, hi
working_system_time_range = get_working_system_time_range()
[docs]def is_working_time(t): return working_system_time_range[0] <= t and \ t <= working_system_time_range[1]
[docs]def fancy_time_ax_format(inc): l0_fmt_brief = '' l2_fmt = '' l2_trig = 0 if inc < 0.000001: l0_fmt = '.%n' l0_center = False l1_fmt = '%H:%M:%S' l1_trig = 6 l2_fmt = '%b %d, %Y' l2_trig = 3 elif inc < 0.001: l0_fmt = '.%u' l0_center = False l1_fmt = '%H:%M:%S' l1_trig = 6 l2_fmt = '%b %d, %Y' l2_trig = 3 elif inc < 1: l0_fmt = '.%r' l0_center = False l1_fmt = '%H:%M:%S' l1_trig = 6 l2_fmt = '%b %d, %Y' l2_trig = 3 elif inc < 60: l0_fmt = '%H:%M:%S' l0_center = False l1_fmt = '%b %d, %Y' l1_trig = 3 elif inc < 3600: l0_fmt = '%H:%M' l0_center = False l1_fmt = '%b %d, %Y' l1_trig = 3 elif inc < sday: l0_fmt = '%H:%M' l0_center = False l1_fmt = '%b %d, %Y' l1_trig = 3 elif inc < smonth: l0_fmt = '%a %d' l0_fmt_brief = '%d' l0_center = True l1_fmt = '%b, %Y' l1_trig = 2 elif inc < syear: l0_fmt = '%b' l0_center = True l1_fmt = '%Y' l1_trig = 1 else: l0_fmt = '%Y' l0_center = False l1_fmt = '' l1_trig = 0 return l0_fmt, l0_fmt_brief, l0_center, l1_fmt, l1_trig, l2_fmt, l2_trig
[docs]def day_start(timestamp): tt = time.gmtime(int(timestamp)) tts = tt[0:3] + (0, 0, 0) + tt[6:9] return calendar.timegm(tts)
[docs]def month_start(timestamp): tt = time.gmtime(int(timestamp)) tts = tt[0:2] + (1, 0, 0, 0) + tt[6:9] return calendar.timegm(tts)
[docs]def year_start(timestamp): tt = time.gmtime(int(timestamp)) tts = tt[0:1] + (1, 1, 0, 0, 0) + tt[6:9] return calendar.timegm(tts)
[docs]def time_nice_value(inc0): if inc0 < acceptable_tincs[0]: return pyrocko.plot.nice_value(inc0) elif inc0 > acceptable_tincs[-1]: return pyrocko.plot.nice_value(inc0/syear)*syear else: i = num.argmin(num.abs(acceptable_tincs-inc0)) return acceptable_tincs[i]
[docs]class TimeScaler(pyrocko.plot.AutoScaler): def __init__(self): pyrocko.plot.AutoScaler.__init__(self) self.mode = 'min-max'
[docs] def make_scale(self, data_range): assert self.mode in ('min-max', 'off'), \ 'mode must be "min-max" or "off" for TimeScaler' data_min = min(data_range) data_max = max(data_range) is_reverse = (data_range[0] > data_range[1]) mi, ma = data_min, data_max nmi = mi if self.mode != 'off': nmi = mi - self.space*(ma-mi) nma = ma if self.mode != 'off': nma = ma + self.space*(ma-mi) mi, ma = nmi, nma if mi == ma and self.mode != 'off': mi -= 1.0 ma += 1.0 mi = max(working_system_time_range[0], mi) ma = min(working_system_time_range[1], ma) # make nice tick increment if self.inc is not None: inc = self.inc else: if self.approx_ticks > 0.: inc = time_nice_value((ma-mi)/self.approx_ticks) else: inc = time_nice_value((ma-mi)*10.) if inc == 0.0: inc = 1.0 if is_reverse: return ma, mi, -inc else: return mi, ma, inc
[docs] def make_ticks(self, data_range): mi, ma, inc = self.make_scale(data_range) is_reverse = False if inc < 0: mi, ma, inc = ma, mi, -inc is_reverse = True ticks = [] if inc < sday: mi_day = day_start(max(mi, working_system_time_range[0]+sday*1.5)) if inc < 0.001: mi_day = hpfloat(mi_day) base = mi_day+num.ceil((mi-mi_day)/inc)*inc if inc < 0.001: base = hpfloat(base) base_day = mi_day i = 0 while True: tick = base+i*inc if tick > ma: break tick_day = day_start(tick) if tick_day > base_day: base_day = tick_day base = base_day i = 0 else: ticks.append(tick) i += 1 elif inc < smonth: mi_day = day_start(max(mi, working_system_time_range[0]+sday*1.5)) dt_base = datetime.datetime(*time.gmtime(mi_day)[:6]) delta = datetime.timedelta(days=int(round(inc/sday))) if mi_day == mi: dt_base += delta i = 0 while True: current = dt_base + i*delta tick = calendar.timegm(current.timetuple()) if tick > ma: break ticks.append(tick) i += 1 elif inc < syear: mi_month = month_start(max( mi, working_system_time_range[0]+smonth*1.5)) y, m = time.gmtime(mi_month)[:2] while True: tick = calendar.timegm((y, m, 1, 0, 0, 0)) m += 1 if m > 12: y, m = y+1, 1 if tick > ma: break if tick >= mi: ticks.append(tick) else: mi_year = year_start(max( mi, working_system_time_range[0]+syear*1.5)) incy = int(round(inc/syear)) y = int(num.floor(time.gmtime(mi_year)[0]/incy)*incy) while True: tick = calendar.timegm((y, 1, 1, 0, 0, 0)) y += incy if tick > ma: break if tick >= mi: ticks.append(tick) if is_reverse: ticks.reverse() return ticks, inc
[docs]def need_l1_tick(tt, ms, l1_trig): return (0, 1, 1, 0, 0, 0)[l1_trig:] == tt[l1_trig:6] and ms == 0.0
[docs]def tick_to_labels(tick, inc): tt, ms = gmtime_x(tick) l0_fmt, l0_fmt_brief, l0_center, l1_fmt, l1_trig, l2_fmt, l2_trig = \ fancy_time_ax_format(inc) l0 = mystrftime(l0_fmt, tt, ms) l0_brief = mystrftime(l0_fmt_brief, tt, ms) l1, l2 = None, None if need_l1_tick(tt, ms, l1_trig): l1 = mystrftime(l1_fmt, tt, ms) if need_l1_tick(tt, ms, l2_trig): l2 = mystrftime(l2_fmt, tt, ms) return l0, l0_brief, l0_center, l1, l2
[docs]def l1_l2_tick(tick, inc): tt, ms = gmtime_x(tick) l0_fmt, l0_fmt_brief, l0_center, l1_fmt, l1_trig, l2_fmt, l2_trig = \ fancy_time_ax_format(inc) l1 = mystrftime(l1_fmt, tt, ms) l2 = mystrftime(l2_fmt, tt, ms) return l1, l2
[docs]class TimeAx(TimeScaler): def __init__(self, *args): TimeScaler.__init__(self, *args)
[docs] def drawit(self, p, xprojection, yprojection): pen = qg.QPen(qg.QColor(*pyrocko.plot.tango_colors['aluminium5']), 1) p.setPen(pen) font = qg.QFont() font.setBold(True) p.setFont(font) fm = p.fontMetrics() ticklen = 10 pad = 10 tmin, tmax = xprojection.get_in_range() ticks, inc = self.make_ticks((tmin, tmax)) l1_hits = 0 l2_hits = 0 vmin, vmax = yprojection(0), yprojection(ticklen) uumin, uumax = xprojection.get_out_range() first_tick_with_label = None for tick in ticks: umin = xprojection(tick) umin_approx_next = xprojection(tick+inc) umax = xprojection(tick) pinc_approx = umin_approx_next - umin p.drawLine(qc.QPointF(umin, vmin), qc.QPointF(umax, vmax)) l0, l0_brief, l0_center, l1, l2 = tick_to_labels(tick, inc) if tick == 0.0 and tmax - tmin < 3600*24: # hide year at epoch (we assume that synthetic data is shown) if l2: l2 = None elif l1: l1 = None if l0_center: ushift = (umin_approx_next-umin)/2. else: ushift = 0. for l0x in (l0, l0_brief, ''): label0 = l0x rect0 = fm.boundingRect(label0) if rect0.width() <= pinc_approx*0.9: break if uumin+pad < umin-rect0.width()/2.+ushift and \ umin+rect0.width()/2.+ushift < uumax-pad: if first_tick_with_label is None: first_tick_with_label = tick p.drawText(qc.QPointF( umin-rect0.width()/2.+ushift, vmin+rect0.height()+ticklen), label0) if l1: label1 = l1 rect1 = fm.boundingRect(label1) if uumin+pad < umin-rect1.width()/2. and \ umin+rect1.width()/2. < uumax-pad: p.drawText(qc.QPointF( umin-rect1.width()/2., vmin+rect0.height()+rect1.height()+ticklen), label1) l1_hits += 1 if l2: label2 = l2 rect2 = fm.boundingRect(label2) if uumin+pad < umin-rect2.width()/2. and \ umin+rect2.width()/2. < uumax-pad: p.drawText(qc.QPointF( umin-rect2.width()/2., vmin+rect0.height()+rect1.height()+rect2.height() + ticklen), label2) l2_hits += 1 if first_tick_with_label is None: first_tick_with_label = tmin l1, l2 = l1_l2_tick(first_tick_with_label, inc) if -3600.*25 < first_tick_with_label <= 3600.*25 and \ tmax - tmin < 3600*24: # hide year at epoch (we assume that synthetic data is shown) if l2: l2 = None elif l1: l1 = None if l1_hits == 0 and l1: label1 = l1 rect1 = fm.boundingRect(label1) p.drawText(qc.QPointF( uumin+pad, vmin+rect0.height()+rect1.height()+ticklen), label1) l1_hits += 1 if l2_hits == 0 and l2: label2 = l2 rect2 = fm.boundingRect(label2) p.drawText(qc.QPointF( uumin+pad, vmin+rect0.height()+rect1.height()+rect2.height()+ticklen), label2) v = yprojection(0) p.drawLine(qc.QPointF(uumin, v), qc.QPointF(uumax, v))
[docs]class Projection(object): def __init__(self): self.xr = 0., 1. self.ur = 0., 1.
[docs] def set_in_range(self, xmin, xmax): if xmax == xmin: xmax = xmin + 1. self.xr = xmin, xmax
[docs] def get_in_range(self): return self.xr
[docs] def set_out_range(self, umin, umax): if umax == umin: umax = umin + 1. self.ur = umin, umax
[docs] def get_out_range(self): return self.ur
def __call__(self, x): umin, umax = self.ur xmin, xmax = self.xr return umin + (x-xmin)*((umax-umin)/(xmax-xmin))
[docs] def clipped(self, x): umin, umax = self.ur xmin, xmax = self.xr return min(umax, max(umin, umin + (x-xmin)*((umax-umin)/(xmax-xmin))))
[docs] def rev(self, u): umin, umax = self.ur xmin, xmax = self.xr return xmin + (u-umin)*((xmax-xmin)/(umax-umin))
[docs] def copy(self): return copy.copy(self)
[docs]def add_radiobuttongroup(menu, menudef, obj, target, default=None): group = qw.QActionGroup(menu) menuitems = [] for name, v in menudef: k = qw.QAction(name, menu) group.addAction(k) menu.addAction(k) k.setCheckable(True) group.triggered.connect(target) menuitems.append((k, v)) if default is not None and name == default: k.setChecked(True) if default is None: menuitems[0][0].setChecked(True) return menuitems
[docs]def sort_actions(menu): actions = menu.actions() for action in actions: menu.removeAction(action) actions.sort(key=lambda x: str(x.text())) help_action = [a for a in actions if a.text() == 'Snuffler Controls'] if help_action: actions.insert(0, actions.pop(actions.index(help_action[0]))) for action in actions: menu.addAction(action)
fkey_map = dict(zip( (qc.Qt.Key_F1, qc.Qt.Key_F2, qc.Qt.Key_F3, qc.Qt.Key_F4, qc.Qt.Key_F5, qc.Qt.Key_F6, qc.Qt.Key_F7, qc.Qt.Key_F8, qc.Qt.Key_F9, qc.Qt.Key_F10, qc.Qt.Key_F11, qc.Qt.Key_F12), range(12)))
[docs]class PileViewerMainException(Exception): pass
[docs]def MakePileViewerMainClass(base): class PileViewerMain(base): want_input = qc.pyqtSignal() about_to_close = qc.pyqtSignal() pile_has_changed_signal = qc.pyqtSignal() tracks_range_changed = qc.pyqtSignal(int, int, int) markers_added = qc.pyqtSignal(int, int) markers_removed = qc.pyqtSignal(int, int) changed_marker_selection = qc.pyqtSignal(list) active_event_marker_changed = qc.pyqtSignal(int) def __init__(self, pile, ntracks_shown_max, panel_parent, *args): if base == qgl.QGLWidget: from OpenGL import GL # noqa base.__init__( self, qgl.QGLFormat(qgl.QGL.SampleBuffers), *args) else: base.__init__(self, *args) self.pile = pile self.ax_height = 80 self.panel_parent = panel_parent self.click_tolerance = 5 self.ntracks_shown_max = ntracks_shown_max self.initial_ntracks_shown_max = ntracks_shown_max self.ntracks = 0 self.show_all = True self.shown_tracks_range = None self.track_start = None self.track_trange = None self.lowpass = None self.highpass = None self.gain = 1.0 self.rotate = 0.0 self.picking_down = None self.picking = None self.floating_marker = None self.markers = [] self.all_marker_kinds = (0, 1, 2, 3, 4, 5) self.visible_marker_kinds = self.all_marker_kinds self.active_event_marker = None self.ignore_releases = 0 self.message = None self.reloaded = False self.pile_has_changed = False self.config = pyrocko.config.config('snuffler') self.tax = TimeAx() self.setBackgroundRole(qg.QPalette.Base) self.setAutoFillBackground(True) poli = qw.QSizePolicy( qw.QSizePolicy.Expanding, qw.QSizePolicy.Expanding) self.setSizePolicy(poli) self.setMinimumSize(300, 200) self.setFocusPolicy(qc.Qt.StrongFocus) self.menu = qw.QMenu(self) mi = qw.QAction('Open waveform files...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.open_waveforms) mi = qw.QAction('Open waveform directory...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.open_waveform_directory) mi = qw.QAction('Open station files...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.open_stations) mi = qw.QAction('Save markers...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.write_markers) mi = qw.QAction('Save selected markers...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.write_selected_markers) mi = qw.QAction('Open marker file...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.read_markers) mi = qw.QAction('Open event file...', self.menu) self.menu.addAction(mi) mi.triggered.connect(self.read_events) self.menu.addSeparator() menudef = [ ('Indivdual Scale', lambda tr: tr.nslc_id), ('Common Scale', lambda tr: None), ('Common Scale per Station', lambda tr: (tr.network, tr.station)), ('Common Scale per Station Location', lambda tr: (tr.network, tr.station, tr.location)), ('Common Scale per Component', lambda tr: (tr.channel)), ] self.menuitems_scaling = add_radiobuttongroup( self.menu, menudef, self, self.scalingmode_change) self.scaling_key = self.menuitems_scaling[0][1] self.scaling_hooks = {} self.menu.addSeparator() menudef = [ ('Scaling based on Minimum and Maximum', 'minmax'), ('Scaling based on Mean +- 2 x Std. Deviation', 2), ('Scaling based on Mean +- 4 x Std. Deviation', 4), ] self.menuitems_scaling_base = add_radiobuttongroup( self.menu, menudef, self, self.scaling_base_change) self.scaling_base = self.menuitems_scaling_base[0][1] self.menu.addSeparator() def sector_dist(sta): if sta.dist_m is None: return None, None else: return ( sector_int(round((sta.azimuth+15.)/30.)), m_float(sta.dist_m)) menudef = [ ('Sort by Names', lambda tr: ()), ('Sort by Distance', lambda tr: self.station_attrib( tr, lambda sta: (m_float_or_none(sta.dist_m),), lambda tr: (None,))), ('Sort by Azimuth', lambda tr: self.station_attrib( tr, lambda sta: (deg_float_or_none(sta.azimuth),), lambda tr: (None,))), ('Sort by Distance in 12 Azimuthal Blocks', lambda tr: self.station_attrib( tr, sector_dist, lambda tr: (None, None))), ('Sort by Backazimuth', lambda tr: self.station_attrib( tr, lambda sta: (deg_float_or_none(sta.backazimuth),), lambda tr: (None,))), ] self.menuitems_ssorting = add_radiobuttongroup( self.menu, menudef, self, self.s_sortingmode_change) self._ssort = lambda tr: () self.menuitem_distances_3d = qw.QAction('3D distances', self.menu) self.menuitem_distances_3d.setCheckable(True) self.menuitem_distances_3d.setChecked(False) self.menuitem_distances_3d.toggled.connect( self.distances_3d_changed) self.menu.addAction(self.menuitem_distances_3d) self.menu.addSeparator() menudef = [ ('Subsort by Network, Station, Location, Channel', (lambda tr: self.ssort(tr) + tr.nslc_id, # gathering lambda a: a, # sorting lambda tr: tr.location)), # coloring ('Subsort by Network, Station, Channel, Location', (lambda tr: self.ssort(tr) + ( tr.network, tr.station, tr.channel, tr.location), lambda a: a, lambda tr: tr.channel)), ('Subsort by Station, Network, Channel, Location', (lambda tr: self.ssort(tr) + ( tr.station, tr.network, tr.channel, tr.location), lambda a: a, lambda tr: tr.channel)), ('Subsort by Location, Network, Station, Channel', (lambda tr: self.ssort(tr) + ( tr.location, tr.network, tr.station, tr.channel), lambda a: a, lambda tr: tr.channel)), ('Subsort by Channel, Network, Station, Location', (lambda tr: self.ssort(tr) + ( tr.channel, tr.network, tr.station, tr.location), lambda a: a, lambda tr: (tr.network, tr.station, tr.location))), ('Subsort by Network, Station, Channel (Grouped by Location)', (lambda tr: self.ssort(tr) + ( tr.network, tr.station, tr.channel), lambda a: a, lambda tr: tr.location)), ('Subsort by Station, Network, Channel (Grouped by Location)', (lambda tr: self.ssort(tr) + ( tr.station, tr.network, tr.channel), lambda a: a, lambda tr: tr.location)), ] self.menuitems_sorting = add_radiobuttongroup( self.menu, menudef, self, self.sortingmode_change) self.menu.addSeparator() self.menuitem_antialias = qw.QAction('Antialiasing', self.menu) self.menuitem_antialias.setCheckable(True) self.menu.addAction(self.menuitem_antialias) self.menuitem_liberal_fetch = qw.QAction( 'Liberal Fetch Optimization', self.menu) self.menuitem_liberal_fetch.setCheckable(True) self.menu.addAction(self.menuitem_liberal_fetch) self.menuitem_cliptraces = qw.QAction('Clip Traces', self.menu) self.menuitem_cliptraces.setCheckable(True) self.menuitem_cliptraces.setChecked(self.config.clip_traces) self.menu.addAction(self.menuitem_cliptraces) self.menuitem_showboxes = qw.QAction('Show Boxes', self.menu) self.menuitem_showboxes.setCheckable(True) self.menuitem_showboxes.setChecked( self.config.show_boxes) self.menu.addAction(self.menuitem_showboxes) self.menuitem_colortraces = qw.QAction('Color Traces', self.menu) self.menuitem_colortraces.setCheckable(True) self.menuitem_colortraces.setChecked(False) self.menu.addAction(self.menuitem_colortraces) self.menuitem_showscalerange = qw.QAction( 'Show Scale Ranges', self.menu) self.menuitem_showscalerange.setCheckable(True) self.menuitem_showscalerange.setChecked( self.config.show_scale_ranges) self.menu.addAction(self.menuitem_showscalerange) self.menuitem_showscaleaxis = qw.QAction( 'Show Scale Axes', self.menu) self.menuitem_showscaleaxis.setCheckable(True) self.menuitem_showscaleaxis.setChecked( self.config.show_scale_axes) self.menu.addAction(self.menuitem_showscaleaxis) self.menuitem_showzeroline = qw.QAction( 'Show Zero Lines', self.menu) self.menuitem_showzeroline.setCheckable(True) self.menu.addAction(self.menuitem_showzeroline) self.menuitem_fixscalerange = qw.QAction( 'Fix Scale Ranges', self.menu) self.menuitem_fixscalerange.setCheckable(True) self.menu.addAction(self.menuitem_fixscalerange) self.menuitem_allowdownsampling = qw.QAction( 'Allow Downsampling', self.menu) self.menuitem_allowdownsampling.setCheckable(True) self.menuitem_allowdownsampling.setChecked(True) self.menu.addAction(self.menuitem_allowdownsampling) self.menuitem_degap = qw.QAction('Allow Degapping', self.menu) self.menuitem_degap.setCheckable(True) self.menuitem_degap.setChecked(True) self.menu.addAction(self.menuitem_degap) self.menuitem_demean = qw.QAction('Demean', self.menu) self.menuitem_demean.setCheckable(True) self.menuitem_demean.setChecked(self.config.demean) self.menu.addAction(self.menuitem_demean) self.menuitem_fft_filtering = qw.QAction( 'FFT Filtering', self.menu) self.menuitem_fft_filtering.setCheckable(True) self.menuitem_fft_filtering.setChecked(False) self.menu.addAction(self.menuitem_fft_filtering) self.menuitem_lphp = qw.QAction( 'Bandpass is Lowpass + Highpass', self.menu) self.menuitem_lphp.setCheckable(True) self.menuitem_lphp.setChecked(True) self.menu.addAction(self.menuitem_lphp) self.menuitem_watch = qw.QAction('Watch Files', self.menu) self.menuitem_watch.setCheckable(True) self.menuitem_watch.setChecked(False) self.menu.addAction(self.menuitem_watch) self.visible_length_menu = qw.QMenu('Visible Length', self.menu) menudef = [(x.key, x.value) for x in self.config.visible_length_setting] self.menuitems_visible_length = add_radiobuttongroup( self.visible_length_menu, menudef, self, self.visible_length_change) self.visible_length = menudef[0][1] self.menu.addMenu(self.visible_length_menu) self.menu.addSeparator() self.snufflings_menu = qw.QMenu('Run Snuffling', self.menu) self.menu.addMenu(self.snufflings_menu) self.toggle_panel_menu = qw.QMenu('Panels', self.menu) self.menu.addMenu(self.toggle_panel_menu) self.menuitem_reload = qw.QAction('Reload Snufflings', self.menu) self.menu.addAction(self.menuitem_reload) self.menuitem_reload.triggered.connect( self.setup_snufflings) self.menu.addSeparator() # Disable ShadowPileTest if False: self.menuitem_test = qw.QAction('Test', self.menu) self.menuitem_test.setCheckable(True) self.menuitem_test.setChecked(False) self.menu.addAction(self.menuitem_test) self.menuitem_test.triggered.connect( self.toggletest) self.menuitem_print = qw.QAction('Print', self.menu) self.menu.addAction(self.menuitem_print) self.menuitem_print.triggered.connect( self.printit) self.menuitem_svg = qw.QAction('Save as SVG|PNG', self.menu) self.menu.addAction(self.menuitem_svg) self.menuitem_svg.triggered.connect( self.savesvg) self.snuffling_help_menu = qw.QMenu('Help', self.menu) self.menu.addMenu(self.snuffling_help_menu) self.menuitem_help = qw.QAction( 'Snuffler Controls', self.snuffling_help_menu) self.snuffling_help_menu.addAction(self.menuitem_help) self.menuitem_help.triggered.connect(self.help) self.snuffling_help_menu.addSeparator() self.menuitem_about = qw.QAction('About', self.menu) self.menu.addAction(self.menuitem_about) self.menuitem_about.triggered.connect(self.about) self.menuitem_close = qw.QAction('Close', self.menu) self.menu.addAction(self.menuitem_close) self.menuitem_close.triggered.connect(self.myclose) self.menu.addSeparator() self.menu.triggered.connect(self.update) self.time_projection = Projection() self.set_time_range(self.pile.get_tmin(), self.pile.get_tmax()) self.time_projection.set_out_range(0., self.width()) self.gather = None self.trace_filter = None self.quick_filter = None self.quick_filter_patterns = None, None self.blacklist = [] self.track_to_screen = Projection() self.track_to_nslc_ids = {} self.old_vec = None self.old_processed_traces = None self.timer = qc.QTimer(self) self.timer.timeout.connect(self.periodical) self.timer.setInterval(1000) self.timer.start() self.pile.add_listener(self) self.trace_styles = {} self.determine_box_styles() self.setMouseTracking(True) user_home_dir = os.environ['HOME'] self.snuffling_modules = {} self.snuffling_paths = [os.path.join(user_home_dir, '.snufflings')] self.default_snufflings = None self.snufflings = [] self.stations = {} self.timer_draw = Timer() self.timer_cutout = Timer() self.time_spent_painting = 0.0 self.time_last_painted = time.time() self.interactive_range_change_time = 0.0 self.interactive_range_change_delay_time = 10.0 self.follow_timer = None self.sortingmode_change_time = 0.0 self.sortingmode_change_delay_time = None self.old_data_ranges = {} self.error_messages = {} self.return_tag = None self.wheel_pos = 60 self.setAcceptDrops(True) self._paths_to_load = [] self.tf_cache = {} self.automatic_updates = True self.closing = False self.paint_timer = qc.QTimer(self) self.paint_timer.timeout.connect(self.reset_updates) self.paint_timer.setInterval(20) self.paint_timer.start() @qc.pyqtSlot() def reset_updates(self): if not self.updatesEnabled(): self.setUpdatesEnabled(True) def fail(self, reason): box = qw.QMessageBox(self) box.setText(reason) box.exec_() def set_trace_filter(self, filter_func): self.trace_filter = filter_func self.sortingmode_change() def update_trace_filter(self): if self.blacklist: def blacklist_func(tr): return not pyrocko.util.match_nslc( self.blacklist, tr.nslc_id) else: blacklist_func = None if self.quick_filter is None and blacklist_func is None: self.set_trace_filter(None) elif self.quick_filter is None: self.set_trace_filter(blacklist_func) elif blacklist_func is None: self.set_trace_filter(self.quick_filter) else: self.set_trace_filter( lambda tr: blacklist_func(tr) and self.quick_filter(tr)) def set_quick_filter(self, filter_func): self.quick_filter = filter_func self.update_trace_filter() def set_quick_filter_patterns(self, patterns, inputline=None): if patterns is not None: self.set_quick_filter( lambda tr: pyrocko.util.match_nslc(patterns, tr.nslc_id)) else: self.set_quick_filter(None) self.quick_filter_patterns = patterns, inputline def get_quick_filter_patterns(self): return self.quick_filter_patterns def add_blacklist_pattern(self, pattern): if pattern == 'empty': keys = set(self.pile.nslc_ids) trs = self.pile.all( tmin=self.tmin, tmax=self.tmax, load_data=False, degap=False) for tr in trs: if tr.nslc_id in keys: keys.remove(tr.nslc_id) for key in keys: xpattern = '.'.join(key) if xpattern not in self.blacklist: self.blacklist.append(xpattern) else: if pattern in self.blacklist: self.blacklist.remove(pattern) self.blacklist.append(pattern) logger.info('Blacklist is [ %s ]' % ', '.join(self.blacklist)) self.update_trace_filter() def remove_blacklist_pattern(self, pattern): if pattern in self.blacklist: self.blacklist.remove(pattern) else: raise PileViewerMainException( 'Pattern not found in blacklist.') logger.info('Blacklist is [ %s ]' % ', '.join(self.blacklist)) self.update_trace_filter() def clear_blacklist(self): self.blacklist = [] self.update_trace_filter() def ssort(self, tr): return self._ssort(tr) def station_key(self, x): return x.network, x.station def station_attrib(self, tr, getter, default_getter): sk = self.station_key(tr) if sk in self.stations: station = self.stations[sk] return getter(station) else: return default_getter(tr) def get_station(self, sk): return self.stations[sk] def has_station(self, station): sk = self.station_key(station) return sk in self.stations def station_latlon(self, tr, default_getter=lambda tr: (0., 0.)): return self.station_attrib( tr, lambda sta: (sta.lat, sta.lon), default_getter) def set_stations(self, stations): self.stations = {} self.add_stations(stations) def add_stations(self, stations): for station in stations: sk = self.station_key(station) self.stations[sk] = station ev = self.get_active_event() if ev: self.set_origin(ev) def add_event(self, event): marker = EventMarker(event) self.add_marker(marker) def add_events(self, events): markers = [EventMarker(e) for e in events] self.add_markers(markers) def set_event_marker_as_origin(self, ignore=None): selected = self.selected_markers() if not selected: self.fail('An event marker must be selected.') return m = selected[0] if not isinstance(m, EventMarker): self.fail('Selected marker is not an event.') return self.set_active_event_marker(m) def deactivate_event_marker(self): if self.active_event_marker: self.active_event_marker.set_active(False) self.active_event_marker_changed.emit(-1) self.active_event_marker = None def set_active_event_marker(self, event_marker): if self.active_event_marker: self.active_event_marker.set_active(False) self.active_event_marker = event_marker event_marker.set_active(True) event = event_marker.get_event() self.set_origin(event) i_active = self.markers.index(self.active_event_marker) self.active_event_marker_changed.emit(i_active) def set_active_event(self, event): for marker in self.markers: if isinstance(marker, EventMarker): if marker.get_event() is event: self.set_active_event_marker(marker) def get_active_event_marker(self): return self.active_event_marker def get_active_event(self): m = self.get_active_event_marker() if m is not None: return m.get_event() else: return None def set_origin(self, location): for station in self.stations.values(): station.set_event_relative_data( location, distance_3d=self.menuitem_distances_3d.isChecked()) self.sortingmode_change() def distances_3d_changed(self, ignore): self.set_event_marker_as_origin(ignore) def toggletest(self, checked): if checked: sp = Integrator() self.add_shadow_pile(sp) else: self.remove_shadow_piles() def add_shadow_pile(self, shadow_pile): shadow_pile.set_basepile(self.pile) shadow_pile.add_listener(self) self.pile = shadow_pile def remove_shadow_piles(self): self.pile = self.pile.get_basepile() def iter_snuffling_modules(self): pjoin = os.path.join for path in self.snuffling_paths: if not os.path.isdir(path): os.mkdir(path) for entry in os.listdir(path): directory = path fn = entry d = pjoin(path, entry) if os.path.isdir(d): directory = d if os.path.isfile( os.path.join(directory, 'snuffling.py')): fn = 'snuffling.py' if not fn.endswith('.py'): continue name = fn[:-3] if (directory, name) not in self.snuffling_modules: self.snuffling_modules[directory, name] = \ pyrocko.gui.snuffling.SnufflingModule( directory, name, self) yield self.snuffling_modules[directory, name] def setup_snufflings(self): # user snufflings for mod in self.iter_snuffling_modules(): try: mod.load_if_needed() except pyrocko.gui.snuffling.BrokenSnufflingModule as e: logger.warning('Snuffling module "%s" is broken' % e) # load the default snufflings on first run if self.default_snufflings is None: self.default_snufflings = pyrocko.gui\ .snufflings.__snufflings__() for snuffling in self.default_snufflings: self.add_snuffling(snuffling) def set_panel_parent(self, panel_parent): self.panel_parent = panel_parent def get_panel_parent(self): return self.panel_parent def add_snuffling(self, snuffling, reloaded=False): logger.debug('Adding snuffling %s' % snuffling.get_name()) snuffling.init_gui( self, self.get_panel_parent(), self, reloaded=reloaded) self.snufflings.append(snuffling) self.update() def remove_snuffling(self, snuffling): snuffling.delete_gui() self.update() self.snufflings.remove(snuffling) snuffling.pre_destroy() def add_snuffling_menuitem(self, item): self.snufflings_menu.addAction(item) item.setParent(self.snufflings_menu) sort_actions(self.snufflings_menu) def remove_snuffling_menuitem(self, item): self.snufflings_menu.removeAction(item) def add_snuffling_help_menuitem(self, item): self.snuffling_help_menu.addAction(item) item.setParent(self.snuffling_help_menu) sort_actions(self.snuffling_help_menu) def remove_snuffling_help_menuitem(self, item): self.snuffling_help_menu.removeAction(item) def add_panel_toggler(self, item): self.toggle_panel_menu.addAction(item) item.setParent(self.toggle_panel_menu) sort_actions(self.toggle_panel_menu) def remove_panel_toggler(self, item): self.toggle_panel_menu.removeAction(item) def load(self, paths, regex=None, format='from_extension', cache_dir=None, force_cache=False): if cache_dir is None: cache_dir = pyrocko.config.config().cache_dir if isinstance(paths, str): paths = [paths] fns = pyrocko.util.select_files( paths, selector=None, regex=regex, show_progress=False) if not fns: return cache = pyrocko.pile.get_cache(cache_dir) t = [time.time()] def update_bar(label, value): pbs = self.parent().get_progressbars() if label.lower() == 'looking at files': label = 'Looking at %i files' % len(fns) else: label = 'Scanning %i files' % len(fns) return pbs.set_status(label, value) def update_progress(label, i, n): abort = False qw.qApp.processEvents() if n != 0: perc = i*100/n else: perc = 100 abort |= update_bar(label, perc) abort |= self.window().is_closing() tnow = time.time() if t[0] + 1. + self.time_spent_painting * 10. < tnow: self.update() t[0] = tnow return abort self.automatic_updates = False self.pile.load_files( sorted(fns), filename_attributes=regex, cache=cache, fileformat=format, show_progress=False, update_progress=update_progress) self.automatic_updates = True self.update() def load_queued(self): if not self._paths_to_load: return paths = self._paths_to_load self._paths_to_load = [] self.load(paths) def load_soon(self, paths): self._paths_to_load.extend(paths) qc.QTimer.singleShot(200, self.load_queued) def open_waveforms(self): caption = 'Select one or more files to open' fns, _ = fnpatch(qw.QFileDialog.getOpenFileNames( self, caption, options=qfiledialog_options)) if fns: self.load(list(str(fn) for fn in fns)) def open_waveform_directory(self): caption = 'Select directory to scan for waveform files' dn = qw.QFileDialog.getExistingDirectory( self, caption, options=qfiledialog_options) if dn: self.load([str(dn)]) def open_stations(self, fns=None): caption = 'Select one or more files to open' if not fns: fns, _ = fnpatch(qw.QFileDialog.getOpenFileNames( self, caption, options=qfiledialog_options)) stations = [pyrocko.model.load_stations(str(x)) for x in fns] for stat in stations: self.add_stations(stat) def add_traces(self, traces): if traces: mtf = pyrocko.pile.MemTracesFile(None, traces) self.pile.add_file(mtf) ticket = (self.pile, mtf) return ticket else: return (None, None) def release_data(self, tickets): for ticket in tickets: pile, mtf = ticket if pile is not None: pile.remove_file(mtf) def periodical(self): if self.menuitem_watch.isChecked(): if self.pile.reload_modified(): self.update() def get_pile(self): return self.pile def pile_changed(self, what): self.pile_has_changed = True self.pile_has_changed_signal.emit() if self.automatic_updates: self.update() def set_gathering(self, gather=None, order=None, color=None): if gather is None: def gather(tr): return tr.nslc_id if order is None: def order(a): return a if color is None: def color(tr): return tr.location self.gather = gather keys = self.pile.gather_keys(gather, self.trace_filter) self.color_gather = color self.color_keys = self.pile.gather_keys(color) previous_ntracks = self.ntracks self.set_ntracks(len(keys)) if self.shown_tracks_range is None or \ previous_ntracks == 0 or \ self.show_all: low, high = 0, min(self.ntracks_shown_max, self.ntracks) key_at_top = None n = high-low else: low, high = self.shown_tracks_range key_at_top = self.track_keys[low] n = high-low self.track_keys = sorted(keys, key=order) if key_at_top is not None: try: ind = self.track_keys.index(key_at_top) low = ind high = low+n except Exception: pass self.set_tracks_range((low, high)) self.key_to_row = dict( [(key, i) for (i, key) in enumerate(self.track_keys)]) def inrange(x, r): return r[0] <= x and x < r[1] def trace_selector(trace): gt = self.gather(trace) return ( gt in self.key_to_row and inrange(self.key_to_row[gt], self.shown_tracks_range)) if self.trace_filter is not None: self.trace_selector = lambda x: \ self.trace_filter(x) and trace_selector(x) else: self.trace_selector = trace_selector if self.tmin == working_system_time_range[0] and \ self.tmax == working_system_time_range[1] or \ self.show_all: tmin, tmax = self.pile.get_tmin(), self.pile.get_tmax() if tmin is not None and tmax is not None: tlen = (tmax - tmin) tpad = tlen * 5./self.width() self.set_time_range(tmin-tpad, tmax+tpad) def set_time_range(self, tmin, tmax): if tmin is None: tmin = working_system_time_range[0] if tmax is None: tmax = working_system_time_range[1] if tmin > tmax: tmin, tmax = tmax, tmin if tmin == tmax: tmin -= 1. tmax += 1. tmin = max(working_system_time_range[0], tmin) tmax = min(working_system_time_range[1], tmax) min_deltat = self.content_deltat_range()[0] if (tmax - tmin < min_deltat): m = (tmin + tmax) / 2. tmin = m - min_deltat/2. tmax = m + min_deltat/2. self.time_projection.set_in_range(tmin, tmax) self.tmin, self.tmax = tmin, tmax def get_time_range(self): return self.tmin, self.tmax def ypart(self, y): if y < self.ax_height: return -1 elif y > self.height()-self.ax_height: return 1 else: return 0 def time_fractional_digits(self): min_deltat = self.content_deltat_range()[0] return min(9, max(1, int(-math.floor(math.log10(min_deltat)))+2)) def write_markers(self, fn=None): caption = "Choose a file name to write markers" if not fn: fn, _ = fnpatch(qw.QFileDialog.getSaveFileName( self, caption, options=qfiledialog_options)) if fn: Marker.save_markers( sorted(self.markers, key=lambda m: m.tmin), fn, fdigits=self.time_fractional_digits()) def write_selected_markers(self, fn=None): caption = "Choose a file name to write selected markers" if not fn: fn, _ = fnpatch(qw.QFileDialog.getSaveFileName( self, caption, options=qfiledialog_options)) if fn: Marker.save_markers( sorted(self.selected_markers(), key=lambda m: m.tmin), fn, fdigits=self.time_fractional_digits()) def read_events(self, fn=None): ''' Open QFileDialog to open, read and add :py:class:`pyrocko.model.Event` instances and their marker representation to the pile viewer. ''' caption = "Selet one or more files to open" if not fn: fn, _ = fnpatch(qw.QFileDialog.getOpenFileName( self, caption, options=qfiledialog_options)) if fn: self.add_events(pyrocko.model.load_events(fn)) self.associate_phases_to_events() def read_markers(self, fn=None): ''' Open QFileDialog to open, read and add markers to the pile viewer. ''' caption = "Selet one or more files to open" if not fn: fn, _ = fnpatch(qw.QFileDialog.getOpenFileName( self, caption, options=qfiledialog_options)) if fn: self.add_markers(Marker.load_markers(fn)) self.associate_phases_to_events() def associate_phases_to_events(self): associate_phases_to_events(self.markers) def add_marker(self, marker): if marker not in self.markers: self.markers.append(marker) self.markers_added.emit( len(self.markers)-1, len(self.markers)-1) def add_markers(self, markers): len_before = len(self.markers) for m in markers: if m not in self.markers: self.markers.append(m) self.markers_added.emit( len_before, len(self.markers)-1) def remove_marker(self, marker): '''Remove a ``marker`` from the :py:class:`PileViewer`. :param marker: :py:class:`Marker` (or subclass) instance''' try: indx = self.markers.index(marker) self.remove_marker_from_menu(indx, indx) self.markers.remove(marker) if marker is self.active_event_marker: self.deactivate_event_marker() self.active_event_marker = None except ValueError: pass def remove_markers(self, markers): '''Remove a list of ``markers`` from the :py:class:`PileViewer`. :param markers: list of :py:class:`Marker` (or subclass) instances''' try: indxs = [self.markers.index(m) for m in markers] except ValueError: return chunks = make_chunks(indxs) for chunk in chunks[::-1]: try: self.remove_marker_from_menu(min(chunk), max(chunk)) about_to_remove = [self.markers[i_m] for i_m in chunk] for marker in about_to_remove: self.markers.remove(marker) if marker is self.active_event_marker: self.deactivate_event_marker() self.active_event_marker = None except ValueError: pass def remove_marker_from_menu(self, istart, istop): self.markers_removed.emit(istart, istop) def set_markers(self, markers): self.markers = markers def selected_markers(self): return [marker for marker in self.markers if marker.is_selected()] def get_markers(self): return self.markers def mousePressEvent(self, mouse_ev): self.show_all = False point = self.mapFromGlobal(mouse_ev.globalPos()) if mouse_ev.button() == qc.Qt.LeftButton: marker = self.marker_under_cursor(point.x(), point.y()) if self.picking: if self.picking_down is None: self.picking_down = ( self.time_projection.rev(mouse_ev.x()), mouse_ev.y()) elif marker is not None: if not (mouse_ev.modifiers() & qc.Qt.ShiftModifier): self.deselect_all() marker.set_selected(True) self.emit_selected_markers() self.update() else: self.track_start = mouse_ev.x(), mouse_ev.y() self.track_trange = self.tmin, self.tmax if mouse_ev.button() == qc.Qt.RightButton: self.menu.exec_(qg.QCursor.pos()) self.update_status() def mouseReleaseEvent(self, mouse_ev): if self.ignore_releases: self.ignore_releases -= 1 return if self.picking: self.stop_picking(mouse_ev.x(), mouse_ev.y()) self.emit_selected_markers() if self.track_start: self.update() self.track_start = None self.track_trange = None self.update_status() def mouseDoubleClickEvent(self, mouse_ev): self.show_all = False self.start_picking(None) self.ignore_releases = 1 def mouseMoveEvent(self, mouse_ev): self.setUpdatesEnabled(False) point = self.mapFromGlobal(mouse_ev.globalPos()) if self.picking: self.update_picking(point.x(), point.y()) elif self.track_start is not None: x0, y0 = self.track_start dx = (point.x() - x0)/float(self.width()) dy = (point.y() - y0)/float(self.height()) if self.ypart(y0) == 1: dy = 0 tmin0, tmax0 = self.track_trange scale = math.exp(-dy*5.) dtr = scale*(tmax0-tmin0) - (tmax0-tmin0) frac = x0/float(self.width()) dt = dx*(tmax0-tmin0)*scale self.interrupt_following() self.set_time_range( tmin0 - dt - dtr*frac, tmax0 - dt + dtr*(1.-frac)) self.update() else: self.hoovering(point.x(), point.y()) self.update_status() def nslc_ids_under_cursor(self, x, y): ftrack = self.track_to_screen.rev(y) nslc_ids = self.get_nslc_ids_for_track(ftrack) return nslc_ids def marker_under_cursor(self, x, y): mouset = self.time_projection.rev(x) deltat = (self.tmax-self.tmin)*self.click_tolerance/self.width() relevant_nslc_ids = None for marker in self.markers: if marker.kind not in self.visible_marker_kinds: continue if (abs(mouset-marker.get_tmin()) < deltat or abs(mouset-marker.get_tmax()) < deltat): if relevant_nslc_ids is None: relevant_nslc_ids = self.nslc_ids_under_cursor(x, y) marker_nslc_ids = marker.get_nslc_ids() if not marker_nslc_ids: return marker for nslc_id in marker_nslc_ids: if nslc_id in relevant_nslc_ids: return marker def hoovering(self, x, y): mouset = self.time_projection.rev(x) deltat = (self.tmax-self.tmin)*self.click_tolerance/self.width() needupdate = False haveone = False relevant_nslc_ids = self.nslc_ids_under_cursor(x, y) for marker in self.markers: if marker.kind not in self.visible_marker_kinds: continue state = abs(mouset-marker.get_tmin()) < deltat or \ abs(mouset-marker.get_tmax()) < deltat and not haveone if state: xstate = False marker_nslc_ids = marker.get_nslc_ids() if not marker_nslc_ids: xstate = True for nslc in relevant_nslc_ids: if marker.match_nslc(nslc): xstate = True state = xstate if state: haveone = True oldstate = marker.is_alerted() if oldstate != state: needupdate = True marker.set_alerted(state) if state: self.message = marker.hoover_message() if not haveone: self.message = None if needupdate: self.update() def keyPressEvent(self, key_event): self.show_all = False dt = self.tmax - self.tmin tmid = (self.tmin + self.tmax) / 2. try: keytext = str(key_event.text()) except UnicodeEncodeError: return if keytext == '?': self.help() elif keytext == ' ': self.interrupt_following() self.set_time_range(self.tmin+dt, self.tmax+dt) elif key_event.key() == qc.Qt.Key_Up: for m in self.selected_markers(): if isinstance(m, PhaseMarker): if key_event.modifiers() & qc.Qt.ShiftModifier: p = 0 else: p = 1 if m.get_polarity() != 1 else None m.set_polarity(p) elif key_event.key() == qc.Qt.Key_Down: for m in self.selected_markers(): if isinstance(m, PhaseMarker): if key_event.modifiers() & qc.Qt.ShiftModifier: p = 0 else: p = -1 if m.get_polarity() != -1 else None m.set_polarity(p) elif keytext == 'b': dt = self.tmax - self.tmin self.interrupt_following() self.set_time_range(self.tmin-dt, self.tmax-dt) elif keytext in ('p', 'n', 'P', 'N'): smarkers = self.selected_markers() tgo = None dir = str(keytext) if smarkers: tmid = smarkers[0].tmin for smarker in smarkers: if dir == 'n': tmid = max(smarker.tmin, tmid) else: tmid = min(smarker.tmin, tmid) tgo = tmid if dir.lower() == 'n': for marker in sorted( self.markers, key=operator.attrgetter('tmin')): t = marker.tmin if t > tmid and \ marker.kind in self.visible_marker_kinds and \ (dir == 'n' or isinstance(marker, EventMarker)): self.deselect_all() marker.set_selected(True) tgo = t break else: for marker in sorted( self.markers, key=operator.attrgetter('tmin'), reverse=True): t = marker.tmin if t < tmid and \ marker.kind in self.visible_marker_kinds and \ (dir == 'p' or isinstance(marker, EventMarker)): self.deselect_all() marker.set_selected(True) tgo = t break if tgo is not None: self.interrupt_following() self.set_time_range(tgo-dt/2., tgo+dt/2.) elif keytext == 'q' or keytext == 'x': self.myclose(keytext) elif keytext == 'r': if self.pile.reload_modified(): self.reloaded = True elif keytext == 'R': self.setup_snufflings() elif key_event.key() == qc.Qt.Key_Backspace: self.remove_markers(self.selected_markers()) elif keytext == 'a': for marker in self.markers: if ((self.tmin <= marker.get_tmin() <= self.tmax or self.tmin <= marker.get_tmax() <= self.tmax) and marker.kind in self.visible_marker_kinds): marker.set_selected(True) else: marker.set_selected(False) elif keytext == 'A': for marker in self.markers: if marker.kind in self.visible_marker_kinds: marker.set_selected(True) elif keytext == 'd': self.deselect_all() elif keytext == 'E': self.deactivate_event_marker() elif keytext == 'e': markers = self.selected_markers() event_markers_in_spe = [ marker for marker in markers if not isinstance(marker, PhaseMarker)] phase_markers = [ marker for marker in markers if isinstance(marker, PhaseMarker)] if len(event_markers_in_spe) == 1: event_marker = event_markers_in_spe[0] if not isinstance(event_marker, EventMarker): nslcs = list(event_marker.nslc_ids) lat, lon = 0.0, 0.0 old = self.get_active_event() if len(nslcs) == 1: lat, lon = self.station_latlon(NSLC(*nslcs[0])) elif old is not None: lat, lon = old.lat, old.lon event_marker.convert_to_event_marker(lat, lon) self.set_active_event_marker(event_marker) event = event_marker.get_event() for marker in phase_markers: marker.set_event(event) else: for marker in event_markers_in_spe: marker.convert_to_event_marker() elif keytext in ('0', '1', '2', '3', '4', '5'): for marker in self.selected_markers(): marker.set_kind(int(keytext)) self.emit_selected_markers() elif key_event.key() in fkey_map: self.handle_fkeys(key_event.key()) elif key_event.key() == qc.Qt.Key_Escape: if self.picking: self.stop_picking(0, 0, abort=True) elif key_event.key() == qc.Qt.Key_PageDown: self.scroll_tracks( self.shown_tracks_range[1]-self.shown_tracks_range[0]) elif key_event.key() == qc.Qt.Key_PageUp: self.scroll_tracks( self.shown_tracks_range[0]-self.shown_tracks_range[1]) elif keytext == '+': self.zoom_tracks(0., 1.) elif keytext == '-': self.zoom_tracks(0., -1.) elif keytext == '=': ntracks_shown = self.shown_tracks_range[1] - \ self.shown_tracks_range[0] dtracks = self.initial_ntracks_shown_max - ntracks_shown self.zoom_tracks(0., dtracks) elif keytext == ':': self.want_input.emit() elif keytext == 'f': if self.window().windowState() & qc.Qt.WindowFullScreen or \ self.window().windowState() & qc.Qt.WindowMaximized: self.window().showNormal() else: if macosx: self.window().showMaximized() else: self.window().showFullScreen() elif keytext == 'g': self.go_to_selection() elif keytext == 'G': self.go_to_selection(tight=True) elif keytext == 'm': self.toggle_marker_editor() elif keytext == 'c': self.toggle_main_controls() elif key_event.key() in (qc.Qt.Key_Left, qc.Qt.Key_Right): dir = 1 amount = 1 if key_event.key() == qc.Qt.Key_Left: dir = -1 if key_event.modifiers() & qc.Qt.ShiftModifier: amount = 10 self.nudge_selected_markers(dir*amount) if keytext != '' and keytext in 'degaApPnN': self.emit_selected_markers() self.update() self.update_status() def handle_fkeys(self, key): self.set_phase_kind( self.selected_markers(), fkey_map[key] + 1) self.emit_selected_markers() def emit_selected_markers(self): _indexes = [] selected_markers = self.selected_markers() markers = self.get_markers() for sm in selected_markers: if sm in markers: _indexes.append(markers.index(sm)) _indexes.sort() _indexes = make_chunks(_indexes) self.changed_marker_selection.emit(_indexes) def toggle_marker_editor(self): self.panel_parent.toggle_marker_editor() def toggle_main_controls(self): self.panel_parent.toggle_main_controls() def nudge_selected_markers(self, npixels): a, b = self.time_projection.ur c, d = self.time_projection.xr for marker in self.selected_markers(): if not isinstance(marker, EventMarker): marker.tmin += npixels * (d-c)/b marker.tmax += npixels * (d-c)/b def about(self): fn = pyrocko.util.data_file('snuffler.png') with open(pyrocko.util.data_file('snuffler_about.html')) as f: txt = f.read() label = qw.QLabel(txt % {'logo': fn}) label.setAlignment(qc.Qt.AlignVCenter | qc.Qt.AlignHCenter) self.show_doc('About', [label], target='tab') def help(self): class MyScrollArea(qw.QScrollArea): def sizeHint(self): s = qc.QSize() s.setWidth(self.widget().sizeHint().width()) s.setHeight(self.widget().sizeHint().height()) return s with open(pyrocko.util.data_file( 'snuffler_help.html')) as f: hcheat = qw.QLabel(f.read()) with open(pyrocko.util.data_file( 'snuffler_help_epilog.html')) as f: hepilog = qw.QLabel(f.read()) for h in [hcheat, hepilog]: h.setAlignment(qc.Qt.AlignTop | qc.Qt.AlignHCenter) h.setWordWrap(True) self.show_doc('Help', [hcheat, hepilog], target='panel') def show_doc(self, name, labels, target='panel'): scroller = qw.QScrollArea() frame = qw.QFrame(scroller) frame.setLineWidth(0) layout = qw.QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) frame.setLayout(layout) scroller.setWidget(frame) scroller.setWidgetResizable(True) frame.setBackgroundRole(qg.QPalette.Base) for h in labels: h.setParent(frame) h.setMargin(3) h.setTextInteractionFlags( qc.Qt.LinksAccessibleByMouse | qc.Qt.TextSelectableByMouse) h.setBackgroundRole(qg.QPalette.Base) layout.addWidget(h) h.linkActivated.connect( self.open_link) if self.panel_parent is not None: if target == 'panel': self.panel_parent.add_panel( name, scroller, True, volatile=False) else: self.panel_parent.add_tab(name, scroller) def open_link(self, link): qg.QDesktopServices.openUrl(qc.QUrl(link)) def wheelEvent(self, wheel_event): if use_pyqt5: self.wheel_pos += wheel_event.angleDelta().y() else: self.wheel_pos += wheel_event.delta() n = self.wheel_pos // 120 self.wheel_pos = self.wheel_pos % 120 if n == 0: return amount = max( 1., abs(self.shown_tracks_range[0]-self.shown_tracks_range[1])/5.) wdelta = amount * n trmin, trmax = self.track_to_screen.get_in_range() anchor = (self.track_to_screen.rev(wheel_event.y())-trmin) \ / (trmax-trmin) if wheel_event.modifiers() & qc.Qt.ControlModifier: self.zoom_tracks(anchor, wdelta) else: self.scroll_tracks(-wdelta) def dragEnterEvent(self, event): if event.mimeData().hasUrls(): if any(url.toLocalFile() for url in event.mimeData().urls()): event.setDropAction(qc.Qt.LinkAction) event.accept() def dropEvent(self, event): if event.mimeData().hasUrls(): paths = list( str(url.toLocalFile()) for url in event.mimeData().urls()) event.acceptProposedAction() self.load(paths) def get_phase_name(self, kind): return self.config.get_phase_name(kind) def set_phase_kind(self, markers, kind): phasename = self.get_phase_name(kind) for marker in markers: if isinstance(marker, PhaseMarker): if kind == 10: marker.convert_to_marker() else: marker.set_phasename(phasename) marker.set_event(self.get_active_event()) elif isinstance(marker, EventMarker): pass else: if kind != 10: event = self.get_active_event() marker.convert_to_phase_marker( event, phasename, None, False) def set_ntracks(self, ntracks): if self.ntracks != ntracks: self.ntracks = ntracks if self.shown_tracks_range is not None: l, h = self.shown_tracks_range else: l, h = 0, self.ntracks self.tracks_range_changed.emit(self.ntracks, l, h) def set_tracks_range(self, range, start=None): low, high = range low = min(self.ntracks-1, low) high = min(self.ntracks, high) low = max(0, low) high = max(1, high) if start is None: start = float(low) if self.shown_tracks_range != (low, high): self.shown_tracks_range = low, high self.shown_tracks_start = start self.tracks_range_changed.emit(self.ntracks, low, high) def scroll_tracks(self, shift): shown = self.shown_tracks_range shiftmin = -shown[0] shiftmax = self.ntracks-shown[1] shift = max(shiftmin, shift) shift = min(shiftmax, shift) shown = shown[0] + shift, shown[1] + shift self.set_tracks_range((int(shown[0]), int(shown[1]))) self.update() def zoom_tracks(self, anchor, delta): ntracks_shown = self.shown_tracks_range[1] \ - self.shown_tracks_range[0] if (ntracks_shown == 1 and delta <= 0) or \ (ntracks_shown == self.ntracks and delta >= 0): return ntracks_shown += int(round(delta)) ntracks_shown = min(max(1, ntracks_shown), self.ntracks) u = self.shown_tracks_start nu = max(0., u-anchor*delta) nv = nu + ntracks_shown if nv > self.ntracks: nu -= nv - self.ntracks nv -= nv - self.ntracks self.set_tracks_range((int(round(nu)), int(round(nv))), nu) self.ntracks_shown_max = self.shown_tracks_range[1] \ - self.shown_tracks_range[0] self.update() def content_time_range(self): pile = self.get_pile() tmin, tmax = pile.get_tmin(), pile.get_tmax() if tmin is None: tmin = working_system_time_range[0] if tmax is None: tmax = working_system_time_range[1] return tmin, tmax def content_deltat_range(self): pile = self.get_pile() deltatmin, deltatmax = pile.get_deltatmin(), pile.get_deltatmax() if deltatmin is None: deltatmin = 0.001 if deltatmax is None: deltatmax = 1000.0 return deltatmin, deltatmax def make_good_looking_time_range(self, tmin, tmax, tight=False): if tmax < tmin: tmin, tmax = tmax, tmin deltatmin = self.content_deltat_range()[0] dt = deltatmin * self.visible_length * 0.95 if dt == 0.0: dt = 1.0 if tight: if tmax != tmin: dtm = tmax - tmin tmin -= dtm*0.1 tmax += dtm*0.1 return tmin, tmax else: tcenter = (tmin + tmax) / 2. tmin = tcenter - 0.5*dt tmax = tcenter + 0.5*dt return tmin, tmax if tmax-tmin < dt: vmin, vmax = self.get_time_range() dt = min(vmax - vmin, dt) tcenter = (tmin+tmax)/2. etmin, etmax = tmin, tmax tmin = min(etmin, tcenter - 0.5*dt) tmax = max(etmax, tcenter + 0.5*dt) dtm = tmax-tmin if etmin == tmin: tmin -= dtm*0.1 if etmax == tmax: tmax += dtm*0.1 else: dtm = tmax-tmin tmin -= dtm*0.1 tmax += dtm*0.1 return tmin, tmax def go_to_selection(self, tight=False): markers = self.selected_markers() if markers: tmax, tmin = self.content_time_range() for marker in markers: tmin = min(tmin, marker.tmin) tmax = max(tmax, marker.tmax) else: if tight: vmin, vmax = self.get_time_range() tmin = tmax = (vmin + vmax) / 2. else: tmin, tmax = self.content_time_range() tmin, tmax = self.make_good_looking_time_range( tmin, tmax, tight=tight) self.interrupt_following() self.set_time_range(tmin, tmax) self.update() def go_to_time(self, t, tlen=None): tmax = t if tlen is not None: tmax = t+tlen tmin, tmax = self.make_good_looking_time_range(t, tmax) self.interrupt_following() self.set_time_range(tmin, tmax) self.update() def go_to_event_by_name(self, name): for marker in self.markers: if isinstance(marker, EventMarker): event = marker.get_event() if event.name and event.name.lower() == name.lower(): tmin, tmax = self.make_good_looking_time_range( event.time, event.time) self.interrupt_following() self.set_time_range(tmin, tmax) def printit(self): from .qt_compat import qprint printer = qprint.QPrinter() printer.setOrientation(qprint.QPrinter.Landscape) dialog = qprint.QPrintDialog(printer, self) dialog.setWindowTitle('Print') if dialog.exec_() != qw.QDialog.Accepted: return painter = qg.QPainter() painter.begin(printer) page = printer.pageRect() self.drawit( painter, printmode=False, w=page.width(), h=page.height()) painter.end() def savesvg(self, fn=None): if not fn: fn, _ = fnpatch(qw.QFileDialog.getSaveFileName( self, 'Save as SVG|PNG', os.path.join(os.environ['HOME'], 'untitled.svg'), 'SVG|PNG (*.svg *.png)', options=qfiledialog_options)) if fn == '': return if str(fn).endswith('.svg'): w, h = 842, 595 margin = 0.025 m = max(w, h)*margin generator = qsvg.QSvgGenerator() generator.setFileName(fn) generator.setSize(qc.QSize(w, h)) generator.setViewBox(qc.QRectF(-m, -m, w+2*m, h+2*m)) painter = qg.QPainter() painter.begin(generator) self.drawit(painter, printmode=False, w=w, h=h) painter.end() elif str(fn).endswith('.png'): if use_pyqt5: pixmap = self.grab() else: pixmap = qg.QPixmap().grabWidget(self) pixmap.save(fn) else: logger.warning('unsupported file type') def paintEvent(self, paint_ev): """Called by QT whenever widget needs to be painted""" painter = qg.QPainter(self) if self.menuitem_antialias.isChecked(): painter.setRenderHint(qg.QPainter.Antialiasing) self.drawit(painter) logger.debug( 'Time spent drawing: %.3f %.3f %.3f %.3f %.3f' % (self.timer_draw - self.timer_cutout)) logger.debug( 'Time spent processing: %.3f %.3f %.3f %.3f %.3f' % self.timer_cutout.get()) self.time_spent_painting = self.timer_draw.get()[-1] self.time_last_painted = time.time() def determine_box_styles(self): traces = list(self.pile.iter_traces()) traces.sort(key=operator.attrgetter('full_id')) istyle = 0 trace_styles = {} for itr, tr in enumerate(traces): if itr > 0: other = traces[itr-1] if not ( other.nslc_id == tr.nslc_id and other.deltat == tr.deltat and abs(other.tmax - tr.tmin) < gap_lap_tolerance*tr.deltat): istyle += 1 trace_styles[tr.full_id, tr.deltat] = istyle self.trace_styles = trace_styles def draw_trace_boxes(self, p, time_projection, track_projections): for v_projection in track_projections.values(): v_projection.set_in_range(0., 1.) def selector(x): return x.overlaps(*time_projection.get_in_range()) if self.trace_filter is not None: def tselector(x): return selector(x) and self.trace_filter(x) else: tselector = selector traces = list(self.pile.iter_traces( group_selector=selector, trace_selector=tselector)) traces.sort(key=operator.attrgetter('full_id')) def drawbox(itrack, istyle, traces): v_projection = track_projections[itrack] dvmin = v_projection(0.) dvmax = v_projection(1.) dtmin = time_projection.clipped(traces[0].tmin) dtmax = time_projection.clipped(traces[-1].tmax) style = box_styles[istyle % len(box_styles)] rect = qc.QRectF(dtmin, dvmin, float(dtmax-dtmin), dvmax-dvmin) p.fillRect(rect, style.fill_brush) p.setPen(style.frame_pen) p.drawRect(rect) traces_by_style = {} for itr, tr in enumerate(traces): gt = self.gather(tr) if gt not in self.key_to_row: continue itrack = self.key_to_row[gt] if itrack not in track_projections: continue istyle = self.trace_styles.get((tr.full_id, tr.deltat), 0) if len(traces) < 500: drawbox(itrack, istyle, [tr]) else: if (itrack, istyle) not in traces_by_style: traces_by_style[itrack, istyle] = [] traces_by_style[itrack, istyle].append(tr) for (itrack, istyle), traces in traces_by_style.items(): drawbox(itrack, istyle, traces) def tobedrawn(self, markers, uminmax): """Returns two lists of indices: first indicates which markers should be labeled. second indicates which markers should be drawn.""" times = [m.tmin for m in markers] m_projections = num.array(list(map(self.time_projection, times))) m_projections = num.floor(m_projections) u, indx = num.unique(m_projections, return_index=True) a = num.zeros(len(m_projections)+2) umin, umax = uminmax a[0] = umin a[-1] = umax a[1:-1] = m_projections offsets = num.floor_divide(num.diff(a), 30.) with num.errstate(invalid='ignore'): offsets = num.divide(offsets, offsets) congregated = num.zeros(len(a)) congregated[:-1] = offsets congregated[1:] += offsets congregated = num.divide(congregated, congregated) with num.errstate(invalid='ignore'): i_labels = num.where(congregated[1:-1] == 1)[0] return i_labels, indx def draw_visible_markers(self, markers, p, vcenter_projection): """Draw non-overlapping ``markers``.""" markers = [x for x in self.markers if ( x.get_tmin() < self.tmax and self.tmin < x.get_tmax())] markers = [ x for x in markers if x.kind in self.visible_marker_kinds] if len(markers) > 500: i_labels, i_markers = self.tobedrawn( markers, self.time_projection.get_out_range()) if len(i_markers) != 0: for i_m in i_markers: if i_m in i_labels: with_label = True else: with_label = False markers[i_m].draw(p, self.time_projection, vcenter_projection, with_label=with_label) else: for m in markers: m.draw(p, self.time_projection, vcenter_projection, with_label=True) def drawit(self, p, printmode=False, w=None, h=None): """This performs the actual drawing.""" self.timer_draw.start() if self.gather is None: self.set_gathering() if self.pile_has_changed: if not self.sortingmode_change_delayed(): self.sortingmode_change() if self.menuitem_showboxes.isChecked(): self.determine_box_styles() self.pile_has_changed = False if h is None: h = float(self.height()) if w is None: w = float(self.width()) if printmode: primary_color = (0, 0, 0) else: primary_color = pyrocko.plot.tango_colors['aluminium5'] ax_h = float(self.ax_height) vbottom_ax_projection = Projection() vtop_ax_projection = Projection() vcenter_projection = Projection() self.time_projection.set_out_range(0., w) vbottom_ax_projection.set_out_range(h-ax_h, h) vtop_ax_projection.set_out_range(0., ax_h) vcenter_projection.set_out_range(ax_h, h-ax_h) vcenter_projection.set_in_range(0., 1.) self.track_to_screen.set_out_range(ax_h, h-ax_h) self.track_to_screen.set_in_range(*self.shown_tracks_range) track_projections = {} for i in range(*self.shown_tracks_range): proj = Projection() proj.set_out_range( self.track_to_screen(i+0.05), self.track_to_screen(i+1.-0.05)) track_projections[i] = proj if self.tmin < self.tmax: self.time_projection.set_in_range(self.tmin, self.tmax) vbottom_ax_projection.set_in_range(0, ax_h) self.tax.drawit(p, self.time_projection, vbottom_ax_projection) yscaler = pyrocko.plot.AutoScaler() if not printmode and self.menuitem_showboxes.isChecked(): self.draw_trace_boxes( p, self.time_projection, track_projections) if self.floating_marker: self.floating_marker.draw( p, self.time_projection, vcenter_projection) self.draw_visible_markers( self.markers, p, vcenter_projection) active_marker = self.get_active_event_marker() if active_marker: self.draw_visible_markers( [active_marker], p, vcenter_projection) self.draw_visible_markers( self.selected_markers(), p, vcenter_projection) primary_pen = qg.QPen(qg.QColor(*primary_color)) p.setPen(primary_pen) font = qg.QFont() font.setBold(True) axannotfont = qg.QFont() axannotfont.setBold(True) axannotfont.setPointSize(8) p.setFont(font) label_bg = qg.QBrush(qg.QColor(255, 255, 255, 100)) processed_traces = self.prepare_cutout2( self.tmin, self.tmax, trace_selector=self.trace_selector, degap=self.menuitem_degap.isChecked(), demean=self.menuitem_demean.isChecked()) color_lookup = dict( [(k, i) for (i, k) in enumerate(self.color_keys)]) self.track_to_nslc_ids = {} nticks = 0 annot_labels = [] if processed_traces: show_scales = self.menuitem_showscalerange.isChecked() \ or self.menuitem_showscaleaxis.isChecked() fm = qg.QFontMetrics(axannotfont, p.device()) trackheight = self.track_to_screen(1.-0.05) \ - self.track_to_screen(0.05) nlinesavail = trackheight/float(fm.lineSpacing()) if self.menuitem_showscaleaxis.isChecked(): nticks = max(3, min(nlinesavail * 0.5, 15)) else: nticks = 15 yscaler = pyrocko.plot.AutoScaler( no_exp_interval=(-3, 2), approx_ticks=nticks, snap=show_scales and not self.menuitem_showscaleaxis.isChecked()) data_ranges = pyrocko.trace.minmax( processed_traces, key=self.scaling_key, mode=self.scaling_base) if not self.menuitem_fixscalerange.isChecked(): self.old_data_ranges = data_ranges else: data_ranges.update(self.old_data_ranges) self.apply_scaling_hooks(data_ranges) trace_to_itrack = {} track_scaling_keys = {} track_scaling_colors = {} for trace in processed_traces: gt = self.gather(trace) if gt not in self.key_to_row: continue itrack = self.key_to_row[gt] if itrack not in track_projections: continue trace_to_itrack[trace] = itrack if itrack not in self.track_to_nslc_ids: self.track_to_nslc_ids[itrack] = set() self.track_to_nslc_ids[itrack].add(trace.nslc_id) if itrack not in track_scaling_keys: track_scaling_keys[itrack] = set() scaling_key = self.scaling_key(trace) track_scaling_keys[itrack].add(scaling_key) color = pyrocko.plot.color( color_lookup[self.color_gather(trace)]) k = itrack, scaling_key if k not in track_scaling_colors \ and self.menuitem_colortraces.isChecked(): track_scaling_colors[k] = color else: track_scaling_colors[k] = primary_color # y axes, zero lines trace_projections = {} for itrack in list(track_projections.keys()): if itrack not in track_scaling_keys: continue uoff = 0 for scaling_key in track_scaling_keys[itrack]: data_range = data_ranges[scaling_key] dymin, dymax = data_range ymin, ymax, yinc = yscaler.make_scale( (dymin/self.gain, dymax/self.gain)) iexp = yscaler.make_exp(yinc) factor = 10**iexp trace_projection = track_projections[itrack].copy() trace_projection.set_in_range(ymax, ymin) trace_projections[itrack, scaling_key] = \ trace_projection umin, umax = self.time_projection.get_out_range() vmin, vmax = trace_projection.get_out_range() umax_zeroline = umax uoffnext = uoff if show_scales: pen = qg.QPen(primary_pen) k = itrack, scaling_key if k in track_scaling_colors: c = qg.QColor(*track_scaling_colors[ itrack, scaling_key]) pen.setColor(c) p.setPen(pen) if nlinesavail > 3: if self.menuitem_showscaleaxis.isChecked(): ymin_annot = math.ceil(ymin/yinc)*yinc ny_annot = int( math.floor(ymax/yinc) - math.ceil(ymin/yinc)) + 1 for iy_annot in range(ny_annot): y = ymin_annot + iy_annot*yinc v = trace_projection(y) line = qc.QLineF( umax-10-uoff, v, umax-uoff, v) p.drawLine(line) if iy_annot == ny_annot - 1 \ and iexp != 0: sexp = ' &times; ' \ '10<sup>%i</sup>' % iexp else: sexp = '' snum = num_to_html(y/factor) lab = Label( p, umax-20-uoff, v, '%s%s' % (snum, sexp), label_bg=None, anchor='MR', font=axannotfont, color=c) uoffnext = max( lab.rect.width()+30., uoffnext) annot_labels.append(lab) if y == 0.: umax_zeroline = \ umax - 20 \ - lab.rect.width() - 10 \ - uoff else: if not self.menuitem_showboxes\ .isChecked(): qpoints = make_QPolygonF( [umax-20-uoff, umax-10-uoff, umax-10-uoff, umax-20-uoff], [vmax, vmax, vmin, vmin]) p.drawPolyline(qpoints) snum = num_to_html(ymin) labmin = Label( p, umax-15-uoff, vmax, snum, label_bg=None, anchor='BR', font=axannotfont, color=c) annot_labels.append(labmin) snum = num_to_html(ymax) labmax = Label( p, umax-15-uoff, vmin, snum, label_bg=None, anchor='TR', font=axannotfont, color=c) annot_labels.append(labmax) for lab in (labmin, labmax): uoffnext = max( lab.rect.width()+10., uoffnext) if self.menuitem_showzeroline.isChecked(): v = trace_projection(0.) if vmin <= v <= vmax: line = qc.QLineF(umin, v, umax_zeroline, v) p.drawLine(line) uoff = uoffnext p.setFont(font) p.setPen(primary_pen) for trace in processed_traces: if trace not in trace_to_itrack: continue itrack = trace_to_itrack[trace] scaling_key = self.scaling_key(trace) trace_projection = trace_projections[ itrack, scaling_key] vdata = trace_projection(trace.get_ydata()) udata_min = float(self.time_projection(trace.tmin)) udata_max = float(self.time_projection( trace.tmin+trace.deltat*(vdata.size-1))) udata = num.linspace(udata_min, udata_max, vdata.size) qpoints = make_QPolygonF(udata, vdata) umin, umax = self.time_projection.get_out_range() vmin, vmax = trace_projection.get_out_range() trackrect = qc.QRectF(umin, vmin, umax-umin, vmax-vmin) if self.menuitem_cliptraces.isChecked(): p.setClipRect(trackrect) if self.menuitem_colortraces.isChecked(): color = pyrocko.plot.color( color_lookup[self.color_gather(trace)]) pen = qg.QPen(qg.QColor(*color), 1) p.setPen(pen) p.drawPolyline(qpoints) if self.floating_marker: self.floating_marker.draw_trace( self, p, trace, self.time_projection, trace_projection, 1.0) for marker in self.markers: if marker.get_tmin() < self.tmax \ and self.tmin < marker.get_tmax(): if marker.kind in self.visible_marker_kinds: marker.draw_trace( self, p, trace, self.time_projection, trace_projection, 1.0) p.setPen(primary_pen) if self.menuitem_cliptraces.isChecked(): p.setClipRect(0, 0, w, h) p.setPen(primary_pen) while font.pointSize() > 2: fm = qg.QFontMetrics(font, p.device()) trackheight = self.track_to_screen(1.-0.05) \ - self.track_to_screen(0.05) nlinesavail = trackheight/float(fm.lineSpacing()) if nlinesavail > 1: break font.setPointSize(font.pointSize()-1) p.setFont(font) for key in self.track_keys: itrack = self.key_to_row[key] if itrack in track_projections: plabel = ' '.join( [str(x) for x in key if x is not None]) lx = 10 ly = self.track_to_screen(itrack+0.5) draw_label(p, lx, ly, plabel, label_bg, 'ML') for lab in annot_labels: lab.draw() self.timer_draw.stop() def see_data_params(self): min_deltat = self.content_deltat_range()[0] # determine padding and downampling requirements if self.lowpass is not None: deltat_target = 1./self.lowpass * 0.25 ndecimate = min( 50, max(1, int(round(deltat_target / min_deltat)))) tpad = 1./self.lowpass * 2. else: ndecimate = 1 tpad = min_deltat*5. if self.highpass is not None: tpad = max(1./self.highpass * 2., tpad) nsee_points_per_trace = 5000*10 tsee = ndecimate*nsee_points_per_trace*min_deltat return ndecimate, tpad, tsee def clean_update(self): self.old_processed_traces = None self.update() def get_adequate_tpad(self): tpad = 0. for f in [self.highpass, self.lowpass]: if f is not None: tpad = max(tpad, 1.0/f) for snuffling in self.snufflings: if snuffling._post_process_hook_enabled \ or snuffling._pre_process_hook_enabled: tpad = max(tpad, snuffling.get_tpad()) return tpad def prepare_cutout2( self, tmin, tmax, trace_selector=None, degap=True, demean=True, nmax=6000): if self.pile.is_empty(): return [] nmax = self.visible_length self.timer_cutout.start() tsee = tmax-tmin min_deltat_wo_decimate = tsee/nmax min_deltat_w_decimate = min_deltat_wo_decimate / 32. min_deltat_allow = min_deltat_wo_decimate if self.lowpass is not None: target_deltat_lp = 0.25/self.lowpass if target_deltat_lp > min_deltat_wo_decimate: min_deltat_allow = min_deltat_w_decimate min_deltat_allow = math.exp( int(math.floor(math.log(min_deltat_allow)))) tmin_ = tmin tmax_ = tmax # fetch more than needed? if self.menuitem_liberal_fetch.isChecked(): tlen = pyrocko.trace.nextpow2((tmax-tmin)*1.5) tmin = math.floor(tmin/tlen) * tlen tmax = math.ceil(tmax/tlen) * tlen fft_filtering = self.menuitem_fft_filtering.isChecked() lphp = self.menuitem_lphp.isChecked() ads = self.menuitem_allowdownsampling.isChecked() tpad = self.get_adequate_tpad() tpad = max(tpad, tsee) # state vector to decide if cached traces can be used vec = ( tmin, tmax, tpad, trace_selector, degap, demean, self.lowpass, self.highpass, fft_filtering, lphp, min_deltat_allow, self.rotate, self.shown_tracks_range, ads, self.pile.get_update_count()) if (self.old_vec and self.old_vec[0] <= vec[0] and vec[1] <= self.old_vec[1] and vec[2:] == self.old_vec[2:] and not (self.reloaded or self.menuitem_watch.isChecked()) and self.old_processed_traces is not None): logger.debug('Using cached traces') processed_traces = self.old_processed_traces else: self.old_vec = vec processed_traces = [] if self.pile.deltatmax >= min_deltat_allow: def group_selector(gr): return gr.deltatmax >= min_deltat_allow if trace_selector is not None: def trace_selectorx(tr): return tr.deltat >= min_deltat_allow \ and trace_selector(tr) else: def trace_selectorx(tr): return tr.deltat >= min_deltat_allow for traces in self.pile.chopper( tmin=tmin, tmax=tmax, tpad=tpad, want_incomplete=True, degap=degap, maxgap=gap_lap_tolerance, maxlap=gap_lap_tolerance, keep_current_files_open=True, group_selector=group_selector, trace_selector=trace_selectorx, accessor_id=id(self), snap=(math.floor, math.ceil), include_last=True): if demean: for tr in traces: if (tr.meta and tr.meta.get('tabu', False)): continue y = tr.get_ydata() tr.set_ydata(y - num.mean(y)) traces = self.pre_process_hooks(traces) for trace in traces: if not (trace.meta and trace.meta.get('tabu', False)): if fft_filtering: but = pyrocko.trace.ButterworthResponse multres = pyrocko.trace.MultiplyResponse if self.lowpass is not None \ or self.highpass is not None: it = num.arange( trace.data_len(), dtype=num.float) detr_data, m, b = detrend( it, trace.get_ydata()) trace.set_ydata(detr_data) freqs, fdata = trace.spectrum( pad_to_pow2=True, tfade=None) nfreqs = fdata.size key = (trace.deltat, nfreqs) if key not in self.tf_cache: resps = [] if self.lowpass is not None: resps.append(but( order=4, corner=self.lowpass, type='low')) if self.highpass is not None: resps.append(but( order=4, corner=self.highpass, type='high')) resp = multres(resps) self.tf_cache[key] = \ resp.evaluate(freqs) filtered_data = num.fft.irfft( fdata*self.tf_cache[key] )[:trace.data_len()] retrended_data = retrend( it, filtered_data, m, b) trace.set_ydata(retrended_data) else: if ads and self.lowpass is not None: while trace.deltat \ < min_deltat_wo_decimate: trace.downsample(2, demean=False) fmax = 0.5/trace.deltat if not lphp and ( self.lowpass is not None and self.highpass is not None and self.lowpass < fmax and self.highpass < fmax and self.highpass < self.lowpass): trace.bandpass( 2, self.highpass, self.lowpass) else: if self.lowpass is not None: if self.lowpass < 0.5/trace.deltat: trace.lowpass( 4, self.lowpass, demean=False) if self.highpass is not None: if self.lowpass is None \ or self.highpass \ < self.lowpass: if self.highpass < \ 0.5/trace.deltat: trace.highpass( 4, self.highpass, demean=False) processed_traces.append(trace) if self.rotate != 0.0: phi = self.rotate/180.*math.pi cphi = math.cos(phi) sphi = math.sin(phi) for a in processed_traces: for b in processed_traces: if (a.network == b.network and a.station == b.station and a.location == b.location and ((a.channel.lower().endswith('n') and b.channel.lower().endswith('e')) or (a.channel.endswith('1') and b.channel.endswith('2'))) and abs(a.deltat-b.deltat) < a.deltat*0.001 and abs(a.tmin-b.tmin) < a.deltat*0.01 and len(a.get_ydata()) == len(b.get_ydata())): aydata = a.get_ydata()*cphi+b.get_ydata()*sphi bydata = -a.get_ydata()*sphi+b.get_ydata()*cphi a.set_ydata(aydata) b.set_ydata(bydata) processed_traces = self.post_process_hooks(processed_traces) self.old_processed_traces = processed_traces chopped_traces = [] for trace in processed_traces: try: ctrace = trace.chop( tmin_-trace.deltat*4., tmax_+trace.deltat*4., inplace=False) except pyrocko.trace.NoData: continue if ctrace.data_len() < 2: continue chopped_traces.append(ctrace) self.timer_cutout.stop() return chopped_traces def pre_process_hooks(self, traces): for snuffling in self.snufflings: if snuffling._pre_process_hook_enabled: traces = snuffling.pre_process_hook(traces) return traces def post_process_hooks(self, traces): for snuffling in self.snufflings: if snuffling._post_process_hook_enabled: traces = snuffling.post_process_hook(traces) return traces def visible_length_change(self, ignore=None): for menuitem, vlen in self.menuitems_visible_length: if menuitem.isChecked(): self.visible_length = vlen def scaling_base_change(self, ignore=None): for menuitem, scaling_base in self.menuitems_scaling_base: if menuitem.isChecked(): self.scaling_base = scaling_base def scalingmode_change(self, ignore=None): for menuitem, scaling_key in self.menuitems_scaling: if menuitem.isChecked(): self.scaling_key = scaling_key def apply_scaling_hooks(self, data_ranges): for k in sorted(self.scaling_hooks.keys()): hook = self.scaling_hooks[k] hook(data_ranges) def set_scaling_hook(self, k, hook): self.scaling_hooks[k] = hook def remove_scaling_hook(self, k): del self.scaling_hooks[k] def remove_scaling_hooks(self): self.scaling_hooks = {} def s_sortingmode_change(self, ignore=None): for menuitem, valfunc in self.menuitems_ssorting: if menuitem.isChecked(): self._ssort = valfunc self.sortingmode_change() def sortingmode_change(self, ignore=None): for menuitem, (gather, order, color) in self.menuitems_sorting: if menuitem.isChecked(): self.set_gathering(gather, order, color) self.sortingmode_change_time = time.time() def lowpass_change(self, value, ignore=None): self.lowpass = value self.passband_check() self.tf_cache = {} self.update() def highpass_change(self, value, ignore=None): self.highpass = value self.passband_check() self.tf_cache = {} self.update() def passband_check(self): if self.highpass and self.lowpass \ and self.highpass >= self.lowpass: self.message = 'Corner frequency of highpass larger than ' \ 'corner frequency of lowpass! I will now ' \ 'deactivate the highpass.' self.update_status() else: oldmess = self.message self.message = None if oldmess is not None: self.update_status() def gain_change(self, value, ignore): self.gain = value self.update() def rot_change(self, value, ignore): self.rotate = value self.update() def set_selected_markers(self, markers): '''Set a list of markers selected :param markers: list of markers ''' self.deselect_all() for m in markers: m.set_selected(True) self.update() def deselect_all(self): for marker in self.markers: marker.set_selected(False) def animate_picking(self): point = self.mapFromGlobal(qg.QCursor.pos()) self.update_picking(point.x(), point.y(), doshift=True) def get_nslc_ids_for_track(self, ftrack): itrack = int(ftrack) if itrack in self.track_to_nslc_ids: return self.track_to_nslc_ids[int(ftrack)] else: return [] def stop_picking(self, x, y, abort=False): if self.picking: self.update_picking(x, y, doshift=False) self.picking = None self.picking_down = None self.picking_timer.stop() self.picking_timer = None if not abort: self.add_marker(self.floating_marker) self.floating_marker.set_selected(True) self.emit_selected_markers() self.floating_marker = None def start_picking(self, ignore): if not self.picking: self.deselect_all() self.picking = qw.QRubberBand(qw.QRubberBand.Rectangle) point = self.mapFromGlobal(qg.QCursor.pos()) gpoint = self.mapToGlobal(qc.QPoint(point.x(), 0)) self.picking.setGeometry( gpoint.x(), gpoint.y(), 1, self.height()) t = self.time_projection.rev(point.x()) ftrack = self.track_to_screen.rev(point.y()) nslc_ids = self.get_nslc_ids_for_track(ftrack) self.floating_marker = Marker(nslc_ids, t, t) self.floating_marker.set_selected(True) self.picking_timer = qc.QTimer() self.picking_timer.timeout.connect( self.animate_picking) self.picking_timer.setInterval(50) self.picking_timer.start() def update_picking(self, x, y, doshift=False): if self.picking: mouset = self.time_projection.rev(x) dt = 0.0 if mouset < self.tmin or mouset > self.tmax: if mouset < self.tmin: dt = -(self.tmin - mouset) else: dt = mouset - self.tmax ddt = self.tmax-self.tmin dt = max(dt, -ddt/10.) dt = min(dt, ddt/10.) x0 = x if self.picking_down is not None: x0 = self.time_projection(self.picking_down[0]) w = abs(x-x0) x0 = min(x0, x) tmin, tmax = ( self.time_projection.rev(x0), self.time_projection.rev(x0+w)) tmin, tmax = ( max(working_system_time_range[0], tmin), min(working_system_time_range[1], tmax)) p1 = self.mapToGlobal(qc.QPoint(x0, 0)) self.picking.setGeometry( p1.x(), p1.y(), max(w, 1), self.height()) ftrack = self.track_to_screen.rev(y) nslc_ids = self.get_nslc_ids_for_track(ftrack) self.floating_marker.set(nslc_ids, tmin, tmax) if dt != 0.0 and doshift: self.interrupt_following() self.set_time_range(self.tmin+dt, self.tmax+dt) self.update() def update_status(self): if self.message is None: point = self.mapFromGlobal(qg.QCursor.pos()) mouse_t = self.time_projection.rev(point.x()) if not is_working_time(mouse_t): return if self.floating_marker: tmi, tma = ( self.floating_marker.tmin, self.floating_marker.tmax) tt, ms = gmtime_x(tmi) if tmi == tma: message = mystrftime( fmt='Pick: %Y-%m-%d %H:%M:%S .%r', tt=tt, milliseconds=ms) else: srange = '%g s' % (tma-tmi) message = mystrftime( fmt='Start: %Y-%m-%d %H:%M:%S .%r Length: '+srange, tt=tt, milliseconds=ms) else: tt, ms = gmtime_x(mouse_t) message = mystrftime(fmt=None, tt=tt, milliseconds=ms) else: message = self.message sb = self.window().statusBar() sb.clearMessage() sb.showMessage(message) def set_sortingmode_change_delay_time(self, dt): self.sortingmode_change_delay_time = dt def sortingmode_change_delayed(self): now = time.time() return ( self.sortingmode_change_delay_time is not None and now - self.sortingmode_change_time < self.sortingmode_change_delay_time) def set_visible_marker_kinds(self, kinds): self.deselect_all() self.visible_marker_kinds = tuple(kinds) def following(self): return self.follow_timer is not None \ and not self.following_interrupted() def interrupt_following(self): self.interactive_range_change_time = time.time() def following_interrupted(self, now=None): if now is None: now = time.time() return now - self.interactive_range_change_time \ < self.interactive_range_change_delay_time def follow(self, tlen, interval=50, lapse=None, tmax_start=None): if tmax_start is None: tmax_start = time.time() self.show_all = False self.follow_time = tlen self.follow_timer = qc.QTimer(self) self.follow_timer.timeout.connect( self.follow_update) self.follow_timer.setInterval(interval) self.follow_timer.start() self.follow_started = time.time() self.follow_lapse = lapse self.follow_tshift = self.follow_started - tmax_start self.interactive_range_change_time = 0.0 def unfollow(self): if self.follow_timer is not None: self.follow_timer.stop() self.follow_timer = None self.interactive_range_change_time = 0.0 def follow_update(self): rnow = time.time() if self.follow_lapse is None: now = rnow else: now = self.follow_started + (rnow - self.follow_started) \ * self.follow_lapse if self.following_interrupted(rnow): return self.set_time_range( now-self.follow_time-self.follow_tshift, now-self.follow_tshift) self.update() def myclose(self, return_tag=''): self.timer.stop() if self.follow_timer is not None: self.follow_timer.stop() self.window().close() for snuffling in list(self.snufflings): self.remove_snuffling(snuffling) self.about_to_close.emit() self.return_tag = return_tag def set_error_message(self, key, value): if value is None: if key in self.error_messages: del self.error_messages[key] else: self.error_messages[key] = value def inputline_changed(self, text): pass def inputline_finished(self, text): line = str(text) toks = line.split() clearit, hideit, error = False, True, None if len(toks) >= 1: command = toks[0].lower() try: quick_filter_commands = { 'n': '%s.*.*.*', 's': '*.%s.*.*', 'l': '*.*.%s.*', 'c': '*.*.*.%s'} if command in quick_filter_commands: if len(toks) >= 2: patterns = [ quick_filter_commands[toks[0]] % pat for pat in toks[1:]] self.set_quick_filter_patterns(patterns, line) else: self.set_quick_filter_patterns(None) self.update() elif command in ('hide', 'unhide'): if len(toks) >= 2: patterns = [] if len(toks) == 2: patterns = [toks[1]] elif len(toks) >= 3: x = { 'n': '%s.*.*.*', 's': '*.%s.*.*', 'l': '*.*.%s.*', 'c': '*.*.*.%s'} if toks[1] in x: patterns.extend( x[toks[1]] % tok for tok in toks[2:]) for pattern in patterns: if command == 'hide': self.add_blacklist_pattern(pattern) else: self.remove_blacklist_pattern(pattern) elif command == 'unhide' and len(toks) == 1: self.clear_blacklist() clearit = True self.update() elif command == 'markers': if len(toks) == 2: if toks[1] == 'all': kinds = self.all_marker_kinds else: kinds = [] for x in toks[1]: try: kinds.append(int(x)) except Exception: pass self.set_visible_marker_kinds(kinds) elif len(toks) == 1: self.set_visible_marker_kinds(()) self.update() elif command == 'scaling': if len(toks) == 2: hideit = False error = 'wrong number of arguments' if len(toks) >= 3: vmin, vmax = [ pyrocko.model.float_or_none(x) for x in toks[-2:]] def upd(d, k, vmin, vmax): if k in d: if vmin is not None: d[k] = vmin, d[k][1] if vmax is not None: d[k] = d[k][0], vmax if len(toks) == 1: self.remove_scaling_hooks() elif len(toks) == 3: def hook(data_ranges): for k in data_ranges: upd(data_ranges, k, vmin, vmax) self.set_scaling_hook('_', hook) elif len(toks) == 4: pattern = toks[1] def hook(data_ranges): for k in pyrocko.util.match_nslcs( pattern, list(data_ranges.keys())): upd(data_ranges, k, vmin, vmax) self.set_scaling_hook(pattern, hook) elif command == 'goto': toks2 = line.split(None, 1) if len(toks2) == 2: arg = toks2[1] m = re.match( r'^\d\d\d\d(-\d\d(-\d\d( \d\d(:\d\d' r'(:\d\d(\.\d+)?)?)?)?)?)?$', arg) if m: tlen = None if not m.group(1): tlen = 12*32*24*60*60 elif not m.group(2): tlen = 32*24*60*60 elif not m.group(3): tlen = 24*60*60 elif not m.group(4): tlen = 60*60 elif not m.group(5): tlen = 60 supl = '1970-01-01 00:00:00' if len(supl) > len(arg): arg = arg + supl[-(len(supl)-len(arg)):] t = pyrocko.util.str_to_time(arg) self.go_to_time(t, tlen=tlen) elif re.match(r'^\d\d:\d\d(:\d\d(\.\d+)?)?$', arg): supl = '00:00:00' if len(supl) > len(arg): arg = arg + supl[-(len(supl)-len(arg)):] tmin, tmax = self.get_time_range() sdate = pyrocko.util.time_to_str( tmin/2.+tmax/2., format='%Y-%m-%d') t = pyrocko.util.str_to_time(sdate + ' ' + arg) self.go_to_time(t) else: self.go_to_event_by_name(arg) else: raise PileViewerMainException( 'No such command: %s' % command) except PileViewerMainException as e: error = str(e) hideit = False return clearit, hideit, error return PileViewerMain
PileViewerMain = MakePileViewerMainClass(qw.QWidget) GLPileViewerMain = MakePileViewerMainClass(qgl.QGLWidget)
[docs]class LineEditWithAbort(qw.QLineEdit): aborted = qc.pyqtSignal() history_down = qc.pyqtSignal() history_up = qc.pyqtSignal()
[docs] def keyPressEvent(self, key_event): if key_event.key() == qc.Qt.Key_Escape: self.aborted.emit() elif key_event.key() == qc.Qt.Key_Down: self.history_down.emit() elif key_event.key() == qc.Qt.Key_Up: self.history_up.emit() else: return qw.QLineEdit.keyPressEvent(self, key_event)
[docs]class PileViewer(qw.QFrame): '''PileViewerMain + Controls + Inputline''' def __init__( self, pile, ntracks_shown_max=20, use_opengl=False, panel_parent=None, *args): qw.QFrame.__init__(self, *args) if use_opengl: self.viewer = GLPileViewerMain( pile, ntracks_shown_max=ntracks_shown_max, panel_parent=panel_parent) else: self.viewer = PileViewerMain( pile, ntracks_shown_max=ntracks_shown_max, panel_parent=panel_parent) layout = qw.QGridLayout() self.setLayout(layout) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) self.setFrameShape(qw.QFrame.StyledPanel) self.setFrameShadow(qw.QFrame.Sunken) self.input_area = qw.QFrame(self) ia_layout = qw.QGridLayout() ia_layout.setContentsMargins(11, 11, 11, 11) self.input_area.setLayout(ia_layout) self.inputline = LineEditWithAbort(self.input_area) self.inputline.returnPressed.connect( self.inputline_returnpressed) self.inputline.editingFinished.connect( self.inputline_finished) self.inputline.aborted.connect( self.inputline_aborted) self.inputline.history_down.connect( lambda: self.step_through_history(1)) self.inputline.history_up.connect( lambda: self.step_through_history(-1)) self.inputline.textEdited.connect( self.inputline_changed) self.inputline.setFocusPolicy(qc.Qt.ClickFocus) self.input_area.hide() self.history = None self.inputline_error_str = None self.inputline_error = qw.QLabel() self.inputline_error.hide() ia_layout.addWidget(self.inputline, 0, 0) ia_layout.addWidget(self.inputline_error, 1, 0) layout.addWidget(self.input_area, 0, 0, 1, 2) layout.addWidget(self.viewer, 1, 0) pb = Progressbars(self) layout.addWidget(pb, 2, 0, 1, 2) self.progressbars = pb scrollbar = qw.QScrollBar(qc.Qt.Vertical) self.scrollbar = scrollbar layout.addWidget(scrollbar, 1, 1) self.scrollbar.valueChanged.connect( self.scrollbar_changed) self.block_scrollbar_changes = False self.viewer.want_input.connect( self.inputline_show) self.viewer.tracks_range_changed.connect( self.tracks_range_changed) self.viewer.pile_has_changed_signal.connect( self.adjust_controls) self.viewer.about_to_close.connect( self.save_inputline_history)
[docs] def get_progressbars(self): return self.progressbars
[docs] def inputline_show(self): if not self.history: self.load_inputline_history() self.input_area.show() self.inputline.setFocus(qc.Qt.OtherFocusReason) self.inputline.selectAll()
[docs] def inputline_set_error(self, string): self.inputline_error_str = string self.inputline.setPalette(pyrocko.gui.util.get_err_palette()) self.inputline.selectAll() self.inputline_error.setText(string) self.input_area.show() self.inputline_error.show()
[docs] def inputline_clear_error(self): if self.inputline_error_str: self.inputline.setPalette(qw.QApplication.palette()) self.inputline_error_str = None self.inputline_error.clear() self.inputline_error.hide()
[docs] def inputline_changed(self, line): self.viewer.inputline_changed(str(line)) self.inputline_clear_error()
[docs] def inputline_returnpressed(self): line = str(self.inputline.text()) clearit, hideit, error = self.viewer.inputline_finished(line) if error: self.inputline_set_error(error) line = line.strip() if line != '' and not error: if len(self.history) >= 1 and line == self.history[-1]: return self.history.append(line) if clearit: self.inputline.blockSignals(True) qpat, qinp = self.viewer.get_quick_filter_patterns() if qpat is None: self.inputline.clear() else: self.inputline.setText(qinp) self.inputline.blockSignals(False) if hideit and not error: self.viewer.setFocus(qc.Qt.OtherFocusReason) self.input_area.hide() self.hist_ind = len(self.history)
[docs] def inputline_aborted(self): '''Hide the input line.''' self.viewer.setFocus(qc.Qt.OtherFocusReason) self.hist_ind = len(self.history) self.input_area.hide()
[docs] def save_inputline_history(self): ''' Save input line history to "$HOME/.pyrocko/.snuffler_history.pf" ''' if not self.history: return conf = pyrocko.config fn_hist = conf.expand(conf.make_conf_path_tmpl('.snuffler_history')) with open(fn_hist, 'w') as f: i = min(100, len(self.history)) for c in self.history[-i:]: f.write('%s\n' % c)
[docs] def load_inputline_history(self): ''' Load input line history from "$HOME/.pyrocko/.snuffler_history.pf" ''' conf = pyrocko.config fn_hist = conf.expand(conf.make_conf_path_tmpl('.snuffler_history')) if not os.path.exists(fn_hist): with open(fn_hist, 'w+') as f: f.write('\n') with open(fn_hist, 'r') as f: self.history = [l.strip() for l in f.readlines()] self.hist_ind = len(self.history)
[docs] def step_through_history(self, ud=1): ''' Step through input line history and set the input line text. ''' n = len(self.history) self.hist_ind += ud self.hist_ind %= (n + 1) if len(self.history) != 0 and self.hist_ind != n: self.inputline.setText(self.history[self.hist_ind]) else: self.inputline.setText('')
[docs] def inputline_finished(self): pass
[docs] def tracks_range_changed(self, ntracks, ilo, ihi): if self.block_scrollbar_changes: return self.scrollbar.blockSignals(True) self.scrollbar.setPageStep(ihi-ilo) vmax = max(0, ntracks-(ihi-ilo)) self.scrollbar.setRange(0, vmax) self.scrollbar.setValue(ilo) self.scrollbar.setHidden(vmax == 0) self.scrollbar.blockSignals(False)
[docs] def scrollbar_changed(self, value): self.block_scrollbar_changes = True ilo = value ihi = ilo + self.scrollbar.pageStep() self.viewer.set_tracks_range((ilo, ihi)) self.block_scrollbar_changes = False self.update_contents()
[docs] def controls(self): frame = qw.QFrame(self) layout = qw.QGridLayout() frame.setLayout(layout) minfreq = 0.001 maxfreq = 1000.0 self.lowpass_control = ValControl(high_is_none=True) self.lowpass_control.setup( 'Lowpass [Hz]:', minfreq, maxfreq, maxfreq, 0) self.highpass_control = ValControl(low_is_none=True) self.highpass_control.setup( 'Highpass [Hz]:', minfreq, maxfreq, minfreq, 1) self.gain_control = ValControl() self.gain_control.setup('Gain:', 0.001, 1000., 1., 2) self.rot_control = LinValControl() self.rot_control.setup('Rotate [deg]:', -180., 180., 0., 3) self.lowpass_control.valchange.connect( self.viewer.lowpass_change) self.highpass_control.valchange.connect( self.viewer.highpass_change) self.gain_control.valchange.connect( self.viewer.gain_change) self.rot_control.valchange.connect( self.viewer.rot_change) for icontrol, control in enumerate(( self.highpass_control, self.lowpass_control, self.gain_control, self.rot_control)): for iwidget, widget in enumerate(control.widgets()): layout.addWidget(widget, icontrol, iwidget) spacer = qw.QSpacerItem( 0, 0, qw.QSizePolicy.Expanding, qw.QSizePolicy.Expanding) layout.addItem(spacer, 4, 0, 1, 3) self.adjust_controls() return frame
[docs] def marker_editor(self): editor = pyrocko.gui.marker_editor.MarkerEditor(self) editor.set_viewer(self.get_view()) editor.get_marker_model().dataChanged.connect( self.update_contents) return editor
[docs] def adjust_controls(self): dtmin, dtmax = self.viewer.content_deltat_range() maxfreq = 0.5/dtmin minfreq = (0.5/dtmax)*0.001 self.lowpass_control.set_range(minfreq, maxfreq) self.highpass_control.set_range(minfreq, maxfreq)
[docs] def setup_snufflings(self): self.viewer.setup_snufflings()
[docs] def get_view(self): return self.viewer
[docs] def update_contents(self): self.viewer.update()
[docs] def get_pile(self): return self.viewer.get_pile()