def certificate_preprocess(plot, plots):
"""
Utility function that loads and renders plots that belong to a specific
scheme.
"""
scheme_plot_layer = lht_plot_layer(plot.scheme_id, CERTIFICATE_PLOT)
QgsMapLayerRegistry.instance().addMapLayer(scheme_plot_layer)
# Get the EPSG code of the plot
epsg_code = plot.cb_check_lht_plot_crs.value
# Setting the project CRS variable
QgsExpressionContextUtils.setProjectVariable('flts_source_crs', epsg_code)
# Styling reference plot using primary key
filter_exp = '"id" = ' + str(plot.id)
scheme_symbol = QgsSymbolV2.defaultSymbol(scheme_plot_layer.geometryType())
# Rule-based rendering
rule_renderer = QgsRuleBasedRendererV2(scheme_symbol)
root_rule = rule_renderer.rootRule()
# Rule for highlighting reference plot
scheme_rule = root_rule.children()[0].clone()
scheme_rule.setLabel('Reference Plot')
scheme_rule.setFilterExpression(filter_exp)
scheme_symbol_layer = scheme_rule.symbol().symbolLayer(0)
scheme_symbol_layer.setFillColor(Qt.yellow)
scheme_symbol_layer.setOutlineColor(Qt.black)
scheme_symbol_layer.setBorderWidth(0.5)
root_rule.appendChild(scheme_rule)
# Rule for other plots
def_rule = root_rule.children()[0].clone()
def_rule.setLabel('Plots')
def_rule.setIsElse(True)
def_symbol_layer = def_rule.symbol().symbolLayer(0)
def_symbol_layer.setFillColor(Qt.transparent)
def_symbol_layer.setOutlineColor(Qt.black)
root_rule.appendChild(def_rule)
# Remove default rule
root_rule.removeChildAt(0)
# Set renderer
scheme_plot_layer.setRendererV2(rule_renderer)
# Enable labeling
scheme_plot_layer.setCustomProperty("labeling", "pal")
scheme_plot_layer.setCustomProperty("labeling/enabled", "true")
scheme_plot_layer.setCustomProperty("labeling/fontFamily", "Arial")
scheme_plot_layer.setCustomProperty("labeling/fontSize", "5.5")
scheme_plot_layer.setCustomProperty("labeling/fieldName", "plot_number")
scheme_plot_layer.setCustomProperty("labeling/placement", "1")
scheme_plot_layer.setCustomProperty("labeling/centroidInside", "true")
scheme_plot_layer.setCustomProperty("labeling/centroidWhole", "false")
scheme_plot_layer.triggerRepaint()
iface.mapCanvas().setExtent(scheme_plot_layer.extent())
QgsApplication.processEvents()
return True
def setUp(self):
myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp')
layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(layer)
# Create rulebased style
sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'})
sym2 = QgsFillSymbolV2.createSimple({'color': '#71bd6c'})
sym3 = QgsFillSymbolV2.createSimple({'color': '#1f78b4'})
self.r1 = QgsRuleBasedRendererV2.Rule(sym1, 0, 0, '"id" = 1')
self.r2 = QgsRuleBasedRendererV2.Rule(sym2, 0, 0, '"id" = 2')
self.r3 = QgsRuleBasedRendererV2.Rule(sym3, 0, 0, 'ELSE')
self.rootrule = QgsRuleBasedRendererV2.Rule(None)
self.rootrule.appendChild(self.r1)
self.rootrule.appendChild(self.r2)
self.rootrule.appendChild(self.r3)
self.renderer = QgsRuleBasedRendererV2(self.rootrule)
layer.setRendererV2(self.renderer)
self.mapsettings = CANVAS.mapSettings()
self.mapsettings.setOutputSize(QSize(400, 400))
self.mapsettings.setOutputDpi(96)
self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52))
rendered_layers = [layer.id()]
self.mapsettings.setLayers(rendered_layers)
def setStyleGrilleControle(layerGrille, idList):
# Symbologie: cellule a controler
props1 = {'color': '241,241,241,0', 'size': '0', 'color_border': '255,0,0'}
symbol1 = QgsFillSymbolV2.createSimple(props1)
#props2 = {'color': '255,127,0,0', 'size':'0', 'color_border' : '255,127,0', 'width_border':'1'}
#symbol2 = QgsFillSymbolV2.createSimple(props2)
# Symbologie: cellule a griser
props3 = {
'color': '180,180,180',
'size': '1',
'color_border': '180,180,180'
}
symbol3 = QgsFillSymbolV2.createSimple(props3)
symbol3.setAlpha(0.70)
# On definit les règles de symbologie
txtRule = ' in ('
for i in range(len(idList)):
id = idList[i]
txtRule = txtRule + str(id) + ', '
txtRule = txtRule[0:len(txtRule) - 2]
txtRule = txtRule + ')'
cell_rules = (('A controler', CONST_ATTRIBUT_ID + ' ' + txtRule, symbol1),
('Pass', CONST_ATTRIBUT_ID + ' not ' + txtRule, symbol3))
# create a new rule-based renderer
symbol = QgsSymbolV2.defaultSymbol(layerGrille.geometryType())
renderer = QgsRuleBasedRendererV2(symbol)
# get the "root" rule
root_rule = renderer.rootRule()
for label, expression, symbol in cell_rules:
# create a clone (i.e. a copy) of the default rule
rule = root_rule.children()[0].clone()
# set the label, expression and color
rule.setLabel(label)
rule.setFilterExpression(expression)
# rule.symbol().setColor(QColor(color_name))
rule.setSymbol(symbol)
# append the rule to the list of rules
root_rule.appendChild(rule)
# delete the default rule
root_rule.removeChildAt(0)
# apply the renderer to the layer
layerGrille.setRendererV2(renderer)
return layerGrille
def setStyleGrilleSaisie(layerGrille, currid):
props1 = {
'color': '241,241,241,0',
'size': '0',
'color_border': '255,0,0',
'width_border': '0.5'
}
symbol1 = QgsFillSymbolV2.createSimple(props1)
props2 = {'color': '255,127,0,0', 'size': '0', 'color_border': '255,127,0'}
symbol2 = QgsFillSymbolV2.createSimple(props2)
# On definit les règles de symbologie
cell_rules = (('Cellule en cours', CONST_ATTRIBUT_ID + ' = ' + str(currid),
symbol1),
('Autre cellule', CONST_ATTRIBUT_ID + ' != ' + str(currid),
symbol2))
# create a new rule-based renderer
symbol = QgsSymbolV2.defaultSymbol(layerGrille.geometryType())
renderer = QgsRuleBasedRendererV2(symbol)
# get the "root" rule
root_rule = renderer.rootRule()
for label, expression, symbol in cell_rules:
# create a clone (i.e. a copy) of the default rule
rule = root_rule.children()[0].clone()
# set the label, expression and color
rule.setLabel(label)
rule.setFilterExpression(expression)
# rule.symbol().setColor(QColor(color_name))
rule.setSymbol(symbol)
# append the rule to the list of rules
root_rule.appendChild(rule)
# delete the default rule
root_rule.removeChildAt(0)
# apply the renderer to the layer
layerGrille.setRendererV2(renderer)
return layerGrille
def make_OD_markers(nb, xo, yo, xd, yd, list_coords=None):
"""
Prepare the Origin (green), Destination (red) and Intermediates (grey)
markers.
"""
OD_layer = QgsVectorLayer(
"Point?crs=epsg:4326&field=id_route:integer&field=role:string(80)",
"markers_osrm{}".format(nb), "memory")
features = []
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(xo), float(yo))))
fet.setAttributes([nb, 'Origin'])
features.append(fet)
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(xd), float(yd))))
fet.setAttributes([nb, 'Destination'])
features.append(fet)
marker_rules = [
('Origin', '"role" LIKE \'Origin\'', '#50b56d', 4),
('Destination', '"role" LIKE \'Destination\'', '#d31115', 4),
]
if list_coords:
for i, pt in enumerate(list_coords):
fet = QgsFeature()
fet.setGeometry(
QgsGeometry.fromPoint(QgsPoint(float(pt[0]),
float(pt[1]))))
fet.setAttributes([nb, 'Via point n°{}'.format(i)])
features.append(fet)
marker_rules.insert(
1, ('Intermediate', '"role" LIKE \'Via point%\'', 'grey', 2))
OD_layer.dataProvider().addFeatures(features)
symbol = QgsSymbolV2.defaultSymbol(OD_layer.geometryType())
renderer = QgsRuleBasedRendererV2(symbol)
root_rule = renderer.rootRule()
for label, expression, color_name, size in marker_rules:
rule = root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QtGui.QColor(color_name))
rule.symbol().setSize(size)
root_rule.appendChild(rule)
root_rule.removeChildAt(0)
OD_layer.setRendererV2(renderer)
return OD_layer
def __getRuleBasedRenderer(self):
"""docstring for __getRuleBasedRenderer"""
root_rule = QgsRuleBasedRendererV2.Rule(None)
n = (len(self.expressions) - 1)
i = 0
for exp, msclass in zip(self.expressions[::-1],
self.mslayer["classes"][::-1]):
Symbol = SymbolImport(msclass, self.qgslayer, self.geom_type, self.sizeunits, \
self.mssymbols, self.symbolsetpath, self.fontset)
symbol = Symbol.getSymbol()
scalemindenom = self.__getScaledenom(msclass, 'minscaledenom',
'styles')
scalemaxdenom = self.__getScaledenom(msclass, 'maxscaledenom',
'styles')
label = msclass.get("name", exp[1])
state = False if msclass.get("status",
'on').lower() == 'off' else True
filterexp = ''
if exp[0] == Expression.TYPE_STRING and self.has_classitem:
filterexp = "\"{}\" = '{}'".format(self.has_classitem, exp[1])
elif exp[0] == Expression.TYPE_LIST or exp[
0] == Expression.TYPE_BETWEEN or exp[
0] == Expression.TYPE_LOGICAL:
filterexp = exp[1]
description = ''
#Si no tiene expresion y si es la ultima regla setear a True, tener en cuenta que se puede declarar al reves
#elserule = True if exp[0] == 'unknown' and exp[1] == '' and i == n else False
elserule = False
rule = QgsRuleBasedRendererV2.Rule(symbol, scalemindenom,
scalemaxdenom, filterexp, label,
description, elserule)
rule.setActive(state)
root_rule.appendChild(rule)
i += 1
return QgsRuleBasedRendererV2(root_rule)
def Mod3Render(iface, styleManager, parent=None):
cellLayer = getLayerByName(u"小区", iface)
# 模三规则
rules = (('0', ' "PCI" % 3 = 0', 'red'), ('1', ' "PCI" % 3 = 1', 'yellow'),
('2', ' "PCI" % 3 = 2', '#47d54c'))
sym_pci = QgsSymbolV2.defaultSymbol(
cellLayer.geometryType()) # 小区feature重置默认样式
rend_pci = QgsRuleBasedRendererV2(sym_pci) # 设置为基于规则样式
root_rule = rend_pci.rootRule()
for label, exp, color, in rules: # 根据规则渲染
rule = root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(exp)
rule.symbol().setColor(QColor(color))
root_rule.appendChild(rule)
cellLayer.setRendererV2(rend_pci)
iface.actionDraw().trigger()
legend = Mod3Legend(iface, styleManager, parent)
legend.show()
legend.exec_()
"color_border": "#000000",
"width_border": "0.25",
"style": "no",
}
)
highlight_style = QgsFillSymbolV2().createSimple(
{
"color": "#000000",
"color_border": "#ff0000",
"width_border": "0.85",
"style": "no",
}
)
highlight_rule = QgsRuleBasedRendererV2.Rule(highlight_style)
highlight_rule.setFilterExpression("$id = @atlas_featureid")
highlight_renderer = QgsRuleBasedRendererV2(normal_style)
highlight_renderer.rootRule().appendChild(highlight_rule)
original_renderer = vector_layer.rendererV2()
vector_layer.setRendererV2(highlight_renderer)
vector_layer.triggerRepaint()
# Produce the reports
atlas.beginRender()
for i in range(atlas.numFeatures()):
atlas.prepareForFeature(i)
region_id = str(atlas.feature().attribute("aoi_id"))
if region_id not in report_tables.keys():
continue
styled_df = report_tables[region_id].style.format("{:.2f}")
html = styled_df.set_table_styles(
[
def extract_layers(self, tree):
"""Return a list of RFU layers."""
# Create vector layers..
l_vertex = QgsVectorLayer(r"Point?crs=epsg:4326&index=yes",
u"Sommet RFU", r"memory")
l_edge = QgsVectorLayer(r"LineString?crs=epsg:4326&index=yes",
u"Limite RFU", r"memory")
p_vertex = l_vertex.dataProvider()
p_edge = l_edge.dataProvider()
# Define default style renderer..
renderer_vertex = QgsRuleBasedRendererV2(QgsMarkerSymbolV2())
vertex_root_rule = renderer_vertex.rootRule()
vertex_rules = (
((u"Borne, borne à puce, pierre, piquet, clou ou broche"),
(u"$id >= 0 AND \"som_nature\" IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche')"),
r"#EC0000", 2.2),
((u"Axe cours d'eau, axe fossé, haut de talus, pied de talus"),
(u"$id >= 0 AND \"som_nature\" IN ('Axe cours d\'\'eau',"
u"'Axe fossé', 'Haut de talus', 'Pied de talus')"), r"#EE8012",
2.2), ((u"Angle de bâtiment, axe de mur, angle de mur, "
u"angle de clôture, pylône et toute autre valeur"),
(u"$id >= 0 AND \"som_nature\" NOT IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche',"
u"'Axe cours d\'\'eau', 'Axe fossé', 'Haut de talus',"
u"'Pied de talus')"), r"#9784EC",
2.2), (u"Temporaire", r"$id < 0", "cyan", 2.4))
for label, expression, color, size in vertex_rules:
rule = vertex_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setSize(size)
vertex_root_rule.appendChild(rule)
vertex_root_rule.removeChildAt(0)
l_vertex.setRendererV2(renderer_vertex)
renderer_edge = QgsRuleBasedRendererV2(QgsLineSymbolV2())
edge_root_rule = renderer_edge.rootRule()
edge_rules = ((r"Limite", r"$id >= 0", "#0A0AFF", 0.5),
(r"Temporaire", r"$id < 0", "cyan", 1))
for label, expression, color, width in edge_rules:
rule = edge_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setWidth(width)
edge_root_rule.appendChild(rule)
edge_root_rule.removeChildAt(0)
l_edge.setRendererV2(renderer_edge)
# Add fields..
p_vertex.addAttributes([
QgsField(r"@id_noeud", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"som_ge_createur", QVariant.String),
QgsField(r"som_nature", QVariant.String),
QgsField(r"som_precision_rattachement", QVariant.Int),
QgsField(r"som_coord_est", QVariant.Double),
QgsField(r"som_coord_nord", QVariant.Double),
QgsField(r"som_representation_plane", QVariant.String),
# QgsField(r"date_creation", QVariant.Date)
])
p_edge.addAttributes([
QgsField(r"@id_arc", QVariant.Int),
# QgsField(r"@id_noeud_debut", QVariant.Int),
# QgsField(r"@id_noeud_fin", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"lim_ge_createur", QVariant.String),
# QgsField(r"lim_date_creation", QVariant.Date)
])
# Add features from xml tree..
# ..to vertex layer..
fts_vertex = []
for e in tree.findall(r"sommet"):
ft_vertex = QgsFeature()
ft_vertex.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_noeud = int(e.attrib[r"id_noeud"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
som_ge_createur = unicode(e.find(r"./som_ge_createur").text)
som_nature = unicode(e.find(r"./som_nature").text)
som_prec_rattcht = int(
e.find(r"./som_precision_rattachement").text)
som_coord_est = float(e.find(r"./som_coord_est").text)
som_coord_nord = float(e.find(r"./som_coord_nord").text)
som_repres_plane = unicode(
e.find(r"./som_representation_plane").text)
# som_date_creation = QDate(datetime.strptime(
# e.find(r"./som_date_creation").text, r"%Y-%m-%d").date())
ft_vertex.setAttributes([
_id_noeud,
# _changeset,
# _timestamp,
_version,
som_ge_createur,
som_nature,
som_prec_rattcht,
som_coord_est,
som_coord_nord,
som_repres_plane,
# som_date_creation
])
fts_vertex.append(ft_vertex)
# ..to edge layer..
fts_edge = []
for e in tree.findall(r"limite"):
ft_edge = QgsFeature()
ft_edge.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_arc = int(e.attrib[r"id_arc"])
# _id_noeud_debut = int(e.attrib[r"id_noeud_debut"])
# _id_noeud_fin = int(e.attrib[r"id_noeud_fin"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
lim_ge_createur = unicode(e.find(r"./lim_ge_createur").text)
# lim_date_creation = QDate(datetime.strptime(
# e.find(r"./lim_date_creation").text, r"%Y-%m-%d").date())
ft_edge.setAttributes([
_id_arc,
# _id_noeud_debut,
# _id_noeud_fin,
# _changeset,
# _timestamp,
_version,
lim_ge_createur,
# lim_date_creation
])
fts_edge.append(ft_edge)
# Add features to layers..
p_vertex.addFeatures(fts_vertex)
p_edge.addFeatures(fts_edge)
# Update fields..
l_vertex.updateFields()
l_edge.updateFields()
# Update layer's extent..
l_vertex.updateExtents()
l_edge.updateExtents()
# Check if valid..
if not l_vertex.isValid() or not l_edge.isValid():
raise Exception(
u"Une erreur est survenue lors du chargement de la couche.")
# Set labelling...
palyr = QgsPalLayerSettings()
palyr.enabled = True
# palyr.readFromLayer(l_vertex)
palyr.fieldName = r"$id" # Expression $id
palyr.placement = 1 # ::OverPoint
palyr.quadOffset = 2 # ::QuadrantAboveRight
palyr.setDataDefinedProperty(80, True, True, r"1",
"") # ::OffsetUnits -> ::MM
palyr.xOffset = 2.0
palyr.yOffset = -1.0
palyr.writeToLayer(l_vertex)
# Then return layers..
return [l_vertex, l_edge]
