def font(self, prefix, size):
"""Return a QFont corresponding to the given prefix and size."""
font = QFont(self.fontname[prefix])
font.setPixelSize(round(size))
if prefix[-1] == 's': # solid style
font.setStyleName('Solid')
return font
def add_reprojections(scene, points, projected, inliers, boards, valid_boards,
options):
marker_font = QFont()
marker_font.setPixelSize(options.marker_size * 0.75)
frame_table = points._extend(proj=projected.points, inlier=inliers)
colors = struct(error_line=(1, 1, 0),
outlier=(1, 0, 0),
inlier=(0, 1, 0),
invalid=(0.5, 0.5, 0))
pens = colors._map(cosmetic_pen, options.line_width)
for board, valid_board, board_points in zip(boards, valid_boards,
frame_table._sequence(0)):
if not valid_board:
continue
for point, id in zip(board_points._sequence(), board.ids):
color_key = 'invalid' if not point.valid else (
'inlier' if point.inlier else 'outlier')
add_marker(scene, point.proj, id, options, pens[color_key],
colors[color_key], marker_font)
if point.valid:
scene.addItem(line(point.proj, point.points, pens.error_line))
def _to_qgraphicstextitem(self):
t = QGraphicsTextItem()
t.setDefaultTextColor(QColor(self.color.hexcolor))
if self.html:
text = self.text.replace(u'\n', u'<br />')
t.setHtml(u'<div align="center">%s</div>' %
text if self.center else text)
else:
t.setPlainText(self.text)
mw = self.max_width
if mw is None:
if self.uniform_coordinates:
mw = self._canvas.width // 2 - self.x
else:
mw = self._canvas.width - self.x
if self.center:
mw *= 2
t.setTextWidth(mw)
f = QFont(self.font_family,
weight=QFont.Bold if self.font_bold else QFont.Normal,
italic=self.font_italic)
for family, substitute in font_substitutions:
f.insertSubstitution(substitute, family)
f.setPixelSize(self.font_size)
t.setFont(f)
return t
def qwtUnscaleFont(painter):
if painter.font().pixelSize() >= 0:
return
dpix, dpiy = get_screen_resolution()
pd = painter.device()
if pd.logicalDpiX() != dpix or pd.logicalDpiY() != dpiy:
pixelFont = QFont(painter.font(), QApplication.desktop())
pixelFont.setPixelSize(QFontInfo(pixelFont).pixelSize())
painter.setFont(pixelFont)
def add_point_markers(scene, points, board, color, options):
marker_font = QFont()
marker_font.setPixelSize(options.marker_size * 0.75)
pen = cosmetic_pen(color, options.line_width)
corners = points.points[points.valid]
for corner, id in zip(corners, board.ids[points.valid]):
add_marker(scene, corner, id, options, pen, color, marker_font)
def qwtUnscaleFont(painter):
if painter.font().pixelSize() >= 0:
return
screenResolution = qwtScreenResolution()
pd = painter.device()
if (pd.logicalDpiX() != screenResolution.width()
or pd.logicalDpiY() != screenResolution.height()):
pixelFont = QFont(painter.font(), QApplication.desktop())
pixelFont.setPixelSize(QFontInfo(pixelFont).pixelSize())
painter.setFont(pixelFont)
def font(self, prefix, size):
"""Returns QFont corresponding to the given prefix and size
Arguments
---------
prefix: str
prefix string of the loaded font
size: int
size for the font
"""
font = QFont(self.fontname[prefix])
font.setPixelSize(size)
return font
def font(self, prefix, size):
"""Returns QFont corresponding to the given prefix and size
Arguments
---------
prefix: str
prefix string of the loaded font
size: int
size for the font
"""
font = QFont(self.fontname[prefix])
font.setPixelSize(size)
return font
def drawText(self, p: QPainter, innerRect: QRectF, innerRadius: float, value: float):
if not self.m_format:
return
f = QFont(self.font())
f.setPixelSize(10)
fm = QFontMetricsF(f)
maxWidth = fm.width(self.valueToText(self.m_max))
delta = innerRadius / maxWidth
fontSize = f.pixelSize() * delta * 0.75
f.setPixelSize(int(fontSize))
p.setFont(f)
textRect = QRectF(innerRect)
p.setPen(self.palette().text().color())
p.drawText(textRect, Qt.AlignCenter, self.valueToText(value))
def _refresh(self, value: int = None):
"""Refresh the value on all subwidgets."""
value = value if value else self._value
self.blockSignals(True)
self._lineedit.setText(str(value))
self._slider.setValue(value)
font = QFont()
font.setPixelSize(value)
self._preview.setFont(font)
font = QFont()
font.setPixelSize(self.fontMetrics().height() - 4)
self._preview_label.setFont(font)
self.blockSignals(False)
def render(self):
rect = QRect(QPoint(), self.geometry().size())
self.m_backingStore.resize(rect.size())
self.m_backingStore.beginPaint(QRegion(rect))
device = self.m_backingStore.paintDevice()
p = QPainter(device)
p.drawImage(0, 0, self.m_image)
font = QFont()
font.setPixelSize(32)
p.setFont(font)
p.drawText(rect, 0, self.m_text)
self.m_backingStore.endPaint()
self.m_backingStore.flush(QRegion(rect))
def get_font_array(sz, chars=DEFAULT_CHARS):
from qtpy.QtGui import QFont, QPainter, QColor
font = QFont()
font.setFixedPitch(True)
font.setPixelSize(int(sz))
font.setStyleStrategy(QFont.NoAntialias)
dummy = QImage(10, 10, QImage.Format_ARGB32)
pnt = QPainter(dummy)
pnt.setFont(font)
metric = pnt.fontMetrics()
rct = metric.boundingRect(chars)
pnt.end()
h = rct.height()
w = rct.width()
img = QImage(w, h, QImage.Format_ARGB32)
paint = QPainter()
paint.begin(img)
paint.setFont(font)
paint.setBrush(QColor(255, 255, 255))
paint.setPen(QColor(255, 255, 255))
paint.drawRect(0, 0, w + 1, h + 1)
paint.setPen(QColor(0, 0, 0))
paint.setBrush(QColor(0, 0, 0))
paint.drawText(0, paint.fontMetrics().ascent(), chars)
paint.end()
try:
try:
# PyQt4 (at least until Qt 4.8)
data = img.bits().asstring(img.numBytes())
except AttributeError:
if PYSIDE2:
# PySide2
data = bytes(img.bits())
else:
# PyQt5
data = img.bits().asstring(img.byteCount())
except SystemError:
# PyQt4 (4.11.3) and PyQt5 (5.3.2) on Python 3
return
npy = np.frombuffer(data, np.uint8)
npy.shape = img.height(), int(img.bytesPerLine() / 4), 4
return npy[:, :, 0]
def drawContents(self, painter):
""" @type painter: QPainter """
w = self.width()
h = self.height()
margin = 10
background = QColor(210, 211, 215)
text_color = QColor(0, 0, 0)
foreground = QColor(255, 255, 255)
painter.setBrush(background)
painter.fillRect(0, 0, w, h, background)
pen = QPen()
pen.setWidth(2)
pen.setColor(foreground)
painter.setPen(pen)
painter.drawRect(0, 0, w - 1, h - 1)
text_x = 2 * margin
top_offset = margin
text_area_width = w - 2 * margin
painter.setPen(text_color)
text_size = 150
font = QFont("Serif")
font.setStyleHint(QFont.Serif)
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, margin + top_offset, text_area_width, text_size, int(Qt.AlignHCenter | Qt.AlignCenter), self.ert)
top_offset += text_size + 2 * margin
text_size = 25
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, top_offset, text_area_width, text_size, int(Qt.AlignHCenter | Qt.AlignCenter), self.ert_title)
top_offset += text_size + 4 * margin
text_size = 20
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, top_offset, text_area_width, text_size, int(Qt.AlignHCenter | Qt.AlignCenter), self.version)
def font(self, prefix, size):
"""Return a QFont corresponding to the given prefix and size."""
font = QFont(self.fontname[prefix])
font.setPixelSize(size)
return font
def font(self, size):
font = QFont(self.font_name)
font.setPixelSize(size)
return font
def font(self, size):
font = QFont(self.font_name)
font.setPixelSize(size)
return font
def create_plots(self, theme='dark', **kwargs):
bold_font = QFont()
bold_font.setPixelSize(12)
bold_font.setBold(True)
self.layout().addStretch()
self.layout().addWidget(QLabel("Channels: ", font=bold_font))
self.layout().addSpacing(10)
# Add check boxes for channels
self.channels = {}
for chan_ix in range(len(self.group_info)):
chan_lbl = self.group_info[chan_ix]['label']
chk_box = QCheckBox(chan_lbl)
chk_box.stateChanged.connect(self.check_channel_and_stim)
self.channels[chan_lbl] = chk_box
self.layout().addWidget(chk_box)
self.layout().addSpacing(10)
bt_clear = QPushButton("Uncheck all")
bt_clear.clicked.connect(lambda: self.uncheck_all(self.channels))
self.layout().addWidget(bt_clear)
self.layout().addSpacing(20)
# Stimuli types
self.layout().addWidget(QLabel("Stimuli: ", font=bold_font))
self.layout().addSpacing(10)
self.mapping_stimuli = {}
for stim in MAPPINGSTIMULI:
self.mapping_stimuli[stim] = QCheckBox(stim)
self.mapping_stimuli[stim].stateChanged.connect(
self.check_channel_and_stim)
self.layout().addWidget(self.mapping_stimuli[stim])
self.mapping_stimuli['Custom'] = QCheckBox()
l = QHBoxLayout()
self.custom_stimulus = QLineEdit("Custom")
l.addWidget(self.mapping_stimuli['Custom'])
l.addSpacing(3)
l.addWidget(self.custom_stimulus)
self.layout().addLayout(l)
self.layout().addSpacing(10)
bt_clear = QPushButton("Uncheck all")
bt_clear.clicked.connect(
lambda: self.uncheck_all(self.mapping_stimuli))
self.layout().addWidget(bt_clear)
self.layout().addSpacing(20)
# side
self.layout().addWidget(QLabel("Body Side: ", font=bold_font))
self.layout().addSpacing(10)
self.sides = {'Left': QCheckBox("Left"), 'Right': QCheckBox("Right")}
l = QHBoxLayout()
l.addWidget(self.sides['Left'])
l.addWidget(self.sides['Right'])
self.layout().addLayout(l)
self.layout().addSpacing(20)
# Body part
self.layout().addWidget(QLabel("Limb: ", font=bold_font))
body_widget = QWidget(self)
body_widget.setLayout(QGridLayout())
body_widget.layout().setContentsMargins(0, 0, 0, 0)
lbl = QLabel()
lbl.setPixmap(
QPixmap(
os.path.join(os.path.dirname(__file__), 'icons',
'HalfBody.png')))
body_widget.layout().addWidget(lbl, 0, 0, 20, 10)
self.body_parts = {}
cb = QCheckBox('')
self.body_parts['Head'] = cb
body_widget.layout().addWidget(cb, 1, 0, 1, 1)
cb = QCheckBox('')
self.body_parts['Arm'] = cb
body_widget.layout().addWidget(cb, 8, 4, 1, 1)
cb = QCheckBox('')
self.body_parts['Hand'] = cb
body_widget.layout().addWidget(cb, 10, 5, 1, 1)
cb = QCheckBox('')
self.body_parts['Leg'] = cb
body_widget.layout().addWidget(cb, 14, 1, 1, 1)
cb = QCheckBox('')
self.body_parts['Foot'] = cb
body_widget.layout().addWidget(cb, 18, 1, 1, 1)
bt_clear = QPushButton("Uncheck all")
bt_clear.clicked.connect(lambda: self.uncheck_all(self.body_parts))
body_widget.layout().addWidget(bt_clear, 20, 0, 1, 10)
self.layout().addWidget(body_widget)
self.layout().addSpacing(20)
self.bt_map = QPushButton("Submit Response")
self.bt_map.setEnabled(False)
self.bt_map.setMinimumHeight(40)
self.bt_map.clicked.connect(self.submit_map)
self.layout().addWidget(self.bt_map)
self.layout().addSpacing(10)
bt_clear = QPushButton("Clear Channel")
bt_clear.setMinimumHeight(20)
bt_clear.clicked.connect(self.clear_data)
self.layout().addWidget(bt_clear)
self.layout().addStretch()
# manual notes
self.layout().addWidget(QLabel("Note: ", font=bold_font))
self.note_field = QTextEdit()
self.note_field.setMaximumHeight(80)
self.note_field.textChanged.connect(self.check_note)
self.layout().addWidget(self.note_field)
self.layout().addSpacing(10)
self.bt_note = QPushButton("Submit Note")
self.bt_note.setEnabled(False)
self.bt_note.setMinimumHeight(20)
self.bt_note.clicked.connect(self.submit_note)
self.layout().addWidget(self.bt_note)
self.layout().addStretch()
def font(self, prefix, size):
"""Return a QFont corresponding to the given prefix and size."""
font = QFont(self.fontname[prefix])
font.setPixelSize(size)
return font
def configure_plot(self):
self.plot.setTitle(title=self.plot_config['title'],
**{
'color': 'w',
'size': '16pt'
})
self.plot.hideButtons()
if self.plot_config['image_plot']:
self.img = pg.ImageItem()
self.plot.addItem(self.img)
pos = np.array(self.plot_config['c_lim'])
# color = np.array([[0, 0, 0, 255], self.plot_config['pen_color'].getRgb()], dtype=np.ubyte)
# c_map = pg.ColorMap(pos, color)
# lut = c_map.getLookupTable(pos[0], pos[1], 1024)
colormap = cm.get_cmap("inferno") # cm.get_cmap("CMRmap")
colormap._init()
lut = (colormap._lut * 255).view(
np.ndarray
) # Convert matplotlib colormap from 0-1 to 0 -255 for Qt
self.img.setLookupTable(lut)
self.img.setLevels(pos)
self.img.scale(1 / 1000, 1)
self.img.setPos(DEPTHRANGE[0], 0)
if self.plot_config['marker_line'] is not None:
self.plot.addItem(
pg.InfiniteLine(angle=0 if self.plot_config['swap_xy'] else 90,
pos=self.plot_config['marker_line'],
movable=False,
pen='y'))
self.plot.setMouseEnabled(x=self.plot_config['mouse_enabled'][0],
y=self.plot_config['mouse_enabled'][1])
# if mouse is enabled, a right click will bring the plot range to its default values
self.plot.scene().sigMouseClicked.connect(self.mouse_clicked)
self.plot.vb.installEventFilter(self)
if self.plot_config['x_range']:
self.plot.setXRange(self.plot_config['x_range'][0],
self.plot_config['x_range'][1],
padding=0)
if self.plot_config['y_range']:
self.plot.setYRange(self.plot_config['y_range'][0],
self.plot_config['y_range'][1],
padding=0)
self.plot.setLabel('bottom', self.plot_config['x_label'])
self.plot.setLabel('left', self.plot_config['y_label'])
if not self.plot_config['x_axis']:
self.plot.hideAxis('bottom')
if not self.plot_config['y_axis']:
self.plot.hideAxis('left')
font = QFont()
font.setPixelSize(20)
font.setBold(True)
self.plot.getAxis('bottom').setStyle(
showValues=self.plot_config['x_ticks'],
tickFont=font,
tickTextOffset=10)
self.plot.getAxis('bottom').setTextPen((255, 255, 255, 255))
self.plot.getAxis('left').setStyle(
showValues=self.plot_config['y_ticks'], tickFont=font)
self.plot.getAxis('left').setTextPen((255, 255, 255, 255))
if self.plot_config['y_tick_labels']:
self.plot.getAxis('left').setTicks(
self.plot_config['y_tick_labels'])
if self.plot_config['interactive']:
self.plot.scene().sigMouseMoved.connect(self.mouse_moved)
if self.plot_config['swap_xy']:
self.line = pg.InfiniteLine(angle=0,
pos=-9999,
movable=False,
pen='w')
else:
self.line = pg.InfiniteLine(angle=90,
pos=-9999,
movable=False,
pen='w')
self.line.setZValue(5)
self.plot.addItem(self.line)
self.text = pg.TextItem(text='', color='w', fill=(0, 0, 0, 0))
self.text.setAnchor(self.plot_config['text_anchor'])
self.text.setX(0)
# self.text.setY(0.5)
self.text.setY(0)
self.plot.addItem(self.text)
self.text.setZValue(6)
def drawContents(self, painter):
""" @type painter: QPainter """
w = self.width()
h = self.height()
margin = 10
background = QColor(210, 211, 215)
text_color = QColor(0, 0, 0)
foreground = QColor(255, 255, 255)
painter.setBrush(background)
painter.fillRect(0, 0, w, h, background)
pen = QPen()
pen.setWidth(2)
pen.setColor(foreground)
painter.setPen(pen)
painter.drawRect(0, 0, w - 1, h - 1)
image_width = self.splash_image.width()
image_height = self.splash_image.height()
aspect = 1.0
if image_height:
aspect = float(image_width) / float(image_height)
scaled_height = h - 2 * margin
scaled_width = scaled_height * aspect
painter.drawRect(margin, margin, scaled_width, scaled_height)
painter.drawPixmap(margin, margin, scaled_width, scaled_height, self.splash_image)
text_x = scaled_width + 2 * margin
top_offset = margin
text_area_width = w - scaled_width - 2 * margin
painter.setPen(text_color)
text_size = 150
font = QFont("Serif")
font.setStyleHint(QFont.Serif)
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, margin + top_offset, text_area_width, text_size, Qt.AlignHCenter | Qt.AlignCenter, self.ert)
top_offset += text_size + 2 * margin
text_size = 25
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, top_offset, text_area_width, text_size, Qt.AlignHCenter | Qt.AlignCenter, self.ert_title)
top_offset += text_size + 4 * margin
text_size = 20
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, top_offset, text_area_width, text_size, Qt.AlignHCenter | Qt.AlignCenter, self.version)
text_size = 12
font.setPixelSize(text_size)
painter.setFont(font)
painter.drawText(text_x, h - text_size - margin - 5, text_area_width, text_size + 5, Qt.AlignHCenter | Qt.AlignCenter, self.copyright)
