def __init__(self, *args, **kwargs):
super(ChartView, self).__init__(*args, **kwargs)
self.resize(800, 600)
self.setRenderHint(QPainter.Antialiasing) # 抗锯齿
self.initChart()
self.toolTipWidget = GraphicsProxyWidget(self._chart)
# line
self.lineItem = QGraphicsLineItem(self._chart)
self.lineItem.setZValue(998)
self.lineItem.hide()
# 一些固定计算，减少mouseMoveEvent中的计算量
# 获取x和y轴的最小最大值
axisX, axisY = self._chart.axisX(), self._chart.axisY()
self.min_x, self.max_x = axisX.min(), axisX.max()
self.min_y, self.max_y = axisY.min(), axisY.max()
# 坐标系中左上角顶点
self.point_top = self._chart.mapToPosition(
QPointF(self.min_x, self.max_y))
# 坐标原点坐标
self.point_bottom = self._chart.mapToPosition(
QPointF(self.min_x, self.min_y))
self.step_x = (self.max_x - self.min_x) / (axisX.tickCount() - 1)
def drawPlayHead(self):
self.play_head = QGraphicsLineItem(self.piano_width,
self.header_height,
self.piano_width, self.total_height)
self.play_head.setPen(QPen(QColor(255, 255, 255, 50), 2))
self.play_head.setZValue(1.)
self.addItem(self.play_head)
def add_clearance_graph(self):
print("-----------------------------------------")
horizontal_clearance = self.clearance_analysis.horizontal_clearance
x_init = self.graph_zero[0] + self.line_extend
y_init = self.graph_zero[1]
for i in range(len(horizontal_clearance)):
clearance_points = horizontal_clearance[i]
x = x_init + i * self.dimension_analysis.section_distance * self.length_multiplier
left = -self.dimension_analysis.domain_length
right = self.dimension_analysis.domain_length
if clearance_points[0]:
left = clearance_points[0]
if clearance_points[1]:
right = clearance_points[1]
clearance = right - left
y_top = y_init + left * self.height_multiplier
y_bottom = y_init + right * self.height_multiplier
pen_red = QPen()
red = Color.create_qcolor_from_rgb_tuple(Color.red)
pen_red.setColor(red)
pen_green = QPen()
green = Color.create_qcolor_from_rgb_tuple(Color.green)
pen_green.setColor(green)
line = QGraphicsLineItem(x, y_top, x, y_bottom)
if clearance < self.min_horizontal_clearance:
line.setPen(pen_red)
else:
line.setPen(pen_green)
self.addToGroup(line)
pass
def moveTo(self, pos):
# data coordinates
oldX, oldY = self.pos.x(), self.pos.y()
x, y = pos.x(), pos.y()
line = QGraphicsLineItem(oldX, oldY, x, y)
line.setPen(
QPen(QBrush(Qt.white), self.brushSize, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
self.scene.addItem(line)
self._hasMoved = True
# update bounding Box
if not self.bb.isValid():
self.bb = QRect(QPoint(oldX, oldY), QSize(1, 1))
# grow bounding box
self.bb.setLeft(
min(self.bb.left(), max(0, x - self.brushSize // 2 - 1)))
self.bb.setRight(
max(self.bb.right(),
min(self.sliceRect[0] - 1, x + self.brushSize // 2 + 1)))
self.bb.setTop(min(self.bb.top(), max(0, y - self.brushSize // 2 - 1)))
self.bb.setBottom(
max(self.bb.bottom(),
min(self.sliceRect[1] - 1, y + self.brushSize // 2 + 1)))
# update/move position
self.pos = pos
def __init__(self, source, dest, id, graphicsGraphView):
# Parent constructor(s)
GraphicsEdge.__init__(self, source, dest, id, graphicsGraphView)
QGraphicsLineItem.__init__(self)
self.setFlag(QGraphicsItem.ItemIsSelectable)
self.update()
class VertexFixSign(QGraphicsItem): def __init__(self, vertex): super().__init__(vertex.circle) self.topLeft = QPointF(vertex.x() - 8, vertex.y() - 8) self.topRight = QPointF(vertex.x() + 8, vertex.y() - 8) self.bottomLeft = QPointF(vertex.x() - 8, vertex.y() + 8) self.bottomRight = QPointF(vertex.x() + 8, vertex.y() + 8) self.line1 = QGraphicsLineItem(QLineF(self.topLeft, self.bottomRight), self) self.line2 = QGraphicsLineItem(QLineF(self.topRight, self.bottomLeft), self) self.vertex = vertex self.setVisible(False) def paint(self, painter, option, widget): painter.setPen(Qt.black) painter.drawLine(self.topLeft, self.bottomRight) painter.drawLine(self.topRight, self.bottomLeft) def boundingRect(self): return QRectF(self.topLeft, self.bottomRight) def move(self): self.topLeft = QPointF(self.vertex.x() - 8, self.vertex.y() - 8) self.topRight = QPointF(self.vertex.x() + 8, self.vertex.y() - 8) self.bottomLeft = QPointF(self.vertex.x() - 8, self.vertex.y() + 8) self.bottomRight = QPointF(self.vertex.x() + 8, self.vertex.y() + 8) self.line1.setLine(QLineF(self.topLeft, self.bottomRight)) self.line2.setLine(QLineF(self.topRight, self.bottomLeft))
def __init__(self, pos, parent=None):
super(LineLabel, self).__init__()
# initial text
self.setPlainText("abc")
# stores index of first point of segment
self.index = None
# distance from line segment
self.gap = None
# set graphical setting
self.setFlags(QGraphicsItem.ItemIsMovable |
QGraphicsItem.ItemIsSelectable |
QGraphicsItem.ItemIsFocusable)
self.setTextInteractionFlags(Qt.NoTextInteraction)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
# set center of text label at mouse pos
self.setPos(pos - self.boundingRect().center())
self.setParentItem(parent)
# add line item to test label
self.line = QGraphicsLineItem()
self.line.setParentItem(self)
self.line.setPen(QPen(Qt.black, 2, Qt.SolidLine))
self.line.setFlag(QGraphicsItem.ItemStacksBehindParent)
# reset position of line
self.resetPos()
self.values = defaultdict(lambda: 0)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
downPos = event.buttonDownPos(Qt.LeftButton)
if not self.__tmpLine and self.__dragStartItem and \
(downPos - event.pos()).manhattanLength() > \
QApplication.instance().startDragDistance():
# Start a line drag
line = QGraphicsLineItem(self)
start = self.__dragStartItem.boundingRect().center()
start = self.mapFromItem(self.__dragStartItem, start)
line.setLine(start.x(), start.y(),
event.pos().x(),
event.pos().y())
pen = QPen(Qt.black, 4)
pen.setCapStyle(Qt.RoundCap)
line.setPen(pen)
line.show()
self.__tmpLine = line
if self.__tmpLine:
# Update the temp line
line = self.__tmpLine.line()
line.setP2(event.pos())
self.__tmpLine.setLine(line)
QGraphicsWidget.mouseMoveEvent(self, event)
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QGraphicsLineItem(
QLineF(mouseEvent.scenePos(), mouseEvent.scenePos()))
self.line.setPen(QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def __init__(self, *args, **kwargs):
super(ChartView, self).__init__(*args, **kwargs)
self.resize(800, 600)
self.setRenderHint(QPainter.Antialiasing) # 抗锯齿
data = pd.read_csv("data/data.csv")
list = data.values.tolist()
xAxisArr = []
for i in range(30):
xAxisArr.append(list[i * 60][2][-5:])
# print(xAxisArr[i])
# 自定义x轴label
self.category = xAxisArr
self.initChart()
# 提示widget
self.toolTipWidget = GraphicsProxyWidget(self._chart)
# line
self.lineItem = QGraphicsLineItem(self._chart)
pen = QPen(Qt.gray)
pen.setWidth(1)
self.lineItem.setPen(pen)
self.lineItem.setZValue(998)
self.lineItem.hide()
# 一些固定计算，减少mouseMoveEvent中的计算量
# 获取x和y轴的最小最大值
axisX, axisY = self._chart.axisX(), self._chart.axisY()
self.min_x, self.max_x = axisX.min(), axisX.max()
self.min_y, self.max_y = axisY.min(), axisY.max()
def __init__(self, parent=None):
super(QChartView, self).__init__(parent=parent)
self.reftime = datetime.datetime.now()
self.cursor = QGraphicsLineItem()
self.scene().addItem(self.cursor)
self.decim_factor = 1
# self.setScene(QGraphicsScene())
self.chart = QChart()
# self.scene().addItem(self.chart)
self.setChart(self.chart)
self.chart.legend().setVisible(True)
self.chart.legend().setAlignment(Qt.AlignBottom)
self.ncurves = 0
self.setRenderHint(QPainter.Antialiasing)
self.setRubberBand(QChartView.HorizontalRubberBand)
# X, Y label on bottom
# self.xTextItem = QGraphicsSimpleTextItem(self.chart)
# self.xTextItem.setText('X: ')
# self.yTextItem = QGraphicsSimpleTextItem(self.chart)
# self.yTextItem.setText('Y: ')
# self.update_x_y_coords()
# Track mouse
self.setMouseTracking(True)
# Top Widgets
newWidget = QWidget(self)
newLayout = QHBoxLayout()
newWidget.setLayout(newLayout)
labelx = QLabel(self)
labelx.setText('X:')
self.labelXValue = QLabel(self)
labely = QLabel(self)
labely.setText('Y:')
self.labelYValue = QLabel(self)
# Test buttons
newLayout.addWidget(QToolButton(self))
newLayout.addWidget(QToolButton(self))
newLayout.addWidget(QToolButton(self))
# Spacer
newLayout.addItem(QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Minimum))
# Labels
newLayout.addWidget(labelx)
newLayout.addWidget(self.labelXValue)
self.labelXValue.setMinimumWidth(200)
self.labelXValue.setMaximumWidth(200)
newLayout.addWidget(labely)
newLayout.addWidget(self.labelYValue)
self.labelYValue.setMinimumWidth(200)
self.labelYValue.setMaximumWidth(200)
if parent is not None:
parent.layout().setMenuBar(newWidget)
def drawLine(self, ):
if not (self.testItem is None):
self.scene.removeItem(self.testItem)
pen = self.relFormat.pen()
#brush = self.relFormat.brush()
self.testItem = QGraphicsLineItem(5, 50, 100, 50, parent=None)
self.testItem.setPen(pen)
self.scene.addItem(self.testItem)
def _add_current_line(self):
self.current_line = QGraphicsLineItem()
self.addItem(self.current_line)
self.current_line.setVisible(False)
pen = QPen(QColor(0, 0, 0))
pen.setWidth(2)
self.current_line.setPen(pen)
self.current_port = None
def drawTemplateRel(self, ):
if not (self.TRtestItem is None):
self.TRscene.removeItem(self.TRtestItem)
rpen = self.templateRelFormat.pen()
rbrush = self.templateRelFormat.brush()
self.TRtestItem = QGraphicsLineItem(5, 50, 100, 50, parent=None)
self.TRtestItem.setPen(rpen)
self.TRscene.addItem(self.TRtestItem)
def distance_to(self, item):
distance = QLineF(QPointF(self.pos().x() + 25,
self.pos().y() + 25), item.pos())
line = QGraphicsLineItem(distance)
line.setPen(QPen(Qt.red))
# self.scene().addItem(line)
return distance.length()
def drawInstanceRel(self, ):
if not (self.IRtestItem is None):
self.IRscene.removeItem(self.IRtestItem)
rpen = self.instanceRelFormat.pen()
# rbrush = self.instanceRelFormat.brush()
self.IRtestItem = QGraphicsLineItem(5, 50, 100, 50, parent=None)
self.IRtestItem.setPen(rpen)
self.IRscene.addItem(self.IRtestItem)
def __init__(self, startNode, endNode, parent: SinglePipeConnection):
super().__init__(startNode, endNode, parent)
self._singlePipeConnection = parent
self.singleLine = QGraphicsLineItem(self)
self.linearGrad = None
self.initGrad()
def __init__(self):
super(KLineChartView, self).__init__()
self.setRenderHint(QPainter.Antialiasing) # 抗锯齿
self._chart = QChart(title='蜡烛图悬浮提示')
self.stocks = read_tick_data()
self.category = [
trade_date[4:] for trade_date in self.stocks['trade_date']
]
self._count = len(self.category)
self.resize(800, 300)
self.init_chart()
self.toolTipWidget = GraphicsProxyWidget(self._chart)
# 鼠标跟踪的十字线
self.lineItem_h = QGraphicsLineItem(self._chart)
self.lineItem_v = QGraphicsLineItem(self._chart)
pen = QPen()
pen.setStyle(Qt.DotLine)
pen.setColor(QColor(Qt.gray))
pen.setWidth(2)
self.lineItem_h.setPen(pen)
self.lineItem_v.setPen(pen)
self.lineItem_h.setZValue(100)
self.lineItem_v.setZValue(100)
self.lineItem_h.hide()
self.lineItem_v.hide()
# 坐标轴上最大最小的值
# x 轴是
self.min_x, self.max_x = 0, len(self._chart.axisX().categories())
self.min_y, self.max_y = self._chart.axisY().min(), self._chart.axisY(
).max()
# y 轴最高点坐标
self.point_y_max = self._chart.mapToPosition(
QPointF(self.min_x, self.max_y))
# x 轴最高点坐标
self.point_x_max = self._chart.mapToPosition(
QPointF(self.max_x, self.min_y))
# self.point_x_min = self._chart.mapToPosition(QPointF(self.min_x, self.min_y))
# 计算x轴单个cate的宽度，用来处理横线不能画到边界
self.x_width = (self.point_x_max.x() - self.point_y_max.x()) / len(
self.category)
self.x_x_min = self.point_y_max.x() - self.x_width / 2
self.x_x_max = self.point_x_max.x() - self.x_width / 2
# 中间位置,用来判断TipWidget放在哪里
mid_date = self.stocks['trade_date'].iloc[len(
self.stocks['trade_date']) // 2]
self.mid_x = float(
time.mktime(
datetime.datetime.strptime(str(mid_date),
'%Y%m%d').timetuple()))
self.left_pos = self.point_y_max
self.right_pos = self._chart.mapToPosition(
QPointF(self.max_x, self.max_y))
def mouseMoveEvent(self, m_event):
"""
Handles a mouse move on the scene
:param m_event: The mouse move event and its details
"""
super(TreeScene, self).mouseMoveEvent(m_event)
# pass move event to dragged node
if self.drag_drop_node:
# initiate connection state if tree has a root
if self.gui.tree and self.gui.tree.root != '':
self.connecting_node = self.drag_drop_node
x, y = self.drag_drop_node.xpos(), self.drag_drop_node.ypos()
self.connecting_line = QGraphicsLineItem(
x, y - self.drag_drop_node.rect().height() / 2, x, y)
# keep connection line on top
self.connecting_line.setZValue(1)
self.addItem(self.connecting_line)
self.app.add_cross_cursor(self)
else:
# add root to model of the tree
self.gui.tree.root = self.drag_drop_node.id
self.root_ui_node = self.drag_drop_node
node = self.gui.tree.nodes.get(self.drag_drop_node.id)
self.gui.update_tree(node)
self.drag_drop_node = None
if self.dragging_node:
self.dragging_node.mouseMoveEvent(m_event)
return
# adjust connection line when connecting node
if self.connecting_line:
line = self.connecting_line.line()
line.setP2(m_event.scenePos() - QPoint(-1, 1))
self.connecting_line.setLine(line)
# pass mouse move event to top item that accepts hover events
item = self.itemAt(m_event.scenePos(), self.view.transform())
if item:
if item.acceptHoverEvents():
item.mouseMoveEvent(m_event)
return
else:
# look for parent that accepts hover events
while item.parentItem():
item = item.parentItem()
if item.acceptHoverEvents():
item.mouseMoveEvent(m_event)
return
# check if scene is being dragged and move all items accordingly
if self.dragging:
dx = m_event.scenePos().x() - m_event.lastScenePos().x()
dy = m_event.scenePos().y() - m_event.lastScenePos().y()
for g_item in [i for i in self.items() if not i.parentItem()]:
if g_item == self.connecting_line:
line = self.connecting_line.line()
line.setP1(line.p1() + QPointF(dx, dy))
self.connecting_line.setLine(line)
else:
g_item.moveBy(dx, dy)
def __init__(self):
super(painter, self).__init__()
self.setFixedSize(self.width, self.height + self.textLineHeight)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
self.setScene(self.scene)
if len(sys.argv) >= 2:
if sys.argv[2] == "MLX90641":
self.blurRaduis = 25
self.ChipType = "MLX90641"
elif sys.argv[2] == "MLX90640":
self.blurRaduis = 50
self.ChipType = "MLX90640"
# center het text item
self.centerTextItem = QGraphicsTextItem()
self.centerTextItem.setPos(self.width / 2 - self.fontSize, 0)
self.centerTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.centerTextItem)
# center anchor item
centerX = self.width / 2
centerY = self.height / 2
self.ellipseItem = QGraphicsEllipseItem(0, 0, self.ellipseRadius * 2,
self.ellipseRadius * 2)
self.horLineItem = QGraphicsLineItem(0, 0, self.anchorLineSize, 0)
self.verLineItem = QGraphicsLineItem(0, 0, 0, self.anchorLineSize)
self.ellipseItem.setPos(centerX - self.ellipseRadius,
centerY - self.ellipseRadius)
self.horLineItem.setPos(centerX - self.anchorLineSize / 2, centerY)
self.verLineItem.setPos(centerX, centerY - self.anchorLineSize / 2)
self.ellipseItem.setPen(QColor(Qt.white))
self.horLineItem.setPen(QColor(Qt.white))
self.verLineItem.setPen(QColor(Qt.white))
self.ellipseItem.setZValue(self.baseZValue + 1)
self.horLineItem.setZValue(self.baseZValue + 1)
self.verLineItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.ellipseItem)
self.scene.addItem(self.horLineItem)
self.scene.addItem(self.verLineItem)
# camera item
self.cameraBuffer = QPixmap(self.width,
self.height + self.textLineHeight)
self.cameraItem = QGraphicsPixmapItem()
if self.useBlur:
self.gusBlurEffect = QGraphicsBlurEffect()
self.gusBlurEffect.setBlurRadius(self.blurRaduis)
self.cameraItem.setGraphicsEffect(self.gusBlurEffect)
self.cameraItem.setPos(0, 0)
self.cameraItem.setZValue(self.baseZValue)
self.scene.addItem(self.cameraItem)
# het text item
self.hetTextBuffer = QPixmap(self.width, self.textLineHeight)
self.hetTextItem = QGraphicsPixmapItem()
self.hetTextItem.setPos(0, self.height)
self.hetTextItem.setZValue(self.baseZValue)
self.scene.addItem(self.hetTextItem)
def __init__(self, source, dest, parent=None):
QGraphicsLineItem.__init__(self, parent)
self.source = source
self.dest = dest
self.source.addEdge(self)
self.dest.addEdge(self)
self.line_color = QColor(153, 153, 153)
self.line_color.setAlpha(40)
self.setPen(QPen(self.line_color, 1.75))
self.adjust()
def __init__(self, vertex): super().__init__(vertex.circle) self.topLeft = QPointF(vertex.x() - 8, vertex.y() - 8) self.topRight = QPointF(vertex.x() + 8, vertex.y() - 8) self.bottomLeft = QPointF(vertex.x() - 8, vertex.y() + 8) self.bottomRight = QPointF(vertex.x() + 8, vertex.y() + 8) self.line1 = QGraphicsLineItem(QLineF(self.topLeft, self.bottomRight), self) self.line2 = QGraphicsLineItem(QLineF(self.topRight, self.bottomLeft), self) self.vertex = vertex self.setVisible(False)
def updateGraphicsLineItem(line: QGraphicsLineItem, lineF: QLineF = None, pen: QPen = None):
"""
更新线 QGraphicsLineItem属性
:param line: QGraphicsLineItem
:param lineF: 线的坐标大小
:param pen: 画笔
"""
if lineF:
line.setLine(lineF)
if pen:
line.setPen(pen)
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def __init__(self, xAxis=[], *args, **kwargs):
super(barChartView, self).__init__(*args, **kwargs)
self.initChart(xAxis)
# line 宽度需要调整
self.lineItem = QGraphicsLineItem(self._chart)
pen = QPen(Qt.gray)
self.lineItem.setPen(pen)
self.lineItem.setZValue(998)
self.lineItem.hide()
self.cal()
def __init__(self, parent=None):
super().__init__(parent)
self.horizontal_line = QGraphicsLineItem()
self.vertical_line = QGraphicsLineItem()
self.horizontal_line.setLine(0, 1080 / 2, 1920, 1080 / 2)
self.vertical_line.setLine(1920 / 2, 0, 1920 / 2, 1080)
self.pen = QPen(Qt.white)
self.horizontal_line.setPen(self.pen)
self.vertical_line.setPen(self.pen)
def fire(self):
arrow = Arrow()
arrow.setPos(self.x(), self.y())
attack_line = QLineF(QPointF(self.x() + 25,
self.y() + 25), self.attack_destination)
line = QGraphicsLineItem(attack_line)
line.setPen(QPen(Qt.blue))
# self.scene().addItem(line)
attack_angle = -1 * attack_line.angle(
) # Multiplied by -1 because the angle is given in counter clockwise direction
arrow.setRotation(attack_angle)
self.scene().addItem(arrow)
def draw(self, nextDown, x, y):
self.nextDown = nextDown
self.x = x
self.y = y
# remove old stuff
for c in self.childItems():
c.setParentItem(None)
# just draw me at x, y
self.setPos(x, y)
# if self.isDrawingDirty:
self.drawBase()
if self.aItem != None:
self.uiFactory.beginRootLayout(x, y, ITEM_SIZE, self)
self.aItem.item.onComposerDraw(self.uiFactory, self.aItem.amount,
self.getMinAmount(),
self.getMaxAmount())
self.uiFactory.endRootLayout()
orgX = x
orgY = y
lastX = x
lastY = y
for child in self.children:
if nextDown:
nextX = orgX
nextY = y + ITEM_SIZE + ITEM_SPACE
else:
nextX = x + ITEM_SIZE + ITEM_SPACE
nextY = orgY
# draw connection between children
if nextDown:
QGraphicsLineItem(lastX + ITEM_SIZE_HALF - orgX,
lastY + ITEM_SIZE - orgY,
nextX + ITEM_SIZE_HALF - orgX,
nextY + ITEM_SIZE - orgY, self)
else:
QGraphicsLineItem(lastX + ITEM_SIZE - orgX,
lastY + ITEM_SIZE_HALF - orgY, nextX - orgX,
nextY + ITEM_SIZE_HALF - orgY, self)
tmpX, tmpY = child.draw(not nextDown, nextX, nextY)
if tmpX > x:
x = tmpX
if tmpY > y:
y = tmpY
lastX = nextX
lastY = nextY
return x, y
def __init__(self, item1, item2, parent):
QGraphicsLineItem.__init__(self)
self.setParentItem(parent)
self.item1 = item1
self.item2 = item2
self.m_locked = False
self.m_lineSelected = False
self.setGraphicsEffect(None)
self.updateLinePos()
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.round = 50
# set range.
self.gScene = QGraphicsScene(0, 0,
self.ui.graphicsView.width() - 5,
self.ui.graphicsView.height() - 5,
self.ui.graphicsView)
print 'graphics View x %f', self.ui.graphicsView.width()
print 'graphics View y %f', self.ui.graphicsView.height()
self.ui.graphicsView.setScene(self.gScene)
# test circle
self.circle = QGraphicsEllipseItem()
red = QBrush(Qt.red)
pen = QPen(Qt.black)
pen.setWidth(6)
# test line
self.x_line = QGraphicsLineItem(self.gScene.width() / 2, 0,
self.gScene.width() / 2,
self.gScene.height())
self.gScene.addItem(self.x_line)
self.y_line = QGraphicsLineItem(0,
self.gScene.width() / 2,
self.gScene.height(),
self.gScene.width() / 2)
self.gScene.addItem(self.y_line)
#self.circle2 = DrawCircles(int(self.gScene.width()/2), int(self.gScene.height()/2))
#self.gScene.addItem(self.circle2)
print 'gScene View x %f', self.gScene.width() / 2
print 'gScene View y %f', self.gScene.height() / 2
self.circle = self.gScene.addEllipse(
self.gScene.width() / 2 - self.round,
self.gScene.height() / 2 - self.round, self.round * 2,
self.round * 2, pen, red)
# check Item argv.
self.g_item = QGraphicsRectItem(self.gScene.width() / 2,
self.gScene.height() / 2, 100, 100)
self.gScene.addItem(self.g_item)
self.g1_item = QGraphicsRectItem(self.gScene.width() / 2,
self.gScene.height() / 2, 100, 100)
self.gScene.addItem(self.g1_item)
# self.gScene.addItem(self.circles)
self.show()
def __init__(self, shape):
QGraphicsLineItem.__init__(self)
StMove.__init__(self, shape)
self.allwaysshow = False
self.path = QPainterPath()
self.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.pen = QPen(QColor(50, 100, 255), 1, QtCore.Qt.SolidLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
self.pen.setCosmetic(True)
self.make_papath()
def _create_grid_lines(self):
pen_color = QColor(255, 255, 255, 255)
pen = QPen(pen_color)
pen.setWidth(2)
pen.setStyle(QtCore.Qt.DotLine)
self.vline = QGraphicsLineItem()
self.vline.setVisible(False)
self.vline.setPen(pen)
self.hline = QGraphicsLineItem()
self.hline.setVisible(False)
self.hline.setPen(pen)
self._scene.addItem(self.vline)
self._scene.addItem(self.hline)
def __init__(self, shape):
QGraphicsLineItem.__init__(self)
StMove.__init__(self, shape)
self.allwaysshow = False
self.path = QPainterPath()
self.setFlag(QGraphicsItem.ItemIsSelectable, False)
self.pen = QPen(QColor(50, 100, 255), 1, QtCore.Qt.SolidLine,
QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)
self.pen.setCosmetic(True)
self.make_papath()
def generateData(self, canvas, lines, params):
scene = QGraphicsScene()
scene.setSceneRect(canvas)
group = scene.createItemGroup([])
for line in lines:
clone = QGraphicsLineItem(line)
clone.setLine(line.line())
clone.setPen(line.pen())
scene.addItem(clone)
group.addToGroup(clone)
pixmaps = []
for i in xrange(params.count):
pixmaps.append(self.generateRandom(scene, group, canvas, params))
return pixmaps
def __init__(self, startNode, endNode):
QGraphicsLineItem.__init__(self)
self.setPen(QPen())
self.startNode = startNode
self.endNode = endNode
self.startNode.addObserver(self)
startShape = self.startNode.mapToScene(self.startNode.shape())
p1 = closestPointTo(self.endNode, startShape)
self.setLine(QLineF(p1, self.endNode))
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QGraphicsLineItem(QLineF(mouseEvent.scenePos(),
mouseEvent.scenePos()))
self.line.setPen(QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def __init__(self, manager):
"""Summary
Args:
manager (TYPE): Description
"""
super(AbstractSliceTool, self).__init__(parent=manager.viewroot)
""" Pareting to viewroot to prevent orphan _line_item from occuring
"""
self.sgv = None
self.manager = manager
self._active = False
self._last_location = None
self._line_item = QGraphicsLineItem(self)
self._line_item.hide()
self._vhi = None
self.hide()
self.is_started = False
self.angles = [math.radians(x) for x in range(0, 360, 30)]
self.vectors = self.setVectors()
self.part_item = None
self.vhi_hint_item = QGraphicsEllipseItem(_DEFAULT_RECT, self)
self.vhi_hint_item.setPen(_MOD_PEN)
self.vhi_hint_item.setZValue(styles.ZPARTITEM)
def mousePressEvent(self, mouse_event):
if mouse_event.button() != Qt.LeftButton:
return
if self.my_mode == self.InsertItem:
x = mouse_event.scenePos().x() # // 50 * 50
y = mouse_event.scenePos().y() # // 50 * 50
item = self.insert_item(self.my_item_type, x, y)
self.itemInserted.emit(item.flume_component)
elif self.my_mode == self.InsertLine:
self.line = QGraphicsLineItem(QLineF(mouse_event.scenePos(),
mouse_event.scenePos()))
self.line.setPen(QPen(self.my_line_color, 2))
self.addItem(self.line)
elif self.my_mode == self.InsertText:
text_item = DiagramTextItem()
text_item.setFont(self.my_font)
text_item.setTextInteractionFlags(Qt.TextEditorInteraction)
text_item.setZValue(1000.0)
text_item.lostFocus.connect(self.editor_lost_focus)
# text_item.selectedChange.connect(self.itemSelected)
self.addItem(text_item)
text_item.setDefaultTextColor(self.my_text_color)
text_item.setPos(mouse_event.scenePos())
self.textInserted.emit(text_item)
else:
self.m_dragged = QGraphicsScene.itemAt(self, mouse_event.scenePos(), QTransform())
if self.m_dragged:
self.my_mode = self.MoveItem
self.m_drag_offset = mouse_event.scenePos() - self.m_dragged.pos()
super(DiagramScene, self).mousePressEvent(mouse_event)
class ParticipantItem(QGraphicsItem):
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def update_position(self, x_pos=-1, y_pos=-1):
if x_pos == -1:
x_pos = self.x_pos()
if y_pos == -1:
y_pos = self.line.line().y2()
self.text.setPos(x_pos - (self.text.boundingRect().width() / 2), 0)
self.line.setLine(x_pos, 30, x_pos, y_pos)
def x_pos(self):
return self.line.line().x1()
def width(self):
return self.boundingRect().width()
def refresh(self):
self.text.setPlainText("?" if not self.model_item else self.model_item.shortname)
if hasattr(self.model_item, "simulate") and self.model_item.simulate:
font = QFont()
font.setBold(True)
self.text.setFont(font)
self.text.setDefaultTextColor(Qt.darkGreen)
self.line.setPen(QPen(Qt.darkGreen, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
else:
self.text.setFont(QFont())
self.text.setDefaultTextColor(constants.LINECOLOR)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
def boundingRect(self):
return self.childrenBoundingRect()
def paint(self, painter, option, widget):
pass
def __init__(self, startNode, endNode):
QGraphicsLineItem.__init__(self)
self.setPen(QPen())
self.startNode = startNode
self.endNode = endNode
self.startNode.addObserver(self)
self.endNode.addObserver(self)
startShape = self.startNode.mapToScene(self.startNode.shape())
endShape = self.endNode.mapToScene(self.endNode.shape())
p1 = closestPointTo(endShape.boundingRect().center(), startShape)
p2 = closestPointTo(startShape.boundingRect().center(), endShape)
self.setLine(QLineF(p1, p2))
self.setFlags(QGraphicsItem.ItemIsSelectable)
def createOriginLine(self):
if self.originLine == None:
self.originLine = QGraphicsLineItem(self.midPointX, self.midPointY, self.graphicsOrigin.scenePos().x(),
self.graphicsOrigin.scenePos().y(), self)
else:
self.originLine.setLine(QLineF(self.midPointX, self.midPointY, self.graphicsOrigin.scenePos().x(),
self.graphicsOrigin.scenePos().y()))
myLine = self.originLine.line()
myLine.setLength(myLine.length() - StateGraphicsItem.NODE_WIDTH / 2)
self.originLine.setLine(myLine)
def drawNewFence(self, fps):
self.clearFencePoints()
prev_fp = None
for i in range(1, len(fps)):
if prev_fp is not None:
prev_x = prev_fp.lon
prev_y = -prev_fp.lat
mapped_x = fps[i].lon
mapped_y = -fps[i].lat
next_line = QGraphicsLineItem(prev_x, prev_y,
mapped_x, mapped_y, self.__fence_layer)
l_pen = QPen(QColor(0, 255, 0))
l_pen.setWidth(0.1)
next_line.setPen(l_pen)
self.__fence_layer.addToGroup(next_line)
prev_fp = fps[i]
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def __init__(self):
super().__init__()
self.center_x = 0
self.center_y = 0
self.radius = 1
self.now = datetime.utcfromtimestamp(0)
# build the clock face
self.circle = QGraphicsEllipseItem(self.root)
self.lines = []
for _ in range(0, 60):
self.lines.append(QGraphicsLineItem(self.root))
self.hours_hand = QGraphicsLineItem(self.root)
self.minutes_hand = QGraphicsLineItem(self.root)
self.seconds_hand = QGraphicsLineItem(self.root)
self.hand_circle = QGraphicsEllipseItem(self.root)
def moveTo(self, pos):
# data coordinates
oldX, oldY = self.pos.x(), self.pos.y()
x, y = pos.x(), pos.y()
line = QGraphicsLineItem(oldX, oldY, x, y)
line.setPen(QPen(QBrush(Qt.white), self.brushSize, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
self.scene.addItem(line)
self._hasMoved = True
# update bounding Box
if not self.bb.isValid():
self.bb = QRect(QPoint(oldX, oldY), QSize(1, 1))
# grow bounding box
self.bb.setLeft(min(self.bb.left(), max(0, x - self.brushSize // 2 - 1)))
self.bb.setRight(max(self.bb.right(), min(self.sliceRect[0] - 1, x + self.brushSize // 2 + 1)))
self.bb.setTop(min(self.bb.top(), max(0, y - self.brushSize // 2 - 1)))
self.bb.setBottom(max(self.bb.bottom(), min(self.sliceRect[1] - 1, y + self.brushSize // 2 + 1)))
# update/move position
self.pos = pos
def create_distance_pointer(self):
self.distance_pointer = QGraphicsLineItem()
pen = QPen()
pen.setWidthF(1.0)
pen.setStyle(Qt.DashDotLine)
color = Color.create_qcolor_from_rgb_tuple_f((1,0,0))
pen.setColor(color)
self.distance_pointer.setPen(pen)
self.distance_pointer.setZValue(1.0)
self.addToGroup(self.distance_pointer)
self.distance_label = QGraphicsSimpleTextItem()
self.distance_label.setZValue(1.0)
self.addToGroup(self.distance_label)
def onMouseMove_draw(self, imageview, event):
self._navIntr.onMouseMove_default(imageview, event)
o = imageview.scene().data2scene.map(QPointF(imageview.oldX, imageview.oldY))
n = imageview.scene().data2scene.map(QPointF(imageview.x, imageview.y))
# Draw temporary line for the brush stroke so the user gets feedback before the data is really updated.
pen = QPen(
QBrush(self._brushingCtrl._brushingModel.drawColor),
self._brushingCtrl._brushingModel.brushSize,
Qt.SolidLine,
Qt.RoundCap,
Qt.RoundJoin,
)
line = QGraphicsLineItem(o.x(), o.y(), n.x(), n.y())
line.setPen(pen)
imageview.scene().addItem(line)
line.setParentItem(imageview.scene().dataRectItem)
self._lineItems.append(line)
self._brushingCtrl._brushingModel.moveTo(imageview.mousePos)
def drawWPLine(self, wp1, wp2):
if wp1 is None or wp2 is None:
print("Error: Can't draw line for Null endpoint")
return
rad = self.__wp_diameter * 0.5
mapped_wp1_x = wp1.y - rad
mapped_wp1_y = -wp1.x
#tangential approach?
if (wp1.command == mavutil.mavlink.MAV_CMD_NAV_LOITER_TO_ALT
and wp1.param1 == 1.0):
l_rad = abs(self.__wp_loiter_radius)
if l_rad is not None:
dis = acs_math.gps_distance(wp1.x, wp1.y, wp2.x, wp2.y)
theta = math.degrees(math.atan(l_rad / dis))
#sign of self.__wp_loiter_radius indicates the direction of the
#loiter (negative is counter-clockwise, postive is clockwise)
#Also, the waypoint itself can override the default setting
#via param2
if ((wp1.param2 == 0 and self.__wp_loiter_radius > 0.0) or
wp1.param2 > 0.0):
theta = -theta
tan_dis = math.sqrt( dis * dis - l_rad * l_rad)
bearing = acs_math.gps_bearing(wp2.x, wp2.y, wp1.x, wp1.y)
(tan_wp_x, tan_wp_y) = acs_math.gps_newpos(wp2.x, wp2.y,
bearing - theta, tan_dis)
mapped_wp1_x = tan_wp_y - rad
mapped_wp1_y = -tan_wp_x
next_line = QGraphicsLineItem(mapped_wp1_x, mapped_wp1_y,
wp2.y - rad, -wp2.x, self.__mission_layer)
l_pen = QPen(QColor(255, 255, 255))
l_pen.setWidth(0.00002)
next_line.setPen(l_pen)
self.__mission_layer.addToGroup(next_line)
def createArrow(self):
rad = self._RADIUS
pen = QPen()
pen.setWidth(3)
color = QColor(Qt.blue)
color.setAlphaF(0.25)
pen.setBrush(color)
if self._virtual_helix.isEvenParity():
arrow = QGraphicsLineItem(rad, rad, 2*rad, rad, self)
else:
arrow = QGraphicsLineItem(0, rad, rad, rad, self)
arrow.setTransformOriginPoint(rad, rad)
arrow.setZValue(400)
arrow.setPen(pen)
self.arrow = arrow
self.arrow.hide()
def add_dummy_line_for_margin(self):
height = self.scene.height()
width = self.scene.width()
pen = QPen()
pen.setStyle(Qt.NoPen)
dummy_line_a= QGraphicsLineItem(0, height, 0, height + 100)
dummy_line_b = QGraphicsLineItem(width, 0, width + 100, 0)
dummy_line_a.setPen(pen)
dummy_line_b.setPen(pen)
self.scene.addItem(dummy_line_a)
self.scene.addItem(dummy_line_b)
def __init__(self, radius, rect, virtual_helix_item, is_active):
"""Summary
Args:
radius (TYPE): Description
rect (TYPE): Description
virtual_helix_item (VirtualHelixItem): Description
is_active (TYPE): Description
"""
super(PreXoverItemGroup, self).__init__(rect, virtual_helix_item)
self._radius = radius
self._rect = rect
self.virtual_helix_item = virtual_helix_item
self.model_part = virtual_helix_item.part()
self.id_num = virtual_helix_item.idNum()
self.is_active = is_active
self.active_wedge_gizmo = WedgeGizmo(radius, rect, self)
self.fwd_prexover_items = fwd_pxis = {}
self.rev_prexover_items = rev_pxis = {}
self._colors = self._getColors()
self.addItems()
self.setPen(getNoPen())
z = styles.ZPXIGROUP + 10 if is_active else styles.ZPXIGROUP
self.setZValue(z)
self.setTransformOriginPoint(rect.center())
bpr, tpr, eulerZ = virtual_helix_item.getProperty(['bases_per_repeat',
'turns_per_repeat',
'eulerZ'])
self.setRotation(-eulerZ) # add 180
# for baseNearestPoint
fwd_pos, rev_pos = [], []
step_size = self.virtual_helix_item.getProperty('bases_per_repeat')
for i in range(int(step_size)):
fwd_pos.append((fwd_pxis[i].scenePos().x(),
fwd_pxis[i].scenePos().y()))
rev_pos.append((rev_pxis[i].scenePos().x(),
rev_pxis[i].scenePos().y()))
self.fwd_pos_array = np.asarray(fwd_pos)
self.rev_pos_array = np.asarray(rev_pos)
self.baseNearLine = QGraphicsLineItem(self)
self.baseNearLine.setPen(getPenObj("#000000", 0.25, capstyle=Qt.RoundCap))
def __init__(self, rect, parent=None):
# setup DNA line
super(QGraphicsEllipseItem, self).__init__(rect, parent)
self._parent = parent
self.setPen(QPen(Qt.NoPen))
self.setBrush(_HOVER_BRUSH)
self.setAcceptHoverEvents(True)
# hover marker
self._hoverLine = QGraphicsLineItem(-_ROTARY_DELTA_WIDTH/2, 0, _ROTARY_DELTA_WIDTH/2, 0, self)
self._hoverLine.setPen(QPen(QColor(204, 0, 0), .5))
self._hoverLine.hide()
self._startPos = None
self._startAngle = None # save selection start
self._clockwise = None
self.dummy = RotaryDialDeltaItem(0, 0, parent)
self.dummy.hide()
def __init__(self):
super().__init__()
self.model = CalendarModel()
self.cursor_pos = None
self.cursor = QGraphicsRectItem(self.root)
self.header = QGraphicsSimpleTextItem(self.root)
self.weekdays = []
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
for day in days:
self.weekdays.append(QGraphicsSimpleTextItem(day, self.root))
self.header_line = QGraphicsLineItem(self.root)
self.days = []
for _ in range(0, 6 * 7):
self.days.append(QGraphicsSimpleTextItem(self.root))
def __init__(self, origX, origY, perCell, n): super(GridItem, self).__init__(); length = perCell*n/2; pen = QPen(Qt.DashLine); pen.setColor(QColor(230, 230, 230)) pen.setWidth(0); x1, y1, x2, y2 = origX-length, origY-length, origX-length, origY+length for i in range(1, n): line = QGraphicsLineItem(x1, y1, x2, y2, self) line.setPen(pen) x1, y1, x2, y2 = x1+perCell, y1, x2+perCell, y2 x1, y1, x2, y2 = origX-length, origY-length, origX+length, origY-length for i in range(1, n): line = QGraphicsLineItem(x1, y1, x2, y2, self) line.setPen(pen) x1, y1, x2, y2 = x1, y1+perCell, x2, y2+perCell
def create_axis(self):
bounding_end = abs(self.dimension_analysis.bounding_rect[3])
bounding_start = abs(self.dimension_analysis.bounding_rect[2])
pen = QPen()
pen.setWidthF(0.5)
# horizontal line
self.graph_zero[0] = self.position[0] + self.margin - self.line_extend
self.graph_zero[1] = self.position[1] + bounding_start * self.height_multiplier + self.margin
self.graph_end[0] = self.graph_zero[0] + self.content_width + self.line_extend
self.graph_end[1] = self.graph_zero[1]
line_item_horizontal = QGraphicsLineItem(self.graph_zero[0], self.graph_zero[1], self.graph_end[0], self.graph_end[1])
line_item_horizontal.setPen(pen)
self.addToGroup(line_item_horizontal)
center = (self.graph_zero[0] + self.line_extend), self.graph_zero[1]
y_top = center[1] - (bounding_start*self.height_multiplier)
y_bottom = center[1]+(bounding_end*self.height_multiplier)
line_item_vertical = QGraphicsLineItem(center[0], y_top, center[0], y_bottom)
line_item_vertical.setPen(pen)
self.addToGroup(line_item_vertical)
def create_axis(self):
counter = 0
while self.surface[0][counter] is None: #get the first tile
counter += 1
# determining the distance from left side
left_coordinate = abs(self.surface[0][counter].point.X())
distance = (left_coordinate + counter * self.sampling_distance) * self.height_multiplier
pen = QPen()
pen.setWidthF(0.5)
self.graph_zero[0] = self.position[0] + self.margin - self.line_extend
self.graph_zero[1] = self.position[1] + distance + self.margin
self.graph_end[0] = self.graph_zero[0] + self.content_width + self.line_extend
self.graph_end[1] = self.graph_zero[1]
line_item_horizontal = QGraphicsLineItem(self.graph_zero[0], self.graph_zero[1], self.graph_end[0], self.graph_end[1])
line_item_horizontal.setPen(pen)
self.addToGroup(line_item_horizontal)
center = (self.graph_zero[0] + self.line_extend), self.graph_zero[1]
y_top = center[1] - distance
y_bottom = self.position[1] + self.margin + len(self.surface[0]) * self.sampling_distance * self.height_multiplier
line_item_vertical = QGraphicsLineItem(center[0], y_top, center[0], y_bottom)
line_item_vertical.setPen(pen)
self.addToGroup(line_item_vertical)
def add_dummy_line(self):
pen = QPen()
pen.setStyle(Qt.NoPen)
dummy_line = QGraphicsLineItem(0, 0, 0, 100)
dummy_line.setPen(pen)
self.scene.addItem(dummy_line)
class PreXoverItemGroup(QGraphicsEllipseItem):
"""Summary
Attributes:
active_wedge_gizmo (TYPE): Description
fwd_prexover_items (dict): Description
HUE_FACTOR (float): Description
id_num (TYPE): Description
is_active (TYPE): Description
model_part (Part): The model part
rev_prexover_items (dict): Description
SPIRAL_FACTOR (float): Description
virtual_helix_item (VirtualHelixItem): Description
"""
HUE_FACTOR = 1.6
SPIRAL_FACTOR = 0.4
def __init__(self, radius, rect, virtual_helix_item, is_active):
"""Summary
Args:
radius (TYPE): Description
rect (TYPE): Description
virtual_helix_item (VirtualHelixItem): Description
is_active (TYPE): Description
"""
super(PreXoverItemGroup, self).__init__(rect, virtual_helix_item)
self._radius = radius
self._rect = rect
self.virtual_helix_item = virtual_helix_item
self.model_part = virtual_helix_item.part()
self.id_num = virtual_helix_item.idNum()
self.is_active = is_active
self.active_wedge_gizmo = WedgeGizmo(radius, rect, self)
self.fwd_prexover_items = fwd_pxis = {}
self.rev_prexover_items = rev_pxis = {}
self._colors = self._getColors()
self.addItems()
self.setPen(getNoPen())
z = styles.ZPXIGROUP + 10 if is_active else styles.ZPXIGROUP
self.setZValue(z)
self.setTransformOriginPoint(rect.center())
bpr, tpr, eulerZ = virtual_helix_item.getProperty(['bases_per_repeat',
'turns_per_repeat',
'eulerZ'])
self.setRotation(-eulerZ) # add 180
# for baseNearestPoint
fwd_pos, rev_pos = [], []
step_size = self.virtual_helix_item.getProperty('bases_per_repeat')
for i in range(int(step_size)):
fwd_pos.append((fwd_pxis[i].scenePos().x(),
fwd_pxis[i].scenePos().y()))
rev_pos.append((rev_pxis[i].scenePos().x(),
rev_pxis[i].scenePos().y()))
self.fwd_pos_array = np.asarray(fwd_pos)
self.rev_pos_array = np.asarray(rev_pos)
self.baseNearLine = QGraphicsLineItem(self)
self.baseNearLine.setPen(getPenObj("#000000", 0.25, capstyle=Qt.RoundCap))
# end def
def mousePressEvent(self, event):
print("PreXoverGroup press")
def mouseMoveEvent(self, event):
print("PreXoverGroup move")
def mouseReleaseEvent(self, event):
print("PreXoverGroup release")
### ACCESSORS ###
def partItem(self):
"""Summary
Returns:
TYPE: Description
"""
return self.virtual_helix_item.partItem()
# end def
def getItem(self, is_fwd, step_idx):
"""Summary
Args:
is_fwd (TYPE): Description
step_idx (int): the base index within the virtual helix
Returns:
TYPE: Description
"""
items = self.fwd_prexover_items if is_fwd else self.rev_prexover_items
if step_idx in items:
return items[step_idx]
else:
return None
# end def
def getItemIdx(self, is_fwd, idx):
"""Summary
Args:
is_fwd (TYPE): Description
idx (int): the base index within the virtual helix
Returns:
TYPE: Description
"""
step_size = self.virtual_helix_item.getProperty('bases_per_repeat')
return self.getItem(is_fwd, idx % step_size)
# end def
### EVENT HANDLERS ###
### PRIVATE SUPPORT METHODS ###
def _getColors(self):
"""Summary
Returns:
TYPE: Description
"""
step_size = int(self.virtual_helix_item.getProperty('bases_per_repeat'))
hue_scale = step_size*self.HUE_FACTOR
return [QColor.fromHsvF(i / hue_scale, 0.75, 0.8).name() for i in range(step_size)]
# end def
### PUBLIC SUPPORT METHODS ###
def addItems(self):
"""Summary
"""
radius = self._radius
step_size, bases_per_turn, tpb, mgroove = self.virtual_helix_item.getAngularProperties()
# print("TPB", tpb, step_size)
iw = PXI_PP_ITEM_WIDTH
spiral_factor = self.SPIRAL_FACTOR
colors = self._colors
ctr = self.mapToParent(self._rect).boundingRect().center()
x = ctr.x() + radius - PXI_PP_ITEM_WIDTH
y = ctr.y()
# tpb = -tpb
# Qt +angle is Clockwise (CW), model +angle is CCW
mgroove = -mgroove
fwd_pxis = self.fwd_prexover_items
rev_pxis = self.rev_prexover_items
for i in range(int(step_size)):
inset = i*spiral_factor # spiral layout
fwd = PreXoverItem(i, tpb, step_size, colors[i], self, is_fwd=True)
rev = PreXoverItem(i, tpb, step_size, colors[-1 - i], self, is_fwd=False)
fwd.setPos(x - inset, y)
rev.setPos(x - inset, y)
fwd.setTransformOriginPoint((-radius + iw + inset), 0)
rev.setTransformOriginPoint((-radius + iw + inset), 0)
fwd.setRotation(round(i*tpb % 360, 3))
rev.setRotation(round((i*tpb + mgroove) % 360, 3))
fwd.setBondLineLength(inset + iw)
rev.setBondLineLength(inset + iw)
fwd_pxis[i] = fwd
rev_pxis[i] = rev
for i in range(int(step_size) - 1):
fwd, next_fwd = fwd_pxis[i], fwd_pxis[i + 1]
j = (step_size - 1) - i
rev, next_rev = rev_pxis[j], rev_pxis[j - 1]
fwd.set3pItem(next_fwd)
rev.set3pItem(next_rev)
next_fwd.set5pItem(fwd)
next_rev.set5pItem(rev)
# end def
def baseNearestPoint(self, is_fwd, scene_pos):
"""Summary
Args:
is_fwd (bool): used to check fwd or rev lists.
scene_pos (QPointF): scene coordinate position
Returns:
PreXoverItem: base nearest to position
"""
pos_array = self.fwd_pos_array if is_fwd else self.rev_pos_array
dist_2 = np.sum((pos_array - (scene_pos.x(), scene_pos.y()))**2, axis=1)
near_idx = np.argmin(dist_2)
near_pxi = self.fwd_prexover_items[near_idx] if is_fwd else self.rev_prexover_items[near_idx]
# Draw a line
p1 = self.mapFromScene(scene_pos.x(), scene_pos.y())
p2 = self.mapFromScene(near_pxi.scenePos())
line = QLineF(p1, p2)
self.baseNearLine.setLine(line)
def destroyItem(self):
"""Summary
"""
fpxis = self.fwd_prexover_items
rpxis = self.rev_prexover_items
scene = self.scene()
for i in range(len(fpxis)):
x = fpxis.pop(i)
x.destroyItem()
x = rpxis.pop(i)
x.destroyItem()
self.virtual_helix_item = None
self.model_part = None
scene.removeItem(self.active_wedge_gizmo)
self.active_wedge_gizmo = None
scene.removeItem(self)
# end def
def updateTurnsPerRepeat(self):
"""Summary
"""
step_size, bases_per_turn, tpb, mgroove = self.virtual_helix_item.getAngularProperties()
mgroove = -mgroove
fpxis = self.fwd_prexover_items
rpxis = self.rev_prexover_items
for i in range(int(step_size)):
fwd = self.fwd_prexover_items[i]
rev = self.rev_prexover_items[i]
fwd.setRotation(round((i*tpb) % 360, 3))
rev.setRotation(round((i*tpb + mgroove) % 360, 3))
for i in range(int(step_size) - 1):
fwd, next_fwd = fpxis[i], fpxis[i + 1]
j = (step_size - 1) - i
rev, next_rev = rpxis[j], rpxis[j - 1]
fwd.set3pItem(next_fwd)
rev.set3pItem(next_rev)
next_fwd.set5pItem(fwd)
next_rev.set5pItem(rev)
# end def
def partCrossoverSpanAngle(self):
"""
Returns:
int: Crossover span angle from Part.
"""
return self.virtual_helix_item.partCrossoverSpanAngle()
def updateModelActiveBaseInfo(self, pre_xover_info):
"""Notify model of pre_xover_item hover state.
"""
self.model_part.setActiveBaseInfo(pre_xover_info)
def __init__(self, source, dest):
# Parent constructor(s)
QGraphicsLineItem.__init__(self)
self.source = source
self.dest = dest
class DiagramScene(QGraphicsScene):
InsertItem, InsertLine, InsertText, MoveItem = range(4)
itemInserted = pyqtSignal(DiagramItem)
textInserted = pyqtSignal(QGraphicsTextItem)
itemSelected = pyqtSignal(QGraphicsItem)
def __init__(self, itemMenu, parent=None):
super(DiagramScene, self).__init__(parent)
self.myItemMenu = itemMenu
self.myMode = self.MoveItem
self.myItemType = DiagramItem.Step
self.line = None
self.textItem = None
self.myItemColor = Qt.white
self.myTextColor = Qt.black
self.myLineColor = Qt.black
self.myFont = QFont()
def setLineColor(self, color):
self.myLineColor = color
if self.isItemChange(Arrow):
item = self.selectedItems()[0]
item.setColor(self.myLineColor)
self.update()
def setTextColor(self, color):
self.myTextColor = color
if self.isItemChange(DiagramTextItem):
item = self.selectedItems()[0]
item.setDefaultTextColor(self.myTextColor)
def setItemColor(self, color):
self.myItemColor = color
if self.isItemChange(DiagramItem):
item = self.selectedItems()[0]
item.setBrush(self.myItemColor)
def setFont(self, font):
self.myFont = font
if self.isItemChange(DiagramTextItem):
item = self.selectedItems()[0]
item.setFont(self.myFont)
def setMode(self, mode):
self.myMode = mode
def setItemType(self, type):
self.myItemType = type
def editorLostFocus(self, item):
cursor = item.textCursor()
cursor.clearSelection()
item.setTextCursor(cursor)
if item.toPlainText():
self.removeItem(item)
item.deleteLater()
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QGraphicsLineItem(QLineF(mouseEvent.scenePos(),
mouseEvent.scenePos()))
self.line.setPen(QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def mouseMoveEvent(self, mouseEvent):
if self.myMode == self.InsertLine and self.line:
newLine = QLineF(self.line.line().p1(), mouseEvent.scenePos())
self.line.setLine(newLine)
elif self.myMode == self.MoveItem:
super(DiagramScene, self).mouseMoveEvent(mouseEvent)
def mouseReleaseEvent(self, mouseEvent):
if self.line and self.myMode == self.InsertLine:
startItems = self.items(self.line.line().p1())
if len(startItems) and startItems[0] == self.line:
startItems.pop(0)
endItems = self.items(self.line.line().p2())
if len(endItems) and endItems[0] == self.line:
endItems.pop(0)
self.removeItem(self.line)
self.line = None
if len(startItems) and len(endItems) and \
isinstance(startItems[0], DiagramItem) and \
isinstance(endItems[0], DiagramItem) and \
startItems[0] != endItems[0]:
startItem = startItems[0]
endItem = endItems[0]
arrow = Arrow(startItem, endItem)
arrow.setColor(self.myLineColor)
startItem.addArrow(arrow)
endItem.addArrow(arrow)
arrow.setZValue(-1000.0)
self.addItem(arrow)
arrow.updatePosition()
self.line = None
super(DiagramScene, self).mouseReleaseEvent(mouseEvent)
def isItemChange(self, type):
for item in self.selectedItems():
if isinstance(item, type):
return True
return False
