def drawImage(self, imageid): cache = image_cache.cache cellColoring = self.cellColoring wallColoring = self.wallColoring pointColoring = self.pointColoring ellipsisDraw = self.ellipsisDraw overSampling = self.overSampling extraDrawing = self.extraDrawing bgColor = self.bgColor.rgb() result = self.result if self.result_type == "Data": data = result img_name = result.images_name[imageid] else: data = result.data img_name = result.images[imageid] #scale = data.images_scale[img_name] min_scale = data.minScale() img = cache.image(data.image_path(img_name)) img_data = data[img_name] size = self._crop.size() pix = QImage(size * overSampling, QImage.Format_ARGB32) pix.fill(bgColor) painter = QPainter() if not painter.begin(pix): self.abort("Cannot create painter on QImage") return None, None, None painter.setRenderHints(QPainter.SmoothPixmapTransform, True) painter.setRenderHints(QPainter.Antialiasing, True) if overSampling > 1: painter.scale(overSampling, overSampling) painter.translate(-self._crop.topLeft()) painter.save() painter.translate(self.translate) log_debug("Translating: %gx%g" % (self.translate.x(), self.translate.y())) painter.scale(1 / min_scale, 1 / min_scale) painter.save() matrix = img_data.matrix() painter.setWorldTransform(matrix, True) painter.drawImage(QPoint(0, 0), img) painter.restore() #pt_matrix = QTransform() #pt_matrix.scale(1/min_scale, 1/min_scale) #painter.setTransform(pt_matrix, True) cellColoring.startImage(painter, imageid) wallColoring.startImage(painter, imageid) for ed in extraDrawing: ed.startImage(painter, imageid) if self.result_type == "Growth": cells = result.cells[imageid] walls = result.walls[imageid] else: cells = img_data.cells walls = set() for cid in img_data.cells: pts = [pt for pt in data.cells[cid] if pt in img_data] if len(pts) > 1: for i in range(len(pts)): walls.add(data.wallId(pts[i - 1], pts[i])) # Now, draw the cells and the ellipsis for cid in cells: painter.setPen(Qt.NoPen) color = cellColoring(imageid, cid) painter.setBrush(color) pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1, p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1, p2]) ppts.append(ppts[0]) poly = QPolygonF(ppts) painter.drawPolygon(poly) # And draw the walls wallThickness = self.wallThickness * min_scale for wid in walls: color = wallColoring(imageid, wid) if color.alpha() > 0: pen = QPen(color) pen.setWidthF(wallThickness) painter.setPen(pen) pts = [img_data[wid[0]] ] + img_data.walls[wid[0], wid[1]] + [img_data[wid[1]]] #painter.drawLine(img_data[wid[0]], img_data[wid[1]]) painter.drawPolyline(*pts) # Then, draw the points pointSize = self.pointSize * min_scale pointLineColor = self.pointLineColor pointLineThickness = self.pointLineThickness * min_scale log_debug("pointSize = %g" % pointSize) for pid in img_data: color = pointColoring(imageid, pid) if color.alpha() > 0: pen = QPen(pointLineColor) pen.setWidthF(pointLineThickness) brush = QBrush(color) painter.setPen(pen) painter.setBrush(brush) pos = img_data[pid] rect = QRectF(pos.x() - pointSize, pos.y() - pointSize, 2 * pointSize, 2 * pointSize) painter.drawEllipse(rect) if ellipsisDraw.plot: for cid in cells: pts = data.cellAtTime(cid, img_data.index) if pts: pts.append(pts[0]) ppts = [] for p1, p2 in zip(pts[:-1], pts[1:]): ppts.append(img_data[p1]) ppts.extend(img_data.walls[p1, p2]) ppts.append(ppts[0]) #poly = QPolygonF(ppts) #painter.drawPolygon(poly) ellipsisDraw(painter, imageid, cid, ppts, min_scale) # At last, draw the extra data for ed in extraDrawing: ed(painter, imageid) tr = painter.worldTransform() painter.restore() pic_w = wallColoring.finalizeImage(painter, imageid, tr, self.crop) pic_c = cellColoring.finalizeImage(painter, imageid, tr, self.crop) for ed in extraDrawing: ed.finalizeImage(painter, imageid, tr, self.crop) painter.end() return pix, pic_w, pic_c
ph = 4 # char spacing sw = 6 sh = 20 # grid thickness 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
# configure the output image width = 800 height = 600 dpi = 92 img = QImage(QSize(width, height), QImage.Format_RGB32) img.setDotsPerMeterX(dpi / 25.4 * 1000) img.setDotsPerMeterY(dpi / 25.4 * 1000) # get the map layers and extent layers = [layer.id() for layer in iface.legendInterface().layers()] extent = iface.mapCanvas().extent() # configure map settings for export mapSettings = QgsMapSettings() mapSettings.setMapUnits(0) mapSettings.setExtent(extent) mapSettings.setOutputDpi(dpi) mapSettings.setOutputSize(QSize(width, height)) mapSettings.setLayers(layers) mapSettings.setFlags(QgsMapSettings.Antialiasing | QgsMapSettings.UseAdvancedEffects | QgsMapSettings.ForceVectorOutput | QgsMapSettings.DrawLabeling) # configure and run painter p = QPainter() p.begin(img) mapRenderer = QgsMapRendererCustomPainterJob(mapSettings, p) mapRenderer.start() mapRenderer.waitForFinished() p.end() # save the result img.save("C:/temp/custom_export.png", "png")
#legend_item = composition.getComposerItemById('legend') #legend_item.updateLegend() composition.refreshItems() dpmm = dpi / 25.4 #width = int(dpmm * composition.paperWidth()) width = int(1400) print(width) #height = int(dpmm * 141) height = int(1000) print(height) # create output image and initialize it image = QImage(QSize(width, height), QImage.Format_ARGB32) #image.setDotsPerMeterX(dpmm * 1000) #image.setDotsPerMeterY(dpmm * 1000) #image.fill(0) # set image's background color #color = QColor(255, 255, 255) # render the composition imagePainter = QPainter(image) composition.renderPage(imagePainter, 0) imagePainter.end() image.save("obraz_wyjsciowy.png", "png") QgsProject.instance().clear() QgsApplication.exitQgis()
def paintEvent(self, event): qp = QPainter() qp.begin(self) if self.image: qp.drawImage(QPoint(0, 0), self.image) qp.end()
def paintEvent(self, event): painter = QPainter(self) for onePixMap in self.lanePixmapList: painter.drawPixmap(onePixMap.x, onePixMap.y, onePixMap.pixmap) return
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) width = self.width() height = self.height() if self.dynamic_resize: knob_radius = self.dynamic_knob_radius else: knob_radius = self.knob_radius # ensure that the center point is in the middle of a pixel to ensure # that exact vertial and horizantal ticks are drawn exactly 1px wide x = math.floor(width / 2.0) + 0.5 y = math.floor(height / 2.0) + 0.5 if DEBUG: painter.fillRect(0, 0, width, height, Qt.yellow) painter.translate(x, y) if self.knob_style == KnobWidget.STYLE_NEEDLE: r = min(x, y) - 1 painter.setPen(Qt.white) painter.setBrush(Qt.white) painter.drawEllipse(QPoint(0, 0), r, r) angle = self.value_factor * self.total_angle - (self.total_angle / 2.0) # draw base knob or needle spike if self.knob_style == KnobWidget.STYLE_ROUND: painter.setPen(self.border_color) if self.pressed: gradient = QRadialGradient(0, 0, knob_radius) gradient.setColorAt(0, self.base_color_pressed) gradient.setColorAt(0.85, self.base_color) gradient.setColorAt(1, self.base_color) painter.setBrush(gradient) else: painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius) elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.save() painter.rotate(angle) painter.setPen(self.needle_color) painter.setBrush(self.needle_color) needle = QPolygonF() needle.append(QPointF(self.needle_base_radius * 0.6, 0)) needle.append(QPointF(0, -knob_radius)) needle.append(QPointF(-self.needle_base_radius * 0.6, 0)) painter.drawPolygon(needle) painter.restore() # draw knob mark or needle base if self.knob_style == KnobWidget.STYLE_ROUND: painter.save() painter.rotate(angle) painter.setPen(QPen(self.mark_color, 2)) painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8) painter.restore() elif self.knob_style == KnobWidget.STYLE_NEEDLE: painter.setPen(self.border_color) painter.setBrush(self.base_color) painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius) if self.scale_visible: painter.setPen(Qt.black) # draw scale arc if self.scale_arc_visible: painter.drawArc(-knob_radius - self.knob_to_scale, -knob_radius - self.knob_to_scale, knob_radius * 2 + self.knob_to_scale * 2, knob_radius * 2 + self.knob_to_scale * 2, (90 + self.total_angle / 2) * 16, -self.total_angle * 16) # draw scale ticks def value_to_angle(value): return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0) value = self.minimum_value while value <= self.maximum_value: angle = value_to_angle(value) painter.save() painter.rotate(value_to_angle(value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_large) if self.scale_text_visible: p = painter.worldTransform().map(QPoint(0, -knob_radius - \ self.knob_to_scale - \ self.tick_size_large - \ self.tick_to_text - \ self.text_radius)) painter.restore() if self.scale_text_visible: if DEBUG: painter.save() painter.setPen(QColor(255, 0, 0, 50)) painter.setBrush(QColor(255, 0, 0, 50)) painter.drawEllipse(QPoint(p.x() - x, p.y() - y), self.text_radius, self.text_radius) painter.restore() painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, str(value)) for i in range(1, self.scale_step_divisions): sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions if sub_value > self.maximum_value: break painter.save() painter.rotate(value_to_angle(sub_value)) painter.drawLine(0, -knob_radius - self.knob_to_scale, 0, -knob_radius - self.knob_to_scale - self.tick_size_small) painter.restore() value += self.scale_step_size if self.title_text != None: painter.drawText(-knob_radius, knob_radius - 30, knob_radius * 2, 60, Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter, self.title_text)
def paintEvent(self, event): painter = QPainter(self) painter.drawImage(QPoint(0, 0), self._image)
def paintEvent(self, event): debug("paintEvent(%s)", event) rect = event.rect() painter = QPainter(self) painter.drawPixmap(rect, self._backing._backing, rect)
def get_box(scene_info): mode = scene_info.mode box_color = scene_info.box_color box_type = scene_info.box_type speaking = scene_info.speaking speaker_id = scene_info.speaker headshot = scene_info.headshot chapter = scene_info.chapter if box_color != common.BOX_COLORS.yellow and box_color != common.BOX_COLORS.green and box_color != common.BOX_COLORS.blue: box_color = common.BOX_COLORS.yellow out = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) out.fill(QColor(0, 0, 0, 0).rgba()) painter = QPainter(out) painter.setRenderHint(QPainter.Antialiasing, True) # Some commonality between the boxes. box = QImage() button = QImage() nametag_x = 0 nametag_y = 0 nametag_color = QColor(255, 255, 255, 255) nametag_vert = False if box_type == common.BOX_TYPES.flat: box = QImage(os.path.join(TEXTBOX_DIR, "box_gray.png")) button = QImage(os.path.join(TEXTBOX_DIR, "button_%s.png" % box_color)) nametag_x = 10 nametag_y = 176 nametag_color = QColor(255, 255, 255, 255) nametag_vert = False elif box_type == common.BOX_TYPES.novel: box = QImage(os.path.join(TEXTBOX_DIR, "box_novel.png")) elif box_type == common.BOX_TYPES.normal: if mode == common.SCENE_MODES.normal: box = QImage(os.path.join(TEXTBOX_DIR, "box.png")) button = QImage( os.path.join(TEXTBOX_DIR, "button_%s.png" % box_color)) nametag_x = 0 nametag_y = 220 nametag_color = QColor(50, 50, 50, 255) nametag_vert = True if not box.format() is QImage.Format_ARGB32_Premultiplied: box = box.convertToFormat(QImage.Format_ARGB32_Premultiplied) box_painter = QPainter(box) box_painter.setRenderHint(QPainter.Antialiasing, True) if speaker_id == 0: # Main character gets a special text box. namebox = QImage( os.path.join(TEXTBOX_DIR, "name_%s_mc.png" % box_color)) else: namebox = QImage( os.path.join(TEXTBOX_DIR, "name_%s.png" % box_color)) box_painter.drawImage(box.rect(), namebox, namebox.rect()) box_painter.end() elif mode == common.SCENE_MODES.trial: box_base = QImage(os.path.join(TRIAL_DIR, "trial_box.png")) banner = QImage(os.path.join(TRIAL_DIR, "trial_banner.png")) if speaker_id == 0: # Main character gets a special text box. namebox = QImage(os.path.join(TRIAL_DIR, "trial_name_mc.png")) else: namebox = QImage(os.path.join(TRIAL_DIR, "trial_name.png")) if not headshot == None: case_num = QImage( os.path.join(TRIAL_DIR, "case_%02d.png" % chapter)) headshot = QImage( os.path.join(TRIAL_DIR, "headshot", "%02d.png" % headshot)) underlay = QImage(os.path.join(TRIAL_DIR, "trial_headshot.png")) else: case_num = QImage() underlay = QImage() headshot = QImage() button = QImage(os.path.join(TRIAL_DIR, "button.png")) nametag_x = 12 nametag_y = 168 nametag_color = QColor(255, 255, 255, 255) nametag_vert = False box = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) box.fill(QColor(0, 0, 0, 0).rgba()) box_painter = QPainter(box) box_painter.setRenderHint(QPainter.Antialiasing, True) box_painter.drawImage(box.rect(), banner, banner.rect()) box_painter.drawImage(box.rect(), namebox, namebox.rect()) box_painter.drawImage(box.rect(), box_base, box_base.rect()) box_painter.drawImage(box.rect(), underlay, underlay.rect()) box_painter.drawImage(box.rect(), headshot, headshot.rect()) box_painter.drawImage(box.rect(), case_num, case_num.rect()) box_painter.end() else: box = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) box.fill(QColor(0, 0, 0, 0).rgba()) painter.drawImage(out.rect(), box, box.rect()) painter.drawImage(out.rect(), button, button.rect()) if not speaker_id == None: nametag = get_nametag(speaker_id, nametag_x, nametag_y, nametag_color, nametag_vert) painter.drawImage(out.rect(), nametag, nametag.rect()) painter.end() return out
def paintEvent(self, e): # Test cercle rouge: paint = QPainter() paint.begin(self) paint.setRenderHint(QPainter.Antialiasing) radx = 10 rady = 10 # Dessine les ronds pour les tests paint.setPen(QtCore.Qt.black) # Reseau center = QtCore.QPoint(20, 20) if self.startTest == 0: paint.setBrush(QtCore.Qt.red) elif self.startTest > 0: paint.setBrush(QtCore.Qt.green) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(36, 26), u"Connexion réseau") # Carte if self.startTest > 1: paint.setBrush(QtCore.Qt.green) elif self.startTest == 1: paint.setBrush(QtCore.Qt.red) elif self.startTest < 1: paint.setBrush(QtGui.QColor(0, 0, 0, 0)) center = QtCore.QPoint(20, 50) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(36, 56), u"Connexion carte") # Imprimante if self.startTest > 2: paint.setBrush(QtCore.Qt.green) elif self.startTest == 2: paint.setBrush(QtCore.Qt.red) elif self.startTest < 2: paint.setBrush(QtGui.QColor(0, 0, 0, 0)) center = QtCore.QPoint(20, 80) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(36, 86), u"Présence imprimante") # Air if self.IOHandler.aircomprime == 1: paint.setBrush(QtCore.Qt.green) elif self.IOHandler.aircomprime == 0: paint.setBrush(QtCore.Qt.red) elif self.IOHandler.aircomprime == -1: paint.setBrush(QtGui.QColor(0, 0, 0, 0)) center = QtCore.QPoint(300, 20) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(316, 26), u"Présence air comprimé") # Ticket if self.IOHandler.etiquette == 1: paint.setBrush(QtCore.Qt.green) elif self.IOHandler.etiquette == 0: paint.setBrush(QtCore.Qt.red) center = QtCore.QPoint(300, 50) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(316, 56), u"Présence étiquette") # Faisceau if self.IOHandler.faisceau == 1: paint.setBrush(QtCore.Qt.green) elif self.IOHandler.faisceau == 0: paint.setBrush(QtCore.Qt.red) center = QtCore.QPoint(300, 80) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(316, 86), u"Présence faisceau") # Verin if self.IOHandler.verin == 1: paint.setBrush(QtCore.Qt.green) elif self.IOHandler.verin == 0: paint.setBrush(QtCore.Qt.red) center = QtCore.QPoint(510, 20) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(526, 26), u"Verrouillage faisceau") #asma # Etancheite if self.etanche1 == 1: paint.setBrush(QtCore.Qt.green) elif self.etanche1 == 0: paint.setBrush(QtCore.Qt.red) center = QtCore.QPoint(510, 50) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(526, 56), u"Etanchéité") # Info #if self.IOHandler.verin == 1: # paint.setBrush(QtCore.Qt.green) #elif self.IOHandler.verin == 0: paint.setBrush(QtCore.Qt.red) center = QtCore.QPoint(510, 80) paint.drawEllipse(center, radx, rady) paint.drawText(QtCore.QPoint(526, 86), u"Info") paint.drawText(QtCore.QPoint(516, 116), self.user) paint.end()
def draw_scene(scene_info, text=None): bg = None max_length = 0 kill_blanks = False if scene_info.mode in [ common.SCENE_MODES.normal, common.SCENE_MODES.normal_flat ]: bg = get_normal(scene_info) if scene_info.box_type == common.BOX_TYPES.flat: scene_info.mode = common.SCENE_MODES.normal_flat else: scene_info.mode = common.SCENE_MODES.normal elif scene_info.mode == common.SCENE_MODES.trial: bg = get_trial(scene_info) elif scene_info.mode == common.SCENE_MODES.novel: scene_info.box_type = common.BOX_TYPES.novel bg = get_normal(scene_info) elif scene_info.mode == common.SCENE_MODES.rules: bg = QImage(os.path.join(MENU_DIR, "rules.png")) elif scene_info.mode == common.SCENE_MODES.ammo: bg = QImage(os.path.join(MENU_DIR, "ammo-desc.png")) overlay = get_ammo(scene_info.file_id, 254, 117) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(bg) painter.setCompositionMode(QPainter.CompositionMode_DestinationOver) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() name = get_ammo_name(scene_info.file_id) if name: bg = print_text(bg, name, common.SCENE_MODES.ammoname, TEXT_FORMATS[common.SCENE_MODES.ammoname], False) elif scene_info.mode == common.SCENE_MODES.ammoname: bg = QImage(os.path.join(MENU_DIR, "ammo-list.png")) overlay = get_ammo(scene_info.file_id, 254, 61) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(bg) painter.setCompositionMode(QPainter.CompositionMode_DestinationOver) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() elif scene_info.mode == common.SCENE_MODES.present: bg = QImage(os.path.join(MENU_DIR, "present-desc.png")) overlay = get_present(scene_info.file_id, 248, 96) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(bg) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() name = get_present_name(scene_info.file_id) if name: bg = print_text(bg, name, common.SCENE_MODES.presentname, TEXT_FORMATS[common.SCENE_MODES.presentname], False) elif scene_info.mode == common.SCENE_MODES.presentname: bg = QImage(os.path.join(MENU_DIR, "present-list.png")) overlay = get_present(scene_info.file_id, 248, 46) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(bg) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() elif scene_info.mode == common.SCENE_MODES.menu: bg = QImage(os.path.join(MENU_DIR, "menu.png")) elif scene_info.mode == common.SCENE_MODES.report or scene_info.mode == common.SCENE_MODES.report2: bg = QImage(os.path.join(MENU_DIR, "report.png")) elif scene_info.mode == common.SCENE_MODES.skill or scene_info.mode == common.SCENE_MODES.skill2: bg = QImage(os.path.join(MENU_DIR, "skills.png")) elif scene_info.mode == common.SCENE_MODES.map: bg = QImage(os.path.join(MENU_DIR, "map.png")) elif scene_info.mode == common.SCENE_MODES.music: bg = QImage(os.path.join(MENU_DIR, "soundtest.png")) elif scene_info.mode in [ common.SCENE_MODES.eventname, common.SCENE_MODES.moviename, common.SCENE_MODES.artworkname ]: bg = QImage(os.path.join(MENU_DIR, "gallery.png")) if scene_info.mode == common.SCENE_MODES.eventname: overlay = get_event_icon(scene_info.file_id) elif scene_info.mode == common.SCENE_MODES.moviename: overlay = get_movie_icon(scene_info.file_id) elif scene_info.mode == common.SCENE_MODES.artworkname: overlay = get_artwork_icon(scene_info.file_id) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(bg) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() elif scene_info.mode == common.SCENE_MODES.theatre: bg = get_normal(scene_info) elif scene_info.mode == common.SCENE_MODES.debate or scene_info.mode == common.SCENE_MODES.hanron: bg = get_trial(scene_info, show_box=False) else: bg = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) bg.fill(QColor(0, 0, 0, 255).rgba()) if not bg.format() is QImage.Format_ARGB32_Premultiplied: bg = bg.convertToFormat(QImage.Format_ARGB32_Premultiplied) if scene_info.cutin != -1: cutin = get_cutin(scene_info.cutin) painter = QPainter(bg) painter.drawImage(bg.rect(), cutin, cutin.rect()) painter.end() if scene_info.ammo != -1: ammo = get_ammo_ingame(scene_info.ammo) painter = QPainter(bg) painter.drawImage(bg.rect(), ammo, ammo.rect()) painter.end() if scene_info.present != -1: present = get_present_ingame(scene_info.present) painter = QPainter(bg) painter.drawImage(bg.rect(), present, present.rect()) painter.end() if scene_info.special == common.SCENE_SPECIAL.option: overlay = QImage(os.path.join(TEXTBOX_DIR, "option_bar.png")) painter = QPainter(bg) painter.drawImage(bg.rect(), overlay, overlay.rect()) painter.end() if not text == None and not text == "": bg = print_text(bg, text, common.SCENE_SPECIAL.option, TEXT_FORMATS[common.SCENE_SPECIAL.option], False) if not text == None and not text == "": bg = print_text(bg, text, scene_info.mode, TEXT_FORMATS[scene_info.mode]) return bg
def draw_anagram(anagram): BOX_LEFT = 4 BOX_TOP = 22 BOX_X_OFFSET = 31 BOX_Y_OFFSET = 61 TEXT_X_OFFSET = 13 TEXT_Y_OFFSET = 9 TEXT_CLT = 8 FONT = CLT_STYLES[TEXT_CLT].font MAX_LETTERS = 15 BOX = QImage(os.path.join(ANAGRAM_DIR, "box.png")) QUESTION = QImage(os.path.join(ANAGRAM_DIR, "question.png")) out = QImage(os.path.join(ANAGRAM_DIR, "bg.png")) text = anagram.solution[common.editor_config.lang_trans] if len(text) == 0: return out if not out.format() is QImage.Format_ARGB32_Premultiplied: out = out.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(out) painter.setRenderHint(QPainter.Antialiasing, True) # Put them in a list so it's easier to loop. visible = [ range(1, len(text) + 1), anagram.easy, anagram.normal, anagram.hard ] x = BOX_LEFT y = BOX_TOP for row in range(len(visible)): if not visible[row] == None: for i, char in enumerate(text): if (i + 1) in visible[row]: painter.drawImage(QRect(x, y, BOX.width(), BOX.height()), BOX, BOX.rect()) # Get info on our current letter. letter, (xshift, yshift, final_w, final_h) = get_letter(TEXT_CLT, char) painter.drawImage( QRect(x + TEXT_X_OFFSET + xshift, y + TEXT_Y_OFFSET + yshift, final_w, final_h), letter, letter.rect()) else: painter.drawImage( QRect(x, y, QUESTION.width(), QUESTION.height()), QUESTION, QUESTION.rect()) x += BOX_X_OFFSET x = BOX_LEFT y += BOX_Y_OFFSET painter.end() return out
def print_text(image, text, scene_mode=common.SCENE_MODES.normal, format=TextFormat(), mangle=True): img_w = IMG_W img_h = IMG_H if image: img_w = image.width() img_h = image.height() out = QImage(img_w, img_h, QImage.Format_ARGB32_Premultiplied) out.fill(QColor(0, 0, 0, 0).rgba()) painter = QPainter(out) # This is a better representation of how the game handles text. painter.setCompositionMode(QPainter.CompositionMode_DestinationOver) painter.setRenderHint(QPainter.Antialiasing, True) lines, lengths, clt_changes = process_text(text, scene_mode, format, mangle) base_x = format.x base_y = format.y line_height = format.h x, y = base_x, base_y cur_clt = 0 text_height = len(lines) * line_height while text_height + y > img_h: y -= line_height center_x = format.x + (format.w / 2.0) right_x = format.x + format.w for i, line in enumerate(lines): # Only bother if we actually see the line. if y > -line_height and y < img_h: line_length = sum(lengths[i]) if format.orient == TEXT_ORIENT.hor: if format.align == TEXT_ALIGN.left: x = base_x elif format.align == TEXT_ALIGN.right: x = right_x - line_length elif format.align == TEXT_ALIGN.center: x = center_x - (line_length / 2.0) elif format.align == TEXT_ALIGN.offcenter: x = center_x - (line_length / 2.0) - 7 for j in range(len(line)): char = line[j] if j in clt_changes[i]: cur_clt = clt_changes[i][j] letter, (xshift, yshift, final_w, final_h) = get_letter(cur_clt, char) final_x = (x + xshift) final_y = (y + yshift) + max( 0, (line_height - final_h)) + CLT_STYLES[cur_clt].y_shift painter.drawImage(QRect(final_x, final_y, final_w, final_h), letter, letter.rect()) if format.orient == TEXT_ORIENT.hor: x += lengths[i][j] elif format.orient == TEXT_ORIENT.ver: y += lengths[i][j] if format.orient == TEXT_ORIENT.hor: y += line_height elif format.orient == TEXT_ORIENT.ver: y = base_y x -= line_height # And, last but not least, draw the image underneath everything. if image: painter.drawImage(out.rect(), image, image.rect()) painter.end() return out
def paintEvent(self, event): if self.schedule: paint = QPainter() paint.begin(self) paint.setPen(self.colors["axis"]) paint.setFont(QtGui.QFont('Decorative', 9 * self.scale)) procX = {} # Draw processor names and axis for i in range(self.proc): paint.drawImage( QRect(15 * self.scale, (10 + i * 20) * self.scale, 24 * self.scale, 24 * self.scale), self.procicon) paint.drawText(40 * self.scale, (25 + i * 20) * self.scale, str(self.schedule.processors[i].reserves)) plus = QRect(5 * self.scale, (10 + i * 20) * self.scale, 10 * self.scale, 10 * self.scale) paint.drawImage(plus, self.addicon) meenoos = QRect(5 * self.scale, (20 + i * 20) * self.scale, 10 * self.scale, 10 * self.scale) paint.drawImage(meenoos, self.delicon) self.procrects[self.schedule.processors[i]] = [plus, meenoos] paint.drawLine(50 * self.scale, (20 + i * 20) * self.scale, (50 + self.time * 10) * self.scale, (20 + i * 20) * self.scale) procX[self.schedule.processors[i].number] = 20 + i * 20 # Draw timeline tdir = self.method.system.tdir paint.drawLine(50 * self.scale, self.height() - 15, (50 + tdir * 10) * self.scale, self.height() - 15) paint.drawLine(50 * self.scale, 10 * self.scale, 50 * self.scale, self.height() - 10) t = 0 paint.setFont(QtGui.QFont('Decorative', 8)) while t < tdir + 10: paint.drawLine((50 + t * 10) * self.scale, self.height() - 20, (50 + t * 10) * self.scale, self.height() - 10) paint.drawText((50 + t * 10 + 1) * self.scale, self.height() - 5, str(t)) t += 10 paint.setPen(self.colors["select"]) paint.drawLine((50 + tdir * 10) * self.scale, 10 * self.scale, (50 + tdir * 10) * self.scale, self.height() - 10) if self.selectedTask: t = self.selectedTask start = self.method.interpreter.executionTimes[t][0] finish = self.method.interpreter.executionTimes[t][1] paint.drawText((50 + start * 10) * self.scale, self.height() - 16, str(start)) paint.drawText((50 + finish * 10) * self.scale, self.height() - 16, str(finish)) # Draw tasks paint.setPen(self.colors["task"]) paint.setFont(QtGui.QFont('Decorative', 9 * self.scale)) self.vertices = {} self.positions = {} for m in self.schedule.vertices.keys(): i = 0 prev = None for t in self.schedule.vertices[m]: start = self.method.interpreter.executionTimes[t][0] finish = self.method.interpreter.executionTimes[t][1] task = QtCore.QRect((50 + start * 10) * self.scale, (procX[t.m.number] - 5) * self.scale, (finish - start) * 10 * self.scale, 10 * self.scale) # TODO: calculate once! self.vertices[t] = task if i == 0: self.positions[(m, i)] = QtCore.QRect( QPoint(50 * self.scale, task.y()), task.bottomLeft()) else: self.positions[(m, i)] = QtCore.QRect( prev.topRight(), task.bottomLeft()) if t != self.selectedTask: paint.fillRect(task, self.colors["task"]) else: paint.fillRect(task, self.colors["select"]) if self.schedule.CanAddVersions(t): self.addrect = QRect(task.topLeft().x(), task.topLeft().y(), 10 * self.scale, 10 * self.scale) paint.drawImage(self.addrect, self.addicon) if self.schedule.CanDeleteVersions(t): self.delrect = QRect( task.topRight().x() - 10 * self.scale, task.topRight().y(), 10 * self.scale, 10 * self.scale) paint.drawImage(self.delrect, self.delicon) paint.setPen(self.colors["axis"]) paint.drawRect(task) paint.setPen(self.colors["task"]) prev = task i += 1 self.positions[(m, i)] = QtCore.QRect( prev.topRight(), QPoint(prev.topRight().x() + 100, prev.bottomRight().y())) if self.targetPos: width = min(self.selectedTask.v.time * 10 * self.scale, self.positions[self.targetPos].width()) rect = QtCore.QRect(self.positions[self.targetPos]) rect.setWidth(width) paint.fillRect(rect, self.colors["select"]) # Draw deliveries paint.setPen(QPen(self.colors["delivery"], 2)) for d in self.method.interpreter.deliveryTimes: self.drawArrow(paint, (50 + d[2] * 10) * self.scale, procX[d[0].number] * self.scale, (50 + d[3] * 10) * self.scale, procX[d[1].number] * self.scale) # Draw captions paint.setPen(self.colors["axis"]) for m in self.schedule.vertices.keys(): for t in self.schedule.vertices[m]: start = self.method.interpreter.executionTimes[t][0] finish = self.method.interpreter.executionTimes[t][1] s = str(t.v.number) if t.k.number > 1: s += " v" + str(t.k.number) paint.drawText((10 + finish + start - int(len(s) / 2)) * 5 * self.scale, (procX[t.m.number] + 5) * self.scale, s) paint.end()
def paintEvent(self, event): painter = QPainter(self) painter.drawPixmap(0, 0, 10, 23, self.__pic_bg, 25, 70, 10, 23) painter.drawPixmap(10, 0, self.width() - 20, 23, self.__pic_bg, 35, 70, 1, 23) painter.drawPixmap(self.width() - 10, 0, 10, 23, self.__pic_bg, 36, 70, 10, 23)
def paintEvent(self, event): """ A custom paint event handler which draws the image according to the current size constraints. """ pixmap = self._pixmap if pixmap is None: return pm_size = pixmap.size() pm_width = pm_size.width() pm_height = pm_size.height() if pm_width == 0 or pm_height == 0: return # Use the widget rect instead of the event rect so the image # paints properly in a scroll area where it may be clipped. evt_rect = self.rect() evt_x = evt_rect.x() evt_y = evt_rect.y() evt_width = evt_rect.width() evt_height = evt_rect.height() if not self._scaled_contents: # If the image isn't scaled, it is centered if possible. # Otherwise, it's painted at the origin and clipped. paint_x = max(0, int((evt_width / 2. - pm_width / 2.) + evt_x)) paint_y = max(0, int((evt_height / 2. - pm_height / 2.) + evt_y)) paint_width = pm_width paint_height = pm_height else: # If the image *is* scaled, it's scaled size depends on the # size of the paint area as well as the other scaling flags. if self._preserve_aspect_ratio: pm_ratio = float(pm_width) / pm_height evt_ratio = float(evt_width) / evt_height if evt_ratio >= pm_ratio: if self._allow_upscaling: paint_height = evt_height else: paint_height = min(pm_height, evt_height) paint_width = int(paint_height * pm_ratio) else: if self._allow_upscaling: paint_width = evt_width else: paint_width = min(pm_width, evt_width) paint_height = int(paint_width / pm_ratio) else: if self._allow_upscaling: paint_height = evt_height paint_width = evt_width else: paint_height = min(pm_height, evt_height) paint_width = min(pm_width, evt_width) # In all cases of scaling, we know that the scaled image is # no larger than the paint area, and can thus be centered. paint_x = int((evt_width / 2. - paint_width / 2.) + evt_x) paint_y = int((evt_height / 2. - paint_height / 2.) + evt_y) # Finally, draw the pixmap into the calculated rect. painter = QPainter(self) painter.setRenderHint(QPainter.SmoothPixmapTransform) painter.drawPixmap(paint_x, paint_y, paint_width, paint_height, pixmap)
def paintInfoColumn(self, painter, option, index, width_limit=0): left = option.rect.left() + 3 top = option.rect.top() width = option.rect.width() - width_limit pixmap = QPixmap(option.rect.size()) pixmap.fill(Qt.transparent) p = QPainter(pixmap) p.setRenderHint(QPainter.Antialiasing, True) p.translate(-option.rect.topLeft()) textInner = 2 * ICON_PADDING + ROW_HEIGHT - 10 itemHeight = ROW_HEIGHT + 2 * ICON_PADDING margin = left + ICON_PADDING - 10 title = index.model().data(index, NameRole).toString() summary = index.model().data(index, SummaryRole).toString() ptype = str(index.model().data(index, TypeRole).toString()) rate = int(index.model().data(index, RateRole).toInt()[0]) installed = index.model().data(index, InstalledRole).toBool() # We need to request update if its not possible to get meta data about the package try: # Get Package Icon if exists _icon = index.model().data(index, Qt.DecorationRole).toString() except: p.end() painter.drawPixmap(option.rect.topLeft(), pixmap) self.parent.requestUpdate() return icon = None if _icon: overlay = [CHECK_ICON] if installed else [] KIconLoader._forceCache = True pix = KIconLoader.loadOverlayed(_icon, overlay, 32) if not pix.isNull(): icon = QIcon( pix.scaled(QSize(32, 32), Qt.KeepAspectRatio, Qt.SmoothTransformation)) KIconLoader._forceCache = False if not icon: icon = self.defaultIcon if not installed else self.defaultInstalledIcon # Paint the Icon icon.paint(p, margin, top + ICON_PADDING, ROW_HEIGHT, ROW_HEIGHT, Qt.AlignCenter) fix_pos = 0 if index.model().columnCount() <= 1: fix_pos = 22 if config.USE_APPINFO: # Rating Stars for _rt_i in range(5): self._rt_0.paint(p, width + 10 * _rt_i - 30 - fix_pos, top + ROW_HEIGHT / 4, 10, 10, Qt.AlignCenter) for _rt_i in range(rate): self._rt_1.paint(p, width + 10 * _rt_i - 30 - fix_pos, top + ROW_HEIGHT / 4, 10, 10, Qt.AlignCenter) foregroundColor = option.palette.color(QPalette.Text) p.setPen(foregroundColor) # Package Name p.setFont(self.boldFont) p.drawText(left + textInner, top, width - textInner, itemHeight / 2, Qt.AlignBottom | Qt.AlignLeft, title) tagWidth = 0 _component_width = 0 if self.parent.showComponents: component = str(index.model().data(index, ComponentRole).toString()) widthOfTitle = self.boldFontFM.width(title) + 6 + left + textInner p.setFont(self.tagFont) rect = self.tagFontFM.boundingRect(option.rect, Qt.TextWordWrap, component) p.setPen(LIGHTGREEN) p.setBrush(LIGHTGREEN) p.drawRoundRect(widthOfTitle, top + 12, rect.width() + 4, rect.height(), 10, 10) p.setPen(DARKGREEN) p.drawText(widthOfTitle + 2, top + 12, rect.width(), rect.height(), Qt.AlignCenter, component) p.setPen(foregroundColor) _component_width = rect.width() + 8 if self.parent.showIsA: isa = str(index.model().data(index, IsaRole).toString()) if not isa == '': widthOfTitle = self.boldFontFM.width( title) + 6 + left + textInner + _component_width p.setFont(self.tagFont) rect = self.tagFontFM.boundingRect(option.rect, Qt.TextWordWrap, isa) p.setPen(LIGHTBLUE) p.setBrush(LIGHTBLUE) p.drawRoundRect(widthOfTitle, top + 12, rect.width() + 4, rect.height(), 10, 10) p.setPen(DARKVIOLET) p.drawText(widthOfTitle + 2, top + 12, rect.width(), rect.height(), Qt.AlignCenter, isa) p.setPen(foregroundColor) _component_width += rect.width() + 8 if ptype not in ('None', 'normal'): widthOfTitle = self.boldFontFM.width( title) + 6 + left + textInner + _component_width p.setFont(self.tagFont) rect = self.tagFontFM.boundingRect(option.rect, Qt.TextWordWrap, self.types[ptype][1]) p.setPen(self.types[ptype][0]) p.setBrush(self.types[ptype][0]) p.drawRoundRect(widthOfTitle, top + 12, rect.width() + 4, rect.height(), 10, 10) p.setPen(WHITE) p.drawText(widthOfTitle + 2, top + 12, rect.width(), rect.height(), Qt.AlignCenter, self.types[ptype][1]) p.setPen(foregroundColor) tagWidth = rect.width() # Package Summary p.setFont(self.normalFont) foregroundColor.setAlpha(160) p.setPen(foregroundColor) elided_summary = self.normalFontFM.elidedText( summary, Qt.ElideRight, width - textInner - tagWidth - 22) p.drawText(left + textInner, top + itemHeight / 2, width - textInner, itemHeight / 2, Qt.TextDontClip, elided_summary) foregroundColor.setAlpha(255) p.setPen(foregroundColor) buttonStyle = None if self.rowAnimator.currentRow() == index.row(): description = index.model().data(index, DescriptionRole).toString() size = index.model().data(index, SizeRole).toString() homepage = index.model().data(index, HomepageRole).toString() installedVersion = str(index.model().data( index, InstalledVersionRole).toString()) version = index.model().data(index, VersionRole) # Package Detail Label position = top + ROW_HEIGHT p.setFont(self.normalDetailFont) baseRect = QRect(left, position, width - 8, option.rect.height()) rect = self.normalDetailFontFM.boundingRect( baseRect, Qt.TextWordWrap | Qt.TextDontClip, description) p.drawText(left + 2, position, width - 8, rect.height(), Qt.TextWordWrap | Qt.TextDontClip, description) # Package Detail Homepage position += rect.height() + 4 p.setFont(self.boldDetailFont) p.drawText(left + ICON_SIZE, position, width - textInner, itemHeight / 2, Qt.AlignLeft, self._titles['website']) p.setFont(self.normalDetailFont) homepage = self.normalDetailFontFM.elidedText( homepage, Qt.ElideRight, width - self._titleFM['website']) rect = self.normalDetailFontFM.boundingRect( option.rect, Qt.TextSingleLine, homepage) self.rowAnimator.hoverLinkFilter.link_rect = QRect( left + self._titleFM['website'] + 2, position + 2 + 32, rect.width(), rect.height()) p.setPen(option.palette.color(QPalette.Link)) p.drawText(left + self._titleFM['website'], position, width, rect.height(), Qt.TextSingleLine, homepage) p.setPen(foregroundColor) # Package Detail Version position += rect.height() p.setFont(self.boldDetailFont) p.drawText(left + ICON_SIZE, position, width - textInner, itemHeight / 2, Qt.AlignLeft, self._titles['release']) p.setFont(self.normalDetailFont) rect = self.normalDetailFontFM.boundingRect( option.rect, Qt.TextWordWrap, version.toString()) p.drawText(left + self._titleFM['release'], position, width, rect.height(), Qt.TextWordWrap, version.toString()) if not installedVersion == '': position += rect.height() p.setFont(self.boldDetailFont) p.drawText(left + ICON_SIZE, position, width - textInner, itemHeight / 2, Qt.AlignLeft, self._titles['installVers']) p.setFont(self.normalDetailFont) rect = self.normalDetailFontFM.boundingRect( option.rect, Qt.TextWordWrap, installedVersion) p.drawText(left + self._titleFM['installVers'], position, width, rect.height(), Qt.TextWordWrap, installedVersion) # Package Detail Repository repository = index.model().data(index, RepositoryRole).toString() if not repository == '': repository = i18n( 'Unknown') if repository == 'N/A' else repository position += rect.height() p.setFont(self.boldDetailFont) p.drawText(left + ICON_SIZE, position, width - textInner, itemHeight / 2, Qt.AlignLeft, self._titles['repository']) p.setFont(self.normalDetailFont) p.drawText(left + self._titleFM['repository'], position, width, itemHeight / 2, Qt.TextWordWrap, repository) # Package Detail Size position += rect.height() p.setFont(self.boldDetailFont) p.drawText(left + ICON_SIZE, position, width - textInner, itemHeight / 2, Qt.AlignLeft, self._titles['size']) p.setFont(self.normalDetailFont) p.drawText(left + self._titleFM['size'], position, width, itemHeight / 2, Qt.TextWordWrap, size) position += rect.height() self.rowAnimator.max_height = position - top + 8 # Package More info button opt = QStyleOptionViewItemV4(option) buttonStyle = QStyleOptionButton() if option.state & QStyle.State_MouseOver or option.state & QStyle.State_HasFocus: buttonStyle.state |= QStyle.State_HasFocus buttonStyle.state |= QStyle.State_Enabled buttonStyle.text = i18n("Details") buttonStyle.rect = QRect(width - 100, position - 22, 100, 22) p.end() # FIXME # if option.state & QStyle.State_HasFocus and self.animatable: # option.state |= QStyle.State_MouseOver # Use Plastique style to draw focus rect like MouseOver effect of Oxygen. # self.plastik.drawPrimitive(QStyle.PE_FrameLineEdit, option, painter, None) if not self.rowAnimator.running() and buttonStyle: if self.show_details_button and (installed or config.USE_APPINFO): PackageDelegate.AppStyle().drawControl(QStyle.CE_PushButton, buttonStyle, painter, None) self.rowAnimator.hoverLinkFilter.button_rect = QRect( buttonStyle.rect) painter.drawPixmap(option.rect.topLeft(), pixmap) del pixmap
def renderedImage(self, width, height, extent, transp_background=False, layerids=None): if QGis.QGIS_VERSION_INT < 20700: return self._renderedImage2(width, height, extent, transp_background, layerids) # render layers with QgsMapRendererCustomPainterJob from qgis.core import QgsMapRendererCustomPainterJob antialias = True settings = self.exportSettings.mapSettings # store old map settings old_outputSize = settings.outputSize() old_extent = settings.extent() old_rotation = settings.rotation() old_layerids = settings.layers() old_backgroundColor = settings.backgroundColor() # map settings settings.setOutputSize(QSize(width, height)) settings.setExtent(extent.unrotatedRect()) settings.setRotation(extent.rotation()) if layerids is not None: settings.setLayers(layerids) if transp_background: settings.setBackgroundColor(QColor(Qt.transparent)) #else: #TODO: remove #settings.setBackgroundColor(self.exportSettings.canvas.canvasColor()) has_pluginlayer = False for layerId in settings.layers(): layer = QgsMapLayerRegistry.instance().mapLayer(layerId) if layer and layer.type() == QgsMapLayer.PluginLayer: has_pluginlayer = True break # create an image image = QImage(width, height, QImage.Format_ARGB32_Premultiplied) painter = QPainter() painter.begin(image) if antialias: painter.setRenderHint(QPainter.Antialiasing) # rendering job = QgsMapRendererCustomPainterJob(settings, painter) if has_pluginlayer: job.renderSynchronously( ) # use this method so that TileLayerPlugin layer is rendered correctly else: job.start() job.waitForFinished() painter.end() # restore map settings settings.setOutputSize(old_outputSize) settings.setExtent(old_extent) settings.setRotation(old_rotation) settings.setLayers(old_layerids) settings.setBackgroundColor(old_backgroundColor) return tools.base64image(image)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setOpacity(self.pixmap_opacity) painter.drawPixmap(0, 0, self.old_pixmap) painter.end()
def onPlotButton(self): """ Batch plots selected geometry items using the selected template and scale. """ # check if one layer is selected if self.ui.LayersComboBox.currentIndex() == -1: QMessageBox.warning(self, tr("Warning"), tr("Select a layer!")) self.ui.LayersComboBox.setFocus() return # check if one composition template is selected if self.ui.TemplateList.selectedItems() == []: QMessageBox.warning(self, tr("Warning"), tr("Select a composer template!")) self.ui.TemplateList.setFocus() return template_filename = QDir(self.templatepath).absoluteFilePath( self.ui.TemplateList.currentItem().text()) # get the scale if self.ui.ScaleCombo.currentText() == "<extent>": scale = -1 else: try: scale = int(self.ui.ScaleCombo.currentText()) except (ValueError): QMessageBox.warning( self, tr("Warning"), tr("Scale must be a positive integer value!")) self.ui.ScaleCombo.setFocus() return if scale <= 0: QMessageBox.warning( self, tr("Warning"), tr("Scale must be a positive integer value!")) self.ui.ScaleCombo.setFocus() return # get composer name composer_name = self.ui.ComposerEdit.text() #check if there are selected items on polygon layers if self.batch_plotting: selected_layer = self.ui.LayersComboBox.itemData( self.ui.LayersComboBox.currentIndex()) selected_polygons = get_features(selected_layer.name(), QGis.Polygon, True) if selected_polygons is None: QMessageBox.warning( self, tr("Warning"), tr("Select at least one polygon on layer '%s'!" % selected_layer.name())) return # check output setting if self.ui.OutputTab.currentIndex() == 0: # to PDF if not self.ui.SingleFileCheckbox.checkState(): if len(self.ui.OutputPDFEdit.text()) == 0: res = QMessageBox.warning( self, tr("Warning"), tr("The filename pattern is empty. A default one will be used." ), QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Ok) if res == QMessageBox.Cancel: return self.ui.OutputPDFEdit.setText( QgsAtlasComposition(None).filenamePattern()) elif self.ui.OutputTab.currentIndex() == 1: # to Printer # no need for checking pass elif self.ui.OutputTab.currentIndex() == 2: # to Composer View # no need for checking yet pass # get map renderer of map canvas renderer = self.iface.mapCanvas().mapRenderer() self.composition = QgsComposition(renderer) # if plot to Composer View the composition must be set # before loading the template # otherwise composer's item properties doesn't appear if self.ui.OutputTab.currentIndex() == 2: # to Composer View if len(composer_name) == 0: composer = self.iface.createNewComposer() else: composer = self.iface.createNewComposer(composer_name) composer.setComposition(self.composition) # read template file and add to composition template_file = QFile(template_filename) template_file.open(QIODevice.ReadOnly | QIODevice.Text) template_content = template_file.readAll() template_file.close() document = QDomDocument() document.setContent(template_content) self.composition.loadFromTemplate(document) # if batch_plotting is True create an atlas composition if self.batch_plotting: # get composer map item and set new scale and the grid cmap = self.composition.getComposerMapById(0) cmap.setNewScale(scale) cmap.setGridIntervalX(scale / 10) cmap.setGridIntervalY(scale / 10) cmap.setAtlasDriven(True) cmap.setAtlasScalingMode(QgsComposerMap.Fixed) # set atlas composition parameters atlas = self.composition.atlasComposition() atlas.setEnabled(True) atlas.setCoverageLayer(selected_layer) atlas.setHideCoverage(False) atlas.setFilenamePattern(self.ui.OutputPDFEdit.text()) atlas.setSingleFile(self.ui.SingleFileCheckbox.checkState()) atlas.setSortFeatures(False) atlas.setFilterFeatures(True) selected_ids = [f.id() for f in selected_layer.selectedFeatures()] filter_id_string = ','.join([str(sid) for sid in selected_ids]) atlas.setFeatureFilter("$id in (" + filter_id_string + ")") # print the complete atlas composition if self.ui.OutputTab.currentIndex() == 0: # to PDF self.composition.setAtlasMode(QgsComposition.ExportAtlas) if self.pdfpath == "": self.pdfpath = QgsProject.instance().homePath().encode( sys.getfilesystemencoding()) if self.ui.SingleFileCheckbox.checkState(): #print to single pdf (multi-page) outputFileName = QDir( self.pdfpath).absoluteFilePath("qgis.pdf") outputFileName = QFileDialog.getSaveFileName( self, tr("Choose a file name to save the map as"), outputFileName, tr("PDF Format") + " (*.pdf *.PDF)") if not outputFileName: return if not outputFileName.lower().endswith(".pdf"): outputFileName += ".pdf" self.pdfpath = QDir(outputFileName).absolutePath() else: #print to more pdf outputDir = QFileDialog.getExistingDirectory( self, tr("Directory where to save PDF files"), self.pdfpath, QFileDialog.ShowDirsOnly) if not outputDir: return # test directory (if it exists and is writable) if not QDir(outputDir).exists() or not QFileInfo( outputDir).isWritable(): QMessageBox.warning( self, tr("Unable to write into the directory"), tr("The given output directory is not writable. Cancelling." )) return self.pdfpath = outputDir printer = QPrinter() painter = QPainter() if not len(atlas.featureFilterErrorString()) == 0: QMessageBox.warning( self, tr("Atlas processing error"), tr("Feature filter parser error: %s" % atlas.featureFilterErrorString())) return atlas.beginRender() if self.ui.SingleFileCheckbox.checkState(): #prepare for first feature, so that we know paper size to begin with atlas.prepareForFeature(0) self.composition.beginPrintAsPDF(printer, outputFileName) # set the correct resolution self.composition.beginPrint(printer) printReady = painter.begin(printer) if not printReady: QMessageBox.warning( self, tr("Atlas processing error"), tr("Error creating %s." % outputFileName)) return progress = QProgressDialog(tr("Rendering maps..."), tr("Abort"), 0, atlas.numFeatures(), self) QApplication.setOverrideCursor(Qt.BusyCursor) for featureI in range(0, atlas.numFeatures()): progress.setValue(featureI + 1) # process input events in order to allow aborting QCoreApplication.processEvents() if progress.wasCanceled(): atlas.endRender() break if not atlas.prepareForFeature(featureI): QMessageBox.warning(self, tr("Atlas processing error"), tr("Atlas processing error")) progress.cancel() QApplication.restoreOverrideCursor() return if not self.ui.SingleFileCheckbox.checkState(): multiFilePrinter = QPrinter() outputFileName = QDir(outputDir).filePath( atlas.currentFilename()) + ".pdf" self.composition.beginPrintAsPDF( multiFilePrinter, outputFileName) # set the correct resolution self.composition.beginPrint(multiFilePrinter) printReady = painter.begin(multiFilePrinter) if not printReady: QMessageBox.warning( self, tr("Atlas processing error"), tr("Error creating %s." % outputFileName)) progress.cancel() QApplication.restoreOverrideCursor() return self.composition.doPrint(multiFilePrinter, painter) painter.end() else: # start print on a new page if we're not on the first feature if featureI > 0: printer.newPage() self.composition.doPrint(printer, painter) atlas.endRender() if self.ui.SingleFileCheckbox.checkState(): painter.end() QApplication.restoreOverrideCursor() elif self.ui.OutputTab.currentIndex() == 1: # to Printer # if To Printer is selected set the printer # setting up printer if self.printer is None: self.printer = QPrinter() self.printer.setFullPage(True) self.printer.setColorMode(QPrinter.Color) # open printer setting dialog pdlg = QPrintDialog(self.printer, self) pdlg.setModal(True) pdlg.setOptions(QAbstractPrintDialog.None) if not pdlg.exec_() == QDialog.Accepted: return QApplication.setOverrideCursor(Qt.BusyCursor) #prepare for first feature, so that we know paper size to begin with self.composition.setAtlasMode(QgsComposition.ExportAtlas) atlas.prepareForFeature(0) # set orientation if self.composition.paperWidth( ) > self.composition.paperHeight(): self.printer.setOrientation(QPrinter.Landscape) self.printer.setPaperSize( QSizeF(self.composition.paperHeight(), self.composition.paperWidth()), QPrinter.Millimeter) else: self.printer.setOrientation(QPrinter.Portrait) self.printer.setPaperSize( QSizeF(self.composition.paperWidth(), self.composition.paperHeight()), QPrinter.Millimeter) self.printer.setResolution(self.composition.printResolution()) self.composition.beginPrint(self.printer) painter = QPainter(self.printer) if not len(atlas.featureFilterErrorString()) == 0: QMessageBox.warning( self, tr("Atlas processing error"), tr("Feature filter parser error: %s" % atlas.featureFilterErrorString())) QApplication.restoreOverrideCursor() return atlas.beginRender() progress = QProgressDialog(tr("Rendering maps..."), tr("Abort"), 0, atlas.numFeatures(), self) for featureI in range(0, atlas.numFeatures()): progress.setValue(featureI + 1) # process input events in order to allow cancelling QCoreApplication.processEvents() if progress.wasCanceled(): atlas.endRender() break if not atlas.prepareForFeature(featureI): QMessageBox.warning(self, tr("Atlas processing error"), tr("Atlas processing error")) progress.cancel() QApplication.restoreOverrideCursor() return # start print on a new page if we're not on the first feature if featureI > 0: self.printer.newPage() self.composition.doPrint(self.printer, painter) atlas.endRender() painter.end() QApplication.restoreOverrideCursor() elif self.ui.OutputTab.currentIndex() == 2: # to Composer View # create new composer self.composition.setAtlasMode(QgsComposition.PreviewAtlas) composer.composerWindow().on_mActionAtlasPreview_triggered( True) atlas.parameterChanged.emit() # Increase the reference count of the composer object # for not being garbage collected. # If not doing this composer would lost reference and qgis would crash # when referring to this composer object or at quit. ctypes.c_long.from_address(id(composer)).value += 1 else: # if batch_plotting is False open a QgsComposerView with current map canvas cmap = self.composition.getComposerMapById(0) # set the new extent of composer map item newextent = self.iface.mapCanvas().mapRenderer().extent() currentextent = cmap.extent() canvas_ratio = newextent.width() / newextent.height() map_ratio = currentextent.width() / currentextent.height() if map_ratio < canvas_ratio: dh = newextent.width() / map_ratio - newextent.height() newextent.setYMinimum(newextent.yMinimum() - dh / 2) newextent.setYMaximum(newextent.yMaximum() + dh / 2) else: dw = map_ratio * newextent.height() - newextent.width() newextent.setXMinimum(newextent.xMinimum() - dw / 2) newextent.setXMaximum(newextent.xMaximum() + dw / 2) cmap.setNewExtent(newextent) # set the new scale of composer map item if scale > 0: cmap.setNewScale(scale) sc = cmap.scale() # set the grid interval according to the scale cmap.setGridIntervalX(sc / 10) cmap.setGridIntervalY(sc / 10) # Increase the reference count of the composer object # for not being garbage collected. # If not doing this composer would lost reference and qgis would crash # when referring to this composer object or at quit. ctypes.c_long.from_address(id(composer)).value += 1 self.accept()
def paintEvent(self, event): painter = QPainter(self) painter.drawImage(event.rect(), self._background_image, event.rect())
def paintEvent(self, e): qp = QPainter() qp.begin(self) self.plot_survey(qp) qp.end()
def paintEvent(self, event): painter = QPainter(self) if self.icon is not None: x = (self.width() - self.icon.width()) / 2 y = (self.height() - self.icon.height()) / 2 painter.drawPixmap(x, y, self.icon)
def atlas_renderer(composition, coverage_layer, output_path, file_format): """Extract composition using atlas generation. :param composition: QGIS Composition object used for producing the report. :type composition: qgis.core.QgsComposition :param coverage_layer: Coverage Layer used for atlas map. :type coverage_layer: QgsMapLayer :param output_path: The output path of the product. :type output_path: str :param file_format: File format of map output, 'pdf' or 'png'. :type file_format: str :return: Generated output path(s). :rtype: str, list """ # set the composer map to be atlas driven composer_map = composition_item(composition, 'impact-map', QgsComposerMap) composer_map.setAtlasDriven(True) composer_map.setAtlasScalingMode(QgsComposerMap.Auto) # setup the atlas composition and composition atlas mode atlas_composition = composition.atlasComposition() atlas_composition.setCoverageLayer(coverage_layer) atlas_composition.setComposerMap(composer_map) atlas_composition.prepareMap(composer_map) atlas_on_single_file = atlas_composition.singleFile() composition.setAtlasMode(QgsComposition.ExportAtlas) if file_format == QgisComposerComponentsMetadata.OutputFormat.PDF: if not atlas_composition.filenamePattern(): atlas_composition.setFilenamePattern( "'output_'||@atlas_featurenumber") output_directory = os.path.dirname(output_path) printer = QPrinter(QPrinter.HighResolution) painter = QPainter() # we need to set the predefined scales for atlas project_scales = [] scales = QgsProject.instance().readListEntry("Scales", "/ScalesList")[0] has_project_scales = QgsProject.instance().readBoolEntry( "Scales", "/useProjectScales")[0] if not has_project_scales or not scales: scales_string = str(general_setting("Map/scales", PROJECT_SCALES)) scales = scales_string.split(',') for scale in scales: parts = scale.split(':') if len(parts) == 2: project_scales.append(float(parts[1])) atlas_composition.setPredefinedScales(project_scales) if not atlas_composition.beginRender() and ( atlas_composition.featureFilterErrorString()): msg = 'Atlas processing error: {error}'.format( error=atlas_composition.featureFilterErrorString()) LOGGER.error(msg) return if atlas_on_single_file: atlas_composition.prepareForFeature(0) composition.beginPrintAsPDF(printer, output_path) composition.beginPrint(printer) if not painter.begin(printer): msg = ('Atlas processing error: ' 'Cannot write to {output}.').format(output=output_path) LOGGER.error(msg) return LOGGER.info('Exporting Atlas') atlas_output = [] for feature_index in range(atlas_composition.numFeatures()): if not atlas_composition.prepareForFeature(feature_index): msg = ('Atlas processing error: Exporting atlas error at ' 'feature number {index}').format(index=feature_index) LOGGER.error(msg) return if not atlas_on_single_file: # we need another printer object fot multi file atlas multi_file_printer = QPrinter(QPrinter.HighResolution) current_filename = atlas_composition.currentFilename() output_path = os.path.join(output_directory, current_filename + '.pdf') composition.beginPrintAsPDF(multi_file_printer, output_path) composition.beginPrint(multi_file_printer) if not painter.begin(multi_file_printer): msg = ('Atlas processing error: Cannot write to ' '{output}.').format(output=output_path) LOGGER.error(msg) return composition.doPrint(multi_file_printer, painter) painter.end() composition.georeferenceOutput(output_path) atlas_output.append(output_path) else: composition.doPrint(printer, painter, feature_index > 0) atlas_composition.endRender() if atlas_on_single_file: painter.end() return output_path return atlas_output
def paintEvent(self, event=None): LogicalSize = 100.0 def logicalFromPhysical(length, side): return (length / side) * LogicalSize fm = QFontMetricsF(self.font()) ymargin = ( (LogicalSize / 30.0) + logicalFromPhysical(self.leftSpinBox.height(), self.height())) ymax = (LogicalSize - logicalFromPhysical(fm.height() * 2, self.height())) width = LogicalSize / 4.0 cx, cy = LogicalSize / 2.0, LogicalSize / 3.0 ax, ay = cx - (2 * width), ymargin bx, by = cx - width, ay dx, dy = cx + width, ay ex, ey = cx + (2 * width), ymargin fx, fy = cx + (width / 2), cx + (LogicalSize / 24.0) gx, gy = fx, ymax hx, hy = cx - (width / 2), ymax ix, iy = hx, fy painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) side = min(self.width(), self.height()) painter.setViewport((self.width() - side) / 2, (self.height() - side) / 2, side, side) painter.setWindow(0, 0, LogicalSize, LogicalSize) painter.setPen(Qt.NoPen) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) a = self.leftSpinBox.value() gradient.setColorAt(1, (Qt.red if a != 0 else Qt.white)) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([ax, ay, bx, by, cx, cy, ix, iy])) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) b = self.rightSpinBox.value() gradient.setColorAt(1, (Qt.blue if b != 0 else Qt.white)) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([cx, cy, dx, dy, ex, ey, fx, fy])) if (a + b) == 0: color = QColor(Qt.white) else: ashare = (a / (a + b)) * 255.0 bshare = 255.0 - ashare color = QColor(ashare, 0, bshare) gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100)) gradient.setColorAt(0, Qt.white) gradient.setColorAt(1, color) painter.setBrush(QBrush(gradient)) painter.drawPolygon(QPolygon([cx, cy, fx, fy, gx, gy, hx, hy, ix, iy])) painter.setPen(Qt.black) painter.drawPolyline(QPolygon([ax, ay, ix, iy, hx, hy])) painter.drawPolyline(QPolygon([gx, gy, fx, fy, ex, ey])) painter.drawPolyline(QPolygon([bx, by, cx, cy, dx, dy]))
def writePrintFiles(self, appdef, folder, app, progress): progress.setText("Writing print layout files") progress.setProgress(0) printFolder = os.path.join(folder, "resources", "print") if not QDir(printFolder).exists(): QDir().mkpath(printFolder) dpis = [72, 150, 300] layoutDefs = [] def getBasicInfo(item): coords = {} pos = item.pos() coords["x"] = pos.x() coords["y"] = pos.y() rect = item.rect() coords["width"] = rect.width() coords["height"] = rect.height() coords["id"] = str(uuid.uuid4()) return coords composers = iface.activeComposers() for i, composer in enumerate(composers): name = composer.composerWindow().windowTitle() layoutSafeName = safeName(name) layoutDef = {} composition = composer.composition() img = composition.printPageAsRaster(0) img = img.scaledToHeight(100, Qt.SmoothTransformation) img.save(os.path.join(printFolder, "%s_thumbnail.png" % layoutSafeName)) layoutDef["width"] = composition.paperWidth() layoutDef["height"] = composition.paperHeight() elements = [] layoutDef["thumbnail"] = "%s_thumbnail.png" % layoutSafeName layoutDef["name"] = name layoutDef["elements"] = elements for item in composition.items(): element = None if isinstance(item, (QgsComposerLegend, QgsComposerShape, QgsComposerScaleBar, QgsComposerArrow)): element = getBasicInfo(item) for dpi in dpis: dpmm = dpi / 25.4 s = QSize(item.rect().width() * dpmm, item.rect().height() * dpmm) img = QImage(s, QImage.Format_ARGB32_Premultiplied) img.fill(Qt.transparent) painter = QPainter(img) painter.scale(dpmm, dpmm) item.paint(painter, None, None) painter.end() img.save(os.path.join(printFolder, "%s_%s_%s.png" % (layoutSafeName, element["id"], str(dpi)))) elif isinstance(item, QgsComposerLabel): element = getBasicInfo(item) element["name"] = item.text() element["size"] = item.font().pointSize() element["font"] = item.font().rawName() elif isinstance(item, QgsComposerMap): element = getBasicInfo(item) grid = item.grid() if grid is not None: element["grid"] = {} element["grid"]["intervalX"] = grid.intervalX() element["grid"]["intervalY"] = grid.intervalY() element["grid"]["crs"] = grid.crs().authid() element["grid"]["annotationEnabled"] = grid.annotationEnabled() elif isinstance(item, QgsComposerPicture): filename = os.path.basename(item.picturePath()) if os.path.exists(filename): element = getBasicInfo(item) shutil.copy(item.pictureFile(), os.path.join(printFolder, filename)) element["file"] = filename if element is not None: element["type"] = item.__class__.__name__[11:].lower() elements.append(element) layoutDefs.append(layoutDef) progress.setProgress(int((i+1)*100.0/len(composers))) app.variables.append("var printLayouts = %s;" % json.dumps(layoutDefs))
def export(self): if not os.path.isdir(self.imagePath): os.mkdir(self.imagePath) total = 100.0 / len(self.composers) dpis = [72, 150, 300] layouts = [] for i, c in enumerate(self.composers): name = c.composerWindow().windowTitle() safeName = self._safeName(name) composition = c.composition() img = composition.printPageAsRaster(0) img = img.scaledToHeight(100, Qt.SmoothTransformation) img.save( os.path.join(self.imagePath, "{}_thumbnail.png".format(safeName))) layoutDef = {} layoutDef["name"] = name layoutDef["width"] = composition.paperWidth() layoutDef["height"] = composition.paperHeight() layoutDef["thumbnail"] = "{}_thumbnail.png".format(safeName) elements = [] layoutDef["elements"] = elements for item in composition.items(): element = None if isinstance(item, (QgsComposerLegend, QgsComposerShape, QgsComposerScaleBar, QgsComposerArrow)): element = self._basicInfo(item) for dpi in dpis: dpmm = dpi / 25.4 s = QSize(item.rect().width() * dpmm, item.rect().height() * dpmm) img = QImage(s, QImage.Format_ARGB32_Premultiplied) img.fill(Qt.transparent) painter = QPainter(img) painter.scale(dpmm, dpmm) item.paint(painter, None, None) painter.end() img.save( os.path.join( self.imagePath, "{}_{}_{}.png".format(safeName, element["id"], dpi))) elif isinstance(item, QgsComposerLabel): element = self._basicInfo(item) element["name"] = item.text() element["size"] = item.font().pointSize() element["font"] = item.font().rawName() elif isinstance(item, QgsComposerMap): element = self._basicInfo(item) grid = item.grid() if grid is not None: element["grid"] = {} element["grid"]["intervalX"] = grid.intervalX() element["grid"]["intervalY"] = grid.intervalY() element["grid"]["crs"] = grid.crs().authid() element["grid"][ "annotationEnabled"] = grid.annotationEnabled() elif isinstance(item, QgsComposerPicture): filename = os.path.basename(item.picturePath()) if os.path.exists(filename): element = self._basicInfo(item) shutil.copy(item.pictureFile(), os.path.join(self.imagePath, filename)) element["file"] = filename if element is not None: element["type"] = item.__class__.__name__[11:].lower() elements.append(element) layouts.append(layoutDef) self.composerExported.emit(int(i * total)) with codecs.open(self.filePath, "w", "utf-8") as f: f.write(json.dumps(layouts)) self.finished.emit()
def paintEvent(self, event): """ Draw the QImage on screen. """ painter = QPainter(self) painter.drawImage(painter.viewport(), self._image)
def updateDisplay(self): ''' Add map(s) of all QF components to the canvas based on what's selected in self.lstTimes''' timestamps = [ pd.datetime.strptime(newItem.text(), '%Y-%m-%d %H:%M') for newItem in self.lstTimes.selectedItems() ] for t in timestamps: outs = pd.read_csv(self.model.getFileList()[t], header=0, index_col=0) outLayer = self.outputLayer # Make sure the output file is properly appended (this gets evaluated for non-extra-disaggregated datasets) # because I didn't set an output shapefile path properly if os.path.split(self.outputLayer)[0] == '': outLayer = os.path.join(self.model.downscaledPath, os.path.split(self.outputLayer)[1]) fileToPopulate = self.outputLayer new_layer = populateShapefileFromTemplate( outs, self.featureIdField, outLayer, int(self.outputEPSG), title=t.strftime(' %Y-%m-%d %H:%M UTC')) # Set ranges suited to all the different QF types range_minima = [0, 0.000001, 0.1, 1, 10, 100] range_maxima = [0.000001, 0.1, 1, 10, 100, 1000] colours = [ '#CECECE', '#FEE6CE', '#FDAE6B', '#F16913', '#D94801', '#7F2704' ] opacity = 1 for component in self.componentTranslation.values(): layerName = component + t.strftime(' %Y-%m-%d %H:%M UTC') if component == self.componentTranslation.values()[0]: colourRanges(new_layer, component, opacity, range_minima, range_maxima, colours) new_layer.setLayerName(layerName) layerId = new_layer.id() QgsMapLayerRegistry.instance().addMapLayer(new_layer) proportion = new_layer.extent().height( ) / new_layer.extent().width() else: # Have to clone. Can't seem to duplicate a map layer... layer = duplicateVectorLayer(new_layer) layer.setLayerName(layerName) colourRanges(layer, component, opacity, range_minima, range_maxima, colours) layerId = layer.id() QgsMapLayerRegistry.instance().addMapLayer(layer) proportion = layer.extent().height() / layer.extent( ).width() maxSize = 2000 # Max size of output image if proportion > 1: hSize = maxSize / proportion vSize = maxSize else: hSize = maxSize vSize = maxSize * proportion # create image in proportion with layer img = QImage(QSize(hSize, vSize), QImage.Format_ARGB32_Premultiplied) # set image's background color color = QColor(255, 255, 255) img.fill(color.rgb()) # create painter p = QPainter() p.begin(img) p.setRenderHint(QPainter.Antialiasing) render = QgsMapRenderer() # set layer set lst = [layerId] # add ID of every layer render.setLayerSet(lst) # set extent rect = QgsRectangle(render.fullExtent()) rect.scale(1.1) render.setExtent(rect) # set output size render.setOutputSize(img.size(), img.logicalDpiX()) # do the rendering render.render(p) p.end() # save image img.save( os.path.join( self.model.renderPath, component + t.strftime('_%Y-%m-%d_%H-%M_UTC.png')), "png")