def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemHand = QGraphicsSvgItem(":/qfi/images/vsi/vsi_hand.svg")
self.m_itemHand.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand.setZValue( self.m_handZ )
self.m_itemHand.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemHand)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/vsi/vsi_face.svg")
self.m_itemFace.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace.setZValue( self.m_faceZ )
self.m_itemFace.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemFace)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/vsi/vsi_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def init(self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemHand = QGraphicsSvgItem(":/qfi/images/vsi/vsi_hand.svg")
self.m_itemHand.setCacheMode(QGraphicsItem.NoCache)
self.m_itemHand.setZValue(self.m_handZ)
self.m_itemHand.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemHand.setTransformOriginPoint(self.m_originalVsiCtr)
self.m_scene.addItem(self.m_itemHand)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/vsi/vsi_face.svg")
self.m_itemFace.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace.setZValue(self.m_faceZ)
self.m_itemFace.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace.setTransformOriginPoint(self.m_originalVsiCtr)
self.m_scene.addItem(self.m_itemFace)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/vsi/vsi_case.svg")
self.m_itemCase.setCacheMode(QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemCase.setTransformOriginPoint(self.m_originalVsiCtr)
self.m_scene.addItem(self.m_itemCase)
self.centerOn(self.width() / 2, self.height() / 2)
self.updateView()
def init (self):
# os.chdir('/Users/zeyneptuna/Desktop/during_flight/widget/battery')
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemFace = QGraphicsSvgItem("widget/battery/battery_face.svg")
self.m_itemFace.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace.setZValue(self.m_faceZ)
self.m_itemFace.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace.setTransformOriginPoint(self.m_originalCtr)
self.m_scene.addItem(self.m_itemFace)
self.m_itemCase = QGraphicsSvgItem("widget/battery/battery_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemCase.setTransformOriginPoint(self.m_originalCtr)
self.m_scene.addItem(self.m_itemCase)
self.m_itemMark = QGraphicsSvgItem("widget/battery/battery_mark.svg")
self.m_itemMark.setCacheMode (QGraphicsItem.NoCache)
self.m_itemMark.setZValue(self.m_markZ)
self.m_itemMark.setPos(57, 120)
self.m_itemMark.setScale(0.77)
self.m_scene.addItem(self.m_itemMark)
self.m_itemMark2 = QGraphicsSvgItem("widget/battery/battery_mark.svg")
self.m_itemMark2.setCacheMode (QGraphicsItem.NoCache)
self.m_itemMark2.setZValue(self.m_mark2Z)
self.m_itemMark2.setPos(57, 92.5)
self.m_itemMark2.setScale(0.77)
self.m_scene.addItem(self.m_itemMark2)
self.m_itemMark3 = QGraphicsSvgItem("widget/battery/battery_mark.svg")
self.m_itemMark3.setCacheMode (QGraphicsItem.NoCache)
self.m_itemMark3.setZValue(self.m_mark3Z)
self.m_itemMark3.setPos(57, 65)
self.m_itemMark3.setScale(0.77)
self.m_scene.addItem(self.m_itemMark3)
self.m_itemMark4 = QGraphicsSvgItem("widget/battery/battery_mark.svg")
self.m_itemMark4.setCacheMode(QGraphicsItem.NoCache)
self.m_itemMark4.setZValue(self.m_mark4Z)
self.m_itemMark4.setPos(57, 37.5)
self.m_itemMark4.setScale(0.77)
self.m_scene.addItem(self.m_itemMark4)
self.m_itemMark5 = QGraphicsSvgItem("widget/battery/battery_mark.svg")
self.m_itemMark5.setCacheMode (QGraphicsItem.NoCache)
self.m_itemMark5.setZValue(self.m_mark5Z)
self.m_itemMark5.setPos(57, 10)
self.m_itemMark5.setScale(0.77)
self.m_scene.addItem(self.m_itemMark5)
self.centerOn(self.width()/2, self.height()/2)
self.updateView()
def draw_frequency_marker(self, x_pos, frequency):
if frequency is None:
self.clear_frequency_marker()
return
y1 = self.sceneRect().y()
y2 = self.sceneRect().y() + self.sceneRect().height()
if self.frequency_marker is None:
pen = QPen(constants.LINECOLOR, 0)
self.frequency_marker = [None, None]
self.frequency_marker[0] = self.addLine(x_pos, y1, x_pos, y2, pen)
self.frequency_marker[1] = self.addSimpleText("")
self.frequency_marker[1].setBrush(QBrush(constants.LINECOLOR))
font = QFont()
font.setBold(True)
font.setPointSize(int(font.pointSize() * 1.25)+1)
self.frequency_marker[1].setFont(font)
self.frequency_marker[0].setLine(x_pos, y1, x_pos, y2)
scale_x, scale_y = util.calc_x_y_scale(self.sceneRect(), self.parent())
self.frequency_marker[1].setTransform(QTransform.fromScale(scale_x, scale_y), False)
self.frequency_marker[1].setText("Tune to " + Formatter.big_value_with_suffix(frequency, decimals=3))
font_metric = QFontMetrics(self.frequency_marker[1].font())
text_width = font_metric.width("Tune to") * scale_x
text_width += (font_metric.width(" ") * scale_x) / 2
self.frequency_marker[1].setPos(x_pos-text_width, 0.95*y1)
def draw_frequency_marker(self, x_pos, frequency):
if frequency is None:
self.clear_frequency_marker()
return
y1 = self.sceneRect().y()
y2 = self.sceneRect().y() + self.sceneRect().height()
if self.frequency_marker is None:
pen = QPen(constants.LINECOLOR, 0)
self.frequency_marker = [None, None]
self.frequency_marker[0] = self.addLine(x_pos, y1, x_pos, y2, pen)
self.frequency_marker[1] = self.addSimpleText("")
self.frequency_marker[1].setBrush(QBrush(constants.LINECOLOR))
font = QFont()
font.setBold(True)
font.setPointSize(int(font.pointSize() * 1.25)+1)
self.frequency_marker[1].setFont(font)
self.frequency_marker[0].setLine(x_pos, y1, x_pos, y2)
scale_x, scale_y = self.__calc_x_y_scale(self.sceneRect())
self.frequency_marker[1].setTransform(QTransform.fromScale(scale_x, scale_y), False)
self.frequency_marker[1].setText("Tune to " + Formatter.big_value_with_suffix(frequency, decimals=3))
font_metric = QFontMetrics(self.frequency_marker[1].font())
text_width = font_metric.width("Tune to") * scale_x
text_width += (font_metric.width(" ") * scale_x) / 2
self.frequency_marker[1].setPos(x_pos-text_width, 0.95*y1)
def redraw_legend(self, force_show=False):
if not (force_show or self.always_show_symbols_legend):
self.hide_legend()
return
num_captions = len(self.centers) + 1
if num_captions != len(self.captions):
self.clear_legend()
fmt = "{0:0" + str(self.bits_per_symbol) + "b}"
for i in range(num_captions):
font = QFont()
font.setPointSize(16)
font.setBold(True)
self.captions.append(self.addSimpleText(fmt.format(i), font))
view_rect = self.parent().view_rect() # type: QRectF
padding = 0
fm = QFontMetrics(self.captions[0].font())
for i, caption in enumerate(self.captions):
caption.show()
scale_x, scale_y = util.calc_x_y_scale(self.separation_areas[i].rect(), self.parent())
try:
caption.setPos(view_rect.x() + view_rect.width() - fm.width(caption.text()) * scale_x,
self.centers[i] + padding)
except IndexError:
caption.setPos(view_rect.x() + view_rect.width() - fm.width(caption.text()) * scale_x,
self.centers[i - 1] - padding - fm.height() * scale_y)
caption.setTransform(QTransform.fromScale(scale_x, scale_y), False)
def ParseTransformAttrib(s):
# where s is an SVG transform attribute such as "translate(-2,1) matrix(0 1 2 3 4 5)"
# return a list of QTransforms
xforms = []
s = s.lower()
while s:
s = re.sub(r'^\s+,?\s+', '', s) # remove leading WS,WS
m = re.match(r'\s*(\w+)\s*\(((\s*[0-9e.+-]+\s*,?)+)\)', s) # match identifier(numbers) clause
if m:
values = SplitFloatValues(m.group(2))
if m.group(1) == 'translate':
if len(values) == 1: values.append(0)
xforms.append( QTransform.fromTranslate(*values) )
elif m.group(1) == 'scale':
if len(values) == 1: values.append(values[0])
xforms.append( QTransform.fromScale(*values) )
elif m.group(1) == 'rotate':
xforms.append( QTransform().rotate(values[0]) ) # TODO: handle cx,cy values
elif m.group(1) == 'matrix':
logger.trace('matrix({}): m.group(2) = {}', values, m.group(2))
xforms.append( QTransform( values[0], values[1], 0
, values[2], values[3], 0
, values[4], values[5], 1) )
# TODO: handle skewX and skewY
else: logger.warning('unrecognized transform: {}', m.group())
s = s[m.end()+1:]
else:
if s: logger.warning('unparsed transform: {}', s)
break
return xforms
def set_scale(self, sx, sy, px, py):
m = QTransform.fromTranslate(-px, -py)
m = QTransform.fromScale(sx, sy) * m
m = QTransform.fromTranslate(px, py) * m
m = self._tmove * m
self._tmove = m
def _coordinate_transform(self, input: QRectF, output: QRectF):
rx, ry = output.width() / input.width(), output.height(
) / input.height()
t = QTransform.fromTranslate(-input.left(), -input.top())
t *= QTransform.fromScale(rx, ry)
t *= QTransform.fromTranslate(output.left(), output.top())
return t
def ParseTransformAttrib(s):
# where s is an SVG transform attribute such as "translate(-2,1) matrix(0 1 2 3 4 5)"
# return a list of QTransforms
xforms = []
s = s.lower()
while s:
s = re.sub(r'^\s+,?\s+', '', s) # remove leading WS,WS
m = re.match(r'\s*(\w+)\s*\(((\s*[0-9e.+-]+\s*,?)+)\)',
s) # match identifier(numbers) clause
if m:
values = SplitFloatValues(m.group(2))
if m.group(1) == 'translate':
if len(values) == 1: values.append(0)
xforms.append(QTransform.fromTranslate(*values))
elif m.group(1) == 'scale':
if len(values) == 1: values.append(values[0])
xforms.append(QTransform.fromScale(*values))
elif m.group(1) == 'rotate':
xforms.append(QTransform().rotate(
values[0])) # TODO: handle cx,cy values
elif m.group(1) == 'matrix':
logger.trace('matrix({}): m.group(2) = {}', values, m.group(2))
xforms.append(
QTransform(values[0], values[1], 0, values[2], values[3],
0, values[4], values[5], 1))
# TODO: handle skewX and skewY
else:
logger.warning('unrecognized transform: {}', m.group())
s = s[m.end() + 1:]
else:
if s: logger.warning('unparsed transform: {}', s)
break
return xforms
def scaleImages(self, kx, ky):
for item in self.items:
rect = item.boundingRect()
scale = QTransform.fromScale(
1 + kx * self.tuningStep() / rect.width(),
1 + ky * self.tuningStep() / rect.height())
item.setTransform(scale, combine=True)
self.updateDisplay()
def dc_invskew():
path1, path2 = p_skew()
t = QTransform.fromScale(-1, 1).translate(-20, 0)
return [
QSize(20, 20),
(path1 * t, 'f', _sidebarIconsFillColor),
(path2 * t, '1', _sidebarIconsStrokeColor),
]
def new_absolute_zoom(self, factor):
"""Sets a new absolute zoom and emits viewport_changed.
"""
f = factor
scene_rect = self.scene().sceneRect() # Scene
view_rect = self.viewport().rect() # Available space
# The size of the scene if the new transform is applied
t_scene_rect = QTransform.fromScale(f, f).mapRect(scene_rect)
if (t_scene_rect.width() < view_rect.width()
and t_scene_rect.height() < view_rect.height()):
# The user wants to zoom out so that the image is smaller than the
# view
self.zoom_home()
else:
f = min(self.MAXIMUM_ZOOM, f)
msg = 'Change absolute zoom from [{0}] to [{1}]'
debug_print(msg.format(self.absolute_zoom, f))
selected = self.scene().selectedItems()
if not selected:
# No selection so we want to centre on the mouse cursor, if it
# is within the view. We need to get the mouse position in
# scene coords before applying the zoom.
mouse_pos = self.mapFromGlobal(QCursor.pos())
if self.rect().contains(mouse_pos, proper=True):
mouse_pos = self.mapToScene(mouse_pos)
else:
mouse_pos = None
self.setTransform(QTransform.fromScale(f, f))
if selected:
# Centre on selected items
self.centerOn(
unite_rects(i.sceneBoundingRect()
for i in selected).center())
elif mouse_pos:
# Centre on mouse position
self.centerOn(mouse_pos)
else:
# Default behaviour is fine
pass
self.viewport_changed.emit(self.normalised_scene_rect())
def new_absolute_zoom(self, factor):
"""Sets a new absolute zoom and emits viewport_changed.
"""
f = factor
scene_rect = self.scene().sceneRect() # Scene
view_rect = self.viewport().rect() # Available space
# The size of the scene if the new transform is applied
t_scene_rect = QTransform.fromScale(f, f).mapRect(scene_rect)
if (t_scene_rect.width() < view_rect.width() and
t_scene_rect.height() < view_rect.height()):
# The user wants to zoom out so that the image is smaller than the
# view
self.zoom_home()
else:
f = min(self.MAXIMUM_ZOOM, f)
msg = 'Change absolute zoom from [{0}] to [{1}]'
debug_print(msg.format(self.absolute_zoom, f))
selected = self.scene().selectedItems()
if not selected:
# No selection so we want to centre on the mouse cursor, if it
# is within the view. We need to get the mouse position in
# scene coords before applying the zoom.
mouse_pos = self.mapFromGlobal(QCursor.pos())
if self.rect().contains(mouse_pos, proper=True):
mouse_pos = self.mapToScene(mouse_pos)
else:
mouse_pos = None
self.setTransform(QTransform.fromScale(f, f))
if selected:
# Centre on selected items
self.centerOn(
unite_rects(i.sceneBoundingRect() for i in selected).center()
)
elif mouse_pos:
# Centre on mouse position
self.centerOn(mouse_pos)
else:
# Default behaviour is fine
pass
self.viewport_changed.emit(self.normalised_scene_rect())
def redraw_legend(self, force_show=False):
if not (force_show or self.always_show_symbols_legend):
if self.zeros_caption is not None:
self.zeros_caption.hide()
if self.ones_caption is not None:
self.ones_caption.hide()
return
if self.ones_caption is None:
font = QFont()
font.setPointSize(32)
font.setBold(True)
self.ones_caption = self.addSimpleText("1", font)
if self.zeros_caption is None:
font = QFont()
font.setPointSize(32)
font.setBold(True)
self.zeros_caption = self.addSimpleText("0", font)
view_rect = self.parent().view_rect() # type: QRectF
self.ones_caption.show()
self.zeros_caption.show()
padding = view_rect.height() / 20
scale_x, scale_y = util.calc_x_y_scale(self.ones_area.rect(),
self.parent())
y_mid = self.y_mid
fm = QFontMetrics(self.ones_caption.font())
self.ones_caption.setPos(
view_rect.x() + view_rect.width() - fm.width("1") * scale_x,
y_mid - fm.height() * scale_y - padding)
self.ones_caption.setTransform(QTransform.fromScale(scale_x, scale_y),
False)
scale_x, scale_y = util.calc_x_y_scale(self.zeros_area.rect(),
self.parent())
self.zeros_caption.setPos(
view_rect.x() + view_rect.width() - fm.width("0") * scale_x,
y_mid + padding)
self.zeros_caption.setTransform(QTransform.fromScale(scale_x, scale_y),
False)
def init (self):
#os.chdir('/Users/zeyneptuna/Desktop/during_flight/widget/flight_duration')
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemFace = QGraphicsSvgItem("widget/flight_duration/fd_face.svg")
self.m_itemFace.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace.setZValue(self.m_faceZ)
self.m_itemFace.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace.setTransformOriginPoint(self.m_originalFdCtr)
self.m_scene.addItem(self.m_itemFace)
self.m_itemCase = QGraphicsSvgItem("widget/flight_duration/fd_case.svg")
self.m_itemCase.setCacheMode(QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemCase.setTransformOriginPoint(self.m_originalFdCtr)
self.m_scene.addItem(self.m_itemCase)
#self.m_itemMark1 = QGraphicsSvgItem("fd_mark_1.svg")
#self.m_itemMark1.setCacheMode(QGraphicsItem.NoCache)
#self.m_itemMark1.setZValue(self.m_mark1Z)
#self.m_itemMark1.setTransformOriginPoint(self.m_originalMarkCtr)
#self.m_itemMark1.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
#self.m_scene.addItem(self.m_itemMark1)
#self.m_itemMark2 = QGraphicsSvgItem("fd_mark_2.svg")
#self.m_itemMark2.setCacheMode(QGraphicsItem.NoCache)
#self.m_itemMark2.setZValue(self.m_mark2Z)
#self.m_itemMark2.setTransformOriginPoint(self.m_originalMarkCtr)
#self.m_itemMark2.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
#self.m_scene.addItem(self.m_itemMark2)
#self.m_itemMark3 = QGraphicsSvgItem("fd_mark_3.svg")
#self.m_itemMark3.setCacheMode(QGraphicsItem.NoCache)
#self.m_itemMark3.setZValue(self.m_mark3Z)
#self.m_itemMark3.setTransformOriginPoint(self.m_originalMarkCtr)
#self.m_itemMark3.setTransform(QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
#self.m_scene.addItem(self.m_itemMark3)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def _QGraphicssItem_scale(self, *args):
if args:
warnings.warn(
"QGraphicsItem.scale(sx, sy) is obsolete and removed in PyQt5. "
"Use setTransform(QTransform.fromScale(sx, sy), True) instead.",
DeprecationWarning,
stacklevel=2)
self.setTransform(QTransform.fromScale(*args), True)
else:
return _QGraphicsItem_scale1(self)
def __init__(self, zoom=1.0, zoom_cb=lambda zoom: None):
super().__init__()
self.pixmap = None
self.zoom = zoom
self.zoom_cb = zoom_cb
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.pixmap_item = QGraphicsPixmapItem()
self.scene = QGraphicsScene()
self.scene.addItem(self.pixmap_item)
self.setScene(self.scene)
self.setTransform(QTransform.fromScale(zoom, zoom))
def _QGraphicssItem_scale(self, *args):
if args:
warnings.warn(
"QGraphicsItem.scale(sx, sy) is obsolete and removed in PyQt5. "
"Use setTransform(QTransform.fromScale(sx, sy), True) instead.",
DeprecationWarning,
stacklevel=2
)
self.setTransform(QTransform.fromScale(*args), True)
else:
return _QGraphicsItem_scale1(self)
def __init__(self, src, title, pixmap, NW_coords, SE_coords):
QGraphicsPixmapItem.__init__(self, pixmap, None)
self.source_file = src
self.title = title
rect = self.boundingRect()
nw = NW_coords.toQPointF()
se = SE_coords.toQPointF()
scale = QTransform.fromScale((se.x() - nw.x()) / rect.width(),
(se.y() - nw.y()) / rect.height())
self.setTransform(scale)
self.setPos(nw)
self.setVisible(False)
def init(self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemBack = QGraphicsSvgItem(":/qfi/images/adi/adi_back.svg")
self.m_itemBack.setCacheMode(QGraphicsItem.NoCache)
self.m_itemBack.setZValue(self.m_backZ)
self.m_itemBack.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemBack.setTransformOriginPoint(self.m_originalAdiCtr)
self.m_scene.addItem(self.m_itemBack)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/adi/adi_face.svg")
self.m_itemFace.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace.setZValue(self.m_faceZ)
self.m_itemFace.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace.setTransformOriginPoint(self.m_originalAdiCtr)
self.m_scene.addItem(self.m_itemFace)
self.m_itemRing = QGraphicsSvgItem(":/qfi/images/adi/adi_ring.svg")
self.m_itemRing.setCacheMode(QGraphicsItem.NoCache)
self.m_itemRing.setZValue(self.m_ringZ)
self.m_itemRing.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemRing.setTransformOriginPoint(self.m_originalAdiCtr)
self.m_scene.addItem(self.m_itemRing)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode(QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemCase.setTransformOriginPoint(self.m_originalAdiCtr)
self.m_scene.addItem(self.m_itemCase)
self.centerOn(self.width() / 2, self.height() / 2)
self.updateView()
def update_transform(self):
if self.transformChanged:
translation = QTransform()
translation = translation.fromTranslate(self.worldPosition[0],
self.worldPosition[1])
scale = QTransform()
scale = scale.fromScale(self.worldScale[0], self.worldScale[1])
rot = QTransform()
rot = rot.rotate(self.worldRotation)
self.worldTransform = scale * rot * translation
self.transformChanged = False
self.update_aabb()
return
def __init__(self, text, x, y, size, color):
self._pos = QPointF(x - 1.8, y + 1.8)
super().__init__()
self.text = QGraphicsTextItem(text)
transform = QTransform.fromScale(0.3, -0.3)
self.text.setTransformOriginPoint(self._pos)
self.text.setTransform(transform)
self.text.setPos(self._pos)
# self.text.setRotation(-180)
font = QFont("Times", 2)
self.text.setFont(font)
self._visible = 1
def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemBack = QGraphicsSvgItem(":/qfi/images/adi/adi_back.svg")
self.m_itemBack.setCacheMode (QGraphicsItem.NoCache)
self.m_itemBack.setZValue( self.m_backZ )
self.m_itemBack.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemBack.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemBack)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/adi/adi_face.svg")
self.m_itemFace.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace.setZValue( self.m_faceZ )
self.m_itemFace.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemFace)
self.m_itemRing = QGraphicsSvgItem(":/qfi/images/adi/adi_ring.svg")
self.m_itemRing.setCacheMode (QGraphicsItem.NoCache)
self.m_itemRing.setZValue( self.m_ringZ )
self.m_itemRing.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemRing.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemRing)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def init(self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemFace_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_1.svg")
self.m_itemFace_1.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace_1.setZValue(self.m_face1Z)
self.m_itemFace_1.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace_1.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemFace_1)
self.m_itemFace_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_2.svg")
self.m_itemFace_2.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace_2.setZValue(self.m_face2Z)
self.m_itemFace_2.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace_2.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemFace_2)
self.m_itemFace_3 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_3.svg")
self.m_itemFace_3.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace_3.setZValue(self.m_face3Z)
self.m_itemFace_3.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemFace_3.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemFace_3)
self.m_itemHand_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_1.svg")
self.m_itemHand_1.setCacheMode(QGraphicsItem.NoCache)
self.m_itemHand_1.setZValue(self.m_hand1Z)
self.m_itemHand_1.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemHand_1.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemHand_1)
self.m_itemHand_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_2.svg")
self.m_itemHand_2.setCacheMode(QGraphicsItem.NoCache)
self.m_itemHand_2.setZValue(self.m_hand2Z)
self.m_itemHand_2.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemHand_2.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemHand_2)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode(QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemCase.setTransformOriginPoint(self.m_originalAltCtr)
self.m_scene.addItem(self.m_itemCase)
self.centerOn(self.width() / 2, self.height() / 2)
self.updateView()
def init(self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.reset()
self.m_itemBack = QGraphicsSvgItem(":/qfi/images/tc/tc_back.svg")
self.m_itemBack.setCacheMode(QGraphicsItem.NoCache)
self.m_itemBack.setZValue(self.m_backZ)
self.m_itemBack.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_scene.addItem(self.m_itemBack)
self.m_itemBall = QGraphicsSvgItem(":/qfi/images/tc/tc_ball.svg")
self.m_itemBall.setCacheMode(QGraphicsItem.NoCache)
self.m_itemBall.setZValue(self.m_ballZ)
self.m_itemBall.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemBall.setTransformOriginPoint(self.m_originalBallCtr)
self.m_scene.addItem(self.m_itemBall)
self.m_itemFace_1 = QGraphicsSvgItem(":/qfi/images/tc/tc_face_1.svg")
self.m_itemFace_1.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace_1.setZValue(self.m_face1Z)
self.m_itemFace_1.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_scene.addItem(self.m_itemFace_1)
self.m_itemFace_2 = QGraphicsSvgItem(":/qfi/images/tc/tc_face_2.svg")
self.m_itemFace_2.setCacheMode(QGraphicsItem.NoCache)
self.m_itemFace_2.setZValue(self.m_face2Z)
self.m_itemFace_2.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_scene.addItem(self.m_itemFace_2)
self.m_itemMark = QGraphicsSvgItem(":/qfi/images/tc/tc_mark.svg")
self.m_itemMark.setCacheMode(QGraphicsItem.NoCache)
self.m_itemMark.setZValue(self.m_markZ)
self.m_itemMark.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_itemMark.setTransformOriginPoint(self.m_originalMarkCtr)
self.m_scene.addItem(self.m_itemMark)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/tc/tc_case.svg")
self.m_itemCase.setCacheMode(QGraphicsItem.NoCache)
self.m_itemCase.setZValue(self.m_caseZ)
self.m_itemCase.setTransform(
QTransform.fromScale(self.m_scaleX, self.m_scaleY), True)
self.m_scene.addItem(self.m_itemCase)
self.centerOn(self.width() / 2, self.height() / 2)
self.updateView()
def paintSelectionShape(painter, item):
path = item.shape()
# Local transform doesn't include translation in scene
P = painter.transform()
s = extractTransformScale(P)
s = (s[0], s[1])
T = item.transform()
T *= matrix3DToTransform(combine3DMatrices(item.transformations()))
T *= QTransform.fromScale(*s)
path = T.map(path)
painter.save()
painter.resetTransform()
dx, dy = extractTransformTranslate(P)
painter.translate(dx, dy)
col = simpleMaxContrastingColor(item.scene().backgroundBrush().color())
col1 = simpleMaxContrastingColor(col)
painter.strokePath(path, QPen(col1, 1.0))
painter.strokePath(path, QPen(col, 1.0, Qt.DashLine))
painter.restore()
def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemFace_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_1.svg")
self.m_itemFace_1.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_1.setZValue( self.m_face1Z )
self.m_itemFace_1.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_1.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_1)
self.m_itemFace_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_2.svg")
self.m_itemFace_2.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_2.setZValue( self.m_face2Z )
self.m_itemFace_2.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_2.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_2)
self.m_itemFace_3 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_3.svg")
self.m_itemFace_3.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_3.setZValue( self.m_face3Z )
self.m_itemFace_3.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_3.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_3)
self.m_itemHand_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_1.svg")
self.m_itemHand_1.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand_1.setZValue( self.m_hand1Z )
self.m_itemHand_1.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand_1.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemHand_1)
self.m_itemHand_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_2.svg")
self.m_itemHand_2.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand_2.setZValue( self.m_hand2Z )
self.m_itemHand_2.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand_2.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemHand_2)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def __init__(self, **kwargs):
QGraphicsView.__init__(self, **kwargs)
self.setRenderHints(QPainter.Antialiasing)
self.setBackgroundBrush(QBrush(QColor(Qt.cyan).lighter(150)))
#self.setBackgroundBrush( QBrush( QColor(Qt.darkGray).darker(200) ) )
# invert y axis because scene coordinates system is direct,
# with y up oriented
self.setTransform(QTransform.fromScale(1.0, -1.0))
# viewport control (part of the scene displayed)
self.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
# seems that the translate stuff is a bit buggy in Qt
# https://bugreports.qt-project.org/browse/QTBUG-7328
# this does not help
#self.setAlignment(Qt.Alignment(0))
# AnchorUnderMouse works by moving the wiewport around with scrollbars
# so movable scrollbars are needed,
# and the scenerect should be large enough
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
def __init__(self, r: float, x: float, y: float, color, line_width: float, text=""):
self._visible = 1
self._radius = r
self._pos = QPointF(x, y)
super().__init__()
# The supporting rectangle
self.rect = QRectF(x - r, y - r, 2 * r, 2 * r)
# The underlying QGraphicsEllipseItem
self.disc = QGraphicsEllipseItem()
self.disc.setRect(self.rect)
self.disc.setBrush(QtGui.QBrush(color))
# The underlying QGraphicsTextItem
self._text: QGraphicsTextItem = QGraphicsTextItem(text)
transform = QTransform.fromScale(0.3, -0.3)
self._text.setTransformOriginPoint(self._pos)
self._text.setTransform(transform)
self._text.setPos(QPointF(x - 1.8, y + 1.8))
font = QFont("Times", 2)
self._text.setFont(font)
pen = QPen()
pen.setWidthF(line_width)
self.disc.setPen(pen)
self._visible = 1
def update_scale(self, sx, sy, px, py):
self._tmove = QTransform.fromScale(sx, sy)
def renderMapToImage(self):
if (not self.mMapDocument):
self.mMapImage = QImage()
return
renderer = self.mMapDocument.renderer()
r = self.contentsRect()
mapSize = renderer.mapSize()
if (mapSize.isEmpty()):
self.mMapImage = QImage()
return
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
# Determine the largest possible scale
scale = min( r.width() / mapSize.width(), r.height() / mapSize.height())
# Allocate a new image when the size changed
imageSize = mapSize * scale
if (self.mMapImage.size() != imageSize):
self.mMapImage = QImage(imageSize, QImage.Format_ARGB32_Premultiplied)
self.updateImageRect()
if (imageSize.isEmpty()):
return
drawObjects = bool(self.mRenderFlags & MiniMapRenderFlag.DrawObjects)
drawTiles = bool(self.mRenderFlags & MiniMapRenderFlag.DrawTiles)
drawImages = bool(self.mRenderFlags & MiniMapRenderFlag.DrawImages)
drawTileGrid = bool(self.mRenderFlags & MiniMapRenderFlag.DrawGrid)
visibleLayersOnly = bool(self.mRenderFlags & MiniMapRenderFlag.IgnoreInvisibleLayer)
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
self.mMapImage.fill(Qt.transparent)
painter = QPainter(self.mMapImage)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(QTransform.fromScale(scale, scale))
painter.translate(margins.left(), margins.top())
renderer.setPainterScale(scale)
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if (tp==TileLayer and drawTiles):
renderer.drawTileLayer(painter, tileLayer)
elif (tp==ObjectGroup and drawObjects):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif (tp==ImageLayer and drawImages):
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter, QRectF(QPointF(), renderer.mapSize()),
prefs.gridColor())
painter.end()
renderer.setFlags(renderFlags)
def _setSize(self, width: float, height: float):
self.__tf_scale = QTransform.fromScale(width / self.default_width,
height / self.default_height)
self.__tf()
def set_zoom(zoom):
if view._zoom != zoom:
view._zoom = zoom
view.setTransform(QTransform.fromScale(*(view._zoom / 100, ) * 2))
zoomout.setEnabled(zoom >= 20)
zoomin.setEnabled(zoom <= 300)
def update_taspect(self, ratio):
self._taspect = QTransform.fromScale(1, ratio)
if __name__ == "__main__":
import sys
import math
app = QApplication(sys.argv)
qsrand(QTime(0, 0, 0).secsTo(QTime.currentTime()))
scene = QGraphicsScene(-200, -200, 400, 400)
for i in range(10):
item = ColorItem()
angle = i * 6.28 / 10.0
item.setPos(math.sin(angle) * 150, math.cos(angle) * 150)
scene.addItem(item)
robot = Robot()
robot.setTransform(QTransform.fromScale(1.2, 1.2), True)
robot.setPos(0, -20)
scene.addItem(robot)
view = GraphicsView(scene)
view.setRenderHint(QPainter.Antialiasing)
view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
view.setBackgroundBrush(QColor(230, 200, 167))
view.setWindowTitle("Drag and Drop Robot")
view.show()
sys.exit(app.exec_())
def wheelEvent(self, event):
if event.angleDelta().y() > 0:
self.scale *= zoom_factor
else:
self.scale /= zoom_factor
self.setTransform(QTransform.fromScale(self.scale, self.scale))
def __init__(self, parent):
QGraphicsView.__init__(self, parent)
self.scale = .25
self.setTransform(QTransform.fromScale(self.scale, self.scale))
def adjustScale(self, scale):
self.setTransform(QTransform.fromScale(scale, scale))
self.setRenderHint(QPainter.SmoothPixmapTransform, self.mZoomable.smoothTransform())
def render(self, mapFileName, imageFileName):
map = None
renderer = None
reader = MapReader()
map = reader.readMap(mapFileName)
if (not map):
qWarning("Error while reading " + mapFileName + ":\n" +
reader.errorString())
return 1
x = map.orientation()
if x == Map.Orientation.Isometric:
renderer = IsometricRenderer(map)
elif x == Map.Orientation.Staggered:
renderer = StaggeredRenderer(map)
elif x == Map.Orientation.Hexagonal:
renderer = HexagonalRenderer(map)
else:
renderer = OrthogonalRenderer(map)
if (self.mTileSize > 0):
xScale = self.mTileSize / map.tileWidth()
yScale = self.mTileSize / map.tileHeight()
else:
xScale = yScale = self.mScale
mapSize = renderer.mapSize()
margins = map.computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
mapSize.setWidth(mapSize.width() * xScale)
mapSize.setHeight(mapSize.height() * yScale)
image = QImage(mapSize, QImage.Format_ARGB32)
image.fill(Qt.transparent)
painter = QPainter(image)
if (xScale != 1.0 or yScale != 1.0):
if (self.mUseAntiAliasing):
painter.setRenderHints(QPainter.SmoothPixmapTransform
| QPainter.Antialiasing)
painter.setTransform(QTransform.fromScale(xScale, yScale))
painter.translate(margins.left(), margins.top())
# Perform a similar rendering than found in exportasimagedialog.py
for layer in map.layers():
if (not self.shouldDrawLayer(layer)):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
imageLayer = layer
tp = type(layer)
if tp == TileLayer:
renderer.drawTileLayer(painter, tileLayer)
elif tp == ImageLayer:
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
painter.end()
# Save image
imageWriter = QImageWriter(imageFileName)
if (not imageWriter.write(image)):
qWarning("Error while writing " + imageFileName + ": " +
imageWriter.errorString())
return 1
return 0
def render(self, mapFileName, imageFileName):
map = None
renderer = None
reader = MapReader()
map = reader.readMap(mapFileName)
if (not map):
qWarning("Error while reading " + mapFileName + ":\n" + reader.errorString())
return 1
x = map.orientation()
if x==Map.Orientation.Isometric:
renderer = IsometricRenderer(map)
elif x==Map.Orientation.Staggered:
renderer = StaggeredRenderer(map)
elif x==Map.Orientation.Hexagonal:
renderer = HexagonalRenderer(map)
else:
renderer = OrthogonalRenderer(map)
if (self.mTileSize > 0):
xScale = self.mTileSize / map.tileWidth()
yScale = self.mTileSize / map.tileHeight()
else:
xScale = yScale = self.mScale
mapSize = renderer.mapSize()
margins = map.computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
mapSize.setWidth(mapSize.width()*xScale)
mapSize.setHeight(mapSize.height()*yScale)
image = QImage(mapSize, QImage.Format_ARGB32)
image.fill(Qt.transparent)
painter = QPainter(image)
if (xScale != 1.0 or yScale != 1.0):
if (self.mUseAntiAliasing):
painter.setRenderHints(QPainter.SmoothPixmapTransform |
QPainter.Antialiasing)
painter.setTransform(QTransform.fromScale(xScale, yScale))
painter.translate(margins.left(), margins.top())
# Perform a similar rendering than found in exportasimagedialog.py
for layer in map.layers():
if (not self.shouldDrawLayer(layer)):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
imageLayer = layer
tp = type(layer)
if tp == TileLayer:
renderer.drawTileLayer(painter, tileLayer)
elif tp == ImageLayer:
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
painter.end()
# Save image
imageWriter = QImageWriter(imageFileName)
if (not imageWriter.write(image)):
qWarning("Error while writing " + imageFileName + ": " + imageWriter.errorString())
return 1
return 0
