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 updateScreen(self, filename, xmlPath, x=0, y=0, w=0, h=0, reloadMode=False): """ Update the screen """ self.imagePath = filename if not reloadMode: self.tableModel.mylist = [] self.tableModel.beginResetModel() self.tableModel.endResetModel() pixmap = QPixmap(filename) if pixmap is not None: self.origWidth = pixmap.width() self.origHeight = pixmap.height() self.screenResolutionLabel.setText( "Resolution=%sx%s" % (self.origWidth, self.origHeight)) #portrait if self.origWidth < self.origHeight: pixmap = pixmap.scaledToHeight(Settings.getInt( 'MobileAndroid', 'resolution-screen-height'), mode=Qt.SmoothTransformation) self.mobileImageLabel.setPixmap(pixmap) else: pixmap = pixmap.scaledToWidth(Settings.getInt( 'MobileAndroid', 'resolution-screen-width'), mode=Qt.SmoothTransformation) self.mobileImageLabel.setPixmap(pixmap) self.drawRectangle(x=x, y=y, w=w, h=h) self.resize(pixmap.width(), pixmap.height()) # convert xml to dict if len(xmlPath): f = QFile(xmlPath) if f.open(QIODevice.ReadOnly): document = QDomDocument() if document.setContent(f): newModel = DomModel(document, self) self.mobileTreeView.setModel(newModel) self.mobileTreeView.expandAll() self.mobileTreeView.resizeColumnToContents(0) f.close()
def setImage(self, imgPath): print("[INFO] ImageWin's cur img path: {}".format(imgPath)) pixmap = QPixmap(imgPath) width = pixmap.width() height = pixmap.height() self.setFixedSize(width, height) self.main_imageLabel = QtGui.QLabel(self) self.main_imageLabel.setGeometry(QtCore.QRect(0, 0, pixmap.width(), pixmap.height())) self.main_imageLabel.setPixmap(pixmap) self.main_imageLabel.setAlignment(Qt.AlignVCenter)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.ui = Ui_Form() self.ui.setupUi(self) pixmap = QPixmap('./banner_nuevo_2016.png') print pixmap.width(), pixmap.height() self.ui.L_ima.setGeometry(20, 10, pixmap.width(), pixmap.height()) self.ui.L_ima.setPixmap(pixmap) self.Web = QWebView() self.la = QVBoxLayout() self.la.addWidget(self.Web) self.ui.W_map.setLayout(self.la) self.timer = QTimer(self) self.timer.timeout.connect(self._result_available) self.timer.start(5000) #milisegundos
def initLanePixmaps(self, grayItemList, highlightItemList): self.lanePixmapList = [] p = QPixmap(":/lane/0.png") width = p.width() height = p.height() totalLaneCount = grayItemList[0].lane_num blankPixmap = QPixmap(":/lane/lane_background.png") for i in range(0, totalLaneCount): x = (width+2)*(totalLaneCount-i-1) self.lanePixmapList.append(LanePixmapWithTopLeftXY(x, 0, blankPixmap)) for grayItem in grayItemList: for i in range(0, 16): if grayItem.lane_info & 2**i: for picPath in grayItem.getPicPath_gray(): tempPixmap = QPixmap(picPath) x = (width+2)*(totalLaneCount-i-1) self.lanePixmapList.append(LanePixmapWithTopLeftXY(x, 0, tempPixmap)) for highlightItem in highlightItemList: for i in range(0, 16): if highlightItem.lane_info & 2**i: for picPath in highlightItem.getPicPath_highlight(): tempPixmap = QPixmap(picPath) x = (width+2)*(totalLaneCount-i-1) self.lanePixmapList.append(LanePixmapWithTopLeftXY(x, 0, tempPixmap))
def addTestImage(self, color_image): self.ocr_areas = OCRAreasFinder(color_image, self.settings["contrast"]) self.market_width = self.ocr_areas.market_width self.valid_market = self.ocr_areas.valid img = QPixmap(self.hiddentext) width = img.width() height = img.height() aspect_ratio = float(width)/height if aspect_ratio > 1.78: new_w = int(1.77778*height) rect = QRect((width-new_w)/2, 0, new_w, height) img = img.copy(rect) if self.valid_market: points = self.ocr_areas.market_table self.market_offset = (points[0][0], points[0][1]) station = self.ocr_areas.station_name self.station_offset = (station[0][0], station[0][1]) rect = QRect(0, 0, points[1][0] + 20, points[1][1] + 20) cut = img.copy(rect) return cut else: self.market_offset = (0, 0) self.station_offset = (0, 0) return img
def addTestImage(self, color_image): self.ocr_areas = OCRAreasFinder(color_image, self.settings["contrast"]) self.market_width = self.ocr_areas.market_width self.valid_market = self.ocr_areas.valid if self.settings['gray_preview']: img = cv2.imread(unicode(self.hiddentext).encode(sys.getfilesystemencoding()), 0) img = array2qimage(img) pix = QPixmap.fromImage(img) else: pix = QPixmap(self.hiddentext) width = pix.width() height = pix.height() if height > 0: aspect_ratio = float(width)/height if aspect_ratio > 1.78: new_w = int(1.77778*height) rect = QRect((width-new_w)/2, 0, new_w, height) pix = pix.copy(rect) if self.valid_market: points = self.ocr_areas.market_table self.market_offset = (points[0][0], points[0][1]) station = self.ocr_areas.station_name self.station_offset = (station[0][0], station[0][1]) rect = QRect(0, 0, points[1][0] + 20, points[1][1] + 20) cut = pix.copy(rect) return cut else: self.market_offset = (0, 0) self.station_offset = (0, 0) return pix
def addTestImage(self, color_image): self.ocr_areas = OCRAreasFinder(color_image, self.settings["contrast"]) self.market_width = self.ocr_areas.market_width self.valid_market = self.ocr_areas.valid if self.settings['gray_preview']: img = cv2.imread( unicode(self.hiddentext).encode(sys.getfilesystemencoding()), 0) img = array2qimage(img) pix = QPixmap.fromImage(img) else: pix = QPixmap(self.hiddentext) width = pix.width() height = pix.height() if height > 0: aspect_ratio = float(width) / height if aspect_ratio > 1.78: new_w = int(1.77778 * height) rect = QRect((width - new_w) / 2, 0, new_w, height) pix = pix.copy(rect) if self.valid_market: points = self.ocr_areas.market_table self.market_offset = (points[0][0], points[0][1]) station = self.ocr_areas.station_name self.station_offset = (station[0][0], station[0][1]) rect = QRect(0, 0, points[1][0] + 20, points[1][1] + 20) cut = pix.copy(rect) return cut else: self.market_offset = (0, 0) self.station_offset = (0, 0) return pix
def select_icon(self, item): icon = str(item.text()) p = os.path.join(self.selected_dir, self.selected_theme, self.selected_sub_dir, icon) pixmap = QPixmap(p) self.image.setPixmap(pixmap) self.image.resize(pixmap.width(), pixmap.height())
class ResizableImage(QLabel): def __init__(self, filename, height, min_scale, max_scale): super(ResizableImage, self).__init__() self.setAlignment(Qt.AlignCenter) self.full_pixmap = None self.scaled_pixmap = None self.aspect = None self.set_file(filename) self.set_height(height) self.min_height = self.full_pixmap.height() * min_scale * self.aspect self.min_width = self.full_pixmap.width() * min_scale / self.aspect self.max_height = self.full_pixmap.height() * max_scale * self.aspect self.max_width = self.full_pixmap.width() * max_scale / self.aspect def set_file(self, filename): self.full_pixmap = QPixmap(filename) self.aspect = float(self.full_pixmap.height()) / self.full_pixmap.width() if self.scaled_pixmap is not None: self.set_height(self.scaled_pixmap.height()) def set_height(self, height): self.scaled_pixmap = self.full_pixmap.scaledToHeight(height, Qt.SmoothTransformation) self.setPixmap(self.scaled_pixmap) def set_width(self, width): self.scaled_pixmap = self.full_pixmap.scaledToWidth(width, Qt.SmoothTransformation) self.setPixmap(self.scaled_pixmap) def resizeEvent(self, ev): width, height = ev.size().width(), ev.size().height() label_aspect = height / width if label_aspect > self.aspect: self.set_width(min(max(.9 * width, self.min_width), self.max_width)) else: self.set_height(min(max(.9 * height, self.min_height), self.max_height))
class Human(Entity): BRAVE = "brave" COWARD = "coward" CARELESS = "careless" CAUTIOUS = "cautious" RATIONAL = "rational" STUPID = "stupid" WEAPON_LONG = "long" WEAPON_SHORT = "short" NO_WEAPON = "noweapon" def __init__(self, personality, weapon, cord_x=0, cord_y=0, parent=None): super().__init__("human_{}_{}.png".format(personality, weapon), parent=parent) self.personality = personality self.weapon = weapon self.cord_x = cord_x self.cord_y = cord_y self.setFixedSize(73 * _SCALE, 73 * _SCALE) def change_weapon(self, weapon): self.weapon = weapon self._base_image = "human_{}_{}.png".format(self.personality, self.weapon) self.updatePixmap() def updatePixmap(self): path = _PATH + os.sep + "assets" + os.sep + self._base_image self.__pixmap = QPixmap(path) self.__pixmap = self.__pixmap.scaled(self.__pixmap.width() * _SCALE, self.__pixmap.height() * _SCALE) self.__pixmap = self.__pixmap.transformed(QTransform().rotate(self.angle)) self._base_label.setPixmap(self.__pixmap)
def __init__(self, parent=None, filename=None): super(MainForm, self).__init__(parent) self.view = GraphicsView() background = QPixmap(filename) self.filename = os.path.splitext(filename)[0] if ("-%s" % ORG) in self.filename: self.filename = self.filename[:-len(ORG)-5] + ".png" self.view.setBackgroundBrush(QBrush(background)) # self.view.setCacheMode(QGraphicsView.CacheBackground) # self.view.setDragMode(QGraphicsView.ScrollHandDrag) self.scene = QGraphicsScene(self) global scene scene = self.scene self.view.dialog = self self.view.setScene(self.scene) self.prevPoint = QPoint() self.lastStamp = -1 buttonLayout = QVBoxLayout() for text, slot in ( ("&Tag", self.addTag), ("Align &bottom", self.alignBottom), ("Align &left", self.alignLeft), ("&Save", self.save), ("&Quit", self.accept)): button = QPushButton(text) if not MAC: button.setFocusPolicy(Qt.NoFocus) self.connect(button, SIGNAL("clicked()"), slot) if text == "&Save": buttonLayout.addStretch(5) if text == "&Quit": buttonLayout.addStretch(1) buttonLayout.addWidget(button) buttonLayout.addStretch() self.view.resize(background.width(), background.height()) self.scene.setSceneRect(0, 0, background.size().width(), background.size().height()) self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) layout = QHBoxLayout() layout.addWidget(self.view, 1) layout.addLayout(buttonLayout) self.setLayout(layout) self.setWindowTitle(AppName) info_name = self.filename + "-" + TAG + ".txt" if os.path.exists(info_name): for tag, x, y in [line.strip().split("\t") for line in open(info_name, "rt").readlines()]: self.addTag(int(tag), QPointF(int(x), int(y)), adjust_position=False) global Dirty; Dirty=False self.show() self.raise_()
def default_image(self): default = "./IMG/default.png" image_display = default filename = default.split("/") self.label = QLabel(self.centralwidget) pixmap = QPixmap(image_display) self.label.setPixmap(pixmap) self.centralwidget.resize(pixmap.width(),pixmap.height())
def __init__(self, image_path, sprite_width, sprite_height, label): pixmap = QPixmap(image_path) width, height = pixmap.width(), pixmap.height() self.pixmaps = [] for x in range(0, width, sprite_width): for y in range(0, height, sprite_height): self.pixmaps.append(pixmap.copy(x, y, sprite_width, sprite_height)) self._current_frame = 0 self.label = label
def run(self): listofimages, nameparts, padding, dirname = self.listrestofsequence(self.f) numberofframes = self.numberofframes duration = (float(numberofframes)/ 25.0)*1000.0 tempfolder = self._refreshTempFolder(gTEMPFOLDER + '/images') image = QPixmap("%s"%(listofimages[0])) size = '%sx%s' % (image.width(),image.height()) # emit setup frames, duration, size self.EmitSetupPlayer(numberofframes,duration,size) if nameparts[2].lower() != '.png': # convert list of images to png first, it's the only format supported by pyqt when compiled # emit start of tempfolder to init dialogbox self.EmitTempfolderUpdate(tempfolder,'start',len(listofimages),"Processing images... ") # use ffmpeg to convert the entire list to png inputfile = '%s/%s%s%sd%s' %(dirname, nameparts[0],'%0',padding,nameparts[2]) outputfile = '%s/%s%sd%s' % (tempfolder, 'temp.%0',padding,'.png') singlefile = outputfile % 1 # run the ffmpeg command command = gFFMPEG + ' -i "'+inputfile+'" -f image2 -sameq '+outputfile self.process = self.Command(command) self.process.wait() # replace the listofimages with the new one from ffmpeg listofimages, nameparts, padding, dirname = self.listrestofsequence(singlefile) numberofframes = len(listofimages) duration = (float(numberofframes) / 25.0)*1000.0 # emit the signal done self.EmitTempfolderUpdate(tempfolder,'done',len(listofimages), "Done.") """ self.EmitStartRegPdBox('start', 0, numberofframes, "Reading Images..." ) for i in range(numberofframes): image=QPixmap("%s"%(listofimages[i])) self.EmitImage2Datablock(image,i) self.EmitStartRegPdBox('between', i, numberofframes) self.EmitStartRegPdBox('end', numberofframes, numberofframes) self.EmitSetupPlayer(numberofframes,duration,size) """ return
def paint(self, painter, option, index): filePath = self.model.filePath(index) fileName = self.model.fileName(index) r = option.rect img = QPixmap(filePath) if img.isNull(): # If not image file, try to load icon with QFileIconProvider # according to file type (extension name). # Currently not work as intended. fileInfo = self.model.fileInfo(index) icon = QFileIconProvider().icon(fileInfo) img = icon.pixmap(QSize(32, 32)) # Scale to height, align center horizontally, align bottom vertically. if img.height() > self.thumbHeight: img = img.scaledToHeight(self.thumbHeight, Qt.SmoothTransformation) if img.width() > self.thumbHeight: img = img.scaledToWidth(self.thumbHeight, Qt.SmoothTransformation) imgLeft = (self.width - img.width()) / 2 imgTop = self.thumbHeight - img.height() painter.drawPixmap(r.left()+imgLeft, r.top()+imgTop, img) rect = QRect(r.left(), r.top()+self.thumbHeight, self.width, self.nameHeight) flag = Qt.AlignHCenter | Qt.TextWrapAnywhere # get the bounding rectangle of the fileName bdRect = painter.boundingRect(rect, flag, fileName) if bdRect.height() < rect.height(): rect = bdRect if option.state & QStyle.State_Selected: painter.setBrush(self.parent().palette().highlight()) painter.drawRoundedRect(rect, 5, 5) pen = QPen(self.parent().palette().highlightedText(), 1, Qt.SolidLine) else: pen = QPen(self.parent().palette().text(), 1, Qt.SolidLine) painter.setPen(pen) painter.drawText(rect, flag, fileName)
def paint(self, painter, option, index): filePath = self.model.filePath(index) fileName = self.model.fileName(index) r = option.rect img = QPixmap(filePath) if img.isNull(): # If not image file, try to load icon with QFileIconProvider # according to file type (extension name). # Currently not work as intended. fileInfo = self.model.fileInfo(index) icon = QFileIconProvider().icon(fileInfo) img = icon.pixmap(QSize(32, 32)) # Scale to height, align center horizontally, align bottom vertically. if img.height() > self.thumbHeight: img = img.scaledToHeight(self.thumbHeight, Qt.SmoothTransformation) if img.width() > self.thumbHeight: img = img.scaledToWidth(self.thumbHeight, Qt.SmoothTransformation) imgLeft = (self.width - img.width()) / 2 imgTop = self.thumbHeight - img.height() painter.drawPixmap(r.left() + imgLeft, r.top() + imgTop, img) rect = QRect(r.left(), r.top() + self.thumbHeight, self.width, self.nameHeight) flag = Qt.AlignHCenter | Qt.TextWrapAnywhere # get the bounding rectangle of the fileName bdRect = painter.boundingRect(rect, flag, fileName) if bdRect.height() < rect.height(): rect = bdRect if option.state & QStyle.State_Selected: painter.setBrush(self.parent().palette().highlight()) painter.drawRoundedRect(rect, 5, 5) pen = QPen(self.parent().palette().highlightedText(), 1, Qt.SolidLine) else: pen = QPen(self.parent().palette().text(), 1, Qt.SolidLine) painter.setPen(pen) painter.drawText(rect, flag, fileName)
def open_file(self, filePath): """ Try to read the currently selected file and print it out to the stdout. """ fileInfo = QFileInfo(filePath) fname = unicode(fileInfo.fileName()) name, ext = path.splitext(fname) if ext.lower() in u'.bmp .gif .ico .jpg .png .tif .xbm'.split(): # apertura come immagine message = u'Opening image {}...'.format(filePath) logging.info(message) self.status_bar.showMessage(message) pixmap = QPixmap(filePath) self.image_window = QScrollArea() self.image_label = QLabel() self.image_label.setPixmap(pixmap) self.image_window.setWidget(self.image_label) self.image_window.show() self.image_label.show() message = u'Image size: {}x{}'.format(pixmap.width(), pixmap.height()) self.status_bar.showMessage(message) else: message = u'Opening file {}...'.format(filePath) logging.info(message) self.status_bar.showMessage(message) nchars = 1000000 # number of first characters showed (temp) try: fobj = open(unicode(filePath), 'rb') except Exception as err: # [Errno 22] invalid mode ('r') or filename: PyQt4.QtCore.QString(u'F:/\u65e5\u672c.txt') print('open error: {}'.format(err)) logging.error(err) self.status_bar.showMessage(str(err)) else: try: data = fobj.read(nchars) except Exception as err: print('read error: {}'.format(err)) logging.error(err) self.status_bar.showMessage(str(err)) else: #sts, old_output = getstatusoutput('chardetect.py "{}"'.format(filePath)) dec = data.decode('utf-8') # override existing text window self.text_window.setPlainText(dec) if not self.text_window.isVisible(): self.text_window.show() status_msg = u"'{}' file read.".format(fname) if len(data) == nchars: status_msg += u' (NB: showed {:,} first bytes only!)'.format(nchars) self.status_bar.showMessage(status_msg) finally: fobj.close()
class PixmapButton(QPushButton): def __init__(self, parent): QPushButton.__init__(self, parent) self.fPixmapNormal = QPixmap() self.fPixmapDown = QPixmap() self.fPixmapHover = QPixmap() self.fPixmapRect = QRectF(0, 0, 0, 0) self.fIsHovered = False self.setText("") def setPixmaps(self, normal, down, hover): self.fPixmapNormal.load(normal) self.fPixmapDown.load(down) self.fPixmapHover.load(hover) width = self.fPixmapNormal.width() height = self.fPixmapNormal.height() self.fPixmapRect = QRectF(0, 0, width, height) self.setMinimumSize(width, height) self.setMaximumSize(width, height) def enterEvent(self, event): self.fIsHovered = True QPushButton.enterEvent(self, event) def leaveEvent(self, event): self.fIsHovered = False QPushButton.leaveEvent(self, event) def paintEvent(self, event): painter = QPainter(self) event.accept() if not self.isEnabled(): painter.save() painter.setOpacity(0.2) painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect) painter.restore() elif self.isChecked() or self.isDown(): painter.drawPixmap(self.fPixmapRect, self.fPixmapDown, self.fPixmapRect) elif self.fIsHovered: painter.drawPixmap(self.fPixmapRect, self.fPixmapHover, self.fPixmapRect) else: painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
def setTiles(self): #background brush = QBrush() pix = QPixmap(os.getcwd() + "/robotImages/tile.png") brush.setTexture(pix) brush.setStyle(24) self.setBackgroundBrush(brush) #wall #left left = QGraphicsRectItem() pix = QPixmap(os.getcwd() + "/robotImages/tileVert.png") left.setRect(QtCore.QRectF(0, 0, pix.width(), self.height)) brush.setTexture(pix) brush.setStyle(24) left.setBrush(brush) left.name = 'left' self.addItem(left) #right right = QGraphicsRectItem() right.setRect(self.width - pix.width(), 0, pix.width(), self.height) right.setBrush(brush) right.name = 'right' self.addItem(right) #top top = QGraphicsRectItem() pix = QPixmap(os.getcwd() + "/robotImages/tileHori.png") top.setRect(QtCore.QRectF(0, 0, self.width, pix.height())) brush.setTexture(pix) brush.setStyle(24) top.setBrush(brush) top.name = 'top' self.addItem(top) #bottom bottom = QGraphicsRectItem() bottom.setRect(0, self.height - pix.height(), self.width, pix.height()) bottom.setBrush(brush) bottom.name = 'bottom' self.addItem(bottom)
def loadImage(self, inputFile): self._setStatusLabel('load', ProcessStatus.Running) if (not inputFile.exists()): self._showStatus('ERROR: Input file not found! File path was ' + inputFile.absoluteFilePath()) self._setStatusLabel('load', ProcessStatus.Failure) return False self._inputFile = inputFile pixmap = QPixmap(self._inputFile.absoluteFilePath()) if pixmap.isNull(): self._signalError('Loading of raw image failed.') return pixmap = QPixmap(self._inputFile.absoluteFilePath()) w = pixmap.width() h = pixmap.height() self._scene.addPixmap(pixmap) self._scene.setSceneRect(QRectF(0, 0, w, h)) self.planView.setSceneView(self._scene, QRectF(0, 0, w, h)) self.headerView.setSceneView(self._scene, QRectF(0, 0, w, 200)) self.footerView.setSceneView(self._scene, QRectF(100, h - 600, w - 200, 500)) self.gcpWidget1.setScene(self._scene, 250, 100, 2) self.gcpWidget2.setScene(self._scene, 250, 3050, 2) self.gcpWidget3.setScene(self._scene, 3200, 3050, 2) self.gcpWidget4.setScene(self._scene, 3200, 100, 2) self.inputFileNameLabel.setText(self._inputFile.baseName()) drawing = Drawing(self._inputFile) if drawing.isValid(): self.siteEdit.setText(drawing.item().siteCode()) self.typeCombo.setCurrentIndex( self.typeCombo.findData(drawing.item().classCode())) self.numberSpin.setValue(int(drawing.item().itemId()) or 0) self.eastSpin.setValue(drawing.easting() or 0) self.northSpin.setValue(drawing.northing() or 0) self.suffixEdit.setText(drawing.suffix()) self._updateFileNames(drawing) self._updateGeoPoints() pointFile = self.pointFileInfo() if pointFile.exists(): self._loadGcp(pointFile.absoluteFilePath()) self._setStatusLabel('load', ProcessStatus.Success) QCoreApplication.processEvents() return True return False
def addCustomIcon(self): m_dir = os.path.expanduser("~/") customIcon = QFileDialog.getOpenFileName(self, "Select Custom Icon", m_dir, "Image Files (*.png *.jpg *.gif)") if customIcon is "": return else: icon1 = QPixmap(customIcon) if icon1.width() > 128 or icon1.height() > 128: QMessageBox.warning(self, "Large Icon File", "The custom icon is too large.\nPlease select an Icon around the size of 24x24 pixels.") return else: self.flagInfo = customIcon self.ui.flagLabel.setPixmap(icon1) self.flagIcon = icon1
def loadImage(self, inputFile): self._setStatusLabel('load', ProcessStatus.Running) if (not inputFile.exists()): self._showStatus('ERROR: Input file not found! File path was ' + inputFile.absoluteFilePath()) self._setStatusLabel('load', ProcessStatus.Failure) return False self._inputFile = inputFile pixmap = QPixmap(self._inputFile.absoluteFilePath()) if pixmap.isNull(): self._signalError('Loading of raw image failed.') return pixmap = QPixmap(self._inputFile.absoluteFilePath()) w = pixmap.width() h = pixmap.height() self._scene.addPixmap(pixmap) self._scene.setSceneRect(QRectF(0, 0, w, h)) self.planView.setSceneView(self._scene, QRectF(0, 0, w, h)) self.headerView.setSceneView(self._scene, QRectF(0, 0, w, 200)) self.footerView.setSceneView(self._scene, QRectF(100, h - 600, w - 200, 500)) self.gcpWidget1.setScene(self._scene, 250, 100, 2) self.gcpWidget2.setScene(self._scene, 250, 3050, 2) self.gcpWidget3.setScene(self._scene, 3200, 3050, 2) self.gcpWidget4.setScene(self._scene, 3200, 100, 2) self.inputFileNameLabel.setText(self._inputFile.baseName()) drawing = Drawing(self._inputFile) if drawing.isValid(): self.siteEdit.setText(drawing.item().siteCode()) self.typeCombo.setCurrentIndex(self.typeCombo.findData(drawing.item().classCode())) self.numberSpin.setValue(int(drawing.item().itemId()) or 0) self.eastSpin.setValue(drawing.easting() or 0) self.northSpin.setValue(drawing.northing() or 0) self.suffixEdit.setText(drawing.suffix()) self._updateFileNames(drawing) self._updateGeoPoints() pointFile = self.pointFileInfo() if pointFile.exists(): self._loadGcp(pointFile.absoluteFilePath()) self._setStatusLabel('load', ProcessStatus.Success) QCoreApplication.processEvents() return True return False
def draw_image(self): data = urllib.request.urlopen(self.url).read() image = QtGui.QImage() image.loadFromData(data) app = QApplication(sys.argv) w = QWidget() w.setWindowTitle('Pokemon') label = QLabel(w) pixmap = QPixmap(image) label.setPixmap(pixmap) w.resize(pixmap.width(), pixmap.height()) w.show() app.exec_()
class PictureWidget(QGraphicsWidget): loaded = False filename = '' def __init__(self, filename=""): super(PictureWidget, self).__init__() self.filename = filename self.pxm = QPixmap(self.filename) def boundingRect(self): w, h = self.pxm.width(), self.pxm.height() L.debug("boundingrect: %r %r" % (w, h)) return QRectF(0, 0, w, h) def paint(self, painter, option, widget): painter.drawPixmap(0, 0, self.pxm)
def paintEvent(self, e): if self.dirty: iconSize = self.style().pixelMetric(QStyle.PM_SmallIconSize) pix = QPixmap(iconSize, iconSize) pix.fill(self.palette().button().color()) p = QPainter(pix) w = pix.width() h = pix.height() p.setPen(QPen(Qt.gray)) p.setBrush(self.col) p.drawRect(2, 2, w - 5, h - 5) self.setIcon(QIcon(pix)) self.dirty = False p.end() QPushButton.paintEvent(self, e)
def __init__(self,parent,nfile): QDialog.__init__(self,parent) tab = QLabel() pal = QPalette(self.palette()) bgcolor = QColor("#ffffff") pal.setColor(QPalette.Background,bgcolor) tab.setPalette(pal) if nfile == "": return pix = QPixmap(nfile) tab.setPixmap(pix) scrollArea = QScrollArea() scrollArea.setWidget(tab) mainLayout = QVBoxLayout() mainLayout.addWidget(scrollArea) self.setLayout(mainLayout) self.resize(pix.width()+25, pix.height()+25)
def _renderPixmaps(self): self._pixmaps=[] for i in range(self._steps+1): angle = int(i * 360.0 / self._steps) pixmap = QPixmap(self._resource) # if problem with loading png if pixmap.size().width()==0: self._pixmaps=None return rotate_matrix = QMatrix() rotate_matrix.rotate(angle) pixmap_rotated = pixmap.transformed(rotate_matrix) pixmap_moved = QPixmap(pixmap.size()) pixmap_moved.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap_moved) painter.drawPixmap((pixmap_moved.width() - pixmap_rotated.width()) / 2.0, (pixmap_moved.height() - pixmap_rotated.height()) / 2.0, pixmap_rotated) painter.end() self._pixmaps+=[pixmap_moved.scaled(self._width, self._height)]
def show(): """ Simple function to show how to load an image from a resource file and add it to a widget. @return: """ # Create window app = QApplication(sys.argv) w = QWidget() w.setWindowTitle("PyQT4") # Create widget label = QLabel(w) image = resource_filename(Requirement.parse("setuptools_resource_example_pkg"), "mypkg/resources/alba-logo.png") pixmap = QPixmap(image) label.setPixmap(pixmap) w.resize(pixmap.width(), pixmap.height()) # Draw window w.show() sys.exit(app.exec_())
def show(): """ Simple function to show how to load an image from a resource file and add it to a widget. @return: """ # Create window app = QApplication(sys.argv) w = QWidget() w.setWindowTitle("PyQT4") # Create widget label = QLabel(w) image = ':/alba-logo.png' pixmap = QPixmap(image) label.setPixmap(pixmap) w.resize(pixmap.width(), pixmap.height()) # Draw window w.show() sys.exit(app.exec_())
def crop_pixmaps(path, mask, pretend=False): """ crop all pixmaps in a dir according to a masks. This function does nothing in regards to validating modules. If the pixmaps exist and an entry exists in masks, the pixmaps get chopped. """ from PyQt4.QtGui import QPixmap for fname in os.listdir(path): if extension(fname) == 'png': fpath = os.path.join(path, fname) pixmap = QPixmap(fpath) x, y, w, h = mask[0], mask[1], mask[2], mask[3] if pixmap.isNull() is False and \ pixmap.width() > w and \ pixmap.height() > h: pixmap = pixmap.copy(x, y, w, h) if pretend: print 'PRETEND:', else: pixmap.save(fpath, 'PNG') print 'wrote %s x=%i y=%i w=%i h=%i' % (fpath, x, y, w, h)
def _runCropStep(self): if self._debug: debug('Crop') self._step = Georeferencer.Crop self._args = [] self._command = '' pixmap = QPixmap(self._rawFile.absoluteFilePath()) if pixmap.isNull(): self._signalError('Loading of raw image failed.') return pixmap = pixmap.copy(0, 0, pixmap.width(), int(pixmap.height() * 0.84)) image = pixmap.toImage() if image.isNull(): self._signalError('Cropping of raw image failed.') return if not image.save(self._cropFile.absoluteFilePath(), 'PNG', 100): self._signalError('Saving of cropped image failed.') return self._signalStatus() self._runTranslateStep()
def getImageInformationsHeader(path, graphicsItem): """ This definition returns a :class:`sibl_gui.libraries.freeImage.freeImage.ImageInformationsHeader` class from given path and graphics item. :param path: Image path. ( String ) :param graphicsItem: Image graphics item. ( QImage, QPixmap, QIcon ) :return: Image informations header. ( ImageInformationsHeader ) """ if not foundations.common.pathExists(path): raise foundations.exceptions.FileExistsError("{0} | '{1}' file doesn't exists!".format(__name__, path)) if type(graphicsItem) is QIcon: graphicsItem = QPixmap(path) return ImageInformationsHeader(path=path, width=graphicsItem.width(), height=graphicsItem.height(), bpp=graphicsItem.depth(), osStats=os.stat(path))
def openImage(self ): """ Öffnet einen Dialog zum Laden eines Charakterbildes und speichert selbiges im Charakter-Speicher. \note Das Bild wird auf eine in der Configurationsdatei festgelegte Maximalgröße skaliert, um die Größe überschaubar zu halten. """ appPath = PathTools.program_path() # Pfad zum Speicherverzeichnis savePath = "" if os.name == "nt": savePath = os.environ['HOMEPATH'] else: savePath = os.environ['HOME'] # Wenn Unterverzeichnis nicht existiert, suche im Programmverzeichnis. if ( not os.path.exists( savePath ) ): savePath = appPath fileData = QFileDialog.getOpenFileName( self, self.tr( "Select Image File" ), savePath, self.tr( "Images (*.jpg *.jpeg *.png *.bmp *.gif *.pgm *.pbm *.ppm *.svg )" ) ) # Sollte PySide verwendet werden! #filePath = fileData[0] # Sollte PyQt4 verwendet werden! filePath = fileData if ( filePath ): image = QPixmap(filePath) if image.width() > Config.CHARACTER_PIC_WIDTH_MAX or image.height() > Config.CHARACTER_PIC_HEIGHT_MAX: image = image.scaled(800, 800, Qt.KeepAspectRatio) self.updatePicture(image) self.__character.picture = image
def rate_Button_clicked(self, starNumber): if self.current_img == None: print("[INFO] No image to rate.") return # Before this btn is clicked, the user has already chosen the score on the slider # Therefore we can remove the current img from the unscored list print("[INFO] Removing {} from imgs_unscored".format(self.current_img)) self.imgs_unscored.remove(self.current_img) # Add the scored image to imgs_scored imgScored = {'imgPath': self.current_img['imgPath'], 'imgScore': starNumber } self.imgs_scored.append(imgScored) # Compute hash for the image to prevent duplicates # If the user has already rated this image, the new score overwrites the old one dhasher = DHash() difference_hash = dhasher.encode_image(image_file = self.current_img['imgPath']) f_vec = self.model.getFeatureVector(self.current_img['imgPath']) self.feedback[difference_hash] = (starNumber, f_vec) # print("[INFO] List of scored images:") # print(json.dumps(self.imgs_scored, indent=2)) # Move on to next pic self.current_img = self.get_next_image(self.imgs_unscored) if self.current_img == None: print("[INFO] No image to rate.") # TODO: Produce dialog informing user end of list acheived else: pixmap = QPixmap(self.current_img['imgPath']) self.train_imageLabel.setPixmap(pixmap) self.train_imageLabel.setGeometry(QtCore.QRect((self.width()/2) - (pixmap.width()/2), (self.height()/2) - (pixmap.height()/2), pixmap.width(), pixmap.height())) print("[INFO] RATE btn clicked. Next image should be visible.")
def openImage(self): """ Öffnet einen Dialog zum Laden eines Charakterbildes und speichert selbiges im Charakter-Speicher. \note Das Bild wird auf eine in der Configurationsdatei festgelegte Maximalgröße skaliert, um die Größe überschaubar zu halten. """ appPath = PathTools.program_path() # Pfad zum Speicherverzeichnis savePath = "" if os.name == "nt": savePath = os.environ['HOMEPATH'] else: savePath = os.environ['HOME'] # Wenn Unterverzeichnis nicht existiert, suche im Programmverzeichnis. if (not os.path.exists(savePath)): savePath = appPath fileData = QFileDialog.getOpenFileName( self, self.tr("Select Image File"), savePath, self. tr("Images (*.jpg *.jpeg *.png *.bmp *.gif *.pgm *.pbm *.ppm *.svg )" )) # Sollte PySide verwendet werden! #filePath = fileData[0] # Sollte PyQt4 verwendet werden! filePath = fileData if (filePath): image = QPixmap(filePath) if image.width() > Config.CHARACTER_PIC_WIDTH_MAX or image.height( ) > Config.CHARACTER_PIC_HEIGHT_MAX: image = image.scaled(800, 800, Qt.KeepAspectRatio) self.updatePicture(image) self.__character.picture = image
class Human(Entity): BRAVE = "brave" COWARD = "coward" CARELESS = "careless" CAUTIOUS = "cautious" RATIONAL = "rational" STUPID = "stupid" WEAPON_LONG = "long" WEAPON_SHORT = "short" NO_WEAPON = "noweapon" def __init__(self, personality, weapon, cord_x=0, cord_y=0, parent=None): super().__init__("human_{}_{}.png".format(personality, weapon), parent=parent) self.personality = personality self.weapon = weapon self.cord_x = cord_x self.cord_y = cord_y self.setFixedSize(73 * _SCALE, 73 * _SCALE) def change_weapon(self, weapon): self.weapon = weapon self._base_image = "human_{}_{}.png".format(self.personality, self.weapon) self.updatePixmap() def updatePixmap(self): path = _PATH + os.sep + "assets" + os.sep + self._base_image self.__pixmap = QPixmap(path) self.__pixmap = self.__pixmap.scaled(self.__pixmap.width() * _SCALE, self.__pixmap.height() * _SCALE) self.__pixmap = self.__pixmap.transformed(QTransform().rotate( self.angle)) self._base_label.setPixmap(self.__pixmap)
class SidebarWidget(QWidget): def __init__(self, editor): QWidget.__init__(self, editor) self.edit = editor self.highest_line = 0 self.foldArea = 15 self.rightArrowIcon = QPixmap() self.downArrowIcon = QPixmap() self.pat = re.compile('(\s)*def |(\s)*class |(\s)*#begin-fold:') self.patNotPython = re.compile('(\s)*#begin-fold:|(.)*{') self._foldedBlocks = [] self._breakpoints = [] self._bookmarks = [] self._pep8Lines = [] self._errorsLines = [] def update_area(self): maxLine = math.ceil(math.log10(self.edit.blockCount())) width = QFontMetrics( self.edit.document().defaultFont()).width('0' * int(maxLine)) \ + 10 + self.foldArea if self.width() != width: self.setFixedWidth(width) self.edit.setViewportMargins(width, 0, 0, 0) self.update() def update(self, *args): QWidget.update(self, *args) def pep8_check_lines(self, lines): self._pep8Lines = lines def static_errors_lines(self, lines): self._errorsLines = lines def code_folding_event(self, lineNumber): if self._is_folded(lineNumber): self._fold(lineNumber) else: self._unfold(lineNumber) self.edit.update() self.update() def _fold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() while block.isValid() and block != endBlock: block.setVisible(False) block.setLineCount(0) block = block.next() self._foldedBlocks.append(startBlock.blockNumber()) self.edit.document().markContentsDirty(startBlock.position(), endPos) def _unfold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() while block.isValid() and block != endBlock: block.setVisible(True) block.setLineCount(block.layout().lineCount()) endPos = block.position() + block.length() if block.blockNumber() in self._foldedBlocks: close = self._find_fold_closing(block) block = self.edit.document().findBlockByNumber(close) else: block = block.next() self._foldedBlocks.remove(startBlock.blockNumber()) self.edit.document().markContentsDirty(startBlock.position(), endPos) def _is_folded(self, line): block = self.edit.document().findBlockByNumber(line) if not block.isValid(): return False return block.isVisible() def _find_fold_closing(self, block): text = block.text() pat = re.compile('(\s)*#begin-fold:') patBrace = re.compile('(.)*{$') if pat.match(text): return self._find_fold_closing_label(block) elif patBrace.match(text): return self._find_fold_closing_brace(block) spaces = helpers.get_leading_spaces(text) pat = re.compile('^\s*$|^\s*#') block = block.next() while block.isValid(): text2 = block.text() if not pat.match(text2): spacesEnd = helpers.get_leading_spaces(text2) if len(spacesEnd) <= len(spaces): if pat.match(block.previous().text()): return block.previous().blockNumber() else: return block.blockNumber() block = block.next() return block.previous().blockNumber() def _find_fold_closing_label(self, block): text = block.text() label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end-fold:' + label) while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_brace(self, block): block = block.next() while block.isValid(): openBrace = block.text().count('{') closeBrace = block.text().count('}') - openBrace if closeBrace > 0: return block.blockNumber() + 1 block = block.next() return block.blockNumber() def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get('sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get('sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) pep8color = resources.CUSTOM_SCHEME.get('pep8-underline', resources.COLOR_SCHEME['pep8-underline']) errorcolor = resources.CUSTOM_SCHEME.get('error-underline', resources.COLOR_SCHEME['error-underline']) painter.fillRect(self.rect(), QColor(background)) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines error = False if settings.CHECK_STYLE and \ ((line_count - 1) in self._pep8Lines): painter.setPen(QColor(pep8color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.FIND_ERRORS and \ ((line_count - 1) in self._errorsLines): painter.setPen(QColor(errorcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True else: painter.setPen(QColor(foreground)) # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText(self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect(xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get('fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if pattern.match(block.text()) and block.isVisible(): if block.blockNumber() in self._foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint elif block.blockNumber() in self._breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self._bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect( xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() painter.end() QWidget.paintEvent(self, event) def mousePressEvent(self, event): if self.foldArea > 0: xofs = self.width() - self.foldArea font_metrics = QFontMetrics(self.edit.document().defaultFont()) fh = font_metrics.lineSpacing() ys = event.posF().y() lineNumber = 0 if event.pos().x() > xofs: pattern = self.pat if self.edit.lang != "python": pattern = self.patNotPython block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() page_bottom = self.edit.viewport().height() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset if position.y() > page_bottom: break if position.y() < ys and (position.y() + fh) > ys and \ pattern.match(str(block.text())): lineNumber = block.blockNumber() + 1 break elif position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.LeftButton: line = block.blockNumber() if line in self._breakpoints: self._breakpoints.remove(line) else: self._breakpoints.append(line) self.update() break elif position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.RightButton: line = block.blockNumber() if line in self._bookmarks: self._bookmarks.remove(line) else: self._bookmarks.append(line) self.update() break block = block.next() self._save_breakpoints_bookmarks() if lineNumber > 0: self.code_folding_event(lineNumber) def _save_breakpoints_bookmarks(self): if self._bookmarks and self.edit.ID != "": settings.BOOKMARKS[self.edit.ID] = self._bookmarks elif self.edit.ID in settings.BOOKMARKS: settings.BOOKMARKS.pop(self.edit.ID) if self._breakpoints and self.edit.ID != "": settings.BREAKPOINTS[self.edit.ID] = self._breakpoints elif self.edit.ID in settings.BREAKPOINTS: settings.BREAKPOINTS.pop(self.edit.ID) def set_breakpoint(self, lineno): if lineno in self._breakpoints: self._breakpoints.remove(lineno) else: self._breakpoints.append(lineno) self.update() self._save_breakpoints_bookmarks() def set_bookmark(self, lineno): if lineno in self._bookmarks: self._bookmarks.remove(lineno) else: self._bookmarks.append(lineno) self.update() self._save_breakpoints_bookmarks()
class SidebarWidget(QWidget): def __init__(self, editor, neditable): QWidget.__init__(self, editor) self.edit = editor self._neditable = neditable self.highest_line = 0 self.foldArea = 15 self.rightArrowIcon = QPixmap() self.downArrowIcon = QPixmap() self.pat = re.compile( r"(\s)*\"\"\"|(\s)*def |(\s)*class |(\s)*if |(\s)*while |" "(\s)*else:|(\s)*elif |(\s)*for |" "(\s)*try:|(\s)*except:|(\s)*except |(\s)*#begin-fold:") self.patNotPython = re.compile('(\s)*#begin-fold:|(.)*{') self.patComment = re.compile(r"(\s)*\"\"\"") self._endDocstringBlocks = [] self.foldedBlocks = [] self.breakpoints = [] self.bookmarks = [] if self._neditable.file_path in settings.BREAKPOINTS: self.breakpoints = settings.BREAKPOINTS[self._neditable.file_path] if self._neditable.file_path in settings.BOOKMARKS: self.bookmarks = settings.BOOKMARKS[self._neditable.file_path] def update_area(self): maxLine = math.ceil(math.log10(self.edit.blockCount())) width = QFontMetrics( self.edit.document().defaultFont()).width('0' * int(maxLine)) \ + 10 + self.foldArea if self.width() != width: self.setFixedWidth(width) self.edit.setViewportMargins(width, 0, 0, 0) self.update() def update(self, *args): QWidget.update(self, *args) def update_sidebar_marks(self, blockNumber, diference): if self.breakpoints: self.breakpoints = helpers.add_line_increment( self.breakpoints, blockNumber, diference) if not self._neditable.new_document: settings.BREAKPOINTS[self._neditable.file_path] = \ self._sidebarWidget._breakpoints if self.bookmarks: self.bookmarks = helpers.add_line_increment( self.bookmarks, blockNumber, diference) if not self._neditable.new_document: settings.BOOKMARKS[self._neditable.file_path] = \ self._sidebarWidget._bookmarks if self._foldedBlocks and self._neditable.file_path: self._foldedBlocks = self._add_line_increment( self._foldedBlocks, blockNumber - 1, diference) def code_folding_event(self, lineNumber): if self._is_folded(lineNumber): self._fold(lineNumber) else: self._unfold(lineNumber) self.edit.update() self.update() def _fold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() while block.isValid() and block != endBlock: block.setVisible(False) block.setLineCount(0) block = block.next() self.foldedBlocks.append(startBlock.blockNumber()) self.edit.document().markContentsDirty(startBlock.position(), endPos) def _unfold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() while block.isValid() and block != endBlock: block.setVisible(True) block.setLineCount(block.layout().lineCount()) endPos = block.position() + block.length() if block.blockNumber() in self.foldedBlocks: close = self._find_fold_closing(block) block = self.edit.document().findBlockByNumber(close) else: block = block.next() self.foldedBlocks.remove(startBlock.blockNumber()) self.edit.document().markContentsDirty(startBlock.position(), endPos) def _is_folded(self, line): block = self.edit.document().findBlockByNumber(line) if not block.isValid(): return False return block.isVisible() def _find_fold_closing(self, block): text = block.text() pat = re.compile('(\s)*#begin-fold:') patBrace = re.compile('(.)*{$') if pat.match(text): return self._find_fold_closing_label(block) elif patBrace.match(text): return self._find_fold_closing_brace(block) elif self.patComment.match(text): return self._find_fold_closing_docstring(block) spaces = helpers.get_leading_spaces(text) pat = re.compile('^\s*$|^\s*#') block = block.next() while block.isValid(): text2 = block.text() if not pat.match(text2): spacesEnd = helpers.get_leading_spaces(text2) if len(spacesEnd) <= len(spaces): if pat.match(block.previous().text()): return block.previous().blockNumber() else: return block.blockNumber() block = block.next() return block.previous().blockNumber() def _find_fold_closing_label(self, block): text = block.text() label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end-fold:' + label) while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_docstring(self, block): block = block.next() while block.isValid(): if block.text().count('"""') > 0: return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_brace(self, block): block = block.next() openBrace = 1 while block.isValid(): openBrace += block.text().count('{') openBrace -= block.text().count('}') if openBrace == 0: return block.blockNumber() + 1 elif openBrace < 0: return block.blockNumber() block = block.next() return block.blockNumber() def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get('sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get('sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) painter.fillRect(self.rect(), QColor(background)) block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines painter.setPen(QColor(foreground)) error = False checkers = sorted(self._neditable.registered_checkers, key=lambda x: x[2], reverse=True) for items in checkers: checker, color, _ = items if (line_count - 1) in checker.checks: painter.setPen(QColor(color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True break # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText(self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect(xofs, 0, self.foldArea, self.height(), QColor(resources.CUSTOM_SCHEME.get('fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush(QColor( resources.CUSTOM_SCHEME.get('fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) self.calculate_docstring_block_fold() block = self.edit.firstVisibleBlock() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break if pattern.match(block.text()) and block.isVisible(): can_fold = True if self.patComment.match(block.text()) and \ (block.blockNumber() in self._endDocstringBlocks): can_fold = False if can_fold: if block.blockNumber() in self.foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint if block.blockNumber() in self.breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self.bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect( xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() painter.end() QWidget.paintEvent(self, event) def calculate_docstring_block_fold(self): self._endDocstringBlocks = [] fold_docstring_open = False block = self.edit.firstVisibleBlock() while block.isValid(): # check if block is a docstring if self.patComment.match(block.text()): fold_docstring_open = not fold_docstring_open #if we are closing the docstring block we add it's line number, #so we can skip it later if not fold_docstring_open: self._endDocstringBlocks.append(block.blockNumber()) block = block.next() def mousePressEvent(self, event): if self.foldArea > 0: xofs = self.width() - self.foldArea font_metrics = QFontMetrics(self.edit.document().defaultFont()) fh = font_metrics.lineSpacing() ys = event.posF().y() lineNumber = 0 if event.pos().x() > xofs: pattern = self.pat if self.edit.lang != "python": pattern = self.patNotPython block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() page_bottom = self.edit.viewport().height() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset if position.y() > page_bottom: break if position.y() < ys and (position.y() + fh) > ys and \ pattern.match(str(block.text())): if not block.blockNumber() in self._endDocstringBlocks: lineNumber = block.blockNumber() + 1 break if position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.LeftButton: line = block.blockNumber() self.set_breakpoint(line) break elif position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.RightButton: line = block.blockNumber() self.set_bookmark(line) break block = block.next() if lineNumber > 0: self.code_folding_event(lineNumber) def _save_breakpoints_bookmarks(self): if self.bookmarks and not self._neditable.new_document: settings.BOOKMARKS[self._neditable.file_path] = self.bookmarks elif self._neditable.file_path in settings.BOOKMARKS: settings.BOOKMARKS.pop(self._neditable.file_path) if self.breakpoints and not self._neditable.new_document: settings.BREAKPOINTS[self._neditable.file_path] = self.breakpoints elif self._neditable.file_path in settings.BREAKPOINTS: settings.BREAKPOINTS.pop(self._neditable.file_path) def set_breakpoint(self, lineno): if lineno in self.breakpoints: self.breakpoints.remove(lineno) else: self.breakpoints.append(lineno) self.update() self._save_breakpoints_bookmarks() def set_bookmark(self, lineno): if lineno in self.bookmarks: self.bookmarks.remove(lineno) else: self.bookmarks.append(lineno) self.update() self._save_breakpoints_bookmarks()
gw = 1 gh = 1 # text offset ch = -22 pixmap = QPixmap(Bl + (bl + (pw + gw) * 5 - gw + br) * 16 + Br, Bt + (bt + (ph + gh) * 8 - gh + bb) * 16 + Bb) painter = QPainter(pixmap) font = QFont('Courier New', 12) font.setBold(True) painter.setPen(Qt.black) painter.setFont(font) painter.fillRect(0, 0, pixmap.width(), pixmap.height(), Qt.white) xb = Bl + bl yb = Bt + bt counter = 0 for line in lines: if not line.startswith('\t'): continue if counter > 31 and counter < 127: text = chr(counter) background = QColor(200, 255, 200) else: text = (u'%02X' % counter) + u'\u2095' background = Qt.white
class Entity(QWidget): def __init__(self, base_image, parent=None): super().__init__(parent) self._base_label = QLabel(self) self._base_image = base_image self._decor_label = QLabel(self) self._decor_pixmap = None self.__pixmap = None """:type: PyQt4.QtGui.QPixmap""" self.__cord_x = 0 self.__cord_y = 0 self.__angle = 0 self.setAlignment(Qt.AlignCenter) self.updatePixmap() if _debugging: self.setStyleSheet("border: 1px solid black") @property def angle(self): return self.__angle @angle.setter def angle(self, angle): self.__angle = angle self.updatePixmap() @property def cord_x(self): return self.__cord_x @cord_x.setter def cord_x(self, cord): self.__cord_x = cord self.move(self.cord_x, self.cord_y) @property def cord_y(self): return self.__cord_y @cord_y.setter def cord_y(self, cord): self.__cord_y = cord self.move(self.cord_x, self.cord_y) def add_decoration(self, path): if path is None: self._decor_label.hide() else: self._decor_label = QLabel(self) self._decor_pixmap = QPixmap(path) self._decor_pixmap = self._decor_pixmap.scaled(self._decor_pixmap.width() * _SCALE, self._decor_pixmap.height() * _SCALE) self._decor_pixmap = self._decor_pixmap.transformed(QTransform().rotate(self.angle)) self._decor_label.setPixmap(self._decor_pixmap) def updatePixmap(self): path = _PATH + os.sep + "assets" + os.sep + self._base_image self.__pixmap = QPixmap(path) self.__pixmap = self.__pixmap.scaled(self.__pixmap.width()*_SCALE, self.__pixmap.height()*_SCALE) self.__pixmap = self.__pixmap.transformed(QTransform().rotate(self.angle)) self._base_label.setPixmap(self.__pixmap) self.setFixedSize(self.__pixmap.width(), self.__pixmap.height()) def setFixedSize(self, x, y): super().setFixedSize(x, y) self._base_label.setFixedSize(x, y) def setAlignment(self, alignment): self._base_label.setAlignment(alignment) self._decor_label.setAlignment(alignment)
def getPixmap(path): pixmap = QPixmap(path) if pixmap.width() > 300 or pixmap.height() > 200: return pixmap.scaled(300, 200) return pixmap
class VCSIndicator: " Holds an indicator properties " def __init__(self, configLine): """ Config line looks as follows: id:::pathOrString:::ForegroundColor:::BackgroundColor:::Tooltip It comes from a config file or from a plugin """ self.identifier = None self.pixmap = None self.text = None self.backgroundColor = None self.foregroundColor = None self.defaultTooltip = "" self.__parseConfigLine(configLine) return def __parseConfigLine(self, configLine): " Fills the members " if type(configLine) == tuple or type(configLine) == list: # Came from a plugin self.__parsePluginProvidedTuple(configLine) else: # Came from a config file self.__parseConfigFileProvidedString(configLine) self.__scalePixmap() return def __setBrokenIndicator(self, msg): " Sets the indicator to the broken state " self.text = BROKEN_INDICATOR self.backgroundColor = QColor(0, 255, 255) self.foregroundColor = QColor(255, 0, 0) self.defaultTooltip = msg return def __parseConfigFileProvidedString(self, configLine): " Parses config file provided values " parts = configLine.split(":::") if len(parts) != 5: raise Exception("Unexpected format of an indicator " "description. Expected 5 values.") # ID field self.identifier = int(parts[0]) # path or text field if os.path.isabs(parts[1]): # That must be a path to the pixmap try: self.pixmap = QPixmap(parts[1]) except: self.__setBrokenIndicator("Failed to load pixmap from " + parts[1]) return else: # Try to find the pixmap in the standard pixmap directory candidate = parts[1].strip() searchPath = os.path.dirname( os.path.abspath( sys.argv[0] ) ) + \ os.path.sep + 'pixmaps' + os.path.sep + candidate if candidate != "" and os.path.exists(searchPath): try: self.pixmap = QPixmap(searchPath) except: self.__setBrokenIndicator("Failed to load pixmap from " + parts[1]) return else: # It is just a text. Cut it to up to 2 letters self.__setText(parts[1]) # Foreground color if parts[2].lower() == "none": self.foregroundColor = None else: self.foregroundColor = buildColor(parts[2]) # Background color if parts[3].lower() == "none": self.backgroundColor = None else: self.backgroundColor = buildColor(parts[3]) # Default tooltip if parts[4].lower() == "none": self.defaultTooltip = "" else: self.defaultTooltip = str(parts[4]).strip() return def __parsePluginProvidedTuple(self, pluginIndicator): " Checks what plugin provided " if len(pluginIndicator) != 5: raise Exception("Unexpected format of an indicator " "description. Expected 5 values.") # ID field self.identifier = int(pluginIndicator[0]) # Pixmap/text field if type(pluginIndicator[1]) == str: self.__setText(pluginIndicator[1]) else: try: self.pixmap = QPixmap(pluginIndicator[1]) except: self.__setBrokenIndicator("Failed to get plugin indicator " "pixmap. Indicator id: " + str(self.identifier)) return # Foreground color if pluginIndicator[2] is None: self.foregroundColor = None else: if type(pluginIndicator[2]) == str: self.foregroundColor = buildColor(pluginIndicator[2]) else: self.foregroundColor = QColor(pluginIndicator[2]) # Background color if pluginIndicator[3] is None: self.backgroundColor = None else: if type(pluginIndicator[3]) == str: self.backgroundColor = buildColor(pluginIndicator[3]) else: self.backgroundColor = QColor(pluginIndicator[3]) # Default tooltip if pluginIndicator[4] is None: self.defaultTooltip = "" else: self.defaultTooltip = str(pluginIndicator[4]).strip() return def __setText(self, value): " Sets the indicator text " if len(value) > MAX_TEXT_INDICATOR_LENGTH: self.text = value[:MAX_TEXT_INDICATOR_LENGTH] else: self.text = value self.text = self.text.strip() return def __scalePixmap(self): " Scales the pixmap if necessary " if self.pixmap is None: return if self.pixmap.width() > MAX_PIXMAP_INDICATOR_WIDTH or \ self.pixmap.height() > MAX_PIXMAP_INDICATOR_HEIGHT: maxSize = QSize(MAX_PIXMAP_INDICATOR_WIDTH, MAX_PIXMAP_INDICATOR_HEIGHT) self.pixmap = self.pixmap.scaled(maxSize, Qt.KeepAspectRatio) return def isPixmap(self): " True if it is a pixmap label " return self.pixmap is not None def draw(self, label): " Draws the indicator as members tell. label is QLabel " label.setPalette(QLabel().palette()) if self.isPixmap(): label.setAutoFillBackground(False) label.setFrameStyle(QLabel().frameStyle()) label.setPixmap(self.pixmap) else: label.setFrameStyle(QFrame.StyledPanel) label.setAutoFillBackground(True) palette = label.palette() if self.backgroundColor is not None: palette.setColor(QPalette.Background, self.backgroundColor) if self.foregroundColor is not None: palette.setColor(QPalette.Foreground, self.foregroundColor) label.setPalette(palette) label.setText(self.text) return
class Radar(QtGui.QLabel): def __init__(self, parent, radar, rect, myname): global xscale, yscale self.myname = myname self.rect = rect self.satellite = Config.satellite try: if radar["satellite"]: self.satellite = 1 except KeyError: pass self.baseurl = self.mapurl(radar, rect, False) print "google map base url: " + self.baseurl self.mkurl = self.mapurl(radar, rect, True) self.wxurl = self.radarurl(radar, rect) print "radar url: " + self.wxurl QtGui.QLabel.__init__(self, parent) self.interval = Config.radar_refresh * 60 self.lastwx = 0 self.retries = 0 self.setObjectName("radar") self.setGeometry(rect) self.setStyleSheet("#radar { background-color: grey; }") self.setAlignment(Qt.AlignCenter) self.wwx = QtGui.QLabel(self) self.wwx.setObjectName("wx") self.wwx.setStyleSheet("#wx { background-color: transparent; }") self.wwx.setGeometry(0, 0, rect.width(), rect.height()) self.wmk = QtGui.QLabel(self) self.wmk.setObjectName("mk") self.wmk.setStyleSheet("#mk { background-color: transparent; }") self.wmk.setGeometry(0, 0, rect.width(), rect.height()) self.wxmovie = QMovie() def mapurl(self, radar, rect, markersonly): # 'https://maps.googleapis.com/maps/api/staticmap?maptype=hybrid¢er='+rcenter.lat+','+rcenter.lng+'&zoom='+rzoom+'&size=300x275'+markersr; urlp = [] if len(ApiKeys.googleapi) > 0: urlp.append('key=' + ApiKeys.googleapi) urlp.append('center=' + str(radar['center'].lat) + ',' + str(radar['center'].lng)) zoom = radar['zoom'] rsize = rect.size() if rsize.width() > 640 or rsize.height() > 640: rsize = QtCore.QSize(rsize.width() / 2, rsize.height() / 2) zoom -= 1 urlp.append('zoom=' + str(zoom)) urlp.append('size=' + str(rsize.width()) + 'x' + str(rsize.height())) if markersonly: urlp.append('style=visibility:off') else: urlp.append('maptype=hybrid') for marker in radar['markers']: marks = [] for opts in marker: if opts != 'location': marks.append(opts + ':' + marker[opts]) marks.append( str(marker['location'].lat) + ',' + str(marker['location'].lng)) urlp.append('markers=' + '|'.join(marks)) return 'http://maps.googleapis.com/maps/api/staticmap?' + \ '&'.join(urlp) def radarurl(self, radar, rect): # wuprefix = 'http://api.wunderground.com/api/'; # wuprefix+wuapi+'/animatedradar/image.gif?maxlat='+rNE.lat+'&maxlon='+ # rNE.lng+'&minlat='+rSW.lat+'&minlon='+rSW.lng+wuoptionsr; # wuoptionsr = '&width=300&height=275&newmaps=0&reproj.automerc=1&num=5 # &delay=25&timelabel=1&timelabel.y=10&rainsnow=1&smooth=1'; rr = getCorners(radar['center'], radar['zoom'], rect.width(), rect.height()) if self.satellite: return (Config.wuprefix + ApiKeys.wuapi + '/animatedsatellite/lang:' + Config.wuLanguage + '/image.gif' + '?maxlat=' + str(rr['N']) + '&maxlon=' + str(rr['E']) + '&minlat=' + str(rr['S']) + '&minlon=' + str(rr['W']) + '&width=' + str(rect.width()) + '&height=' + str(rect.height()) + '&newmaps=0&reproj.automerc=1&num=5&delay=25' + '&timelabel=1&timelabel.y=10&smooth=1&key=sat_ir4_bottom') else: return (Config.wuprefix + ApiKeys.wuapi + '/animatedradar/lang:' + Config.wuLanguage + '/image.gif' + '?maxlat=' + str(rr['N']) + '&maxlon=' + str(rr['E']) + '&minlat=' + str(rr['S']) + '&minlon=' + str(rr['W']) + '&width=' + str(rect.width()) + '&height=' + str(rect.height()) + '&newmaps=0&reproj.automerc=1&num=5&delay=25' + '&timelabel=1&timelabel.y=10&rainsnow=1&smooth=1' + '&radar_bitmap=1&xnoclutter=1&xnoclutter_mask=1&cors=1') def basefinished(self): if self.basereply.error() != QNetworkReply.NoError: return self.basepixmap = QPixmap() self.basepixmap.loadFromData(self.basereply.readAll()) if self.basepixmap.size() != self.rect.size(): self.basepixmap = self.basepixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) if self.satellite: p = QPixmap(self.basepixmap.size()) p.fill(Qt.transparent) painter = QPainter() painter.begin(p) painter.setOpacity(0.6) painter.drawPixmap(0, 0, self.basepixmap) painter.end() self.basepixmap = p self.wwx.setPixmap(self.basepixmap) else: self.setPixmap(self.basepixmap) def mkfinished(self): if self.mkreply.error() != QNetworkReply.NoError: return self.mkpixmap = QPixmap() self.mkpixmap.loadFromData(self.mkreply.readAll()) if self.mkpixmap.size() != self.rect.size(): self.mkpixmap = self.mkpixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) br = QBrush(QColor(Config.dimcolor)) painter = QPainter() painter.begin(self.mkpixmap) painter.fillRect(0, 0, self.mkpixmap.width(), self.mkpixmap.height(), br) painter.end() self.wmk.setPixmap(self.mkpixmap) def wxfinished(self): if self.wxreply.error() != QNetworkReply.NoError: print "get radar error " + self.myname + ":" + \ str(self.wxreply.error()) self.lastwx = 0 return print "radar map received:" + self.myname + ":" + time.ctime() self.wxmovie.stop() self.wxdata = QtCore.QByteArray(self.wxreply.readAll()) self.wxbuff = QtCore.QBuffer(self.wxdata) self.wxbuff.open(QtCore.QIODevice.ReadOnly) mov = QMovie(self.wxbuff, 'GIF') print "radar map frame count:" + self.myname + ":" + \ str(mov.frameCount()) + ":r" + str(self.retries) if mov.frameCount() > 2: self.lastwx = time.time() self.retries = 0 else: # radar image retreval failed if self.retries > 3: # give up, last successful animation stays. # the next normal radar_refresh time (default 10min) will apply self.lastwx = time.time() return self.lastwx = 0 # count retries self.retries = self.retries + 1 # retry in 5 seconds QtCore.QTimer.singleShot(5 * 1000, self.getwx) return self.wxmovie = mov if self.satellite: self.setMovie(self.wxmovie) else: self.wwx.setMovie(self.wxmovie) if self.parent().isVisible(): self.wxmovie.start() def getwx(self): global lastapiget i = 0.1 # making sure there is at least 2 seconds between radar api calls lastapiget += 2 if time.time() > lastapiget: lastapiget = time.time() else: i = lastapiget - time.time() print "get radar api call spacing oneshot get i=" + str(i) QtCore.QTimer.singleShot(i * 1000, self.getwx2) def getwx2(self): global manager try: if self.wxreply.isRunning(): return except Exception: pass print "getting radar map " + self.myname + ":" + time.ctime() self.wxreq = QNetworkRequest( QUrl(self.wxurl + '&rrrand=' + str(time.time()))) self.wxreply = manager.get(self.wxreq) QtCore.QObject.connect(self.wxreply, QtCore.SIGNAL("finished()"), self.wxfinished) def getbase(self): global manager self.basereq = QNetworkRequest(QUrl(self.baseurl)) self.basereply = manager.get(self.basereq) QtCore.QObject.connect(self.basereply, QtCore.SIGNAL("finished()"), self.basefinished) def getmk(self): global manager self.mkreq = QNetworkRequest(QUrl(self.mkurl)) self.mkreply = manager.get(self.mkreq) QtCore.QObject.connect(self.mkreply, QtCore.SIGNAL("finished()"), self.mkfinished) def start(self, interval=0): if interval > 0: self.interval = interval self.getbase() self.getmk() self.timer = QtCore.QTimer() QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.getwx) def wxstart(self): print "wxstart for " + self.myname if (self.lastwx == 0 or (self.lastwx + self.interval) < time.time()): self.getwx() # random 1 to 10 seconds added to refresh interval to spread the # queries over time i = (self.interval + random.uniform(1, 10)) * 1000 self.timer.start(i) self.wxmovie.start() QtCore.QTimer.singleShot(1000, self.wxmovie.start) def wxstop(self): print "wxstop for " + self.myname self.timer.stop() self.wxmovie.stop() def stop(self): try: self.timer.stop() self.timer = None if self.wxmovie: self.wxmovie.stop() except Exception: pass
class OWParallelGraph(OWPlot, ScaleData): show_distributions = Setting(False) show_attr_values = Setting(True) show_statistics = Setting(default=False) group_lines = Setting(default=False) number_of_groups = Setting(default=5) number_of_steps = Setting(default=30) use_splines = Setting(False) alpha_value = Setting(150) alpha_value_2 = Setting(150) def __init__(self, widget, parent=None, name=None): OWPlot.__init__(self, parent, name, axes=[], widget=widget) ScaleData.__init__(self) self.update_antialiasing(False) self.widget = widget self.last_selected_curve = None self.enableGridXB(0) self.enableGridYL(0) self.domain_contingencies = None self.auto_update_axes = 1 self.old_legend_keys = [] self.selection_conditions = {} self.attributes = [] self.visualized_mid_labels = [] self.attribute_indices = [] self.valid_data = [] self.groups = {} self.colors = None self.selected_examples = [] self.unselected_examples = [] self.bottom_pixmap = QPixmap( gui.resource_filename("icons/upgreenarrow.png")) self.top_pixmap = QPixmap( gui.resource_filename("icons/downgreenarrow.png")) def set_data(self, data, subset_data=None, **args): self.start_progress() self.set_progress(1, 100) self.data = data self.have_data = True self.domain_contingencies = None self.groups = {} OWPlot.setData(self, data) ScaleData.set_data(self, data, no_data=True, **args) self.end_progress() def update_data(self, attributes, mid_labels=None): old_selection_conditions = self.selection_conditions self.clear() if not (self.have_data): return if len(attributes) < 2: return if self.show_statistics: self.alpha_value = TRANSPARENT self.alpha_value_2 = VISIBLE else: self.alpha_value = VISIBLE self.alpha_value_2 = TRANSPARENT self.attributes = attributes self.attribute_indices = [ self.data_domain.index(name) for name in self.attributes ] self.valid_data = self.get_valid_list(self.attribute_indices) self.visualized_mid_labels = mid_labels self.add_relevant_selections(old_selection_conditions) class_var = self.data_domain.class_var if not class_var: self.colors = None elif class_var.is_discrete: self.colors = class_var.colors elif class_var.is_continuous: self.colors = ContinuousPaletteGenerator(*class_var.colors) if self.group_lines: self.show_statistics = False self.draw_groups() else: self.show_statistics = False self.draw_curves() self.draw_distributions() self.draw_axes() self.draw_statistics() self.draw_mid_labels(mid_labels) self.draw_legend() self.replot() def add_relevant_selections(self, old_selection_conditions): """Keep only conditions related to the currently visualized attributes""" for name, value in old_selection_conditions.items(): if name in self.attributes: self.selection_conditions[name] = value def draw_axes(self): self.remove_all_axes() for i in range(len(self.attributes)): axis_id = UserAxis + i a = self.add_axis(axis_id, line=QLineF(i, 0, i, 1), arrows=AxisStart | AxisEnd, zoomable=True) a.always_horizontal_text = True a.max_text_width = 100 a.title_margin = -10 a.text_margin = 0 a.setZValue(5) self.set_axis_title(axis_id, self.data_domain[self.attributes[i]].name) self.set_show_axis_title(axis_id, self.show_attr_values) if self.show_attr_values: attr = self.data_domain[self.attributes[i]] if attr.is_continuous: self.set_axis_scale(axis_id, self.attr_values[attr.name][0], self.attr_values[attr.name][1]) elif attr.is_discrete: attribute_values = get_variable_values_sorted( self.data_domain[self.attributes[i]]) attr_len = len(attribute_values) values = [ float(1.0 + 2.0 * j) / float(2 * attr_len) for j in range(len(attribute_values)) ] a.set_bounds((0, 1)) self.set_axis_labels(axis_id, labels=attribute_values, values=values) def draw_curves(self): conditions = { name: self.attributes.index(name) for name in self.selection_conditions.keys() } def is_selected(example): return all(self.selection_conditions[name][0] <= example[index] <= self.selection_conditions[name][1] for (name, index) in list(conditions.items())) selected_curves = defaultdict(list) background_curves = defaultdict(list) diff, mins = [], [] for i in self.attribute_indices: var = self.data_domain[i] if var.is_discrete: diff.append(len(var.values)) mins.append(-0.5) else: diff.append( self.domain_data_stat[i].max - self.domain_data_stat[i].min or 1) mins.append(self.domain_data_stat[i].min) def scale_row(row): return [(x - m) / d for x, m, d in zip(row, mins, diff)] for row_idx, row in enumerate(self.data[:, self.attribute_indices]): if any(np.isnan(v) for v in row.x): continue color = tuple(self.select_color(row_idx)) if is_selected(row): color += (self.alpha_value, ) selected_curves[color].extend(scale_row(row)) self.selected_examples.append(row_idx) else: color += (self.alpha_value_2, ) background_curves[color].extend(row) self.unselected_examples.append(row_idx) self._draw_curves(selected_curves) self._draw_curves(background_curves) def select_color(self, row_index): if self.data_has_class: if self.data_has_continuous_class: return self.continuous_palette.getRGB( self.data[row_index, self.data_class_index]) else: return self.colors[int(self.data[row_index, self.data_class_index])] else: return 0, 0, 0 def _draw_curves(self, selected_curves): n_attr = len(self.attributes) for color, y_values in sorted(selected_curves.items()): n_rows = int(len(y_values) / n_attr) x_values = list(range(n_attr)) * n_rows curve = OWCurve() curve.set_style(OWCurve.Lines) curve.set_color(QColor(*color)) curve.set_segment_length(n_attr) curve.set_data(x_values, y_values) curve.attach(self) def draw_groups(self): phis, mus, sigmas = self.compute_groups() diff, mins = [], [] for i in self.attribute_indices: var = self.data_domain[i] if var.is_discrete: diff.append(len(var.values)) mins.append(-0.5) else: diff.append( self.domain_data_stat[i].max - self.domain_data_stat[i].min or 1) mins.append(self.domain_data_stat[i].min) for j, (phi, cluster_mus, cluster_sigma) in enumerate(zip(phis, mus, sigmas)): for i, (mu1, sigma1, mu2, sigma2), in enumerate( zip(cluster_mus, cluster_sigma, cluster_mus[1:], cluster_sigma[1:])): nmu1 = (mu1 - mins[i]) / diff[i] nmu2 = (mu2 - mins[i + 1]) / diff[i + 1] nsigma1 = math.sqrt(sigma1) / diff[i] nsigma2 = math.sqrt(sigma2) / diff[i + 1] polygon = ParallelCoordinatePolygon( i, nmu1, nmu2, nsigma1, nsigma2, phi, tuple(self.colors[j]) if self.colors else (0, 0, 0)) polygon.attach(self) self.replot() def compute_groups(self): key = (tuple(self.attributes), self.number_of_groups, self.number_of_steps) if key not in self.groups: def callback(i, n): self.set_progress(i, 2 * n) conts = create_contingencies(self.data[:, self.attribute_indices], callback=callback) self.set_progress(50, 100) w, mu, sigma, phi = lac(conts, self.number_of_groups, self.number_of_steps) self.set_progress(100, 100) self.groups[key] = list(map(np.nan_to_num, (phi, mu, sigma))) return self.groups[key] def draw_legend(self): if self.data_has_class: if self.data_domain.has_discrete_class: self.legend().clear() values = get_variable_values_sorted(self.data_domain.class_var) for i, value in enumerate(values): self.legend().add_item( self.data_domain.class_var.name, value, OWPoint(OWPoint.Rect, QColor(*self.colors[i]), 10)) else: values = self.attr_values[self.data_domain.class_var.name] decimals = self.data_domain.class_var.number_of_decimals self.legend().add_color_gradient( self.data_domain.class_var.name, ["%%.%df" % decimals % v for v in values]) else: self.legend().clear() self.old_legend_keys = [] def draw_mid_labels(self, mid_labels): if mid_labels: for j in range(len(mid_labels)): self.addMarker(mid_labels[j], j + 0.5, 1.0, alignment=Qt.AlignCenter | Qt.AlignTop) def draw_statistics(self): """Draw lines that represent standard deviation or quartiles""" return # TODO: Implement using BasicStats if self.show_statistics and self.have_data: data = [] for attr_idx in self.attribute_indices: if not self.data_domain[attr_idx].is_continuous: data.append([()]) continue # only for continuous attributes if not self.data_has_class or self.data_has_continuous_class: # no class if self.show_statistics == MEANS: m = self.domain_data_stat[attr_idx].mean dev = self.domain_data_stat[attr_idx].var data.append([(m - dev, m, m + dev)]) elif self.show_statistics == MEDIAN: data.append([(0, 0, 0)]) continue sorted_array = np.sort(attr_values) if len(sorted_array) > 0: data.append([ (sorted_array[int(len(sorted_array) / 4.0)], sorted_array[int(len(sorted_array) / 2.0)], sorted_array[int(len(sorted_array) * 0.75)]) ]) else: data.append([(0, 0, 0)]) else: curr = [] class_values = get_variable_values_sorted( self.data_domain.class_var) for c in range(len(class_values)): attr_values = self.data[ attr_idx, self.data[self.data_class_index] == c] attr_values = attr_values[~np.isnan(attr_values)] if len(attr_values) == 0: curr.append((0, 0, 0)) continue if self.show_statistics == MEANS: m = attr_values.mean() dev = attr_values.std() curr.append((m - dev, m, m + dev)) elif self.show_statistics == MEDIAN: sorted_array = np.sort(attr_values) curr.append( (sorted_array[int(len(attr_values) / 4.0)], sorted_array[int(len(attr_values) / 2.0)], sorted_array[int(len(attr_values) * 0.75)])) data.append(curr) # draw vertical lines for i in range(len(data)): for c in range(len(data[i])): if data[i][c] == (): continue x = i - 0.03 * (len(data[i]) - 1) / 2.0 + c * 0.03 col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve( "", col, col, 3, OWCurve.Lines, OWPoint.NoSymbol, xData=[x, x, x], yData=[data[i][c][0], data[i][c][1], data[i][c][2]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][0], data[i][c][0]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][1], data[i][c][1]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][2], data[i][c][2]], lineWidth=4) # draw lines with mean/median values if not self.data_has_class or self.data_has_continuous_class: class_count = 1 else: class_count = len(self.data_domain.class_var.values) for c in range(class_count): diff = -0.03 * (class_count - 1) / 2.0 + c * 0.03 ys = [] xs = [] for i in range(len(data)): if data[i] != [()]: ys.append(data[i][c][1]) xs.append(i + diff) else: if len(xs) > 1: col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=xs, yData=ys, lineWidth=4) xs = [] ys = [] col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=xs, yData=ys, lineWidth=4) def draw_distributions(self): """Draw distributions with discrete attributes""" if not (self.show_distributions and self.have_data and self.data_has_discrete_class): return class_count = len(self.data_domain.class_var.values) class_ = self.data_domain.class_var # we create a hash table of possible class values (happens only if we have a discrete class) if self.domain_contingencies is None: self.domain_contingencies = dict( zip([attr for attr in self.data_domain if attr.is_discrete], get_contingencies(self.raw_data, skipContinuous=True))) self.domain_contingencies[class_] = get_contingency( self.raw_data, class_, class_) max_count = max([ contingency.max() for contingency in self.domain_contingencies.values() ] or [1]) sorted_class_values = get_variable_values_sorted( self.data_domain.class_var) for axis_idx, attr_idx in enumerate(self.attribute_indices): attr = self.data_domain[attr_idx] if attr.is_discrete: continue contingency = self.domain_contingencies[attr] attr_len = len(attr.values) # we create a hash table of variable values and their indices sorted_variable_values = get_variable_values_sorted(attr) # create bar curve for j in range(attr_len): attribute_value = sorted_variable_values[j] value_count = contingency[:, attribute_value] for i in range(class_count): class_value = sorted_class_values[i] color = QColor(*self.colors[i]) color.setAlpha(self.alpha_value) width = float( value_count[class_value] * 0.5) / float(max_count) y_off = float(1.0 + 2.0 * j) / float(2 * attr_len) height = 0.7 / float(class_count * attr_len) y_low_bottom = y_off + float( class_count * height) / 2.0 - i * height curve = PolygonCurve(QPen(color), QBrush(color), xData=[ axis_idx, axis_idx + width, axis_idx + width, axis_idx ], yData=[ y_low_bottom, y_low_bottom, y_low_bottom - height, y_low_bottom - height ], tooltip=attr.name) curve.attach(self) # handle tooltip events def event(self, ev): if ev.type() == QEvent.ToolTip: x = self.inv_transform(xBottom, ev.pos().x()) y = self.inv_transform(yLeft, ev.pos().y()) canvas_position = self.mapToScene(ev.pos()) x_float = self.inv_transform(xBottom, canvas_position.x()) contact, (index, pos) = self.testArrowContact(int(round(x_float)), canvas_position.x(), canvas_position.y()) if contact: attr = self.data_domain[self.attributes[index]] if attr.is_continuous: condition = self.selection_conditions.get( attr.name, [0, 1]) val = self.attr_values[attr.name][0] + condition[pos] * ( self.attr_values[attr.name][1] - self.attr_values[attr.name][0]) str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val QToolTip.showText(ev.globalPos(), str_val) else: for curve in self.items(): if type(curve) == PolygonCurve and \ curve.boundingRect().contains(x, y) and \ getattr(curve, "tooltip", None): (name, value, total, dist) = curve.tooltip count = sum([v[1] for v in dist]) if count == 0: continue tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \ "Total instances: <b>%i</b> (%.1f%%)<br>" \ "Class distribution:<br>" % ( name, value, count, 100.0 * count / float(total)) for (val, n) in dist: tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % ( val, n, 100.0 * float(n) / float(count)) QToolTip.showText(ev.globalPos(), tooltip_text[:-4]) elif ev.type() == QEvent.MouseMove: QToolTip.hideText() return OWPlot.event(self, ev) def testArrowContact(self, indices, x, y): if type(indices) != list: indices = [indices] for index in indices: if index >= len(self.attributes) or index < 0: continue int_x = self.transform(xBottom, index) bottom = self.transform( yLeft, self.selection_conditions.get(self.attributes[index], [0, 1])[0]) bottom_rect = QRect(int_x - self.bottom_pixmap.width() / 2, bottom, self.bottom_pixmap.width(), self.bottom_pixmap.height()) if bottom_rect.contains(QPoint(x, y)): return 1, (index, 0) top = self.transform( yLeft, self.selection_conditions.get(self.attributes[index], [0, 1])[1]) top_rect = QRect(int_x - self.top_pixmap.width() / 2, top - self.top_pixmap.height(), self.top_pixmap.width(), self.top_pixmap.height()) if top_rect.contains(QPoint(x, y)): return 1, (index, 1) return 0, (0, 0) def mousePressEvent(self, e): canvas_position = self.mapToScene(e.pos()) x = self.inv_transform(xBottom, canvas_position.x()) contact, info = self.testArrowContact(int(round(x)), canvas_position.x(), canvas_position.y()) if contact: self.pressed_arrow = info else: OWPlot.mousePressEvent(self, e) def mouseMoveEvent(self, e): if hasattr(self, "pressed_arrow"): canvas_position = self.mapToScene(e.pos()) y = min(1, max(0, self.inv_transform(yLeft, canvas_position.y()))) index, pos = self.pressed_arrow attr = self.data_domain[self.attributes[index]] old_condition = self.selection_conditions.get(attr.name, [0, 1]) old_condition[pos] = y self.selection_conditions[attr.name] = old_condition self.update_data(self.attributes, self.visualized_mid_labels) if attr.is_continuous: val = self.attr_values[attr.name][0] + old_condition[pos] * ( self.attr_values[attr.name][1] - self.attr_values[attr.name][0]) strVal = attr.name + "= %.2f" % val QToolTip.showText(e.globalPos(), strVal) if self.sendSelectionOnUpdate and self.auto_send_selection_callback: self.auto_send_selection_callback() else: OWPlot.mouseMoveEvent(self, e) def mouseReleaseEvent(self, e): if hasattr(self, "pressed_arrow"): del self.pressed_arrow else: OWPlot.mouseReleaseEvent(self, e) def zoom_to_rect(self, r): r.setTop(self.graph_area.top()) r.setBottom(self.graph_area.bottom()) super().zoom_to_rect(r) def removeAllSelections(self, send=1): self.selection_conditions = {} self.update_data(self.attributes, self.visualized_mid_labels) # draw the curves and the selection conditions def drawCanvas(self, painter): OWPlot.drawCanvas(self, painter) for i in range( int( max( 0, math.floor( self.axisScaleDiv( xBottom).interval().minValue()))), int( min( len(self.attributes), math.ceil( self.axisScaleDiv(xBottom).interval().maxValue()) + 1))): bottom, top = self.selection_conditions.get( self.attributes[i], (0, 1)) painter.drawPixmap( self.transform(xBottom, i) - self.bottom_pixmap.width() / 2, self.transform(yLeft, bottom), self.bottom_pixmap) painter.drawPixmap( self.transform(xBottom, i) - self.top_pixmap.width() / 2, self.transform(yLeft, top) - self.top_pixmap.height(), self.top_pixmap) def auto_send_selection_callback(self): pass def clear(self): super().clear() self.attributes = [] self.visualized_mid_labels = [] self.selected_examples = [] self.unselected_examples = [] self.selection_conditions = {}
class Entity(QWidget): def __init__(self, base_image, parent=None): super().__init__(parent) self._base_label = QLabel(self) self._base_image = base_image self._decor_label = QLabel(self) self._decor_pixmap = None self.__pixmap = None """:type: PyQt4.QtGui.QPixmap""" self.__cord_x = 0 self.__cord_y = 0 self.__angle = 0 self.setAlignment(Qt.AlignCenter) self.updatePixmap() if _debugging: self.setStyleSheet("border: 1px solid black") @property def angle(self): return self.__angle @angle.setter def angle(self, angle): self.__angle = angle self.updatePixmap() @property def cord_x(self): return self.__cord_x @cord_x.setter def cord_x(self, cord): self.__cord_x = cord self.move(self.cord_x, self.cord_y) @property def cord_y(self): return self.__cord_y @cord_y.setter def cord_y(self, cord): self.__cord_y = cord self.move(self.cord_x, self.cord_y) def add_decoration(self, path): if path is None: self._decor_label.hide() else: self._decor_label = QLabel(self) self._decor_pixmap = QPixmap(path) self._decor_pixmap = self._decor_pixmap.scaled( self._decor_pixmap.width() * _SCALE, self._decor_pixmap.height() * _SCALE) self._decor_pixmap = self._decor_pixmap.transformed( QTransform().rotate(self.angle)) self._decor_label.setPixmap(self._decor_pixmap) def updatePixmap(self): path = _PATH + os.sep + "assets" + os.sep + self._base_image self.__pixmap = QPixmap(path) self.__pixmap = self.__pixmap.scaled(self.__pixmap.width() * _SCALE, self.__pixmap.height() * _SCALE) self.__pixmap = self.__pixmap.transformed(QTransform().rotate( self.angle)) self._base_label.setPixmap(self.__pixmap) self.setFixedSize(self.__pixmap.width(), self.__pixmap.height()) def setFixedSize(self, x, y): super().setFixedSize(x, y) self._base_label.setFixedSize(x, y) def setAlignment(self, alignment): self._base_label.setAlignment(alignment) self._decor_label.setAlignment(alignment)
class OWParallelGraph(OWPlot, ScaleData): show_distributions = Setting(False) show_attr_values = Setting(True) show_statistics = Setting(default=False) group_lines = Setting(default=False) number_of_groups = Setting(default=5) number_of_steps = Setting(default=30) use_splines = Setting(False) alpha_value = Setting(150) alpha_value_2 = Setting(150) def __init__(self, widget, parent=None, name=None): OWPlot.__init__(self, parent, name, axes=[], widget=widget) ScaleData.__init__(self) self.update_antialiasing(False) self.widget = widget self.last_selected_curve = None self.enableGridXB(0) self.enableGridYL(0) self.domain_contingencies = None self.auto_update_axes = 1 self.old_legend_keys = [] self.selection_conditions = {} self.attributes = [] self.visualized_mid_labels = [] self.attribute_indices = [] self.valid_data = [] self.groups = {} self.selected_examples = [] self.unselected_examples = [] self.bottom_pixmap = QPixmap(os.path.join(environ.widget_install_dir, "icons/upgreenarrow.png")) self.top_pixmap = QPixmap(os.path.join(environ.widget_install_dir, "icons/downgreenarrow.png")) def set_data(self, data, subset_data=None, **args): self.start_progress() self.set_progress(1, 100) self.data = data self.have_data = True self.domain_contingencies = None self.groups = {} OWPlot.setData(self, data) ScaleData.set_data(self, data, subset_data, no_data=True, **args) self.end_progress() def update_data(self, attributes, mid_labels=None): old_selection_conditions = self.selection_conditions self.clear() if not (self.have_data or self.have_subset_data): return if len(attributes) < 2: return if self.show_statistics: self.alpha_value = TRANSPARENT self.alpha_value_2 = VISIBLE else: self.alpha_value = VISIBLE self.alpha_value_2 = TRANSPARENT self.attributes = attributes self.attribute_indices = [self.attribute_name_index[name] for name in self.attributes] self.valid_data = self.get_valid_list(self.attribute_indices) self.visualized_mid_labels = mid_labels self.add_relevant_selections(old_selection_conditions) if self.data_has_discrete_class: self.discrete_palette.set_number_of_colors(len(self.data_domain.class_var.values)) if self.group_lines: self.show_statistics = False self.draw_groups() else: self.show_statistics = False self.draw_curves() self.draw_distributions() self.draw_axes() self.draw_statistics() self.draw_mid_labels(mid_labels) self.draw_legend() self.replot() def add_relevant_selections(self, old_selection_conditions): """Keep only conditions related to the currently visualized attributes""" for name, value in old_selection_conditions.items(): if name in self.attributes: self.selection_conditions[name] = value def draw_axes(self): self.remove_all_axes() for i in range(len(self.attributes)): axis_id = UserAxis + i a = self.add_axis(axis_id, line=QLineF(i, 0, i, 1), arrows=AxisStart | AxisEnd, zoomable=True) a.always_horizontal_text = True a.max_text_width = 100 a.title_margin = -10 a.text_margin = 0 a.setZValue(5) self.set_axis_title(axis_id, self.data_domain[self.attributes[i]].name) self.set_show_axis_title(axis_id, self.show_attr_values) if self.show_attr_values: attr = self.data_domain[self.attributes[i]] if isinstance(attr, ContinuousVariable): self.set_axis_scale(axis_id, self.attr_values[attr.name][0], self.attr_values[attr.name][1]) elif isinstance(attr, DiscreteVariable): attribute_values = get_variable_values_sorted(self.data_domain[self.attributes[i]]) attr_len = len(attribute_values) values = [float(1.0 + 2.0 * j) / float(2 * attr_len) for j in range(len(attribute_values))] a.set_bounds((0, 1)) self.set_axis_labels(axis_id, labels=attribute_values, values=values) def draw_curves(self): conditions = {name: self.attributes.index(name) for name in self.selection_conditions.keys()} def is_selected(example): return all(self.selection_conditions[name][0] <= example[index] <= self.selection_conditions[name][1] for (name, index) in list(conditions.items())) selected_curves = defaultdict(list) background_curves = defaultdict(list) diff, mins = [], [] for i in self.attribute_indices: var = self.data_domain[i] if isinstance(var, DiscreteVariable): diff.append(len(var.values)) mins.append(-0.5) else: diff.append(self.domain_data_stat[i].max - self.domain_data_stat[i].min or 1) mins.append(self.domain_data_stat[i].min) def scale_row(row): return [(x - m) / d for x, m, d in zip(row, mins, diff)] for row_idx, row in enumerate(self.data[:, self.attribute_indices]): if any(np.isnan(v) for v in row.x): continue color = self.select_color(row_idx) if is_selected(row): color += (self.alpha_value,) selected_curves[color].extend(scale_row(row)) self.selected_examples.append(row_idx) else: color += (self.alpha_value_2,) background_curves[color].extend(row) self.unselected_examples.append(row_idx) self._draw_curves(selected_curves) self._draw_curves(background_curves) def select_color(self, row_index): if self.data_has_class: if self.data_has_continuous_class: return self.continuous_palette.getRGB(self.data[row_index, self.data_class_index]) else: return self.discrete_palette.getRGB(self.data[row_index, self.data_class_index]) else: return 0, 0, 0 def _draw_curves(self, selected_curves): n_attr = len(self.attributes) for color, y_values in sorted(selected_curves.items()): n_rows = int(len(y_values) / n_attr) x_values = list(range(n_attr)) * n_rows curve = OWCurve() curve.set_style(OWCurve.Lines) curve.set_color(QColor(*color)) curve.set_segment_length(n_attr) curve.set_data(x_values, y_values) curve.attach(self) def draw_groups(self): phis, mus, sigmas = self.compute_groups() diff, mins = [], [] for i in self.attribute_indices: var = self.data_domain[i] if isinstance(var, DiscreteVariable): diff.append(len(var.values)) mins.append(-0.5) else: diff.append(self.domain_data_stat[i].max - self.domain_data_stat[i].min or 1) mins.append(self.domain_data_stat[i].min) for j, (phi, cluster_mus, cluster_sigma) in enumerate(zip(phis, mus, sigmas)): for i, (mu1, sigma1, mu2, sigma2), in enumerate( zip(cluster_mus, cluster_sigma, cluster_mus[1:], cluster_sigma[1:])): nmu1 = (mu1 - mins[i]) / diff[i] nmu2 = (mu2 - mins[i + 1]) / diff[i + 1] nsigma1 = math.sqrt(sigma1) / diff[i] nsigma2 = math.sqrt(sigma2) / diff[i + 1] polygon = ParallelCoordinatePolygon(i, nmu1, nmu2, nsigma1, nsigma2, phi, self.discrete_palette.getRGB(j)) polygon.attach(self) self.replot() def compute_groups(self): key = (tuple(self.attributes), self.number_of_groups, self.number_of_steps) if key not in self.groups: def callback(i, n): self.set_progress(i, 2*n) conts = create_contingencies(self.data[:, self.attribute_indices], callback=callback) self.set_progress(50, 100) w, mu, sigma, phi = lac(conts, self.number_of_groups, self.number_of_steps) self.set_progress(100, 100) self.groups[key] = map(np.nan_to_num, (phi, mu, sigma)) return self.groups[key] def draw_legend(self): if self.data_has_class: if isinstance(self.data_domain.class_var, DiscreteVariable): self.legend().clear() values = get_variable_values_sorted(self.data_domain.class_var) for i, value in enumerate(values): self.legend().add_item(self.data_domain.class_var.name, value, OWPoint(OWPoint.Rect, self.discrete_palette[i], self.point_width)) else: values = self.attr_values[self.data_domain.class_var.name] decimals = self.data_domain.class_var.number_of_decimals self.legend().add_color_gradient(self.data_domain.class_var.name, ["%%.%df" % decimals % v for v in values]) else: self.legend().clear() self.old_legend_keys = [] def draw_mid_labels(self, mid_labels): if mid_labels: for j in range(len(mid_labels)): self.addMarker(mid_labels[j], j + 0.5, 1.0, alignment=Qt.AlignCenter | Qt.AlignTop) def draw_statistics(self): """Draw lines that represent standard deviation or quartiles""" return # TODO: Implement using BasicStats if self.show_statistics and self.have_data: data = [] for attr_idx in self.attribute_indices: if not isinstance(self.data_domain[attr_idx], ContinuousVariable): data.append([()]) continue # only for continuous attributes if not self.data_has_class or self.data_has_continuous_class: # no class if self.show_statistics == MEANS: m = self.domain_data_stat[attr_idx].mean dev = self.domain_data_stat[attr_idx].var data.append([(m - dev, m, m + dev)]) elif self.show_statistics == MEDIAN: data.append([(0, 0, 0)]); continue sorted_array = np.sort(attr_values) if len(sorted_array) > 0: data.append([(sorted_array[int(len(sorted_array) / 4.0)], sorted_array[int(len(sorted_array) / 2.0)], sorted_array[int(len(sorted_array) * 0.75)])]) else: data.append([(0, 0, 0)]) else: curr = [] class_values = get_variable_values_sorted(self.data_domain.class_var) for c in range(len(class_values)): attr_values = self.data[attr_idx, self.data[self.data_class_index] == c] attr_values = attr_values[~np.isnan(attr_values)] if len(attr_values) == 0: curr.append((0, 0, 0)) continue if self.show_statistics == MEANS: m = attr_values.mean() dev = attr_values.std() curr.append((m - dev, m, m + dev)) elif self.show_statistics == MEDIAN: sorted_array = np.sort(attr_values) curr.append((sorted_array[int(len(attr_values) / 4.0)], sorted_array[int(len(attr_values) / 2.0)], sorted_array[int(len(attr_values) * 0.75)])) data.append(curr) # draw vertical lines for i in range(len(data)): for c in range(len(data[i])): if data[i][c] == (): continue x = i - 0.03 * (len(data[i]) - 1) / 2.0 + c * 0.03 col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve("", col, col, 3, OWCurve.Lines, OWPoint.NoSymbol, xData=[x, x, x], yData=[data[i][c][0], data[i][c][1], data[i][c][2]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][0], data[i][c][0]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][1], data[i][c][1]], lineWidth=4) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=[x - 0.03, x + 0.03], yData=[data[i][c][2], data[i][c][2]], lineWidth=4) # draw lines with mean/median values if not self.data_has_class or self.data_has_continuous_class: class_count = 1 else: class_count = len(self.data_domain.class_var.values) for c in range(class_count): diff = - 0.03 * (class_count - 1) / 2.0 + c * 0.03 ys = [] xs = [] for i in range(len(data)): if data[i] != [()]: ys.append(data[i][c][1]) xs.append(i + diff) else: if len(xs) > 1: col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=xs, yData=ys, lineWidth=4) xs = [] ys = [] col = QColor(self.discrete_palette[c]) col.setAlpha(self.alpha_value_2) self.add_curve("", col, col, 1, OWCurve.Lines, OWPoint.NoSymbol, xData=xs, yData=ys, lineWidth=4) def draw_distributions(self): """Draw distributions with discrete attributes""" if not (self.show_distributions and self.have_data and self.data_has_discrete_class): return class_count = len(self.data_domain.class_var.values) class_ = self.data_domain.class_var # we create a hash table of possible class values (happens only if we have a discrete class) if self.domain_contingencies is None: self.domain_contingencies = dict( zip([attr for attr in self.data_domain if isinstance(attr, DiscreteVariable)], get_contingencies(self.raw_data, skipContinuous=True))) self.domain_contingencies[class_] = get_contingency(self.raw_data, class_, class_) max_count = max([contingency.max() for contingency in self.domain_contingencies.values()] or [1]) sorted_class_values = get_variable_values_sorted(self.data_domain.class_var) for axis_idx, attr_idx in enumerate(self.attribute_indices): attr = self.data_domain[attr_idx] if isinstance(attr, DiscreteVariable): continue contingency = self.domain_contingencies[attr] attr_len = len(attr.values) # we create a hash table of variable values and their indices sorted_variable_values = get_variable_values_sorted(attr) # create bar curve for j in range(attr_len): attribute_value = sorted_variable_values[j] value_count = contingency[:, attribute_value] for i in range(class_count): class_value = sorted_class_values[i] color = QColor(self.discrete_palette[i]) color.setAlpha(self.alpha_value) width = float(value_count[class_value] * 0.5) / float(max_count) y_off = float(1.0 + 2.0 * j) / float(2 * attr_len) height = 0.7 / float(class_count * attr_len) y_low_bottom = y_off + float(class_count * height) / 2.0 - i * height curve = PolygonCurve(QPen(color), QBrush(color), xData=[axis_idx, axis_idx + width, axis_idx + width, axis_idx], yData=[y_low_bottom, y_low_bottom, y_low_bottom - height, y_low_bottom - height], tooltip=attr.name) curve.attach(self) # handle tooltip events def event(self, ev): if ev.type() == QEvent.ToolTip: x = self.inv_transform(xBottom, ev.pos().x()) y = self.inv_transform(yLeft, ev.pos().y()) canvas_position = self.mapToScene(ev.pos()) x_float = self.inv_transform(xBottom, canvas_position.x()) contact, (index, pos) = self.testArrowContact(int(round(x_float)), canvas_position.x(), canvas_position.y()) if contact: attr = self.data_domain[self.attributes[index]] if isinstance(attr, ContinuousVariable): condition = self.selection_conditions.get(attr.name, [0, 1]) val = self.attr_values[attr.name][0] + condition[pos] * ( self.attr_values[attr.name][1] - self.attr_values[attr.name][0]) str_val = attr.name + "= %%.%df" % attr.number_of_decimals % val QToolTip.showText(ev.globalPos(), str_val) else: for curve in self.items(): if type(curve) == PolygonCurve and \ curve.boundingRect().contains(x, y) and \ getattr(curve, "tooltip", None): (name, value, total, dist) = curve.tooltip count = sum([v[1] for v in dist]) if count == 0: continue tooltip_text = "Attribute: <b>%s</b><br>Value: <b>%s</b><br>" \ "Total instances: <b>%i</b> (%.1f%%)<br>" \ "Class distribution:<br>" % ( name, value, count, 100.0 * count / float(total)) for (val, n) in dist: tooltip_text += " <b>%s</b> : <b>%i</b> (%.1f%%)<br>" % ( val, n, 100.0 * float(n) / float(count)) QToolTip.showText(ev.globalPos(), tooltip_text[:-4]) elif ev.type() == QEvent.MouseMove: QToolTip.hideText() return OWPlot.event(self, ev) def testArrowContact(self, indices, x, y): if type(indices) != list: indices = [indices] for index in indices: if index >= len(self.attributes) or index < 0: continue int_x = self.transform(xBottom, index) bottom = self.transform(yLeft, self.selection_conditions.get(self.attributes[index], [0, 1])[0]) bottom_rect = QRect(int_x - self.bottom_pixmap.width() / 2, bottom, self.bottom_pixmap.width(), self.bottom_pixmap.height()) if bottom_rect.contains(QPoint(x, y)): return 1, (index, 0) top = self.transform(yLeft, self.selection_conditions.get(self.attributes[index], [0, 1])[1]) top_rect = QRect(int_x - self.top_pixmap.width() / 2, top - self.top_pixmap.height(), self.top_pixmap.width(), self.top_pixmap.height()) if top_rect.contains(QPoint(x, y)): return 1, (index, 1) return 0, (0, 0) def mousePressEvent(self, e): canvas_position = self.mapToScene(e.pos()) x = self.inv_transform(xBottom, canvas_position.x()) contact, info = self.testArrowContact(int(round(x)), canvas_position.x(), canvas_position.y()) if contact: self.pressed_arrow = info else: OWPlot.mousePressEvent(self, e) def mouseMoveEvent(self, e): if hasattr(self, "pressed_arrow"): canvas_position = self.mapToScene(e.pos()) y = min(1, max(0, self.inv_transform(yLeft, canvas_position.y()))) index, pos = self.pressed_arrow attr = self.data_domain[self.attributes[index]] old_condition = self.selection_conditions.get(attr.name, [0, 1]) old_condition[pos] = y self.selection_conditions[attr.name] = old_condition self.update_data(self.attributes, self.visualized_mid_labels) if isinstance(attr, ContinuousVariable): val = self.attr_values[attr.name][0] + old_condition[pos] * ( self.attr_values[attr.name][1] - self.attr_values[attr.name][0]) strVal = attr.name + "= %.2f" % val QToolTip.showText(e.globalPos(), strVal) if self.sendSelectionOnUpdate and self.auto_send_selection_callback: self.auto_send_selection_callback() else: OWPlot.mouseMoveEvent(self, e) def mouseReleaseEvent(self, e): if hasattr(self, "pressed_arrow"): del self.pressed_arrow else: OWPlot.mouseReleaseEvent(self, e) def zoom_to_rect(self, r): r.setTop(self.graph_area.top()) r.setBottom(self.graph_area.bottom()) super().zoom_to_rect(r) def removeAllSelections(self, send=1): self.selection_conditions = {} self.update_data(self.attributes, self.visualized_mid_labels) # draw the curves and the selection conditions def drawCanvas(self, painter): OWPlot.drawCanvas(self, painter) for i in range( int(max(0, math.floor(self.axisScaleDiv(xBottom).interval().minValue()))), int(min(len(self.attributes), math.ceil(self.axisScaleDiv(xBottom).interval().maxValue()) + 1))): bottom, top = self.selection_conditions.get(self.attributes[i], (0, 1)) painter.drawPixmap(self.transform(xBottom, i) - self.bottom_pixmap.width() / 2, self.transform(yLeft, bottom), self.bottom_pixmap) painter.drawPixmap(self.transform(xBottom, i) - self.top_pixmap.width() / 2, self.transform(yLeft, top) - self.top_pixmap.height(), self.top_pixmap) def auto_send_selection_callback(self): pass def clear(self): super().clear() self.attributes = [] self.visualized_mid_labels = [] self.selected_examples = [] self.unselected_examples = [] self.selection_conditions = {}
class Radar(QtGui.QLabel): def __init__(self, parent, radar, rect, myname): global xscale, yscale self.myname = myname self.rect = rect self.anim = 5 self.zoom = radar["zoom"] self.point = radar["center"] self.radar = radar self.baseurl = self.mapurl(radar, rect) print "map base url: " + self.baseurl QtGui.QLabel.__init__(self, parent) self.interval = Config.radar_refresh * 60 self.lastwx = 0 self.retries = 0 self.corners = getCorners(self.point, self.zoom, rect.width(), rect.height()) self.baseTime = 0 self.cornerTiles = { "NW": getTileXY(LatLng(self.corners["N"], self.corners["W"]), self.zoom), "NE": getTileXY(LatLng(self.corners["N"], self.corners["E"]), self.zoom), "SE": getTileXY(LatLng(self.corners["S"], self.corners["E"]), self.zoom), "SW": getTileXY(LatLng(self.corners["S"], self.corners["W"]), self.zoom) } self.tiles = [] self.tiletails = [] self.totalWidth = 0 self.totalHeight = 0 self.tilesWidth = 0 self.tilesHeight = 0 self.setObjectName("radar") self.setGeometry(rect) self.setStyleSheet("#radar { background-color: grey; }") self.setAlignment(Qt.AlignCenter) self.wwx = QtGui.QLabel(self) self.wwx.setObjectName("wx") self.wwx.setStyleSheet("#wx { background-color: transparent; }") self.wwx.setGeometry(0, 0, rect.width(), rect.height()) self.wmk = QtGui.QLabel(self) self.wmk.setObjectName("mk") self.wmk.setStyleSheet("#mk { background-color: transparent; }") self.wmk.setGeometry(0, 0, rect.width(), rect.height()) for y in range(int(self.cornerTiles["NW"]["Y"]), int(self.cornerTiles["SW"]["Y"]) + 1): self.totalHeight += 256 self.tilesHeight += 1 for x in range(int(self.cornerTiles["NW"]["X"]), int(self.cornerTiles["NE"]["X"]) + 1): tile = {"X": x, "Y": y} self.tiles.append(tile) tail = "/256/%d/%d/%d.png?color=3" % (self.zoom, x, y) self.tiletails.append(tail) for x in range(int(self.cornerTiles["NW"]["X"]), int(self.cornerTiles["NE"]["X"]) + 1): self.totalWidth += 256 self.tilesWidth += 1 self.frameImages = [] self.frameIndex = 0 self.displayedFrame = 0 self.ticker = 0 self.lastget = 0 def rtick(self): if time.time() > (self.lastget + self.interval): self.get(time.time()) self.lastget = time.time() if len(self.frameImages) < 1: return if self.displayedFrame == 0: self.ticker += 1 if self.ticker < 5: return self.ticker = 0 f = self.frameImages[self.displayedFrame] self.wwx.setPixmap(f["image"]) self.displayedFrame += 1 if self.displayedFrame >= len(self.frameImages): self.displayedFrame = 0 def get(self, t=0): t = int(t / 600) * 600 if t > 0 and self.baseTime == t: return if t == 0: t = self.baseTime else: self.baseTime = t newf = [] for f in self.frameImages: if f["time"] >= (t - self.anim * 600): newf.append(f) self.frameImages = newf firstt = t - self.anim * 600 for tt in range(firstt, t + 1, 600): print "get... " + str(tt) + " " + self.myname gotit = False for f in self.frameImages: if f["time"] == tt: gotit = True if not gotit: self.getTiles(tt) break def getTiles(self, t, i=0): t = int(t / 600) * 600 self.getTime = t self.getIndex = i if i == 0: self.tileurls = [] self.tileQimages = [] for tt in self.tiletails: tileurl = "https://tilecache.rainviewer.com/v2/radar/%d/%s" \ % (t, tt) self.tileurls.append(tileurl) print self.myname + " " + str(self.getIndex) + " " + self.tileurls[i] self.tilereq = QNetworkRequest(QUrl(self.tileurls[i])) self.tilereply = manager.get(self.tilereq) QtCore.QObject.connect(self.tilereply, QtCore.SIGNAL("finished()"), self.getTilesReply) def getTilesReply(self): print "getTilesReply " + str(self.getIndex) if self.tilereply.error() != QNetworkReply.NoError: return self.tileQimages.append(QImage()) self.tileQimages[self.getIndex].loadFromData(self.tilereply.readAll()) self.getIndex = self.getIndex + 1 if self.getIndex < len(self.tileurls): self.getTiles(self.getTime, self.getIndex) else: self.combineTiles() self.get() def combineTiles(self): global radar1 ii = QImage(self.tilesWidth * 256, self.tilesHeight * 256, QImage.Format_ARGB32) painter = QPainter() painter.begin(ii) painter.setPen(QColor(255, 255, 255, 255)) painter.setFont(QFont("Arial", 10)) i = 0 xo = self.cornerTiles["NW"]["X"] xo = int((int(xo) - xo) * 256) yo = self.cornerTiles["NW"]["Y"] yo = int((int(yo) - yo) * 256) for y in range(0, self.totalHeight, 256): for x in range(0, self.totalWidth, 256): painter.drawImage(x, y, self.tileQimages[i]) # painter.drawRect(x, y, 255, 255) # painter.drawText(x+3, y+12, self.tiletails[i]) i += 1 painter.end() painter = None self.tileQimages = [] ii2 = ii.copy(-xo, -yo, self.rect.width(), self.rect.height()) ii = None painter2 = QPainter() painter2.begin(ii2) timestamp = "{0:%H:%M} RainView.com".format( datetime.datetime.fromtimestamp(self.getTime)) painter2.setPen(QColor(63, 63, 63, 255)) painter2.setFont(QFont("Arial", 8)) painter2.setRenderHint(QPainter.TextAntialiasing) painter2.drawText(3 - 1, 12 - 1, timestamp) painter2.drawText(3 + 2, 12 + 1, timestamp) painter2.setPen(QColor(255, 255, 255, 255)) painter2.drawText(3, 12, timestamp) painter2.drawText(3 + 1, 12, timestamp) painter2.end() painter2 = None ii3 = QPixmap(ii2) ii2 = None self.frameImages.append({"time": self.getTime, "image": ii3}) ii3 = None def mapurl(self, radar, rect): mb = 0 try: mb = Config.usemapbox except: pass if mb: return self.mapboxurl(radar, rect) else: return self.googlemapurl(radar, rect) def mapboxurl(self, radar, rect): # note we're using google maps zoom factor. # Mapbox equivilant zoom is one less # They seem to be using 512x512 tiles instead of 256x256 style = 'mapbox/satellite-streets-v10' if 'style' in radar: style = radar['style'] return 'https://api.mapbox.com/styles/v1/' + \ style + \ '/static/' + \ str(radar['center'].lng) + ',' + \ str(radar['center'].lat) + ',' + \ str(radar['zoom']-1) + ',0,0/' + \ str(rect.width()) + 'x' + str(rect.height()) + \ '?access_token=' + ApiKeys.mbapi def googlemapurl(self, radar, rect): urlp = [] if len(ApiKeys.googleapi) > 0: urlp.append('key=' + ApiKeys.googleapi) urlp.append('center=' + str(radar['center'].lat) + ',' + str(radar['center'].lng)) zoom = radar['zoom'] rsize = rect.size() if rsize.width() > 640 or rsize.height() > 640: rsize = QtCore.QSize(rsize.width() / 2, rsize.height() / 2) zoom -= 1 urlp.append('zoom=' + str(zoom)) urlp.append('size=' + str(rsize.width()) + 'x' + str(rsize.height())) urlp.append('maptype=hybrid') return 'http://maps.googleapis.com/maps/api/staticmap?' + \ '&'.join(urlp) def basefinished(self): if self.basereply.error() != QNetworkReply.NoError: return self.basepixmap = QPixmap() self.basepixmap.loadFromData(self.basereply.readAll()) if self.basepixmap.size() != self.rect.size(): self.basepixmap = self.basepixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) self.setPixmap(self.basepixmap) # make marker pixmap self.mkpixmap = QPixmap(self.basepixmap.size()) self.mkpixmap.fill(Qt.transparent) br = QBrush(QColor(Config.dimcolor)) painter = QPainter() painter.begin(self.mkpixmap) painter.fillRect(0, 0, self.mkpixmap.width(), self.mkpixmap.height(), br) for marker in self.radar['markers']: pt = getPoint(marker["location"], self.point, self.zoom, self.rect.width(), self.rect.height()) mk2 = QImage() mkfile = 'teardrop' if 'image' in marker: mkfile = marker['image'] if os.path.dirname(mkfile) == '': mkfile = os.path.join('markers', mkfile) if os.path.splitext(mkfile)[1] == '': mkfile += '.png' mk2.load(mkfile) if mk2.format != QImage.Format_ARGB32: mk2 = mk2.convertToFormat(QImage.Format_ARGB32) mkh = 80 # self.rect.height() / 5 if 'size' in marker: if marker['size'] == 'small': mkh = 64 if marker['size'] == 'mid': mkh = 70 if marker['size'] == 'tiny': mkh = 40 if 'color' in marker: c = QColor(marker['color']) (cr, cg, cb, ca) = c.getRgbF() for x in range(0, mk2.width()): for y in range(0, mk2.height()): (r, g, b, a) = QColor.fromRgba(mk2.pixel(x, y)).getRgbF() r = r * cr g = g * cg b = b * cb mk2.setPixel(x, y, QColor.fromRgbF(r, g, b, a).rgba()) mk2 = mk2.scaledToHeight(mkh, 1) painter.drawImage(pt.x - mkh / 2, pt.y - mkh / 2, mk2) painter.end() self.wmk.setPixmap(self.mkpixmap) def getbase(self): global manager self.basereq = QNetworkRequest(QUrl(self.baseurl)) self.basereply = manager.get(self.basereq) QtCore.QObject.connect(self.basereply, QtCore.SIGNAL("finished()"), self.basefinished) def start(self, interval=0): if interval > 0: self.interval = interval self.getbase() self.timer = QtCore.QTimer() self.timer.timeout.connect(self.rtick) self.lastget = time.time() - self.interval + random.uniform(3, 10) def wxstart(self): print "wxstart for " + self.myname self.timer.start(200) def wxstop(self): print "wxstop for " + self.myname self.timer.stop() def stop(self): try: self.timer.stop() self.timer = None except Exception: pass
class Window(QtGui.QMainWindow): def __init__(self): super(Window, self).__init__() self.setGeometry(50, 50, 500, 300) self.setWindowTitle("Jack-en-Poy") self.setWindowIcon(QtGui.QIcon('images/python.png')) self.options = {1: "Rock", 2: "Paper", 3: "Scissors"} self.options_path = { 1: "images/rock.png", 2: "images/paper.png", 3: "images/scissors.png" } self.home() def home(self): self.winnerlbl = QtGui.QLabel("Play the game", self) self.winnerlbl.setGeometry(90, 170, 500, 100) self.userlbl = QtGui.QLabel("", self) self.enemylbl = QtGui.QLabel("", self) self.user_img = QPixmap(os.getcwd() + '\\' + self.options_path[1]) self.userlbl.setPixmap(self.user_img) self.userlbl.resize(self.user_img.width(), self.user_img.height()) self.userlbl.setGeometry(50, 20, self.user_img.width(), self.user_img.height() + 20) self.enemy_img = QPixmap(os.getcwd() + '\\' + self.options_path[2]) self.enemylbl.setPixmap(self.enemy_img) self.enemylbl.resize(self.enemy_img.width(), self.enemy_img.height()) self.enemylbl.setGeometry(300, 20, self.enemy_img.width(), self.enemy_img.height() + 20) rockbtn = QtGui.QPushButton("Rock", self) rockbtn.clicked.connect(lambda: self.jack_en_poy('1')) rockbtn.move(70, 250) paperbtn = QtGui.QPushButton("Paper", self) paperbtn.clicked.connect(lambda: self.jack_en_poy('2')) paperbtn.move(200, 250) scissorsbtn = QtGui.QPushButton("Scissors", self) scissorsbtn.clicked.connect(lambda: self.jack_en_poy('3')) scissorsbtn.move(330, 250) self.show() def jack_en_poy(self, user_choice): choice = int(user_choice) random_choice = r.randint(1, 3) if (choice == random_choice): self.user_img = QPixmap(os.getcwd() + '\\' + self.options_path[choice]) self.userlbl.setPixmap(self.user_img) self.userlbl.resize(self.user_img.width(), self.user_img.height() + 20) self.enemy_img = QPixmap(os.getcwd() + '\\' + self.options_path[random_choice]) self.enemylbl.resize(self.enemy_img.width(), self.enemy_img.height() + 20) self.enemylbl.setPixmap(self.enemy_img) self.winnerlbl.setText( f"Draw - Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print( f"Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print("Draw") elif ((choice == 1 and random_choice == 2) or (choice == 2 and random_choice == 3) or (choice == 3 and random_choice == 1)): self.user_img = QPixmap(os.getcwd() + '\\' + self.options_path[choice]) self.userlbl.setPixmap(self.user_img) self.enemy_img = QPixmap(os.getcwd() + '\\' + self.options_path[random_choice]) self.enemylbl.setPixmap(self.enemy_img) self.winnerlbl.setText( f"You Lose - Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print( f"Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print("Player lose") else: self.user_img = QPixmap(os.getcwd() + '\\' + self.options_path[choice]) self.userlbl.setPixmap(self.user_img) self.enemy_img = QPixmap(os.getcwd() + '\\' + self.options_path[random_choice]) self.enemylbl.setPixmap(self.enemy_img) self.winnerlbl.setText( f"You Win - Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print( f"Player chose {self.options[choice]} and Opponent chose {self.options[random_choice]}" ) print("Player wins")
class EkdPreview(): """ On gère un cache des Pixmap générés La méthode est simple : au lieu de charger toute l'image et d'en faire une préview après on génère la préview au chargement de l'image. On est ainsi moins dépendant de la taille de l'image à prévisualiser Pour faire ça, on utilise le QImageReader On utilise également la fonction de cache pour éviter d'avoir à regénérer à chaque fois les apperçus""" def __init__(self, imagePath, width=64, height=0, quality=0, Cache=True, keepRatio=True, magnify=False): """ imagePath : chemin de l'image a charger size : taille de la préview a générer quality : qualité de la preview (0=mavaise, 10=très bonne) keepRation : garde-t-on les proportion de l'image magnify : agrandit-on l'image si la preview demandée est plus grande que l'image originale """ self.preview = QPixmap() if width == 0: width = 64 if height == 0: height = width self.size = QSize(width, height) self.quality = quality self.imageName = imagePath self.keepRatio = keepRatio self.magnify = magnify self.cache = Cache QPixmapCache.setCacheLimit(50*1024) self.update() def get_preview(self): return self.preview def toggle_keepRatio(self): self.keepRatio = not self.keepRatio def get_image(self): return self.preview.toImage() def get_imageName(self): return self.imageName def set_imageName(self, path): self.imageName = path def get_size(self): return self.size def set_size(self, size): self.size = size def get_quality(self): return self.quality def set_quality(self, quality): self.quality = quality def width(self): return self.preview.width() def height(self): return self.preview.height() def origin(self): old_keepRatio=self.keepRatio self.keepRatio=False self.set_size(self.origineSize) self.update() self.keepRatio=old_keepRatio def update(self): """ Fonction de mise à jour de la préview : * Si la taille de l'image est plus petite que la taille souhaité, on n'agrandi pas l'image, on prend la plus petite des deux * Le cache contient en index les images+size""" miniImg = QImage() image = QImageReader(self.imageName) self.origineSize = image.size() image.setQuality(self.quality) if not self.magnify : if ( ( self.size.width() + self.size.height() ) > (image.size().width() + image.size().height() ) ) : self.size = image.size() if self.keepRatio : image.setScaledSize(QSize(self.size.width(), image.size().height() * self.size.width() / image.size().width() ) ) else : image.setScaledSize(self.size) if not QPixmapCache.find(self.imageName + str(self.size), self.preview) or not self.cache: image.read(miniImg) self.preview = self.preview.fromImage(miniImg) if self.cache : QPixmapCache.insert(self.imageName + str(self.size), self.preview)
def initUI(self): cw = QWidget() self.setCentralWidget(cw) grid = QGridLayout() grid.setSpacing(15) # status bar self.statusBar().showMessage('Ready') font_label = QFont() font_label.setBold(True) font_info = QFont() font_info.setItalic(True) font_info.setPixelSize(10) ############# lisa_title = QLabel('Organ Segmentation with Random Walker') info = QLabel('Developed by:\n' + 'University of West Bohemia\n' + 'Faculty of Applied Sciences\n' + QString.fromUtf8('M. Jirik, V. Lukes, T. Ryba - 2013') ) info.setFont(font_info) lisa_title.setFont(font_label) lisa_logo = QLabel() logopath = os.path.join(path_to_script, 'kky_small.png') logo = QPixmap(logopath) lisa_logo.setPixmap(logo) grid.addWidget(lisa_title, 0, 1) grid.addWidget(info, 1, 1) grid.addWidget(lisa_logo, 0, 2, 2, 1) grid.setColumnMinimumWidth(1, logo.width()) ### dicom reader rstart = 2 hr = QFrame() hr.setFrameShape(QFrame.HLine) text_dcm = QLabel('DICOM reader') text_dcm.setFont(font_label) btn_dcmdir = QPushButton("Load DICOM", self) btn_dcmdir.clicked.connect(self.loadDcmDir) btn_dcmcrop = QPushButton("Crop", self) btn_dcmcrop.clicked.connect(self.cropDcm) self.text_dcm_dir = QLabel('DICOM dir:') self.text_dcm_data = QLabel('DICOM data:') grid.addWidget(hr, rstart + 0, 0, 1, 4) grid.addWidget(text_dcm, rstart + 1, 1, 1, 2) grid.addWidget(btn_dcmdir, rstart + 2, 1) grid.addWidget(btn_dcmcrop, rstart + 2, 2) grid.addWidget(self.text_dcm_dir, rstart + 5, 1, 1, 2) grid.addWidget(self.text_dcm_data, rstart + 6, 1, 1, 2) rstart += 8 # ################ segmentation hr = QFrame() hr.setFrameShape(QFrame.HLine) text_seg = QLabel('Segmentation') text_seg.setFont(font_label) btn_segauto = QPushButton("Automatic seg.", self) btn_segauto.clicked.connect(self.autoSeg) btn_segman = QPushButton("Manual seg.", self) btn_segman.clicked.connect(self.manualSeg) self.text_seg_data = QLabel('segmented data:') grid.addWidget(hr, rstart + 0, 0, 1, 4) grid.addWidget(text_seg, rstart + 1, 1) grid.addWidget(btn_segauto, rstart + 2, 1) grid.addWidget(btn_segman, rstart + 2, 2) grid.addWidget(self.text_seg_data, rstart + 3, 1, 1, 2) rstart += 4 # ################ save/view btn_segsave = QPushButton("Save", self) btn_segsave.clicked.connect(self.saveOut) btn_segsavedcm = QPushButton("Save Dicom", self) btn_segsavedcm.clicked.connect(self.saveOutDcm) btn_segview = QPushButton("View3D", self) if viewer3D_available: btn_segview.clicked.connect(self.view3D) else: btn_segview.setEnabled(False) grid.addWidget(btn_segsave, rstart + 0, 1) grid.addWidget(btn_segview, rstart + 0, 2) grid.addWidget(btn_segsavedcm, rstart + 1, 1) rstart += 2 hr = QFrame() hr.setFrameShape(QFrame.HLine) grid.addWidget(hr, rstart + 0, 0, 1, 4) # quit btn_quit = QPushButton("Quit", self) btn_quit.clicked.connect(self.quit) grid.addWidget(btn_quit, rstart + 1, 1, 1, 2) cw.setLayout(grid) self.setWindowTitle('Organ Segmentation with Random Walker') self.show()
class SidebarWidget(QWidget): def __init__(self, editor): QWidget.__init__(self, editor) self.edit = editor self.highest_line = 0 self.foldArea = 15 self.rightArrowIcon = QPixmap() self.downArrowIcon = QPixmap() self.bindIcon = QPixmap() self.pat = re.compile( "(\s)*def |(\s)*class |(\s)*if |(\s)*while |" "(\s)*else:|(\s)*elif |(\s)*for |" "(\s)*try:|(\s)*except:|(\s)*except |(\s)*#begin-fold|" "(\s)*#.*AppObject:|(\s)*##.*Alexa Log|(\s)*#.*AppImage:|" "(\s)*#.*AppText:") self.patNotPython = re.compile('(\s)*#begin-fold:|(.)*{') self._foldedBlocks = [] self._oldFoldedBlocks = [] self._breakpoints = [] self._bookmarks = [] self._pep8Lines = [] self._errorsLines = [] self._migrationLines = [] self._firstPaintEvent = True self._oldCursorLine = 0 self._oldVerticalScrollbarPosition = 0 self._oldHorizontalScrollbarPosition = 0 self._oldAlexaAppObjIconsCoords = [] self._oldAlexaAppImgIconsCoords = [] self._oldAlexaAppTextIconsCoords = [] self._foldedAlexaObject = [] self._foldedAlexaImage = [] self._foldedAlexaText = [] self._oldAlexaLogIconsCoords = [] self._foldedAlexaLog = [] self.lineToFold = [] self._alexaFolded = False self._alexaObjectsPresent = False self.strings = [] self.jumpedUP = False self._keypress = False self._originalTotalLine = 0 self._currentTotalLine = 0 self.alexaFoundLines = [] #self.edit.go_to_line(0) def update_area(self): maxLine = math.ceil(math.log10(self.edit.blockCount())) width = QFontMetrics( self.edit.document().defaultFont()).width('0' * int(maxLine)) \ + 10 + self.foldArea if self.width() != width: self.setFixedWidth(width) self.edit.setViewportMargins(width, 0, 0, 0) self.update() def update(self, *args): QWidget.update(self, *args) def pep8_check_lines(self, lines): self._pep8Lines = lines def static_errors_lines(self, lines): self._errorsLines = lines def migration_lines(self, lines): self._migrationLines = lines def code_folding_event(self, lineNumber): if self._is_folded(lineNumber): self._fold(lineNumber) else: self._unfold(lineNumber) self.edit.update() self.update() def _fold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() while block.isValid() and block != endBlock: block.setVisible(False) block.setLineCount(0) block = block.next() self._foldedBlocks.append(startBlock.blockNumber()) #self._oldFoldedBlocks = copy.deepcopy(self._foldedBlocks) self.edit.document().markContentsDirty(startBlock.position(), endPos) self.updateAlexaCoords() def _unfold(self, lineNumber): startBlock = self.edit.document().findBlockByNumber(lineNumber - 1) endPos = self._find_fold_closing(startBlock) endBlock = self.edit.document().findBlockByNumber(endPos) block = startBlock.next() tmpBlock = None # avoid loop (alan) while block.isValid() and block != endBlock: block.setVisible(True) block.setLineCount(block.layout().lineCount()) endPos = block.position() + block.length() if block.blockNumber( ) in self._foldedBlocks: # and block != tmpBlock: close = self._find_fold_closing(block) block = self.edit.document().findBlockByNumber(close) else: block = block.next() tmpBlock = block #self._oldFoldedBlocks = copy.deepcopy(self._foldedBlocks) self._foldedBlocks.remove(startBlock.blockNumber()) self.edit.document().markContentsDirty(startBlock.position(), endPos) self.updateAlexaCoords() def _is_folded(self, line): block = self.edit.document().findBlockByNumber(line) if not block.isValid(): return False return block.isVisible() def _find_fold_closing(self, block): text = block.text() pat = re.compile('(\s)*#begin-fold:') patAlexaAppObject = re.compile('(\s)*#.*AppObject:') patAlexaLog = re.compile('(\s)*##.*Alexa Log') patAlexaAppImage = re.compile('(\s)*#.*AppImage:') patAlexaAppText = re.compile('(\s)*#.*AppText:') patBrace = re.compile('(.)*{$') if pat.match(text): return self._find_fold_closing_label(block) elif patAlexaAppObject.match(text): return self._find_fold_closing_alexaAppObject(block) elif patAlexaLog.match(text): return self._find_fold_closing_alexaLog(block) elif patAlexaAppImage.match(text): return self._find_fold_closing_alexaAppImage(block) elif patAlexaAppText.match(text): return self._find_fold_closing_alexaAppText(block) elif patBrace.match(text): return self._find_fold_closing_brace(block) spaces = helpers.get_leading_spaces(text) pat = re.compile('^\s*$|^\s*#') block = block.next() while block.isValid(): text2 = block.text() if not pat.match(text2): spacesEnd = helpers.get_leading_spaces(text2) if len(spacesEnd) <= len(spaces): if pat.match(block.previous().text()): return block.previous().blockNumber() else: return block.blockNumber() block = block.next() return block.previous().blockNumber() def _find_fold_closing_label(self, block): text = block.text() label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end-fold:' + label) while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_alexaAppObject(self, block): #text = block.text() #label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end AppObject') while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_alexaAppImage(self, block): #text = block.text() #label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end AppImage') while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_alexaAppText(self, block): #text = block.text() #label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end AppText') while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_alexaLog(self, block): #text = block.text() #label = text.split(':')[1] block = block.next() pat = re.compile('\s*#end Alexa Log') while block.isValid(): if pat.match(block.text()): return block.blockNumber() + 1 block = block.next() return block.blockNumber() def _find_fold_closing_brace(self, block): block = block.next() openBrace = 1 while block.isValid(): openBrace += block.text().count('{') openBrace -= block.text().count('}') if openBrace == 0: return block.blockNumber() + 1 elif openBrace < 0: return block.blockNumber() block = block.next() return block.blockNumber() def paintEvent(self, event): page_bottom = self.edit.viewport().height() font_metrics = QFontMetrics(self.edit.document().defaultFont()) current_block = self.edit.document().findBlock( self.edit.textCursor().position()) if self._firstPaintEvent is True: self.jumpedUP = False self.strings = self.edit.toPlainText().split('\n') self._originalTotalLine = len(self.strings) self.edit.jump_to_line(len(self.strings) - 2) elif self.jumpedUP is False: self.edit.jump_to_line(1) self.edit.verticalScrollBar().setValue(0) self.jumpedUP = True return pattern = self.pat if self.edit.lang == "python" else self.patNotPython painter = QPainter(self) background = resources.CUSTOM_SCHEME.get( 'sidebar-background', resources.COLOR_SCHEME['sidebar-background']) foreground = resources.CUSTOM_SCHEME.get( 'sidebar-foreground', resources.COLOR_SCHEME['sidebar-foreground']) pep8color = resources.CUSTOM_SCHEME.get( 'pep8-underline', resources.COLOR_SCHEME['pep8-underline']) errorcolor = resources.CUSTOM_SCHEME.get( 'error-underline', resources.COLOR_SCHEME['error-underline']) migrationcolor = resources.CUSTOM_SCHEME.get( 'migration-underline', resources.COLOR_SCHEME['migration-underline']) painter.fillRect(self.rect(), QColor(background)) ''' if self._firstPaintEvent is True: block = self.edit.document().findBlock(0) else: block = self.edit.firstVisibleBlock() ''' block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() line_count = block.blockNumber() painter.setFont(self.edit.document().defaultFont()) pat = re.compile('\s*#.*AppObject:') patAlexaAppImage = re.compile('\s*#.*AppImage:') patAlexaAppText = re.compile('\s*#.*AppText:') patAlexaLog = re.compile('\s*##.*Alexa Log') while block.isValid(): line_count += 1 # The top left position of the block in the document position = self.edit.blockBoundingGeometry(block).topLeft() + \ viewport_offset # Check if the position of the block is outside of the visible area if position.y() > page_bottom: break # Set the Painter Pen depending on special lines error = False if settings.CHECK_STYLE and \ ((line_count - 1) in self._pep8Lines): painter.setPen(QColor(pep8color)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.FIND_ERRORS and \ ((line_count - 1) in self._errorsLines): painter.setPen(QColor(errorcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True elif settings.SHOW_MIGRATION_TIPS and \ ((line_count - 1) in self._migrationLines): painter.setPen(QColor(migrationcolor)) font = painter.font() font.setItalic(True) font.setUnderline(True) painter.setFont(font) error = True else: painter.setPen(QColor(foreground)) # We want the line number for the selected line to be bold. bold = False if block == current_block: bold = True font = painter.font() font.setBold(True) painter.setFont(font) # Draw the line number right justified at the y position of the # line. 3 is a magic padding number. drawText(x, y, text). if block.isVisible(): painter.drawText( self.width() - self.foldArea - font_metrics.width(str(line_count)) - 3, round(position.y()) + font_metrics.ascent() + font_metrics.descent() - 1, str(line_count)) # Remove the bold style if it was set previously. if bold: font = painter.font() font.setBold(False) painter.setFont(font) if error: font = painter.font() font.setItalic(False) font.setUnderline(False) painter.setFont(font) block = block.next() self.highest_line = line_count #Code Folding xofs = self.width() - self.foldArea painter.fillRect( xofs, 0, self.foldArea, self.height(), QColor( resources.CUSTOM_SCHEME.get( 'fold-area', resources.COLOR_SCHEME['fold-area']))) if self.foldArea != self.rightArrowIcon.width(): polygon = QPolygonF() self.rightArrowIcon = QPixmap(self.foldArea, self.foldArea) self.rightArrowIcon.fill(Qt.transparent) self.downArrowIcon = QPixmap(self.foldArea, self.foldArea) self.downArrowIcon.fill(Qt.transparent) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.25)) polygon.append(QPointF(self.foldArea * 0.4, self.foldArea * 0.75)) polygon.append(QPointF(self.foldArea * 0.8, self.foldArea * 0.5)) iconPainter = QPainter(self.rightArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor( resources.CUSTOM_SCHEME.get( 'fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) polygon.clear() polygon.append(QPointF(self.foldArea * 0.25, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.75, self.foldArea * 0.4)) polygon.append(QPointF(self.foldArea * 0.5, self.foldArea * 0.8)) iconPainter = QPainter(self.downArrowIcon) iconPainter.setRenderHint(QPainter.Antialiasing) iconPainter.setPen(Qt.NoPen) iconPainter.setBrush( QColor( resources.CUSTOM_SCHEME.get( 'fold-arrow', resources.COLOR_SCHEME['fold-arrow']))) iconPainter.drawPolygon(polygon) if self._firstPaintEvent is True: block = self.edit.document().findBlock(0) else: block = self.edit.firstVisibleBlock() #block = self.edit.firstVisibleBlock() line_count = block.blockNumber() while block.isValid(): #while line_count < 5000: line_count += 1 position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset #Check if the position of the block is outside of the visible area if position.y() > page_bottom: break #block.isVisible() and if block.isVisible() and pat.match( block.text()) and block not in self._foldedAlexaObject: self._fold(line_count) self._foldedAlexaObject.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaAppImage.match( block.text()) and block not in self._foldedAlexaImage: self._fold(line_count) self._foldedAlexaImage.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaAppText.match( block.text()) and block not in self._foldedAlexaText: self._fold(line_count) self._foldedAlexaText.append(block) self._alexaObjectsPresent = True elif block.isVisible() and patAlexaLog.match( block.text()) and block not in self._foldedAlexaLog: self._fold(line_count) self._foldedAlexaLog.append(block) self._alexaObjectsPresent = True elif pattern.match(block.text()) and block.isVisible(): if block.blockNumber() in self._foldedBlocks: painter.drawPixmap(xofs, round(position.y()), self.rightArrowIcon) else: #block.setVisible(True) painter.drawPixmap(xofs, round(position.y()), self.downArrowIcon) #Add Bookmarks and Breakpoint elif block.blockNumber() in self._breakpoints: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(255, 11, 11)) linear_gradient.setColorAt(1, QColor(147, 9, 9)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse(xofs + 1, round(position.y()) + 6, self.foldArea - 1, self.foldArea - 1) elif block.blockNumber() in self._bookmarks: linear_gradient = QLinearGradient( xofs, round(position.y()), xofs + self.foldArea, round(position.y()) + self.foldArea) linear_gradient.setColorAt(0, QColor(13, 62, 243)) linear_gradient.setColorAt(1, QColor(5, 27, 106)) painter.setRenderHints(QPainter.Antialiasing, True) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(linear_gradient)) painter.drawRoundedRect(xofs + 1, round(position.y()) + 6, self.foldArea - 2, self.foldArea - 1, 3, 3) block = block.next() block = self.edit.document().findBlock(0) line_count = 0 line_hidden = 0 while block.isValid(): line_count += 1 if not block.isVisible(): line_hidden += 1 block = block.next() endScrollBar = line_count - line_hidden self.edit.verticalScrollBar().setRange(0, endScrollBar) if self._firstPaintEvent is True: self._firstPaintEvent = False #self.updateAlexaAppObjCoords() #self.updateAlexaLogCoords() painter.end() ''' #self.edit.update() if self.edit.verticalScrollBar().value() != self._oldVerticalScrollbarPosition and self._alexaObjectsPresent is True: self._oldVerticalScrollbarPosition = self.edit.verticalScrollBar().value() self.updateAlexaCoords() self.edit.update() # in this way we can refresh alexa icon position if self.edit.horizontalScrollBar().value() != self._oldHorizontalScrollbarPosition and self._alexaObjectsPresent is True: self._oldHorizontalScrollbarPosition = self.edit.horizontalScrollBar().value() self.updateAlexaCoords() self.edit.update() # in this way we can refresh alexa icon position ''' self.strings = self.edit.toPlainText().split('\n') self._currentTotalLine = len(self.strings) if self._currentTotalLine != self._originalTotalLine: self._originalTotalLine = self._currentTotalLine self.updateAlexaCoords() self.edit.update() ''' if self._returnPressed is True: self._returnPressed = False self.updateAlexaAppObjCoords() self.updateAlexaLogCoords() self.edit.update() if self._backspacePressed is True: self._backspacePressed = False self.strings = self.edit.toPlainText().split('\n') self._currentTotalLine = len(self.strings) if self._currentTotalLine != self._originalTotalLine: self.updateAlexaAppObjCoords() self.updateAlexaLogCoords() self.edit.update() ''' if self.edit._alexaAppObjIconsCoords != self._oldAlexaAppObjIconsCoords: self._oldAlexaAppObjIconsCoords = copy.deepcopy( self.edit._alexaAppObjIconsCoords) self.edit.update() if self.edit._alexaAppImgIconsCoords != self._oldAlexaAppImgIconsCoords: self._oldAlexaAppImgIconsCoords = copy.deepcopy( self.edit._alexaAppImgIconsCoords) self.edit.update() if self.edit._alexaAppTextIconsCoords != self._oldAlexaAppTextIconsCoords: self._oldAlexaAppTextIconsCoords = copy.deepcopy( self.edit._alexaAppTextIconsCoords) self.edit.update() if self.edit._alexaLogIconsCoords != self._oldAlexaLogIconsCoords: self._oldAlexaLogIconsCoords = copy.deepcopy( self.edit._alexaLogIconsCoords) self.edit.update() selectedLine = self.edit.textCursor().selectedText() textAtCursorPos = self.edit.textCursor().block().text() try: #tmp = selectedLine.index("# AppObject") if (pat.match(selectedLine) or patAlexaLog.match(selectedLine) or \ pat.match(textAtCursorPos) or patAlexaLog.match(textAtCursorPos) or \ patAlexaAppImage.match(selectedLine) or patAlexaAppImage.match(textAtCursorPos) or\ patAlexaAppText.match(selectedLine) or patAlexaAppText.match(textAtCursorPos)) and \ self._keypress is True: self._keypress = False self.updateAlexaCoords() except: pass QWidget.paintEvent(self, event) ''' if self._alexaFolded is False: # and self._alexaFolded is False: self._alexaFolded = True #return #self.edit.setCursor(QCursor(Qt.WaitCursor)) load = loading.Loading(self) load.show() #self._alexaFolded = True line_alexa_cnt = 1 strings = self.edit.toPlainText().split('\n') for line in strings: #print line percent = (line_alexa_cnt * 100) / len(strings) #print percent tmpObj = -1 try: tmpObj = line.index('# AppObject:') #self.lineToFold.append(line_alexa_cnt) self._fold(line_alexa_cnt) self._alexaObjectsPresent = True self.loading.update() except: pass try: if tmpObj == -1: tmpObj = line.index('# Alexa Log') self._fold(line_alexa_cnt) self._alexaObjectsPresent = True except: tmpObj = -1 line_alexa_cnt += 1 ''' def mousePressEvent(self, event): if self.foldArea > 0: xofs = self.width() - self.foldArea font_metrics = QFontMetrics(self.edit.document().defaultFont()) fh = font_metrics.lineSpacing() ys = event.posF().y() lineNumber = 0 #self.code_folding_event(lineNumber) if event.pos().x() > xofs: pattern = self.pat if self.edit.lang != "python": pattern = self.patNotPython block = self.edit.firstVisibleBlock() viewport_offset = self.edit.contentOffset() page_bottom = self.edit.viewport().height() while block.isValid(): position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset if position.y() > page_bottom: break if position.y() < ys and (position.y() + fh) > ys and \ pattern.match(str(block.text())): lineNumber = block.blockNumber() + 1 break elif position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.LeftButton: line = block.blockNumber() if line in self._breakpoints: self._breakpoints.remove(line) else: self._breakpoints.append(line) self.update() break elif position.y() < ys and (position.y() + fh) > ys and \ event.button() == Qt.RightButton: line = block.blockNumber() if line in self._bookmarks: self._bookmarks.remove(line) else: self._bookmarks.append(line) self.update() break block = block.next() self._save_breakpoints_bookmarks() if lineNumber > 0: self.code_folding_event(lineNumber) def _save_breakpoints_bookmarks(self): if self._bookmarks and self.edit.ID != "": settings.BOOKMARKS[self.edit.ID] = self._bookmarks elif self.edit.ID in settings.BOOKMARKS: settings.BOOKMARKS.pop(self.edit.ID) if self._breakpoints and self.edit.ID != "": settings.BREAKPOINTS[self.edit.ID] = self._breakpoints elif self.edit.ID in settings.BREAKPOINTS: settings.BREAKPOINTS.pop(self.edit.ID) def set_breakpoint(self, lineno): if lineno in self._breakpoints: self._breakpoints.remove(lineno) else: self._breakpoints.append(lineno) self.update() self._save_breakpoints_bookmarks() def set_bookmark(self, lineno): if lineno in self._bookmarks: self._bookmarks.remove(lineno) else: self._bookmarks.append(lineno) self.update() self._save_breakpoints_bookmarks() def updateAlexaCoords(self): self.updateAlexaAppObjCoords() self.updateAlexaAppImgCoords() self.updateAlexaAppTextCoords() self.updateAlexaLogCoords() def updateAlexaAppObjCoords(self): self.edit._alexaAppObjIconsCoords = [] #block = self.edit.document().findBlock(0) block = self.edit.firstVisibleBlock() line_count = block.blockNumber() pat = re.compile('\s*#.*AppObject:') viewport_offset = self.edit.contentOffset() while block.isValid(): line_count += 1 #maxLine = math.ceil(math.log10(self.edit.blockCount())) font_metrics = QFontMetrics(self.edit.document().defaultFont()) position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset width = self.edit.blockBoundingGeometry(block).width() ''' width = 4 for char in block.text(): width += font_metrics.width(char) ''' x = 4 + viewport_offset.x() if pat.match(block.text()): try: if self.edit.useTabs: x += block.text().index(" #") * ( font_metrics.width('.') * self.edit.indent) else: x += block.text().index(" #") * font_metrics.width('.') except: pass if block.isVisible( ): # da notare che il blocco è la riga e non il blocco compreso tra i tag di Al'exa self.edit._alexaAppObjIconsCoords.append( (x, position.y(), width, line_count)) block = block.next() def updateAlexaAppImgCoords(self): self.edit._alexaAppImgIconsCoords = [] #block = self.edit.document().findBlock(0) block = self.edit.firstVisibleBlock() line_count = block.blockNumber() pat = re.compile('\s*#.*AppImage:') viewport_offset = self.edit.contentOffset() while block.isValid(): line_count += 1 #maxLine = math.ceil(math.log10(self.edit.blockCount())) font_metrics = QFontMetrics(self.edit.document().defaultFont()) position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset width = self.edit.blockBoundingGeometry(block).width() ''' width = 4 for char in block.text(): width += font_metrics.width(char) ''' x = 5 + viewport_offset.x() if pat.match(block.text()): try: if self.edit.useTabs: x += block.text().index(" #") * ( font_metrics.width('.') * self.edit.indent) else: x += block.text().index(" #") * font_metrics.width('.') except: pass if block.isVisible( ): # da notare che il blocco è la riga e non il blocco compreso tra i tag di Al'exa self.edit._alexaAppImgIconsCoords.append( (x, position.y(), width, line_count)) block = block.next() def updateAlexaAppTextCoords(self): self.edit._alexaAppTextIconsCoords = [] #block = self.edit.document().findBlock(0) block = self.edit.firstVisibleBlock() line_count = block.blockNumber() pat = re.compile('\s*#.*AppText:') viewport_offset = self.edit.contentOffset() while block.isValid(): line_count += 1 #maxLine = math.ceil(math.log10(self.edit.blockCount())) font_metrics = QFontMetrics(self.edit.document().defaultFont()) position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset width = self.edit.blockBoundingGeometry(block).width() x = 3 + viewport_offset.x() if pat.match(block.text()): try: if self.edit.useTabs: #x += block.text().index("#") * (font_metrics.width('.') * self.edit.indent) x += block.text().index(" #") * ( font_metrics.width('.') * self.edit.indent) else: #x += block.text().index("#") * font_metrics.width('.') x += block.text().index(" #") * font_metrics.width('.') except: pass if block.isVisible( ): # da notare che il blocco è la riga e non il blocco compreso tra i tag di Al'exa self.edit._alexaAppTextIconsCoords.append( (x, position.y(), width, line_count)) block = block.next() def updateAlexaLogCoords(self): self.edit._alexaLogIconsCoords = [] #block = self.edit.document().findBlock(0) block = self.edit.firstVisibleBlock() line_count = block.blockNumber() pat = re.compile('\s*##.*Alexa Log') viewport_offset = self.edit.contentOffset() while block.isValid(): line_count += 1 #maxLine = math.ceil(math.log10(self.edit.blockCount())) font_metrics = QFontMetrics(self.edit.document().defaultFont()) position = self.edit.blockBoundingGeometry( block).topLeft() + viewport_offset width = self.edit.blockBoundingGeometry(block).width() x = 2 + viewport_offset.x() if pat.match(block.text()): try: if self.edit.useTabs: #x += block.text().index("#") * (font_metrics.width('.') * self.edit.indent) x += block.text().index(" #") * ( font_metrics.width('.') * self.edit.indent) else: #x += block.text().index("#") * font_metrics.width('.') x += block.text().index(" #") * font_metrics.width('.') except: pass if block.isVisible( ): # da notare che il blocco è la riga e non il blocco compreso tra i tag di Al'exa self.edit._alexaLogIconsCoords.append( (x, position.y(), width, line_count)) block = block.next()
class VCSIndicator: " Holds an indicator properties " def __init__( self, configLine ): """ Config line looks as follows: id:::pathOrString:::ForegroundColor:::BackgroundColor:::Tooltip It comes from a config file or from a plugin """ self.identifier = None self.pixmap = None self.text = None self.backgroundColor = None self.foregroundColor = None self.defaultTooltip = "" self.__parseConfigLine( configLine ) return def __parseConfigLine( self, configLine ): " Fills the members " if type( configLine ) == tuple or type( configLine ) == list: # Came from a plugin self.__parsePluginProvidedTuple( configLine ) else: # Came from a config file self.__parseConfigFileProvidedString( configLine ) self.__scalePixmap() return def __setBrokenIndicator( self, msg ): " Sets the indicator to the broken state " self.text = BROKEN_INDICATOR self.backgroundColor = QColor( 0, 255, 255 ) self.foregroundColor = QColor( 255, 0, 0 ) self.defaultTooltip = msg return def __parseConfigFileProvidedString( self, configLine ): " Parses config file provided values " parts = configLine.split( ":::" ) if len( parts ) != 5: raise Exception( "Unexpected format of an indicator " "description. Expected 5 values." ) # ID field self.identifier = int( parts[ 0 ] ) # path or text field if os.path.isabs( parts[ 1 ] ): # That must be a path to the pixmap try: self.pixmap = QPixmap( parts[ 1 ] ) except: self.__setBrokenIndicator( "Failed to load pixmap from " + parts[ 1 ] ) return else: # Try to find the pixmap in the standard pixmap directory candidate = parts[ 1 ].strip() searchPath = os.path.dirname( os.path.abspath( sys.argv[0] ) ) + \ os.path.sep + 'pixmaps' + os.path.sep + candidate if candidate != "" and os.path.exists( searchPath ): try: self.pixmap = QPixmap( searchPath ) except: self.__setBrokenIndicator( "Failed to load pixmap from " + parts[ 1 ] ) return else: # It is just a text. Cut it to up to 2 letters self.__setText( parts[ 1 ] ) # Foreground color if parts[ 2 ].lower() == "none": self.foregroundColor = None else: self.foregroundColor = buildColor( parts[ 2 ] ) # Background color if parts[ 3 ].lower() == "none": self.backgroundColor = None else: self.backgroundColor = buildColor( parts[ 3 ] ) # Default tooltip if parts[ 4 ].lower() == "none": self.defaultTooltip = "" else: self.defaultTooltip = str( parts[ 4 ] ).strip() return def __parsePluginProvidedTuple( self, pluginIndicator ): " Checks what plugin provided " if len( pluginIndicator ) != 5: raise Exception( "Unexpected format of an indicator " "description. Expected 5 values." ) # ID field self.identifier = int( pluginIndicator[ 0 ] ) # Pixmap/text field if type( pluginIndicator[ 1 ] ) == str: self.__setText( pluginIndicator[ 1 ] ) else: try: self.pixmap = QPixmap( pluginIndicator[ 1 ] ) except: self.__setBrokenIndicator( "Failed to get plugin indicator " "pixmap. Indicator id: " + str( self.identifier ) ) return # Foreground color if pluginIndicator[ 2 ] is None: self.foregroundColor = None else: if type( pluginIndicator[ 2 ] ) == str: self.foregroundColor = buildColor( pluginIndicator[ 2 ] ) else: self.foregroundColor = QColor( pluginIndicator[ 2 ] ) # Background color if pluginIndicator[ 3 ] is None: self.backgroundColor = None else: if type( pluginIndicator[ 3 ] ) == str: self.backgroundColor = buildColor( pluginIndicator[ 3 ] ) else: self.backgroundColor = QColor( pluginIndicator[ 3 ] ) # Default tooltip if pluginIndicator[ 4 ] is None: self.defaultTooltip = "" else: self.defaultTooltip = str( pluginIndicator[ 4 ] ).strip() return def __setText( self, value ): " Sets the indicator text " if len( value ) > MAX_TEXT_INDICATOR_LENGTH: self.text = value[ : MAX_TEXT_INDICATOR_LENGTH ] else: self.text = value self.text = self.text.strip() return def __scalePixmap( self ): " Scales the pixmap if necessary " if self.pixmap is None: return if self.pixmap.width() > MAX_PIXMAP_INDICATOR_WIDTH or \ self.pixmap.height() > MAX_PIXMAP_INDICATOR_HEIGHT: maxSize = QSize( MAX_PIXMAP_INDICATOR_WIDTH, MAX_PIXMAP_INDICATOR_HEIGHT ) self.pixmap = self.pixmap.scaled( maxSize, Qt.KeepAspectRatio ) return def isPixmap( self ): " True if it is a pixmap label " return self.pixmap is not None def draw( self, label ): " Draws the indicator as members tell. label is QLabel " label.setPalette( QLabel().palette() ) if self.isPixmap(): label.setAutoFillBackground( False ) label.setFrameStyle( QLabel().frameStyle() ) label.setPixmap( self.pixmap ) else: label.setFrameStyle( QFrame.StyledPanel ) label.setAutoFillBackground( True ) palette = label.palette() if self.backgroundColor is not None: palette.setColor( QPalette.Background, self.backgroundColor ) if self.foregroundColor is not None: palette.setColor( QPalette.Foreground, self.foregroundColor ) label.setPalette( palette ) label.setText( self.text ) return
def updateMainImage(self, image): pixmap = QPixmap(image) if pixmap.width() == 0 or pixmap.width() > self.width() or pixmap.height() > self.height(): QMessageBox.critical(self, "Uh oh!", "Could not display:\n {}".format(image)) else: self.main_imageLabel.setPixmap(pixmap)
def __init__(self, parent=None): super(Ui_Train, self).__init__(parent) self.setWindowTitle(("Train")) self.setWindowState(QtCore.Qt.WindowMaximized) self.isTrainWindowShown = True self.importedFiles = ImageData(self.imgs, self.isTrainWindowShown) # Random images will be taken from imgs_unscored for imgPath in self.importedFiles.images: self.imgs_unscored.append({'imgPath': imgPath}) # print("[INFO] imgs_unscored:") # print(json.dumps(self.imgs_unscored, indent=2)) self.mainMenu = self.menuBar() # Actions which can be seen from the drop-down of each menu selection self.instructionsAction = QtGui.QAction("&Instructions", self) self.instructionsAction.triggered.connect(self.instructions_Button_clicked) # Menu selections that show on the menubar on the Selekti screen self.helpMenu = self.mainMenu.addMenu('&Help') self.helpMenu.addAction(self.instructionsAction) self.rate_label = QtGui.QLabel(self) self.rate_label.setText("What do you think of this photo?") self.rate_label.setStyleSheet("QLabel { color: white; font: 18px; }") self.rate_label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter) star_empty = QPixmap("star_empty.png") star_filled = QPixmap("star_filled.png") star_size = star_empty.rect().size() stars = [] # Make the stars self.star_1 = StarButton('', self) self.star_2 = StarButton('', self) self.star_3 = StarButton('', self) self.star_4 = StarButton('', self) self.star_5 = StarButton('', self) stars.append(self.star_1) stars.append(self.star_2) stars.append(self.star_3) stars.append(self.star_4) stars.append(self.star_5) # Ideally all this stuff would go into StarButton's constructor but I couldn't find out how to override it properly for btn in stars: btn.initStarList() btn.setIcon(QIcon(star_empty)) btn.setDefaultIcon(QIcon(star_empty)) btn.setOnHoverIcon(QIcon(star_filled)) btn.setFixedSize(star_size) btn.setIconSize(QSize(50,50)) btn.setStyleSheet("QPushButton { border: none; }") btn.setEnabled(True) # Clicking a star will rate the image with the level of the star self.star_1.clicked.connect(lambda: self.rate_Button_clicked(1)) self.star_2.clicked.connect(lambda: self.rate_Button_clicked(2)) self.star_3.clicked.connect(lambda: self.rate_Button_clicked(3)) self.star_4.clicked.connect(lambda: self.rate_Button_clicked(4)) self.star_5.clicked.connect(lambda: self.rate_Button_clicked(5)) # when the current star is hovered over, all the stars to its left # should also be highlighted self.star_2.addDependentStar(self.star_1) self.star_3.addDependentStar(self.star_1) self.star_3.addDependentStar(self.star_2) self.star_4.addDependentStar(self.star_1) self.star_4.addDependentStar(self.star_2) self.star_4.addDependentStar(self.star_3) self.star_5.addDependentStar(self.star_1) self.star_5.addDependentStar(self.star_2) self.star_5.addDependentStar(self.star_3) self.star_5.addDependentStar(self.star_4) self.finish_Button = QtGui.QPushButton('Finish', self) self.finish_Button.clicked.connect(self.finish_Button_clicked) self.train_imageLabel = QtGui.QLabel(self) self.train_imageLabel.setAlignment(QtCore.Qt.AlignCenter) # need to show the win before trying to access its size below self.show() # prevent window minimization self.setFixedSize(self.width(), self.height()) self.rate_label.setGeometry(QtCore.QRect((self.width()*0.40), (self.height()*0.065), 400, 30)) self.finish_Button.setGeometry(QtCore.QRect((self.width()*0.70), (self.height()*0.95), 100, 30)) self.star_1.setGeometry(QtCore.QRect((self.width()*0.40), (self.height()*0.88), 97, 27)) self.star_2.setGeometry(QtCore.QRect((self.width()*0.45), (self.height()*0.88), 97, 27)) self.star_3.setGeometry(QtCore.QRect((self.width()*0.50), (self.height()*0.88), 97, 27)) self.star_4.setGeometry(QtCore.QRect((self.width()*0.55), (self.height()*0.88), 97, 27)) self.star_5.setGeometry(QtCore.QRect((self.width()*0.60), (self.height()*0.88), 97, 27)) self.current_img = self.get_next_image(self.imgs_unscored) if self.current_img == None: print("[INFO] No images to score.") else: # click on the train image pixmap = QPixmap(self.current_img['imgPath']) # sometimes the pixmap is null if pixmap.width() == 0 or pixmap.width() > self.width() or pixmap.height() > self.height(): QMessageBox.critical(self, "Uh oh!", "Could not display:\n {}\n\nYou can still rate it by clicking on a star.".format(self.current_img['imgPath'])) else: print("[INFO] displaying a pixmap") self.train_imageLabel.setPixmap(pixmap) self.train_imageLabel.setGeometry(QtCore.QRect((self.width()/2) - (pixmap.width()/2), (self.height()/2) - (pixmap.height()/2), pixmap.width(), pixmap.height())) self.train_imageLabel.setObjectName('train_imageLabel') self.train_imageLabel.mousePressEvent = self.train_image_clicked print("[INFO] Starting image was set.") # Feedback consists of the user's score for an image along with that image's feature vector # It's stored in a dictionary where the feat vectors are the keys and the scores are the values self.feedback_path = "feedback.cpickle" if os.path.isfile(self.feedback_path): feedback_file = open(self.feedback_path, "rb") self.feedback = pickle.load(feedback_file) # print("[INFO] feedback on OPEN: {}".format(self.feedback)) feedback_file.close() else: self.feedback = {}
def drawFeatureImages(self, imageFile): """Draw two consecutive images on the screen""" #Load image files path, file_ = os.path.split(imageFile) image1 = QPixmap(os.path.join(path, 'first_' + file_)) image2 = QPixmap(os.path.join(path, 'second_' + file_)) self.imageWidth = image1.width() #Add pixmaps image1Map = self.canvasScene.addPixmap(image1) image2Map = self.canvasScene.addPixmap(image2) #Shift pixmaps to the right position image1Map.setOffset(QPointF(5, 3)) image2Map.setOffset(QPointF(10 + image1.width(), 3))