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 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): 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