def drawSymbol(self, painter, point_or_rect):
"""
Draw the symbol into a rectangle
The symbol is painted centered and scaled into the target rectangle.
It is always painted uncached and the pin point is ignored.
This method is primarily intended for drawing a symbol to the legend.
:param QPainter painter: Painter
:param point_or_rect: Position or target rectangle of the symbol in screen coordinates
:type point_or_rect: QPointF or QPoint or QRectF
"""
if isinstance(point_or_rect, (QPointF, QPoint)):
# drawSymbol( QPainter *, const QPointF & )
self.drawSymbols(painter, [point_or_rect])
return
# drawSymbol( QPainter *, const QRectF & )
rect = point_or_rect
assert isinstance(rect, QRectF)
if self.__data.style == QwtSymbol.NoSymbol:
return
if self.__data.style == QwtSymbol.Graphic:
self.__data.graphic.graphic.render(painter, rect,
Qt.KeepAspectRatio)
elif self.__data.style == QwtSymbol.Path:
if self.__data.path.graphic.isNull():
self.__data.path.graphic = qwtPathGraphic(
self.__data.path.path, self.__data.pen, self.__data.brush)
self.__data.path.graphic.render(painter, rect, Qt.KeepAspectRatio)
return
elif self.__data.style == QwtSymbol.SvgDocument:
if self.__data.svg.renderer is not None:
scaledRect = QRectF()
sz = QSizeF(self.__data.svg.renderer.viewBoxF().size())
if not sz.isEmpty():
sz.scale(rect.size(), Qt.KeepAspectRatio)
scaledRect.setSize(sz)
scaledRect.moveCenter(rect.center())
else:
scaledRect = rect
self.__data.svg.renderer.render(painter, scaledRect)
else:
br = QRect(self.boundingRect())
ratio = min(
[rect.width() / br.width(),
rect.height() / br.height()])
painter.save()
painter.translate(rect.center())
painter.scale(ratio, ratio)
isPinPointEnabled = self.__data.isPinPointEnabled
self.__data.isPinPointEnabled = False
pos = QPointF()
self.renderSymbols(painter, pos, 1)
self.__data.isPinPointEnabled = isPinPointEnabled
painter.restore()
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent):
"""
mouseMoveEvent
Parameters
----------
event : QGraphicsSceneMouseEvent
"""
geom = self._node.geometry
state = self._node.state
if state.resizing:
diff = event.pos() - event.lastPos()
w = self._node.model.embedded_widget()
if w:
self.prepareGeometryChange()
old_size = w.size() + QSize(diff.x(), diff.y())
w.setFixedSize(old_size)
old_size_f = QSizeF(old_size)
self._proxy_widget.setMinimumSize(old_size_f)
self._proxy_widget.setMaximumSize(old_size_f)
self._proxy_widget.setPos(geom.widget_position)
geom.recalculate_size()
self.update()
self.move_connections()
event.accept()
else:
super().mouseMoveEvent(event)
if event.lastPos() != event.pos():
self.move_connections()
event.ignore()
bounding = self.mapToScene(self.boundingRect()).boundingRect()
r = self.scene().sceneRect().united(bounding)
self.scene().setSceneRect(r)
def create_drop_indicator_widget(self, area: DockWidgetArea,
mode: OverlayMode) -> QLabel:
'''
Create drop indicator widget
Parameters
----------
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QLabel
'''
l = QLabel()
l.setObjectName("DockWidgetAreaLabel")
metric = 3.0 * l.fontMetrics().height()
size = QSizeF(metric, metric)
l.setPixmap(
self.create_high_dpi_drop_indicator_pixmap(size, area, mode))
l.setWindowFlags(Qt.Tool | Qt.FramelessWindowHint)
l.setAttribute(Qt.WA_TranslucentBackground)
l.setProperty("dockWidgetArea", area)
return l
def draw_slvs_ranges(self) -> None:
"""Draw solving range."""
pen = QPen()
pen.setWidth(5)
for i, (tag, rect) in enumerate(self.ranges.items()):
range_color = QColor(color_num(i + 1))
range_color.setAlpha(30)
self.painter.setBrush(range_color)
range_color.setAlpha(255)
pen.setColor(range_color)
self.painter.setPen(pen)
cx = rect.x() * self.zoom
cy = rect.y() * -self.zoom
if rect.width():
self.painter.drawRect(QRectF(
QPointF(cx, cy),
QSizeF(rect.width(), rect.height()) * self.zoom
))
else:
self.draw_circle(QPointF(cx, cy), 3)
range_color.setAlpha(255)
pen.setColor(range_color)
self.painter.setPen(pen)
self.painter.drawText(QPointF(cx, cy) + QPointF(6, -6), tag)
self.painter.setBrush(Qt.NoBrush)
def reset(self):
"""Clear all stored commands"""
self.__data.commands = []
self.__data.pathInfos = []
self.__data.boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)
self.__data.pointRect = QRectF(0.0, 0.0, -1.0, -1.0)
self.__data.defaultSize = QSizeF()
def update_ranges(self, ranges: Dict[str, Tuple[float, float, float]]) -> None:
"""Update the ranges of dimensional synthesis."""
self.ranges.clear()
self.ranges.update({tag: QRectF(
QPointF(values[0] - values[2], values[1] + values[2]),
QSizeF(values[2], values[2]) * 2
) for tag, values in ranges.items()})
self.update()
def __init__(self):
self.boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)
self.pointRect = QRectF(0.0, 0.0, -1.0, -1.0)
self.initialTransform = None
self.defaultSize = QSizeF()
self.commands = []
self.pathInfos = []
self.renderHints = 0
def paintEvent(self, event: QPaintEvent) -> None:
"""Using a QPainter under 'self',
so just change QPen or QBrush before painting.
"""
if not self.__grab_mode:
self.painter.begin(self)
self.painter.fillRect(event.rect(), QBrush(Qt.white))
# Translation
self.painter.translate(self.ox, self.oy)
# Background
if not self.background.isNull():
rect = self.background.rect()
self.painter.setOpacity(self.background_opacity)
self.painter.drawImage(
QRectF(
self.background_offset * self.zoom,
QSizeF(rect.width(), rect.height()) *
self.background_scale * self.zoom), self.background,
QRectF(rect))
self.painter.setOpacity(1)
# Show frame
pen = QPen(Qt.blue)
pen.setWidth(1)
self.painter.setPen(pen)
self.painter.setFont(QFont("Arial", self.font_size))
# Draw origin lines
if self.show_ticks not in {_TickMark.SHOW, _TickMark.SHOW_NUM}:
return
pen.setColor(Qt.gray)
self.painter.setPen(pen)
x_l = -self.ox
x_r = self.width() - self.ox
self.painter.drawLine(QPointF(x_l, 0), QPointF(x_r, 0))
y_t = self.height() - self.oy
y_b = -self.oy
self.painter.drawLine(QPointF(0, y_b), QPointF(0, y_t))
def indexing(v: float) -> int:
"""Draw tick."""
return int(v / self.zoom - v / self.zoom % 5)
# Draw tick
for x in range(indexing(x_l), indexing(x_r) + 1, 5):
if x == 0:
continue
is_ten = x % 10 == 0
end = QPointF(x * self.zoom, -10 if is_ten else -5)
self.painter.drawLine(QPointF(x, 0) * self.zoom, end)
if self.show_ticks == _TickMark.SHOW_NUM and is_ten:
self.painter.drawText(end + QPointF(0, 3), f"{x}")
for y in range(indexing(y_b), indexing(y_t) + 1, 5):
if y == 0:
continue
is_ten = y % 10 == 0
end = QPointF(10 if is_ten else 5, y * self.zoom)
self.painter.drawLine(QPointF(0, y) * self.zoom, end)
if self.show_ticks == _TickMark.SHOW_NUM and is_ten:
self.painter.drawText(end + QPointF(3, 0), f"{-y}")
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
At PyDMSymbol this method handles the alarm painting with parameters
from the stylesheet and draws the proper image.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
# self._painter.setRenderHint(QPainter.Antialiasing)
if self._current_key is None:
self._painter.end()
return
image_to_draw = self._state_images.get(self._current_key, (None, None))[1]
if image_to_draw is None:
self._painter.end()
return
if isinstance(image_to_draw, QPixmap):
w = float(image_to_draw.width())
h = float(image_to_draw.height())
if self._aspect_ratio_mode == Qt.IgnoreAspectRatio:
scale = (event.rect().width() / w, event.rect().height() / h)
elif self._aspect_ratio_mode == Qt.KeepAspectRatio:
sf = min(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
elif self._aspect_ratio_mode == Qt.KeepAspectRatioByExpanding:
sf = max(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
self._painter.scale(scale[0], scale[1])
self._painter.drawPixmap(event.rect().x(), event.rect().y(), image_to_draw)
elif isinstance(image_to_draw, QSvgRenderer):
draw_size = QSizeF(image_to_draw.defaultSize())
draw_size.scale(QSizeF(event.rect().size()), self._aspect_ratio_mode)
image_to_draw.render(self._painter, QRectF(0.0, 0.0, draw_size.width(), draw_size.height()))
self._painter.end()
def setSize(self, width, height):
"""Set the size of the visible area in pixels.
Update the scene rect.
Args:
width(int): Width of the visible area.
height(int): Height of the visible area.
"""
rect = QRectF(self.sceneRect().topLeft(), QSizeF(width, height))
self.setSceneRect(rect)
def __init__(self,
mechanism: Dict[str, Any],
path: Sequence[Sequence[_Coord]],
vpoints: List[VPoint] = None,
vlinks: List[VLink] = None,
parent: QWidget = None):
"""Input link and path data."""
super(_DynamicCanvas, self).__init__(parent)
self.mechanism = mechanism
self.vpoints = vpoints or []
self.vlinks = vlinks or []
self.no_mechanism = not self.vpoints or not self.vlinks
use_norm = self.no_mechanism and self.mechanism.get(
'shape_only', False)
# Target path
same: Dict[int, int] = self.mechanism['same']
target_path: _TargetPath = self.mechanism['target']
for i, p in target_path.items():
for j in range(i):
if j in same:
i -= 1
if use_norm:
self.target_path[i] = [(x, y) for x, y in norm_path(p)]
else:
self.target_path[i] = p
self.path.path = []
for i, p in enumerate(path):
if i in self.target_path and use_norm:
self.path.path.append([(x, y)
for x, y in norm_path(efd_fitting(p))])
else:
self.path.path.append(p)
self.__index = 0
self.__interval = 1
self.__path_count = max(len(path) for path in self.path.path) - 1
self.pos = []
# Error
self.error = False
self.__no_error = 0
if self.no_mechanism:
return
# Ranges
ranges: Dict[int, _Range] = self.mechanism['placement']
self.ranges.update({
f"P{i}":
QRectF(QPointF(values[0] - values[2], values[1] + values[2]),
QSizeF(values[2] * 2, values[2] * 2))
for i, values in ranges.items()
})
# Timer
self.__timer = QTimer()
self.__timer.timeout.connect(self.__change_index)
self.__timer.start(18)
def qwtFillBackground(*args):
if len(args) == 2:
painter, canvas = args
rects = []
if canvas.testAttribute(Qt.WA_StyledBackground):
recorder = QwtStyleSheetRecorder(canvas.size())
p = QPainter(recorder)
qwtDrawStyledBackground(canvas, p)
p.end()
if recorder.background.brush.isOpaque():
rects = recorder.clipRects
else:
rects += [canvas.rect()]
else:
r = canvas.rect()
radius = canvas.borderRadius()
if radius > 0.0:
sz = QSizeF(radius, radius)
rects += [
QRectF(r.topLeft(), sz),
QRectF(r.topRight() - QPointF(radius, 0), sz),
QRectF(r.bottomRight() - QPointF(radius, radius), sz),
QRectF(r.bottomLeft() - QPointF(0, radius), sz),
]
qwtFillBackground(painter, canvas, rects)
elif len(args) == 3:
painter, widget, fillRects = args
if not fillRects:
return
if painter.hasClipping():
clipRegion = painter.transform().map(painter.clipRegion())
else:
clipRegion = widget.contentsRect()
bgWidget = qwtBackgroundWidget(widget.parentWidget())
for fillRect in fillRects:
rect = QRectF(fillRect).toAlignedRect()
if clipRegion.intersects(rect):
pm = QPixmap(rect.size())
QwtPainter.fillPixmap(
bgWidget, pm, widget.mapTo(bgWidget, rect.topLeft())
)
painter.drawPixmap(rect, pm)
else:
raise TypeError(
"%s() takes 2 or 3 argument(s) (%s given)"
% ("qwtFillBackground", len(args))
)
def update_drop_indicator_icon(self, label: QLabel):
'''
Update drop indicator icon
Parameters
----------
drop_indicator_widget : QLabel
'''
metric = 3.0 * label.fontMetrics().height()
size = QSizeF(metric, metric)
area = label.property("dockWidgetArea")
label.setPixmap(
self.create_high_dpi_drop_indicator_pixmap(size, area, self.mode))
def size(self):
"""
Get the node size
Parameters
----------
node : Node
Returns
-------
value : QSizeF
"""
return QSizeF(self.width, self.height)
def heightForWidth(self, font, flags, text, width):
"""
Find the height for a given width
:param QFont font: Font of the text
:param int flags: Bitwise OR of the flags used like in QPainter::drawText
:param str text: Text to be rendered
:param float width: Width
:return: Calculated height
"""
doc = QwtRichTextDocument(text, flags, font)
doc.setPageSize(QSizeF(width, QWIDGETSIZE_MAX))
return doc.documentLayout().documentSize().height()
def setDefaultSize(self, size):
"""
The default size is used in all methods rendering the graphic,
where no size is explicitly specified. Assigning an empty size
means, that the default size will be calculated from the bounding
rectangle.
:param QSizeF size: Default size
.. seealso::
:py:meth:`defaultSize()`, :py:meth:`boundingRect()`
"""
w = max([0.0, size.width()])
h = max([0.0, size.height()])
self.__data.defaultSize = QSizeF(w, h)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
At PyDMSymbol this method handles the alarm painting with parameters
from the stylesheet and draws the proper image.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
# self._painter.setRenderHint(QPainter.Antialiasing)
if self._current_key is None:
self._painter.end()
return
image_to_draw = self._state_images.get(self._current_key,
(None, None))[1]
if image_to_draw is None:
self._painter.end()
return
if isinstance(image_to_draw, QPixmap):
w = float(image_to_draw.width())
h = float(image_to_draw.height())
if self._aspect_ratio_mode == Qt.IgnoreAspectRatio:
scale = (event.rect().width() / w, event.rect().height() / h)
elif self._aspect_ratio_mode == Qt.KeepAspectRatio:
sf = min(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
elif self._aspect_ratio_mode == Qt.KeepAspectRatioByExpanding:
sf = max(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
self._painter.scale(scale[0], scale[1])
self._painter.drawPixmap(event.rect().x(),
event.rect().y(), image_to_draw)
elif isinstance(image_to_draw, QSvgRenderer):
draw_size = QSizeF(image_to_draw.defaultSize())
draw_size.scale(QSizeF(event.rect().size()),
self._aspect_ratio_mode)
image_to_draw.render(
self._painter,
QRectF(0.0, 0.0, draw_size.width(), draw_size.height()))
self._painter.end()
def exportTo(self, plot, documentname, sizeMM=None, resolution=85):
"""
Execute a file dialog and render the plot to the selected file
:param qwt.plot.QwtPlot plot: Plot widget
:param str documentName: Default document name
:param QSizeF sizeMM: Size for the document in millimeters
:param int resolution: Resolution in dots per Inch (dpi)
:return: True, when exporting was successful
.. seealso::
:py:meth:`renderDocument()`
"""
if plot is None:
return
if sizeMM is None:
sizeMM = QSizeF(300, 200)
filename = documentname
imageFormats = QImageWriter.supportedImageFormats()
filter_ = [
"PDF documents (*.pdf)",
"SVG documents (*.svg)",
"Postscript documents (*.ps)",
]
if imageFormats:
imageFilter = "Images"
imageFilter += " ("
for idx, fmt in enumerate(imageFormats):
if idx > 0:
imageFilter += " "
imageFilter += "*." + str(fmt)
imageFilter += ")"
filter_ += [imageFilter]
filename, _s = getsavefilename(
plot,
"Export File Name",
filename,
";;".join(filter_),
options=QFileDialog.DontConfirmOverwrite,
)
if not filename:
return False
self.renderDocument(plot, filename, sizeMM, resolution)
return True
def minimumSizeHint(self):
"""
Return a minimum size hint
"""
sz = self.__data.text.textSize(self.font())
mw = 2 * (self.frameWidth() + self.__data.margin)
mh = mw
indent = self.__data.indent
if indent <= 0:
indent = self.defaultIndent()
if indent > 0:
align = self.__data.text.renderFlags()
if align & Qt.AlignLeft or align & Qt.AlignRight:
mw += self.__data.indent
elif align & Qt.AlignTop or align & Qt.AlignBottom:
mh += self.__data.indent
sz += QSizeF(mw, mh)
return QSize(np.ceil(sz.width()), np.ceil(sz.height()))
def textSize(self, defaultFont):
"""
Returns the size, that is needed to render text
:param QFont defaultFont Font, used for the calculation if the text has no font
:return: Caluclated size
"""
font = QFont(self.usedFont(defaultFont), self._desktopwidget)
if (not self.__layoutCache.textSize.isValid()
or self.__layoutCache.font is not font):
self.__layoutCache.textSize = self.__data.textEngine.textSize(
font, self.__data.renderFlags, self.__data.text)
self.__layoutCache.font = font
sz = self.__layoutCache.textSize
if self.__data.layoutAttributes & self.MinimumLayout:
(left, right, top,
bottom) = self.__data.textEngine.textMargins(font)
sz -= QSizeF(left + right, top + bottom)
return sz
def draw(self, painter, rect, flags, text):
"""
Draw the text in a clipping rectangle
:param QPainter painter: Painter
:param QRectF rect: Clipping rectangle
:param int flags: Bitwise OR of the flags like in for QPainter::drawText()
:param str text: Text to be rendered
"""
txt = QwtRichTextDocument(text, flags, painter.font())
painter.save()
unscaledRect = QRectF(rect)
if painter.font().pixelSize() < 0:
res = qwtScreenResolution()
pd = painter.device()
if pd.logicalDpiX() != res.width() or pd.logicalDpiY(
) != res.height():
transform = QTransform()
transform.scale(
res.width() / float(pd.logicalDpiX()),
res.height() / float(pd.logicalDpiY()),
)
painter.setWorldTransform(transform, True)
invtrans, _ok = transform.inverted()
unscaledRect = invtrans.mapRect(rect)
txt.setDefaultFont(painter.font())
txt.setPageSize(QSizeF(unscaledRect.width(), QWIDGETSIZE_MAX))
layout = txt.documentLayout()
height = layout.documentSize().height()
y = unscaledRect.y()
if flags & Qt.AlignBottom:
y += unscaledRect.height() - height
elif flags & Qt.AlignVCenter:
y += (unscaledRect.height() - height) / 2
context = QAbstractTextDocumentLayout.PaintContext()
context.palette.setColor(QPalette.Text, painter.pen().color())
painter.translate(unscaledRect.x(), y)
layout.draw(painter, context)
painter.restore()
def qwtDrawSvgSymbols(painter, points, numPoints, renderer, symbol):
if renderer is None or not renderer.isValid():
return
viewBox = QRectF(renderer.viewBoxF())
if viewBox.isEmpty():
return
sz = QSizeF(symbol.size())
if not sz.isValid():
sz = viewBox.size()
sx = sz.width() / viewBox.width()
sy = sz.height() / viewBox.height()
pinPoint = QPointF(viewBox.center())
if symbol.isPinPointEnabled():
pinPoint = symbol.pinPoint()
dx = sx * (pinPoint.x() - viewBox.left())
dy = sy * (pinPoint.y() - viewBox.top())
for pos in points:
x = pos.x() - dx
y = pos.y() - dy
renderer.render(painter, QRectF(x, y, sz.width(), sz.height()))
def __init__(self, mechanism: Dict[str, Any],
path: Sequence[Sequence[Tuple[float, float]]],
vpoints: List[VPoint], vlinks: List[VLink], parent: QWidget):
"""Input link and path data."""
super(_DynamicCanvas, self).__init__(parent)
self.mechanism = mechanism
self.path.path = path
self.vpoints = vpoints
self.vlinks = vlinks
ranges: Dict[int, Tuple[float, float,
float]] = self.mechanism['placement']
self.ranges.update({
f"P{i}":
QRectF(QPointF(values[0] - values[2], values[1] + values[2]),
QSizeF(values[2] * 2, values[2] * 2))
for i, values in ranges.items()
})
same: Dict[int, int] = self.mechanism['same']
target_path: Dict[int, List[Tuple[float,
float]]] = self.mechanism['target']
for i, path in target_path.items():
for j in range(i):
if j in same:
i -= 1
self.target_path[f"P{i}"] = path
self.__index = 0
self.__interval = 1
self.__path_count = max(len(path) for path in self.path.path) - 1
self.pos: List[Tuple[float, float]] = []
# Error
self.error = False
self.__no_error = 0
# Timer start.
self.__timer = QTimer()
self.__timer.timeout.connect(self.__change_index)
self.__timer.start(18)
def paintEvent(self, event):
"""Override Qt method."""
painter = QPainter(self)
painter.setOpacity(self.current_opacity)
max_width = (
SASS_VARIABLES.WIDGET_CONTENT_TOTAL_WIDTH - 2 *
SASS_VARIABLES.WIDGET_CONTENT_PADDING - 2 *
SASS_VARIABLES.WIDGET_CONTENT_MARGIN
)
# Hover top
br = self.label_icon.rect().bottomRight()
tl = self.label_icon.rect().topLeft() + QPoint(1, 1)
y = br.y() + self.label_text.height() - 2
# br_new = QPoint(br.x() + 2, y) - QPoint(1, 1)
br_new = QPoint(max_width - 1, y) - QPoint(1, 1)
rect_hover = QRect(tl, br_new) # 2 is the border
pen = QPen(Qt.NoPen)
brush = QBrush(Qt.SolidPattern)
brush.setColor(QColor('#fff'))
painter.setBrush(brush)
painter.setPen(pen)
painter.drawRect(rect_hover)
font = self.font()
font.setPointSize(10)
painter.setFont(font)
pen = QPen()
pen.setColor(QColor('black'))
painter.setPen(pen)
td = self.text_document
td.setPageSize(QSizeF(rect_hover.size()))
td.setHtml(self.summary)
td.drawContents(painter)
self.raise_()
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
At PyDMSymbolEditor this method handles the image preview.
Parameters
----------
event : QPaintEvent
"""
if not self.preview:
return
size = QSize(140, 140)
_painter = QPainter()
_painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, _painter, self)
image_to_draw = self.preview_file
if isinstance(image_to_draw, QPixmap):
w = float(image_to_draw.width())
h = float(image_to_draw.height())
sf = min(size.width() / w, size.height() / h)
scale = (sf, sf)
_painter.scale(scale[0], scale[1])
_painter.drawPixmap(335 / sf, 120 / sf, image_to_draw)
elif isinstance(image_to_draw, QSvgRenderer):
draw_size = QSizeF(image_to_draw.defaultSize())
draw_size.scale(QSizeF(size), Qt.KeepAspectRatio)
image_to_draw.render(
_painter,
QRectF(335, 120, draw_size.width(), draw_size.height()))
_painter.end()
self.preview = False
def boundingRect(self):
"""
Calculate the bounding rectangle for a symbol at position (0,0).
:return: Bounding rectangle
"""
rect = QRectF()
pinPointTranslation = False
if self.__data.style in (QwtSymbol.Ellipse, QwtSymbol.Rect,
QwtSymbol.Hexagon):
pw = 0.0
if self.__data.pen.style() != Qt.NoPen:
pw = max([self.__data.pen.widthF(), 1.0])
rect.setSize(self.__data.size + QSizeF(pw, pw))
rect.moveCenter(QPointF(0.0, 0.0))
elif self.__data.style in (
QwtSymbol.XCross,
QwtSymbol.Diamond,
QwtSymbol.Triangle,
QwtSymbol.UTriangle,
QwtSymbol.DTriangle,
QwtSymbol.RTriangle,
QwtSymbol.LTriangle,
QwtSymbol.Star1,
QwtSymbol.Star2,
):
pw = 0.0
if self.__data.pen.style() != Qt.NoPen:
pw = max([self.__data.pen.widthF(), 1.0])
rect.setSize(QSizeF(self.__data.size) + QSizeF(2 * pw, 2 * pw))
rect.moveCenter(QPointF(0.0, 0.0))
elif self.__data.style == QwtSymbol.Path:
if self.__data.path.graphic.isNull():
self.__data.path.graphic = qwtPathGraphic(
self.__data.path.path, self.__data.pen, self.__data.brush)
rect = qwtScaleBoundingRect(self.__data.path.graphic,
self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.Pixmap:
if self.__data.size.isEmpty():
rect.setSize(self.__data.pixmap.pixmap.size())
else:
rect.setSize(self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.Graphic:
rect = qwtScaleBoundingRect(self.__data.graphic.graphic,
self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.SvgDocument:
if self.__data.svg.renderer is not None:
rect = self.__data.svg.renderer.viewBoxF()
if self.__data.size.isValid() and not rect.isEmpty():
sz = QSizeF(rect.size())
sx = self.__data.size.width() / sz.width()
sy = self.__data.size.height() / sz.height()
transform = QTransform()
transform.scale(sx, sy)
rect = transform.mapRect(rect)
pinPointTranslation = True
else:
rect.setSize(self.__data.size)
rect.moveCenter(QPointF(0.0, 0.0))
if pinPointTranslation:
pinPoint = QPointF(0.0, 0.0)
if self.__data.isPinPointEnabled:
pinPoint = rect.center() - self.__data.pinPoint
rect.moveCenter(pinPoint)
r = QRect()
r.setLeft(np.floor(rect.left()))
r.setTop(np.floor(rect.top()))
r.setRight(np.floor(rect.right()))
r.setBottom(np.floor(rect.bottom()))
if self.__data.style != QwtSymbol.Pixmap:
r.adjust(-1, -1, 1, 1)
return r
def paint(self, p=QPainter(), o=QStyleOptionGraphicsItem(), widget=None):
pen = QPen(Qt.blue)
p.setPen(pen)
p.drawRect(QRectF(QPointF(0, -100), QSizeF(200, 200)))
def boundingRect(self):
return QRectF(QPointF(0, -100), QSizeF(200, 200))
def drawLabel(self, painter, canvasRect, pos):
"""
Align and draw the text label of the marker
:param QPainter painter: Painter
:param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
:param QPointF pos: Position of the marker, translated into widget coordinates
.. seealso::
:py:meth:`drawLabel()`,
:py:meth:`qwt.symbol.QwtSymbol.drawSymbol()`
"""
if self.__data.label.isEmpty():
return
align = Qt.Alignment(self.__data.labelAlignment)
alignPos = QPointF(pos)
symbolOff = QSizeF(0, 0)
if self.__data.style == QwtPlotMarker.VLine:
# In VLine-style the y-position is pointless and
# the alignment flags are relative to the canvas
if bool(self.__data.labelAlignment & Qt.AlignTop):
alignPos.setY(canvasRect.top())
align &= ~Qt.AlignTop
align |= Qt.AlignBottom
elif bool(self.__data.labelAlignment & Qt.AlignBottom):
# In HLine-style the x-position is pointless and
# the alignment flags are relative to the canvas
alignPos.setY(canvasRect.bottom() - 1)
align &= ~Qt.AlignBottom
align |= Qt.AlignTop
else:
alignPos.setY(canvasRect.center().y())
elif self.__data.style == QwtPlotMarker.HLine:
if bool(self.__data.labelAlignment & Qt.AlignLeft):
alignPos.setX(canvasRect.left())
align &= ~Qt.AlignLeft
align |= Qt.AlignRight
elif bool(self.__data.labelAlignment & Qt.AlignRight):
alignPos.setX(canvasRect.right() - 1)
align &= ~Qt.AlignRight
align |= Qt.AlignLeft
else:
alignPos.setX(canvasRect.center().x())
else:
if self.__data.symbol and self.__data.symbol.style(
) != QwtSymbol.NoSymbol:
symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
symbolOff /= 2
pw2 = self.__data.pen.widthF() / 2.0
if pw2 == 0.0:
pw2 = 0.5
spacing = self.__data.spacing
xOff = max([pw2, symbolOff.width()])
yOff = max([pw2, symbolOff.height()])
textSize = self.__data.label.textSize(painter.font())
if align & Qt.AlignLeft:
alignPos.setX(alignPos.x() - (xOff + spacing))
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setX(alignPos.x() - textSize.height())
else:
alignPos.setX(alignPos.x() - textSize.width())
elif align & Qt.AlignRight:
alignPos.setX(alignPos.x() + xOff + spacing)
else:
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setX(alignPos.x() - textSize.height() / 2)
else:
alignPos.setX(alignPos.x() - textSize.width() / 2)
if align & Qt.AlignTop:
alignPos.setY(alignPos.y() - (yOff + spacing))
if self.__data.labelOrientation != Qt.Vertical:
alignPos.setY(alignPos.y() - textSize.height())
elif align & Qt.AlignBottom:
alignPos.setY(alignPos.y() + yOff + spacing)
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setY(alignPos.y() + textSize.width())
else:
if self.__data.labelOrientation == Qt.Vertical:
alignPos.setY(alignPos.y() + textSize.width() / 2)
else:
alignPos.setY(alignPos.y() - textSize.height() / 2)
painter.translate(alignPos.x(), alignPos.y())
if self.__data.labelOrientation == Qt.Vertical:
painter.rotate(-90.0)
textRect = QRectF(0, 0, textSize.width(), textSize.height())
self.__data.label.draw(painter, textRect)
def updateTime(self, frame):
if frame == self.previousframe:
return
self.previousframe = frame
idx = self.currentPuff.currentIndex()
currentPuff = self.group.puffs[idx]
image1 = np.copy(self.I[frame])
mmax = np.max(self.I)
image1 = image1 / mmax
image2 = np.copy(self.I_fits[idx][frame])
image2 = image2 / mmax
self.puff_3D.update_images(image1, image2)
rel_frame = frame - (currentPuff.kinetics['t_start'] -
currentPuff.kinetics['before'])
for line in [self.vLine1, self.vLine2,
self.vLine5]: # self.vLine3,self.vLine4,self.vLine5]:
line.setValue(rel_frame)
for bar in self.error_bars:
bar.plot.removeItem(bar)
self.error_bars = []
for item in self.addedItems:
self.imageview.view.removeItem(item)
self.addedItems = []
scatter = pg.ScatterPlotItem(size=8, pen=pg.mkPen(None))
self.imageview.view.addItem(scatter)
self.addedItems.append(scatter)
spots = []
for i in np.arange(len(self.group.puffs)):
rel_frame2 = frame - ((currentPuff.kinetics['t_start'] -
currentPuff.kinetics['before']) -
(self.group.puffs[i].kinetics['t_start'] -
self.group.puffs[i].kinetics['before']))
if self.puffCheckBoxes[i].isChecked(
) and rel_frame2 >= 0 and rel_frame2 < self.params[i].shape[0]:
centers = self.params[i][:, :2] - self.bounds[1:, 0]
center = centers[rel_frame2, :]
amps = np.copy(self.params[i][:, -1])
amps[amps <= 0] = .00000001
amp = amps[rel_frame2]
std = self.group.puffs[0].clusters.standard_deviations[i]
color = np.array(self.colors[i])
color[3] = 50
### FIRST ADD THE POINT TO THE SCATTER PLOT
if 0.8 / amp < std: # if the amplitude>0 and the error (0.8/SNR) is within the fitting bounds
### FIRST PLOT THE
""" WARNING!!! the amp should really be the signal to noise ratio, so it is only valid when the image has been ratiod by the standard deviation of the noise """
sigma = 0.8 / amp
sigmas = 0.8 / amps
# add error bars to x and y
# first add X
color[3] = 255
err = pg.ErrorBarItem(
x=np.array([rel_frame]),
y=np.array([self.params[i][rel_frame2, 0]]),
top=np.array([sigma]),
bottom=np.array([sigma]),
beam=0.5,
pen=pg.mkPen(pg.mkColor(tuple(color))))
self.p3.addItem(err)
err.plot = self.p3
self.error_bars.append(err)
# second add Y
err = pg.ErrorBarItem(
x=np.array([rel_frame]),
y=np.array([self.params[i][rel_frame2, 1]]),
top=np.array([sigma]),
bottom=np.array([sigma]),
beam=0.5,
pen=pg.mkPen(pg.mkColor(tuple(color))))
self.p4.addItem(err)
err.plot = self.p4
self.error_bars.append(err)
reasonable_fit = sigmas < 2 * std
bounds = QRectF(
QPointF(center[0] - sigma, center[1] - sigma),
QSizeF(2 * sigma, 2 * sigma))
### plot outer circle
pathitem = QGraphicsEllipseItem(bounds)
color[-1] = 127 # alpha channel
pathitem.setPen(pg.mkPen(pg.mkColor(tuple(color))))
pathitem.setBrush(pg.mkColor((0, 0, 0, 0)))
self.imageview.view.addItem(pathitem)
self.addedItems.append(pathitem)
### plot line
frame_i = rel_frame2 - 6
if frame_i < 0:
frame_i = 0
alpha = 255
for ii in np.arange(rel_frame2, frame_i, -1) - 1:
if alpha <= 0 or not reasonable_fit[ii]:
break
color[-1] = alpha # alpha channel
alpha = alpha - (255 * 1. / 6.)
pathitem = QGraphicsPathItem()
pathitem.setPen(pg.mkColor(tuple(color)))
path = QPainterPath(QPointF(*centers[ii]))
path.lineTo(QPointF(*centers[ii + 1]))
pathitem.setPath(path)
self.imageview.view.addItem(pathitem)
self.addedItems.append(pathitem)
color[3] = 255 # make the spot transparent
spots.append({
'pos': center,
'brush': pg.mkBrush(pg.mkColor(tuple(color)))
})
scatter.addPoints(spots)
def create_high_dpi_drop_indicator_pixmap(
self, size: QSizeF, area: DockWidgetArea,
mode: OverlayMode) -> QPixmap:
'''
Create high dpi drop indicator pixmap
Parameters
----------
size : QSizeF
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QPixmap
'''
border_color = self.icon_color(IconColor.frame_color)
background_color = self.icon_color(IconColor.window_background_color)
window = self.public.window()
# QT version compatibility (TODO necessary for qtpy?)
device_pixel_ratio = (window.devicePixelRatioF()
if hasattr(window, 'devicePixelRatioF')
else window.devicePixelRatio())
pixmap_size = QSizeF(size * device_pixel_ratio)
pm = QPixmap(pixmap_size.toSize())
pm.fill(QColor(0, 0, 0, 0))
p = QPainter(pm)
pen = p.pen()
shadow_rect = QRectF(pm.rect())
base_rect = QRectF()
base_rect.setSize(shadow_rect.size() * 0.7)
base_rect.moveCenter(shadow_rect.center())
# Fill
shadow_color = self.icon_color(IconColor.shadow_color)
if shadow_color.alpha() == 255:
shadow_color.setAlpha(64)
p.fillRect(shadow_rect, shadow_color)
# Drop area rect.
p.save()
area_rect = QRectF()
area_line = QLineF()
non_area_rect = QRectF()
if area == DockWidgetArea.top:
area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
elif area == DockWidgetArea.right:
area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
elif area == DockWidgetArea.bottom:
area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
elif area == DockWidgetArea.left:
area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
baseSize = base_rect.size()
if (OverlayMode.container == mode
and area != DockWidgetArea.center):
base_rect = area_rect
p.fillRect(base_rect, background_color)
if area_rect.isValid():
pen = p.pen()
pen.setColor(border_color)
Color = self.icon_color(IconColor.overlay_color)
if Color.alpha() == 255:
Color.setAlpha(64)
p.setBrush(Color)
p.setPen(Qt.NoPen)
p.drawRect(area_rect)
pen = p.pen()
pen.setWidth(1)
pen.setColor(border_color)
pen.setStyle(Qt.DashLine)
p.setPen(pen)
p.drawLine(area_line)
p.restore()
p.save()
# Draw outer border
pen = p.pen()
pen.setColor(border_color)
pen.setWidth(1)
p.setBrush(Qt.NoBrush)
p.setPen(pen)
p.drawRect(base_rect)
# draw window title bar
p.setBrush(border_color)
frame_rect = QRectF(base_rect.topLeft(),
QSizeF(base_rect.width(), baseSize.height()/10))
p.drawRect(frame_rect)
p.restore()
# Draw arrow for outer container drop indicators
if (OverlayMode.container == mode and
area != DockWidgetArea.center):
arrow_rect = QRectF()
arrow_rect.setSize(baseSize)
arrow_rect.setWidth(arrow_rect.width()/4.6)
arrow_rect.setHeight(arrow_rect.height()/2)
arrow_rect.moveCenter(QPointF(0, 0))
arrow = QPolygonF()
arrow.append(arrow_rect.topLeft())
arrow.append(QPointF(arrow_rect.right(), arrow_rect.center().y()))
arrow.append(arrow_rect.bottomLeft())
p.setPen(Qt.NoPen)
p.setBrush(self.icon_color(IconColor.arrow_color))
p.setRenderHint(QPainter.Antialiasing, True)
p.translate(non_area_rect.center().x(), non_area_rect.center().y())
if area == DockWidgetArea.top:
p.rotate(-90)
elif area == DockWidgetArea.right:
...
elif area == DockWidgetArea.bottom:
p.rotate(90)
elif area == DockWidgetArea.left:
p.rotate(180)
p.drawPolygon(arrow)
pm.setDevicePixelRatio(device_pixel_ratio)
return pm