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 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__(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))