def trigger(self, *args):
image = os.path.join(matplotlib.rcParams['datapath'], 'images',
'matplotlib.png')
parent = self.canvas.manager.window
dia = SubplotToolQt(self.figure, parent)
dia.setWindowIcon(QtGui.QIcon(image))
dia.exec_()
def set_color(self, color):
if color != self._color:
self._color = color
self.colorChanged.emit(self._color)
pixmap = QtGui.QPixmap(self.iconSize())
pixmap.fill(color)
self.setIcon(QtGui.QIcon(pixmap))
def _icon(self, name):
if is_pyqt5():
name = name.replace('.png', '_large.png')
pm = QtGui.QPixmap(os.path.join(self.basedir, name))
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(self.canvas._dpi_ratio)
return QtGui.QIcon(pm)
def __init__(self, cesta_projekt):
super().__init__()
self.setWindowIcon(QtGui.QIcon('foto.jpg'))
_translate = QtCore.QCoreApplication.translate
self.setWindowTitle(_translate("Dialog", "Grafika"))
self._main = QtWidgets.QWidget()
self.cesta = cesta_projekt
self.setCentralWidget(self._main)
layout = QtWidgets.QVBoxLayout(self._main)
static_canvas = FigureCanvas(Figure(figsize=(20, 20)))
layout.addWidget(static_canvas)
self.addToolBar(NavigationToolbar(static_canvas, self))
self._static_ax = static_canvas.figure.subplots()
query = "select Y, X, CB from gps_sour"
sour = Databaze.sql_query(self.cesta, query)
y = []
x = []
for i in range(0, len(sour)):
Y = -sour[i][0]
X = -sour[i][1]
CB = sour[i][2]
y.append(Y)
x.append(X)
self._static_ax.text(Y, X, CB)
self._static_ax.plot(y, x, "+")
self._static_ax.axis('equal')
self.show()
def _icon(name):
direct = os.path.dirname(__file__)
name = os.path.join(direct, name)
pm = QtGui.QPixmap(name)
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(fig.canvas._dpi_ratio)
return QtGui.QIcon(pm)
def __init__(self, l, r, u, d, parent=None):
""""""
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle('Set Heatmap Domain')
self.setWindowIcon(QtGui.QIcon('kiwi.png'))
self.setMinimumWidth(400)
self.header = QtWidgets.QLabel("All distances are relative to the array center.")
self.leftLabel = QtWidgets.QLabel("Left/West:")
self.lledit = QtWidgets.QLineEdit(self)
self.lledit.setText(str(l))
self.rightLabel = QtWidgets.QLabel("Right/East:")
self.rledit = QtWidgets.QLineEdit(self)
self.rledit.setText(str(r))
self.upLabel = QtWidgets.QLabel("Up/North:")
self.uledit = QtWidgets.QLineEdit(self)
self.uledit.setText(str(u))
self.downLabel = QtWidgets.QLabel("Down/South:")
self.dledit = QtWidgets.QLineEdit(self)
self.dledit.setText(str(d))
self.activate = QtWidgets.QPushButton("Set")
Box = QtWidgets.QVBoxLayout()
Box.addWidget(self.header)
left = QtWidgets.QHBoxLayout()
left.addWidget(self.leftLabel)
left.addWidget(self.lledit)
right = QtWidgets.QHBoxLayout()
right.addWidget(self.rightLabel)
right.addWidget(self.rledit)
up = QtWidgets.QHBoxLayout()
up.addWidget(self.upLabel)
up.addWidget(self.uledit)
down = QtWidgets.QHBoxLayout()
down.addWidget(self.downLabel)
down.addWidget(self.dledit)
Box.addLayout(left)
Box.addLayout(right)
Box.addLayout(up)
Box.addLayout(down)
Box.addWidget(self.activate)
# Now put everything into the frame
self.setLayout(Box)
def _init_toolbar(self):
#self.basedir = os.path.join(matplotlib.rcParams['datapath'], 'images')
iconDir = os.path.join(os.path.dirname(os.path.abspath(__file__)),'icons', '')
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
self.addSeparator()
else:
# a = self.addAction(self._icon(iconDir + image_file + '.png'),
# text, getattr(self, callback))
a = self.addAction(QtGui.QIcon(iconDir + image_file + '.png'),
text, getattr(self, callback))
self._actions[callback] = a
if callback in ['zoom', 'pan', 'cursorcluster', 'radiomode', 'shapemode', 'selectedmode']:
a.setCheckable(True)
if tooltip_text is not None:
a.setToolTip(tooltip_text)
if figureoptions is not None:
# a = self.addAction(self._icon("qt4_editor_options.png"),
# 'Customize', self.edit_parameters)
a = self.addAction(QtGui.QIcon("qt4_editor_options.png"),
'Customize', self.edit_parameters)
a.setToolTip('Edit curves line and axes parameters')
self.buttons = {}
# Add the x,y location widget at the right side of the toolbar
# The stretch factor is 1 which means any resizing of the toolbar
# will resize this label instead of the buttons.
if self.coordinates:
self.locLabel = QtWidgets.QLabel("", self)
self.locLabel.setAlignment(
QtCore.Qt.AlignRight | QtCore.Qt.AlignTop)
self.locLabel.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Ignored))
labelAction = self.addWidget(self.locLabel)
labelAction.setVisible(True)
# reference holder for subplots_adjust window
self.adj_window = None
def _icon(self, name, color=None):
if is_pyqt5():
name = name.replace('.png', '_large.png')
pm = QtGui.QPixmap(os.path.join(self.basedir, name))
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(self.canvas._dpi_ratio)
if color is not None:
mask = pm.createMaskFromColor(QtGui.QColor('black'),
QtCore.Qt.MaskOutColor)
pm.fill(color)
pm.setMask(mask)
return QtGui.QIcon(pm)
def setup_file_actions(self):
self.actions['exit'] = create_action(
'&Exit',
parent=self,
tip='Exit application',
shortcut='Ctrl+Q',
icon=QtGui.QIcon('exit.png'),
connect=QtWidgets.qApp.quit,
add_to=self.file_menu
)
self.actions['remove_interval_markings'] = create_action(
'&Remove markings in displayed interval',
parent=self,
connect=self.delete_visible_markings_in_displayed_interval,
add_to=self.file_menu,
shortcut='Ctrl+R'
)
self.actions['load_markings'] = create_action(
'&Load markings for visible series',
parent=self,
connect=lambda: self.model.load_markings(only_visible=True),
add_to=self.file_menu,
)
self.actions['save_markings'] = create_action(
'Save &markings for visible series',
parent=self,
connect=lambda: self.model.save_markings(only_visible=True),
add_to=self.file_menu
)
self.actions['save_interval_cleaned'] = create_action(
'Save visible series as cleaned',
parent=self,
connect=lambda: self.model.tag_items(
tag=CLEANED,
only_visible=True
),
add_to=self.file_menu,
)
self.actions['save_interval_cleaned_between_markings'] = create_action(
'Save visible series as cleaned between outer markings',
parent=self,
connect=lambda: self.model.tag_items_between_outer_markings(
tag=CLEANED,
only_visible=True
),
add_to=self.file_menu,
)
def __init__(self):
# Set window param
super(ApplicationWindow, self).__init__()
self._main = QtWidgets.QWidget()
self.setCentralWidget(self._main)
layout = QtWidgets.QVBoxLayout(self._main)
self.setWindowTitle('Visited Countries World Map')
self.setWindowIcon(QtGui.QIcon('icon.ico'))
# Initialize canvas
self.canvas = WorldMapCanvas()
layout.addWidget(self.canvas)
# Add toolbar
self.addToolBar(NavigationToolbar(self.canvas, self))
# Set up event handlers
self.canvas.mpl_connect('button_press_event', self.on_click)
self.canvas.mpl_connect('motion_notify_event', self.on_move)
def __init__(self, cur_locs=[[0, 0], [0, 1], [1, 0], [1, 1]], parent=None):
""""""
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle('Set Array Configuration Information')
self.setWindowIcon(QtGui.QIcon('kiwi.png'))
self.setMinimumWidth(400)
self.coordsLabel = QtWidgets.QLabel("Coordinates")
self.name1 = QtWidgets.QPlainTextEdit(self)
self.name1.setPlainText(self.arrayToStr(cur_locs))
self.activate = QtWidgets.QPushButton("Set")
Box = QtWidgets.QVBoxLayout()
Box.addWidget(self.coordsLabel)
Box.addWidget(self.name1)
Box.addWidget(self.activate)
# Now put everything into the frame
self.setLayout(Box)
def __init__(self, coords=(0., 0.), EPSG=4326, pEPSG=2193, tEPSG=3857, parent=None):
""""""
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle('Set GPS Array Information')
self.setWindowIcon(QtGui.QIcon('kiwi.png'))
self.setMinimumWidth(400)
self.coordsLabel = QtWidgets.QLabel("Coordinates")
self.name1 = QtWidgets.QLineEdit(self)
self.name1.setText(str(coords)[1:-1])
self.EPSGLabel = QtWidgets.QLabel("EPSG")
self.name2 = QtWidgets.QLineEdit(self)
self.name2.setText(str(EPSG))
self.EPSGLabel2 = QtWidgets.QLabel("Local Projected EPSG")
self.name3 = QtWidgets.QLineEdit(self)
self.name3.setText(str(pEPSG))
self.EPSGLabel3 = QtWidgets.QLabel("Target EPSG")
self.name4 = QtWidgets.QLineEdit(self)
self.name4.setText(str(tEPSG))
self.name4.setStatusTip("Save the current display to a PNG file.")
self.activate = QtWidgets.QPushButton("Set")
Box = QtWidgets.QVBoxLayout()
Box.addWidget(self.coordsLabel)
Box.addWidget(self.name1)
Box.addWidget(self.EPSGLabel)
Box.addWidget(self.name2)
Box.addWidget(self.EPSGLabel2)
Box.addWidget(self.name3)
Box.addWidget(self.EPSGLabel3)
Box.addWidget(self.name4)
Box.addWidget(self.activate)
# Now put everything into the frame
self.setLayout(Box)
def _icon(self, name):
return QtGui.QIcon(os.path.join(self.media, name))
def __init__(self, canvas, num):
FigureManagerBase.__init__(self, canvas, num)
self.canvas = canvas
self.window = MainWindow()
self.window.closing.connect(canvas.close_event)
self.window.closing.connect(self._widgetclosed)
self.window.setWindowTitle("Figure %d" % num)
image = os.path.join(matplotlib.rcParams['datapath'], 'images',
'matplotlib.svg')
self.window.setWindowIcon(QtGui.QIcon(image))
# Give the keyboard focus to the figure instead of the
# manager; StrongFocus accepts both tab and click to focus and
# will enable the canvas to process event w/o clicking.
# ClickFocus only takes the focus is the window has been
# clicked
# on. http://qt-project.org/doc/qt-4.8/qt.html#FocusPolicy-enum or
# http://doc.qt.digia.com/qt/qt.html#FocusPolicy-enum
self.canvas.setFocusPolicy(QtCore.Qt.StrongFocus)
self.canvas.setFocus()
self.window._destroying = False
self.toolmanager = self._get_toolmanager()
self.toolbar = self._get_toolbar(self.canvas, self.window)
self.statusbar = None
if self.toolmanager:
backend_tools.add_tools_to_manager(self.toolmanager)
if self.toolbar:
backend_tools.add_tools_to_container(self.toolbar)
self.statusbar = StatusbarQt(self.window, self.toolmanager)
if self.toolbar is not None:
self.window.addToolBar(self.toolbar)
if not self.toolmanager:
# add text label to status bar
statusbar_label = QtWidgets.QLabel()
self.window.statusBar().addWidget(statusbar_label)
self.toolbar.message.connect(statusbar_label.setText)
tbs_height = self.toolbar.sizeHint().height()
else:
tbs_height = 0
# resize the main window so it will display the canvas with the
# requested size:
cs = canvas.sizeHint()
sbs = self.window.statusBar().sizeHint()
self._status_and_tool_height = tbs_height + sbs.height()
height = cs.height() + self._status_and_tool_height
self.window.resize(cs.width(), height)
self.window.setCentralWidget(self.canvas)
if matplotlib.is_interactive():
self.window.show()
self.canvas.draw_idle()
def notify_axes_change(fig):
# This will be called whenever the current axes is changed
if self.toolbar is not None:
self.toolbar.update()
self.canvas.figure.add_axobserver(notify_axes_change)
self.window.raise_()
def __init__(self):
super(ApplicationWindow, self).__init__()
# self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self._main = QtWidgets.QStackedWidget()
self.file_name = "NO NAME"
# self._main = QtWidgets.QWidget()
self.setCentralWidget(self._main)
# self.setWindowTitle("UHSLC QC Software")
self.setWindowIcon(QtGui.QIcon('uhslclogotext72_pfL_icon.ico'))
self.resize(1837, 1200)
# Create Screen objects
self.start_screen = Start(self)
self.second_screen = HelpScreen(self)
self._main.addWidget(self.start_screen)
self._main.addWidget(self.second_screen)
self._main.setCurrentWidget(self.start_screen)
self.start_screen.clicked.connect(
lambda: self._main.setCurrentWidget(self.second_screen))
self.second_screen.clicked.connect(
lambda: self._main.setCurrentWidget(self.start_screen))
self.setStatusTip("Permanent status bar")
# Create an action in the menu bar that is later on assigned to one of
# the options (e.g. File, Edit, View etc) in the menu bar
close_app = QtWidgets.QAction("&Exit", self)
close_app.setShortcut("Ctrl+Q")
# Show the tip in the status bar on hover
close_app.setStatusTip('Leave the app')
close_app.triggered.connect(self.close_application)
open_help_menu = QtWidgets.QAction("&Instructions", self)
open_help_menu.setShortcut("F1")
open_help_menu.triggered.connect(self.start_screen.clicked.emit)
# open_help_menu.triggered.connect(self.open_help_menu)
open_file = QtWidgets.QAction("&Open monp", self)
open_file.setShortcut("Ctrl+O")
open_file.setStatusTip('Load a File')
open_file.triggered.connect(self.file_open)
reload_file = QtWidgets.QAction("&Reload", self)
reload_file.setShortcut("Ctrl+R")
reload_file.setStatusTip('Reload all file(s) that were loaded')
reload_file.triggered.connect(self.get_loaded_files)
opents_file = QtWidgets.QAction("&Open ts", self)
opents_file.setShortcut("Ctrl+T")
opents_file.setStatusTip('Opens ts folder')
opents_file.triggered.connect(self.open_ts)
self.statusBar()
# Create dropwon menu
main_menu = self.menuBar()
# Add options to the menuBar
file_menu = main_menu.addMenu('&File')
help_menu = main_menu.addMenu('&Help')
# Connect action with the option
file_menu.addAction(open_file)
file_menu.addAction(reload_file)
file_menu.addAction(opents_file)
file_menu.addAction(close_app)
help_menu.addAction(open_help_menu)
def configure_subplots(self):
image = os.path.join(matplotlib.rcParams['datapath'], 'images', 'matplotlib.png')
dia = CustomSubplotTool(self.canvas.figure, self.parent)
dia.setWindowIcon(QtGui.QIcon(image))
dia.exec_()
def _icon(self, name):
pm = QtGui.QPixmap(os.path.join(self.basedir, name))
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(self.canvas._dpi_ratio)
return QtGui.QIcon(pm)
def __init__(self):
"""Initialise the application - includes loading settings from disc, initialising a lakeator, and setting up the GUI."""
super().__init__()
self._load_settings()
self._main = QtWidgets.QWidget()
self.setCentralWidget(self._main)
layout = QtWidgets.QHBoxLayout(self._main)
self.setWindowTitle('Locator')
self.setWindowIcon(QtGui.QIcon("./kiwi.png"))
self.loadAction = QtWidgets.QAction("&Load File", self)
self.loadAction.setShortcut("Ctrl+L")
self.loadAction.setStatusTip("Load a multichannel .wav file.")
self.loadAction.triggered.connect(self.file_open)
self.saveAction = QtWidgets.QAction("&Save Image", self)
self.saveAction.setShortcut("Ctrl+S")
self.saveAction.setStatusTip("Save the current display to a PNG file.")
self.saveAction.triggered.connect(self.save_display)
self.saveAction.setDisabled(True)
self.saveGisAction = QtWidgets.QAction("&Save to GIS", self)
self.saveGisAction.setShortcut("Ctrl+G")
self.saveGisAction.setStatusTip(
"Save the heatmap as a QGIS-readable georeferenced TIFF file.")
self.saveGisAction.triggered.connect(self.exportGIS)
self.saveGisAction.setDisabled(True)
self.statusBar()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu("&File")
fileMenu.addAction(self.loadAction)
fileMenu.addAction(self.saveAction)
fileMenu.addAction(self.saveGisAction)
setArrayDesign = QtWidgets.QAction("&Configure Array Design", self)
setArrayDesign.setShortcut("Ctrl+A")
setArrayDesign.setStatusTip(
"Input relative microphone positions and array bearing.")
setArrayDesign.triggered.connect(self.get_array_info)
setGPSCoords = QtWidgets.QAction("&Set GPS Coordinates", self)
setGPSCoords.setShortcut("Ctrl+C")
setGPSCoords.setStatusTip(
"Set the GPS coordinates for the array, and ESPG code for the CRS."
)
setGPSCoords.triggered.connect(self.get_GPS_info)
arrayMenu = mainMenu.addMenu("&Array")
arrayMenu.addAction(setArrayDesign)
arrayMenu.addAction(setGPSCoords)
setDomain = QtWidgets.QAction("&Set Heatmap Domain", self)
setDomain.setShortcut("Ctrl+D")
setDomain.setStatusTip(
"Configure distances left/right up/down at which to generate the heatmap."
)
setDomain.triggered.connect(self.getBoundsInfo)
self.refreshHeatmap = QtWidgets.QAction("&Calculate", self)
self.refreshHeatmap.setShortcut("Ctrl+H")
self.refreshHeatmap.setStatusTip("(Re)calculate heatmap.")
self.refreshHeatmap.triggered.connect(self.generate_heatmap)
self.refreshHeatmap.setDisabled(True)
self.refreshView = QtWidgets.QAction("&Recalculate on View", self)
self.refreshView.setShortcut("Ctrl+R")
self.refreshView.setStatusTip(
"Recalculate heatmap at current zoom level.")
self.refreshView.triggered.connect(self.recalculateOnView)
self.refreshView.setDisabled(True)
heatmapMenu = mainMenu.addMenu("&Heatmap")
heatmapMenu.addAction(setDomain)
# Initialise canvas
self.static_canvas = FigureCanvas(Figure(figsize=(5, 3)))
layout.addWidget(self.static_canvas)
# Add a navbar
navbar = NavigationToolbar(self.static_canvas, self)
self.addToolBar(QtCore.Qt.BottomToolBarArea, navbar)
# Override the default mpl save functionality to change default filename
navbar._actions['save_figure'].disconnect()
navbar._actions['save_figure'].triggered.connect(self.save_display)
navbar._actions['home'].triggered.connect(lambda: print("testing"))
self.img = None
# Dynamically generate menu full of all available colourmaps. Do not add the inverted ones.
self.colMenu = heatmapMenu.addMenu("&Choose Colour Map")
self.colMenu.setDisabled(True)
colGroup = QtWidgets.QActionGroup(self)
for colour in sorted(colormaps(), key=str.casefold):
if colour[-2:] != "_r":
cm = self.colMenu.addAction(colour)
cm.setCheckable(True)
if colour == self.settings["heatmap"]["cmap"][:-2]:
cm.setChecked(True)
receiver = lambda checked, cmap=colour: self.img.set_cmap(cmap)
cm.triggered.connect(receiver)
cm.triggered.connect(self._setcol)
cm.triggered.connect(self.static_canvas.draw)
colGroup.addAction(cm)
self.invert = QtWidgets.QAction("&Invert Colour Map", self)
self.invert.setShortcut("Ctrl+I")
self.invert.setStatusTip("Invert the current colourmap.")
self.invert.triggered.connect(self.invert_heatmap)
self.invert.setCheckable(True)
self.invert.setDisabled(True)
heatmapMenu.addAction(self.invert)
heatmapMenu.addSeparator()
heatmapMenu.addAction(self.refreshHeatmap)
heatmapMenu.addAction(self.refreshView)
algoMenu = mainMenu.addMenu("Algorithm")
self.algChoice = algoMenu.addMenu("&Change Algorithm")
algGroup = QtWidgets.QActionGroup(self)
for alg in sorted(["GCC", "MUSIC", "AF-MUSIC"], key=str.casefold):
cm = self.algChoice.addAction(alg)
cm.setCheckable(True)
if alg == self.settings["algorithm"]["current"]:
cm.setChecked(True)
receiver = lambda checked, al=alg: self.setAlg(al)
cm.triggered.connect(receiver)
colGroup.addAction(cm)
self.params = QtWidgets.QAction("&Algorithm Settings", self)
self.params.setStatusTip("Alter algorithm-specific settings.")
self.params.triggered.connect(self.getAlgoInfo)
algoMenu.addAction(self.params)
# Display a "ready" message
self.statusBar().showMessage('Ready')
# Boolean to keep track of whether we have GPS information for the array, and an image
self._has_GPS = False
self._has_heatmap = False
# Keep track of the currently opened file
self.open_filename = ""
self.loc = lakeator.Lakeator(self.settings["array"]["mic_locations"])
def _icon(self, name):
return QtGui.QIcon(os.path.join(self.basedir, name))
def trigger(self, *args, **kwargs):
all_axes = self.figure.get_axes()
if not all_axes:
QMessageBox.warning(
self.figure.canvas.parent(),
"Error", "There are no axes to edit.")
return
elif len(all_axes) == 1:
axis = all_axes[0]
elif self.x_axis_type in {"GST", "LST", "UT"}:
# edit all axes at the same time,
# only makes sense if same data shape is edited
axis = all_axes[-1]
else:
titles = [
ax.get_label() or
ax.get_title() or
" - ".join(filter(None, [ax.get_xlabel(), ax.get_ylabel()])) or
f"<anonymous {type(ax).__name__}>"
for ax in all_axes]
duplicate_titles = [
title for title in titles if titles.count(title) > 1]
for i, ax in enumerate(all_axes):
if titles[i] in duplicate_titles:
titles[i] += f" (id: {id(ax):#x})" # Deduplicate titles.
item, ok = QInputDialog.getItem(
self.figure.canvas.parent(), "Customize", "Select axes:",
titles, 0, False)
if not ok:
return
axis = all_axes[titles.index(item)]
sep = (None, None) # separator
has_curve = len(axis.get_lines()) > 0
# Get / General
if self.x_axis_type in ["GST", "LST"]:
xmin, xmax = (matplotlib.dates._from_ordinalf(l)
for l in axis.get_xlim())
elif self.x_axis_type == "UT":
xmin, xmax = (matplotlib.dates._from_ordinalf(l)
for l in axis.get_xlim())
else:
xmin, xmax = axis.get_xlim()
ymin, ymax = axis.get_ylim()
general = [('Title', axis.get_title()),
sep,
(None, "<b>X-Axis</b>"),
('Min', xmin),
('Max', xmax),
('Scale', [axis.get_xscale(), 'linear', 'log']),
sep,
(None, "<b>Y-Axis</b>"),
('Min', ymin),
('Max', ymax),
('Scale', [axis.get_yscale(), 'linear', 'log']),
sep,
('(Re-)Generate automatic legend', False),
]
xmin_row = 3
xmax_row = 4
# Save the unit data
xconverter = axis.xaxis.converter
yconverter = axis.yaxis.converter
xunits = axis.xaxis.get_units()
yunits = axis.yaxis.get_units()
xformatter = axis.xaxis.get_major_formatter()
yformatter = axis.yaxis.get_major_formatter()
if has_curve:
# Get / Curves
linedict = {}
for line in axis.get_lines():
label = line.get_label()
if label == '_nolegend_':
continue
linedict[label] = line
curves = []
linestyles = list(six.iteritems(figureoptions.LINESTYLES))
drawstyles = list(six.iteritems(figureoptions.DRAWSTYLES))
markers = list(six.iteritems(figureoptions.MARKERS))
curvelabels = sorted(linedict.keys())
for label in curvelabels:
line = linedict[label]
color = rgb2hex(colorConverter.to_rgb(line.get_color()))
ec = rgb2hex(colorConverter.to_rgb(line.get_markeredgecolor()))
fc = rgb2hex(colorConverter.to_rgb(line.get_markerfacecolor()))
curvedata = [('Label', label),
sep,
(None, '<b>Line</b>'),
('Line Style',
[line.get_linestyle()] + linestyles),
('Draw Style',
[line.get_drawstyle()] + drawstyles),
('Width', line.get_linewidth()),
('Color', color),
sep,
(None, '<b>Marker</b>'),
('Style', [line.get_marker()] + markers),
('Size', line.get_markersize()),
('Facecolor', fc),
('Edgecolor', ec),
]
curves.append([curvedata, label, ""])
# make sure that there is at least one displayed curve
has_curve = bool(curves)
datalist = [(general, "Axes", "")]
if has_curve:
datalist.append((curves, "Curves", ""))
def apply_callback(data):
"""This function will be called to apply changes"""
if has_curve:
general, curves = data
else:
general, = data
# Set / General
title, xmin, xmax, xscale, ymin, ymax, yscale, \
generate_legend = general
axes_to_apply = [axis]
if self.x_axis_type in {"GST", "LST", "UT"}:
axes_to_apply = all_axes
for apply_to_axis in axes_to_apply:
apply_to_axis.set_xscale(xscale)
apply_to_axis.set_yscale(yscale)
apply_to_axis.set_title(title)
apply_to_axis.set_xlim(xmin, xmax)
apply_to_axis.set_ylim(ymin, ymax)
# Restore the unit data
apply_to_axis.xaxis.converter = xconverter
apply_to_axis.yaxis.converter = yconverter
apply_to_axis.xaxis.set_units(xunits)
apply_to_axis.yaxis.set_units(yunits)
apply_to_axis.xaxis.set_major_formatter(xformatter)
apply_to_axis.yaxis.set_major_formatter(yformatter)
apply_to_axis.xaxis._update_axisinfo()
apply_to_axis.yaxis._update_axisinfo()
if has_curve:
# Set / Curves
for index, curve in enumerate(curves):
line = linedict[curvelabels[index]]
label, linestyle, drawstyle, linewidth, color, \
marker, markersize, markerfacecolor, \
markeredgecolor = curve
line.set_label(label)
line.set_linestyle(linestyle)
line.set_drawstyle(drawstyle)
line.set_linewidth(linewidth)
line.set_color(color)
if marker != 'none':
line.set_marker(marker)
line.set_markersize(markersize)
line.set_markerfacecolor(markerfacecolor)
line.set_markeredgecolor(markeredgecolor)
# re-generate legend, if checkbox is checked
if generate_legend:
draggable = None
ncol = 1
if apply_to_axis.legend_ is not None:
old_legend = apply_to_axis.get_legend()
draggable = old_legend.get_draggable()
ncol = old_legend._ncol
new_legend = apply_to_axis.legend(ncol=ncol)
if new_legend:
new_legend.set_draggable(draggable)
# Redraw
figure = apply_to_axis.get_figure()
figure.canvas.draw()
dialog = FormDialogWrapper(
datalist,
title="Figure options",
icon=QtGui.QIcon(self.image),
apply=apply_callback)
axes_tab = dialog.formwidget.widgetlist[0]
if LooseVersion(formlayout.__version__) >= LooseVersion("1.2"):
# in version >= 1.2 the widgetlist elements are
# (title, widget) tuples
axes_tab = axes_tab[1]
if self.x_axis_type in ["GST", "LST"]:
layout = axes_tab.formlayout
for (value, row) in ((xmin, xmin_row), (xmax, xmax_row)):
layout.removeRow(row)
widget = LstWidget(value, axis.xaxis.lst_base_date, axes_tab)
layout.insertRow(row, general[row][0], widget)
axes_tab.widgets[row] = widget
elif self.x_axis_type == "UT":
for row in (xmin_row, xmax_row):
axes_tab.widgets[row].setDisplayFormat("yyyy-MM-dd hh:mm:ss")
if dialog.exec_():
apply_callback(dialog.get())
def __init__(self, algSettingsDict, parent=None):
""""""
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle('Change Algorithm-Specific Settings')
self.setWindowIcon(QtGui.QIcon('kiwi.png'))
self.setMinimumWidth(400)
self.cur = algSettingsDict["current"]
# Set the font to be used for section headings
fnt = QtGui.QFont()
fnt.setBold(True)
# AF-MUSIC
self.afTitle = QtWidgets.QLabel("AF-MUSIC:")
self.afTitle.setFont(fnt)
self.fmax_l = QtWidgets.QLabel(u"\u0192_max (Hz):")
self.fmax = QtWidgets.QLineEdit(self)
self.fmax.setText(str(algSettingsDict["AF-MUSIC"]["f_max"]))
self.fmin_l = QtWidgets.QLabel(u"\u0192_min (Hz):")
self.fmin = QtWidgets.QLineEdit(self)
self.fmin.setText(str(algSettingsDict["AF-MUSIC"]["f_min"]))
self.f0_l = QtWidgets.QLabel("Focusing Frequency (Hz):")
self.f0 = QtWidgets.QLineEdit(self)
self.f0.setText(str(algSettingsDict["AF-MUSIC"]["f_0"]))
# GCC
self.GCCTitle = QtWidgets.QLabel("GCC:")
self.GCCTitle.setFont(fnt)
# Available processors: PHAT, p-PHAT, CC, RIR, SCOT, HB
self.GCC_l = QtWidgets.QLabel("Processor:")
# self.GCC.setText(algSettingsDict["GCC"]["processor"])
self.possible_processors = ["PHAT", "p-PHAT", "CC", "RIR", "SCOT", "HB"]
self.cb = QtWidgets.QComboBox()
self.cb.addItems(self.possible_processors)
self.cb.setCurrentIndex(self.possible_processors.index(algSettingsDict["GCC"]["processor"]))
self.def_rho = algSettingsDict["GCC"]["rho"]
self.sl_l = QtWidgets.QLabel(u"0 \u2265 \u03C1={} \u2265 1:".format(self.def_rho))
self.sl = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.sl.setMinimum(0)
self.sl.setMaximum(100)
self.sl.setTickInterval(10)
self.sl.setTickPosition(QtWidgets.QSlider.TicksBelow)
self.sl.setValue(int(self.def_rho*100))
self.sl.valueChanged.connect(self.changeRho)
# MUSIC
self.MUSICTitle = QtWidgets.QLabel("MUSIC:")
self.MUSICTitle.setFont(fnt)
self.MUSIC_l = QtWidgets.QLabel("Frequency:")
self.MUSIC = QtWidgets.QLineEdit(self)
self.MUSIC.setText(str(algSettingsDict["MUSIC"]["freq"]))
self.activate = QtWidgets.QPushButton("Set")
Box = QtWidgets.QVBoxLayout()
Box.addWidget(self.afTitle)
f_min = QtWidgets.QHBoxLayout()
f_min.addWidget(self.fmin_l)
f_min.addWidget(self.fmin)
Box.addLayout(f_min)
f_max = QtWidgets.QHBoxLayout()
f_max.addWidget(self.fmax_l)
f_max.addWidget(self.fmax)
Box.addLayout(f_max)
f_0 = QtWidgets.QHBoxLayout()
f_0.addWidget(self.f0_l)
f_0.addWidget(self.f0)
Box.addLayout(f_0)
Box.addSpacerItem(QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding))
Box.addWidget(self.GCCTitle)
procBox = QtWidgets.QHBoxLayout()
procBox.addWidget(self.GCC_l)
procBox.addWidget(self.cb)
Box.addLayout(procBox)
rhoBox = QtWidgets.QHBoxLayout()
rhoBox.addWidget(self.sl_l)
rhoBox.addWidget(self.sl)
Box.addLayout(rhoBox)
Box.addSpacerItem(QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding))
Box.addWidget(self.MUSICTitle)
MUSICBox = QtWidgets.QHBoxLayout()
MUSICBox.addWidget(self.MUSIC_l)
MUSICBox.addWidget(self.MUSIC)
Box.addLayout(MUSICBox)
Box.addWidget(self.activate)
# Now put everything into the frame
self.setLayout(Box)
def figure_edit(axes, parent=None):
"""Edit matplotlib figure options"""
sep = (None, None) # separator
# Get / General
# Cast to builtin floats as they have nicer reprs.
xmin, xmax = map(float, axes.get_xlim())
ymin, ymax = map(float, axes.get_ylim())
general = [
('Title', axes.get_title()),
sep,
(None, "<b>X-Axis</b>"),
('Left', xmin),
('Right', xmax),
('Label', axes.get_xlabel()),
('Scale', [axes.get_xscale(), 'linear', 'log', 'logit']),
sep,
(None, "<b>Y-Axis</b>"),
('Bottom', ymin),
('Top', ymax),
('Label', axes.get_ylabel()),
('Scale', [axes.get_yscale(), 'linear', 'log', 'logit']),
sep,
('(Re-)Generate automatic legend', False),
]
# Save the unit data
xconverter = axes.xaxis.converter
yconverter = axes.yaxis.converter
xunits = axes.xaxis.get_units()
yunits = axes.yaxis.get_units()
# Sorting for default labels (_lineXXX, _imageXXX).
def cmp_key(label):
match = re.match(r"(_line|_image)(\d+)", label)
if match:
return match.group(1), int(match.group(2))
else:
return label, 0
# Get / Curves
linedict = {}
for line in axes.get_lines():
label = line.get_label()
if label == '_nolegend_':
continue
linedict[label] = line
curves = []
def prepare_data(d, init):
"""
Prepare entry for FormLayout.
*d* is a mapping of shorthands to style names (a single style may
have multiple shorthands, in particular the shorthands `None`,
`"None"`, `"none"` and `""` are synonyms); *init* is one shorthand
of the initial style.
This function returns an list suitable for initializing a
FormLayout combobox, namely `[initial_name, (shorthand,
style_name), (shorthand, style_name), ...]`.
"""
if init not in d:
d = {**d, init: str(init)}
# Drop duplicate shorthands from dict (by overwriting them during
# the dict comprehension).
name2short = {name: short for short, name in d.items()}
# Convert back to {shorthand: name}.
short2name = {short: name for name, short in name2short.items()}
# Find the kept shorthand for the style specified by init.
canonical_init = name2short[d[init]]
# Sort by representation and prepend the initial value.
return ([canonical_init] + sorted(
short2name.items(), key=lambda short_and_name: short_and_name[1]))
curvelabels = sorted(linedict, key=cmp_key)
for label in curvelabels:
line = linedict[label]
color = mcolors.to_hex(mcolors.to_rgba(line.get_color(),
line.get_alpha()),
keep_alpha=True)
ec = mcolors.to_hex(mcolors.to_rgba(line.get_markeredgecolor(),
line.get_alpha()),
keep_alpha=True)
fc = mcolors.to_hex(mcolors.to_rgba(line.get_markerfacecolor(),
line.get_alpha()),
keep_alpha=True)
curvedata = [
('Label', label), sep, (None, '<b>Line</b>'),
('Line style', prepare_data(LINESTYLES, line.get_linestyle())),
('Draw style', prepare_data(DRAWSTYLES, line.get_drawstyle())),
('Width', line.get_linewidth()), ('Color (RGBA)', color), sep,
(None, '<b>Marker</b>'),
('Style', prepare_data(MARKERS, line.get_marker())),
('Size', line.get_markersize()), ('Face color (RGBA)', fc),
('Edge color (RGBA)', ec)
]
curves.append([curvedata, label, ""])
# Is there a curve displayed?
has_curve = bool(curves)
# Get ScalarMappables.
mappabledict = {}
for mappable in [*axes.images, *axes.collections]:
label = mappable.get_label()
if label == '_nolegend_' or mappable.get_array() is None:
continue
mappabledict[label] = mappable
mappablelabels = sorted(mappabledict, key=cmp_key)
mappables = []
cmaps = [(cmap, name) for name, cmap in sorted(cm._cmap_registry.items())]
for label in mappablelabels:
mappable = mappabledict[label]
cmap = mappable.get_cmap()
if cmap not in cm._cmap_registry.values():
cmaps = [(cmap, cmap.name), *cmaps]
low, high = mappable.get_clim()
mappabledata = [
('Label', label),
('Colormap', [cmap.name] + cmaps),
('Min. value', low),
('Max. value', high),
]
if hasattr(mappable, "get_interpolation"): # Images.
interpolations = [(name, name)
for name in sorted(mimage.interpolations_names)]
mappabledata.append(
('Interpolation',
[mappable.get_interpolation(), *interpolations]))
mappables.append([mappabledata, label, ""])
# Is there a scalarmappable displayed?
has_sm = bool(mappables)
datalist = [(general, "Axes", "")]
if curves:
datalist.append((curves, "Curves", ""))
if mappables:
datalist.append((mappables, "Images, etc.", ""))
def apply_callback(data):
"""A callback to apply changes."""
orig_xlim = axes.get_xlim()
orig_ylim = axes.get_ylim()
general = data.pop(0)
curves = data.pop(0) if has_curve else []
mappables = data.pop(0) if has_sm else []
if data:
raise ValueError("Unexpected field")
# Set / General
(title, xmin, xmax, xlabel, xscale, ymin, ymax, ylabel, yscale,
generate_legend) = general
if axes.get_xscale() != xscale:
axes.set_xscale(xscale)
if axes.get_yscale() != yscale:
axes.set_yscale(yscale)
axes.set_title(title)
axes.set_xlim(xmin, xmax)
axes.set_xlabel(xlabel)
axes.set_ylim(ymin, ymax)
axes.set_ylabel(ylabel)
# Restore the unit data
axes.xaxis.converter = xconverter
axes.yaxis.converter = yconverter
axes.xaxis.set_units(xunits)
axes.yaxis.set_units(yunits)
axes.xaxis._update_axisinfo()
axes.yaxis._update_axisinfo()
# Set / Curves
for index, curve in enumerate(curves):
line = linedict[curvelabels[index]]
(label, linestyle, drawstyle, linewidth, color, marker, markersize,
markerfacecolor, markeredgecolor) = curve
line.set_label(label)
line.set_linestyle(linestyle)
line.set_drawstyle(drawstyle)
line.set_linewidth(linewidth)
rgba = mcolors.to_rgba(color)
line.set_alpha(None)
line.set_color(rgba)
if marker != 'none':
line.set_marker(marker)
line.set_markersize(markersize)
line.set_markerfacecolor(markerfacecolor)
line.set_markeredgecolor(markeredgecolor)
# Set ScalarMappables.
for index, mappable_settings in enumerate(mappables):
mappable = mappabledict[mappablelabels[index]]
if len(mappable_settings) == 5:
label, cmap, low, high, interpolation = mappable_settings
mappable.set_interpolation(interpolation)
elif len(mappable_settings) == 4:
label, cmap, low, high = mappable_settings
mappable.set_label(label)
mappable.set_cmap(cm.get_cmap(cmap))
mappable.set_clim(*sorted([low, high]))
# re-generate legend, if checkbox is checked
if generate_legend:
draggable = None
ncol = 1
if axes.legend_ is not None:
old_legend = axes.get_legend()
draggable = old_legend._draggable is not None
ncol = old_legend._ncol
new_legend = axes.legend(ncol=ncol)
if new_legend:
new_legend.set_draggable(draggable)
# Redraw
figure = axes.get_figure()
figure.canvas.draw()
if not (axes.get_xlim() == orig_xlim and axes.get_ylim() == orig_ylim):
figure.canvas.toolbar.push_current()
data = _formlayout.fedit(
datalist,
title="Figure options",
parent=parent,
icon=QtGui.QIcon(
str(cbook._get_data_path('images', 'qt4_editor_options.svg'))),
apply=apply_callback)
if data is not None:
apply_callback(data)
def configure_subplots(self):
image = str(cbook._get_data_path('images/matplotlib.png'))
dia = SubplotToolQt(self.canvas.figure, self.canvas.parent())
dia.setWindowIcon(QtGui.QIcon(image))
dia.exec_()
def get_icon(name):
import matplotlib
basedir = osp.join(matplotlib.rcParams['datapath'], 'images')
return QtGui.QIcon(osp.join(basedir, name))
def _icon(self, name):
pm = QtGui.QPixmap(name)
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(self.toolmanager.canvas._dpi_ratio)
return QtGui.QIcon(pm)
