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")
