def render_image(self):
# qimage = QImage(self.qPixmap.size(), QImage.Format_ARGB32_Premultiplied)
qimage = QImage(self.qPixmap.size(), QImage.Format_RGB32)
painter = QPainter(qimage)
self.scene_edit.render(painter, QRectF(
qimage.rect()), QRectF(self.qPixmap.rect()))
painter.end()
qpixmap = QPixmap.fromImage(qimage)
qpixmapItem = QGraphicsPixmapItem(qpixmap)
qpixmapItem.setPos(self.roi[2], self.roi[0])
self.mainForm.scene.addItem(qpixmapItem)
mainImage = self.mainForm.images[self.mainForm.page]
qimage = QImage(
QSize(mainImage.shape[1], mainImage.shape[0]), QImage.Format_RGB32)
painter = QPainter(qimage)
self.mainForm.scene.render(painter,
QRectF(qimage.rect()),
QRectF(QRect(0, 0, mainImage.shape[1], mainImage.shape[0])))
painter.end()
image = qimage2mat(qimage)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
self.mainForm.images[self.mainForm.page] = image
def __init__(self, aItemStack, aParent, aPos, aToolkitTypes): super().__init__(aParent) self.setPos(aPos) self.itemStack = aItemStack self.font = QFont() icon = QGraphicsPixmapItem(aToolkitTypes.GetTypePixmap(self.itemStack.itemId, 32), self) icon.setPos(QPointF(2, 2))
class FormWidget(QWidget):
def __init__(self):
super().__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.show()
# Initialize run after show function so GraphicsView Width,Height values are correct
self.initializeGraphicsView()
def initializeGraphicsView(self):
self.scene = QGraphicsScene(self)
self.scene.setSceneRect(QtCore.QRectF(0,0,self.ui.graphicsView.width(),
self.ui.graphicsView.height()))
self.ui.graphicsView.setScene(self.scene)
def setImageFromPath(self,path):
self.imagePixmap = QPixmap(path)
self.imagePixmap = self.imagePixmap.scaled(int(self.ui.graphicsView.width()),
int(self.ui.graphicsView.height()))
self.imageItem = QGraphicsPixmapItem()
self.imageItem.setPixmap(self.imagePixmap)
self.imageItem.setPos(0,0)
self.scene.addItem(self.imageItem)
def cannyEdgeOnImage(self,value1,value2):
class WayPoint:
def __init__(self, **kwargs):
super().__init__()
self.location = MapPoint()
self.__dict__.update(kwargs)
self.pixmap = QGraphicsPixmapItem(
QPixmap('HOME_DIR + /nparse/data/maps/waypoint.png'))
self.pixmap.setOffset(-10, -20)
self.line = QGraphicsLineItem(0.0, 0.0, self.location.x,
self.location.y)
self.line.setPen(QPen(Qt.green, 1, Qt.DashLine))
self.line.setVisible(False)
self.pixmap.setZValue(5)
self.line.setZValue(4)
self.pixmap.setPos(self.location.x, self.location.y)
def update_(self, scale, location=None):
self.pixmap.setScale(scale)
if location:
line = self.line.line()
line.setP1(QPointF(location.x, location.y))
self.line.setLine(line)
pen = self.line.pen()
pen.setWidth(1 / scale)
self.line.setPen(pen)
self.line.setVisible(True)
class Pixmap(QObject):
""" Wrapper class for PixmapItem """
def __init__(self, pix):
super(Pixmap, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
self.pixmap_item.setFlag(QGraphicsItem.ItemIsMovable)
self.pixmap_item.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
def __del__(self):
self.deleteLater()
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
def _set_opacity(self, op):
self.pixmap_item.setOpacity(op)
pos = pyqtProperty(QPointF, fset=_set_pos) # Position property
opacity = pyqtProperty(float, fset=_set_opacity) # Opacity property
def get_pixmap(self):
""" Return pixmap item """
return self.pixmap_item
def set_pixmap(self, pix):
""" Return pixmap item """
self.pixmap_item = QGraphicsPixmapItem(pix)
class GraphicsScene(QGraphicsScene):
def __init__(self):
super(GraphicsScene, self).__init__()
self.sprite_speed = 200
self.bucket_created = False
def add_bucket(self):
pixmap = QPixmap('images/bucket.png')
self.bucket_item = QGraphicsPixmapItem(pixmap)
self.bucket_item.setPos(368, 416)
self.addItem(self.bucket_item)
self.bucket_created = True
def add_shapes(self):
self.setSceneRect(0, 0, 800, 480)
if not self.bucket_created:
self.add_bucket()
print('add shapes')
class Princess(QObject):
def __init__(self, parent, x, y):
super().__init__(parent)
self.item = QGraphicsPixmapItem()
self.item.setPixmap(QPixmap(IMAGES_DIR + "princess/princess.png"))
self.item.setPos(x, y)
parent.addItem(HelpSign(x + 45, y - 35))
class PixmapItem(QObject):
def __init__(self, pix):
super(PixmapItem, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
pos = pyqtProperty(QPointF, fset=_set_pos)
class PixmapItem(QObject):
def __init__(self, pix):
super(PixmapItem, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
pos = pyqtProperty(QPointF, fset=_set_pos)
class Ball(QObject):
def __init__(self):
super().__init__()
self.pixmap_item = QGraphicsPixmapItem(QPixmap("ball.png"))
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
pos = pyqtProperty(QPointF, fset=_set_pos)
def dodaj_liczbe(self, numer):
Hy = 100 * y
Hx = (3**0.5) * Hy // 2
self.numer = numer
liczba = QGraphicsPixmapItem(self)
liczba.setPixmap(
QPixmap("obrazki/" + str(numer) + ".png").scaled(
Hx * 0.6, Hy * 0.6))
liczba.setPos(Hx * 0.2, Hy * 0.2)
print(liczba)
class WaitingForPlayers(InfoScene):
def __init__(self, parent):
super().__init__()
self.__parent__ = parent
self.opponent_text = QGraphicsPixmapItem()
self.opponent_text.setPixmap(
QPixmap(IMAGES_DIR + "menu/waiting_for_opponent.png"))
self.opponent_text.setPos((SCENE_WIDTH - 500) / 2, 250)
self.addItem(self.opponent_text)
def main(argv):
signal.signal(signal.SIGINT, signal.SIG_DFL)
app = QApplication([])
scene = QGraphicsScene()
view = QGraphicsView()
thumbnails = []
for filename in os.listdir(argv[1]):
filename = os.path.join(argv[1], filename)
print(filename)
thumbnails.append(DBusThumbnailer.thumbnail_from_filename(filename, "large"))
count = 0
items = []
for y in range(0, 100000, 150):
for x in range(0, 2500, 150):
scene.addRect(x, y, 128, 128)
# image = QImage(128, 128, QImage.Format_RGB32)
if count < len(thumbnails):
print(thumbnails[count])
image = QImage(thumbnails[count])
else:
arr = numpy.random.randint(0, 2**32, (128, 128), dtype=numpy.uint32)
image = QImage(arr, 128, 128, 128 * 4, QImage.Format_ARGB32)
pixmap = QPixmap.fromImage(image)
item = QGraphicsPixmapItem(pixmap)
scene.addItem(item)
text = scene.addText("Test Textual: {}".format(count))
item.setPos(x, y)
text.setPos(x, y + 128)
count += 1
item.setFlags(QGraphicsItem.ItemIsSelectable)
item.setAcceptHoverEvents(True)
items.append([item, text])
print(count)
if False:
random.shuffle(items)
i = 0
for y in range(0, 100000, 150):
for x in range(0, 2500, 150):
for item in items[i]:
item.setPos(x, y)
i += 1
view.setScene(scene)
view.resize(800, 600)
view.show()
app.exec()
class Pixmap(QObject):
def __init__(self, pix):
super(Pixmap, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
self.pixmap_item.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
pos = pyqtProperty(QPointF, fset=_set_pos)
class Pixmap(QObject):
def __init__(self, pix):
super(Pixmap, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
self.pixmap_item.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
pos = pyqtProperty(QPointF, fset=_set_pos)
class Objects(QObject):
def __init__(self, image_path):
super().__init__()
item_pixmap = QPixmap(image_path)
resize_item = item_pixmap.scaledToWidth(150)
self.item = QGraphicsPixmapItem(resize_item)
def _set_position(self, position):
self.item.setPos(position)
position = pyqtProperty(QPointF, fset=_set_position)
def add_racks(self):
""" Draw racks that hold tiles """
rack_img = QPixmap('tiles\\rack.png')
for i in range(2):
rack = QGraphicsPixmapItem(rack_img)
self.scene.addItem(rack)
rack.setPos(Cons.RACK_POS[i], Cons.RACK_Y)
for player in range(2):
self.players[player].totals.show()
self.players[player].totals.show_totals()
def create_icon(self, type, x, y):
ccoimage = QImage('../Interface/cco.png')
steimage = QImage('../Interface/ste.png')
vimage = QImage('../Interface/v.png')
if type == "cco":
ret = QGraphicsPixmapItem(QPixmap.fromImage(ccoimage))
elif type == "ste":
ret = QGraphicsPixmapItem(QPixmap.fromImage(steimage))
else:
ret = QGraphicsPixmapItem(QPixmap.fromImage(vimage))
ret.setPos(x, y)
self.scene.addItem(ret)
return ret
def plot(self, position):
xs, ys = np.asarray(position).T
self.plotWidget.clear()
item = pg.ScatterPlotItem([xs[0]], [ys[0]],
pen=pg.mkPen(color=(0, 0, 0), width=2))
self.plotWidget.addItem(item)
image = QGraphicsPixmapItem(self.pixel_map)
image.scale(self.image_scale, -self.image_scale)
image.setPos(xs[1] - self.pixel_map.width() * self.image_scale / 2,
ys[1] + self.pixel_map.height() * self.image_scale / 2)
self.plotWidget.addItem(image)
def plot_path(self, path, just_scatter=False):
xs, ys = path.to_numpy_array()
if not just_scatter:
self.plotWidget.plot(xs,
ys,
pen=pg.mkPen(color=(255, 255, 255), width=2),
clear=True)
else:
for i in range(len(xs)):
image = QGraphicsPixmapItem(self.pixel_map)
image.scale(self.image_scale, -self.image_scale)
image.setPos(
xs[i] - self.pixel_map.width() * self.image_scale / 2,
ys[i] + self.pixel_map.height() * self.image_scale / 2)
self.plotWidget.addItem(image)
class Pixmap(QObject):
pixmapSize = QSize(0,0)
def __init__(self, pix):
super(Pixmap, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
self.pixmap_item.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.pixmap_item.setZValue(0)
def _set_pos(self, pos):
self.pixmap_item.setPos(pos)
def _set_scale(self, scale):
self.pixmap_item.setScale(scale)
pos = pyqtProperty(QPointF, fset=_set_pos)
scale = pyqtProperty(float, fset=_set_scale)
class Coin(QObject):
draw_signal = pyqtSignal(int, int)
remove_signal = pyqtSignal()
animate_signal = pyqtSignal()
def __init__(self, parent):
super().__init__()
self.__parent__ = parent
self.item = QGraphicsPixmapItem()
self.drawn = False
self.current_frame_index = 0
self.animation_frames = [QPixmap(IMAGES_DIR + "coin/coin_0.png"), QPixmap(IMAGES_DIR + "coin/coin_1.png"),
QPixmap(IMAGES_DIR + "coin/coin_2.png"), QPixmap(IMAGES_DIR + "coin/coin_3.png"), QPixmap(IMAGES_DIR + "coin/coin_4.png"),
QPixmap(IMAGES_DIR + "coin/coin_5.png")]
self.draw_signal[int, int].connect(self.__draw)
self.remove_signal.connect(self.__remove)
self.animate_signal.connect(self.__animate)
self.animate_thread = Thread(target=self.__animate_thread_do_work)
self.animate_thread.start()
def __draw(self, x: int, y: int):
self.item.setPos(x, y)
self.__parent__.addItem(self.item)
self.drawn = True
def __remove(self):
self.drawn = False
self.__parent__.removeItem(self.item)
def __animate(self):
self.item.setPixmap(self.animation_frames[self.current_frame_index])
def __animate_thread_do_work(self):
while not self.__parent__.kill_thread:
if self.drawn is True:
count = len(self.animation_frames)
if self.current_frame_index + 1 > count - 1:
self.current_frame_index = 0
else:
self.current_frame_index = self.current_frame_index + 1
self.animate_signal.emit()
time.sleep(0.04)
def __init__(self):
QGraphicsScene.__init__(self)
# 60hz에 가까운 주기로 새로고침함(16ms에 1번 = 960ms(0.96초)에 16번)
self.timer = QBasicTimer()
self.timer.start(FRAME_TIME_MS, self)
self.mainscene = True
self.keys_pressed = set()
self.cleared = False
bg = QGraphicsPixmapItem()
bg.setPixmap(QPixmap("title.png"))
bg.setScale(0.57)
self.addItem(bg)
start = QGraphicsPixmapItem(QPixmap("start.png"))
start.setScale(0.5)
self.addItem(start)
start.setPos(127, 400)
def __placeShip(self, shipListItem, x, y, rotation):
sceneX, sceneY = (x + 1) * self.tileSize, (y + 1) * self.tileSize
shipListItem.count -= 1
shipListItem.counterText.setPlainText(str(shipListItem.count))
pixmap = QPixmap(shipListItem.image).transformed(QTransform().rotate(
(rotation.value)))
placedShip = QGraphicsPixmapItem(pixmap)
placedShip.setData(0, rotation)
placedShip.setData(1, shipListItem)
placedShip.setData(2, QPoint(x, y)) # position in map coordinates
placedShip.setPos(sceneX, sceneY)
placedShip.setTransformationMode(
Qt.TransformationMode.SmoothTransformation)
placedShip.setScale(self.__scaleFactor)
self.__placedShips.append(placedShip)
self.__scene.addItem(placedShip)
class Button(QGraphicsObject):
state_changed = pyqtSignal()
state = ButtonState.NONE
def __init__(self, func, func_param, x: float, y: float, normal: str,
highlight: str, state: ButtonState):
super().__init__()
self.func = func
self.func_param = func_param
self.state_changed.connect(self.__state_changed_handler)
self.normalImage = QPixmap(normal)
self.highlightImage = QPixmap(highlight)
self.graphics_item = QGraphicsPixmapItem()
self.graphics_item.setPos(x, y)
self.set_state(state)
""" Changes button state """
def set_state(self, state):
self.state = state
self.state_changed.emit()
""" Executes button logic """
def execute(self):
if self.func_param is None:
return self.func()
else:
return self.func(self.func_param)
""" Changes button image """
def __state_changed_handler(self):
if self.state is ButtonState.NORMAL:
self.graphics_item.setPixmap(self.normalImage)
elif self.state is ButtonState.HIGHLIGHTED:
self.graphics_item.setPixmap(self.highlightImage)
def makeMove(self, move):
if move >= self._board._boardSize or\
move not in self._board.legalMoves() or\
self._board.winner() > 0:
# illegal move
return
image = None
sideToMove = self._board.currPlayer()
if sideToMove == 1:
image = self._OImage
if sideToMove == 2:
image = self._XImage
self._board.makeMove(move)
playerIcon = QGraphicsPixmapItem(QPixmap.fromImage(image))
playerIcon.setScale(0.15)
cellID = move
cc = self.cellCenter(cellID)
cellSize = self.cellSize()
playerIcon.setPos(int(cc[0] - 0.25 * cellSize), int(cc[1] - 0.25 * cellSize))
self.addItem(playerIcon)
def __init__(self, aProductionProcess, aToolkitTypes): super().__init__() self.process = aProductionProcess self.col = 0 self.row = 0 self.inputs = [] self.outputs = [] icon = QGraphicsPixmapItem(aToolkitTypes.GetTypePixmap(self.process.scheme.schemeId, 32), self) icon.setPos(2, 2) width = 250 space = 40 inputOffset = 40 outputOffset = 40 for inp in self.process.inputs: inputOffset = inputOffset + space self.inputs.append(InputGraphic(inp, self, QPointF(0, inputOffset), aToolkitTypes)) for out in self.process.outputs: outputOffset = outputOffset + space self.outputs.append(OutputGraphic(out, self, QPointF(width, outputOffset), aToolkitTypes)) self.rect = QRectF(0, 0, width, max(outputOffset, inputOffset) + space) spinbox = QSpinBox() spinbox.setRange(0, 1000000) spinbox.setValue(self.process.runs) spinbox.valueChanged.connect(self.OnRunChanged) proxy = QGraphicsProxyWidget(self) proxy.setWidget(spinbox) proxy.setPos(QPointF(width / 2 - spinbox.width() / 2, 40)) self.runs = proxy self.spinbox = spinbox
def __loadStaticImages(self, static_images):
for image_info in static_images:
pixmap = QPixmap(FileInfo().getPath(FileInfo.FileDataType.IMAGE,
image_info.name))
height = image_info.height
width = image_info.width
if height is None:
if width is not None:
pixmap = pixmap.scaledToWidth(width)
elif width is None:
pixmap = pixmap.scaledToHeight(height)
else:
pixmap = pixmap.scaled(width, height)
image_item = QGraphicsPixmapItem(pixmap)
image_item.setPos(image_info.x, image_info.y)
brect = image_item.boundingRect()
image_item.setOffset(-brect.width() / 2, -brect.height() / 2)
self.__ui.view.scene().addItem(image_item)
def __finalResult(self):
if self.__myScore > self.__enemyScore: # win
pixmap = QPixmap("resources/win.png")
QGPI = QGraphicsPixmapItem()
QGPI.setPixmap(pixmap)
QGPI.setPos(150, 160)
self.__scene.addItem(QGPI)
elif self.__myScore < self.__enemyScore: # lose
pixmap = QPixmap("resources/lose.png")
QGPI = QGraphicsPixmapItem()
QGPI.setPixmap(pixmap)
QGPI.setPos(100, 160)
self.__scene.addItem(QGPI)
else:
pixmap = QPixmap("resources/tie.png")
QGPI = QGraphicsPixmapItem()
QGPI.setPixmap(pixmap)
QGPI.setPos(150, 160)
self.__scene.addItem(QGPI)
if hasattr(self, '_GamePage__actioner'):
self.__actioner.cancel()
if hasattr(self, '_GamePage__renderEmojiRunner'):
self.__renderEmojiRunner.cancel()
if hasattr(self, '_GamePage__displayTimeRunner'):
self.__displayTimeRunner.cancel()
if hasattr(self, '_GamePage__CFIRunner'):
self.__CFIRunner.cancel()
self.__camera.stop()
self.__camera.release()
if hasattr(self.__camera, 'captureThread'):
self.__camera.captureThread.cancel()
if hasattr(self.__camera, 'predictThread'):
self.__camera.predictThread.cancel()
try:
self.__net.close()
except:
pass
class Node(QObject):
"""
Node是一个节点的抽象
"""
def __init__(self,
canvas: 'PMGraphicsScene',
node_id,
text: str = '',
input_ports: List[CustomPort] = None,
output_ports: List[CustomPort] = None,
icon_path=r''):
super(Node, self).__init__()
self.id = node_id
self.text = text if text != '' else node_id
self.base_rect = CustomRect(self)
icon_path = os.path.join(get_parent_path(__file__), 'icons',
'logo.png') if icon_path == '' else icon_path
self.icon_path = icon_path
pix_map = QPixmap(icon_path)
# pix_map.scaled(QSize(20,20),Qt.KeepAspectRatio)
self.pix_map_item = QGraphicsPixmapItem(pix_map, parent=self.base_rect)
self.pix_map_item.setPos(20, 20)
self.text_item = QGraphicsTextItem(parent=self.base_rect)
start_left = 50
self.text_item.setPos(start_left, 10)
self.text_item.setPlainText(self.text)
self.internal_value_text = QGraphicsTextItem(parent=self.base_rect)
self.internal_value_text.setPos(start_left, 30)
self.internal_value_text.setPlainText('')
self.status_text = QGraphicsTextItem(parent=self.base_rect)
self.status_text.setPos(start_left, 100)
self.status_text.setPlainText('wait')
self.input_ports = input_ports
self.output_ports = output_ports
self.input_ports_dic = {p.id: p for p in input_ports}
self.output_ports_dic = {p.id: p for p in output_ports}
self.canvas = canvas
# self.set_content(content)
self.setup()
def display_internal_values(self, val_str: str = ''):
self.internal_value_text.setPlainText(val_str)
def set_content(self, content: 'FlowContentEditableFunction' = None):
self.content: 'FlowContentEditableFunction' = content if content is not None else FlowContentEditableFunction(
self, '')
self.content.signal_exec_finished.connect(self.on_exec_finished)
self.content.signal_exec_started.connect(self.on_exec_started)
self.content.signal_error_occurs.connect(self.on_error_occurs)
def on_error_occurs(self, error: str):
flow_widget: PMFlowWidget = self.canvas.flow_widget
flow_widget.on_error_occurs(error)
def on_exec_started(self, content):
"""
执行前进行的操作
:param content:
:return:
"""
self.status_text.setPlainText(content)
def on_exec_finished(self, content: str):
"""
执行完成后进行的操作
:param content:
:return:
"""
self.status_text.setPlainText(content)
#
def reset(self):
self.status_text.setPlainText('wait')
def get_port_index(self, port: CustomPort):
"""
获取端口的索引
:param port:
:return:
"""
return self.input_ports.index(
port) if port.port_type == 'input' else self.output_ports.index(
port)
def set_icon(self, icon_path: str):
pass
def set_pos(self, x: int, y: int):
"""
设置位置，左上角角点
:param x:
:param y:
:return:
"""
self.base_rect.setPos(x, y)
self.refresh_pos()
def get_pos(self) -> Tuple[int, int]:
"""
获取位置，左上角角点
:return:
"""
pos = self.base_rect.pos()
return pos.x(), pos.y()
def refresh_pos(self):
"""
刷新位置。当节点被拖动的时候，此方法会被触发。
"""
y = self.base_rect.y()
dy_input = self.base_rect.boundingRect().height() / (
1 + len(self.input_ports))
dy_output = self.base_rect.boundingRect().height() / (
1 + len(self.output_ports))
x_input = self.base_rect.x() + 5
x_output = self.base_rect.x() + self.base_rect.boundingRect().width(
) - 15
for i, p in enumerate(self.input_ports):
p.setPos(QPointF(x_input, y + int(dy_input * (1 + i))))
for i, p in enumerate(self.output_ports):
p.setPos(QPointF(x_output, y + int(dy_output * (1 + i))))
self.canvas.signal_item_dragged.emit('')
def setup(self):
self.base_rect.setPos(80, 80)
self.canvas.signal_clear_selection.connect(
self.base_rect.on_clear_selection)
self.canvas.addItem(self.base_rect)
for p in self.input_ports + self.output_ports:
self.canvas.addItem(p)
p.port_clicked.connect(self.on_port_clicked)
p.node = self
self.refresh_pos()
def on_port_clicked(self, port: 'CustomPort'):
if self.canvas.drawing_lines:
if self.canvas.line_start_port is not port:
if not port.port_type == self.canvas.line_start_port.port_type:
if len(port.connected_lines) == 0:
self.canvas.connect_port(port)
# else:
# self.canvas.drawing_lines = False
else:
if port.port_type == 'output':
self.canvas.drawing_lines = True
# if self.canvas.item
self.canvas.line_start_point = port.center_pos
self.canvas.line_start_port = port
def on_delete(self):
for port in self.input_ports + self.output_ports:
port.canvas = self.canvas
port.on_delete()
self.canvas.removeItem(self.base_rect)
self.canvas.nodes.remove(self)
self.deleteLater()
def __repr__(self):
s = super(Node, self).__repr__()
return s + repr(self.input_ports) + repr(self.output_ports)
def get_port(self, port_id: str) -> 'CustomPort':
for port in self.input_ports + self.output_ports:
if port_id == port.id:
return port
return None
def add_port(self, port: CustomPort):
"""
添加一个端口
:param port:
:return:
"""
port_type = port.port_type
if port_type == 'input':
self.input_ports.append(port)
self.input_ports_dic[port.id] = port
elif port_type == 'output':
self.output_ports.append(port)
self.output_ports_dic[port.id] = port
else:
raise ValueError('port type invalid')
self.refresh_pos()
self.canvas.addItem(port)
port.port_clicked.connect(self.on_port_clicked)
return port
def remove_port(self, port: CustomPort):
"""
删除一个端口
:param port:
:return:
"""
port_type = port.port_type
if port_type == 'input':
self.input_ports.remove(port)
self.input_ports_dic.pop(port.id)
elif port_type == 'output':
self.output_ports.remove(port)
self.output_ports_dic.pop(port.id)
else:
raise ValueError('port type invalid')
port.on_delete()
self.refresh_pos()
def change_property(self, property: Dict[str, Union[int, str]]):
"""
改变各个端口的文字、端口的数目以及文字。
:param property:
:return:
"""
self.text = property['text']
self.text_item.setPlainText(self.text)
self.content.update_settings(property)
self.valid_port_ids = []
if property.get('inputs') is not None:
for input_id, input_text in zip(property['inputs'][0],
property['inputs'][1]):
self.valid_port_ids.append(input_id)
p = self.get_port(input_id)
if p is None:
p = self.add_port(
CustomPort(port_id=input_id,
text=input_text,
port_type='input'))
p.set_text(input_text)
for p in self.input_ports:
if p.id not in self.valid_port_ids:
self.remove_port(p)
if property.get('outputs') is not None:
for output_id, output_text in zip(property['outputs'][0],
property['outputs'][1]):
self.valid_port_ids.append(output_id)
p = self.get_port(output_id)
if p is None:
p = self.add_port(
CustomPort(port_id=output_id,
text=output_text,
port_type='output'))
p.set_text(output_text)
for p in self.output_ports:
if p.id not in self.valid_port_ids:
self.remove_port(p)
def on_edit_properties_requested(self):
from pmgwidgets import SettingsPanel
from PyQt5.QtWidgets import QDialog, QVBoxLayout
dlg = QDialog(self.base_rect.scene().flow_widget)
sp = SettingsPanel()
p: 'CustomPort' = None
input_ids, output_ids = [], []
input_texts, output_texts = [], []
self._last_var = 0
def new_id_input():
node_id = self.id
max_val = 0
for p in self.input_ports:
n, t, p = p.parse_id()
if max_val < int(p):
max_val = int(p)
self._last_var += 1
return '%s:input:%d' % (node_id, max_val + self._last_var)
def new_id_output():
node_id = self.id
max_val = 0
for p in self.output_ports:
n, t, p = p.parse_id()
if max_val < int(p):
max_val = int(p)
self._last_var += 1
return '%s:output:%d' % (node_id, max_val + self._last_var)
for p in self.input_ports:
input_ids.append(p.id)
input_texts.append(p.text)
for p in self.output_ports:
output_ids.append(p.id)
output_texts.append(p.text)
views = []
views += self.content.get_settings_params()
views += [
('line_edit', 'text', 'Node Text', self.text),
]
if self.content.ports_changable[0]:
views.append(('entry_list', 'inputs', 'Set Inputs',
[input_ids, input_texts], new_id_input))
if self.content.ports_changable[1]:
views.append(('entry_list', 'outputs', 'Set Outputs',
[output_ids, output_texts], new_id_output))
sp.set_items(views)
dlg.setLayout(QVBoxLayout())
dlg.layout().addWidget(sp)
dlg.exec_()
dic = sp.get_value()
self.change_property(dic)
class WinnerView(QGraphicsView):
def __init__(self, centralWidget: QStackedWidget):
self.isFullScreen = False
super(WinnerView, self).__init__()
self.viewlist = centralWidget
self.player = ""
self.playerCar = 0
self.initUI()
def initUI(self):
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.holder = QVBoxLayout()
self.playersLayout1 = QHBoxLayout()
self.playersLayout2 = QHBoxLayout()
self.playersLayout3 = QHBoxLayout()
self.playersLayout1.setAlignment(Qt.AlignCenter)
self.playersLayout2.setAlignment(Qt.AlignCenter)
self.playersLayout3.setAlignment(Qt.AlignCenter)
self.grafickascena = QGraphicsScene()
self.grafickascena.setSceneRect(0, 0, 1000, 850)
self.setbackground()
self.backbtn1 = StyleButton('PNG/Buttons/Close_BTN.png',
'Back to Menu', 40, 40)
self.backbtn1.clicked.connect(self.backtomenu)
self.backbtn2 = StyleButton('PNG/Buttons/Replay_BTN.png', 'Replay', 40,
40)
self.backbtn2.clicked.connect(self.replay)
self.playersLayout3.addWidget(self.backbtn1)
self.playersLayout3.addWidget(self.backbtn2)
self.okvir = HUDOkvir(
"player1", 1) # OVDE UBACITI KOJI IGRAC JE POBEDIO I NJEGOV AUTO
tempImg = QPixmap('PNG/You_Win/Header.png')
tempImg = tempImg.scaled(500, 100)
self.graphicsPixmapItem = QGraphicsPixmapItem(tempImg)
self.grafickascena.addItem(self.graphicsPixmapItem)
self.graphicsPixmapItem.setPos(220, 100)
self.playersLayout2.addWidget(self.okvir)
self.holder.addLayout(self.playersLayout1)
self.holder.addLayout(self.playersLayout2)
self.holder.addLayout(self.playersLayout3)
self.setScene(self.grafickascena)
self.setLayout(self.holder)
def setbackground(self):
tempImg = QPixmap('PNG/9c49087c09fd07a10ae3887a7825f389.jpg')
tempImg = tempImg.scaled(self.grafickascena.width(),
self.grafickascena.height())
new_pix = QPixmap(tempImg.size())
new_pix.fill(Qt.darkGray)
painter = QPainter(new_pix)
painter.setOpacity(0.35)
painter.drawPixmap(QPoint(), tempImg)
painter.end()
self.graphicsPixmapItem = QGraphicsPixmapItem(new_pix)
self.grafickascena.addItem(self.graphicsPixmapItem)
def backtomenu(self):
self.viewlist.setCurrentWidget(self.viewlist.widget(0))
def replay(self):
self.viewlist.setCurrentWidget(self.viewlist.widget(3))
def lastPlayer(self, player, playerCar):
self.okvir.setNameAndCar(player, playerCar)
self.okvir.setLives(0)
class MultiplayerTwoPlayerScene(QGraphicsScene):
def __init__(self, startMethod, backMethod, parent=None):
super(MultiplayerTwoPlayerScene, self).__init__(parent)
screenWidth = 1370
screenHeight = 730
oImage = QPixmap("asteroids.jpg")
sImage = oImage.scaled(QSize(screenWidth, screenHeight)) # resize Image to widgets size
self.graphicsPixmapItem = QGraphicsPixmapItem(sImage)
self.addItem(self.graphicsPixmapItem)
self.setSceneRect(0, 0, screenWidth, screenHeight)
self.y_start = 250
self.y_step = 150
player1 = QLabel('PLAYER 1')
player2 = QLabel('PLAYER 2')
start = ClickableQLabel('START')
back = ClickableQLabel('BACK')
player1.setStyleSheet("color: white; font-size: 40px; background-color: rgba(0,0,0,0%)")
player2.setStyleSheet("color: white; font-size: 40px; background-color: rgba(0,0,0,0%)")
start.setStyleSheet("color: white; font-size: 40px; background-color: rgba(0,0,0,0%)")
back.setStyleSheet("color: white; font-size: 40px; background-color: rgba(0,0,0,0%)")
player1.setGeometry(QRect(270, self.y_start, 300, 40)) # (x, y, width, height)
player2.setGeometry(QRect(270, self.y_start + self.y_step, 300, 40))
start.setGeometry(QRect(screenWidth - 200, screenHeight - 200, 300, 40))
back.setGeometry(QRect(100, 100, 300, 40))
commands1 = QLabel("left => left, right => right,\n up => up, down => down,\n shoot => ctrl")
commands2 = QLabel("left => a, right => d, \n up => w, down => s, \n shoot => shift")
commands1.setStyleSheet("color: white; font-size: 20px; background-color: rgba(0,0,0,0%)")
commands2.setStyleSheet("color: white; font-size: 20px; background-color: rgba(0,0,0,0%)")
y_comm_start = self.y_start - 20
commands1.setGeometry(QRect(1050, y_comm_start, 300, 64))
commands2.setGeometry(QRect(1050, y_comm_start + self.y_step, 300, 64))
self.textbox1 = QLineEdit()
self.textbox1.move(500, self.y_start)
self.textbox1.resize(280, 40)
font1 = self.textbox1.font()
font1.setPointSize(20)
self.textbox1.setFont(font1)
self.textbox2 = QLineEdit()
self.textbox2.move(500, self.y_start + self.y_step)
self.textbox2.resize(280, 40)
font2 = self.textbox2.font()
font2.setPointSize(20)
self.textbox2.setFont(font2)
start.connect(startMethod)
back.connect(backMethod)
oImageSpaceshipGray = QPixmap("spaceship2.jpg")
sImageSpaceshipGray = oImageSpaceshipGray.scaled(QSize(100, 100)) # resize Image to widgets size
self.graphicsPixmapItem1 = QGraphicsPixmapItem(sImageSpaceshipGray)
oImageSpaceshipYellow = QPixmap("spaceshipRed.jpg")
sImageSpaceshipYellow = oImageSpaceshipYellow.scaled(QSize(100, 100)) # resize Image to widgets size
self.graphicsPixmapItem2 = QGraphicsPixmapItem(sImageSpaceshipYellow)
self.graphicsPixmapItem1.setPos(900, self.y_start - 30)
self.graphicsPixmapItem2.setPos(900, self.y_start + self.y_step - 30)
self.addItem(self.graphicsPixmapItem1)
self.addItem(self.graphicsPixmapItem2)
self.addWidget(player1)
self.addWidget(player2)
self.addWidget(start)
self.addWidget(back)
self.addWidget(commands1)
self.addWidget(commands2)
self.addWidget(self.textbox1)
self.addWidget(self.textbox2)
class NetScene(QGraphicsScene):
SPACE_WIDTH = 200 # 留白宽度
def __init__(self, parent, announces, api):
super().__init__(parent)
self.announces = announces
self.api = api
api['Scene.setBackgroundColor'] = self.setBackgroundBrush
api['Scene.setBackgroundPixmap'] = self.setBackgroundPixmap
api['Scene.setLayout'] = self.setLayout
api['Scene.renderNode'] = self.renderNode
api['Scene.renderEdge'] = self.renderEdge
api['Scene.selectedNode'] = lambda: self.selected_node
announces['addICNNode'].append(self.addICNNode)
announces['addICNEdge'].append(self.addICNEdge)
self.node_table = {} # { node_id:node_item, ... }
self.edge_table = {} # { edge_id:edge_item, ... }
self.cache_pixmap = None
self.background_item = QGraphicsPixmapItem()
self.addItem(self.background_item)
self.selected_node = None
def setLayout(self, layout):
"""
设置场景中节点的位置
:param layout: {node_id:(x,y), ...}
:return: None
"""
for node_id, (x, y) in layout.items():
self.node_table[node_id].checkPos(x, y)
self.adjustBounding()
def addICNNode(self, node_id):
node_item = NodeItem(node_id)
node_item.press_callback = self.pressNode
node_item.release_callback = self.releaseNode
node_item.double_click_callback = self.announces['doubleClickNode']
node_item.move_callback = self.moveNode
self.node_table[node_id] = node_item
self.addItem(node_item)
self.update()
def addICNEdge(self, edge_id):
edge_item = EdgeItem(edge_id)
edge_item.double_click_callback = self.announces['doubleClickEdge']
src_id, dst_id = edge_id
src_item = self.node_table[src_id]
dst_item = self.node_table[dst_id]
edge_item.adjust(src_item.pos(), dst_item.pos())
self.edge_table[edge_id] = edge_item
self.addItem(edge_item)
self.update()
def renderNode(self, node_id, style: dict):
self.node_table[node_id].setStyle(style)
def renderEdge(self, edge_id, style: dict):
self.edge_table[edge_id].setStyle(style)
# ------------------------------------------------------------------------------------------------------------------
def setBackgroundPixmap(self, pixmap):
if pixmap is None:
self.background_item.hide()
else:
if self.cache_pixmap is not pixmap:
self.cache_pixmap = pixmap
self.background_item.setPixmap(pixmap)
# 设置位置居中
rect = self.background_item.boundingRect()
self.background_item.setPos(-rect.center())
self.background_item.show()
def adjustBounding(self):
self.setSceneRect(
self.itemsBoundingRect().adjusted(
-self.SPACE_WIDTH,
-self.SPACE_WIDTH,
self.SPACE_WIDTH,
self.SPACE_WIDTH
)
)
self.update()
# ------------------------------------------------------------------------------------------------------------------
def pressNode(self, node_id):
self.selected_node= node_id
self.announces['selectedNode'](self.selected_node)
def moveNode(self, src_id):
"""
当一个节点位置变化时，调整与该节点链接的边
:param src_id: 节点id
:return: None
"""
graph = self.api['Sim.graph']() # 邻接表{node_id:{neighbor_id, ...}, }
src_pos = self.node_table[src_id].pos()
for dst_id in graph[src_id]:
dst_pos = self.node_table[dst_id].pos()
self.edge_table[(src_id, dst_id)].adjust(src_pos, dst_pos)
self.edge_table[(dst_id, src_id)].adjust(dst_pos, src_pos)
def releaseNode(self, node_id):
node_item = self.node_table[node_id]
pos = node_item.pos()
pos = pos.x(), pos.y()
self.announces['sceneNodeMoved'](node_id, pos)
def create_scene_items_from_world(self, item: QGraphicsPixmapItem, pos: QPoint):
self.addItem(item)
item.setPos(pos)
class BoardScene(QGraphicsScene):
"""
Contains and manages SquareWidgets interacting
with each other.
Sends moves and premoves through signals.
"""
moveInputted = pyqtSignal(chess.Move)
def __init__(self, parent, board):
super().__init__(parent)
self.board = copy.deepcopy(board)
self.squareWidgets = []
self.squareWidth = 0
self.dragPieceBehind = None
self.dragPieceAhead = None
self.lastMouseSquare = None
self.selectedSquare = -1
# For arrows
self.longestPV = []
self.effectItems = []
self.heroColor = chess.WHITE
def initSquares(self, squareWidth):
"""
Initializes squares and pieces with dimensions
given by squareWidth.
"""
self.squareWidth = squareWidth
constants.PIECE_PADDING_RIGHT = constants.PIECE_PADDING_RIGHT * \
squareWidth
constants.PIECE_PADDING_BOT = constants.PIECE_PADDING_BOT * squareWidth
for s in chess.SQUARES:
newSquareWidget = SquareWidget(s, squareWidth)
newSquareWidget.pieceReleased.connect(self.sendMove)
newSquareWidget.invalidDrop.connect(self.deselectSquares)
self.addItem(newSquareWidget)
if self.board.piece_at(s) is not None:
piece = self.createPiece(self.board.piece_at(s))
newSquareWidget.addPiece(piece)
self.squareWidgets.append(newSquareWidget)
self.setSceneRect(0, 0, int(squareWidth * 8), int(squareWidth * 8))
def createPiece(self, piece, scale=None):
newPieceItem = PieceItem(piece)
newPieceItem.pieceClicked.connect(self.pieceClicked)
newPieceItem.pieceDragStarting.connect(self.pieceDragStarting)
newPieceItem.pieceDragHappening.connect(self.pieceDragHappening)
newPieceItem.pieceDragStopping.connect(self.pieceDragStopping)
if scale is None:
scale = (float(self.squareWidth) /
newPieceItem.boundingRect().width())
newPieceItem.setScale(scale)
return newPieceItem
def sendMove(self, toSquare, fromSquare=None):
"""
Emits moveInputted after first asking for a promotion
piece if there should be one. Then updates the board graphics.
Does not validate move, although it should be valid.
"""
if fromSquare is None:
fromSquare = self.selectedSquare
m = chess.Move(fromSquare, toSquare)
if (self.board.piece_at(m.from_square).piece_type == chess.PAWN and
chess.rank_index(m.to_square) in [0, 7]):
# TODO: ask for a real promotion piece
print('promoting to queen')
m.promotion = chess.QUEEN
# In order to be as responsive as possible, the board is updated with
# its own move before being sent to the engine, ect.
self.updateAfterMove(m)
self.moveInputted.emit(m)
def squareWidgetAt(self, pos):
for i in self.items(pos):
if type(i) == DummySquareItem:
return i.parentItem()
return None
def updateSelectionGraphics(self, lastSelection, square):
# Clicking on a new piece selects it.
if lastSelection != square:
self.squareWidgets[square].isSelected = True
self.squareWidgets[square].addEffectItem(SquareWidget.Selected)
else:
# Same piece deselects
self.selectedSquare = -1
return
# Add the valid move squares
for m in self.board.legal_moves:
if m.from_square == self.selectedSquare:
self.squareWidgets[m.to_square].addEffectItem(
SquareWidget.ValidMove)
self.squareWidgets[m.to_square].isValidMove = True
def updateSquareEffects(self, move=None):
for s in self.squareWidgets:
p = self.board.piece_at(s.square)
if (move and (s.square == move.from_square or
s.square == move.to_square)):
s.clearEffectItems()
s.addEffectItem(SquareWidget.LastMove)
elif (self.board.is_check() and p is not None and
p.piece_type == chess.KING and
p.color == self.board.turn):
s.addEffectItem(SquareWidget.CheckSquare)
else:
s.clearEffectItems()
s.isValidMove = False
self.selectedSquare = -1
def updateAfterMove(self, move):
"""
Updates the board graphics one valid move forward.
This is faster than calling refreshPosition.
:param move: the move that happened on the board
:param oldBoard: the board before the move
:return: void
"""
time2 = time.time()
if move.promotion is None:
fromPieceItem = self.squareWidgets[move.from_square].pieceItem
self.squareWidgets[move.from_square].removePiece()
else:
fromPieceItem = self.createPiece(chess.Piece(move.promotion,
self.board.turn))
self.squareWidgets[move.from_square].removePiece(True)
if self.board.is_queenside_castling(move):
# Fix rook, move.to_square is the rook square
if self.board.turn == chess.WHITE:
rookSquare = chess.A1
move.to_square = chess.C1
else:
rookSquare = chess.A8
move.to_square = chess.C8
rookWid = self.squareWidgets[rookSquare]
rookItem = rookWid.pieceItem
rookWid.removePiece()
self.squareWidgets[rookSquare + 3].addPiece(rookItem)
elif self.board.is_kingside_castling(move):
# Fix rook, move.to_square is the rook square
if self.board.turn == chess.WHITE:
rookSquare = chess.H1
move.to_square = chess.G1
else:
rookSquare = chess.H8
move.to_square = chess.G8
rookWidg = self.squareWidgets[rookSquare]
rookItem = rookWidg.pieceItem
rookWidg.removePiece()
self.squareWidgets[rookSquare - 2].addPiece(rookItem)
elif self.board.is_en_passant(move):
# remember we are updating after the move has occurred
if self.board.turn == chess.WHITE:
self.squareWidgets[move.to_square - 8].removePiece()
else:
self.squareWidgets[move.to_square + 8].removePiece()
self.squareWidgets[move.to_square].removePiece(True)
self.squareWidgets[move.to_square].addPiece(fromPieceItem)
self.board.push(move)
self.updateSquareEffects(move)
print('time3', time.time(), time.time() - time2)
def createEffectItem(self, itemClass, move=None, hero=True, opacity=1.0):
if itemClass == ArrowGraphicsItem.Type:
assert move is not None
fromSquare = self.squareWidgets[move.from_square]
toSquare = self.squareWidgets[move.to_square]
item = ArrowGraphicsItem(hero, move, fromSquare, toSquare,
self.squareWidth)
item.setOpacity(opacity)
return item
return None
def addEffectItem(self, itemClass, move=None, hero=True, zValue=0,
opacity=1.0):
effectItem = self.createEffectItem(itemClass.Type, move, hero, opacity)
if effectItem is not None:
effectItem.setZValue(151 + zValue)
self.effectItems.append(effectItem)
self.addItem(effectItem)
# print('adding', effectItem.move, self.effectItems)
else:
print('tried to add an invalid effect item', itemClass)
def removeEffectItem(self, effectItem):
assert effectItem in self.effectItems
self.effectItems.remove(effectItem)
effectItem.setParentItem(None)
self.removeItem(effectItem)
# print('removing', effectItem.move, self.effectItems)
def clearEffectItems(self, item=None):
# TODO: fix this ugly. for some reason I cant remove elements
# while iterating.
itemsCopy = self.effectItems.copy()
for i in itemsCopy:
if item is not None and i.type() == item.Type:
self.removeEffectItem(i)
elif item is None:
self.removeEffectItem(i)
assert not self.effectItems
def readBoard(self, board):
"""
Creates new pieces according to board.
"""
self.board = copy.deepcopy(board)
for s in self.squareWidgets:
s.clearEffectItems()
p = self.board.piece_at(s.square)
if not p or (s.pieceItem and s.pieceItem.piece != p):
s.removePiece(True)
if p and (not s.pieceItem or
(s.pieceItem and s.pieceItem.piece != p)):
newPieceItem = self.createPiece(p)
s.addPiece(newPieceItem)
def updatePVItems(self, longestPV):
if not longestPV:
self.clearEffectItems(ArrowGraphicsItem)
return
self.longestPV = longestPV
length = min(len(longestPV),
int(userConfig.config['BOARD']['numArrows']))
# Arrows
moveList = longestPV[:length]
# Remove all non-repeated arrows
curArrows = [a for a in self.effectItems if a.type() ==
ArrowGraphicsItem.Type]
for a in curArrows.copy():
if a.move not in moveList:
self.removeEffectItem(a)
curArrows.remove(a)
# Add new arrows, or modify existing ones
for i, m in enumerate(moveList):
arrow = [a for a in curArrows if a.move == m]
if arrow:
opacity = 1.0 - i / length
arrow[0].setOpacity(opacity)
else:
hero = self.heroColor == (i+self.board.turn) % 2
opacity = 1.0 - i / length
self.addEffectItem(ArrowGraphicsItem, m,
hero, length - i, opacity)
assert len(self.effectItems) <= length
def createPositionAnimation(self, item, duration):
ani = QPropertyAnimation(item, b'pos', self)
ani.setDuration(duration)
ani.setStartValue(item.pos())
width = self.squareWidth * 7
ani.setEndValue(QPointF(width - item.x(),
width - item.y()))
return ani
def flipBoard(self):
self.heroColor = not self.heroColor
curArrows = [a for a in self.effectItems if a.type() ==
ArrowGraphicsItem.Type]
for a in curArrows:
a.changeHero()
aniGroup = BoardAnimationGroup(self, curArrows + self.squareWidgets)
aniDuration = 250
for sq in self.squareWidgets:
ani = self.createPositionAnimation(sq, aniDuration)
aniGroup.addAnimation(ani)
if sq.pieceItem:
ani2 = self.createPositionAnimation(sq.pieceItem, aniDuration)
aniGroup.addAnimation(ani2)
aniGroup.start()
def toggleCoordinates(self):
# TODO: implement
pass
def pieceClicked(self, square):
# This is a two-click capture move.
if (self.board.piece_at(square).color != self.board.turn):
if self.selectedSquare != -1:
self.sendMove(square)
return
lastSelection = self.selectedSquare
# Clicking on a new or old piece deselects the previous squares
self.deselectSquares()
self.selectedSquare = square
self.updateSelectionGraphics(lastSelection, square)
def pieceDragStarting(self, square):
self.dragPieceAhead = self.squareWidgets[square].pieceItem
self.squareWidgets[square].removePiece()
self.dragPieceAhead.setZValue(150)
self.dragPieceAhead.setCursor(Qt.SizeAllCursor)
pieceImg = QPixmap(self.squareWidth, self.squareWidth)
pieceImg.fill(QColor(0, 0, 0, 0))
painter = QPainter(pieceImg)
self.dragPieceAhead.renderer().render(painter)
painter.end()
self.dragPieceBehind = QGraphicsPixmapItem(pieceImg)
self.dragPieceBehind.setPos(self.squareWidgets[square].pos())
self.dragPieceBehind.setOpacity(0.5)
self.addItem(self.dragPieceBehind)
def pieceDragHappening(self, mousePos):
squareWidget = self.squareWidgetAt(mousePos)
if squareWidget is not None:
if self.lastMouseSquare != squareWidget:
squareWidget.hoverEnterEvent(None)
if self.lastMouseSquare is not None:
self.lastMouseSquare.hoverLeaveEvent(None)
self.lastMouseSquare = squareWidget
def pieceDragStopping(self, square, mousePos):
print('time1', time.time())
assert(self.dragPieceBehind is not None)
self.removeItem(self.dragPieceBehind)
self.dragPieceBehind = None
assert(self.dragPieceAhead is not None)
self.squareWidgets[square].addPiece(self.dragPieceAhead)
# This is a drag and drop move
toWidget = self.squareWidgetAt(mousePos)
if toWidget is not None and toWidget.isValidMove:
self.dragPieceAhead.setCursor(Qt.ArrowCursor)
self.dragPieceAhead = None
self.sendMove(toWidget.square, square)
else:
self.dragPieceAhead.setCursor(Qt.PointingHandCursor)
self.dragPieceAhead = None
self.deselectSquares()
def deselectSquares(self):
for s in self.squareWidgets:
if s.isValidMove:
s.isValidMove = False
s.removeEffectItem(SquareWidget.ValidMove)
self.squareWidgets[self.selectedSquare].removeEffectItem(
SquareWidget.Selected)
self.selectedSquare = -1
def reset(self, newNode):
print('board reset', newNode.board().fen())
self.dragPieceBehind = None
self.dragPieceAhead = None
self.selectedSquare = -1
self.lastMouseSquare = None
# For squares
self.readBoard(newNode.board())
self.updateSquareEffects()
# For arrows
self.longestPV = []
self.clearEffectItems()
def writeBoard(self):
"""
Returns a chess.board representative of self.squareWidgets.
Castling rights and ep squares are added, and the position is
validated as well, although it can be overridden by the user.
"""
returnBoard = chess.Board()
returnBoard.clear()
for i in range(self.squareWidgets):
p = self.squareWidgets.piece
if p:
returnBoard.set_piece_at(i, p)
if returnBoard.status() == chess.STATUS_VALID:
return returnBoard
else:
errors = [strings.BOARD_ERROR_DICT[error] for error in
constants.CHESS_ERRORS if error & returnBoard.status()]
errorString = '{}\n{}\n\n{}'.format(strings.BOARD_ERROR,
'\n'.join(errors),
strings.BOARD_ERROR_CONTINUE)
response = QMessageBox.warning(self, strings.BOARD_ERROR_TITLE,
errorString,
QMessageBox.Yes | QMessageBox.No)
if response == QMessageBox.Yes:
return returnBoard
else:
return None
def editBoard(self):
pieces = [chess.Piece(t, c) for t in chess.PIECE_TYPES
for c in chess.COLORS]
class painter(QGraphicsView):
pixelSize = int(15 / narrowRatio)
width = int(480 / narrowRatio)
height = int(360 / narrowRatio)
fontSize = int(15 / narrowRatio)
anchorLineSize = int(100 / narrowRatio)
ellipseRadius = int(8 / narrowRatio)
textInterval = int(90 / narrowRatio)
col = width / pixelSize
line = height / pixelSize
centerIndex = int(round(((line / 2 - 1) * col) + col / 2))
frameCount = 0
failedCount = 0
baseZValue = 0
mode = 1
body = 1
open_status = 0
textLineHeight = fontSize + 10
blurRaduis = 50 # Smoother improvement
def __init__(self, dataThread):
super(painter, self).__init__()
self.dataThread = dataThread
self.setFixedSize(self.width + 200, self.height + self.textLineHeight)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scene = QGraphicsScene()
self.setScene(self.scene)
# center het text item
self.centerTextItem = QGraphicsTextItem()
self.centerTextItem.setPos((self.width + 200) / 2 - self.fontSize, 0)
self.centerTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.centerTextItem)
# version text item
self.versionTextItem = QGraphicsTextItem()
self.versionTextItem.setPos(self.width * 0.8 - self.fontSize,
self.height * 0.8 - self.fontSize)
self.versionTextItem.setZValue(self.baseZValue + 1)
self.scene.addItem(self.versionTextItem)
self.userCom = None
# 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 useBlur:
self.gusBlurEffect = QGraphicsBlurEffect()
self.gusBlurEffect.setBlurRadius(self.blurRaduis)
self.cameraItem.setGraphicsEffect(self.gusBlurEffect)
self.cameraItem.setPos(100, 0)
self.cameraItem.setZValue(self.baseZValue)
self.scene.addItem(self.cameraItem)
# het text item
self.hetTextBuffer = QPixmap(self.width + 200, self.textLineHeight)
self.hetTextItem = QGraphicsPixmapItem()
self.hetTextItem.setPos(0, self.height)
self.hetTextItem.setZValue(self.baseZValue)
self.scene.addItem(self.hetTextItem)
# button item
self.ctrlOpenButton = QPushButton('Open', self)
self.ctrlOpenButton.clicked.connect(self.ctrlOpen)
self.ctrlOpenButton.setGeometry(10, 30, 100, 40)
self.EvaluateButton = QPushButton('None', self)
self.EvaluateButton.clicked.connect(self.evaluate)
self.EvaluateButton.setGeometry(10, 80, 100, 40)
self.getOnePicButton = QPushButton('Get a frame', self)
self.getOnePicButton.clicked.connect(self.ctrlSendone)
self.getOnePicButton.setGeometry(10, 130, 100, 40)
self.getOnePicButton.setEnabled(False)
self.modeManualButton = QPushButton('Auto', self)
self.modeManualButton.clicked.connect(self.modeManual)
self.modeManualButton.setGeometry(10, 180, 100, 40)
self.modeObjButton = QPushButton('Body', self)
self.modeObjButton.clicked.connect(self.objBody)
self.modeObjButton.setGeometry(10, 230, 100, 40)
self.modeFpsButton = QPushButton('4FPS', self)
self.modeFpsButton.clicked.connect(self.rate)
self.modeFpsButton.setGeometry(10, 280, 100, 40)
self.modeAutoButton = QPushButton('Get offset', self)
self.modeAutoButton.clicked.connect(self.commonOffset)
self.modeAutoButton.setGeometry(570, 30, 100, 40)
self.modeAutoButton = QPushButton('Get version', self)
self.modeAutoButton.clicked.connect(self.sysVer)
self.modeAutoButton.setGeometry(570, 80, 100, 40)
self.evaluate = 1
self.evaluateButton = QPushButton('Evaluate', self)
self.evaluateButton.clicked.connect(self.setEvaluate)
self.evaluateButton.setGeometry(570, 120, 100, 40)
self.serial_l = QLabel(self)
self.serial_l.move(580, 250)
self.serial_l.resize(60, 30)
self.serial_l.setStyleSheet(
"QLabel{color:rgb(0,0,0,255);background-color: rgb(255,255,255);font-size:16px;font-weight:normal;font-family:Arial;}"
)
self.serial_l.setText("Serial:")
self.serialList = SerialComboBox(self)
self.serialList.setCurrentIndex(0)
self.serialList.setStyleSheet(
"border-width: 1px;border-style: solid;border-color: rgb(255, 170, 0);"
)
self.serialList.currentIndexChanged.connect(self.serialChange)
# self.evaluateButton.setGeometry(570,140,100,40)
self.serialList.move(580, 280)
self.serialList.resize(120, 30)
self.serialList.addItem("Please select serial device")
def checkSerial(self):
reply = QMessageBox.information(self, 'No serial',
"Please select serial device",
QMessageBox.Yes)
# portlist = SerialComboBox().get_port_list(self)
# self.userCom = None
# if portlist is not None:
# for port in portlist:
# print("port ",port)
# self.userCom = port
# if self.userCom is not None :
# self.dataThread.openSerial(self.userCom)
# else:
# reply = QMessageBox.information(self, '没有设置串口', "请选择串口" , QMessageBox.Yes)
def serialChange(self, i):
print("serialChange", i, self.serialList.currentText())
if i > 0:
self.userCom = self.serialList.currentText()
self.dataThread.initSerialPort(self.userCom)
def ctrlOpen(self):
print("self.userCom", self.userCom)
if self.userCom is None:
self.checkSerial()
return
if self.open_status == 1:
print('start send C command 0')
self.open_status = 0
self.ctrlOpenButton.setText("Open")
self.dataThread.sendData('CMDC\0')
else:
print('start send C command 1')
self.open_status = 1
self.ctrlOpenButton.setText("Close")
self.dataThread.sendData('CMDC\1')
def evaluate(self):
if self.userCom is None:
self.checkSerial()
return
global evaluate_mode
if evaluate_mode == "operate":
print('start send E command 0')
evaluate_mode = "evaluate"
self.EvaluateButton.setText("Evaluate")
self.dataThread.sendData('CMDE\1')
else:
print('start send E command 1')
evaluate_mode = "operate"
self.EvaluateButton.setText("Operate")
self.dataThread.sendData('CMDE\0')
def ctrlSendone(self):
if self.userCom is None:
self.checkSerial()
return
print('send a frame')
self.dataThread.sendData('CMDC\2')
def modeManual(self):
if self.userCom is None:
self.checkSerial()
return
if self.mode == 1:
self.getOnePicButton.setEnabled(True)
self.modeManualButton.setText("Manual")
self.dataThread.sendData('CMDM\0')
self.mode = 0
print('mode: manual')
else:
self.getOnePicButton.setEnabled(False)
self.modeManualButton.setText("Auto")
self.dataThread.sendData('CMDM\1')
print('mode: auto')
self.mode = 1
def modeAuto(self):
if self.userCom is None:
self.checkSerial()
return
print('mode: auto')
self.dataThread.sendData('CMDM\1')
def rate(self):
if self.userCom is None:
self.checkSerial()
return
global btn_index
btn_index = (btn_index + 1) % 5
print('FPS:', strButton[btn_index])
self.modeFpsButton.setText(strButton[btn_index])
self.dataThread.sendData(strFpsCmd[btn_index]) #'CMDF\0')
def objBody(self):
if self.userCom is None:
self.checkSerial()
return
if self.body == 1:
self.body = 0
print('obj: Object')
self.modeObjButton.setText("Object")
self.dataThread.sendData('CMDO\0')
else:
self.body = 1
print('obj: Human Body')
self.modeObjButton.setText("Body")
self.dataThread.sendData('CMDO\1')
def uiUpdate(self):
global evaluate_mode
print("update UI ", evaluate_mode)
if evaluate_mode == "operate":
self.EvaluateButton.setText("Operate")
elif evaluate_mode == "evaluate":
self.EvaluateButton.setText("Evaluate")
else:
self.EvaluateButton.setText("None")
def cmdUpdate(self):
if self.userCom is None:
self.checkSerial()
return
print("get evaluate status and version\n")
time.sleep(0.1)
self.dataThread.sendData('CMDE\2')
time.sleep(0.1)
self.dataThread.sendData('CMDV\0')
time.sleep(0.1)
self.dataThread.sendData('CMDT\1')
def commonOffset(self):
if self.userCom is None:
self.checkSerial()
return
self.dataThread.sendData('CMDT\1')
print("Get commonOffset")
def sysVer(self):
if self.userCom is None:
self.checkSerial()
return
self.dataThread.sendData('CMDV\1')
print("Get firmware version and calibration version.")
def setEvaluate(self):
if self.userCom is None:
self.checkSerial()
return
if self.evaluate == 1:
self.evaluate = 0
self.evaluateButton.setText("Operate")
self.dataThread.sendData('CMDE\0')
else:
self.evaluate = 1
self.evaluateButton.setText("Evaluate")
self.dataThread.sendData('CMDE\1')
def draw(self):
global minHue
global maxHue
global maxHet
global minHet
global device_commonOffset
global evaluate_mode
if len(displayData) == 0:
return
font = QFont()
color = QColor()
font.setPointSize(self.fontSize)
#font.setFamily("Microsoft YaHei")
font.setLetterSpacing(QFont.AbsoluteSpacing, 0)
index = 0
lock.acquire()
frame = displayData.pop(0)
lock.release()
p = QPainter(self.cameraBuffer)
p.fillRect(0, 0, self.width, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
# draw camera
color = QColor()
cneter = 0.0
if chip == "90640":
if self.centerIndex == 0:
centerIndex = 12 * 32 + 16
for yIndex in range(int(self.height / self.pixelSize)):
for xIndex in range(int(self.width / self.pixelSize)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize,
yIndex * self.pixelSize, self.pixelSize,
self.pixelSize, QBrush(color))
index = index + 1
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
elif chip == "90621":
if self.centerIndex == 0 or self.centerIndex >= 64:
self.centerIndex = 2 * 16 + 8
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
for yIndex in range(int(self.height / self.pixelSize / 6)):
for xIndex in range(int(self.width / self.pixelSize / 2)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize * 2,
yIndex * self.pixelSize * 2 + 160,
self.pixelSize * 2, self.pixelSize * 2,
QBrush(color))
index = index + 1
elif chip == "90641":
if self.centerIndex == 0 or self.centerIndex >= 192:
self.centerIndex = 6 * 16 + 8
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet,
maxHet), 1)
for yIndex in range(int(self.height / self.pixelSize / 2)):
for xIndex in range(int(self.width / self.pixelSize / 2)):
color.setHsvF(frame[index] / 360, 1.0, 1.0)
p.fillRect(xIndex * self.pixelSize * 2,
yIndex * self.pixelSize * 2, self.pixelSize * 2,
self.pixelSize * 2, QBrush(color))
index = index + 1
else:
print("Dsiplay Error: can't detect any chip type!")
self.cameraItem.setPixmap(self.cameraBuffer)
self.frameCount = self.frameCount + 1
# draw text
p = QPainter(self.hetTextBuffer)
p.fillRect(0, 0, self.width + 200, self.height + self.textLineHeight,
QBrush(QColor(Qt.black)))
version = self.dataThread.getID()
p.setPen(QColor(Qt.white))
p.setFont(font)
p.drawText(0, self.fontSize, " max:" + '{:.2f}'.format(maxHet))
p.drawText(self.textInterval, self.fontSize,
" min:" + '{:.2f}'.format(minHet))
p.drawText(self.textInterval * 2, self.fontSize,
"offset:" + '{:.2f}'.format(device_commonOffset))
p.drawText(self.textInterval * 3, self.fontSize,
"mode:" + detect_status)
p.drawText(self.textInterval * 4, self.fontSize, evaluate_mode)
p.drawText(self.textInterval * 5, self.fontSize,
"ID:" + str(version[0]))
p.drawText(self.textInterval * 6, self.fontSize,
"ver:" + str(version[1] & 0xff))
p.drawText(self.textInterval * 7, self.fontSize, chip)
self.hetTextItem.setPixmap(self.hetTextBuffer)
cneter = round(
mapValue(frame[self.centerIndex], minHue, maxHue, minHet, maxHet),
1)
centerText = "<font color=white>%s</font>"
self.centerTextItem.setFont(font)
self.centerTextItem.setHtml(centerText % (str(cneter) + "°"))
# draw version text
self.versionTextItem.setFont(font)
