def add_background_to_image(self, ): assert self.image_bank is not None, "Images need to be loaded before calling this method (try load_images_json_file)" if "Background to" in self.image_bank: background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"]) self.background_to_image = QGraphicsPixmapItem(background_to_pixmap) self.scene.addItem(self.background_to_image) self.background_to_image.setZValue(2)
def make_move(self): if not self.game.is_my_turn: x = randint(0, 9) y = randint(0, 8) if self.game.my_board[x][y] not in range(2,4): if self.game.my_board[x][y] == 1: self.game.my_board[x][y] = 2 picture = 'res/cancel.png' else: self.game.my_board[x][y] = 3 picture = 'res/ok.png' if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.game.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.game.scene.addItem(self.item) print(self.game.enemies_board) print(self.game.my_board) self.game.is_my_turn = True
def get_shot(self, x, y): ''' Shot handler. :param x: x coord of shot :param y: y coord of shot ''' is_Hit = False if self.my_board[x][y] == 1: self.my_board[x][y] = 2 is_hit = True picture = 'res/ok.png' else: self.my_board[x][y] = -1 is_hit = False picture = 'res/cancel.png' if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.scene.addItem(self.item)
class StartSelectView(QGraphicsView): def __init__(self, *args): QGraphicsView.__init__(self, *args) self.move(2, 250) self.btnSize = 28 self.setMaximumHeight(self.btnSize * 2) self.setMaximumWidth(334) self.setMinimumHeight(self.btnSize * 2) self.setMinimumWidth(334) self.adjustSize() self.scene = QGraphicsScene(self) self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;') self.psButtons = QPixmap(os.getcwd() + '/../icons/controller-sprite.png') self.select = self.psButtons.copy(696, 120, 45, 30) self.select = self.select.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.selectItem = QGraphicsPixmapItem(self.select) self.selectItem.setOffset(QPointF(0, 0)) self.scene.addItem(self.selectItem) self.start = self.psButtons.copy(754, 120, 45, 30) self.start = self.start.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.startItem = QGraphicsPixmapItem(self.start) self.startItem.setOffset(QPointF(86, 0)) self.scene.addItem(self.startItem) self.setScene(self.scene)
def __init__(self, *args): self.seleccionado = False self.velocity = random.randint(1,10) QGraphicsPixmapItem.__init__(self, *args) self.setPixmap(QPixmap("sprites/"+str(random.randint(1,45))+".png")) self.setTransformOriginPoint(self.boundingRect().width()/2.0,self.boundingRect().height()/2.0) self.setZValue(10) ##menu contextual self.menu = QMenu() self.Actions =[] #arreglo de acciones self.Actions.append( self.menu.addAction("Seguir") ) self.Actions.append( self.menu.addAction("Editar") ) self.Actions.append( self.menu.addAction("girar clockwise") ) self.Actions.append( self.menu.addAction("girar anti-clockwise") ) self.Actions.append( self.menu.addAction("Colisiones") ) self.Actions.append( self.menu.addAction("Duplicar") ) self.Actions.append( self.menu.addAction("Eliminar") ) self.menu.triggered[QAction].connect(self.test) ##offset para el arrastre self.offset= QPointF(0,0) ##poligono de vision poligono = QPolygonF() poligono.append(QPointF(-1,10)) poligono.append(QPointF(-1,20)) poligono.append(QPointF(-30,40)) poligono.append(QPointF(-40,15)) poligono.append(QPointF(-30,-10)) self.vision = QGraphicsPolygonItem(poligono,self,self.scene()) self.vision.setBrush(QColor(255, 255, 0,100)) self.vision.setPen(QColor(255, 255, 0))
def __init__(self, *args): self.seleccionado = False self.velocity = random.randint(1, 10) QGraphicsPixmapItem.__init__(self, *args) self.setPixmap( QPixmap("sprites/" + str(random.randint(1, 45)) + ".png")) self.setTransformOriginPoint(self.boundingRect().width() / 2.0, self.boundingRect().height() / 2.0) self.setZValue(10) ##menu contextual self.menu = QMenu() self.Actions = [] #arreglo de acciones self.Actions.append(self.menu.addAction("Seguir")) self.Actions.append(self.menu.addAction("Editar")) self.Actions.append(self.menu.addAction("girar clockwise")) self.Actions.append(self.menu.addAction("girar anti-clockwise")) self.Actions.append(self.menu.addAction("Colisiones")) self.Actions.append(self.menu.addAction("Duplicar")) self.Actions.append(self.menu.addAction("Eliminar")) self.menu.triggered[QAction].connect(self.test) ##offset para el arrastre self.offset = QPointF(0, 0) ##poligono de vision poligono = QPolygonF() poligono.append(QPointF(-1, 10)) poligono.append(QPointF(-1, 20)) poligono.append(QPointF(-30, 40)) poligono.append(QPointF(-40, 15)) poligono.append(QPointF(-30, -10)) self.vision = QGraphicsPolygonItem(poligono, self, self.scene()) self.vision.setBrush(QColor(255, 255, 0, 100)) self.vision.setPen(QColor(255, 255, 0))
class FaceButtonsView(QGraphicsView): def __init__(self, *args): QGraphicsView.__init__(self, *args) self.move(170, 90) self.btnSize = 40 self.padding = 5 self.setMaximumHeight(self.btnSize * 4) self.setMaximumWidth(self.btnSize * 4) self.setMinimumHeight(self.btnSize * 4) self.setMinimumWidth(self.btnSize * 4) self.adjustSize() self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;') self.scene = QGraphicsScene(self) self.psButtons = QPixmap(os.getcwd() + '/../icons/PS3_Buttons.png') self.triangle = self.psButtons.copy(0, 0, 220, 225) self.triangle = self.triangle.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.square = self.psButtons.copy(220, 0, 220, 225) self.square = self.square.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.circle = self.psButtons.copy(440, 0, 220, 225) self.circle = self.circle.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.cross = self.psButtons.copy(660, 0, 220, 225) self.cross = self.cross.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.triangleItem = QGraphicsPixmapItem(self.triangle) self.triangleItem.setOffset(QPointF(self.btnSize + self.padding, 0)) self.scene.addItem(self.triangleItem) self.squareItem = QGraphicsPixmapItem(self.square) self.squareItem.setOffset(QPointF(0, self.btnSize + self.padding)) self.scene.addItem(self.squareItem) self.circleItem = QGraphicsPixmapItem(self.circle) self.circleItem.setOffset(QPointF(self.btnSize * 2 + self.padding * 2, self.btnSize + self.padding)) self.scene.addItem(self.circleItem) self.crossItem = QGraphicsPixmapItem(self.cross) self.crossItem.setOffset(QPointF(self.btnSize + self.padding, self.btnSize * 2 + self.padding * 2)) self.scene.addItem(self.crossItem) self.effect = QGraphicsDropShadowEffect() self.effect.setOffset(0, 0) self.effect.setBlurRadius(20) self.effect.setColor(Qt.green) self.triangleItem.setGraphicsEffect(self.effect) self.setScene(self.scene) self.tl2 = QTimeLine(10000) self.tl2.setFrameRange(0, 10000) self.t = QGraphicsItemAnimation() self.t.setItem(self.triangleItem) self.t.setTimeLine(self.tl2) self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect) self.effectd = 3 self.tl2.start() def updateEffect(self): if self.effect.blurRadius() > 50: self.effectd = -3 elif self.effect.blurRadius() < 5: self.effectd = 3 self.effect.setBlurRadius(self.effect.blurRadius() + self.effectd)
def __init__(self, classifier, granularity, scale, spacing, rect=None): orangeqt.PlotItem.__init__(self) self.classifier = classifier self.rect = rect self.granularity = granularity self.scale = scale self.spacing = spacing self.pixmap_item = QGraphicsPixmapItem(self) self.set_in_background(True) self.setZValue(ProbabilitiesZValue)
class DpadView(QGraphicsView): def __init__(self, *args): QGraphicsView.__init__(self, *args) self.move(2, 90) self.btnSize = 75 self.padding = -35 self.setMaximumHeight(self.btnSize * 2 + 20) self.setMaximumWidth(self.btnSize * 2 + 20) self.setMinimumHeight(self.btnSize * 2 + 20) self.setMinimumWidth(self.btnSize * 2 + 20) self.adjustSize() self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;') self.scene = QGraphicsScene(self) self.left = QPixmap(os.getcwd() + '/../icons/left.png') self.left = self.left.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.right = QPixmap(os.getcwd() + '/../icons/right.png') self.right = self.right.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.up = QPixmap(os.getcwd() + '/../icons/up.png') self.up = self.up.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.down = QPixmap(os.getcwd() + '/../icons/down.png') self.down = self.down.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.leftItem = QGraphicsPixmapItem(self.left) self.leftItem.setOffset(QPointF(0, self.btnSize + self.padding)) self.scene.addItem(self.leftItem) self.rightItem = QGraphicsPixmapItem(self.right) self.rightItem.setOffset(QPointF(self.btnSize * 2 + self.padding * 2, self.btnSize + self.padding)) self.scene.addItem(self.rightItem) self.upItem = QGraphicsPixmapItem(self.up) self.upItem.setOffset(QPointF(self.btnSize + self.padding, 0)) self.scene.addItem(self.upItem) self.downItem = QGraphicsPixmapItem(self.down) self.downItem.setOffset(QPointF(self.btnSize + self.padding, self.btnSize * 2 + self.padding * 2)) self.scene.addItem(self.downItem) self.effect = QGraphicsDropShadowEffect() self.effect.setOffset(0, 0) self.effect.setBlurRadius(20) self.effect.setColor(Qt.green) self.downItem.setGraphicsEffect(self.effect) self.setScene(self.scene) self.tl2 = QTimeLine(10000) self.tl2.setFrameRange(0, 10000) self.t = QGraphicsItemAnimation() self.t.setItem(self.downItem) self.t.setTimeLine(self.tl2) self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect) self.effectd = 3 self.tl2.start() def updateEffect(self): if self.effect.blurRadius() > 50: self.effectd = -3 elif self.effect.blurRadius() < 5: self.effectd = 3 self.effect.setBlurRadius(self.effect.blurRadius() + self.effectd)
def __init__(self, data, encoding, x0, y0, x1, y1, xsize, ysize): p = QPixmap() p.loadFromData(data, encoding, Qt.AutoColor) w, h = p.width(), p.height() p = p.copy(x0, y0, min(w, x1-x0), min(h, y1-y0)) if p.width() != xsize or p.height() != ysize: p = p.scaled(xsize, ysize, Qt.IgnoreAspectRatio, Qt.SmoothTransformation) QGraphicsPixmapItem.__init__(self, p) self.height, self.width = ysize, xsize self.setTransformationMode(Qt.SmoothTransformation) self.setShapeMode(QGraphicsPixmapItem.BoundingRectShape)
def __init__(self, data, encoding, x0, y0, x1, y1, xsize, ysize): p = QPixmap() p.loadFromData(data, encoding, Qt.AutoColor) w, h = p.width(), p.height() p = p.copy(x0, y0, min(w, x1 - x0), min(h, y1 - y0)) if p.width() != xsize or p.height() != ysize: p = p.scaled(xsize, ysize, Qt.IgnoreAspectRatio, Qt.SmoothTransformation) QGraphicsPixmapItem.__init__(self, p) self.height, self.width = ysize, xsize self.setTransformationMode(Qt.SmoothTransformation) self.setShapeMode(QGraphicsPixmapItem.BoundingRectShape)
def resizeEvent(self, event): view_size = self.view.size() new_background_height = (1.5 / 4.) * view_size.height() background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"]) background_to_pixmap = background_to_pixmap.scaled(new_background_height, new_background_height, Qt.KeepAspectRatio) if not self.background_to_image: self.background_to_image = QGraphicsPixmapItem(background_to_pixmap) else: self.background_to_image.setPixmap(background_to_pixmap) sugested_x_position = int(2 * (view_size.width() / 3.)) if sugested_x_position < 0: sugested_x_position = 0 sugested_y_position = int(view_size.height() / 2. - background_to_pixmap.size().height() / 2) if sugested_y_position < 0: sugested_y_position = 0 self.background_to_image.setPos(sugested_x_position, sugested_y_position) ##################### new_background_height = (2.2 / 4.) * view_size.height() background_from_pixmap = QPixmap(self.image_bank["Background from"]["path"]) background_from_pixmap = background_from_pixmap.scaled(new_background_height, new_background_height, Qt.KeepAspectRatio) if not self.background_to_image: self.background_from_image = QGraphicsPixmapItem(background_from_pixmap) else: self.background_from_image.setPixmap(background_from_pixmap) sugested_x_position = int(view_size.width() / 5. - background_from_pixmap.size().height() / 2) if sugested_x_position < 0: sugested_x_position = 0 sugested_y_position = int(view_size.height() / 2. - background_from_pixmap.size().height() / 2) if sugested_y_position < 0: sugested_y_position = 0 self.background_from_image.setPos(sugested_x_position, sugested_y_position) #### new_widget_height = (1 / 4.) * view_size.height() if self.image_bank is not None: for image_id in self.image_bank.keys(): if "clothes" in self.image_bank[image_id]["categories"]: widget = self.image_bank[image_id]["widget"] pixmap = widget.pixmap pixmap = pixmap.scaled(new_widget_height, new_widget_height, Qt.KeepAspectRatio) widget.setPixmap(pixmap) print widget.moved_flag if not widget.moved_flag: newpos_x = self.background_from_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2 newpos_y = self.background_from_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2 widget.setPos(newpos_x, newpos_y) super(TakeDragGame, self).resizeEvent(event)
def __init__(o, parent, pieceid, w, h, dominant_colors): QGraphicsPixmapItem.__init__(o, parent=parent) o.id = pieceid o.dominant_colors = dominant_colors o.angle_deg = 0 o.img = None o._got_image = False # create dummy pixmap, transparent pxm = QPixmap(w, h) pxm.fill(QColor(0, 0, 0, 0)) o.setPixmap(pxm) o.setTransformationMode(Qt.SmoothTransformation)
def createPixmapItem(self, pixmap, position, matrix=QMatrix()): item = QGraphicsPixmapItem(pixmap) item.setFlags(QGraphicsItem.ItemIsSelectable| QGraphicsItem.ItemIsMovable) item.setPos(position) item.setMatrix(matrix) self.scene.clearSelection() self.scene.addItem(item) item.setSelected(True)
def __init__(self, *args): QGraphicsPixmapItem.__init__(self, *args) self.setPixmap(QPixmap("sprites/calle/centro.png")) self.setTransformOriginPoint(self.boundingRect().width()/2.0,self.boundingRect().height()/2.0) self.setZValue(1) self.menu = QMenu() self.Actions =[] #arreglo de acciones self.Actions.append( self.menu.addAction("girar clockwise") ) self.Actions.append( self.menu.addAction("girar anti-clockwise") ) self.Actions.append( self.menu.addAction("Duplicar") ) self.Actions.append( self.menu.addAction("Eliminar") ) self.menu.triggered[QAction].connect(self.test) self.offset=QPointF(0,0)
def build_ships_from_matrix(self): for x in range(10): for y in range(9): if self.my_board[x][y] == 1: if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(18+y*61, 21+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(49+y*61, 21+x*53) self.scene.addItem(self.item)
def __mouseReleaseEvent(self,event): global PIX self.drag_stop = event.pos() im = PIX.pixmap().toImage() start, stop = self.mapToScene(self.drag_start),self.mapToScene(self.drag_stop) logging.debug((start,stop)) augmented = QGraphicsPixmapItem(QPixmap(tempfile)) augmented.setOffset(rect.topLeft()) augmented.setMatrix(QMatrix()) if None != self.selectbox: self.scene().removeItem(self.selectbox) self.selectbox = augmented self.scene().addItem(self.selectbox)
def search(self): # first set/change the font of the serach box font = self.dlg.search_lineEdit.font() font.setItalic(False) self.dlg.search_lineEdit.setFont(font) # clear description and quicklook self.dlg.textEdit.clear() # make a new emptey scene to show if not self.dlg.graphicsView is None: scene = QGraphicsScene() pic = QPixmap() scene.addItem(QGraphicsPixmapItem(pic)) self.dlg.graphicsView.setScene(scene) self.dlg.graphicsView.show() # function the searches for a string in the datasets name, service type and otganization text = self.dlg.search_lineEdit.text() # convert to lower case and remove greek accents in case of Greek text = text.lower() text = self.removeGreekAccents(text) foundDatasets = [] for dataset in self.datasets: # use lowercase characters and remove greek accents , to make the comparison name = self.removeGreekAccents(dataset.getName(self.language).lower()) source = self.removeGreekAccents(dataset.getSource(self.language).lower()) serviceType = self.removeGreekAccents(dataset.serviceType.lower()) if text in name or text in source or text in serviceType: #QMessageBox.information(None, "DEBUG:", str(type(dataset.getName(self.language)))) foundDatasets.append(dataset) #fill the table with the found datasets self.fill_table(foundDatasets)
def __init__(self, *args): QGraphicsView.__init__(self, *args) self.move(20, 240) self.outerD = 125 self.innerD = 35 self.innerRange = 48 self.inputRange = 256 self.thresh = 3 self.padding = 40 self.marginTop = 10 self.worker = QSixAxisThread() self.worker.valueUpdated.connect(self.moveJoysticks) self.worker.start() self.setContentsMargins(0, 0, 0, 0) self.setMaximumHeight(180) self.setMaximumWidth(420) self.setMinimumHeight(240) self.setMinimumWidth(300) self.adjustSize() self.scene = QGraphicsScene(self) self.outerCircle1 = QGraphicsEllipseItem(0, self.marginTop, self.outerD, self.outerD) self.outerCircle1.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine)) self.outerCircle1.setBrush(Qt.gray) self.innerCircle1 = QGraphicsEllipseItem(self.outerD / 2 - self.innerD / 2, self.outerD / 2 - self.innerD / 2 + self.marginTop, self.innerD, self.innerD) self.innerCircle1.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine)) self.innerCircle1.setBrush(Qt.lightGray) self.scene.addItem(self.outerCircle1) self.scene.addItem(self.innerCircle1) self.outerCircle2 = QGraphicsEllipseItem(self.outerD + self.padding, self.marginTop, self.outerD, self.outerD) self.outerCircle2.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine)) self.outerCircle2.setBrush(Qt.gray) self.innerCircle2 = QGraphicsEllipseItem(self.outerD + self.padding + self.outerD / 2 - self.innerD / 2, self.outerD / 2 - self.innerD / 2 + self.marginTop, self.innerD, self.innerD) self.innerCircle2.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine)) self.innerCircle2.setBrush(Qt.lightGray) self.scene.addItem(self.outerCircle2) self.scene.addItem(self.innerCircle2) self.setScene(self.scene) self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;') self.currentX = 0 self.currentY = 0 self.currentA = 0 self.currentZ = 0 self.psBtn = QPixmap(os.getcwd() + '/../icons/bt_PS.png') self.psBtn = self.psBtn.scaled(50, 50, Qt.KeepAspectRatio) self.psItem = QGraphicsPixmapItem(self.psBtn) self.psItem.setOffset(QPointF(self.outerD - 4, 0)) self.effect = QGraphicsDropShadowEffect() self.effect.setOffset(0, 0) self.effect.setBlurRadius(20) self.effect.setColor(Qt.green) self.psItem.setGraphicsEffect(self.effect) self.scene.addItem(self.psItem) self.tl2 = QTimeLine(10000) self.tl2.setFrameRange(0, 10000) self.c = QGraphicsItemAnimation() self.c.setItem(self.psItem) self.c.setTimeLine(self.tl2) self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect) self.effectd = 3 self.tl2.start()
def __init__(self, filename=None, width=None, height=None, x=0, y=0, pixmap=None, group=None, pos=None, size=None, padding=None): self.effects = {} self.animations = {} self.filename = filename if isinstance(filename, str) else None if pixmap : self.pixmap = pixmap elif isinstance(filename, QPixmap) : self.pixmap = filename elif isinstance(filename, str) : self.pixmap = QPixmap(os.path.dirname(__file__) + '/../buttons/' + filename) else : self.pixmap = None if (width != None or height != None) and self.pixmap != None : self.pixmap = self.pixmap.scaled(width if width != None else height, height if height != None else width, Qt.KeepAspectRatio) self.group = group self.pos = pos self.size = size self.padding = padding self.x = x self.y = y if isinstance(self.pixmap, QPixmap) : self.item = QGraphicsPixmapItem(self.pixmap) self.item.setOffset(QPointF(self.getX(), self.getY())) self.effect = QGraphicsDropShadowEffect() self.effect.setOffset(0, 0) self.effect.setBlurRadius(0) self.effect.setColor(Qt.green) self.addEffect('shadow', self.effect, True) self.addAnimation('glow', Glow(15, 300, self, maxRadius=80, minRadius=5))
def __init__(self, parent=None, direction=Qt.LeftToRight, node=None, icon=None, iconSize=None, **args): QGraphicsWidget.__init__(self, parent, **args) self.setAcceptedMouseButtons(Qt.NoButton) self.__direction = direction self.setLayout(QGraphicsLinearLayout(Qt.Horizontal)) # Set the maximum size, otherwise the layout can't grow beyond its # sizeHint (and we need it to grow so the widget can grow and keep the # contents centered vertically. self.layout().setMaximumSize(QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)) self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.__iconSize = iconSize or QSize(64, 64) self.__icon = icon self.__iconItem = QGraphicsPixmapItem(self) self.__iconLayoutItem = GraphicsItemLayoutItem(item=self.__iconItem) self.__channelLayout = QGraphicsGridLayout() self.__channelAnchors = [] if self.__direction == Qt.LeftToRight: self.layout().addItem(self.__iconLayoutItem) self.layout().addItem(self.__channelLayout) channel_alignemnt = Qt.AlignRight else: self.layout().addItem(self.__channelLayout) self.layout().addItem(self.__iconLayoutItem) channel_alignemnt = Qt.AlignLeft self.layout().setAlignment(self.__iconLayoutItem, Qt.AlignCenter) self.layout().setAlignment(self.__channelLayout, Qt.AlignVCenter | channel_alignemnt) if node is not None: self.setSchemeNode(node)
def __init__(self, win, rect, filename, metadata): self.win = win self.rect = rect self.filename = filename self.metadata = metadata if self.metadata: self.line1 = self.metadata['Name'] self.line2 = "%s Mission" % (self.metadata['Mission']) self.line3 = "%s" % (self.metadata['Time']) else: self.line1 = "" self.line2 = "" self.line3 = "" self.image = QGraphicsPixmapItem() self.win.scene.addItem(self.image) self.image.setTransformationMode(Qt.SmoothTransformation) self.use_two_lines = True self.fontsize1 = 32 self.fontsize2 = 26 self.fontsize3 = 24 self.font1 = QFont('Times New Roman', self.fontsize1) self.font2 = QFont('Times New Roman', self.fontsize2) self.font3 = QFont('Times New Roman', self.fontsize3) self.title1 = self.win.scene.addText(self.line1, self.font1) self.title1.setDefaultTextColor(Qt.white) self.title1.setVisible(False) self.title2 = self.win.scene.addText(self.line2, self.font2) self.title2.setDefaultTextColor(Qt.white) self.title2.setVisible(False) self.title3 = self.win.scene.addText(self.line3, self.font3) self.title3.setDefaultTextColor(Qt.white) self.title3.setVisible(False) self.reservedHeight = 128 self.padding = 20 self.hide()
def build_shots_from_matrix(self): picture = 'res/cancel.png' for x in range(10): for y in range(9): if self.my_board[x][y] == 2 or self.my_board[x][y] == 3: if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.scene.addItem(self.item) self.build_ships_from_matrix()
def createPixmapItem(self, pixmap, matrix=QMatrix()): global PIX item = QGraphicsPixmapItem(pixmap) PIX = item # item.setFlags(QGraphicsItem.ItemIsSelectable| # QGraphicsItem.ItemIsMovable) item.setMatrix(matrix) self.scene.clearSelection() for i in self.scene.items(): self.scene.removeItem(i) self.scene.addItem(item) self.view.fitInView(item,Qt.KeepAspectRatio) global DIRTY DIRTY = True
class AI(object): def __init__(self, QMainWindow): self.game = QMainWindow self.clear_unused_fields() ships = 0 while ships < 10: x = randint(0, 9) y = randint(0, 8) if self.game.enemies_board[x][y] == 0: self.game.enemies_board[x][y] = 1 ships += 1 def clear_unused_fields(self): self.game.connect_btn.hide() self.game.ip_addr_field.hide() self.game.port_field.hide() def make_move(self): if not self.game.is_my_turn: x = randint(0, 9) y = randint(0, 8) if self.game.my_board[x][y] not in range(2,4): if self.game.my_board[x][y] == 1: self.game.my_board[x][y] = 2 picture = 'res/cancel.png' else: self.game.my_board[x][y] = 3 picture = 'res/ok.png' if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.game.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.game.scene.addItem(self.item) print(self.game.enemies_board) print(self.game.my_board) self.game.is_my_turn = True
def btnLoadImageClicked(self): if self.dlgLoadImage.exec_(): filename = self.dlgLoadImage.selectedFiles()[0] self._image = QImage(filename) self._imagePixmap = QGraphicsPixmapItem(QPixmap(self._image), None, self._imageScene) self.grObjectImage.setScene(self._imageScene) self.grObjectImage.fitInView(self._imageScene.sceneRect(), Qt.KeepAspectRatio) self._imagePixmap.mousePressEvent = self.getRGBFromPixel
def __init__(self, classifier, granularity, scale, spacing, rect=None): orangeqt.PlotItem.__init__(self) self.classifier = classifier self.rect = rect self.granularity = granularity self.scale = scale self.spacing = spacing self.pixmap_item = QGraphicsPixmapItem(self) self.set_in_background(True) self.setZValue(ProbabilitiesZValue)
def inicializarUI(self): self.setWindowTitle("BlueKing::Reversa") self.setGeometry(0,0,320,240) self.setAutoFillBackground(True) #QGraphicsView/Scene self.view = QGraphicsView() self.view.setStyleSheet("border: 0px;margin: 0px;background-color: #000000;") self.scene = QGraphicsScene(0,0,320,240) self.view.setScene(self.scene) self.baseLayout = QVBoxLayout() self.baseLayout.setContentsMargins(0,0,0,0) self.baseLayout.addWidget(self.view) #Decoracion car_logo = QPixmap("imagenes/car_logo.png") car_logo_item = QGraphicsPixmapItem(car_logo) car_logo_item.setPos(5,5) self.scene.addItem(car_logo_item) self.distlabel = QLabel("-") self.distlabel.setGeometry(20, 20, 280, 200) self.distlabel.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.distlabel.setStyleSheet("color: #00FFFF;font-size: 150px;background-color: transparent;") self.scene.addWidget(self.distlabel) self.measureLabel=QLabel("metros") self.measureLabel.setGeometry(10,190,300,30) self.measureLabel.setAlignment(QtCore.Qt.AlignRight |QtCore.Qt.AlignVCenter) self.measureLabel.setStyleSheet("color: #FFFF00;font-size: 30px; font-weight: bold; font-style: italic;background-color: transparent;") self.scene.addWidget(self.measureLabel) self.setLayout(self.baseLayout) transformacion = QTransform() transformacion.scale(1.0,-1.0) #self.view.setTransform(transformacion) self.show()
def __init__(self, power, color, bot): QGraphicsPixmapItem.__init__(self) #graphics self.maskColor = QtGui.QColor(255, 128, 0) self.pixmap = QtGui.QPixmap(os.getcwd() + "/robotImages/blast.png") self.setPixmap(self.pixmap) self.setColour(color) self.isfired = False #physics self.width = self.boundingRect().width() self.height = self.boundingRect().height() if power <= 0.5: power = 0.5 elif power >= 10: power = 10 self.power = power bsize = power if power < 3: bsize = 4 self.pixmap = self.pixmap.scaled(bsize, bsize) self.setPixmap(self.pixmap) self.robot = bot
def __init__(self, *args): QGraphicsView.__init__(self, *args) self.move(2, 22) self.btnSize = 60 self.setMaximumHeight(60) self.setMaximumWidth(332) self.setMinimumHeight(60) self.setMinimumWidth(332) self.adjustSize() self.scene = QGraphicsScene(self) self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;') self.l1 = QPixmap(os.getcwd() + '/../icons/l1.png') self.l1 = self.l1.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.l1Item = QGraphicsPixmapItem(self.l1) self.l1Item.setOffset(QPointF(30, 0)) self.scene.addItem(self.l1Item) self.r1 = QPixmap(os.getcwd() + '/../icons/r1.png') self.r1 = self.l1.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio) self.r1Item = QGraphicsPixmapItem(self.r1) self.r1Item.setOffset(QPointF(200, 0)) self.scene.addItem(self.r1Item) self.setScene(self.scene)
def set_ship(self): if not self.is_client_connected: x = self.set_X.text() y = self.set_Y.text() x, y = parser(x, y) if self.my_ships < 10: if x != -1 and y != -1: # Dodanie statku do pola self.my_board[x][y] = 1 self.my_ships += 1 self.enemies_board[x][y] = 1 QMessageBox.about(self, "Statek na polu", "({}, {})".format(x, y)) if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(18+y*61, 21+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(49+y*61, 21+x*53) self.scene.addItem(self.item) else: QMessageBox.about(self, "Blad", "Niepoprawne pola") else: QMessageBox.about(self, "Blad", "Wykorzystales juz cala flote") else: QMessageBox.about(self, "Info", "Nie polaczyles sie z przeciwnikiem") if self.my_ships == 5: self.ready_to_play = True self.set_X.hide() self.set_Y.hide() self.set_ship_btn.hide() QMessageBox.about(self, "Info", "Jestes gotowy aby rozpoczac gre")
def draw_env(self, image): if self.scene_env == 0: self.scene_env = QGraphicsPixmapItem() else: self.removeItem(self.scene_env) self.scene_env.setPixmap(QPixmap(image)) if self.scene_env != 0: self.scene_env.setPos(0, -self.environment.im.shape[1]) self.addItem(self.scene_env) self.scene_env.setZValue(-1) if not self.f_show_env: self.scene_env.hide() self.spinEnvX.setValue(self.environment.im.shape[0]) self.spinEnvY.setValue(self.environment.im.shape[1]) if self.f_auto_edge: self.delete_all_edges() self.net.recalculate_edges() self.draw_all_edges()
def __init__(self, master, *args): QGraphicsView.__init__(self, *args) self.master = master self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.setRenderHints(QPainter.Antialiasing) scene = QGraphicsScene(self) self.pixmapGraphicsItem = QGraphicsPixmapItem(None, scene) self.setScene(scene) self.setMouseTracking(True) self.viewport().setMouseTracking(True) self.setFocusPolicy(Qt.WheelFocus)
def close(self): #clear everything self.init_table() # clear description and quicklook self.dlg.textEdit.clear() # clear search box #text = self.dlg.search_lineEdit.setText("") self.init_searchBox() # make a new emptey scene to show if not self.dlg.graphicsView is None: scene = QGraphicsScene() pic = QPixmap() scene.addItem(QGraphicsPixmapItem(pic)) self.dlg.graphicsView.setScene(scene) self.dlg.graphicsView.show() """close the dialog""" self.dlg.close()
def updateDescAndQL(self): # get the name of the selected dataset dataset_name, dataset_serviceType = self.getSelectedNameAndType() #custom web service object dataset = self.selectdataSets(dataset_name, dataset_serviceType) quicklook = os.path.join(self.quicklooks_dir, dataset.QLname + ".jpg") desc = dataset.getDescription(self.language) name = dataset.getName(self.language) #update decription self.dlg.textEdit.clear() #creation and last update if self.language == "EN": crDate = "Creation date : " + dataset.creationDate update = "Last update : " + dataset.lastUpdate elif self.language == "GR": crDate = unicode( "Ημερομηνια δημιουργιας : " + dataset.creationDate, 'utf-8') update = unicode("Τελευταία ενημέρωση : " + dataset.lastUpdate, 'utf-8') cursor = QTextCursor(self.dlg.textEdit.document()) cursor.insertHtml("<h3> " + name + " <br><br></h3>") cursor.insertHtml("<p> " + desc + " <br><br><br></p>") cursor.insertHtml("<p><i> " + crDate + " <br></i></p>") #cursor.insertHtml("<p><i> "+update+" <br></i></p>") self.dlg.textEdit.setReadOnly(True) #update quicklook #GET DIMENSIONS OF THE IMAGE img = Image.open(quicklook) w, h = img.size scene = QGraphicsScene() pic = QPixmap(quicklook) scene.addItem(QGraphicsPixmapItem(pic)) self.dlg.graphicsView.setScene(scene) self.dlg.graphicsView.fitInView(QRectF(0, 0, w, h), Qt.KeepAspectRatio) self.dlg.graphicsView.show()
def __init__(self, parent=None, direction=Qt.LeftToRight, node=None, icon=None, iconSize=None, **args): QGraphicsWidget.__init__(self, parent, **args) self.setAcceptedMouseButtons(Qt.NoButton) self.__direction = direction self.setLayout(QGraphicsLinearLayout(Qt.Horizontal)) # Set the maximum size, otherwise the layout can't grow beyond its # sizeHint (and we need it to grow so the widget can grow and keep the # contents centered vertically. self.layout().setMaximumSize(QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)) self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.__iconSize = iconSize or QSize(64, 64) self.__icon = icon self.__iconItem = QGraphicsPixmapItem(self) self.__iconLayoutItem = GraphicsItemLayoutItem(item=self.__iconItem) self.__channelLayout = QGraphicsGridLayout() self.__channelAnchors = [] if self.__direction == Qt.LeftToRight: self.layout().addItem(self.__iconLayoutItem) self.layout().addItem(self.__channelLayout) channel_alignemnt = Qt.AlignRight else: self.layout().addItem(self.__channelLayout) self.layout().addItem(self.__iconLayoutItem) channel_alignemnt = Qt.AlignLeft self.layout().setAlignment(self.__iconLayoutItem, Qt.AlignCenter) self.layout().setAlignment(self.__channelLayout, Qt.AlignVCenter | channel_alignemnt) if node is not None: self.setSchemeNode(node)
def updateLanguage(self): # get the new language language = str(self.dlg.language_comboBox.currentText()) # Change the self.language propertie and change the labe;s if language == "English": self.language = "EN" self.dlg.desc_lbl.setText("Description") self.dlg.preview_lbl.setText("Preview") self.dlg.load_btn.setText("Load") self.dlg.close_btn.setText("Close") self.dlg.search_lbl.setText("Search") self.dlg.info_btn.setText("Info") elif language == "Greek": self.language = "GR" self.dlg.desc_lbl.setText(unicode("Περιγραφή", 'utf-8')) self.dlg.preview_lbl.setText(unicode("Προεπισκόπηση",'utf-8')) self.dlg.load_btn.setText(unicode("Φόρτωση",'utf-8')) self.dlg.close_btn.setText(unicode("Κλείσιμο",'utf-8')) self.dlg.search_lbl.setText(unicode("Αναζήτηση",'utf-8')) self.dlg.info_btn.setText(unicode("Πληροφορίες", 'utf-8')) self.dlg.preview_lbl.setAlignment(Qt.AlignRight) #refill the table self.init_table() # clear description and quicklook self.dlg.textEdit.clear() # clear search box #text = self.dlg.search_lineEdit.setText("") self.init_searchBox() # make a new emptey scene to show if not self.dlg.graphicsView is None: scene = QGraphicsScene() pic = QPixmap() scene.addItem(QGraphicsPixmapItem(pic)) self.dlg.graphicsView.setScene(scene) self.dlg.graphicsView.show()
def __init__(self, pathway, objects, *args, **kwargs): QGraphicsPixmapItem.__init__(self, *args) self.setTransformationMode(Qt.SmoothTransformation) self.setPathway(pathway) self.setMarkedObjects(objects, name_mapper=kwargs.get("name_mapper", {}))
def __init__(self, face, pixmap): QGraphicsPixmapItem.__init__(self, pixmap)
def background_pixmap_item(self): return QGraphicsPixmapItem(self.background_pixmap)
class SlideshowFrame(object): def __init__(self, win, rect, filename, metadata): self.win = win self.rect = rect self.filename = filename self.metadata = metadata if self.metadata: self.line1 = self.metadata['Name'] self.line2 = "%s Mission" % (self.metadata['Mission']) self.line3 = "%s" % (self.metadata['Time']) else: self.line1 = "" self.line2 = "" self.line3 = "" self.image = QGraphicsPixmapItem() self.win.scene.addItem(self.image) self.image.setTransformationMode(Qt.SmoothTransformation) self.use_two_lines = True self.fontsize1 = 32 self.fontsize2 = 26 self.fontsize3 = 24 self.font1 = QFont('Times New Roman', self.fontsize1) self.font2 = QFont('Times New Roman', self.fontsize2) self.font3 = QFont('Times New Roman', self.fontsize3) self.title1 = self.win.scene.addText(self.line1, self.font1) self.title1.setDefaultTextColor(Qt.white) self.title1.setVisible(False) self.title2 = self.win.scene.addText(self.line2, self.font2) self.title2.setDefaultTextColor(Qt.white) self.title2.setVisible(False) self.title3 = self.win.scene.addText(self.line3, self.font3) self.title3.setDefaultTextColor(Qt.white) self.title3.setVisible(False) self.reservedHeight = 128 self.padding = 20 self.hide() def move(self, x, y): self.rect = QRectF(x, y, self.rect.width(), self.rect.height()) def __rotate(self, metadata, origImgSize): # Qt only handles orientation properly from v5.5 try: # try directly to get the tag, because sometimes get_tags() returns # tags that don't actually are in the file rot = metadata['Exif.Image.Orientation'] except KeyError: # guess :-/ rot = '1' # see http://www.daveperrett.com/images/articles/2012-07-28-exif-orientation-handling-is-a-ghetto/EXIF_Orientations.jpg # we have to 'undo' the rotations, so the numbers are negative if rot == '1': rotate = 0 imgSize = origImgSize if rot == '8': rotate = -90 imgSize = QSize(origImgSize.height(), origImgSize.width()) if rot == '3': rotate = -180 imgSize = origImgSize if rot == '6': rotate = -270 imgSize = QSize(origImgSize.height(), origImgSize.width()) # undo the last rotation and apply the new one self.image.setRotation(rotate) return imgSize def __zoomFit(self, imgSize): reservedHeight = self.reservedHeight + self.padding * 2 hZoom = self.rect.width() / imgSize.width() vZoom = (self.rect.height() - reservedHeight) / imgSize.height() scale = min(hZoom, vZoom) self.image.setScale(scale) width = imgSize.width() * scale height = imgSize.height() * scale self.image.setPos( (self.rect.width() - width) / 2 + self.rect.x(), (self.rect.height() - reservedHeight - height) / 2 + self.rect.y()) def layoutText(self): reservedHeight = self.reservedHeight + self.padding vertical_spacing = (self.reservedHeight - self.title1.boundingRect().height() - self.title2.boundingRect().height() - self.title3.boundingRect().height()) / 3 x = (self.rect.width() - self.title1.boundingRect().width()) / 2 y = self.rect.height() - reservedHeight + vertical_spacing self.title1.setPos(x + self.rect.x(), y + self.rect.y()) x = (self.rect.width() - self.title2.boundingRect().width()) / 2 y = self.rect.height( ) - reservedHeight + vertical_spacing * 2 + self.title1.boundingRect( ).height() self.title2.setPos(x + self.rect.x(), y + self.rect.y()) x = (self.rect.width() - self.title3.boundingRect().width()) / 2 y = self.rect.height( ) - reservedHeight + vertical_spacing * 3 + self.title1.boundingRect( ).height() + self.title2.boundingRect().height() self.title3.setPos(x + self.rect.x(), y + self.rect.y()) def show(self): img = QPixmap(self.filename) try: metadata = GExiv2.Metadata(self.filename) except GLib.Error as e: print(repr(e)) return self.image.setPixmap(img) self.image.setScale(1.0) self.image.setRotation(0) imgSize = self.__rotate(metadata, img.size()) self.__zoomFit(imgSize) self.layoutText() self.title1.setVisible(True) self.title2.setVisible(True) self.title3.setVisible(True) self.image.setVisible(True) def hide(self): self.title1.setVisible(False) self.title2.setVisible(False) self.title3.setVisible(False) self.image.setVisible(False) self.image.setPixmap(QPixmap()) def showImage(self, file, md): self.metadata = md try: metadata = GExiv2.Metadata(file) except GLib.Error as e: print(repr(e)) return img = QPixmap(file) self.image.setPixmap(img) self.image.setScale(1.0) self.image.setRotation(0) imgSize = self.__rotate(metadata, img.size()) self.__zoomFit(imgSize) self.layoutMetadata()
def __init__(self, face, node, pixmap): QGraphicsPixmapItem.__init__(self, pixmap) _ActionDelegator.__init__(self) self.node = node
def show_fullscreen_pixmap(self, pixmap): """:param pixmap: a QPixmap""" item = QGraphicsPixmapItem(pixmap) self.show_fullscreen_item(item)
def __init__(self, pathway, objects, *args, **kwargs): QGraphicsPixmapItem.__init__(self, *args) self.setTransformationMode(Qt.SmoothTransformation) self.setPathway(pathway) self.setMarkedObjects(objects, name_mapper=kwargs.get("name_mapper", {}))
def head_pixmap_item(self): head_pixmap_item = QGraphicsPixmapItem(self.head_pixmap) head_pixmap_item.setZValue(1) return head_pixmap_item
class ProbabilitiesItem(orangeqt.PlotItem): """ Displays class probabilities in the background :param classifier: The classifier for which the probabilities are calculated :type classifier: orange.P2NN :param granularity: The size of individual cells :type granularity: int :param scale: The data scale factor :type scale: float :param spacing: The space between cells :param spacing: int :param rect: The rectangle into which to draw the probabilities. If unspecified, the entire plot is used. :type rect: QRectF """ def __init__(self, classifier, granularity, scale, spacing, rect=None): orangeqt.PlotItem.__init__(self) self.classifier = classifier self.rect = rect self.granularity = granularity self.scale = scale self.spacing = spacing self.pixmap_item = QGraphicsPixmapItem(self) self.set_in_background(True) self.setZValue(ProbabilitiesZValue) def update_properties(self): ## Mostly copied from OWScatterPlotGraph if not self.plot(): return if not self.rect: x, y = self.axes() self.rect = self.plot().data_rect_for_axes(x, y) s = self.graph_transform().mapRect(self.rect).size().toSize() if not s.isValid(): return rx = s.width() ry = s.height() rx -= rx % self.granularity ry -= ry % self.granularity p = self.graph_transform().map(QPointF(0, 0)) - self.graph_transform().map(self.rect.topLeft()) p = p.toPoint() ox = p.x() oy = -p.y() if isinstance(self.classifier.classVar, ContinuousVariable): imagebmp = orangeom.potentialsBitmap(self.classifier, rx, ry, ox, oy, self.granularity, self.scale) palette = [qRgb(255.0 * i / 255.0, 255.0 * i / 255.0, 255 - (255.0 * i / 255.0)) for i in range(255)] + [ qRgb(255, 255, 255) ] else: imagebmp, nShades = orangeom.potentialsBitmap( self.classifier, rx, ry, ox, oy, self.granularity, self.scale, self.spacing ) palette = [] sortedClasses = get_variable_values_sorted(self.classifier.domain.classVar) for cls in self.classifier.classVar.values: color = self.plot().discPalette.getRGB(sortedClasses.index(cls)) towhite = [255 - c for c in color] for s in range(nShades): si = 1 - float(s) / nShades palette.append(qRgb(*tuple([color[i] + towhite[i] * si for i in (0, 1, 2)]))) palette.extend([qRgb(255, 255, 255) for i in range(256 - len(palette))]) self.potentialsImage = QImage(imagebmp, rx, ry, QImage.Format_Indexed8) self.potentialsImage.setColorTable(ColorPaletteDlg.signedPalette(palette) if qVersion() < "4.5" else palette) self.potentialsImage.setNumColors(256) self.pixmap_item.setPixmap(QPixmap.fromImage(self.potentialsImage)) self.pixmap_item.setPos(self.graph_transform().map(self.rect.bottomLeft())) def data_rect(self): return self.rect if self.rect else QRectF()
def paintBoundaries(tgslicesFile, zSlice, d, boundaryData, mask, filename, swapCoordinates=False, colortable=None, penWidth=4.0): print "* making boundary img '%s'" % filename #b = BoundariesLayerPy(tgslicesFile=tgslicesFile, normalAxis=2, data2scene=QTransform(), swapCoordinates=True) b = BoundariesLayer(None, 2, QTransform(), True) n = b.normalAxis() axis = None if swapCoordinates: if n == 0: axis = "z" elif n == 1: axis = "y" else: axis = "x" else: if n == 0: axis = "x" elif n == 1: axis = "y" else: axis = "z" f = h5py.File(tgslicesFile, 'r') group = "%s/%d" % (axis, zSlice) serializedBoundaries = f[group].value f.close() assert d.ndim == 2 scene = QGraphicsScene() b.setSliceNumber( zSlice ) b.setBoundaries(serializedBoundaries) b.setColormap("tyr") assert boundaryData.dtype == numpy.float32 assert mask.dtype == numpy.float32 b.setBoundaryData(boundaryData, boundaryData.size, boundaryData) b.setBoundaryMask(mask, mask.size) if colortable is not None: b.setColormap(colortable) print "setting pen width to be %f" % penWidth b.setPenWidth(float(penWidth)) print "...done" mag = 4 shape = d.shape dBig = vigra.sampling.resizeImageNoInterpolation(d.astype(numpy.float32), (mag*shape[0], mag*shape[1])) #dBig = dBig.swapaxes(0,1) qimg = qimage2ndarray.gray2qimage(dBig) #qimg = qimg.mirrored(True, False) imgItm = QGraphicsPixmapItem(QPixmap(qimg)) imgItm.setScale(1.0/mag) scene.addItem(imgItm) sourceRect = QRectF(0,0,shape[1], shape[0]) targetRect = QRectF(0,0,mag*shape[1], mag*shape[0]) scene.setSceneRect(sourceRect) scene.addItem(b) img = QImage(targetRect.width(), targetRect.height(), QImage.Format_ARGB32); painter = QPainter(img); painter.setRenderHint(QPainter.Antialiasing); scene.render(painter, targetRect, sourceRect ); img.save(filename) painter.end() #print "img has size ", img.width(), img.height() img = None painter = None scene = None
def head_pixmap_item(self): head_pixmap_item = QGraphicsPixmapItem(self.head_pixmap) head_pixmap_item.setZValue(1) return head_pixmap_item
class TakeDragGame(QWidget): def __init__(self, parent=None): super(TakeDragGame, self).__init__(parent) # This is always the same self.dot2 = QGraphicsTextItem(':') self.dot1 = QGraphicsTextItem(':') self.animations = [] self.digits = [] self.main_layout = QHBoxLayout() self.setLayout(self.main_layout) self.scene = QGraphicsScene() self.scene.setSceneRect(0, 0, 600, 400) self.view = QGraphicsView() self.view.setScene(self.scene) # TODO: Check if its better with opengl or not # self.view.setViewport(QtOpenGL.QGLWidget()) self.main_layout.addWidget(self.view) # self.setWindowState(Qt.WindowMaximized) self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft) self.image_bank = None self.create_and_add_images() # self.scene.setBackgroundBrush(QBrush(Qt.red, Qt.SolidPattern)) # self.populate() # self.animator = QTimer() # self.animator.timeout.connect(self.animate) # self.animate() def create_and_add_images(self): self.load_images_json_file() self.add_background_to_image() self.add_background_from_image() if self.image_bank is not None: for image_id in self.image_bank.keys(): if "clothes" in self.image_bank[image_id]["categories"]: image_path = self.image_bank[image_id]["path"] new_image = DraggableItem(image_path, self.background_from_image) new_image.moved_signal.moved.connect(self.item_moved) self.image_bank[image_id]["widget"] = new_image newpos_x = self.background_from_image.boundingRect().width() / 2 - new_image.boundingRect().width() / 2 newpos_y = self.background_from_image.boundingRect().height() / 2 - new_image.boundingRect().height() / 2 new_image.setPos(newpos_x, newpos_y) # self.scene.addItem(new_image) new_image.setZValue(30) def item_moved(self, pos): widget = self.sender().get_parent() print widget.zValue() print self.background_from_image.zValue() print self.background_to_image.zValue() item_br = widget.sceneBoundingRect() if self.background_from_image.sceneBoundingRect().contains(item_br): widget.setParentItem(self.background_from_image) newpos_x = self.background_from_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2 newpos_y = self.background_from_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2 # self.background_to_image.stackBefore(self.background_from_image) widget.setPos(newpos_x, newpos_y) elif self.background_to_image.sceneBoundingRect().contains(item_br): widget.setParentItem(self.background_to_image) newpos_x = self.background_to_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2 newpos_y = self.background_to_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2 # self.background_from_image.stackBefore(self.background_to_image) widget.setPos(newpos_x, newpos_y) def load_images_json_file(self): with open(os.path.join(CURRENT_PATH, './resources/images.json')) as f: self.image_bank = json.load(f) def add_background_from_image(self, ): assert self.image_bank is not None, "Images need to be loaded before calling this method (try load_images_json_file)" if "Background from" in self.image_bank: background_from_pixmap = QPixmap(self.image_bank["Background from"]["path"]) self.background_from_image = QGraphicsPixmapItem(background_from_pixmap) self.scene.addItem(self.background_from_image) self.background_from_image.setZValue(2) def add_background_to_image(self, ): assert self.image_bank is not None, "Images need to be loaded before calling this method (try load_images_json_file)" if "Background to" in self.image_bank: background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"]) self.background_to_image = QGraphicsPixmapItem(background_to_pixmap) self.scene.addItem(self.background_to_image) self.background_to_image.setZValue(2) def resizeEvent(self, event): view_size = self.view.size() new_background_height = (1.5 / 4.) * view_size.height() background_to_pixmap = QPixmap(self.image_bank["Background to"]["path"]) background_to_pixmap = background_to_pixmap.scaled(new_background_height, new_background_height, Qt.KeepAspectRatio) if not self.background_to_image: self.background_to_image = QGraphicsPixmapItem(background_to_pixmap) else: self.background_to_image.setPixmap(background_to_pixmap) sugested_x_position = int(2 * (view_size.width() / 3.)) if sugested_x_position < 0: sugested_x_position = 0 sugested_y_position = int(view_size.height() / 2. - background_to_pixmap.size().height() / 2) if sugested_y_position < 0: sugested_y_position = 0 self.background_to_image.setPos(sugested_x_position, sugested_y_position) ##################### new_background_height = (2.2 / 4.) * view_size.height() background_from_pixmap = QPixmap(self.image_bank["Background from"]["path"]) background_from_pixmap = background_from_pixmap.scaled(new_background_height, new_background_height, Qt.KeepAspectRatio) if not self.background_to_image: self.background_from_image = QGraphicsPixmapItem(background_from_pixmap) else: self.background_from_image.setPixmap(background_from_pixmap) sugested_x_position = int(view_size.width() / 5. - background_from_pixmap.size().height() / 2) if sugested_x_position < 0: sugested_x_position = 0 sugested_y_position = int(view_size.height() / 2. - background_from_pixmap.size().height() / 2) if sugested_y_position < 0: sugested_y_position = 0 self.background_from_image.setPos(sugested_x_position, sugested_y_position) #### new_widget_height = (1 / 4.) * view_size.height() if self.image_bank is not None: for image_id in self.image_bank.keys(): if "clothes" in self.image_bank[image_id]["categories"]: widget = self.image_bank[image_id]["widget"] pixmap = widget.pixmap pixmap = pixmap.scaled(new_widget_height, new_widget_height, Qt.KeepAspectRatio) widget.setPixmap(pixmap) print widget.moved_flag if not widget.moved_flag: newpos_x = self.background_from_image.boundingRect().width() / 2 - widget.boundingRect().width() / 2 newpos_y = self.background_from_image.boundingRect().height() / 2 - widget.boundingRect().height() / 2 widget.setPos(newpos_x, newpos_y) super(TakeDragGame, self).resizeEvent(event)
def show_fullscreen_image(self, image): """:param image: a QImage""" pixmap = QPixmap.fromImage(image) item = QGraphicsPixmapItem(pixmap) self.show_fullscreen_item(item)
class ProbabilitiesItem(orangeqt.PlotItem): """ Displays class probabilities in the background :param classifier: The classifier for which the probabilities are calculated :type classifier: orange.P2NN :param granularity: The size of individual cells :type granularity: int :param scale: The data scale factor :type scale: float :param spacing: The space between cells :param spacing: int :param rect: The rectangle into which to draw the probabilities. If unspecified, the entire plot is used. :type rect: QRectF """ def __init__(self, classifier, granularity, scale, spacing, rect=None): orangeqt.PlotItem.__init__(self) self.classifier = classifier self.rect = rect self.granularity = granularity self.scale = scale self.spacing = spacing self.pixmap_item = QGraphicsPixmapItem(self) self.set_in_background(True) self.setZValue(ProbabilitiesZValue) def update_properties(self): ## Mostly copied from OWScatterPlotGraph if not self.plot(): return if not self.rect: x, y = self.axes() self.rect = self.plot().data_rect_for_axes(x, y) s = self.graph_transform().mapRect(self.rect).size().toSize() if not s.isValid(): return rx = s.width() ry = s.height() rx -= rx % self.granularity ry -= ry % self.granularity p = self.graph_transform().map(QPointF( 0, 0)) - self.graph_transform().map(self.rect.topLeft()) p = p.toPoint() ox = p.x() oy = -p.y() if self.classifier.classVar.is_continuous: imagebmp = orangeom.potentialsBitmap(self.classifier, rx, ry, ox, oy, self.granularity, self.scale) palette = [ qRgb(255. * i / 255., 255. * i / 255., 255 - (255. * i / 255.)) for i in range(255) ] + [qRgb(255, 255, 255)] else: imagebmp, nShades = orangeom.potentialsBitmap( self.classifier, rx, ry, ox, oy, self.granularity, self.scale, self.spacing) palette = [] sortedClasses = get_variable_values_sorted( self.classifier.domain.classVar) for cls in self.classifier.classVar.values: color = self.plot().discPalette.getRGB( sortedClasses.index(cls)) towhite = [255 - c for c in color] for s in range(nShades): si = 1 - float(s) / nShades palette.append( qRgb(*tuple( [color[i] + towhite[i] * si for i in (0, 1, 2)]))) palette.extend( [qRgb(255, 255, 255) for i in range(256 - len(palette))]) self.potentialsImage = QImage(imagebmp, rx, ry, QImage.Format_Indexed8) self.potentialsImage.setColorTable( ColorPaletteDlg.signedPalette(palette ) if qVersion() < "4.5" else palette) self.potentialsImage.setNumColors(256) self.pixmap_item.setPixmap(QPixmap.fromImage(self.potentialsImage)) self.pixmap_item.setPos(self.graph_transform().map( self.rect.bottomLeft())) def data_rect(self): return self.rect if self.rect else QRectF()
def __init__(self, face, node, pixmap): QGraphicsPixmapItem.__init__(self, pixmap) _ActionDelegator.__init__(self) self.node = node
class MyWin(QMainWindow): STATEK = 'res/ship1.png' def __init__(self, address='127.0.0.1', port=5007): QMainWindow.__init__(self) uic.loadUi('untitled.ui', self) self.step_nr = 0 self.is_my_turn = True self.ai_mode = False # List with game states self.state = [] self.ready_to_play = False self.send = (-1, -1) # 1 - Ship # 2 - Hit # 3 - Missed self.my_board = np.zeros((10, 9)) self.enemies_board = np.zeros((10, 9)) self.build_ships_from_matrix() self.tie = 0 self.my_points = 0 self.enemies_points = 0 self.xml_init() self.state.append((self.my_board, self.enemies_board, self.my_points)) self.my_ships = 0 self.s = Server(self, address, port) self.s.start() self.is_client_connected = False WindowConfig.config(self) self.scene = QGraphicsScene() self.my_screen.setScene(self.scene) self.dm = DrawMap(self.scene) # self.my_screen.viewport().installEventFilter(self) # buttons self.ai_btn.clicked.connect(self.play_with_ai) self.move_btn.clicked.connect(self.move_ship) self.next_btn.clicked.connect(self.next_step) self.back_btn.clicked.connect(self.step_back) self.save_btn.clicked.connect(self.save_dialog) self.clear_btn.clicked.connect(self.clear_board) self.read_file_btn.clicked.connect(self.load_state) self.gen_rand_btn.clicked.connect(self.build_random_matrix) self.shot_btn.clicked.connect(self.execute_shot) self.set_ship_btn.clicked.connect(self.set_ship) self.connect_btn.clicked.connect(self.connect_with_enemy) self.exit_btn.clicked.connect(self.close_app) pass def xml_init(self): self.root = ET.Element("game") doc = ET.SubElement(self.root, "initialization") ET.SubElement(doc, "my_board", name="my board").text = str(self.my_board) ET.SubElement(doc, "enemies_board", name="enemies board").text = str(self.my_board) def play_with_ai(self): self.ai_mode = True self.ai = AI(self) pass def move_ship(self): x = self.x_field.text() y = self.y_field.text() x, y = parser(x, y) if (x != -1 and y != -1) and \ (self.my_board[x][y] == 1): new_x = randint(0, 9) new_y = randint(0, 8) if self.my_board[new_x][new_y] not in range(1,4): self.my_board[x][y] = 0 self.my_board[new_x][new_y] = 1 self.clear_board() self.build_shots_from_matrix() else: QMessageBox.about(self, "Move", "Wybierz statek") pass def next_step(self): self.my_board = self.state[self.step_nr][0] self.enemies_board = self.state[self.step_nr][1] self.my_points = self.state[self.step_nr][2] self.clear_board() self.build_shots_from_matrix() self.step_nr += 1 def step_back(self): self.step_nr -= 1 self.my_board = self.state[self.step_nr][0] self.enemies_board = self.state[self.step_nr][1] self.my_points = self.state[self.step_nr][2] self.clear_board() self.build_shots_from_matrix() def save_dialog(self): fname = QFileDialog.getOpenFileName(self, 'Open file', '/home') pickle.dump( self.state, open( fname, "wb" ) ) self.tree = ET.ElementTree(self.root) xmlstr = minidom.parseString(ET.tostring(self.root)).toprettyxml(indent=" ") with open("newState.xml", "w") as f: f.write(xmlstr) # self.tree.write("states.xml") def load_state(self): ''' Reads game state from binary file. ''' fname = QFileDialog.getOpenFileName(self, 'Open file', '/home') self.state = pickle.load(open(fname, "rb")) # TODO tree = ET.parse('New_Database.xml') root = tree.getroot() def eventFilter(self, source, event): if (event.type() == QEvent.MouseButtonPress and source is self.my_screen.viewport()): QCursor.pos() QMessageBox.about(self, "Debug", "debug {}".format(QCursor.pos())) def connect_with_enemy(self): ''' Connects our game instance with our enemy ''' ip_addr = self.ip_addr_field.text() port = self.port_field.text() port = int(port) pattern = re.compile("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$") test = pattern.match(ip_addr) if test: QMessageBox.about(self, "Info", "{}".format(ip_addr, port)) self.connect_btn.hide() self.ip_addr_field.hide() self.port_field.hide() self.client = jsonSocket.JsonClient(address=ip_addr, port=port) self.client.connect() else: QMessageBox.about(self, "Blad", "Bledny format adresu ip") def execute_shot(self): ''' Shot execution. ''' is_hit = False if not self.ai_mode: if not self.is_my_turn: QMessageBox.about(self, "Czekaj", "Czekaj na twoją turę!") return if not self.is_client_connected: x = self.x_field.text() y = self.y_field.text() x, y = parser(x, y) if x != -1 and y != -1: if self.enemies_board[x][y] == 1: self.enemies_board[x][y] = 2 is_hit = True picture = 'res/ok.png' else: self.enemies_board[x][y] = 3 is_hit = False picture = 'res/cancel.png' # if x % 2 != 0: # self.item = QGraphicsPixmapItem(QPixmap(picture)) # self.item.setOffset(16+y*61, 17+(x*52)) # self.scene.addItem(self.item) # # # elif x % 2 == 0: # self.item = QGraphicsPixmapItem(QPixmap(picture)) # self.item.setOffset(47+y*61, 16+x*53) # self.scene.addItem(self.item) # QMessageBox.about(self, "Strzal", "({}, {})".format(x, y)) self.send = (x, y) self.client.sendObj({"x": x, "y": y}) else: QMessageBox.about(self, "Blad", "Niepoprawne pola") else: QMessageBox.about(self, "Info", "Nie polaczyles sie z przeciwnikiem") if is_hit: pass else: pass else: x = self.x_field.text() y = self.y_field.text() x, y = parser(x, y) if x != -1 and y != -1: if self.enemies_board[x][y] == 1: self.enemies_board[x][y] = 2 is_hit = True picture = 'res/ok.png' else: self.enemies_board[x][y] = 3 is_hit = False picture = 'res/cancel.png' self.is_my_turn = False self.ai.make_move() def get_shot(self, x, y): ''' Shot handler. :param x: x coord of shot :param y: y coord of shot ''' is_Hit = False if self.my_board[x][y] == 1: self.my_board[x][y] = 2 is_hit = True picture = 'res/ok.png' else: self.my_board[x][y] = -1 is_hit = False picture = 'res/cancel.png' if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.scene.addItem(self.item) def set_ship(self): if not self.is_client_connected: x = self.set_X.text() y = self.set_Y.text() x, y = parser(x, y) if self.my_ships < 10: if x != -1 and y != -1: # Dodanie statku do pola self.my_board[x][y] = 1 self.my_ships += 1 self.enemies_board[x][y] = 1 QMessageBox.about(self, "Statek na polu", "({}, {})".format(x, y)) if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(18+y*61, 21+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(49+y*61, 21+x*53) self.scene.addItem(self.item) else: QMessageBox.about(self, "Blad", "Niepoprawne pola") else: QMessageBox.about(self, "Blad", "Wykorzystales juz cala flote") else: QMessageBox.about(self, "Info", "Nie polaczyles sie z przeciwnikiem") if self.my_ships == 5: self.ready_to_play = True self.set_X.hide() self.set_Y.hide() self.set_ship_btn.hide() QMessageBox.about(self, "Info", "Jestes gotowy aby rozpoczac gre") def build_ships_from_matrix(self): for x in range(10): for y in range(9): if self.my_board[x][y] == 1: if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(18+y*61, 21+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(self.STATEK)) self.item.setOffset(49+y*61, 21+x*53) self.scene.addItem(self.item) def build_shots_from_matrix(self): picture = 'res/cancel.png' for x in range(10): for y in range(9): if self.my_board[x][y] == 2 or self.my_board[x][y] == 3: if x % 2 != 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(16+y*61, 17+(x*52)) self.scene.addItem(self.item) elif x % 2 == 0: self.item = QGraphicsPixmapItem(QPixmap(picture)) self.item.setOffset(47+y*61, 16+x*53) self.scene.addItem(self.item) self.build_ships_from_matrix() def build_random_matrix(self): self.dm.clear() self.ready_to_play = True self.set_X.hide() self.set_Y.hide() self.set_ship_btn.hide() self.my_board = np.zeros((10, 9)) ships = 0 while ships < 10: x = randint(0, 9) y = randint(0, 8) if self.my_board[x][y] == 0: self.my_board[x][y] = 1 ships += 1 self.build_ships_from_matrix() # self.state.append((self.my_board, self.enemies_board, self.my_points)) def clear_board(self): self.dm.clear() def close_app(self): if self.is_client_connected: self.client.close() self.s.stop() self.close() @staticmethod def _parser(x, y): try: x = int(x) y = int(y) if x not in range(11): x, y = 0, 0 if y not in range(11): x, y = 0, 0 except ValueError: x, y = 0, 0 return x, y
class EditLinksNode(QGraphicsWidget): """ A Node representation with channel anchors. `direction` specifies the layout (default `Qt.LeftToRight` will have icon on the left and channels on the right). """ def __init__(self, parent=None, direction=Qt.LeftToRight, node=None, icon=None, iconSize=None, **args): QGraphicsWidget.__init__(self, parent, **args) self.setAcceptedMouseButtons(Qt.NoButton) self.__direction = direction self.setLayout(QGraphicsLinearLayout(Qt.Horizontal)) # Set the maximum size, otherwise the layout can't grow beyond its # sizeHint (and we need it to grow so the widget can grow and keep the # contents centered vertically. self.layout().setMaximumSize(QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX)) self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.__iconSize = iconSize or QSize(64, 64) self.__icon = icon self.__iconItem = QGraphicsPixmapItem(self) self.__iconLayoutItem = GraphicsItemLayoutItem(item=self.__iconItem) self.__channelLayout = QGraphicsGridLayout() self.__channelAnchors = [] if self.__direction == Qt.LeftToRight: self.layout().addItem(self.__iconLayoutItem) self.layout().addItem(self.__channelLayout) channel_alignemnt = Qt.AlignRight else: self.layout().addItem(self.__channelLayout) self.layout().addItem(self.__iconLayoutItem) channel_alignemnt = Qt.AlignLeft self.layout().setAlignment(self.__iconLayoutItem, Qt.AlignCenter) self.layout().setAlignment(self.__channelLayout, Qt.AlignVCenter | channel_alignemnt) if node is not None: self.setSchemeNode(node) def setIconSize(self, size): """ Set the icon size for the node. """ if size != self.__iconSize: self.__iconSize = QSize(size) if self.__icon: self.__iconItem.setPixmap(self.__icon.pixmap(size)) self.__iconLayoutItem.updateGeometry() def iconSize(self): """ Return the icon size. """ return QSize(self.__iconSize) def setIcon(self, icon): """ Set the icon to display. """ if icon != self.__icon: self.__icon = QIcon(icon) self.__iconItem.setPixmap(icon.pixmap(self.iconSize())) self.__iconLayoutItem.updateGeometry() def icon(self): """ Return the icon. """ return QIcon(self.__icon) def setSchemeNode(self, node): """ Set an instance of `SchemeNode`. The widget will be initialized with its icon and channels. """ self.node = node if self.__direction == Qt.LeftToRight: channels = node.output_channels() else: channels = node.input_channels() self.channels = channels loader = icon_loader.from_description(node.description) icon = loader.get(node.description.icon) self.setIcon(icon) label_template = ('<div align="{align}">' '<b class="channelname">{name}</b><br/>' '<span class="typename">{typename}</span>' '</div>') if self.__direction == Qt.LeftToRight: align = "right" label_alignment = Qt.AlignVCenter | Qt.AlignRight anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft label_row = 0 anchor_row = 1 else: align = "left" label_alignment = Qt.AlignVCenter | Qt.AlignLeft anchor_alignment = Qt.AlignVCenter | Qt.AlignLeft label_row = 1 anchor_row = 0 self.__channelAnchors = [] grid = self.__channelLayout for i, channel in enumerate(channels): text = label_template.format(align=align, name=escape(channel.name), typename=escape(channel.type)) text_item = GraphicsTextWidget(self) text_item.setHtml(text) text_item.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) grid.addItem(text_item, i, label_row, alignment=label_alignment) anchor = ChannelAnchor(self, channel=channel, rect=QRectF(0, 0, 20, 20)) anchor.setBrush(self.palette().brush(QPalette.Mid)) layout_item = GraphicsItemLayoutItem(grid, item=anchor) grid.addItem(layout_item, i, anchor_row, alignment=anchor_alignment) if hasattr(channel, "description"): text_item.setToolTip((channel.description)) self.__channelAnchors.append(anchor) def anchor(self, channel): """ Return the anchor item for the `channel` name. """ for anchor in self.__channelAnchors: if anchor.channel() == channel: return anchor raise ValueError(channel.name) def paint(self, painter, option, widget=None): painter.save() palette = self.palette() border = palette.brush(QPalette.Mid) pen = QPen(border, 1) pen.setCosmetic(True) painter.setPen(pen) painter.setBrush(palette.brush(QPalette.Window)) brect = self.boundingRect() painter.drawRoundedRect(brect, 4, 4) painter.restore()
def img_received_triggered(gui, img): scene = QGraphicsScene() pixmap = QGraphicsPixmapItem(QPixmap(img), None, scene) gui.grOriginalImage.setScene(scene) gui.grOriginalImage.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
def __init__(self): super(QTRehaZenterGUI, self).__init__() uic.loadUi(currentdir + '/ui_files/QTRehaZenterGUI.ui', self) # connect to DB and create cursor object to perform queries self._mysqldb_connection = MySQLdb.connect(host=self.mysql_hostname, user=self.mysql_user, passwd=self.mysql_password, db="iot") # initialize custom object loader widget self.defineNewColorWidget = DefineNewColor.UIDefineNewColorWidget(self) # disable camera feed tab on startup (enabled later) self.tabWidget.setTabEnabled(2, False) # load logo images uniLuLogoScene = QGraphicsScene() imagePixmap_unilu = QGraphicsPixmapItem(QPixmap(QImage(currentdir + "/imgs/university_of_luxembourg_logo.png")), None, uniLuLogoScene) self.grUniLuLogo.setScene(uniLuLogoScene) self.grUniLuLogo.fitInView(uniLuLogoScene.sceneRect(), Qt.KeepAspectRatio) luxAILogoScene = QGraphicsScene() imagePixmap_luxai = QGraphicsPixmapItem(QPixmap(QImage(currentdir + "/imgs/luxai_logo.png")), None, luxAILogoScene) self.grLuxAILogo.setScene(luxAILogoScene) self.grLuxAILogo.fitInView(luxAILogoScene.sceneRect(), Qt.KeepAspectRatio) # initialize calibration file selection dialog self.dlgLoadCalibFile = QFileDialog() self.dlgLoadCalibFile.setFileMode(QFileDialog.ExistingFile) self.dlgLoadCalibFile.setFilter("Calibration files (*.clb)") self.dlgLoadCalibFile.setAcceptMode(QFileDialog.AcceptOpen) # initialize color file selection dialog self.dlgLoadColorFile = QFileDialog() self.dlgLoadColorFile.setFileMode(QFileDialog.ExistingFile) self.dlgLoadColorFile.setFilter("Color files (*.clr)") self.dlgLoadColorFile.setAcceptMode(QFileDialog.AcceptOpen) # initialize calibration file save dialog self.dlgSaveCalibFile = QFileDialog() self.dlgSaveCalibFile.setFileMode(QFileDialog.AnyFile) self.dlgSaveCalibFile.setFilter("Calibration files (*.clb)") self.dlgSaveCalibFile.setAcceptMode(QFileDialog.AcceptSave) # initialize rotation exercises warning message box self.msgRotationExercises = QMessageBox() self.msgRotationExercises.setIcon(QMessageBox.Warning) self.msgRotationExercises.setText("Sorry, rotation exercises have not been implemented yet!") self.msgRotationExercises.setInformativeText("Please choose one of the motion exercises instead until rotation exercises become available.") self.msgRotationExercises.setWindowTitle("Rotation exercises warning") self.msgRotationExercises.setStandardButtons(QMessageBox.Ok) # initialize calibration fail message box self.msgErrorWarning = QMessageBox() self.msgErrorWarning.setIcon(QMessageBox.Warning) self.msgErrorWarning.setStandardButtons(QMessageBox.Ok) # initialize list of faces (in string form) self._faces_list = ["sad", "happy", "crying", "neutral", "showing_smile", "surprise", "breathing_exercise", "breathing_exercise_nose", "smile", "happy_blinking", "calming_down", "random emotion"] self.cmbFaces.addItems(self._faces_list) # disable various labels and widgets on startup self.lblPerRepetitions1.setEnabled(False) self.lblPerRepetitions2.setEnabled(False) self.spnQuantEncRep.setEnabled(False) self.cmbQualiEnc.setEnabled(False) self.btnDeleteLine.setEnabled(False) self.spnFixedReps.setEnabled(False) self.spnFrequencyReps.setEnabled(False) self.btnAddLine.setEnabled(False) self.lblAuth.setVisible(False) self.lblPINCode.setVisible(False) self.lnPINCode.setVisible(False) self.btnConfirm.setVisible(False) self.lblHelloMsg.setVisible(False) self.lblRemove.setVisible(False) self.grProfilePicture.setVisible(True) self.tabWidget.setTabEnabled(1, False) self.tabWidget.setTabEnabled(2, False) self.tabWidget.setTabEnabled(3, False) self.tabWidget.setTabEnabled(4, False) self.lblWrongPINCode.setVisible(False) self.grProfilePicture.setVisible(False) # resize table columns to match their text size header = self.tblEmotionalFeedback.horizontalHeader() header.setResizeMode(0, QHeaderView.Stretch) header.setResizeMode(1, QHeaderView.Stretch) header.setResizeMode(2, QHeaderView.Stretch) # initialize ROS publisher topics rospy.init_node("reha_interface", anonymous=True) self._exercise_request_pub = rospy.Publisher("exercise_request", ExerciseRequest, queue_size=1) self._exercise_stop_pub = rospy.Publisher("exercise_stop", Bool, queue_size=1) self._calibration_request_pub = rospy.Publisher("calibration_request", CalibrationRequest, queue_size=1) rospy.Subscriber("exercise_reply", ExerciseReply, self._server_reply_callback) rospy.Subscriber("calibration_reply", CalibrationReply, self._server_reply_callback) rospy.Subscriber("/plain/image_modified/compressed", CompressedImage, self._img_received_callback) rospy.Subscriber("/user_logging/initial_key", String, self._smartcard_detected_callback) #self._decryption_node = None # initialize some other necessary variables self._is_calibrating = False self._is_exercise_running = False self._bridge = CvBridge() # connect functions to widgets self.btnInternalRotationExercise.clicked.connect(self.btnInternalRotationExerciseClicked) self.btnExternalRotationExercise.clicked.connect(self.btnExternalRotationExerciseClicked) self.btnAbductionMotionExercise.clicked.connect(self.btnAbductionMotionExerciseClicked) self.btnFlexionMotionExercise.clicked.connect(self.btnFlexionMotionExerciseClicked) self.btnBegin.clicked.connect(self.btnBeginClicked) self.btnStop.clicked.connect(self.btnStopClicked) self.btnDefineNewColor.clicked.connect(self.openDefineNewColorWidget) self.slNbrBlocks.valueChanged.connect(self.slNbrBlocksValueChanged) self.rdFixed.clicked.connect(self.rdFixedClicked) self.rdFrequency.clicked.connect(self.rdFrequencyClicked) self.btnAddLine.clicked.connect(self.btnAddLineClicked) self.cmbFaces.currentIndexChanged.connect(self.cmbFacesCurrentIndexChanged) self.actionQuit.triggered.connect(self.closeEvent) self.btnDeleteLine.clicked.connect(self.btnDeleteLineClicked) self.tblEmotionalFeedback.itemClicked.connect(self.tblEmotionalFeedbackItemClicked) self.chkQualitative.clicked.connect(self.chkQualitativeClicked) self.chkQuantitative.clicked.connect(self.chkQuantitativeClicked) self.btnLoadColorFile.clicked.connect(self.btnLoadColorFileClicked) self.btnLoadCalibFile.clicked.connect(self.btnLoadCalibFileClicked) self.btnCalibrateNow.clicked.connect(self.btnCalibrateNowClicked) self.robot_finished.connect(robot_finished_triggered) self.img_received.connect(img_received_triggered) self.smartcard_rosmsg_received.connect(smartcard_rosmsg_received_triggered) self.logoff_signal_received.connect(logoff_signal_received_triggered) self.btnConfirm.clicked.connect(self.btnConfirmClicked) self.lnPINCode.textChanged.connect(self.disableErrorLabelOnEdit)
def btnConfirmClicked(self): # check if PIN code corresponds to PIN code stored in database (use SHA-256 to hash passwords!) cursor = self._mysqldb_connection.cursor() query_str = "select * from tblUser where userID='" + self._rfid + "'" cursor.execute(query_str) if cursor.rowcount != 1: self.lblWrongPINCode.setVisible(True) cursor.close() return # fetch (only) matching row from DB tblUser_row = cursor.fetchone() # hash pin entered by user with salt string from DB pincode_hash = SHA256.new(str(self.lnPINCode.text()) + str(tblUser_row[4])).hexdigest().upper() #print pincode_hash if pincode_hash == tblUser_row[3]: # permit access to user and enable widgets accordingly self.lblWrongPINCode.setVisible(False) self.tabWidget.setTabEnabled(1, True) self.tabWidget.setTabEnabled(2, True) self.tabWidget.setTabEnabled(3, True) self.tabWidget.setTabEnabled(4, True) self.lblAuth.setEnabled(False) self.lblPINCode.setEnabled(False) self.lnPINCode.setEnabled(False) self.btnConfirm.setEnabled(False) self.lblHelloMsg.setVisible(True) self.lblHelloMsg.setText("Welcome back, " + tblUser_row[2] + "!") self.lblRemove.setVisible(True) self.grProfilePicture.setVisible(True) self.grProfilePicture.setEnabled(True) scene = QGraphicsScene() qimg = QtGui.QImage.fromData(tblUser_row[6]) pixmap = QGraphicsPixmapItem(QPixmap.fromImage(qimg), None, scene) self.grProfilePicture.setScene(scene) self.grProfilePicture.fitInView(scene.sceneRect(), Qt.KeepAspectRatio) self.grProfilePicture.setVisible(True) self._encourager.say("Welcome back, " + tblUser_row[2] + "!") self._encourager.show_emotion("happy") ### HARDCODED: display different information depending on user connected ### if self._rfid == "3BEA00008131FE450031C573C0014000900077": self.slNbrBlocks.setValue(3) self.spnNbrRepetitions.setValue(25) self.chkQualitative.setChecked(False) self.chkQuantitative.setChecked(True) self.spnQuantEncRep.setEnabled(True) self.cmbQualiEnc.setEnabled(False) self.spnQuantEncRep.setValue(3) else: self.slNbrBlocks.setValue(2) self.spnNbrRepetitions.setValue(15) self.chkQualitative.setChecked(True) self.chkQuantitative.setChecked(True) self.spnQuantEncRep.setEnabled(True) self.spnQuantEncRep.setValue(2) self.cmbQualiEnc.setEnabled(True) self.cmbQualiEnc.setCurrentIndex(1) #launch_params = ['roslaunch', 'simple_image_cyphering', 'one_node_decryption.launch'] #self._decryption_node = Popen(launch_params) else: self.lblWrongPINCode.setVisible(True) cursor.close()
def itemChange(self, change, variant): if change != QGraphicsItem.ItemSelectedChange: global Dirty; Dirty = True return QGraphicsPixmapItem.itemChange(self, change, variant)
class Scene(QGraphicsScene): def __init__(self, lblXY, spinId, spinX, spinY, btnAddEdge, btnDeleteEdge, spinCommRange, spinEnvX, spinEnvY, comboChannelType): super(self.__class__, self).__init__() self.net = pymote.Network() self.net_dict = {} #for keeping pairs of net_node and scene_node self.comm_range = 200 self.curr_id = 1 self.node_size = 15 self.node_color = QtCore.Qt.blue self.pressed_color = QtCore.Qt.red self.lblXY = lblXY #shows x,y position on scene self.spinId = spinId self.spinId.setEnabled(False) self.spinX = spinX self.spinY = spinY self.btnAddEdge = btnAddEdge self.btnDeleteEdge = btnDeleteEdge self.spinEnvX = spinEnvX self.spinEnvY = spinEnvY self.comboChannelType = comboChannelType self.hide_btn_edge() #on start: auto edge mode selected -> buttons add and delete edge not needed self.hide_pressed_item_data() #on start: no item is pressed -> hide item data self.spinCommRange = spinCommRange self.spinCommRange.setValue(self.comm_range) self.f_show_radius = False self.f_auto_edge = True self.f_move = False self.f_moved = False self.f_show_env = True self.f_opening_net = False self.option = 0 self.edge_option = 0 self.last_pressed_node = 0 self.radius = 0 self.environment = pymote.Environment() self.scene_env = 0 self.envX = 600 self.envY = 600 self.channel_type = self.comboChannelType.currentText() self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY)) def ini_scene(self): self.clear() new_net = pymote.Network() self.net = new_net self.net_dict.clear() self.curr_id = 1 self.option = 0 self.edge_option = 0 self.last_pressed_node = 0 self.radius = 0 self.environment = pymote.Environment() self.scene_env = 0 def get_net(self): return self.net def hide_pressed_item_data(self): #self.spinId.setEnable(False) self.spinId.setValue(0) self.spinX.setEnabled(False) self.spinX.setValue(0) self.spinY.setEnabled(False) self.spinY.setValue(0) def show_pressed_item_data(self): #self.spinId.setEnable(True) self.spinId.setValue(self.last_pressed_node.node_id) self.spinX.setEnabled(True) self.spinX.setValue(self.last_pressed_node.get_X()) self.spinY.setEnabled(True) self.spinY.setValue(-self.last_pressed_node.get_Y()) def hide_btn_edge(self): self.btnAddEdge.setEnabled(False) self.btnDeleteEdge.setEnabled(False) def show_btn_edge(self): self.btnAddEdge.setEnabled(True) self.btnDeleteEdge.setEnabled(True) def auto_add_edge(self, toggle): if toggle.isChecked() == True: self.f_auto_edge = True self.hide_btn_edge() self.delete_all_edges() self.net.recalculate_edges() self.draw_all_edges() else: self.f_auto_edge = False self.show_btn_edge() def show_radius(self, toggle): if toggle.isChecked() == True: self.f_show_radius = True if self.last_pressed_node != 0 and self.option == 0: self.draw_radius(self.last_pressed_node.get_X() + self.node_size/2, self.last_pressed_node.get_Y() + self.node_size/2, self.comm_range) else: self.f_show_radius = False if self.radius != 0: self.delete_radius() def show_env(self, toggle): if toggle.isChecked() == True: self.f_show_env =True if self.scene_env != 0: self.scene_env.show() else: self.f_show_env = False if self.scene_env != 0: self.delete_env() def draw_radius(self, x, y, comm_range): self.radius = Radius(x, y, comm_range) self.addItem(self.radius) def delete_radius(self): self.removeItem(self.radius) self.radius = 0 # def search_node_by_id(self): # f_found = False # # if self.last_pressed_node != 0: # if self.last_pressed_node.node_id != self.spinId.value(): # self.last_pressed_node.setBrush(self.node_color) # for n in self.items(): # if isinstance(n, Node): # if n.node_id == self.spinId.value(): # if self.radius != 0 and self.f_show_radius: # size = n.comm_range # self.radius.setRect(n.get_X() - size, n.get_Y() - size, size * 2, size * 2) # self.last_pressed_node = n # n.setBrush(self.pressed_color) # self.spinX.setValue(n.get_X()) # self.spinY.setValue(-n.get_Y()) # f_found = True # # if not f_found: # self.last_pressed_node = 0 # self.spinX.setValue(0) # self.spinY.setValue(0) # if self.radius != 0: # self.delete_radius() def change_node_x(self): if self.last_pressed_node != 0 and not self.f_move: if self.last_pressed_node.get_X() != self.spinX.value(): self.spin_value_changed(True) def change_node_y(self): if self.last_pressed_node != 0 and not self.f_move: if -self.last_pressed_node.get_Y() != self.spinY.value(): self.spin_value_changed(False) def spin_value_changed(self, f_isX): if not self.f_auto_edge: self.move_edges(self.last_pressed_node, self.spinX.value(), self.spinY.value()) if self.f_auto_edge and not self.f_moved: #delete edges before node is moved edges = list() for edge in self.last_pressed_node.edges: edges.append(edge) for edge in edges: self._delete_edge(edge, True) if f_isX: self.last_pressed_node.setX(self.spinX.value() - self.last_pressed_node.get_iniX()) self.last_pressed_node.node_label.setX(self.spinX.value()) else: self.last_pressed_node.setY(-self.spinY.value() - self.last_pressed_node.get_iniY()) self.last_pressed_node.node_label.setY(-self.spinY.value()) net_node, n = self.get_nodes_from_net(self.last_pressed_node, 0) self.net.pos[net_node] = [self.spinX.value(), self.spinY.value()] if self.f_auto_edge and not self.f_moved: self.net.recalculate_edges([self.last_pressed_node.net_node]) self.draw_recalc_edges(self.last_pressed_node.net_node) def change_comm_range(self): self.comm_range = self.spinCommRange.value() if self.last_pressed_node != 0: self.last_pressed_node.set_comm_range(self.comm_range) net_node, n = self.get_nodes_from_net(self.last_pressed_node, 0) net_node.commRange = self.comm_range if self.radius != 0: size = self.comm_range self.radius.setRect(self.radius.get_iniX() - size, self.radius.get_iniY() - size, size * 2, size * 2) def change_node_env_x(self): self.envX = self.spinEnvX.value() #TODO: dodati promjenu velicine env u net.env self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY)) def change_node_env_y(self): self.envY = self.spinEnvY.value() #TODO: dodati promjenu velicine env u net.env self.setSceneRect(QtCore.QRectF(0, -self.envY, self.envX, self.envY)) def change_channel_type(self): if self.comboChannelType.currentIndex() == 0: self.net.channelType = pymote.channeltype.Udg(self.net.environment) elif self.comboChannelType.currentIndex() == 1: self.net.channelType = pymote.channeltype.SquareDisc(self.net.environment) if not self.f_opening_net and self.f_auto_edge: self.delete_all_edges() self.net.recalculate_edges() self.draw_all_edges() def draw_net(self, net): self.ini_scene() self.net = net self.f_opening_net = True max_id = 0 for net_node in net: node = self.draw_node(net.pos[net_node][0], net.pos[net_node][1], net_node.id, net_node.commRange, net_node) self.net_dict[net_node] = node if net_node.id > max_id: max_id = net_node.id self.curr_id = max_id + 1 self.draw_all_edges() self.environment = net.environment img = Image.fromarray(net.environment.im[::-1, :], 'L') img.save('env.png') self.draw_env('env.png') combo_index = -1 if isinstance(net.channelType, pymote.channeltype.Udg): combo_index = 0 elif isinstance(net.channelType, pymote.channeltype.SquareDisc): combo_index = 1 self.comboChannelType.setCurrentIndex(combo_index) self.f_opening_net = False def draw_node(self, x, y, node_id, comm_range, net_node): node_label = Label(str(node_id), x, -y) self.addItem(node_label) node = Node(x - self.node_size/2, -y - self.node_size/2, self.node_size, node_id, node_label, comm_range, net_node) node.setBrush(self.node_color) self.addItem(node) return node def draw_edge(self, node1, node2): edge = Edge(node1, node2) self.addItem(edge) node1.add_edge_to_list(edge) node2.add_edge_to_list(edge) return edge def draw_all_edges(self): net = self.net edges = list() for net_node in self.net: for n in net.adj[net_node].keys(): f_draw_edge = True for e in edges: #check if edge already drawn if (e[0] == net_node.id and e[1] == n.id) or (e[1] == net_node.id and e[0] == n.id): f_draw_edge = False if f_draw_edge: node = self.net_dict[net_node] adj_node = self.net_dict[n] self.draw_edge(node, adj_node) edges.append((net_node.id, n.id)) def delete_all_edges(self): for item in self.items(): if isinstance(item, Edge): self._delete_edge(item, True) def draw_recalc_edges(self, net_node): node = self.net_dict[net_node] for n in self.net.adj[net_node].keys(): adj_node = self.net_dict[n] self.draw_edge(node, adj_node) def open_env(self): filters = ['Environment image (*.png)', 'All files (*)'] selectedFilter = 'Environment image (*.png)' filters = ';;'.join(filters) fname = QFileDialog.getOpenFileName( self.parent(), "Choose a file to open", '', filters, selectedFilter) if fname: try: self.environment.__init__(path = str(fname)) self.net.environment = self.environment self.draw_env(fname) except Exception as e: print ("Error opening file %s" % str(e)), QMessageBox.critical( self, "Error opening file", str(e), QMessageBox.Ok, QMessageBox.NoButton) def draw_env(self, image): if self.scene_env == 0: self.scene_env = QGraphicsPixmapItem() else: self.removeItem(self.scene_env) self.scene_env.setPixmap(QPixmap(image)) if self.scene_env != 0: self.scene_env.setPos(0, -self.environment.im.shape[1]) self.addItem(self.scene_env) self.scene_env.setZValue(-1) if not self.f_show_env: self.scene_env.hide() self.spinEnvX.setValue(self.environment.im.shape[0]) self.spinEnvY.setValue(self.environment.im.shape[1]) if self.f_auto_edge: self.delete_all_edges() self.net.recalculate_edges() self.draw_all_edges() def delete_env(self): if self.scene_env != 0: self.scene_env.hide() def option_change(self): if self.radius != 0: self.delete_radius() if self.edge_option != 0: self.edge_option = 0 self.deselect_node() if self.last_pressed_node != 0: self.deselect_node() def move_node(self): self.option_change() self.option = 0 def add_node(self): self.option_change() self.option = 1 def _add_node(self, x, y): #add node to network net_node = pymote.Node() self.net.add_node(net_node, (x, y)) net_node.id = self.curr_id net_node.commRange = self.comm_range #add node to scene node = self.draw_node(x, y, self.curr_id, self.comm_range, net_node) self.net_dict[net_node] = node self.curr_id = self.curr_id + 1 '''when adding new node to network pymote calls recalculate_edges, if USE MODEL OF COMMUNICATON TO AUTO EDGES is not selected then we need to remove those edges''' if not self.f_auto_edge: self.net.adj[net_node].clear() for n in self.net: if self.net.adj[n].has_key(net_node): del self.net.adj[n][net_node] else: self.draw_recalc_edges(net_node) def delete_node(self): self.option_change() self.option = 2 def _delete_node(self, node): #delete node edges from scene edges = list() for edge in node.edges: edges.append(edge) for edge in edges: self._delete_edge(edge, False) self.removeItem(node) self.removeItem(node.node_label) #delete node from network self.net.remove_node(node.net_node) del self.net_dict[node.net_node] def add_edge(self): self.option_change() self.option = 3 def _add_edge(self, pressed_node): if pressed_node != 0: if self.edge_option == 0: self.select_node(pressed_node) self.edge_option = 1 if self.edge_option == 1 and self.last_pressed_node != pressed_node and self.last_pressed_node != 0: self.edge_option = 2 edge_exists = self.find_edge(pressed_node, self.last_pressed_node) if edge_exists != 0: self.edge_option = 0 self.deselect_node() if self.edge_option == 2: self.draw_edge(self.last_pressed_node, pressed_node) self.edge_option = 0 #add edge to net.adj node1, node2 = self.get_nodes_from_net(self.last_pressed_node, pressed_node) if node1 != 0 and node2 != 0: self.net.adj[node1][node2] = [] self.net.adj[node2][node1] = [] self.deselect_node() elif pressed_node == 0 and self.edge_option == 1: self.edge_option = 0 self.deselect_node() def delete_edge(self): self.option_change() self.option = 4 def _delete_edge(self, edge, f_recal_called): n1 = edge.node1 n2 = edge.node2 n1.remove_edge_from_list(edge) n2.remove_edge_from_list(edge) self.removeItem(edge) #delete edge from net.adj if not f_recal_called: node1, node2 = self.get_nodes_from_net(n1, n2) if node1 != 0 and node2 != 0: self.delete_edge_from_adj(node1, node2) self.delete_edge_from_adj(node2, node1) def get_nodes_from_net(self, n1, n2): node1 = 0 node2 = 0 for n in self.net: if n.id == n1.node_id: node1 = n if n2 != 0: if n.id == n2.node_id: node2 = n return (node1, node2) def delete_edge_from_adj(self, node, del_n): del self.net.adj[node][del_n] def find_edge(self, node, n): for e in node.edges: if (n.get_X() == e.line().x1() and n.get_Y() == e.line().y1()) or (n.get_X() == e.line().x2() and n.get_Y() == e.line().y2()): return e return 0 def select_node(self, node): self.last_pressed_node = node node.setBrush(self.pressed_color) if self.option == 0: self.show_pressed_item_data() if self.f_show_radius: self.draw_radius(node.get_X() + self.node_size/2, node.get_Y() + self.node_size/2, self.last_pressed_node.comm_range) def deselect_node(self): self.last_pressed_node.setBrush(self.node_color) self.last_pressed_node = 0 self.hide_pressed_item_data() if self.radius != 0: self.delete_radius() def move_edges(self, node, x, y): for edge in node.edges: if edge.line().x1() == node.get_X() and edge.line().y1() == node.get_Y(): edge.setLine(x, y, edge.line().x2(), edge.line().y2()) else: edge.setLine(edge.line().x1(), edge.line().y1(), x, y) def mousePressEvent(self, e): mouseX = e.scenePos().x() mouseY = -e.scenePos().y() pressed_node = 0 pressed_edge = 0 self.f_move = True for item in self.items(e.scenePos()): if pressed_node == 0 and isinstance(item, Node): pressed_node = item if pressed_edge == 0 and isinstance(item, Edge): pressed_edge = item #on new mouse press deselect last node (only if option add edge is not selected) if self.last_pressed_node != 0: if self.edge_option != 1: self.deselect_node() if self.option == 1: #draw node self._add_node(mouseX, mouseY) elif self.option == 2: #delete node if pressed_node != 0: self._delete_node(pressed_node) elif self.option == 3: #add edge self._add_edge(pressed_node) elif self.option == 4: #delete edge if pressed_edge != 0: self._delete_edge(pressed_edge, False) #select new pressed node and save it if pressed_node != 0: if self.option == 0: self.select_node(pressed_node) self.spinCommRange.setValue(pressed_node.comm_range) else: self.last_pressed_node = 0 def mouseMoveEvent(self, e): mouseX = e.scenePos().x() mouseY = e.scenePos().y() self.lblXY.setText('x: ' + str(mouseX) + ' y: ' + str(-mouseY)) if self.last_pressed_node != 0 and self.f_move: node = self.last_pressed_node self.f_moved = True if self.option == 0: #when moving node, move his edges if not self.f_auto_edge: self.move_edges(node, mouseX, mouseY) #move node node.setX(mouseX - node.get_iniX()) node.setY(mouseY - node.get_iniY()) node.node_label.setPos(mouseX, mouseY) net_node, n = self.get_nodes_from_net(node, 0) self.net.pos[net_node][0] = mouseX self.net.pos[net_node][1] = -mouseY if self.f_auto_edge: edges = list() for edge in node.edges: edges.append(edge) for edge in edges: self._delete_edge(edge, True) self.spinX.setValue(mouseX) self.spinY.setValue(-mouseY) #move radius if self.f_show_radius and (self.option == 1 or (self.option == 0 and self.last_pressed_node != 0 and self.f_move)): if self.radius == 0 and self.option == 1: self.draw_radius(mouseX, mouseY, self.comm_range) elif self.radius != 0: self.radius.setX(mouseX - self.radius.get_iniX()) self.radius.setY(mouseY - self.radius.get_iniY()) def mouseReleaseEvent(self, e): if self.f_auto_edge and self.last_pressed_node != 0 and self.option == 0 and self.f_moved: self.net.recalculate_edges([self.last_pressed_node.net_node]) self.draw_recalc_edges(self.last_pressed_node.net_node) self.f_move = False self.f_moved = False