def __init__(self, parent: QtWidgets.QGraphicsItem = None):
super().__init__(parent)
self.setMinimumSize(640, 320)
self._xaxis = QtCharts.QValueAxis()
self._xaxis.setVisible(False)
self.xaxis = NiceValueAxis()
self.xaxis.setTitleText("Size (nm)")
self.xaxis.setGridLineVisible(False)
self.yaxis = QtCharts.QValueAxis()
self.yaxis.setGridLineVisible(False)
self.yaxis.setTitleText("Count")
self.yaxis.setLabelFormat("%d")
self.addAxis(self._xaxis, QtCore.Qt.AlignBottom)
self.addAxis(self.xaxis, QtCore.Qt.AlignBottom)
self.addAxis(self.yaxis, QtCore.Qt.AlignLeft)
self.series = QtCharts.QBarSeries()
self.series.setBarWidth(0.9)
self.addSeries(self.series)
self.series.attachAxis(self._xaxis)
self.series.attachAxis(self.yaxis)
self.set = QtCharts.QBarSet("sizes")
self.set.setColor(QtCore.Qt.black)
self.set.hovered.connect(self.barHovered)
self.series.append(self.set)
self.fit = QtCharts.QSplineSeries()
self.fit.setPen(QtGui.QPen(QtGui.QColor(255, 172, 0), 2.0))
self.addSeries(self.fit)
self.fit.attachAxis(self.xaxis)
self.fit.attachAxis(self.yaxis)
self.label_fit = QtWidgets.QGraphicsTextItem(self)
self.label_fit.setFont(QtGui.QFont("sans", 12, italic=False))
self.label_fit.setZValue(99)
self.label_fit.setDefaultTextColor(QtGui.QColor(255, 172, 0))
self.xaxis.rangeChanged.connect(self.updateFitLabelPos)
self.label_hovered = QtWidgets.QGraphicsTextItem(self)
self.plotAreaChanged.connect(self.updateHoveredLabelPos)
self.vlines: List[QtCharts.QLineSeries] = []
# Clean legend
self.legend().setMarkerShape(QtCharts.QLegend.MarkerShapeFromSeries)
self.legend().markers(self.series)[0].setVisible(False)
def __init__(self, parent, index):
super().__init__()
self.color = (255, 0, 0)
self._layout = minimized_layout
self._input_items = {}
self._output_items = {}
self.painter = minimized_painter
self.inputs = [PortItem(OutPort(parent.rtl, index, 'dummy'), self)]
port_text = QtWidgets.QGraphicsTextItem('dummy', self)
self._input_items[self.inputs[0]] = port_text
self.outputs = []
self._text_item = QtWidgets.QGraphicsTextItem('', self)
self.layout()
def _add_port(self, port, display_name=True):
port_item = PortItem(port, self)
port_item.display_name = display_name
text = QtWidgets.QGraphicsTextItem(port_item.name, self)
text.font().setPointSize(8)
text.setFont(text.font())
# text.setVisible(display_name)
if isinstance(port, InPort):
port_node_name = f'i{len(self._input_items)}'
self.layout_graph.add_node(port_node_name,
label='',
width=1 / 72,
height=1 / 72)
self._input_items[port_item] = text
else:
port_node_name = f'o{len(self._output_items)}'
self.layout_graph.add_node(port_node_name,
label='',
width=1 / 72,
height=1 / 72)
self._output_items[port_item] = text
return port_item
def __init__(self,
name,
layout,
parent=None,
model=None,
graph=Inject('gearbox/graph')):
super().__init__(name)
self._layout = layout
self.parent = parent
self.graph = graph
self.model = model
self.layout_graph = pgv.AGraph(directed=True,
rankdir='LR',
splines='true',
strict=False)
self.layout_pipe_map = {}
self._text_item = QtWidgets.QGraphicsTextItem(self.name, self)
self._input_items = {}
self._output_items = {}
self._nodes = []
self.pipes = []
self.minimum_size = (80, 80)
self.layout_vertices = {}
self.layout_root_vertices = []
self.layout_edges = []
self.layout_inport_vertices = {}
self.layout_outport_vertices = {}
self.collapsed = False if parent is None else True
self.layers = []
def __init__(self):
super(GraphicsView, self).__init__()
self.setMouseTracking(True)
#self.scene = QtWidgets.QGraphicsScene()
self.scene = GraphicsScene()
self.st = self.scene.addItem(
QtWidgets.QGraphicsTextItem("Hello, world!"))
self.setScene(self.scene)
pub.subscribe(self.addState, "CONTROLLER_ADD_STATE")
pub.subscribe(self.addTransition, "CONTROLLER_ADD_TRANSITION")
def __init__(self, title: str = None, parent: QtWidgets.QWidget = None):
super().__init__(QtCharts.QChart(), theme=light_theme, parent=parent)
self.setRubberBand(QtCharts.QChartView.RectangleRubberBand)
self.setMinimumSize(QtCore.QSize(640, 480))
self.setRenderHint(QtGui.QPainter.Antialiasing)
if title is not None:
self.chart().setTitle(title)
self.chart().legend().hide()
self.xaxis = QtCharts.QValueAxis()
self.yaxis = QtCharts.QValueAxis()
self.addAxis(self.xaxis, QtCore.Qt.AlignBottom)
self.addAxis(self.yaxis, QtCore.Qt.AlignLeft)
self.label_series = QtCharts.QScatterSeries()
self.label_series.append(0, 0)
self.label_series.setBrush(
QtGui.QBrush(QtCore.Qt.black, QtCore.Qt.NoBrush))
self.label_series.setPointLabelsFormat("(@xPoint, @yPoint)")
self.label_series.setPointLabelsColor(light_theme["text"])
self.label_series.setVisible(False)
self.chart().addSeries(self.label_series)
self.label_series.attachAxis(self.xaxis)
self.label_series.attachAxis(self.yaxis)
self.line = QtCharts.QLineSeries()
self.line.setPen(QtGui.QPen(sequential[1], 1.5))
# self.line.setColor(QtCore.Qt.red)
self.chart().addSeries(self.line)
self.line.attachAxis(self.xaxis)
self.line.attachAxis(self.yaxis)
self.series = QtCharts.QScatterSeries()
self.series.setPen(QtGui.QPen(sequential[1], 1.5))
self.series.setBrush(QtGui.QBrush(highlights[1]))
self.series.setMarkerSize(12)
self.chart().addSeries(self.series)
self.series.attachAxis(self.xaxis)
self.series.attachAxis(self.yaxis)
self.series.hovered.connect(self.showPointPosition)
self.label = QtWidgets.QGraphicsTextItem()
self.label.setPlainText("hats")
self.label.setFlag(QtWidgets.QGraphicsItem.ItemIgnoresTransformations)
self.chart().scene().addItem(self.label)
self.chart().plotAreaChanged.connect(self.moveLabel)
def start_clicked(self):
if not self.textItem:
self.textItem = QtWidgets.QGraphicsTextItem()
self.textItem.setPos(
0,
self.centralwidget.frameGeometry().height() // 2)
self.textItem.setPlainText('<-- @ _ @ -->')
self.textItem.setTextWidth(200)
self.sceneView.addItem(self.textItem)
if not self.timer.isActive():
self.timer.start(10)
def __init__(self, name='node', parent=None):
super(NodeItem, self).__init__(name, parent)
pixmap = QtGui.QPixmap(ICON_NODE_BASE)
pixmap = pixmap.scaledToHeight(NODE_ICON_SIZE,
QtCore.Qt.SmoothTransformation)
self._properties['icon'] = ICON_NODE_BASE
self._icon_item = QtWidgets.QGraphicsPixmapItem(pixmap, self)
self._text_item = QtWidgets.QGraphicsTextItem(self.name, self)
self._x_item = XDisabledItem(self, 'node disabled')
self._input_text_items = {}
self._output_text_items = {}
self._input_items = []
self._output_items = []
self._widgets = OrderedDict()
def __init__(self, parent, cmdp, state):
pg.GraphicsObject.__init__(self, parent)
self._parent = parent
self._cmdp = cmdp
self._log = logging.getLogger('%s.%s' % (__name__, state['x']))
self._move_start_point = None
y = state.get('y')
if y is not None:
y = float(y)
my_id = state.get('id')
if my_id is None: # assign an id
my_id = id(self)
while my_id in _registry:
my_id += 1
elif my_id in _registry:
raise RuntimeError(f'id {my_id} already in annotation registry')
self._state = {
'id': my_id,
'signal_name': state['signal_name'],
'x': float(state['x']),
'y': y,
'group_id': 0,
'text': state.get('text'),
'text_visible': True,
'size': state.get('size', 6),
}
_registry[my_id] = weakref.ref(self)
self._pathItem = QtWidgets.QGraphicsPathItem()
self._pathItem.setParentItem(self)
self._text_item = QtWidgets.QGraphicsTextItem(self)
self._text_item.setParentItem(self)
self._text_item.setVisible(bool(self._state['text_visible']))
self.group_id = state.get('group_id', 0)
self._lastTransform = None
self._lastScene = None
self._fill = pg.mkBrush(None)
self._border = pg.mkPen(None)
self.group_id = self._state['group_id']
self.setPos(self._state['x'], 0.0)
self._z_value_set()
self.text = self._state['text']
self._update_colors()
self.prepareGeometryChange()
def __init__(self, parent=None, field=None, units=None, cmdp=None):
pg.GraphicsWidget.__init__(self, parent=parent)
self._field = field
self._units = units
self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
self._label = QtWidgets.QGraphicsTextItem(self)
self._label.setVisible(True)
self._label.document().setUseDesignMetrics(True)
self._value_cache = None
self._cmdp = cmdp
labels = single_stat_to_api(-0.000000001, 0.000001, -0.001, 0.001, self._units)
self.data_update(labels)
self._resize()
self.data_clear()
cmdp.subscribe('Widgets/Waveform/Statistics/font-color', self._on_font_color, update_now=True)
pg.GraphicsWidget.show(self)
def draw_pieces(self):
for item in self.scenePlayerA.items():
self.scenePlayerA.removeItem(item)
if self.board.firstSize > 3 or self.board.secondSize > 3 or self.board.thirdSize > 3:
space_size = 23
font_size = 13
distance_from_edge = 30
else:
space_size = 40
font_size = 20
distance_from_edge = 50
for i in range(len(self.board.pieces)):
for j in range(len(self.board.pieces[i])):
if self.board.pieces[i][j].value != 0:
self.board.pieces[i][j].setPos(
QtCore.QPointF(
space_size * j + distance_from_edge,
space_size * i * np.sqrt(3) + distance_from_edge))
self.scenePlayerA.addItem(self.board.pieces[i][j])
if self.board.pieces[i][j].value != 1:
font = QtGui.QFont()
font.setPixelSize(font_size)
font.setBold(True)
text = QtWidgets.QGraphicsTextItem()
text.setPlainText(str(self.board.pieces[i][j].value))
text.setFont(font)
text.setPos(
QtCore.QPointF(
space_size * j + distance_from_edge -
text.boundingRect().size().width() / 2,
space_size * i * np.sqrt(3) +
distance_from_edge -
text.boundingRect().size().height() / 2))
self.scenePlayerA.addItem(text)
def add_output(self, name='output', multi_port=False, display_name=True):
"""
Args:
name (str): name for the port.
multi_port (bool): allow multiple connections.
display_name (bool): display the port name.
Returns:
PortItem: output item widget
"""
port = PortItem(self)
port.name = name
port.port_type = OUT_PORT
port.multi_connection = multi_port
port.display_name = display_name
text = QtWidgets.QGraphicsTextItem(port.name, self)
text.font().setPointSize(8)
text.setFont(text.font())
text.setVisible(display_name)
self._output_text_items[port] = text
self._output_items.append(port)
if self.scene():
self.post_init()
return port
def plot_all(self, section):
# original way of plotting all
self.section = section
self.clear_scene()
# unpack geometry properties
X = self.section.get_X()
Y = self.section.get_Y()
T = self.section.get_thick()
centreX, centreY = self.section.get_centre()
wallAngles = self.section.get_angles()
# connect itemChange signal with method
# scene.changed.connect(self.node_moved)
# self.graphicsViewGeometry.scene().changed.connect(self.node_moved)
# scene.blockSignals(True)
# self.graphicsViewGeometry.blockSignals(True)
# Styles
bold_pencil = QtGui.QPen(QtCore.Qt.DashLine)
bold_pencil.setColor(QtCore.Qt.black)
bold_pencil.setWidth(10)
no_pencil = QtGui.QPen(QtCore.Qt.NoPen)
thin_pencil = QtGui.QPen(QtCore.Qt.black) # create a black pen
blue_fill = QtGui.QBrush(QtCore.Qt.blue) # create a blue brush
grey_fill = QtGui.QBrush(
QtCore.Qt.lightGray) # create a light gray brush
font = QtGui.QFont()
font.setPixelSize(120)
font.setBold(False)
font.setFamily("Calibri")
# Initiate item lists
shade_rects = []
centre_lines = []
node_circles = []
# node_rects = []
node_texts = []
# Loop over geometry nodes to preb. for geometry plots
for i in range(len(X)):
X1, Y1 = X[i], Y[i] # start node
if i + 1 == len(X): # if last node
X2, Y2 = X[0], Y[0] # end node
else:
X2, Y2 = X[i + 1], Y[i + 1]
# prep. shaded geometry Periphery
PX1 = X1 + T[i] / 2 * math.sin(-wallAngles[i])
PY1 = Y1 + T[i] / 2 * math.cos(-wallAngles[i])
PX2 = X1 - T[i] / 2 * math.sin(-wallAngles[i])
PY2 = Y1 - T[i] / 2 * math.cos(-wallAngles[i])
PX3 = X2 - T[i] / 2 * math.sin(-wallAngles[i])
PY3 = Y2 - T[i] / 2 * math.cos(-wallAngles[i])
PX4 = X2 + T[i] / 2 * math.sin(-wallAngles[i])
PY4 = Y2 + T[i] / 2 * math.cos(-wallAngles[i])
rect = QtGui.QPolygonF()
rect.append(QtCore.QPointF(PX1, -PY1))
rect.append(QtCore.QPointF(PX2, -PY2))
rect.append(QtCore.QPointF(PX3, -PY3))
rect.append(QtCore.QPointF(PX4, -PY4))
shade_rects.append(rect)
# # add outline on top
# scene.addLine(QtCore.QLineF(PX1, -PY1, PX2, -PY2), thin_pencil)
# scene.addLine(QtCore.QLineF(PX2, -PY2, PX3, -PY3), thin_pencil)
# scene.addLine(QtCore.QLineF(PX3, -PY3, PX4, -PY4), thin_pencil)
# scene.addLine(QtCore.QLineF(PX4, -PY4, PX1, -PY1), thin_pencil)
# prep. centre line
line = QtCore.QLineF(X1, -Y1, X2, -Y2) # x pos. right, y pos. down
centre_lines.append(line)
# preb. node circles
radi = 0.01 * max([max(X) - min(X),
max(Y) - min(Y)]) # radius of node circles
# circle = QtWidgets.QGraphicsEllipseItem(X1 - radi, -(Y1 + radi), radi * 2.0, radi * 2.0)
# circle = MyEllipse(X1 - radi, -(Y1 + radi), radi * 2.0, radi * 2.0, self, self.section, i)
circle = MyEllipse(X1 - radi, -(Y1 + radi), radi * 2.0, radi * 2.0)
circle.setAcceptHoverEvents(True)
circle.set_wall_id(i)
circle.setPen(thin_pencil)
circle.setBrush(blue_fill)
circle.node_moved.connect(
self.update_section
) # call update_section method if a node_moved signal is received
# circle.setZValue(10) # higher Z values will always be drawn on top of lower Z values
node_circles.append(circle)
# preb. node texts
point = QtCore.QPointF(X1, -Y1)
text = QtWidgets.QGraphicsTextItem()
text.setPos(point)
text.setFont(font)
text.setPlainText("Node " + str(i + 1))
# text.setZValue(8) # higher Z values will always be drawn on top of lower Z values
node_texts.append(text)
# plot the shaded rectangles
for rect in shade_rects:
self.scene.addPolygon(rect, pen=no_pencil, brush=grey_fill)
# plot centre lines
for line in centre_lines:
self.scene.addLine(line, bold_pencil)
# plot node circles
for circle in node_circles:
self.scene.addItem(circle)
# plot node texts
for text in node_texts:
self.scene.addItem(text)
# plot centre text
point = QtCore.QPointF(centreX, -centreY)
text = QtWidgets.QGraphicsTextItem()
text.setPlainText("CG")
text.setFont(font)
text.setPos(point)
self.scene.addItem(text)
# fit view to make sure that QGraphics view have no scrollbars
self.fitInView(self.scene.sceneRect(), QtCore.Qt.KeepAspectRatio)
self.scene.mousePressEvent = self.scene_mousePressEvent # overrule QGraphicsSceneEvent
