def scaledBoundingRect(self, sx, sy):
"""
Calculate the target rectangle for scaling the graphic
:param float sx: Horizontal scaling factor
:param float sy: Vertical scaling factor
:return: Scaled bounding rectangle
.. note::
In case of paths that are painted with a cosmetic pen
(see :py:meth:`QPen.isCosmetic()`) the target rectangle is
different to multiplying the bounding rectangle.
.. seealso::
:py:meth:`boundingRect()`, :py:meth:`controlPointRect()`
"""
if sx == 1.0 and sy == 1.0:
return self.__data.boundingRect
transform = QTransform()
transform.scale(sx, sy)
rect = transform.mapRect(self.__data.pointRect)
for pathInfo in self.__data.pathInfos:
rect |= pathInfo.scaledBoundingRect(
sx, sy,
not bool(self.__data.renderHints & self.RenderPensUnscaled))
return rect
def updatePosition(self, scene):
# 1. Get pix coords for each lat/lon point
pos0 = scene.posFromLonLat(self._lon0, self._lat0)
pos1 = scene.posFromLonLat(self._lon1, self._lat1)
pos2 = scene.posFromLonLat(self._lon2, self._lat2)
pos3 = scene.posFromLonLat(self._lon3, self._lat3)
self.prepareGeometryChange()
# Set the image to 0, 0, then use a transform to
# to translate, rotate and warp it to the map
# tranfsorm and scale
self.setPos(0, 0)
t = QTransform()
poly1 = QPolygonF()
w = self.pixmap().width()
h = self.pixmap().height()
poly1.append(QPointF(0, 0))
poly1.append(QPointF(w, 0))
poly1.append(QPointF(w, h))
poly1.append(QPointF(0, h))
poly2 = QPolygonF()
poly2.append(QPointF(pos0[0], pos0[1]))
poly2.append(QPointF(pos1[0], pos1[1]))
poly2.append(QPointF(pos2[0], pos2[1]))
poly2.append(QPointF(pos3[0], pos3[1]))
success = QTransform.quadToQuad(poly1, poly2, t)
if not success:
logging.error('Unable to register image')
self.setTransform(t)
def port_scene_position(self,
port_type: PortType,
index: int,
t: QTransform = None) -> QPointF:
"""
Port scene position
Parameters
----------
port_type : PortType
index : int
t : QTransform
Returns
-------
value : QPointF
"""
if t is None:
t = QTransform()
step = self._entry_height + self._spacing
total_height = float(self.caption_height) + step * index
# TODO_UPSTREAM: why?
total_height += step / 2.0
if port_type == PortType.output:
x = self._width + self._style.connection_point_diameter
result = QPointF(x, total_height)
elif port_type == PortType.input:
x = -float(self._style.connection_point_diameter)
result = QPointF(x, total_height)
else:
raise ValueError(port_type)
return t.map(result)
def draw_icon(self, painter):
path = QPainterPath(QPointF(0, 0.3))
path.lineTo(0, 0.9)
path.lineTo(1, 0.3)
path.lineTo(1, 0.9)
path.closeSubpath()
painter.drawPath(path)
painter.drawLine(QPointF(0.5, 0.6), QPointF(0.5, 0.15))
# Draw the arrow end-caps
painter.setBrush(QBrush(QColor(0, 0, 0)))
top_arrow_point = QPointF(0.65, 0.36)
arrow = QPolygonF([
QPointF(-0.09, 0.0),
QPointF(-0.005, 0.0),
QPointF(-0.005, 0.8),
QPointF(0.005, 0.8),
QPointF(0.005, 0.0),
QPointF(0.09, 0.0),
QPointF(0.00, -0.25)
])
t = QTransform()
t.rotate(35)
top_arrow_r = t.map(arrow)
arrow_l = top_arrow_r.translated(top_arrow_point)
painter.drawPolygon(arrow_l)
painter.setBrush(self._interlock_brush)
painter.drawRect(QRectF(0.3, 0, 0.4, 0.15))
def transform(self, img=None):
if not self._geometry or not self.displaymode == DisplayMode.remesh:
return super(EwaldCorrected, self).transform(
img) # Do pixel space transform when not calibrated
from camsaxs import remesh_bbox
img, q_x, q_z = remesh_bbox.remesh(np.squeeze(img),
self._geometry,
reflection=False,
alphai=None)
# Build Quads
shape = img.shape
a = shape[-2] - 1, 0 # bottom-left
b = shape[-2] - 1, shape[-1] - 1 # bottom-right
c = 0, shape[-1] - 1 # top-right
d = 0, 0 # top-left
quad1 = QPolygonF()
quad2 = QPolygonF()
for p, q in zip([a, b, c, d],
[a, b, c, d]): # the zip does the flip :P
quad1.append(QPointF(*p[::-1]))
quad2.append(QPointF(q_x[q], q_z[q]))
transform = QTransform()
QTransform.quadToQuad(quad1, quad2, transform)
for item in self.view.items:
if isinstance(item, ImageItem):
item.setTransform(transform)
self._transform = transform
return img, self._transform
def setData(self, data):
xvals = data.coords[data.dims[-1]]
yvals = data.coords[data.dims[-2]]
xmin = float(xvals.min())
xmax = float(xvals.max())
ymin = float(yvals.min())
ymax = float(yvals.max())
# Position the image according to coords
shape = data.shape
a = [(0, shape[-1]), (shape[-2] - 1, shape[-1]), (shape[-2] - 1, 1), (0, 1)]
# b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)]
b = [(xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)]
quad1 = QPolygonF()
quad2 = QPolygonF()
for p, q in zip(a, b):
quad1.append(QPointF(*p))
quad2.append(QPointF(*q))
transform = QTransform()
QTransform.quadToQuad(quad1, quad2, transform)
# Bind coords from the xarray to the timeline axis
# super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode)
self.image_item.setImage(np.asarray(data), autoLevels=False)
self.image_item.setTransform(transform)
# Label the image axes
self.view.setLabel('left', data.dims[-2])
self.view.setLabel('bottom', data.dims[-1])
def updateZoom(self, zx, zy):
trans = QTransform()
trans.scale(1.0 / zx, 1.0 / zy)
# self.setTransform( trans )
self.VP.setTransform(trans)
self.preBP.setTransform(trans)
self.postBP.setTransform(trans)
self.updateTPPos()
def setZoom(self, x, y):
self.zx = x
self.zy = y
trans = QTransform()
trans.scale(self.zx, self.zy)
self.setTransform(trans)
for vert in self.vertItems:
vert.updateZoom(self.zx, self.zy)
def updateTransfrom(self):
if self.updating: return
self.updating = True
trans = QTransform()
tx = self.valueToX(-self.scrollX) + self.offsetX
ty = self.valueToY(-self.scrollY)
# if ty > 20000:
# raise "wtf"
trans.translate(tx, ty)
self.setTransform(trans)
self.update()
self.updating = False
def pixmap(self, viewer_policy, max_w, max_h):
if not self._image:
self._load_image()
image = self._image
# Scale
scale = viewer_policy["scale"]
if scale == 'fit_auto':
image = image.scaled(max_w, max_h, Qt.KeepAspectRatio)
elif scale == 'fit_to_window':
image = image.scaled(max_w, max_h)
elif scale == 'fit_to_width':
image = image.scaledToWidth(max_w)
elif scale == 'fit_to_height':
image = image.scaledToHeight(max_h)
# Else Original
# Zoom
zoom = self.image_policy["zoom"]
if zoom != 0:
new_size = image.size()
if zoom > 0:
for i in range(abs(zoom)):
new_size *= 1.3
else:
for i in range(abs(zoom)):
new_size /= 1.3
image = image.scaled(new_size, Qt.KeepAspectRatio)
# Vertical Flipping
v_flipping = (abs(self.image_policy["flip_v"]) %
2) * (1 if self.image_policy["flip_v"] >= 0 else -1)
if v_flipping != 0:
v_transform = QTransform().scale(1, -1)
image = image.transformed(v_transform)
# Horizontal Flipping
h_flipping = (abs(self.image_policy["flip_h"]) %
2) * (1 if self.image_policy["flip_h"] >= 0 else -1)
if h_flipping != 0:
h_transform = QTransform().scale(-1, 1)
image = image.transformed(h_transform)
# Rotation
rotation = 90 * (abs(self.image_policy["rotate"]) %
4) * (1 if self.image_policy["rotate"] >= 0 else -1)
if rotation != 0:
r_transform = QTransform().rotate(rotation)
image = image.transformed(r_transform)
return image
def setImage(self, imgdata):
self.imageitem.clear()
self.textitem.hide()
self.imgdata = imgdata
self.imageitem.setImage(np.log(self.imgdata * (self.imgdata > 0) + (self.imgdata < 1)), autoLevels=True)
self.imageitem.setTransform(QTransform(1, 0, 0, -1, 0, self.imgdata.shape[-2]))
self.view.autoRange()
def setImage(self, img, **kwargs):
if hasattr(img, 'coords'):
if 'transform' not in kwargs:
xvals = img.coords[img.dims[-2]]
yvals = img.coords[img.dims[-1]]
xmin = float(xvals.min())
xmax = float(xvals.max())
ymin = float(yvals.min())
ymax = float(yvals.max())
# Position the image according to coords
shape = img.shape
a = [(0, shape[-2]), (shape[-1] - 1, shape[-2]),
(shape[-1] - 1, 1), (0, 1)]
b = [(ymin, xmin), (ymax, xmin), (ymax, xmax), (ymin, xmax)]
quad1 = QPolygonF()
quad2 = QPolygonF()
for p, q in zip(a, b):
quad1.append(QPointF(*p))
quad2.append(QPointF(*q))
transform = QTransform()
QTransform.quadToQuad(quad1, quad2, transform)
kwargs['transform'] = transform
if 'xvals' not in kwargs:
kwargs['xvals'] = np.asarray(img.coords[img.dims[0]])
# Set the timeline axis label from dims
self.ui.roiPlot.setLabel('bottom', img.dims[0])
# Label the image axes
self.axesItem.setLabel('left', img.dims[-2])
self.axesItem.setLabel('bottom', img.dims[-1])
# Add a bit more size
self.ui.roiPlot.setMinimumSize(QSize(0, 70))
# Bind coords from the xarray to the timeline axis
super(XArrayView, self).setImage(img, **kwargs)
def qwtDrawPixmapSymbols(painter, points, numPoints, symbol):
size = symbol.size()
if size.isEmpty():
size = symbol.pixmap().size()
transform = QTransform(painter.transform())
if transform.isScaling():
r = QRect(0, 0, size.width(), size.height())
size = transform.mapRect(r).size()
pm = QPixmap(symbol.pixmap())
if pm.size() != size:
pm = pm.scaled(size)
pinPoint = QPointF(0.5 * size.width(), 0.5 * size.height())
if symbol.isPinPointEnabled():
pinPoint = symbol.pinPoint()
painter.resetTransform()
for pos in points:
pos = QPointF(transform.map(pos)) - pinPoint
QwtPainter.drawPixmap(painter, QRect(pos.toPoint(), pm.size()), pm)
def paintEvent(self, event):
super(DataGraphWidget, self).paintEvent(event)
if not self.text_adjusted:
for node in self.nodes:
width = node.label.boundingRect().width()
height = node.label.boundingRect().height()
transform = QTransform()
if node in self.left_nodes:
transform.translate(-width, -height / 2)
else:
transform.translate(0, -height / 2)
node.label.setTransform(transform)
self.text_adjusted = True
def transform(self, img=None):
# Build Quads
shape = img.shape
a = [(0, shape[-2] - 1), (shape[-1] - 1, shape[-2] - 1), (shape[-1] - 1, 0), (0, 0)]
b = [(0, 1), (shape[-1] - 1, 1), (shape[-1] - 1, shape[-2]), (0, shape[-2])]
quad1 = QPolygonF()
quad2 = QPolygonF()
for p, q in zip(a, b):
quad1.append(QPointF(*p))
quad2.append(QPointF(*q))
transform = QTransform()
QTransform.quadToQuad(quad1, quad2, transform)
for item in self.view.items:
if isinstance(item, ImageItem):
item.setTransform(transform)
self._transform = transform
return img, transform
def setData(self, data):
# Constrain squareness when units match
is_square = data.dims[-2].split('(')[-1] == data.dims[-1].split(
'(')[-1]
self.view.vb.setAspectLocked(is_square)
xvals = data.coords[data.dims[-1]]
yvals = data.coords[data.dims[-2]]
xmin = float(xvals.min())
xmax = float(xvals.max())
ymin = float(yvals.min())
ymax = float(yvals.max())
# Position the image according to coords
shape = data.shape
a = [(0, shape[-2]), (shape[-1], shape[-2]), (shape[-1], 0), (0, 0)]
# b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)]
if self.slice_direction in ['horizontal', 'depth']:
b = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
elif self.slice_direction == 'vertical':
b = [(xmax, ymax), (xmin, ymax), (xmin, ymin), (xmax, ymin)]
quad1 = QPolygonF()
quad2 = QPolygonF()
for p, q in zip(a, b):
quad1.append(QPointF(*p))
quad2.append(QPointF(*q))
transform = QTransform()
QTransform.quadToQuad(quad1, quad2, transform)
# Bind coords from the xarray to the timeline axis
# super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode)
self.image_item.setImage(np.asarray(data), autoLevels=False)
self.image_item.setTransform(transform)
# Label the image axes
self.view.setLabel('left', data.dims[-2])
self.view.setLabel('bottom', data.dims[-1])
def __init__(self,
image,
name="",
invertY=False,
xlabel: str = None,
ylabel: str = None,
transform=None,
z: int = None,
**kwargs):
self._name = name
super(ImageHint, self).__init__()
self.count = next(self.ref_count)
self.image = image
self.invertY = invertY
self.xlabel = xlabel
self.ylabel = ylabel
self.transform = transform
if transform is None:
transform = QTransform()
transform.translate(0, -1)
transform.scale(0, -1)
self.transform = transform
self.z = z
self.kwargs = kwargs
self.enabled = False
self.canvas = None
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 __init__(self, *args, **kwargs):
# Add axes
self.axesItem = PlotItem()
self.axesItem.axes["left"]["item"].setZValue(10)
self.axesItem.axes["top"]["item"].setZValue(10)
if "view" not in kwargs:
kwargs["view"] = self.axesItem
self._transform = QTransform()
super(PixelSpace, self).__init__(*args, **kwargs)
self.imageItem.sigImageChanged.connect(self.updateAxes)
def draw_icon(self, painter):
painter.drawEllipse(QPointF(0.5, 0.5), 0.5, 0.5)
painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 45 * 16, -120 * 16)
painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 135 * 16, 120 * 16)
bottom_arrow_point = QPointF(0.5, 0.8)
painter.drawLine(bottom_arrow_point, QPointF(0.5, 0.7))
curve_start = QPointF(0.5, 0.7)
bend_angle = 25
curve_end_l = QPointF(
0.4 * math.cos(math.radians(90 + bend_angle)) + 0.5,
-0.4 * math.sin(math.radians(90 + bend_angle)) + 0.5)
c1 = QPointF(0.5, 0.4)
path = QPainterPath(curve_start)
path.quadTo(c1, curve_end_l)
painter.drawPath(path)
curve_end_r = QPointF(
0.4 * math.cos(math.radians(90 - bend_angle)) + 0.5,
-0.4 * math.sin(math.radians(90 - bend_angle)) + 0.5)
path = QPainterPath(curve_start)
path.quadTo(c1, curve_end_r)
painter.drawPath(path)
# Draw the arrow end-caps
painter.setBrush(QBrush(QColor(0, 0, 0)))
arrow = QPolygonF(
[QPointF(-0.025, 0.0),
QPointF(0.025, 0.0),
QPointF(0.0, 0.025)])
painter.drawPolygon(arrow.translated(bottom_arrow_point))
t = QTransform()
t.rotate(180.0 - 25.0)
arrow_l = t.map(arrow)
arrow_l = arrow_l.translated(curve_end_l)
painter.drawPolygon(arrow_l)
t = QTransform()
t.rotate(180.0 + 25.0)
arrow_r = t.map(arrow)
arrow_r = arrow_r.translated(curve_end_r)
painter.drawPolygon(arrow_r)
def qwtDrawGraphicSymbols(painter, points, numPoint, graphic, symbol):
pointRect = QRectF(graphic.controlPointRect())
if pointRect.isEmpty():
return
sx = 1.0
sy = 1.0
sz = symbol.size()
if sz.isValid():
sx = sz.width() / pointRect.width()
sy = sz.height() / pointRect.height()
pinPoint = QPointF(pointRect.center())
if symbol.isPinPointEnabled():
pinPoint = symbol.pinPoint()
transform = QTransform(painter.transform())
for pos in points:
tr = QTransform(transform)
tr.translate(pos.x(), pos.y())
tr.scale(sx, sy)
tr.translate(-pinPoint.x(), -pinPoint.y())
painter.setTransform(tr)
graphic.render(painter)
painter.setTransform(transform)
def scaledBoundingRect(self, sx, sy, scalePens):
if sx == 1.0 and sy == 1.0:
return self.__boundingRect
transform = QTransform()
transform.scale(sx, sy)
if scalePens and self.__scalablePen:
rect = transform.mapRect(self.__boundingRect)
else:
rect = transform.mapRect(self.__pointRect)
l = abs(self.__pointRect.left() - self.__boundingRect.left())
r = abs(self.__pointRect.right() - self.__boundingRect.right())
t = abs(self.__pointRect.top() - self.__boundingRect.top())
b = abs(self.__pointRect.bottom() - self.__boundingRect.bottom())
rect.adjust(-l, -t, r, b)
return rect
def labelTransformation(self, pos, size):
"""
Calculate the transformation that is needed to paint a label
depending on its alignment and rotation.
:param QPointF pos: Position where to paint the label
:param QSizeF size: Size of the label
:return: Transformation matrix
.. seealso::
:py:meth:`setLabelAlignment()`, :py:meth:`setLabelRotation()`
"""
transform = QTransform()
transform.translate(pos.x(), pos.y())
transform.rotate(self.labelRotation())
flags = self.labelAlignment()
if flags == 0:
flags = self.Flags[self.alignment()]
if flags & Qt.AlignLeft:
x = -size.width()
elif flags & Qt.AlignRight:
x = 0.0
else:
x = -(0.5 * size.width())
if flags & Qt.AlignTop:
y = -size.height()
elif flags & Qt.AlignBottom:
y = 0
else:
y = -(0.5 * size.height())
transform.translate(x, y)
return transform
def monitor_images(self):
while self.active:
if self.last_frame:
image_array = self.style.stylize(self.last_frame)
image = QImage(image_array.data, image_array.shape[1],
image_array.shape[0], image_array.strides[0],
QImage.Format_RGB888)
rotating = QTransform()
rotating.scale(-1, 1) # mirror
rotating.rotate(settings.ROTATE_IMAGE)
image = image.transformed(rotating)
self.image_signal.emit(StyledCapture(image, self.style.name))
# check for stop/changes
QApplication.processEvents()
def paintEvent(self, event):
super(DataGraphWidget, self).paintEvent(event)
if not self.text_adjusted:
for node in self.nodes:
width = node.label.boundingRect().width()
height = node.label.boundingRect().height()
transform = QTransform()
if node in self.left_nodes:
transform.translate(-width, -height / 2)
else:
transform.translate(0, -height / 2)
node.label.setTransform(transform)
self.text_adjusted = True
def _paint_icon(self, iconic, painter, rect, mode, state, options):
"""Paint a single icon."""
painter.save()
color = options['color']
char = options['char']
color_options = {
QIcon.On: {
QIcon.Normal: (options['color_on'], options['on']),
QIcon.Disabled:
(options['color_on_disabled'], options['on_disabled']),
QIcon.Active:
(options['color_on_active'], options['on_active']),
QIcon.Selected:
(options['color_on_selected'], options['on_selected'])
},
QIcon.Off: {
QIcon.Normal: (options['color_off'], options['off']),
QIcon.Disabled:
(options['color_off_disabled'], options['off_disabled']),
QIcon.Active:
(options['color_off_active'], options['off_active']),
QIcon.Selected:
(options['color_off_selected'], options['off_selected'])
}
}
color, char = color_options[state][mode]
painter.setPen(QColor(color))
# A 16 pixel-high icon yields a font size of 14, which is pixel perfect
# for font-awesome. 16 * 0.875 = 14
# The reason why the glyph size is smaller than the icon size is to
# account for font bearing.
draw_size = round(0.875 * rect.height() * options['scale_factor'])
prefix = options['prefix']
# Animation setup hook
animation = options.get('animation')
if animation is not None:
animation.setup(self, painter, rect)
painter.setFont(iconic.font(prefix, draw_size))
if 'offset' in options:
rect = QRect(rect)
rect.translate(round(options['offset'][0] * rect.width()),
round(options['offset'][1] * rect.height()))
if 'vflip' in options and options['vflip'] == True:
x_center = rect.width() * 0.5
y_center = rect.height() * 0.5
painter.translate(x_center, y_center)
transfrom = QTransform()
transfrom.scale(1, -1)
painter.setTransform(transfrom, True)
painter.translate(-x_center, -y_center)
if 'hflip' in options and options['hflip'] == True:
x_center = rect.width() * 0.5
y_center = rect.height() * 0.5
painter.translate(x_center, y_center)
transfrom = QTransform()
transfrom.scale(-1, 1)
painter.setTransform(transfrom, True)
painter.translate(-x_center, -y_center)
if 'rotated' in options:
x_center = rect.width() * 0.5
y_center = rect.height() * 0.5
painter.translate(x_center, y_center)
painter.rotate(options['rotated'])
painter.translate(-x_center, -y_center)
painter.setOpacity(options.get('opacity', 1.0))
painter.drawText(rect, int(Qt.AlignCenter | Qt.AlignVCenter), char)
painter.restore()
def setCommands(self, commands):
self.reset()
painter = QPainter(self)
for cmd in commands:
qwtExecCommand(painter, cmd, 0, QTransform(), None)
painter.end()
def paintEvent(self, event):
""" Adds a frame and the splitters internal id to the UI if debug is enabled.
:param event: paint event
"""
painter = QPainter(self)
if CONFIG.debug_layout:
painter.setPen(QPen(Qt.yellow, 4.0))
painter.drawRect(self.rect().adjusted(1, 1, -2, -2))
painter.setPen(QPen(Qt.black, 1.0))
painter.drawText(QPointF(5, 12), str(self))
# Relative drop cross and icons
dock_center_x = self.width() / 2.0
dock_center_y = self.height() / 2.0
d_transform = QTransform()
transform = d_transform.fromTranslate(dock_center_x, dock_center_y)
painter.setTransform(transform)
self._paintBackgroundCross(painter)
transform = d_transform.fromTranslate(dock_center_x - 34,
dock_center_y)
painter.setTransform(transform)
self._paintRefDropIcon(painter, Placement.LEFT)
transform = d_transform.fromTranslate(dock_center_x - 68,
dock_center_y)
painter.setTransform(transform)
self._paintAbsDropIcon(painter, Placement.LEFT)
transform = d_transform.fromTranslate(dock_center_x,
dock_center_y - 34)
painter.setTransform(transform)
self._paintRefDropIcon(painter, Placement.TOP)
transform = d_transform.fromTranslate(dock_center_x,
dock_center_y - 68)
painter.setTransform(transform)
self._paintAbsDropIcon(painter, Placement.TOP)
transform = d_transform.fromTranslate(dock_center_x + 34,
dock_center_y)
painter.setTransform(transform)
self._paintRefDropIcon(painter, Placement.RIGHT)
transform = d_transform.fromTranslate(dock_center_x + 68,
dock_center_y)
painter.setTransform(transform)
self._paintAbsDropIcon(painter, Placement.RIGHT)
transform = d_transform.fromTranslate(dock_center_x,
dock_center_y + 34)
painter.setTransform(transform)
self._paintRefDropIcon(painter, Placement.BOTTOM)
transform = d_transform.fromTranslate(dock_center_x,
dock_center_y + 68)
painter.setTransform(transform)
self._paintAbsDropIcon(painter, Placement.BOTTOM)
transform = d_transform.fromTranslate(dock_center_x, dock_center_y)
painter.setTransform(transform)
self._paintRefDropIcon(painter, Placement.TAB)
def zoomOriginal(self):
self._ui.view.setTransform(QTransform())
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 draw_icon(self, painter):
painter.drawEllipse(QPointF(0.5, 0.5), 0.5, 0.5)
painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 90 * 16, -100 * 16)
painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 135 * 16, 100 * 16)
# Draw the arrow end-caps
painter.setBrush(QBrush(QColor(0, 0, 0)))
top_arrow_point = QPointF(0.35, 0.15)
arrow = QPolygonF([
QPointF(-0.08, 0.0),
QPointF(-0.005, 0.0),
QPointF(-0.005, 0.15),
QPointF(0.005, 0.15),
QPointF(0.005, 0.0),
QPointF(0.08, 0.0),
QPointF(0.00, -0.08)
])
t = QTransform()
t.rotate(-25)
top_arrow_r = t.map(arrow)
arrow_l = top_arrow_r.translated(top_arrow_point)
painter.drawPolygon(arrow_l)
bottom_left_arrow_point = QPointF(0.35, 0.89)
t = QTransform()
t.rotate(180.0 + 25.0)
arrow_r = t.map(arrow)
arrow_r = arrow_r.translated(bottom_left_arrow_point)
painter.drawPolygon(arrow_r)
bottom_right_arrow_point = QPointF(0.85, 0.65)
t = QTransform()
t.rotate(180.0 - 65.0)
arrow_r = t.map(arrow)
arrow_r = arrow_r.translated(bottom_right_arrow_point)
painter.drawPolygon(arrow_r)
