def paintmap(self, surface):
ww = surface.window().width()
wh = surface.window().height()
self.vb.setMaximum(self.qimg.height() - (wh // self.line.height))
self.line.x_map = ww - 32
r = QRect(self.line.x_map, 2, 32, wh - 4)
surface.drawImage(r, self.qimg)
factor = wh / self.qimg.height()
pen = surface.pen()
p = QPen(Qt.white)
p.setCapStyle(Qt.RoundCap)
p.setWidth(2)
surface.setPen(p)
l0 = self.vb.value() * factor
l1 = l0 + (wh // self.line.height) * factor
pad = 4
p1 = QPointF(self.line.x_map - pad, l0)
p2 = QPointF(self.line.x_map - pad, l1)
if l1 - l0 > 4:
p.setWidth(2)
surface.drawLine(p1, p2)
surface.drawLine(p1, QPointF(self.line.x_map, l0))
surface.drawLine(p2, QPointF(self.line.x_map, l1))
else:
p.setWidth(4)
surface.drawLine(p1, p2)
surface.setPen(pen)
def from_p1(self, p1: QPointF = QPointF(0.0, 0.0), tmax: float = 1.0):
self.idx: int = 0
self.time: float = 0.0
self.easing = QEasingCurve.Type.Linear
self.time_max: None | float = tmax
self.pos = QPointF(p1)
self.frames: List[QPointF] = [p1]
def input_to_graphics_item(input_stream: QDataStream, item: QGraphicsItem):
# Type
pos = QPointF()
scale: float
rotation: float
transform = QTransform()
transform_op = QPointF()
flags = QGraphicsItem.GraphicsItemFlags()
is_enabled: bool
is_selected: bool
z_value: float
# Read
input_stream >> pos
scale = input_stream.readFloat()
rotation = input_stream.readFloat()
input_stream >> transform
input_stream >> transform_op
input_stream >> flags
is_enabled = input_stream.readBool()
is_selected = input_stream.readBool()
z_value = input_stream.readFloat()
# Set
item.setPos(pos)
item.setScale(scale)
item.setRotation(rotation)
item.setTransform(transform)
item.setTransformOriginPoint(transform_op)
item.setFlags(flags)
item.setEnabled(is_enabled)
item.setSelected(is_selected)
item.setZValue(z_value)
print(type(item), z_value)
def __init__(self):
QMainWindow.__init__(self)
self.series = QtCharts.QLineSeries()
self.series.append(0, 6)
self.series.append(2, 4)
self.series.append(3, 8)
self.series.append(7, 4)
self.series.append(10, 5)
self.series.append(QPointF(11, 1))
self.series.append(QPointF(13, 3))
self.series.append(QPointF(17, 6))
self.series.append(QPointF(18, 3))
self.series.append(QPointF(20, 2))
self.chart = QtCharts.QChart()
self.chart.legend().hide()
self.chart.addSeries(self.series)
self.chart.createDefaultAxes()
self.chart.setTitle("Simple line chart example")
self.chartView = QtCharts.QChartView(self.chart)
self.chartView.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.chartView)
def __init__(self, parent=None):
QOpenGLWidget.__init__(self, parent)
QOpenGLFunctions.__init__(self)
self.core = "--coreprofile" in QCoreApplication.arguments()
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPointF()
self.logo = Logo()
self.vao = QOpenGLVertexArrayObject()
self.logoVbo = QOpenGLBuffer()
self.program = QOpenGLShaderProgram()
self.projMatrixLoc = 0
self.mvMatrixLoc = 0
self.normalMatrixLoc = 0
self.lightPosLoc = 0
self.proj = QMatrix4x4()
self.camera = QMatrix4x4()
self.world = QMatrix4x4()
self.transparent = "--transparent" in QCoreApplication.arguments()
if self.transparent:
fmt = self.format()
fmt.setAlphaBufferSize(8)
self.setFormat(fmt)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
center = QPointF(self.width() / 2, self.height() / 2)
radius = self.radius()
ellipse_line_width = self.radius() * 60 / 512
# big ellipse
pen = QPen()
pen.setWidth(ellipse_line_width)
pen.setColor(self.color)
painter.setPen(pen)
painter.drawEllipse(center, radius - pen.width() / 2,
radius - pen.width() / 2)
# dots
pen = QPen()
pen.setColor(QColor(0, 0, 0, 0))
painter.setPen(pen)
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
dot_size = radius * 200 / 1024
color = copy.copy(self.color)
self._change_color(painter, brush, color, 0)
painter.drawEllipse(
QPointF((self.width() - radius - ellipse_line_width / 2) / 2,
self.height() / 2), dot_size, dot_size)
self._change_color(painter, brush, color, 15)
painter.drawEllipse(center, dot_size, dot_size)
self._change_color(painter, brush, color, 30)
painter.drawEllipse(
QPointF((self.width() + radius + ellipse_line_width / 2) / 2,
self.height() / 2), dot_size, dot_size)
def create_areachart(self):
chart = QtCharts.QChart()
chart.setTitle("Area Chart")
# The lower series initialized to zero values
lower_series = None
name = "Series "
for i in range(len(self.data_table)):
upper_series = QtCharts.QLineSeries(chart)
for j in range(len(self.data_table[i])):
data = self.data_table[i][j]
if lower_series:
points = lower_series.pointsVector()
y_value = points[i].y() + data[0].y()
upper_series.append(QPointF(j, y_value))
else:
upper_series.append(QPointF(j, data[0].y()))
area = QtCharts.QAreaSeries(upper_series, lower_series)
area.setName("{}{}".format(name, i))
chart.addSeries(area)
lower_series = upper_series
chart.createDefaultAxes()
chart.axisX().setRange(0, self.value_count - 1)
chart.axisY().setRange(0, self.value_max)
# Add space to label to add space between labels and axis
chart.axisY().setLabelFormat("%.1f ")
return chart
def __init__(self, chart):
QGraphicsItem.__init__(self, chart)
self._chart = chart
self._text = ""
self._textRect = QRectF()
self._anchor = QPointF()
self._font = QFont()
self._rect = QRectF()
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
self.pixmapOffset += event.position() - self.lastDragPos
self.lastDragPos = QPointF()
deltaX = (self.width() - self.pixmap.width()) / 2 - self.pixmapOffset.x()
deltaY = (self.height() - self.pixmap.height()) / 2 - self.pixmapOffset.y()
self.scroll(deltaX, deltaY)
def default(self) -> None:
self.path = QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0))
self.pos = self.path.p2()
self.res = QSize(1920, 1080)
self.fps = 24.0
self.easing = QEasingCurve.Type.Linear
self.time_max = 1.0
self.frames = [self.p1, self.p2]
def load_model(self, mdl_id: int, parent=None):
if not self._valid_model_id(mdl_id): raise ProjectFileAppError(msg="", code=ProjectFileAppError.MDL_ID_INVALID)
from PySide6.QtCore import QPointF
from project.model_editor import ModelWorkspace
from model_view.node import FasterNode
from model_view.connection import Connection
from model_view.components import InteractiveComponent
from node_graph.nodes import NodeExec, node_class_ref
print(f"loading model <{mdl_id}:{self.dat['mdl_ids'][mdl_id]}>")
model_wkrspc = ModelWorkspace(self.dat["mdl_ids"][mdl_id], parent=parent)
exec_node_dt = []
dto = self.models[mdl_id].copy()
cids = list(self.models[mdl_id].keys())
cids.reverse()
# converts connection and interactive components concrete data into python objects
for cid in cids:
compn = dto[cid]
if "connection" in compn: # connection
dto[cid] = Connection(QPointF(0, 0), QPointF(0, 0))
model_wkrspc.qscene.addItem(dto[cid])
elif "ctag" in compn: # interactive components
dto[cid] = compn["cdat"]
# converts node data into python objects, and modify them from connector, connection, and interactive-compn info
for cid in cids:
compn = dto[cid]
if not isinstance(compn, dict):
continue
if "tag" in compn: # node
node: NodeExec = node_class_ref[compn["tag"]]()
exec_node_dt.append(node)
wx_node: FasterNode = node.interface(model_wkrspc.qscene, (0,0))
wx_node.setPos(QPointF(compn["pos"][0], compn["pos"][1]))
# and then we add the connections to each of the connectors
for i in range(0, len(wx_node.fd_input)):
wx_node.connectors[i].prim_connc = [dto[c] for c in dto[compn["connc"][i]]["pc"]]
wx_node.connectors[i].scnd_connc = [dto[c] for c in dto[compn["connc"][i]]["sc"]]
for i in range(len(wx_node.fd_input), len(wx_node.fd_input) + len(wx_node.fd_output)):
wx_node.connectors[i].prim_connc = [dto[c] for c in dto[compn["connc"][i]]["pc"]]
wx_node.connectors[i].scnd_connc = [dto[c] for c in dto[compn["connc"][i]]["sc"]]
# update the state of constant fields
c: InteractiveComponent
for ind, c in enumerate(wx_node.fd_wx_consts):
c.deserialize(dto[compn["const"][ind]])
model_wkrspc.qscene.addItem(wx_node)
wx_node.update_connc()
wx_node.add_const_wx(model_wkrspc.qscene)
return model_wkrspc
def updatePixmap(self, image, scaleFactor):
if not self.lastDragPos.isNull():
return
self.pixmap = QPixmap.fromImage(image)
self.pixmapOffset = QPointF()
self.lastDragPosition = QPointF()
self.pixmapScale = scaleFactor
self.update()
def __init__(
self,
p1=QPointF(0.0, 0.0),
p2=QPointF(0.0, 0.0),
res=QSize(1920, 1080),
fps=24.0,
ease=QEasingCurve.Type.Linear,
tmax: None | float = 1.0,
) -> None:
self.from_line(QLineF(p1, p2), res, fps, ease, tmax)
def _ShowImg(self, data):
self.scaleCnt = 0
self.pixMap = QPixmap()
self.pixMap.loadFromData(data)
self.show()
self.graphicsItem.setPixmap(self.pixMap)
self.graphicsView.setSceneRect(QRectF(QPointF(0, 0), QPointF(self.pixMap.width(), self.pixMap.height())))
size = ToolUtil.GetDownloadSize(len(data))
self.sizeLabel.setText(size)
weight, height = ToolUtil.GetPictureSize(data)
self.resolutionLabel.setText(str(weight) + "x" + str(height))
self.ScalePicture()
def rebuildDataBrushIfNeeded(self):
if not self.m_rebuildBrush or not self.m_gradientData or self.m_barStyle == self.BarStyle.LINE:
return
self.m_rebuildBrush = False
p = self.palette()
if self.m_barStyle == self.BarStyle.EXPAND:
dataBrush = QRadialGradient(0.5, 0.5, 0.5, 0.5, 0.5)
dataBrush.setCoordinateMode(QGradient.StretchToDeviceMode)
for i in range(0, len(self.m_gradientData)):
dataBrush.setColorAt(self.m_gradientData[i][0],
self.m_gradientData[i][1])
p.setBrush(QPalette.Highlight, dataBrush)
else:
dataBrush = QConicalGradient(QPointF(0.5, 0.5),
self.m_nullPosition)
dataBrush.setCoordinateMode(QGradient.StretchToDeviceMode)
for i in range(0, len(self.m_gradientData)):
dataBrush.setColorAt(1 - self.m_gradientData[i][0],
self.m_gradientData[i][1])
p.setBrush(QPalette.Highlight, dataBrush)
self.setPalette(p)
def from_sect(self,
s: Section,
fps=24.0,
tmax: float|None = 1.0,
ease=QEasingCurve.Type.Linear
):
self.frames = []
step_n = len(s.steps)
for i, step in enumerate(s.steps):
if i == 0:
self.frames.append(QPointF(step.mouse_x, step.mouse_y))
self.frames.append(QPointF(step.mouse_x, step.mouse_y))
else:
self.from_pts(step.pos, s.steps[i-1].pos, s.res, fps, tmax)
self.from_pts(sect.p1, sect.p2, sect.res, fps, tmax, ease)
def __init__(self, parent: QGraphicsView, settings: Settings):
super(VideoScene, self).__init__(parent)
self.settings = settings
self.setting_helper = SettingWidgetHelper(settings)
self.mode = OperationMode.MOVE
# 视频帧base64字典 {帧数: base64}
self._frame_base64_dict = {}
# 粒子数据字典 {帧数: ParticleData}
self._particle_data = {}
# 粒子+标签 Item
self.particle_group_items = {}
# 轨迹Item
self.trajectory_items = {}
# 已更新轨迹的帧
self.updated_frame_index = set()
# 当前帧图像对象
self.current_frame_item = QGraphicsPixmapItem(None)
# 当前帧索引
self.current_frame_index = 0
self.config_changed = False
self.addItem(self.current_frame_item)
self.mouse_press_pos = QPointF()
# np.ndarray 用于缓存导出图像
self.export_frame_dict = {}
def __init__(self, path: Path):
self.position = QPointF()
self.path = path
self.size = QSize()
self.InitializeSize()
def __init__(self, valve: Valve):
super().__init__()
AppGlobals.Instance().onChipModified.connect(self.CheckForValve)
self._valve = valve
self.valveToggleButton = QToolButton()
self.valveNumberLabel = QLabel("Number")
self.valveNumberDial = QSpinBox()
self.valveNumberDial.setMinimum(0)
self.valveNumberDial.setValue(self._valve.solenoidNumber)
self.valveNumberDial.setMaximum(9999)
self.valveNumberDial.valueChanged.connect(self.UpdateValve)
self.valveNameLabel = QLabel("Name")
self.valveNameField = QLineEdit(self._valve.name)
self.valveNameField.textChanged.connect(self.UpdateValve)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.valveToggleButton, alignment=Qt.AlignCenter)
layout = QGridLayout()
layout.addWidget(self.valveNameLabel, 0, 0)
layout.addWidget(self.valveNameField, 0, 1)
layout.addWidget(self.valveNumberLabel, 1, 0)
layout.addWidget(self.valveNumberDial, 1, 1)
mainLayout.addLayout(layout)
self.containerWidget.setLayout(mainLayout)
self.valveToggleButton.clicked.connect(self.Toggle)
self.Update()
self.Move(QPointF())
def move_hover_line(new_value: QPointF) -> None:
x = new_value.x()
plot_area = chart.plotArea()
x_min = plot_area.left()
x_max = plot_area.right()
result.setVisible(x_min <= x <= x_max)
result.setLine(x, plot_area.bottom(), x, plot_area.top())
def AddItem(self, item: ChipItem):
if item not in self._sceneItems:
self._sceneItems.add(item)
item.Move(QPointF())
item.onRemoved.connect(self.RemoveItem)
self.scene().addItem(item.GraphicsObject())
item.SetEditDisplay(self._editing)
return item
def __init__(self, parent=None):
super(MandelbrotWidget, self).__init__(parent)
self.thread = RenderThread()
self.pixmap = QPixmap()
self.pixmapOffset = QPointF()
self.lastDragPos = QPointF()
self.centerX = DefaultCenterX
self.centerY = DefaultCenterY
self.pixmapScale = DefaultScale
self.curScale = DefaultScale
self.thread.renderedImage.connect(self.updatePixmap)
self.setWindowTitle("Mandelbrot")
self.setCursor(Qt.CrossCursor)
self.resize(550, 400)
def paint(self, painter, option, widget=None):
qgp = self.getqgp()
pen = QPen()
pen.setWidth(2)
qgp.setPen(pen)
qgp.setBrush(QBrush(Qt.NoBrush))
painter.setClipRect(option.exposedRect)
qgp.paint(painter, option, widget)
lastp = self.points[-1]
angle = radians(qgp.path().angleAtPercent(1.0))
angle = angle + pi
p = lastp + QPointF(
cos(angle - pi / 6.0) * 10, -sin(angle - pi / 6.0) * 10)
q = lastp + QPointF(
cos(angle + pi / 6.0) * 10, -sin(angle + pi / 6.0) * 10)
painter.setBrush(QBrush(QColor("black")))
self.head = QPolygonF([lastp, p, q])
painter.drawPolygon(self.head)
def Duplicate(self) -> 'ChipItem':
newValve = Valve()
newValve.position = QPointF(self._valve.position)
newValve.name = self._valve.name
newValve.solenoidNumber = AppGlobals.Chip().NextSolenoidNumber()
AppGlobals.Chip().valves.append(newValve)
AppGlobals.Instance().onChipModified.emit()
return ValveChipItem(newValve)
def Duplicate(self) -> 'ChipItem':
newPreset = ProgramPreset(self._preset.instance.program)
newPreset.instance = self._preset.instance.Clone()
newPreset.position = QPointF(self._preset.position)
newPreset.name = self._preset.name
AppGlobals.Chip().programPresets.append(newPreset)
AppGlobals.Instance().onChipModified.emit()
return ProgramPresetItem(newPreset)
def update_connc(self):
delta = QPointF(self.prev_pos.x() - self.x(),
self.prev_pos.y() - self.y())
for c in self.connectors:
c.setPos(QPointF(c.x() - delta.x(), c.y() - delta.y()))
pconnc: Connection
for pconnc in c.prim_connc:
pconnc.a = QPointF(c.x() + c.cpos[0] + Connector.SIZE / 2,
c.y() + c.cpos[1] + Connector.SIZE / 2)
sconnc: Connection
for sconnc in c.scnd_connc:
sconnc.b = QPointF(c.x() + c.cpos[0] + Connector.SIZE / 2,
c.y() + c.cpos[1] + Connector.SIZE / 2)
c: InteractiveComponent
for c in self.fd_wx_consts:
c.setPos(QPointF(c.x() - delta.x(), c.y() - delta.y()))
self.prev_pos = self.pos()
def game_loc_to_qt_local(self, pos: Union[NodeLocation,
list[float]]) -> QPointF:
if isinstance(pos, NodeLocation):
x = pos.x
y = pos.y
else:
x, y = pos[0], pos[1]
return QPointF(self.scale * (x - self.area_bounds.min_x),
self.scale * (self.area_bounds.max_y - y))
def resizeEvent(self, event):
if self.scene():
self.scene().setSceneRect(QRectF(QPointF(0, 0), event.size()))
self._chart.resize(event.size())
self._coordX.setPos(self._chart.size().width() / 2 - 50,
self._chart.size().height() - 20)
self._coordY.setPos(self._chart.size().width() / 2 + 50,
self._chart.size().height() - 20)
for callout in self._callouts:
callout.updateGeometry()
QGraphicsView.resizeEvent(self, event)
def DuplicateSelected(self):
newItems = []
for item in self.GetSelectedItems():
if item.CanDuplicate():
newItem = item.Duplicate()
newItem.Move(QPointF(50, 50))
self.AddItem(newItem)
newItems.append(newItem)
if newItems:
self.DeselectAll()
[self.SelectItem(item) for item in newItems]
self.selectionChanged.emit(self.GetSelectedItems())
def paint(self, painter: QPainter):
brush = QBrush(QColor("#007430"))
painter.setBrush(brush)
painter.setPen(Qt.NoPen)
painter.setRenderHint(QPainter.Antialiasing)
itemSize = self.size()
painter.drawRoundedRect(0, 0, itemSize.width(), itemSize.height() - 10, 10, 10)
if self.rightAligned:
points = [
QPointF(itemSize.width() - 10.0, itemSize.height() - 10.0),
QPointF(itemSize.width() - 20.0, itemSize.height()),
QPointF(itemSize.width() - 30.0, itemSize.height() - 10.0),
]
else:
points = [
QPointF(10.0, itemSize.height() - 10.0),
QPointF(20.0, itemSize.height()),
QPointF(30.0, itemSize.height() - 10.0),
]
painter.drawConvexPolygon(points)