def boundingRect(self):
return QRectF(self.__x, self.__y, self.__tileSize, self.__tileSize)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self._background_color = QColor(204, 204, 204, 255)
self.setClearBeforeRendering(False)
self.beforeRendering.connect(self._render, type=Qt.DirectConnection)
self._mouse_device = QtMouseDevice(self)
self._mouse_device.setPluginId("qt_mouse")
self._key_device = QtKeyDevice()
self._key_device.setPluginId("qt_key")
self._previous_focus = None # type: Optional["QQuickItem"]
self._app = QCoreApplication.instance()
# Remove previously added input devices (if any). This can happen if the window was re-loaded.
self._app.getController().removeInputDevice("qt_mouse")
self._app.getController().removeInputDevice("qt_key")
self._app.getController().addInputDevice(self._mouse_device)
self._app.getController().addInputDevice(self._key_device)
self._app.getController().getScene().sceneChanged.connect(
self._onSceneChanged)
self._preferences = Preferences.getInstance()
self._preferences.addPreference("general/window_width", 1280)
self._preferences.addPreference("general/window_height", 720)
self._preferences.addPreference("general/window_left", 50)
self._preferences.addPreference("general/window_top", 50)
self._preferences.addPreference("general/window_state",
Qt.WindowNoState)
# Restore window geometry
self.setWidth(int(self._preferences.getValue("general/window_width")))
self.setHeight(int(
self._preferences.getValue("general/window_height")))
self.setPosition(
int(self._preferences.getValue("general/window_left")),
int(self._preferences.getValue("general/window_top")))
# Make sure restored geometry is not outside the currently available screens
screen_found = False
for s in range(0, self._app.desktop().screenCount()):
if self.geometry().intersects(
self._app.desktop().availableGeometry(s)):
screen_found = True
break
if not screen_found:
self.setPosition(50, 50)
self.setWindowState(
int(self._preferences.getValue("general/window_state")))
self._mouse_x = 0
self._mouse_y = 0
self._mouse_pressed = False
self._viewport_rect = QRectF(0, 0, 1.0, 1.0)
Application.getInstance().setMainWindow(self)
self._fullscreen = False
self._allow_resize = True
def paint(self, painter, option, widget):
if canvas.scene.loading_items:
return
painter.save()
painter.setRenderHint(QPainter.Antialiasing,
bool(options.antialiasing == ANTIALIASING_FULL))
selected = self.isSelected()
theme = canvas.theme
if self.m_port_type == PORT_TYPE_AUDIO_JACK:
if self.m_is_alternate:
poly_color = theme.port_cv_jack_bg_sel if selected else theme.port_cv_jack_bg
poly_pen = theme.port_cv_jack_pen_sel if selected else theme.port_cv_jack_pen
else:
poly_color = theme.port_audio_jack_bg_sel if selected else theme.port_audio_jack_bg
poly_pen = theme.port_audio_jack_pen_sel if selected else theme.port_audio_jack_pen
text_pen = theme.port_audio_jack_text_sel if selected else theme.port_audio_jack_text
conn_pen = QPen(theme.port_audio_jack_pen_sel)
elif self.m_port_type == PORT_TYPE_MIDI_JACK:
poly_color = theme.port_midi_jack_bg_sel if selected else theme.port_midi_jack_bg
poly_pen = theme.port_midi_jack_pen_sel if selected else theme.port_midi_jack_pen
text_pen = theme.port_midi_jack_text_sel if selected else theme.port_midi_jack_text
conn_pen = QPen(theme.port_midi_jack_pen_sel)
elif self.m_port_type == PORT_TYPE_MIDI_ALSA:
poly_color = theme.port_midi_alsa_bg_sel if selected else theme.port_midi_alsa_bg
poly_pen = theme.port_midi_alsa_pen_sel if selected else theme.port_midi_alsa_pen
text_pen = theme.port_midi_alsa_text_sel if selected else theme.port_midi_alsa_text
conn_pen = QPen(theme.port_midi_alsa_pen_sel)
elif self.m_port_type == PORT_TYPE_PARAMETER:
poly_color = theme.port_parameter_bg_sel if selected else theme.port_parameter_bg
poly_pen = theme.port_parameter_pen_sel if selected else theme.port_parameter_pen
text_pen = theme.port_parameter_text_sel if selected else theme.port_parameter_text
conn_pen = QPen(theme.port_parameter_pen_sel)
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid port type '%s'" %
port_type2str(self.m_port_type))
return
# To prevent quality worsening
poly_pen = QPen(poly_pen)
poly_pen.setWidthF(poly_pen.widthF() + 0.00001)
lineHinting = poly_pen.widthF() / 2
poly_locx = [0, 0, 0, 0, 0, 0]
poly_corner_xhinting = ((float(canvas.theme.port_height) / 2) %
floor(float(canvas.theme.port_height) / 2))
if poly_corner_xhinting == 0:
poly_corner_xhinting = 0.5 * (
1 - 7 / (float(canvas.theme.port_height) / 2))
is_cv_port = bool(self.m_port_type == PORT_TYPE_AUDIO_JACK
and self.m_is_alternate)
if self.m_port_mode == PORT_MODE_INPUT:
text_pos = QPointF(3, canvas.theme.port_text_ypos)
if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port:
poly_locx[0] = lineHinting
poly_locx[1] = self.m_port_width + 5 - lineHinting
poly_locx[2] = self.m_port_width + 12 - poly_corner_xhinting
poly_locx[3] = self.m_port_width + 5 - lineHinting
poly_locx[4] = lineHinting
poly_locx[5] = self.m_port_width
elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port:
poly_locx[0] = lineHinting
poly_locx[1] = self.m_port_width + 5 - lineHinting
poly_locx[2] = self.m_port_width + 5 - lineHinting
poly_locx[3] = self.m_port_width + 5 - lineHinting
poly_locx[4] = lineHinting
poly_locx[5] = self.m_port_width
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'"
% canvas.theme.port_mode)
return
elif self.m_port_mode == PORT_MODE_OUTPUT:
text_pos = QPointF(9, canvas.theme.port_text_ypos)
if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port:
poly_locx[0] = self.m_port_width + 12 - lineHinting
poly_locx[1] = 7 + lineHinting
poly_locx[2] = 0 + poly_corner_xhinting
poly_locx[3] = 7 + lineHinting
poly_locx[4] = self.m_port_width + 12 - lineHinting
poly_locx[5] = 12 - lineHinting
elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port:
poly_locx[0] = self.m_port_width + 12 - lineHinting
poly_locx[1] = 5 + lineHinting
poly_locx[2] = 5 + lineHinting
poly_locx[3] = 5 + lineHinting
poly_locx[4] = self.m_port_width + 12 - lineHinting
poly_locx[5] = 12 - lineHinting
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'"
% canvas.theme.port_mode)
return
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid port mode '%s'" %
port_mode2str(self.m_port_mode))
return
polygon = QPolygonF()
if self.m_portgrp_id:
first_of_portgrp = False
last_of_portgrp = False
# look in portgroup if port is the first,
# the last, or not.
for portgrp in canvas.portgrp_list:
if portgrp.portgrp_id == self.m_portgrp_id:
if self.m_port_id == portgrp.port_id_list[0]:
first_of_portgrp = True
if self.m_port_id == portgrp.port_id_list[-1]:
last_of_portgrp = True
break
if first_of_portgrp:
polygon += QPointF(poly_locx[0], lineHinting)
polygon += QPointF(poly_locx[5], lineHinting)
else:
polygon += QPointF(poly_locx[0], 0)
polygon += QPointF(poly_locx[5], 0)
if last_of_portgrp:
polygon += QPointF(poly_locx[5],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[0],
canvas.theme.port_height - lineHinting)
else:
polygon += QPointF(poly_locx[5], canvas.theme.port_height)
polygon += QPointF(poly_locx[0], canvas.theme.port_height)
else:
polygon += QPointF(poly_locx[0], lineHinting)
polygon += QPointF(poly_locx[1], lineHinting)
polygon += QPointF(poly_locx[2],
float(canvas.theme.port_height) / 2)
polygon += QPointF(poly_locx[3],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[4],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[0], lineHinting)
if canvas.theme.port_bg_pixmap:
portRect = polygon.boundingRect().adjusted(-lineHinting + 1,
-lineHinting + 1,
lineHinting - 1,
lineHinting - 1)
portPos = portRect.topLeft()
painter.drawTiledPixmap(portRect, canvas.theme.port_bg_pixmap,
portPos)
else:
port_gradient = QLinearGradient(0, 0, 0, self.m_port_height)
dark_color = poly_color.darker(112)
light_color = poly_color.lighter(111)
if poly_color.lightness() > 127:
port_gradient.setColorAt(0, dark_color)
port_gradient.setColorAt(0.5, light_color)
port_gradient.setColorAt(1, dark_color)
else:
port_gradient.setColorAt(0, light_color)
port_gradient.setColorAt(0.5, dark_color)
port_gradient.setColorAt(1, light_color)
painter.setBrush(port_gradient)
painter.setPen(poly_pen)
painter.drawPolygon(polygon)
if self.m_is_alternate and not self.m_portgrp_id:
if is_cv_port:
poly_pen.setWidthF(2.000001)
painter.setPen(poly_pen)
y_line = canvas.theme.port_height / 2.0
if self.m_port_mode == PORT_MODE_OUTPUT:
painter.drawLine(QPointF(0.0, y_line),
QPointF(float(poly_locx[1]), y_line))
elif self.m_port_mode == PORT_MODE_INPUT:
painter.drawLine(QPointF(self.m_port_width + 5.0, y_line),
QPointF(self.m_port_width + 12.0, y_line))
else:
# draw the little circle for a2j (or MidiBridge) port
poly_pen.setWidthF(1.000001)
painter.setBrush(canvas.theme.box_bg_1)
ellipse_x = poly_locx[1]
if self.m_port_mode == PORT_MODE_OUTPUT:
ellipse_x -= 2
elif self.m_port_mode == PORT_MODE_INPUT:
ellipse_x += 2
painter.drawEllipse(
QPointF(ellipse_x, canvas.theme.port_height / 2.0), 2, 2)
painter.setPen(text_pen)
painter.setFont(self.m_port_font)
sizer = QFontMetrics(self.m_port_font)
sep_width = sizer.width(self.m_trunck_sep)
if self.m_portgrp_id:
print_name_size = self.get_text_width()
if self.m_port_mode == PORT_MODE_OUTPUT:
text_pos = QPointF(self.m_port_width + 9 - print_name_size,
canvas.theme.port_text_ypos)
if print_name_size > (self.m_port_width - 4):
painter.setPen(QPen(port_gradient, 3))
painter.drawLine(
QPointF(float(poly_locx[5]), 3.0),
QPointF(float(poly_locx[5]),
canvas.theme.port_height - 3.0))
painter.setPen(text_pen)
painter.setFont(self.m_port_font)
painter.drawText(text_pos, self.m_print_name)
if self.m_name_truncked:
sep_x = text_pos.x() + sizer.width(self.m_print_name)
painter.drawText(QPointF(sep_x + sep_width, text_pos.y()),
self.m_print_name_right)
painter.setPen(poly_pen)
painter.drawText(QPointF(sep_x,
text_pos.y() + 1), self.m_trunck_sep)
if canvas.theme.idx == Theme.THEME_OOSTUDIO and canvas.theme.port_bg_pixmap:
painter.setPen(Qt.NoPen)
painter.setBrush(conn_pen.brush())
if self.m_port_mode == PORT_MODE_INPUT:
connRect = QRectF(portRect.topLeft(),
QSizeF(2, portRect.height()))
else:
connRect = QRectF(
QPointF(portRect.right() - 2, portRect.top()),
QSizeF(2, portRect.height()))
painter.drawRect(connRect)
painter.restore()
def scale_changed(self):
self.display_area.setRange(
QRectF(0, 0, self.current_image.shape[1], self.current_image.shape[0]),
update=True,
disableAutoRange=True,
)
def boundingRect(self):
return QRectF(self.x, self.y, self.size.width(), self.size.height())
def paint(self, painter, option, index):
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
rect = option.rect
text_rect_height = 30
img_text_height = self.view.img_text_height
source_rect_height = img_text_height - text_rect_height
text_y = rect.y() + rect.height() - img_text_height
cover_height = rect.height() - img_text_height
cover_width = rect.width()
text_rect = QRectF(rect.x(), text_y, rect.width(), text_rect_height)
source_rect = QRectF(rect.x(), text_y + text_rect_height - 5,
rect.width(), source_rect_height + 5)
obj = index.data(Qt.DecorationRole)
if obj is None:
painter.restore()
return
text_color = option.palette.color(QPalette.Text)
if text_color.lightness() > 150:
non_text_color = text_color.darker(140)
else:
non_text_color = text_color.lighter(150)
non_text_color.setAlpha(100)
painter.save()
pen = painter.pen()
pen.setColor(non_text_color)
painter.setPen(pen)
painter.translate(rect.x(), rect.y())
if isinstance(obj, QColor):
color = obj
brush = QBrush(color)
painter.setBrush(brush)
else:
if obj.height() < obj.width():
pixmap = obj.scaledToHeight(cover_height,
Qt.SmoothTransformation)
else:
pixmap = obj.scaledToWidth(cover_width,
Qt.SmoothTransformation)
brush = QBrush(pixmap)
painter.setBrush(brush)
border_radius = 3
if self.as_circle:
border_radius = cover_width // 2
cover_rect = QRect(0, 0, cover_width, cover_height)
painter.drawRoundedRect(cover_rect, border_radius, border_radius)
painter.restore()
option = QTextOption()
source_option = QTextOption()
if self.as_circle:
option.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
source_option.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
else:
option.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
source_option.setAlignment(Qt.AlignLeft | Qt.AlignTop)
name = index.data(Qt.DisplayRole)
fm = QFontMetrics(painter.font())
elided_name = fm.elidedText(name, Qt.ElideRight,
int(text_rect.width()))
source = index.data(Qt.WhatsThisRole)
painter.drawText(text_rect, elided_name, option)
painter.restore()
painter.save()
pen = painter.pen()
font = painter.font()
resize_font(font, -2)
painter.setFont(font)
pen.setColor(non_text_color)
painter.setPen(non_text_color)
painter.drawText(source_rect, source, source_option)
painter.restore()
def boundingRect(self):
return QRectF(0, 0, self.width, self.height)
def boundingRect(self):
return QRectF(-30, 0, self.fret_distance[-1], self.string_dist * 6)
def draw_rect(self, rect, pen, brush):
painter = self.current_painter
painter.setPen(pen)
painter.setBrush(brush)
painter.drawRect(QRectF(*self.flipRect(rect)))
from .abstractpathtool import AbstractPathTool
from cadnano.gui.views.pathview import pathstyles as styles
import cadnano.util as util
from PyQt5.QtCore import Qt, QRectF, QPointF
from PyQt5.QtGui import QBrush, QFont, QPen, QPainterPath, QPolygonF
from PyQt5.QtWidgets import QGraphicsItem
_BW = styles.PATH_BASE_WIDTH
_PEN = QPen(styles.RED_STROKE, 1)
_RECT = QRectF(0, 0, _BW, _BW)
_PATH_ARROW_LEFT = QPainterPath()
_L3_POLY = QPolygonF()
_L3_POLY.append(QPointF(_BW, 0))
_L3_POLY.append(QPointF(0.25 * _BW, 0.5 * _BW))
_L3_POLY.append(QPointF(_BW, _BW))
_PATH_ARROW_LEFT.addPolygon(_L3_POLY)
_PATH_ARROW_RIGHT = QPainterPath()
_R3_POLY = QPolygonF() # right-hand 3' arr
_R3_POLY.append(QPointF(0, 0))
_R3_POLY.append(QPointF(0.75 * _BW, 0.5 * _BW))
_R3_POLY.append(QPointF(0, _BW))
_PATH_ARROW_RIGHT.addPolygon(_R3_POLY)
class BreakTool(AbstractPathTool):
"""
docstring for BreakTool
"""
def __init__(self, controller):
super(BreakTool, self).__init__(controller)
from cadnano.gui.views.pathview import pathstyles as styles
from cadnano.enum import StrandType
import cadnano.util as util
from PyQt5.QtCore import QRectF, Qt, QPointF
from PyQt5.QtGui import QBrush, QPen, QFont
from PyQt5.QtWidgets import QGraphicsItem, QGraphicsItemGroup, QGraphicsObject
_BW = styles.PATH_BASE_WIDTH
_TOOL_RECT = QRectF(0, 0, _BW, _BW) # protected not private
_RECT = QRectF(-styles.PATH_BASE_HL_STROKE_WIDTH,\
-styles.PATH_BASE_HL_STROKE_WIDTH,\
_BW + 2*styles.PATH_BASE_HL_STROKE_WIDTH,\
_BW + 2*styles.PATH_BASE_HL_STROKE_WIDTH)
_PEN = QPen(styles.RED_STROKE, styles.PATH_BASE_HL_STROKE_WIDTH)
_BRUSH = QBrush(Qt.NoBrush)
# There's a bug where C++ will free orphaned graphics items out from
# under pyqt. To avoid this, "_mother" adopts orphaned graphics items.
# _mother = QGraphicsItemGroup()
class AbstractPathTool(QGraphicsObject):
"""Abstract base class to be subclassed by all other pathview tools."""
def __init__(self, controller, parent=None):
super(AbstractPathTool, self).__init__(parent)
self._controller = controller
self._window = controller.window
self._active = False
def show(self, title, points, pos):
self.setGeometry(QRectF(pos, self.size()))
self.tipWidget.updateUi(title, points)
super(GraphicsProxyWidget, self).show()
def boundingRect(self):
# adjust = 2.0
adjust = 0.0
ball_size = 50
return QRectF(-ball_size - adjust, -ball_size - adjust,
2 * ball_size + adjust, 2 * ball_size + adjust)
def keyPressEvent(self, event: QKeyEvent) -> None:
event.setAccepted(False)
unknown = False
if event == QKeySequence.SelectAll:
self.selectAll()
event.accept()
elif event == QKeySequence.SelectPreviousChar:
self.move_cursor(
self.text_layout.previousCursorPosition(self.cursor_ind), True)
event.accept()
elif event == QKeySequence.SelectNextChar:
self.move_cursor(
self.text_layout.nextCursorPosition(self.cursor_ind), True)
event.accept()
else:
if event.key() == Qt.Key_Left:
if self.cursor_ind == 0:
self.edit_previous_tag()
else:
self.move_cursor(
self.text_layout.previousCursorPosition(
self.cursor_ind), False)
event.accept()
elif event.key() == Qt.Key_Right:
if self.cursor_ind == len(self.tags[self.editing_index].text):
self.edit_next_tag()
else:
self.move_cursor(
self.text_layout.nextCursorPosition(self.cursor_ind),
False)
event.accept()
elif event.key() == Qt.Key_Home:
if self.cursor_ind == 0 and self.editing_index > 0:
self.edit_tag(0)
else:
self.move_cursor(0, False)
event.accept()
elif event.key() == Qt.Key_End:
if (self.cursor_ind == len(self.tags[self.editing_index].text)
and self.editing_index < len(self.tags) - 1):
self.edit_tag(len(self.tags) - 1)
else:
self.move_cursor(len(self.tags[self.editing_index].text),
False)
event.accept()
elif event.key() == Qt.Key_Backspace:
if self.tags[self.editing_index].text:
self.remove_backwards_character()
elif self.editing_index > 0:
self.edit_previous_tag()
event.accept()
elif event.key() == Qt.Key_Space:
if self.tags[self.editing_index].text:
self.tags.insert(self.editing_index + 1, Tag("", QRectF()))
self.edit_next_tag()
event.accept()
elif event.key() == Qt.Key_Escape:
self.escape_pressed.emit()
event.accept()
elif event.key() == Qt.Key_Return:
self.enter_pressed.emit()
event.accept()
else:
unknown = True
if unknown:
if self.has_selection_active():
self.remove_selection()
txt = self.tags[self.editing_index].text
txt = txt[:self.cursor_ind] + event.text().lower(
) + txt[self.cursor_ind:]
self.tags[self.editing_index].text = txt
self.cursor_ind += len(event.text())
event.accept()
if event.isAccepted():
self.update_display_text()
self.compute_tag_rects()
self.update_cursor_blinking()
self.update()
from cadnano.fileio.lattice import HoneycombDnaPart, SquareDnaPart from cadnano.gui.palette import getBrushObj, getColorObj, getNoPen, getPenObj from cadnano.proxies.cnenum import GridType from . import slicestyles as styles PXI_PP_ITEM_WIDTH = IW = 2.0 # 1.5 TRIANGLE = QPolygonF() TRIANGLE.append(QPointF(0, 0)) TRIANGLE.append(QPointF(0.75 * IW, 0.5 * IW)) TRIANGLE.append(QPointF(0, IW)) TRIANGLE.append(QPointF(0, 0)) # TRIANGLE.translate(-0.75*IW, -0.5*IW) TRIANGLE.translate(-0.25 * IW, -0.5 * IW) PXI_RECT = QRectF(0, 0, IW, IW) T90, T270 = QTransform(), QTransform() T90.rotate(90) T270.rotate(270) FWDPXI_PP, REVPXI_PP = QPainterPath(), QPainterPath() FWDPXI_PP.addPolygon(T90.map(TRIANGLE)) REVPXI_PP.addPolygon(T270.map(TRIANGLE)) # FWDPXI_PP.moveTo(-0.5*IW, 0.7*IW) # FWDPXI_PP.lineTo(0., -0.2*IW) # FWDPXI_PP.lineTo(0.5*IW, 0.7*IW) # extra1 = QPainterPath() # extra1.addEllipse(-0.5*IW, 0.5*IW, IW, 0.4*IW) # extra2 = QPainterPath() # extra2.addEllipse(-0.35*IW, 0.5*IW, 0.7*IW, 0.3*IW) # FWDPXI_PP += extra1
def drawInner(self, painter):
inner_rect = QRectF(0, 0, self._inner_width, self._inner_height)
painter.drawText(inner_rect, '☯', QTextOption(Qt.AlignCenter))
PP_53.addRect(0, 0.125 * _BASE_WIDTH, 0.5 * _BASE_WIDTH, 0.75 * _BASE_WIDTH)
POLY_53 = QPolygonF()
POLY_53.append(QPointF(0.5 * _BASE_WIDTH, 0))
POLY_53.append(QPointF(_BASE_WIDTH, 0.5 * _BASE_WIDTH))
POLY_53.append(QPointF(0.5 * _BASE_WIDTH, _BASE_WIDTH))
PP_53.addPolygon(POLY_53)
# single base left 3'<-5'
PP_35.addRect(0.50 * _BASE_WIDTH, 0.125 * _BASE_WIDTH, 0.5 * _BASE_WIDTH,
0.75 * _BASE_WIDTH)
POLY_35 = QPolygonF()
POLY_35.append(QPointF(0.5 * _BASE_WIDTH, 0))
POLY_35.append(QPointF(0, 0.5 * _BASE_WIDTH))
POLY_35.append(QPointF(0.5 * _BASE_WIDTH, _BASE_WIDTH))
PP_35.addPolygon(POLY_35)
_DEFAULT_RECT = QRectF(0, 0, _BASE_WIDTH, _BASE_WIDTH)
_NO_PEN = QPen(Qt.NoPen)
MOD_RECT = QRectF(.25 * _BASE_WIDTH, -.25 * _BASE_WIDTH, 0.5 * _BASE_WIDTH,
0.5 * _BASE_WIDTH)
class EndpointItem(QGraphicsPathItem):
_filter_name = "endpoint"
def __init__(self, strand_item, cap_type, is_drawn5to3):
"""The parent should be a StrandItem."""
super(EndpointItem, self).__init__(strand_item.virtualHelixItem())
self._strand_item = strand_item
def mousePressEvent(self, event):
self.pressPos = event.scenePos()
self.Rec = QRectF(self.pressPos, self.pressPos)
self.RecItem = QGraphicsRectItem(self.Rec)
self.RecItem.setVisible(True)
self.addItem(self.RecItem)
def exportGeorefRaster(self, layer, rasterPath, isPutRotationInWorldFile):
rasterFormat = rasterPath[-3:]
try:
originalWidth = layer.image.width()
originalHeight = layer.image.height()
radRotation = layer.rotation * math.pi / 180
if isPutRotationInWorldFile:
# keep the image as is and put all transformation params
# in world file
img = layer.image
a = layer.xScale * math.cos(radRotation)
# sin instead of -sin because angle in CW
b = -layer.yScale * math.sin(radRotation)
d = layer.xScale * -math.sin(radRotation)
e = -layer.yScale * math.cos(radRotation)
c = layer.center.x() - (a * (originalWidth - 1) / 2 + b *
(originalHeight - 1) / 2)
f = layer.center.y() - (d * (originalWidth - 1) / 2 + e *
(originalHeight - 1) / 2)
else:
# transform the image with rotation and scaling between the
# axes
# maintain at least the original resolution of the raster
ratio = layer.xScale / layer.yScale
if ratio > 1:
# increase x
scaleX = ratio
scaleY = 1
else:
# increase y
scaleX = 1
scaleY = 1. / ratio
width = (abs(scaleX * originalWidth * math.cos(radRotation)) +
abs(scaleY * originalHeight * math.sin(radRotation)))
height = (abs(scaleX * originalWidth * math.sin(radRotation)) +
abs(scaleY * originalHeight * math.cos(radRotation)))
qDebug("wh %f,%f" % (width, height))
img = QImage(QSize(math.ceil(width), math.ceil(height)),
QImage.Format_ARGB32)
# transparent background
img.fill(QColor(0, 0, 0, 0))
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing, True)
rect = QRectF(
QPointF(-layer.image.width() / 2.0,
-layer.image.height() / 2.0),
QPointF(layer.image.width() / 2.0,
layer.image.height() / 2.0))
painter.translate(QPointF(width / 2.0, height / 2.0))
painter.rotate(layer.rotation)
painter.scale(scaleX, scaleY)
painter.drawImage(rect, layer.image)
painter.end()
extent = layer.extent()
a = extent.width() / width
e = -extent.height() / height
# 2nd term because (0,0) of world file is on center of upper
# left pixel instead of upper left corner of that pixel
c = extent.xMinimum() + a / 2
f = extent.yMaximum() + e / 2
b = d = 0.0
img.save(rasterPath, rasterFormat)
worldFilePath = rasterPath[:-3]
if rasterFormat == "jpg":
worldFilePath += "jgw"
elif rasterFormat == "png":
worldFilePath += "pgw"
elif rasterFormat == "bmp":
worldFilePath += "bpw"
elif rasterFormat == "tif":
worldFilePath += "tfw"
with open(worldFilePath, "w") as writer:
writer.write("%.13f\n%.13f\n%.13f\n%.13f\n%.13f\n%.13f" %
(a, b, d, e, c, f))
crsFilePath = rasterPath + ".aux.xml"
with open(crsFilePath, "w") as writer:
writer.write(
self.auxContent(
self.iface.mapCanvas().mapSettings().destinationCrs()))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer", "Raster exported successfully.")
self.iface.messageBar().pushWidget(widget, Qgis.Info, 2)
except Exception as ex:
QgsMessageLog.logMessage(repr(ex))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer",
"There was an error performing this command. "
"See QGIS Message log for details.")
self.iface.messageBar().pushWidget(widget, Qgis.Critical, 5)
def mouseMoveEvent(self, event):
self.movePos = event.scenePos()
self.removeItem(self.RecItem)
self.RecItem.setRect(QRectF(self.pressPos, self.movePos))
self.addItem(self.RecItem)
def boundingRect(self):
return QRectF(-65, -65, 130, 130)
def boundingRect(self) -> QRectF:
return QRectF(
self.first_photo_btn.boundingRect().topLeft(),
self.synchronize_btn.pos() +
self.synchronize_btn.boundingRect().bottomRight())
def __init__(self, *args, experiment=None, **kwargs):
"""
:param experiment: experiment to which this belongs
(:class:Experiment <stytra.Experiment> object)
"""
super().__init__(*args, **kwargs)
self.experiment = experiment
if experiment is not None:
self.camera = experiment.camera
experiment.gui_timer.timeout.connect(self.retrieve_image)
else:
self.gui_timer = QTimer()
self.gui_timer.setSingleShot(False)
self.control_params = self.experiment.camera_state
# Create the layout for the camera view:
self.camera_display_widget = pg.GraphicsLayoutWidget()
# Display area for showing the camera image:
self.display_area = pg.ViewBox(lockAspect=1, invertY=False)
self.display_area.setRange(
QRectF(0, 0, 640, 480), update=True, disableAutoRange=True
)
self.scale = 640
self.display_area.invertY(True)
# Image to which the frame will be set, initially black:
self.image_item = pg.ImageItem()
self.image_item.setImage(np.zeros((640, 480), dtype=np.uint8))
self.display_area.addItem(self.image_item)
self.camera_display_widget.addItem(self.display_area)
# Queue of frames coming from the camera
if hasattr(experiment, "frame_dispatcher"):
self.frame_queue = self.experiment.frame_dispatcher.gui_queue
else:
self.frame_queue = self.camera.frame_queue
# Queue of control parameters for the camera:
self.control_queue = self.camera.control_queue
self.camera_rotation = self.camera.rotation
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.camera_display_widget)
self.layout_control = QHBoxLayout()
self.layout_control.setContentsMargins(10, 0, 10, 10)
self.btn_pause = ControlToggleIcon(
self.experiment.camera_state,
"paused",
icon_on=get_icon("play"),
icon_off=get_icon("pause"),
action_off="Pause",
action_on="Play",
)
self.layout_control.addWidget(self.btn_pause)
if hasattr(self.experiment.camera_state, "replay"):
self.experiment.camera_state.replay = False
self.btn_rewind = ControlToggleIcon(
self.experiment.camera_state,
"replay",
icon_on=get_icon("rewind"),
action_off="Resume",
action_on="Replay",
)
self.btn_rewind.setToolTip("Replay the time period selected in the plot")
self.layout_control.addWidget(self.btn_rewind)
if self.control_queue is not None:
self.btn_camera_param = IconButton(
icon_name="edit_camera", action_name="Configure camera"
)
self.btn_camera_param.clicked.connect(self.show_params_gui)
self.layout_control.addWidget(self.btn_camera_param)
self.btn_capture = IconButton(
icon_name="camera_flash", action_name="Capture frame"
)
self.btn_capture.clicked.connect(self.save_image)
self.layout_control.addWidget(self.btn_capture)
self.btn_autorange = ToggleIconButton(
icon_off="autoscale", icon_on="autoscaleOFF", action_on="Autoscale"
)
self.layout_control.addWidget(self.btn_autorange)
self.layout.addLayout(self.layout_control)
self.current_image = None
self.setLayout(self.layout)
self.current_frame_time = None
self.param_widget = None
def __init__(self, parent=None):
super().__init__(parent)
self._generator = PiGenerator()
self.setSceneRect(QRectF(QPointF(-self.SCENE_WIDTH/2, -self.SCENE_HEIGHT/2),
QPointF(self.SCENE_WIDTH/2, self.SCENE_HEIGHT/2)))
# scale type
self.addItem(TextItem('Scale', TextItem.CENTER, self.SCALE_TYPE_LABEL_POS))
scaleTypeLeftButton = TriangleButton(TriangleButton.LEFT)
scaleTypeLeftButton.setPos(self.SCALE_TYPE_LEFT_BUTTON_POS)
scaleTypeLeftButton.clicked.connect(self._generator.setPreviousScaleType)
self.addItem(scaleTypeLeftButton)
scaleTypeRightButton = TriangleButton(TriangleButton.RIGHT)
scaleTypeRightButton.setPos(self.SCALE_TYPE_RIGHT_BUTTON_POS)
scaleTypeRightButton.clicked.connect(self._generator.setNextScaleType)
self.addItem(scaleTypeRightButton)
self._scaleTypeSelectedTextItem = TextItem(self._generator.scaleType, TextItem.CENTER, self.SCALE_TYPE_CENTER_POS)
self._scaleTypeLeftTextItem = TextItem(self._generator.previousScaleType, TextItem.LEFT, self.SCALE_TYPE_LEFT_POS)
self._scaleTypeRightTextItem = TextItem(self._generator.nextScaleType, TextItem.RIGHT, self.SCALE_TYPE_RIGHT_POS)
self.addItem(self._scaleTypeSelectedTextItem)
self.addItem(self._scaleTypeLeftTextItem)
self.addItem(self._scaleTypeRightTextItem)
# root note
rootNoteLeftButton = TriangleButton(TriangleButton.LEFT)
rootNoteLeftButton.setPos(self.ROOT_NOTE_LEFT_BUTTON_POS)
rootNoteLeftButton.clicked.connect(self._generator.setPreviousRootNote)
self.addItem(rootNoteLeftButton)
rootNoteRightButton = TriangleButton(TriangleButton.RIGHT)
rootNoteRightButton.setPos(self.ROOT_NOTE_RIGHT_BUTTON_POS)
rootNoteRightButton.clicked.connect(self._generator.setNextRootNote)
self.addItem(rootNoteRightButton)
self._rootNoteSelectedTextItem = TextItem(self._generator.rootNote, TextItem.CENTER, self.ROOT_NOTE_CENTER_POS)
self._rootNoteLeftTextItem = TextItem(self._generator.previousRootNote, TextItem.LEFT, self.ROOT_NOTE_LEFT_POS)
self._rootNoteRightTextItem = TextItem(self._generator.nextRootNote, TextItem.RIGHT, self.ROOT_NOTE_RIGHT_POS)
self.addItem(self._rootNoteSelectedTextItem)
self.addItem(self._rootNoteLeftTextItem)
self.addItem(self._rootNoteRightTextItem)
# scale
self._scaleItem = ScaleTextItem()
self._scaleItem.setScale(self._generator.scale)
self._scaleItem.setPos(self.SCALE_POS)
self.addItem(self._scaleItem)
# solo length
self._soloLengthLabelTextItem = TextItem('Solo length', TextItem.LEFT, self.SOLO_LENGTH_LABEL_POS)
self.addItem(self._soloLengthLabelTextItem)
self._soloLengthMaxLabelTextItem = TextItem('Max length: '+str(self._generator.maxSoloLength), TextItem.RIGHT, self.SOLO_LENGTH_MAX_POS)
self.addItem(self._soloLengthMaxLabelTextItem)
self._soloLengthTextItem = TextItem(str(self._generator.soloLength), TextItem.CENTER, self.SOLO_LENGTH_POS)
self.addItem(self._soloLengthTextItem)
soloLengthLeftButton = TriangleButton(TriangleButton.LEFT)
soloLengthLeftButton.setPos(self.SOLO_LENGTH_LEFT_BUTTON_POS)
soloLengthLeftButton.clicked.connect(self._generator.decreaseSoloLength)
self.addItem(soloLengthLeftButton)
soloLengthRightButton = TriangleButton(TriangleButton.RIGHT)
soloLengthRightButton.setPos(self.SOLO_LENTGH_RIGHT_BUTTON_POS)
soloLengthRightButton.clicked.connect(self._generator.increaseSoloLength)
self.addItem(soloLengthRightButton)
# generate button
generateButton = Button('Generate', self.GENERATE_BUTTON_WIDTH, self.GENERATE_BUTTON_HEIGHT)
generateButton.setPos(self.GENERATE_BUTTON_POS)
self.addItem(generateButton)
# about button
aboutButton = Button('?', self.ABOUT_BUTTON_WIDTH, self.ABOUT_BUTTON_HEIGHT)
aboutButton.setPos(self.ABOUT_BUTTON_POS)
self.addItem(aboutButton)
# solo
self._soloTextItem1 = TextItem('', TextItem.CENTER, self.SOLO_POS_1)
self.addItem(self._soloTextItem1)
self._soloTextItem2 = TextItem('', TextItem.CENTER, self.SOLO_POS_2)
self.addItem(self._soloTextItem2)
self._soloTextItem3 = TextItem('', TextItem.CENTER, self.SOLO_POS_3)
self.addItem(self._soloTextItem3)
self._soloTextItem4 = TextItem('', TextItem.CENTER, self.SOLO_POS_4)
self.addItem(self._soloTextItem4)
self._soloTextItem5 = TextItem('', TextItem.CENTER, self.SOLO_POS_5)
self.addItem(self._soloTextItem5)
self._soloTextItem6 = TextItem('', TextItem.CENTER, self.SOLO_POS_6)
self.addItem(self._soloTextItem6)
self._soloTextItem7 = TextItem('', TextItem.CENTER, self.SOLO_POS_7)
self.addItem(self._soloTextItem7)
self._soloTextItem8 = TextItem('', TextItem.CENTER, self.SOLO_POS_8)
self.addItem(self._soloTextItem8)
self._soloAreas = ((self._soloTextItem3,),
(self._soloTextItem3, self._soloTextItem4),
(self._soloTextItem3, self._soloTextItem4,
self._soloTextItem5),
(self._soloTextItem2, self._soloTextItem3,
self._soloTextItem4, self._soloTextItem5),
(self._soloTextItem2, self._soloTextItem3,
self._soloTextItem4, self._soloTextItem5,
self._soloTextItem6),
(self._soloTextItem2, self._soloTextItem3,
self._soloTextItem4, self._soloTextItem5,
self._soloTextItem6, self._soloTextItem7),
(self._soloTextItem1, self._soloTextItem2,
self._soloTextItem3, self._soloTextItem4,
self._soloTextItem5, self._soloTextItem6,
self._soloTextItem7),
(self._soloTextItem1, self._soloTextItem2,
self._soloTextItem3, self._soloTextItem4,
self._soloTextItem5, self._soloTextItem6,
self._soloTextItem7, self._soloTextItem8))
scaleTypeLeftButton.clicked.connect(self._updateTextItems)
scaleTypeRightButton.clicked.connect(self._updateTextItems)
rootNoteLeftButton.clicked.connect(self._updateTextItems)
rootNoteRightButton.clicked.connect(self._updateTextItems)
soloLengthLeftButton.clicked.connect(self._updateTextItems)
soloLengthRightButton.clicked.connect(self._updateTextItems)
generateButton.clicked.connect(self._updateTextItems)
aboutButton.clicked.connect(self.aboutButtonClicked)
def multiplyDiameter(self, factor):
r1 = self.rect()
r2 = QRectF(0, 0, r1.width() * factor, r1.height() * factor)
self.setRect(r2)
self.setPos(self.pos() + r1.center() - r2.center())
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(), self.f_size.height(),
QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h, total_distance_h, img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(),
total_distance_h)
painter.drawLine(0,
base_img.height() - (total_distance_h),
base_img.width(),
base_img.height() - (total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h,
base_img.height())
painter.drawLine(base_img.width() - (total_distance_h), 0,
base_img.width() - (total_distance_h),
base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(
QRectF((total_distance_h) + (border_thick / 2),
(total_distance_h) + (border_thick / 2),
base_img.width() - ((total_distance_h) * 2) -
((border_thick) - 1),
(base_img.height() -
((total_distance_h)) * 2) - ((border_thick) - 1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(
QRectF((total_distance_h), (total_distance_h),
base_img.width() - ((total_distance_h) * 2),
(base_img.height() - ((total_distance_h)) * 2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0,
base_img.height() / 2, total_distance_h,
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, 0,
base_img.width() / 2, total_distance_h)
painter.drawLine(base_img.width() - total_distance_h,
base_img.height() / 2, base_img.width(),
base_img.height() / 2)
painter.drawLine(base_img.width() / 2, base_img.height(),
base_img.width() / 2,
base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(
os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size - 11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.drawImage(
((total_distance_h)) + 11, ((total_distance_h)) + 11,
QImage(icon_path('electrumb.png')).scaledToWidth(
2.1 * (total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2 - 77,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
11,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.version + '_' +
self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0,
base_img.height() - dist_v, base_img.width(),
base_img.height() - (dist_v))
painter.drawLine(base_img.width() - (dist_h), 0,
base_img.width() - (dist_h),
base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(
1.3 * (total_distance_h))
painter.drawImage((total_distance_h) + (border_thick),
((total_distance_h)) + (border_thick), logo,
Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(
total_distance_h + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2),
total_distance_h + logo.width() + border_thick,
total_distance_h + logo.height() + 3 * (border_thick / 2))
painter.drawLine(
logo.width() + total_distance_h + 3 * (border_thick / 2),
total_distance_h + (border_thick),
total_distance_h + logo.width() + 3 * (border_thick / 2),
total_distance_h + logo.height() + (border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width() - ((total_distance_h)) -
(border_thick / 2) - 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2)
painter.drawLine(
(base_img.width() / 2 +
(total_distance_h / 2) - border_thick -
(border_thick * 8) / 2) - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - (border_thick * 8) / 2 - qr_size,
((base_img.height() - ((total_distance_h))) -
(border_thick / 2) - 2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) -
(border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) -
border_thick - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0, 0, 0, 255))
painter.drawText(
QRect(((base_img.width() / 2) + 21) - qr_size,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
93,
base_img.height() - total_distance_h - border_thick),
Qt.AlignLeft,
self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(
QRect(
0,
base_img.height() - 107,
base_img.width() - total_distance_h - border_thick -
3 - qr_size,
base_img.height() - total_distance_h - border_thick),
Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(
self.versioned_seed.get_ui_string_version_plus_seed() +
self.versioned_seed.checksum)
target = QRectF(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size, qr_size,
qr_size)
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) -
((border_thick * 8)) - (border_thick / 2) - 4)
painter.drawLine(base_img.width() - 65 - qr_size,
base_img.height() - 65 - qr_size,
base_img.width() - 65,
base_img.height() - 65 - qr_size)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100,
self.f_size.height() + 100, QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0, 0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n = 15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n, n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - 13,
x + 2 + base_img.height() - (dist_v),
(((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) + 13,
x + 2 + base_img.height() - (dist_v))
num_pos = 9
if x > 9: num_pos = 17
if x < 0: num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width()) / (n * 2)) *
(x)) + (base_img.width() / 2) - num_pos,
50 + base_img.height() - (dist_v), str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) - 13,
x + 2 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) * (x)) +
(base_img.height() / n) + (base_img.height() / 2) + 13)
cal_painter.drawText(30 + (base_img.width() - (dist_h)),
((base_img.height() / (2 * n)) *
(x)) + (base_img.height() / 2) + 13,
str(x))
cal_painter.end()
base_img = cal_img
return base_img
def boundingRect(self):
return self.scene().data2scene.mapRect(
QRectF(0, 0, self._width, self._height))
def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) angle_step = 360 / self.n_states painter.save() #Save_1. Save the state of the system (push matrix) painter.translate(self.dist_center.x(), self.dist_center.y()) # go to the center of the render area painter.rotate(-180) #to start painting from the left side of the circle (clockwise) #center of the circumference where through we are going to paint our states x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h # each state is equidistant from the others. We paint them in circles painter.save() #Save_2 painter.rotate(rot) #now our system is pointing to the next state to be drawn painter.translate(x,y) #now our origin is in the center of the next state to be drawn #if the state is active, fill it green if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0,0), self.state_radius, self.state_radius) #draw the new state #global position of transformed coordinates (before any transformation, origin at top-left corner) gx = painter.worldTransform().map(QPoint(0,0)).x() gy = painter.worldTransform().map(QPoint(0,0)).y() self.machine.getState(h).setPos(gx, gy) #store the center of the state without any transformation applied # text transformation. Our origin is still in the center of the current state painter.save() #Save_3 painter.rotate(180) #making the text go vertical painter.rotate(-rot) #undoing the rotation made for painting the state. No the text is horizontal font = painter.font(); font.setPixelSize(self.state_radius*.4); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()); painter.restore() #Restore_3 #end text transformation painter.restore() #Restore_2 painter.restore() #Restore_1. Restore the state of the system (pop matrix) #drawing transitions. Line between states painter.save() # Save_4 pptv = QTransform() #Define a new transformation. Needed to rotate the system along other axis than Z pptv.translate(0, self.height()) #We are now at the bottom-left corner of the screen pptv.rotate(-180, Qt.XAxis) #Rotate along the X-axis so now we are in a typical cartesian system. painter.setTransform(pptv) #Apply the transformation states = self.machine.getStates() for state in states: transitions = state.getTransitions() for transition in transitions: #get the center of the origin and destination states in our current system state orig = QPoint(state.getPos()[0], state.getPos()[1]) end = QPoint(self.machine.getState(transition.getStateEnd()).getPos()[0], self.machine.getState(transition.getStateEnd()).getPos()[1]) # get those coordinates without transformation orig2 = QPoint(painter.worldTransform().map(orig)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers and the horizon angle = math.atan2(end2.y() - orig2.y(), end2.x() - orig2.x()) #get the coordinates of the starting point of the transition (it starts in the bound of the state, not in the center) newX = self.state_radius * math.cos(angle) + orig2.x() newY = self.state_radius * math.sin(angle) + orig2.y() #now the transition starts at the border, not in the center orig2.setX(newX) orig2.setY(newY) #same for the destination state angle2 = math.atan2(orig2.y() - end2.y(), orig2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #draw the line between the origin and destination states painter.drawLine(orig2, end2) #get the start and the end of the transition untransformed init = QPoint(painter.worldTransform().map(orig2)) end = QPoint(painter.worldTransform().map(end2)) #store that info transition.setOrig(init.x(), init.y()) transition.setDest(end.x(), end.y()) transition.setAngle(angle) painter.restore() #Restore_4 #Appliying style to the transitions painter.setPen(QPen(QColor(Qt.gray), 3)) for state in self.machine.getStates(): for transition in state.getTransitions(): #get the start and end coordinates of the transition i = QPoint(transition.getOrig()[0], transition.getOrig()[1]) o = QPoint(transition.getDest()[0], transition.getDest()[1]) painter.drawPolyline(i, o) #Drawing the arrow at the end of the transition painter.save() #Save_5 painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate(transition.getDest()[0],transition.getDest()[1]) #Go to the end of the transition painter.rotate(90 - transition.getAngle()*180/math.pi) #Rotate to point in the direction of the transition #coordinates of the arrow (triangle) a = QPoint(0,0) b = QPoint(-5,10) c = QPoint(5,10) #coordinates of the arrow untransformed a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) #Drawin the actual arrow pointer = QPolygon([a,b,c]) painter.drawPolygon(pointer) painter.restore() #Restore_5 #For the animation of the transition painter.save() #Save_6 if transition.isActive(): #if the current transition is the active one the wave function will be running, so it's updating the canvas painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(i,o) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) #Draw the arrow in the active state (red arrow) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1,b1,c1]) painter.drawPolygon(pointer) #Ball that follows the line animation for x, y in self.pts: painter.drawEllipse(QRectF(self.pts[0][0] - 4, self.pts[0][1] - 4, 8, 8)) painter.restore() #Restore_6 #Painting the text of the transition painter.save() #Save_7 pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) #get the middle point of the transition middleX = (transition.getOrig()[0] + transition.getDest()[0]) /2 middleY = (transition.getOrig()[1] + transition.getDest()[1]) /2 pptv.translate(middleX, middleY) #translate to that point painter.setTransform(pptv) #apply the transformation font = painter.font(); font.setPixelSize(self.state_radius*.2); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) name = str(transition.getId())+ '. ' + transition.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() #Restore_7 #paint the actual canvas painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def updateImagePreview(self):
maxSize = 256
wBase = max(
self.widthUnit.pixelsForUnit(self.spn_width.value(),
self.DPI.value()), 1)
bL = self.bleedLeftUnit.pixelsForUnit(self.bleedLeft.value(),
self.DPI.value())
bR = self.bleedRightUnit.pixelsForUnit(self.bleedRight.value(),
self.DPI.value())
mL = self.marginLeftUnit.pixelsForUnit(self.marginLeft.value(),
self.DPI.value())
mR = self.marginRightUnit.pixelsForUnit(self.marginRight.value(),
self.DPI.value())
hBase = max(
self.heightUnit.pixelsForUnit(self.spn_height.value(),
self.DPI.value()), 1)
bT = self.bleedTopUnit.pixelsForUnit(self.bleedTop.value(),
self.DPI.value())
bB = self.bleedBottomUnit.pixelsForUnit(self.bleedBottom.value(),
self.DPI.value())
mT = self.marginTopUnit.pixelsForUnit(self.marginTop.value(),
self.DPI.value())
mB = self.marginBottomUnit.pixelsForUnit(self.marginBottom.value(),
self.DPI.value())
scaleRatio = maxSize / (hBase + bT + bB)
if wBase > hBase:
scaleRatio = maxSize / (wBase + bR + bL)
width = (wBase + bL + bR) * scaleRatio
height = (hBase + bT + bB) * scaleRatio
topLeft = [
max((maxSize - width) / 2, 0),
max((maxSize - height) / 2, 0)
]
image = QImage(maxSize, maxSize, QImage.Format_ARGB32)
image.fill(Qt.transparent)
p = QPainter(image)
p.setBrush(Qt.white)
CanvasSize = QRectF(topLeft[0], topLeft[1], width, height)
p.drawRect(CanvasSize.toRect())
# Draw bleeds.
PageSize = CanvasSize
PageSize.setWidth(width - (bR * scaleRatio))
PageSize.setHeight(height - (bB * scaleRatio))
PageSize.setX(PageSize.x() + (bL * scaleRatio))
PageSize.setY(PageSize.y() + (bT * scaleRatio))
p.setPen(Qt.blue)
p.setBrush(Qt.transparent)
p.drawRect(PageSize.toRect())
# Draw liveArea
LiveArea = PageSize
LiveArea.setWidth(LiveArea.width() - (mR * scaleRatio))
LiveArea.setHeight(LiveArea.height() - (mB * scaleRatio))
LiveArea.setX(LiveArea.x() + (mL * scaleRatio))
LiveArea.setY(LiveArea.y() + (mT * scaleRatio))
p.setPen(Qt.blue)
p.drawRect(LiveArea.toRect())
p.end()
self.imagePreview.setPixmap(QPixmap.fromImage(image))
def boundingRect(self) -> QRectF:
rect = self.rect()
c = rect.center()
r = 20
return QRectF(c.x() - r, c.y() - r, 2*r, 2*r)
