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))
def evaluate(self):
if not self.videoPlaybackWidget.isOpened():
return
qimg = misc.cvMatToQImage(self.cv_img)
pixmapItem = QGraphicsPixmapItem(QPixmap.fromImage(qimg))
pixmapItem.setOpacity(0.2)
self.frameBuffer.put(pixmapItem)
self.frameBufferItemGroup.addToGroup(pixmapItem)
if self.frameBuffer.qsize() > 10:
item = self.frameBuffer.get()
self.frameBufferItemGroup.removeFromGroup(item)
"""
if self.trackingPathGroup is not None:
self.trackingPathGroup.setPoints(self.currentFrameNo)
"""
if self.handInputSystem is not None:
self.handInputSystem.setPoints(self.currentFrameNo)
if self.drawingFlag is True:
mousePosition = QCursor().pos()
mousePosition = self.inputGraphicsView.mapFromGlobal(mousePosition)
mousePosition = self.inputGraphicsView.mapToScene(mousePosition)
pos = [mousePosition.x(),mousePosition.y()]
self.handInputSystem.appendPosition(pos,self.currentFrameNo)
def __init__(self, pixmap, c_width, c_height):
QGraphicsPixmapItem.__init__(self, None)
self.c_width = c_width # Container width
self.c_height = c_height # Container height
self.setPixmap(pixmap) # The pixmap
self.setFlag(QGraphicsItem.ItemIsMovable) # Make it movable
self.pixmap = self.pixmap() # just call it once
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)
def applyEffectToPixmap(pixmap, effect):
scene = QGraphicsScene()
item = QGraphicsPixmapItem()
item.setPixmap(pixmap)
item.setGraphicsEffect(effect)
scene.addItem(item)
res = QPixmap(pixmap.size())
res.fill(Qt.transparent)
painter = QPainter(res)
scene.render(painter)
return res
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)
def drawImage(self, image):
height, width, dim = image.shape
image = QImage(image, width, height, dim * width, QImage.Format_RGB888)
image_item = QGraphicsPixmapItem(QPixmap.fromImage(image))
self.scene = QGraphicsScene()
__width = image_item.boundingRect().width()
__height = image_item.boundingRect().height()
self.graphicsResize(__width, __height)
self.scene.addItem(image_item)
self.imageView.setScene(self.scene)
def blurPixmap(pixmap, radius):
effect = QGraphicsBlurEffect()
effect.setBlurRadius(radius)
buffer = QPixmap(pixmap)
item = QGraphicsPixmapItem(buffer)
item.setGraphicsEffect(effect)
output = QPixmap(pixmap.width(), pixmap.height())
painter = QtGui.QPainter(output)
scene = QtWidgets.QGraphicsScene()
view = QtWidgets.QGraphicsView(scene)
scene.addItem(item)
scene.render(painter)
return output
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()
def __init__(self, parent, client1, client2, boardWidth, boardHeight):
super(Blob, self).__init__()
self.parent = parent
self.blob = QGraphicsPixmapItem()
self.width = 100
self.height = 100
self.driver = client1
self.gunner = client2
self.blob.setPixmap(QPixmap('C:\\Users\\michaelh\\Desktop\\CSC Project\\Server\\src\\resources\\blueBlob.png'))
self.blob.setPixmap(self.blob.pixmap().scaled(self.width, self.height,
Qt.KeepAspectRatio, Qt.SmoothTransformation))
self.defSpeed = 3
self.xSpeed = 0
self.ySpeed = 0
self.hits = 0
self.gun = Gun(self, boardWidth, boardHeight)
self.gun.setPos((self.width - self.gun.width) / 2, (self.height - self.gun.height) / 2)
self.addToGroup(self.blob)
self.addToGroup(self.gun)
self.show()
def create_scene(self):
pixmap = QPixmap(self.image_filename)
size = pixmap.size()
self.imageSizeChanged.emit(size)
self._item = QGraphicsPixmapItem(pixmap)
self._item.setCacheMode(QGraphicsPixmapItem.NoCache)
self._item.setZValue(0)
self.scene().addItem(self._item)
self.__emit_scale_factor()
def updateImg(self, width=0): if not self.pixmap or not self.img: return; width = width or self.getWidth(); self.img.setParentItem(None); self.scene().removeItem(self.img); self.img = QGraphicsPixmapItem(self.pixmap.scaledToWidth(width)); self.img.setFlags(QGraphicsItem.ItemStacksBehindParent); # self.img.setOffset(0, -self.img.boundingRect().height()); self.img.setParentItem(self); self.img.setScale(1/self.scale()); self.update();
def __init__(self, Xe4Thru_worker: workers.Xe4ThruWorker, *args, **kwargs):
super().__init__()
self.Xe4Thru_worker = Xe4Thru_worker
self.Xe4Thru_worker.signal_data.connect(
self.control_process_xethru_data)
self.main_page = QtWidgets.QVBoxLayout(self)
self.setLayout(self.main_page)
self.graph_container1 = init_container(
parent=self.main_page,
vertical=True,
label="RF Frame and Baseband Frame",
label_bold=True,
label_position="lefttop")
self.graph_container2 = init_container(parent=self.main_page,
vertical=True,
label="Clutter Removed frame",
label_bold=True,
label_position="lefttop")
self.graph_container3 = init_container(parent=self.main_page,
vertical=True,
label="BASEBAND HISTORY",
label_bold=True,
label_position="lefttop")
# plots
self.rf_curve, self.baseband_curve = self.init_xethrux4_runtime_view(
parent=self.graph_container1, label="Clutter frame")
self.clutter_free_rf_curve, self.clutter_free_baseband_curve = self.init_xethrux4_runtime_view(
parent=self.graph_container2, label="Clutter free frame")
self.xethrux4_ir_spectrogram_display = QGraphicsPixmapItem()
self.xethrux4_runtime_view = self.init_spec_view(
parent=self.graph_container3,
label="XeThruX4",
graph=self.xethrux4_ir_spectrogram_display)
def get_ng_sample_image_path(self):
test_ng_path = str(Dataset.images_path(Dataset.Category.TEST_NG))
test_ng_images = os.listdir(test_ng_path)
test_ng_images = [
img for img in test_ng_images
if Path(img).suffix in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']
]
if not test_ng_images:
return
original_image_path = os.path.join(test_ng_path, test_ng_images[0])
original_image = cv2.imread(original_image_path)
h, w, c = original_image.shape
self.h, self.w = h, w
original_image_shape = QSize(w + 2, h + 10)
original_image_item = QGraphicsPixmapItem(QPixmap(original_image_path))
original_image_item.setZValue(0)
self.original_image_scene = QGraphicsScene()
self.original_image_scene.addItem(original_image_item)
self.ui.original_image_view.setScene(self.original_image_scene)
self.ui.original_image_view.setBaseSize(original_image_shape)
self.ui.original_image_view.setMaximumSize(original_image_shape)
self.resize(self.w + 32, self.h + 72)
def __init__(self):
QGraphicsScene.__init__(self)
# 60hz에 가까운 주기로 새로고침함(16ms에 1번 = 960ms(0.96초)에 16번)
self.timer = QBasicTimer()
self.timer.start(FRAME_TIME_MS, self)
self.cleared = False
self.gameover = False
self.gameover_bg = QGraphicsPixmapItem(QPixmap("gameover.png"))
self.gameover_bg.setScale(0.57)
# 배경 사진 설정
bg = QGraphicsPixmapItem()
bg.setPixmap(QPixmap("bg_brick.png"))
bg.setScale(0.25)
self.addItem(bg)
# 맵 조성
self.terrain1 = SolidRect(0, 560, 800, 40) # 제일 밑 땅.
self.addItem(self.terrain1)
self.terrain2 = SolidRect(0, 440, 500, 40)
self.addItem(self.terrain2)
# 맵 object 추가
self.f_door = f_door()
self.f_door.setPos(0, 440 - 64)
self.addItem(self.f_door)
self.w_door = w_door()
self.w_door.setPos(60, 440 - 64)
self.addItem(self.w_door)
self.slide_v1 = Slide_V(440, 480, 60, 80)
self.addItem(self.slide_v1)
self.button_v1 = Button(Slide_V, 200, 550)
self.addItem(self.button_v1)
self.button_v2 = Button(Slide_V, 200, 430)
self.addItem(self.button_v2)
# 파이어보이 생성 및 좌표 지정
self.player1 = player.Player1()
self.player1.setPos(60, 500)
self.addItem(self.player1)
# 워터걸 생성 및 좌표 지정
self.player2 = player.Player2()
self.player2.setPos(120, 500)
self.addItem(self.player2)
def setImage(self, filePath: str) -> None:
"""
Convert `filaPath` to an instance of QPixmap and add
it to the scene.
"""
pixmap = self.convertToPixmap(filePath)
item = QGraphicsPixmapItem()
item.setPixmap(pixmap)
item.setTransformationMode(Qt.SmoothTransformation)
self._update_scene(item, item.boundingRect())
def choose_file(self):
fileName_choose, filetype = QFileDialog.getOpenFileName(
self,
"选取文件",
self.cwd, # 起始路径
"JPG Files (*.jpg);;PNG Files (*.png);;TIF Files (*.tif)"
) # 设置文件扩展名过滤,用双分号间隔
if fileName_choose == "":
print("\n取消选择")
self.lineEdit.setText("取消选择")
return
print("\n你选择的文件为:")
self.lineEdit.setText(fileName_choose)
print(fileName_choose)
print("文件筛选器类型: ", filetype)
img = cv2.imread(fileName_choose)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#img=Image.open(fileName_choose)
#img=img.resize([224,224])
#img.show()
#获得控件尺寸==》（0，0，449，391）
print(self.graphicsView.rect())
img = np.uint8(img)
self.img = img
x = img.shape[1]
y = img.shape[0]
min = 391
scale = min / max(x, y)
self.zoomscale = scale
frame = QImage(img, x, y, x * img.shape[2], QImage.Format_RGB888)
pix = QPixmap.fromImage(frame)
self.item = QGraphicsPixmapItem(pix)
self.item.setScale(self.zoomscale)
self.scene = QGraphicsScene()
self.scene.addItem(self.item)
self.graphicsView.setScene(self.scene)
def reset_im(self):
image_file = os.path.join((self._presenter["fractal"]).directory,
self._presenter["image"] + ".png")
valid_image = True
try:
with PIL.Image.open(image_file) as im:
info = im.info
nx, ny = im.size
# print("info debug", info["debug"])
except FileNotFoundError:
valid_image = False
info = {"x": None, "y": None, "dx": None, "xy_ratio": None}
nx = None
ny = None
# Storing the "initial" zoom info
self._fractal_zoom_init = {k: info[k] for k in
["x", "y", "dx", "xy_ratio"]}
self._fractal_zoom_init["nx"] = nx
self._fractal_zoom_init["ny"] = ny
self.validate()
# if self._qim is not None:
# self._group.removeFromGroup(self._qim)
for item in [self._qim, self._rect]:
if item is not None:
self._group.removeFromGroup(item)
if valid_image:
self._qim = QGraphicsPixmapItem(QtGui.QPixmap.fromImage(
QtGui.QImage(image_file)))#QtGui.QImage()))#imqt)) # QtGui.QImage(self._im)))
self._qim.setAcceptHoverEvents(True)
self._group.addToGroup(self._qim)
self.fit_image()
else:
self._qim = None
self._rect = None
self._drawing_rect = False
def showImage(self): #显示第一次检查的第一张图片
self.image_path = self.Filedic3 + '/' + self.image_path_all[
self.current_num_2]
img = QImage(self.image_path)
size = QSize(650, 690)
pixImg = QPixmap.fromImage(img.scaled(size, Qt.KeepAspectRatio))
self.graphicsView.scene = QGraphicsScene() # 创建一个图片元素的对象
item = QGraphicsPixmapItem(pixImg) # 创建一个变量用于承载加载后的图片
self.graphicsView.scene.addItem(item) # 将加载后的图片传递给scene对象
self.graphicsView.setScene(self.graphicsView.scene) # 这个我也不知道是做了个啥
def open(self):
if not self.flag_open:
self.graphicsView.viewport().update()
self.graphicsView.scene().clear()
self.filename = QFileDialog.getOpenFileName(filter="Image files (*.jpg *.png)\nAny files (*)")[0]
self.setWindowTitle(self.basic_name + self.filename)
image = QImage(self.filename)
item = QGraphicsPixmapItem(QPixmap.fromImage(image))
self.graphicsView.scene().addItem(item)
self.graphicsView.show()
self.flag_open = True
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 updateInputGraphicsView(self):
self.inputScene.removeItem(self.inputPixMapItem)
qimg = misc.cvMatToQImage(self.cv_img)
self.inputPixMap = QPixmap.fromImage(qimg)
rect = QtCore.QRectF(self.inputPixMap.rect())
self.inputScene.setSceneRect(rect)
self.inputPixMapItem = QGraphicsPixmapItem(self.inputPixMap)
self.inputScene.addItem(self.inputPixMapItem)
self.inputGraphicsView.viewport().update()
self.inputGraphicsViewResized()
def shapes(self):
"""
Tworzę itemy
:return:
"""
w = 0
k = 0
idx_counter = 0
for r in range(-5, 5, 1):
for c in range(-5, 5, 1):
he = HexagonItem(6, 30, (-500) + 90 * c, (-300) + r * 50, w, k,
idx_counter)
he.create_poly()
hex_items.append(he)
self.scene.addItem(hex_items[idx_counter])
idx_counter += 1
k += 2
w += 1
k = 1
for c in range(-5, 5, 1):
he = HexagonItem(6, 30, (-500) + 45 + (90 * c),
(-300) + (r * 50) + 25, w, k, idx_counter)
he.create_poly()
hex_items.append(he)
self.scene.addItem(hex_items[idx_counter])
idx_counter += 1
k += 2
w += 1
k = 0
# Użycie resources za pomoca QGraphicsPixmapItem do wyświetlania grafik
im_qrc = QGraphicsPixmapItem()
path = QPixmap(":/mojqrc/sn_img.jpg")
im_qrc.setPixmap(path)
self.scene_img.addItem(im_qrc)
def evaluate(self):
if not self.videoPlaybackWidget.isOpened():
return
qimg = misc.cvMatToQImage(self.cv_img)
pixmapItem = QGraphicsPixmapItem(QPixmap.fromImage(qimg))
pixmapItem.setOpacity(0.2)
self.frameBuffer.put(pixmapItem)
self.frameBufferItemGroup.addToGroup(pixmapItem)
if self.frameBuffer.qsize() > 10:
item = self.frameBuffer.get()
self.frameBufferItemGroup.removeFromGroup(item)
if self.trackingPathGroup is not None:
self.trackingPathGroup.setPoints(self.currentFrameNo)
if self.movableArrowGroup is not None:
self.movableArrowGroup.setPositions(self.currentFrameNo)
for k, v in self.line_item_dict.items():
v.setPolyline(self.currentFrameNo)
def evaluate(self):
if not self.videoPlaybackWidget.isOpened():
return
qimg = misc.cvMatToQImage(self.cv_img)
pixmapItem = QGraphicsPixmapItem(QPixmap.fromImage(qimg))
pixmapItem.setOpacity(0.2)
self.frameBuffer.put(pixmapItem)
self.frameBufferItemGroup.addToGroup(pixmapItem)
if self.frameBuffer.qsize() > 10:
item = self.frameBuffer.get()
self.frameBufferItemGroup.removeFromGroup(item)
if self.trackingPathGroup is not None:
self.trackingPathGroup.setPoints(self.currentFrameNo)
if self.movableArrowGroup is not None:
self.movableArrowGroup.setPositions(self.currentFrameNo)
for k, v in self.line_item_dict.items():
v.setPolyline(self.currentFrameNo)
def init_ui(self):
scene = QGraphicsScene()
scene.setBackgroundBrush(QColor(100, 100, 100))
scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
scene.setSceneRect(scene.itemsBoundingRect())
self.setDragMode(QGraphicsView.RubberBandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
self.frame_item = QGraphicsPixmapItem()
self.text_item_offset = 0
self.rect_item_array = []
self.text_item_array = []
for i in range(0, 5):
rect_item = QGraphicsRectItem()
rect_item.setVisible(False)
rect_item.setZValue(20.0)
rect_item.setPen(QPen(Qt.red, 5))
rect_item.setRect(20, 20, 20, 20)
scene.addItem(rect_item)
self.rect_item_array.append(rect_item)
text_item = QGraphicsSimpleTextItem("")
text_item.setBrush(QBrush(Qt.red))
text_item.setZValue(20.0)
text_item.setPos(10, 50)
text_item.setFont(QFont("黑体", 24))
text_item.setVisible(False)
scene.addItem(text_item)
self.text_item_array.append(text_item)
scene.addItem(self.frame_item)
self.curr_factor = 1.0
self.setScene(scene)
def __display_result_image(self, file_path):
image_reader = QImageReader(file_path)
if image_reader.canRead() is True:
widget_height = self.resultView.height()
widget_width = self.resultView.width()
image = image_reader.read().scaled(widget_width, widget_height, Qt.KeepAspectRatio)
item = QGraphicsPixmapItem(QPixmap.fromImage(image))
scene = QGraphicsScene()
scene.addItem(item)
self.resultView.setScene(scene)
else:
scene = QGraphicsScene()
self.resultView.setScene(scene)
def __init__(self, parent=None):
super(ShowImgView, self).__init__(parent)
self.img_item = QGraphicsPixmapItem()
self.scene = QGraphicsScene(self)
self.scene.addItem(self.img_item)
self.setScene(self.scene)
self.mouse_wheel_speed = 0.2
self.setBackgroundBrush(QBrush(Qt.white))
self.setMouseTracking(True)
self.setRenderHint(QStylePainter.Antialiasing, False)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setOptimizationFlags(QGraphicsView.DontSavePainterState)
self.setViewportUpdateMode(QGraphicsView.SmartViewportUpdate)
def __init__(self):
super().__init__()
self.setupUi(self)
self.current_file_name = ""
self.current_path = ""
self.bandcount = 0
self.image_count = 0
self.path = ""
self.image_size = 800
self.block_size = 800
self.points = []
self.detection_data = []
self._current_rect_item = None
self.brush = QBrush()
self.brush.setColor(Qt.red)
self.item = QGraphicsPixmapItem()
self.item.mousePressEvent = self.item_clicked
self.item.setZValue(0)
self.item.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, False)
self.item.setFlag(QtWidgets.QGraphicsItem.ItemIsFocusable, False)
self.item.setFlag(QtWidgets.QGraphicsItem.ItemStacksBehindParent, True)
self.scene = QGraphicsScene()
self.view = myGraphicsView()
self.view.setMinimumSize(QtCore.QSize(0, 0))
self.picture.addWidget(self.view, 0, 0)
self.view.setScene(self.scene)
self.menubar = self.menuBar()
self.menubar.triggered[QAction].connect(self.processtrigger)
self._start = QtCore.QPointF()
self._current_rect_item = None
self.tif_driver = gdal.GetDriverByName("GTiff")
self.tif_driver_path = ''
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(MainWindow)
gridlayout = QGridLayout(self.centralwidget)
hlayout = QHBoxLayout()
self.button1 = QPushButton(' add image ')
self.button3 = QPushButton('add video')
self.button2 = QPushButton('remove')
self.playbutton = QPushButton('play')
self.stopbutton = QPushButton('stop')
hlayout.addWidget(self.button1)
hlayout.addWidget(self.button3)
hlayout.addWidget(self.button2)
hlayout.addWidget(self.playbutton)
hlayout.addWidget(self.stopbutton)
self.scene = QGraphicsScene()
self.item = QGraphicsPixmapItem()
imgpath = 'C:\\Users\Administrator\Pictures\Saved Pictures\\1.jpg'
self.item.setPixmap(QtGui.QPixmap(imgpath))
self.scene.addItem(self.item)
self.graphicsview = QGraphicsView()
self.graphicsview.setScene(self.scene)
self.tabwidget = QTabWidget()
vlayout = QVBoxLayout()
vlayout.addLayout(hlayout)
vlayout.addWidget(self.tabwidget)
MainWindow.setCentralWidget(self.centralwidget)
gridlayout.addLayout(vlayout, 0, 0, 1, 1)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __changed_image_line_edit(self):
file_path = self.lineEdit_image.text()
image_reader = QImageReader(file_path)
if image_reader.canRead() is True:
widget_height = self.queryView.height()
widget_width = self.queryView.width()
image = image_reader.read().scaled(widget_width, widget_height, Qt.KeepAspectRatio)
item = QGraphicsPixmapItem(QPixmap.fromImage(image))
scene = QGraphicsScene()
scene.addItem(item)
self.queryView.setScene(scene)
else:
scene = QGraphicsScene()
self.queryView.setScene(scene)
def __loadGraphicItemImagePart(self, image, condition_variables):
pixmap = QPixmap(FileInfo().getPath(FileInfo.FileDataType.IMAGE,
image.name))
image_x_is_expr = isinstance(image.x, str)
image_y_is_expr = isinstance(image.y, str)
image_angle_is_expr = isinstance(image.angle, str)
width_scale, height_scale = self.__getSizeScale(
pixmap.width(), pixmap.height(), image.width, image.height)
if not image_angle_is_expr:
pixmap = pixmap.transformed(QTransform().rotate(image.angle))
if image_angle_is_expr or image_x_is_expr or image_y_is_expr or \
image.condition:
gitem_part = ConditionGraphicsPixmapItem(image.condition,
pixmap,
names=condition_variables)
self.__condition_graphic_items.append(gitem_part)
else:
gitem_part = QGraphicsPixmapItem(pixmap)
gitem_part.setTransform(QTransform().scale(width_scale, height_scale))
if image_angle_is_expr:
gitem_part.setAngleOffsetExpression(image.angle)
x_offset = 0
if image_x_is_expr:
gitem_part.setXOffsetExpression(image.x,
multiplier=1 / width_scale)
else:
x_offset = image.x / width_scale
y_offset = 0
if image_y_is_expr:
gitem_part.setYOffsetExpression(image.y,
multiplier=1 / height_scale)
else:
y_offset = image.y / height_scale
gitem_part.setOffset(x_offset - pixmap.width() / 2,
y_offset - pixmap.height() / 2)
gitem_part.setZValue(image.z_value)
return gitem_part
def __init__(self, x, y, val, parent = None):
QGraphicsPixmapItem.__init__(self, parent)
self.x = x
self.y = y
if val == 1:
self.setPixmap(QPixmap("static/ground.png"))
self.setPos(self.x, self.y)
elif val == 2:
self.setPixmap(QPixmap("static/water.png"))
self.setPos(self.x, self.y)
elif val == 3:
self.setPixmap(QPixmap("static/box.png"))
self.setPos(self.x, self.y)
elif val == 4:
self.setPixmap(QPixmap("static/tube_top.png"))
self.setPos(self.x-5, self.y)
elif val == 5:
self.setPixmap(QPixmap("static/tube.png"))
self.setPos(self.x, self.y)
elif val == 6:
self.setPixmap(QPixmap("static/tile1.png"))
self.setPos(self.x, self.y)
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 __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 load_image_encode(self):
dialog = QFileDialog()
fname = dialog.getOpenFileName(None, "Window name", "",
"Image (*.bmp *.png)")
self.img_encode_path = fname[0]
self.inputFileEncode.setText(self.img_encode_path)
# show msg
pix = QPixmap(self.img_encode_path)
pix.scaledToHeight(10)
item = QGraphicsPixmapItem(pix)
scene = QGraphicsScene(self)
scene.addItem(item)
self.imagePreview.setScene(scene)
def clickedTree(self, currentindex):
self.pushButton.setEnabled(True)
self.select_imgname = self.treeWidget.currentItem().text(0)
img = QImage(os.path.join(self.base_path, self.select_imgname))
pix = QPixmap.fromImage(img)
pix_item = QGraphicsPixmapItem(pix)
scene = QGraphicsScene()
#self.graphicsView.fitInView(self.pix_item)
# self.scene.setSceneRect()
scene.addItem(pix_item)
self.graphicsView.setScene(scene)
self.graphicsView.show()
result = self.tree_data[self.select_imgname]
self.change_result_show('{:} {:}'.format(result[0], result[1]))
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
class ImageViewer(QGraphicsView):
factor = 1.5
def __init__(self, parent=None):
super().__init__(parent)
self.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
self.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.setBackgroundRole(QPalette.NoRole)
scene = QGraphicsScene()
self.setScene(scene)
self._pixmap_item = QGraphicsPixmapItem()
scene.addItem(self._pixmap_item)
def load_image(self, fileName):
pixmap = QPixmap(fileName)
if pixmap.isNull():
return False
self._pixmap_item.setPixmap(pixmap)
return True
def zoom_in(self):
self.zoom(self.factor)
def zoom_out(self):
self.zoom(1 / self.factor)
def zoom(self, f):
self.scale(f, f)
def reset_zoom(self):
self.resetTransform()
def fit_to_window(self):
self.fitInView(self.sceneRect(), QtCore.Qt.KeepAspectRatio)
def click_start(self):
try:
global token, token_list, tree, i
i = 0
tree = ASTree()
token_list = []
code = self.textEdit.toPlainText()
code = removeTag(code)
code = code.strip()
token_list = get_token(code)
token_list = [s for s in token_list if s != '' and s != ' ']
token_list.append('$') #加入结束符
token = token_list[0]
progrem()
tree.printTree()
img = cv.imread('./image/output.jpg')
self.graphicsView.scene_img = QGraphicsScene()
self.imgShow = QPixmap()
self.imgShow.load('./image/output.jpg')
self.imgShowItem = QGraphicsPixmapItem()
#self.imgShowItem.setPixmap(QPixmap(self.imgShow))
self.imgShowItem.setPixmap(
QPixmap(self.imgShow).scaled(img.shape[1],
img.shape[0])) #自己设定尺寸
self.graphicsView.scene_img.addItem(self.imgShowItem)
self.graphicsView.setScene(self.graphicsView.scene_img)
self.graphicsView.fitInView(
QGraphicsPixmapItem(QPixmap(self.imgShow)))
QtWidgets.QMessageBox.information(self, '提示',
'生成AST成功!\n原图片存放在路径：./image',
QMessageBox.Yes)
except ValueError:
QtWidgets.QMessageBox.critical(self, '错误', '生成AST失败！请检查代码语法格式！',
QMessageBox.Yes)
def on_item_changed(self, current, previous):
if not current:
return
crc, goodname, path, fname = current.data(Qt.UserRole)
title = QPixmap(
os.path.join(self.user_data_path, "title", "%s.png") % crc)
snapshot = QPixmap(
os.path.join(self.user_data_path, "snapshot", "%s.png") % crc)
if title.isNull():
title = QPixmap(":/title/%s.jpg" % crc)
if snapshot.isNull():
snapshot = QPixmap(":/snapshot/%s.jpg" % crc)
if title.isNull():
title = QPixmap(":/images/default.png")
if snapshot.isNull():
snapshot = QPixmap(":/images/default.png")
if previous is not None:
self.titleView.scene().removeItem(self.title_item)
self.snapshotView.scene().removeItem(self.snapshot_item)
title_pixmap = title.scaled(self.titleView.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
snapshot_pixmap = snapshot.scaled(self.snapshotView.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
title_item = QGraphicsPixmapItem(title_pixmap)
snapshot_item = QGraphicsPixmapItem(snapshot_pixmap)
self.titleView.scene().addItem(title_item)
self.snapshotView.scene().addItem(snapshot_item)
self.title_item = title_item
self.snapshot_item = snapshot_item
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)
def initUI(self):
self.setStyleSheet("background: transparent")
self.setFrameShape(QFrame.NoFrame)
self.grafickascena = QGraphicsScene()
self.grafickascena.setSceneRect(0, 0, 150, 200)
tempImg = QPixmap('PNG/Level_Menu/Window.png')
tempImg = tempImg.scaled(self.grafickascena.width(),
self.grafickascena.height())
self.graphicsPixmapItem = QGraphicsPixmapItem(tempImg)
self.grafickascena.addItem(self.graphicsPixmapItem)
self.path = 'PNG/Car_' + str(self.car) + '_Main_Positions/Car_' + str(
self.car) + '_01'
#slika na okviru za hud
img = QPixmap(self.path)
img = img.scaled(100, 120)
self.image = QGraphicsPixmapItem(img)
self.image.moveBy(25, 30)
self.grafickascena.addItem(self.image)
self.initLives(4) # makes 4 heart images and positions them correctly
self.setLives(3) # show only 3 on init
#-----------------------------------------
self.label = QLabel(self.name)
self.label.setFixedWidth(120)
self.label.move(33, 11)
self.label.setStyleSheet(
'color: yellow; font-weight: bold; background: transparent;')
self.grafickascena.addWidget(self.label)
self.setScene(self.grafickascena)
def AddPictureAnswer6(self):
try:
id = self.lineEdit_tmbs.text()
if id == "":
reply = QMessageBox.information(self, "标题", "试题标识不能为空，请先添加试题！",
QMessageBox.Yes)
return
else:
fileName, filetype = QFileDialog.getOpenFileName(
self, "QFileDialog.getOpenFileName()", "", "图片文件(*.jpg);")
# 将选中的文件入库
self.m_db.WriteFileToBlob("TPDA6", "XXFZK.TKB",
"where ID='" + id + "'", fileName)
# 显示图片
image = QPixmap()
image.load(fileName)
scene = QGraphicsScene()
self.picture_answer_item6 = QGraphicsPixmapItem(image)
scene.addItem(self.picture_answer_item6)
self.graphicsView_da6.setScene(scene)
self.picture_answer_zoomscale6 = 1
except:
print("添加图片答案6时发错误！")
def __init__(self, refresh_interval, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.resize(1920, 1080)
pg.setConfigOption('background', 'w')
w = QWidget()
# create main layout
self.lay = QGridLayout(self)
# add spectrogram graphic view
self.spec_pixmap_item = QGraphicsPixmapItem()
self.init_spec_view()
# add detected points plots
self.scatterXY = self.init_pts_view(pos=(0, 3))
self.scatterZD = self.init_pts_view(pos=(0, 4))
# add the interrupt button
self.interruptBtn = QtWidgets.QPushButton(text='Interrupt')
self.interruptBtn.clicked.connect(self.interruptBtnAction)
self.lay.addWidget(self.interruptBtn, *(0, 1))
# add dialogue label
self.dialogueLabel = QLabel()
self.dialogueLabel.setText("Running")
self.lay.addWidget(self.dialogueLabel, *(0, 0))
# set the main layout
w.setLayout(self.lay)
self.setCentralWidget(w)
self.show()
# create thread pool
self.threadpool = QThreadPool()
self.timer = QTimer()
self.timer.setInterval(refresh_interval)
self.timer.timeout.connect(self.recurring_timer)
self.timer.start()
def show_processed_image(self, img, area):
img = img.astype(np.int8)
showImage = QtGui.QImage(img, img.shape[1], img.shape[0],
QtGui.QImage.Format_RGB888)
pix = QtGui.QPixmap.fromImage(showImage)
item = QGraphicsPixmapItem(pix) # 创建像素图元
scene = QGraphicsScene() # 创建场景
scene.addItem(item)
if area == 0:
self.graphicsView_0.setScene(scene) # 将场景添加至视图
elif area == 1:
self.graphicsView_1.setScene(scene)
elif area == 2:
self.graphicsView_2.setScene(scene)
def cloneBody(self, bodyspecName, dropPos, itemId=None, width=0):
bodyDef = self.bodies[bodyspecName];
if not itemId:
if bodyspecName not in self.nameIndex:
self.nameIndex[bodyspecName] = 0;
self.nameIndex[bodyspecName] += 1;
itemId = "{}{}".format(bodyspecName, self.nameIndex[bodyspecName]);
body = BodyItem(itemId, bodyspecName, 2);
self.bodyInstances.append(body);
body.setPos(dropPos);
group = QGraphicsItemGroup(body);
self.renderScene.addItem(body);
width = width*self.UNITS_PER_METER or self.DEFAULT_BODY_SIZE;
for shape in bodyDef["shapes"]:
vertices = shape["vertices"];
if shape["type"] == "POLYGON":
newItem = QGraphicsPolygonItem(QPolygonF(vertices));
if shape["type"] == "CIRCLE":
p1, p2 = vertices
radius = math.hypot(p2.x()-p1.x(), p2.y()-p1.y());
newItem = QGraphicsEllipseItem(p1.x()-radius, p1.y()-radius, radius*2, radius*2);
pen = QPen();
pen.setWidth(0);
newItem.setPen(pen);
newItem.setParentItem(group);
bounding = group.childrenBoundingRect();
imagePath = None;
height = 0;
if (bodyDef["image"]):
imagePath = bodyDef["image"];
pixmap = QPixmap(imagePath);
body.setPixmap(pixmap);
pm = QGraphicsPixmapItem(pixmap.scaledToWidth(width), body);
body.setImg(pm);
pm.setFlags(QGraphicsItem.ItemStacksBehindParent);
pm.setOffset(0, -pm.boundingRect().height());
group.setScale(width/self.TRANSCOORD_X);
height = pm.boundingRect().height();
else:
group.setScale(width/bounding.width());
height = bounding.height();
for item in body.childItems():
item.setPos(item.pos().x(), item.pos().y() + height)
body.updateBorder();
return body;
def init_ui(self):
scene = QGraphicsScene()
scene.setBackgroundBrush(QColor(100, 100, 100))
scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
scene.setSceneRect(scene.itemsBoundingRect())
self.setDragMode(QGraphicsView.RubberBandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
self.frame_item = QGraphicsPixmapItem()
self.text_item_offset = 0
self.rect_item_array = []
self.text_item_array = []
for i in range(0, 5):
rect_item = QGraphicsRectItem()
rect_item.setVisible(False)
rect_item.setZValue(20.0)
rect_item.setPen(QPen(Qt.red, 5))
rect_item.setRect(20, 20, 20, 20)
scene.addItem(rect_item)
self.rect_item_array.append(rect_item)
text_item = QGraphicsSimpleTextItem("")
text_item.setBrush(QBrush(Qt.red))
text_item.setZValue(20.0)
text_item.setPos(10, 50)
text_item.setFont(QFont("黑体", 24))
text_item.setVisible(False)
scene.addItem(text_item)
self.text_item_array.append(text_item)
scene.addItem(self.frame_item)
self.curr_factor = 1.0
self.setScene(scene)
def __init__(self, pix):
super(PixmapItem, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
class Blob(QGraphicsItemGroup):
""" Allow for a blob to be drawn on GameBoard """
def __init__(self, parent, client1, client2, boardWidth, boardHeight):
super(Blob, self).__init__()
self.parent = parent
self.blob = QGraphicsPixmapItem()
self.width = 100
self.height = 100
self.driver = client1
self.gunner = client2
self.blob.setPixmap(QPixmap('C:\\Users\\michaelh\\Desktop\\CSC Project\\Server\\src\\resources\\blueBlob.png'))
self.blob.setPixmap(self.blob.pixmap().scaled(self.width, self.height,
Qt.KeepAspectRatio, Qt.SmoothTransformation))
self.defSpeed = 3
self.xSpeed = 0
self.ySpeed = 0
self.hits = 0
self.gun = Gun(self, boardWidth, boardHeight)
self.gun.setPos((self.width - self.gun.width) / 2, (self.height - self.gun.height) / 2)
self.addToGroup(self.blob)
self.addToGroup(self.gun)
self.show()
def updatePos(self, dim, wall1, wall2):
""" update the position using the speed variable, this will be set by the GameBoard class
dim is a list of the dimensions of the board, [width, height] """
# Draw blob in it's new position
lastX = self.x()
lastY = self.y()
x = self.x() + self.xSpeed
y = self.y() + self.ySpeed
# Check x
if x < 0:
x = 0
elif x + self.width > dim[0]:
x = dim[0] - self.width # Sets x to be equal to width of the widget minus width of blob
# Check y
if y < 0:
y = 0
elif y + self.height > dim[1]:
y = dim[1] - self.height # Sets y to be equal to height of the widget minus height of blob
self.setPos(x, y)
if self.collidesWithItem(wall1) or self.collidesWithItem(wall2):
# todo while loop to allow blob to get as close sa possible to the walls
self.setPos(lastX, lastY)
def onDraw(self, dim, wall1, wall2):
self.updatePos(dim, wall1, wall2)
self.gun.onDraw(self.x(), self.y())
class BodyItem(QGraphicsRectItem): def __init__(self, itemId, bodyspecName, margin): super(BodyItem, self).__init__(0, 0, 0, 0); self.deleted = False; self.itemId = itemId; self.bodyspecName = bodyspecName; self.margin = 0; pen = QPen(Qt.SolidLine); pen.setColor(QColor(230, 230, 230)) pen.setWidth(0); self.setPen(pen); self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsMovable); self.pixmap = None; self.img = None; def meterPos(self): return QPointF(self.pos().x()/MainManager.UNITS_PER_METER, self.pos().y()/MainManager.UNITS_PER_METER); def setPosXByMeter(self, x): self.setPos(QPointF(x*MainManager.UNITS_PER_METER, self.pos().y())); def setPosYByMeter(self, y): self.setPos(QPointF(self.pos().x(), y*MainManager.UNITS_PER_METER)); def updateBorder(self): margin = self.margin / self.scale(); rect = self.childrenBoundingRect() self.setRect(QRectF(rect.x()-margin, rect.y()-margin, rect.width()+2*margin, rect.height()+2*margin)); def setDeleted(self, deleted): self.setVisible(not deleted); self.deleted = deleted; def getMeterWidth(self): return self.getWidth() / MainManager.UNITS_PER_METER; def getWidth(self): return self.childrenBoundingRect().width() * self.scale(); def getMeterHeight(self): return self.getHeight() / MainManager.UNITS_PER_METER; def getHeight(self): return self.childrenBoundingRect().height() * self.scale(); def setId(self, itemId): self.itemId = itemId; def setPixmap(self, pixmap): self.pixmap = pixmap; def setImg(self, item): self.img = item; def updateImg(self, width=0): if not self.pixmap or not self.img: return; width = width or self.getWidth(); self.img.setParentItem(None); self.scene().removeItem(self.img); self.img = QGraphicsPixmapItem(self.pixmap.scaledToWidth(width)); self.img.setFlags(QGraphicsItem.ItemStacksBehindParent); # self.img.setOffset(0, -self.img.boundingRect().height()); self.img.setParentItem(self); self.img.setScale(1/self.scale()); self.update();
def __init__(self, pix):
super(Pixmap, self).__init__()
self.pixmap_item = QGraphicsPixmapItem(pix)
self.pixmap_item.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.pixmap_item.setZValue(0)
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 ImageViewer(QGraphicsView):
scaleFactorChanged = pyqtSignal(float)
imageSizeChanged = pyqtSignal("QSize")
SCALE_FACTOR = 1.2
def __init__(self, filename):
super().__init__()
self.image_filename = filename
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setFrameShape(QGraphicsView.NoFrame)
self.setRenderHint(QPainter.SmoothPixmapTransform)
# Menu
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self._show_menu)
# Draw background
pix = QPixmap(64, 64)
pix.fill(QColor("#1e1e1e"))
painter = QPainter(pix)
color = QColor(20, 20, 20)
painter.fillRect(0, 0, 32, 32, color)
painter.fillRect(32, 32, 32, 32, color)
painter.end()
self.setBackgroundBrush(QBrush(pix))
def _show_menu(self, point):
menu = QMenu(self)
fit_action = menu.addAction(translations.TR_FIT_TO_SCREEN)
fit_action.triggered.connect(self.fit_to_screen)
restore_action = menu.addAction(translations.TR_RESTORE_SIZE)
restore_action.triggered.connect(self.restore_to_original_size)
menu.exec_(self.mapToGlobal(point))
def display_name(self):
return file_manager.get_basename(self.image_filename)
def create_scene(self):
pixmap = QPixmap(self.image_filename)
size = pixmap.size()
self.imageSizeChanged.emit(size)
self._item = QGraphicsPixmapItem(pixmap)
self._item.setCacheMode(QGraphicsPixmapItem.NoCache)
self._item.setZValue(0)
self.scene().addItem(self._item)
self.__emit_scale_factor()
def __emit_scale_factor(self):
factor = self.transform()
self.scaleFactorChanged.emit(factor.m11())
def zoom_in(self):
self.__scale(self.SCALE_FACTOR)
def zoom_out(self):
self.__scale(1 / self.SCALE_FACTOR)
def __scale(self, factor):
current = self.transform().m11()
new = current * factor
actual = factor
if new > 1000:
actual = 1000 / current
elif new < 0.001:
actual = 0.001 / current
self.scale(actual, actual)
self.__emit_scale_factor()
def drawBackground(self, painter, rect):
painter.save()
painter.resetTransform()
painter.drawTiledPixmap(
self.viewport().rect(), self.backgroundBrush().texture())
painter.restore()
def restore_to_original_size(self):
self.resetTransform()
self.__emit_scale_factor()
def fit_to_screen(self):
self.fitInView(self._item, Qt.KeepAspectRatio)
self.__emit_scale_factor()
def wheelEvent(self, event):
factor = self.SCALE_FACTOR ** (event.angleDelta().y() / 240.0)
self.__scale(factor)
event.accept()
class HyperLprImageView(QGraphicsView):
def __init__(self):
super().__init__()
self.init_ui()
def init_ui(self):
scene = QGraphicsScene()
scene.setBackgroundBrush(QColor(100, 100, 100))
scene.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
scene.setSceneRect(scene.itemsBoundingRect())
self.setDragMode(QGraphicsView.RubberBandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing)
self.frame_item = QGraphicsPixmapItem()
self.text_item_offset = 0
self.rect_item_array = []
self.text_item_array = []
for i in range(0, 5):
rect_item = QGraphicsRectItem()
rect_item.setVisible(False)
rect_item.setZValue(20.0)
rect_item.setPen(QPen(Qt.red, 5))
rect_item.setRect(20, 20, 20, 20)
scene.addItem(rect_item)
self.rect_item_array.append(rect_item)
text_item = QGraphicsSimpleTextItem("")
text_item.setBrush(QBrush(Qt.red))
text_item.setZValue(20.0)
text_item.setPos(10, 50)
text_item.setFont(QFont("黑体", 24))
text_item.setVisible(False)
scene.addItem(text_item)
self.text_item_array.append(text_item)
scene.addItem(self.frame_item)
self.curr_factor = 1.0
self.setScene(scene)
def resetRectText(self, res_set):
max_no = len(res_set)
if max_no > 5:
max_no = 5
for i in range(0, 5):
if i < max_no:
curr_rect = res_set[i][2]
self.rect_item_array[i].setRect(int(curr_rect[0]), int(
curr_rect[1]), int(curr_rect[2]), int(curr_rect[3]))
self.rect_item_array[i].setVisible(True)
self.text_item_array[i].setText(
res_set[i][4] + " " + res_set[i][3])
self.text_item_array[i].setPos(
int(curr_rect[0]), int(curr_rect[1]) - 48)
self.text_item_array[i].setVisible(True)
else:
self.text_item_array[i].setVisible(False)
self.rect_item_array[i].setVisible(False)
def wheelEvent(self, event):
factor = event.angleDelta().y() / 120.0
if event.angleDelta().y() / 120.0 > 0:
factor = 1.08
else:
factor = 0.92
if self.curr_factor > 0.1 and self.curr_factor < 10:
self.curr_factor = self.curr_factor * factor
self.scale(factor, factor)
def resetPixmap(self, image):
self.frame_item.setPixmap(QPixmap.fromImage(image))
