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]
def exportStyles(layers, folder, clustered): stylesFolder = os.path.join(folder, "styles") QDir().mkpath(stylesFolder) for count, (layer, cluster) in enumerate(zip(layers, clustered)): sln = safeName(layer.name()) + unicode(count) if layer.type() != layer.VectorLayer: continue labelsEnabled = unicode( layer.customProperty("labeling/enabled")).lower() == "true" if (labelsEnabled): labelField = layer.customProperty("labeling/fieldName") if labelField != "": if unicode(layer.customProperty( "labeling/isExpression")).lower() == "true": exprFilename = os.path.join(folder, "resources", "qgis2web_expressions.js") fieldName = layer.customProperty("labeling/fieldName") name = compile_to_file(fieldName, "label_%s" % sln, "OpenLayers3", exprFilename) js = "%s(context)" % (name) js = js.strip() labelText = js else: fieldIndex = layer.pendingFields().indexFromName( labelField) try: editFormConfig = layer.editFormConfig() editorWidget = editFormConfig.widgetType(fieldIndex) except: editorWidget = layer.editorWidgetV2(fieldIndex) if (editorWidget == QgsVectorLayer.Hidden or editorWidget == 'Hidden'): labelField = "q2wHide_" + labelField labelText = ('feature.get("%s")' % labelField.replace('"', '\\"')) else: labelText = '""' else: labelText = '""' defs = "var size = 0;\n" try: renderer = layer.rendererV2() layer_alpha = layer.layerTransparency() if isinstance(renderer, QgsSingleSymbolRendererV2): symbol = renderer.symbol() if cluster: style = "var size = feature.get('features').length;\n" else: style = "var size = 0;\n" style += " var style = " + getSymbolAsStyle( symbol, stylesFolder, layer_alpha) value = 'var value = ""' elif isinstance(renderer, QgsCategorizedSymbolRendererV2): defs += """function categories_%s(feature, value) { switch(value) {""" % sln cats = [] for cat in renderer.categories(): if (cat.value() is not None and cat.value() != "" and not isinstance(cat.value(), QPyNullVariant)): categoryStr = "case '%s':" % unicode( cat.value()).replace("'", "\\'") else: categoryStr = "default:" categoryStr += ''' return %s; break;''' % (getSymbolAsStyle(cat.symbol(), stylesFolder, layer_alpha)) cats.append(categoryStr) defs += "\n".join(cats) + "}};" classAttr = renderer.classAttribute() fieldIndex = layer.pendingFields().indexFromName(classAttr) try: editFormConfig = layer.editFormConfig() editorWidget = editFormConfig.widgetType(fieldIndex) except: editorWidget = layer.editorWidgetV2(fieldIndex) if (editorWidget == QgsVectorLayer.Hidden or editorWidget == 'Hidden'): classAttr = "q2wHide_" + classAttr value = ('var value = feature.get("%s");' % classAttr) style = ('''var style = categories_%s(feature, value)''' % (sln)) elif isinstance(renderer, QgsGraduatedSymbolRendererV2): varName = "ranges_" + sln defs += "var %s = [" % varName ranges = [] for ran in renderer.ranges(): symbolstyle = getSymbolAsStyle(ran.symbol(), stylesFolder, layer_alpha) ranges.append( '[%f, %f, %s]' % (ran.lowerValue(), ran.upperValue(), symbolstyle)) defs += ",\n".join(ranges) + "];" classAttr = renderer.classAttribute() fieldIndex = layer.pendingFields().indexFromName(classAttr) try: editFormConfig = layer.editFormConfig() editorWidget = editFormConfig.widgetType(fieldIndex) except: editorWidget = layer.editorWidgetV2(fieldIndex) if (editorWidget == QgsVectorLayer.Hidden or editorWidget == 'Hidden'): classAttr = "q2wHide_" + classAttr value = ('var value = feature.get("%s");' % classAttr) style = '''var style = %(v)s[0][2]; for (i = 0; i < %(v)s.length; i++){ var range = %(v)s[i]; if (value > range[0] && value<=range[1]){ style = range[2]; } }''' % { "v": varName } elif isinstance(renderer, QgsRuleBasedRendererV2): template = """ function rules_%s(feature, value) { var context = { feature: feature, variables: {} }; // Start of if blocks and style check logic %s else { return %s; } } var style = rules_%s(feature, value); """ elsejs = "[]" js = "" root_rule = renderer.rootRule() rules = root_rule.children() expFile = os.path.join(folder, "resources", "qgis2web_expressions.js") ifelse = "if" for count, rule in enumerate(rules): symbol = rule.symbol() styleCode = getSymbolAsStyle(symbol, stylesFolder, layer_alpha) name = "".join((sln, "rule", unicode(count))) exp = rule.filterExpression() if rule.isElse(): elsejs = styleCode continue name = compile_to_file(exp, name, "OpenLayers3", expFile) js += """ %s (%s(context)) { return %s; } """ % (ifelse, name, styleCode) js = js.strip() ifelse = "else if" value = ("var value = '';") style = template % (sln, js, elsejs, sln) else: style = "" if layer.customProperty("labeling/fontSize"): size = float(layer.customProperty("labeling/fontSize")) * 1.3 else: size = 10 italic = layer.customProperty("labeling/fontItalic") bold = layer.customProperty("labeling/fontWeight") r = layer.customProperty("labeling/textColorR") g = layer.customProperty("labeling/textColorG") b = layer.customProperty("labeling/textColorB") color = "rgba(%s, %s, %s, 255)" % (r, g, b) face = layer.customProperty("labeling/fontFamily") palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) sv = palyr.scaleVisibility if sv: min = float(palyr.scaleMin) max = float(palyr.scaleMax) min = 1 / ((1 / min) * 39.37 * 90.7) max = 1 / ((1 / max) * 39.37 * 90.7) labelRes = " && resolution > %(min)d " % {"min": min} labelRes += "&& resolution < %(max)d" % {"max": max} else: labelRes = "" buffer = palyr.bufferDraw if buffer: bufferColor = palyr.bufferColor.name() bufferWidth = palyr.bufferSize stroke = """ stroke: new ol.style.Stroke({ color: "%s", width: %d }),""" % (bufferColor, bufferWidth) else: stroke = "" if style != "": style = '''function(feature, resolution){ var context = { feature: feature, variables: {} }; %(value)s %(style)s; if (%(label)s !== null%(labelRes)s) { var labelText = String(%(label)s); } else { var labelText = "" } var key = value + "_" + labelText if (!%(cache)s[key]){ var text = new ol.style.Text({ font: '%(size)spx \\'%(face)s\\', sans-serif', text: labelText, textBaseline: "center", textAlign: "left", offsetX: 5, offsetY: 3, fill: new ol.style.Fill({ color: '%(color)s' }),%(stroke)s }); %(cache)s[key] = new ol.style.Style({"text": text}) } var allStyles = [%(cache)s[key]]; allStyles.push.apply(allStyles, style); return allStyles; }''' % { "style": style, "labelRes": labelRes, "label": labelText, "cache": "styleCache_" + sln, "size": size, "face": face, "color": color, "stroke": stroke, "value": value } else: style = "''" except Exception, e: style = """{ /* """ + traceback.format_exc() + " */}" QgsMessageLog.logMessage(traceback.format_exc(), "qgis2web", level=QgsMessageLog.CRITICAL) path = os.path.join(stylesFolder, sln + "_style.js") with codecs.open(path, "w", "utf-8") as f: f.write('''%(defs)s var styleCache_%(name)s={} var style_%(name)s = %(style)s;''' % { "defs": defs, "name": sln, "style": style })
def testLabelMargin(self): """ Test rendering map item with a label margin set """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False) engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) checker = QgsLayoutChecker('composermap_label_nomargin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin( QgsLayoutMeasurement(15, QgsUnitTypes.LayoutMillimeters)) checker = QgsLayoutChecker('composermap_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setLabelMargin( QgsLayoutMeasurement(3, QgsUnitTypes.LayoutCentimeters)) checker = QgsLayoutChecker('composermap_label_cm_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) map.setMapRotation(45) map.zoomToExtent(vl.extent()) map.setScale(map.scale() * 1.2) checker = QgsLayoutChecker('composermap_rotated_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) # data defined map.setMapRotation(0) map.zoomToExtent(vl.extent()) map.dataDefinedProperties().setProperty( QgsLayoutObject.MapLabelMargin, QgsProperty.fromExpression('1+3')) map.refresh() checker = QgsLayoutChecker('composermap_dd_label_margin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message)
def testCreateCalloutProperty(self): s = QgsAuxiliaryStorage() self.assertTrue(s.isValid()) # Create a new auxiliary layer with 'pk' as key vl = createLayer() pkf = vl.fields().field(vl.fields().indexOf('pk')) al = s.createAuxiliaryLayer(pkf, vl) self.assertTrue(al.isValid()) vl.setAuxiliaryLayer(al) # Create a new callout property on layer without labels key = QgsCallout.DestinationX index = QgsAuxiliaryLayer.createProperty(key, vl) self.assertEqual(index, -1) # Labeling, but no callouts settings = QgsPalLayerSettings() settings.setCallout(None) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) index = QgsAuxiliaryLayer.createProperty(key, vl) self.assertEqual(index, -1) # callouts settings = QgsPalLayerSettings() callout = QgsSimpleLineCallout() callout.setEnabled(True) settings.setCallout(callout) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) index = QgsAuxiliaryLayer.createProperty(key, vl) p = QgsCallout.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertEqual( settings.callout().dataDefinedProperties().property(key), QgsProperty.fromField('auxiliary_storage_callouts_destinationx')) key2 = QgsCallout.DestinationY index = QgsAuxiliaryLayer.createProperty(key2, vl) p = QgsCallout.propertyDefinitions()[key2] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertEqual( settings.callout().dataDefinedProperties().property(key), QgsProperty.fromField('auxiliary_storage_callouts_destinationx')) self.assertEqual( settings.callout().dataDefinedProperties().property(key2), QgsProperty.fromField('auxiliary_storage_callouts_destinationy')) # with existing property key = QgsCallout.OriginX settings = QgsPalLayerSettings() callout = QgsSimpleLineCallout() callout.dataDefinedProperties().setProperty( key, QgsProperty.fromExpression('$x + 20')) callout.setEnabled(True) settings.setCallout(callout) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) # without overwriting existing, property should be upgraded to coalesce("aux field", 'existing expression') type index = QgsAuxiliaryLayer.createProperty(key, vl, False) p = QgsCallout.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertTrue(settings.callout().dataDefinedProperties().property( key).isActive()) self.assertEqual( settings.callout().dataDefinedProperties().property( key).asExpression(), 'coalesce("auxiliary_storage_callouts_originx",$x + 20)') # with overwrite existing key = QgsCallout.OriginY callout = QgsSimpleLineCallout() callout.dataDefinedProperties().setProperty( key, QgsProperty.fromExpression('$y + 20')) settings.setCallout(callout) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) # existing property should be discarded index = QgsAuxiliaryLayer.createProperty(key, vl, True) p = QgsCallout.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertTrue(settings.callout().dataDefinedProperties().property( key).isActive()) self.assertEqual( settings.callout().dataDefinedProperties().property(key).field(), 'auxiliary_storage_callouts_originy')
def showMarkDaSoc(self): try: flag = FlightPlanBaseDlg.btnConstruct_Click(self) # if not flag: # return point3dThr = self.parametersPanel.pnlThrPosition.Point3d point3dFaf = self.parametersPanel.pnlFapPosition.Point3d inboundTrackRad = Unit.ConvertDegToRad(self.parametersPanel.pnlInboundTrack.Value)#MathHelper.getBearing(point3dFaf, point3dThr) inboundTrack180Rad = MathHelper.smethod_4(inboundTrackRad + math.pi) estimatedAltitdeMeters = self.parametersPanel.pnlEstimatedAltitude.Value.Metres thrAltitudeMeters = self.parametersPanel.pnlThrPosition.Altitude().Metres heightLossAltitudeMeters = self.parametersPanel.pnlHeightLoss.Value.Metres rdhAltitudeMeters = self.parametersPanel.pnlRDH.Value.Metres vpa = Unit.ConvertDegToRad(self.getVPA()) xz = self.parametersPanel.pnlDistXz.Value.Metres socThrDistMeters = ((estimatedAltitdeMeters - thrAltitudeMeters - heightLossAltitudeMeters) / math.tan(vpa)) + xz daThrDistMeters = (estimatedAltitdeMeters - thrAltitudeMeters - rdhAltitudeMeters) / math.tan(vpa) sockBearing = inboundTrackRad # if socThrDistMeters < 0: # sockBearing = inboundTrack180Rad # socThrDistMeters = math.fabs(socThrDistMeters) # else: # sockBearing = inboundTrackRad daBearing = inboundTrack180Rad # if daThrDistMeters < 0: # daBearing = inboundTrackRad # daThrDistMeters = math.fabs(daThrDistMeters) # else: # daBearing = inboundTrack180Rad self.socPoint3d = MathHelper.distanceBearingPoint(point3dThr, sockBearing, -socThrDistMeters).smethod_167(self.calcSocAltitude()) self.daPoint3d = MathHelper.distanceBearingPoint(point3dThr, daBearing, daThrDistMeters) daSocLayer = AcadHelper.createVectorLayer("DA_SOC_" + self.surfaceType, QGis.Point) AcadHelper.setGeometryAndAttributesInLayer(daSocLayer, self.socPoint3d, False, {"Caption":"SOC"}) AcadHelper.setGeometryAndAttributesInLayer(daSocLayer, self.daPoint3d, False, {"Caption":"DA"}) QgisHelper.appendToCanvas(define._canvas, [daSocLayer], self.surfaceType) palSetting = QgsPalLayerSettings() palSetting.readFromLayer(daSocLayer) palSetting.enabled = True palSetting.fieldName = "Caption" palSetting.isExpression = True palSetting.placement = QgsPalLayerSettings.AroundPoint palSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True, '8', "") palSetting.writeToLayer(daSocLayer) QgisHelper.zoomToLayers([daSocLayer]) self.resultLayerList = [daSocLayer] # # show SOC Mark # point3d = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - 0, 100) # point3d1 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - math.pi / 2, 100) # point3d2 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - math.pi, 100) # point3d3 = MathHelper.distanceBearingPoint(self.socPoint3d, Unit.ConvertDegToRad(450) - (math.pi * 3) / 2 , 100) # # if self.socRubber == None: # self.socRubber = QgsRubberBand(define._canvas, QGis.Line) # self.socRubber.setColor(Qt.yellow) # else: # self.socRubber.reset(QGis.Line) # self.socRubber.addGeometry(QgsGeometry.fromPolyline([point3d, point3d2]), None) # self.socRubber.addGeometry(QgsGeometry.fromPolyline([point3d1, point3d3]), None) # circle = MathHelper.constructCircle(self.socPoint3d, 100, 16) # self.socRubber.addGeometry(QgsGeometry.fromPolyline(circle), None) # self.socRubber.show() # # self.socAnnotation.setMapPosition(self.socPoint3d) # self.socAnnotation.show() # # # show DA Mark # point3d = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - 0, 100) # point3d1 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - math.pi / 2, 100) # point3d2 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - math.pi, 100) # point3d3 = MathHelper.distanceBearingPoint(self.daPoint3d, Unit.ConvertDegToRad(450) - (math.pi * 3) / 2 , 100) # # if self.daRubber == None: # self.daRubber = QgsRubberBand(define._canvas, QGis.Line) # self.daRubber.setColor(Qt.yellow) # else: # self.daRubber.reset(QGis.Line) # self.daRubber.addGeometry(QgsGeometry.fromPolyline([point3d, point3d2]), None) # self.daRubber.addGeometry(QgsGeometry.fromPolyline([point3d1, point3d3]), None) # circle = MathHelper.constructCircle(self.daPoint3d, 100, 16) # self.daRubber.addGeometry(QgsGeometry.fromPolyline(circle), None) # self.daRubber.show() # # self.daAnnotation.setMapPosition(self.daPoint3d) # self.daAnnotation.show() self.putDistances() return daSocLayer except: pass
def testClippingHideClipSource(self): """ When an item is set to be the clip source, it shouldn't render anything itself """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(30) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'XXXX'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Polygon?crs=epsg:4326&field=id:integer", "vl", "memory") props = { "color": "127,255,127", 'outline_style': 'solid', 'outline_width': '1', 'outline_color': '0,0,255' } fillSymbol = QgsFillSymbol.createSimple(props) renderer = QgsSingleSymbolRenderer(fillSymbol) vl.setRenderer(renderer) f = QgsFeature(vl.fields(), 1) for x in range(0, 15, 3): for y in range(0, 15, 3): f.setGeometry(QgsGeometry(QgsPoint(x, y)).buffer(1, 3)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(False) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) shape = QgsLayoutItemShape(layout) layout.addLayoutItem(shape) shape.setShapeType(QgsLayoutItemShape.Ellipse) shape.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.itemClippingSettings().setEnabled(True) map.itemClippingSettings().setSourceItem(shape) map.itemClippingSettings().setForceLabelsInsideClipPath(False) map.itemClippingSettings().setFeatureClippingType( QgsMapClippingRegion.FeatureClippingType.ClipToIntersection) checker = QgsLayoutChecker('composermap_itemclip_nodrawsource', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() TestQgsLayoutMap.report += checker.report() self.assertTrue(result, message)
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = ReanalysisVisualizationDialog() project = QgsProject.instance() if not project.mapLayersByName('back'): layer = QgsVectorLayer( './background/ne_110m_admin_0_countries.shp', "back", "ogr") project.addMapLayer(layer) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: params, variables, drawStyle, need_slideshow = self.dlg.prepare_form_data() try: root = QgsProject.instance().layerTreeRoot() group = root.findGroup('contours') if group: group.removeAllChildren() else: group = root.addGroup("contours") root.insertChildNode(-1, QgsLayerTreeLayer(project.mapLayersByName('back')[0])) root.removeLayer(project.mapLayersByName('back')[0]) data_grid = DataGrid(params, variables) geojsons = Isolines(data_grid, drawStyle).get_geojsons() for geojson in geojsons: layer = QgsVectorLayer( geojson['geojson'], "leadTime = " + str(geojson['leadTime']), "ogr") layer.setOpacity(0.87) # apply contour style properties symbol_layer = layer.renderer().symbol().symbolLayers()[0] symbol_layer.setDataDefinedProperty( QgsSymbolLayer.PropertyStrokeColor, QgsProperty.fromField("stroke")) symbol_layer.setDataDefinedProperty( QgsSymbolLayer.PropertyFillColor, QgsProperty.fromField("fill")) symbol_layer.setDataDefinedProperty( QgsSymbolLayer.PropertyStrokeWidth, QgsProperty.fromField("stroke-width")) # add labels pal_layer = QgsPalLayerSettings() pal_layer.fieldName = 'title' pal_layer.enabled = True pal_layer.placement = QgsPalLayerSettings.PerimeterCurved pal_layer.placementFlags = QgsPalLayerSettings.OnLine labeler = QgsVectorLayerSimpleLabeling(pal_layer) layer.setLabeling(labeler) layer.setLabelsEnabled(True) # add vector layer with isolines QgsProject.instance().addMapLayer(layer, False) group.insertChildNode(-1, QgsLayerTreeLayer(layer)) group.setIsMutuallyExclusive(True, 0) if need_slideshow: slideshow = threading.Thread( target=self.__change_active_layer, args=(group,)) slideshow.start() except Exception as e: error_text = '' if (params['east'] > 180 or params['east'] < -180 or params['west'] > 180 or params['west'] < -180 or params['south'] > 90 or params['south'] < -90 or params['north'] > 90 or params['north'] < -90): error_text += "Ошибка: Некорректно заданы координаты области" else: error_text += "Ошибка: \n" + str(e) error_dialog = QErrorMessage() error_dialog.showMessage(error_text) error_dialog.exec_()
def btnConstruct_Click(self): flag = FlightPlanBaseSimpleDlg.btnConstruct_Click(self) if not flag: return constructionLayer = AcadHelper.createVectorLayer(SurfaceTypes.DmeTolerance, QGis.Line) point3d1 = self.parametersPanel.pnlDME.Point3d circleAreaList = [] # length = self.groundDistance.Metres / 5 # # rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,) # point1 = Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() + length / 2) # point2 = Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2) captionCircleLine = [] centerPoint = None radius = 0.0 arc = None; resultPoint3dArrayList = [] if (self.groundDistance.Metres > 0): metres = self.dmeTolerance.valueMetres / 1.7; if (self.parametersPanel.cmbConstructionType.currentIndex() != 0): num1 = Unit.ConvertDegToRad(float(self.parametersPanel.pnlRadial.Value)); num2 = math.asin(min([1 / self.groundDistance.NauticalMiles, 1])); num3 = num1 + num2 num4 = num1 - num2 # arc = PolylineArea() # arc.Add(PolylineAreaPoint(point3d1, self.groundDistance.Metres)) arc = MathHelper.constructArc(point3d1, self.groundDistance.Metres, num3, num4, 30); point3d = MathHelper.distanceBearingPoint(point3d1, num1, self.groundDistance.Metres); captionCircleLine = [MathHelper.distanceBearingPoint(point3d, MathHelper.getBearing(point3d, point3d1) + math.pi / 2, self.groundDistance.Metres / 20), MathHelper.distanceBearingPoint(point3d, MathHelper.getBearing(point3d, point3d1) - math.pi / 2, self.groundDistance.Metres / 20)] num = -num1; if (self.parametersPanel.chbDrawRadial.isChecked()): line = PolylineArea([point3d1, point3d]); resultPoint3dArrayList.append([point3d1, point3d]) # AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer); else: arc = MathHelper.constructCircle(point3d1, self.groundDistance.Metres, 50); circleAreaList.append(PolylineArea(None, point3d1, self.groundDistance.Metres)) centerPoint = point3d1 radius = self.groundDistance.Metres point3d = MathHelper.distanceBearingPoint(point3d1, 0, self.groundDistance.Metres); length = self.groundDistance.Metres / 5 # rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,) point1 = MathHelper.distanceBearingPoint(point3d, Unit.ConvertDegToRad(270), length / 4)#Point3D(point3d.get_X() - length / 4, point3d.get_Y()) point2 = MathHelper.distanceBearingPoint(point3d, Unit.ConvertDegToRad(90), length / 4)#Point3D(point3d.get_X() + length / 4, point3d.get_Y()) captionCircleLine = [point1, point2] num = 0; resultPoint3dArrayList.append(arc) # AcadHelper.smethod_18(transaction, blockTableRecord, arc, constructionLayer); if (self.parametersPanel.chbWriteText.isChecked()): nauticalMiles = self.groundDistance.NauticalMiles; # DBText dBText = AcadHelper.smethod_138(string.Format("{0} DME", nauticalMiles.ToString("0.#")), point3d, metres, 1); # dBText.set_Rotation(num); # AcadHelper.smethod_18(transaction, blockTableRecord, dBText, constructionLayer); if (self.parametersPanel.chbDrawDmeTol.isVisible() and self.parametersPanel.chbDrawDmeTol.isChecked() and self.dmeTolerance.IsValid() and arc != None): offsetCurf = QgisHelper.offsetCurve(arc, self.dmeTolerance.Metres) if self.parametersPanel.cmbConstructionType.currentIndex() == 0: circleAreaList.append(PolylineArea(None, centerPoint, radius + self.dmeTolerance.Metres)) if (self.parametersPanel.cmbConstructionType.currentIndex() == 0): endPoint = offsetCurf[0] offsetCurf.append(endPoint) resultPoint3dArrayList.append(offsetCurf) # foreach (Entity offsetCurf in arc.GetOffsetCurves(self.dmeTolerance.Metres)) # { # AcadHelper.smethod_19(transaction, blockTableRecord, offsetCurf, constructionLayer, 5); # } entity = QgisHelper.offsetCurve(arc, -(self.dmeTolerance.Metres + self.slantTolerance.Metres)) if self.parametersPanel.cmbConstructionType.currentIndex() == 0: circleAreaList.append(PolylineArea(None, centerPoint, radius -(self.dmeTolerance.Metres + self.slantTolerance.Metres))) if (self.parametersPanel.cmbConstructionType.currentIndex() == 0): endPoint = entity[0] entity.append(endPoint) resultPoint3dArrayList.append(entity) # foreach (Entity entity in arc.GetOffsetCurves(-(self.dmeTolerance.Metres + self.slantTolerance.Metres))) # { # AcadHelper.smethod_19(transaction, blockTableRecord, entity, constructionLayer, 5); # } # } if (self.parametersPanel.chbDrawSlantTol.isVisible() and self.parametersPanel.chbDrawSlantTol.isChecked() and self.slantTolerance.IsValid() and arc != None): offsetCurf1 = QgisHelper.offsetCurve(arc, -self.slantTolerance.Metres) if self.parametersPanel.cmbConstructionType.currentIndex() == 0: circleAreaList.append(PolylineArea(None, centerPoint, radius -self.slantTolerance.Metres)) if (self.parametersPanel.cmbConstructionType.currentIndex() == 0): endPoint = offsetCurf1[0] offsetCurf1.append(endPoint) resultPoint3dArrayList.append(offsetCurf1) # foreach (Entity offsetCurf1 in arc.GetOffsetCurves(-self.slantTolerance.Metres)) # { # AcadHelper.smethod_19(transaction, blockTableRecord, offsetCurf1, constructionLayer, 2); # } # } if (self.parametersPanel.chbInsertSymbol.isChecked()): length = self.groundDistance.Metres / 5 rectangle = QgsRectangle(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2, point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2,) point1 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(315), length / 2)#Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() + length / 2) point2 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(225), length / 2)#Point3D(point3d1.get_X() - length / 2, point3d1.get_Y() - length / 2) point3 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(135), length / 2)#Point3D(point3d1.get_X() + length / 2, point3d1.get_Y() - length / 2) point4 = MathHelper.distanceBearingPoint(point3d1, Unit.ConvertDegToRad(45), length / 2)#Point3D(point3d1.get_X() + length / 2, point3d1.get_Y() + length / 2) resultPoint3dArrayList.append([point1, point2, point3, point4, point1]) # Symbol symbol = new Symbol(SymbolType.Dme); # AcadHelper.smethod_57(transaction, blockTableRecord, symbol.BlockName, symbol.BlockFileName, point3d1, new Scale3d(1), 0, constructionLayer, None); # } for point3dArray in resultPoint3dArrayList: if (self.parametersPanel.cmbConstructionType.currentIndex() != 0): bulge = MathHelper.smethod_60(point3dArray[0], point3dArray[int(len(point3dArray)/2)], point3dArray[len(point3dArray)-1]) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3dArray, False, {"Bulge":bulge}) if self.parametersPanel.cmbConstructionType.currentIndex() == 0: for area in circleAreaList: AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, area) if self.parametersPanel.chbInsertSymbol.isChecked(): AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, [point1, point2, point3, point4, point1]) if (self.parametersPanel.chbWriteText.isChecked()): AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, captionCircleLine, False, {"Caption":"3DME"} ) palSetting = QgsPalLayerSettings() palSetting.readFromLayer(constructionLayer) palSetting.enabled = True palSetting.fieldName = "Caption" palSetting.isExpression = True palSetting.placement = QgsPalLayerSettings.Line palSetting.placementFlags = QgsPalLayerSettings.AboveLine palSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True, '12', "") palSetting.writeToLayer(constructionLayer) QgisHelper.appendToCanvas(define._canvas, [constructionLayer], self.surfaceType, True) QgisHelper.zoomToLayers([constructionLayer]) self.resultLayerList = [constructionLayer]
def run(self): #coloco el puntero arriba del todo #QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 ) #genero una lista con los campos de la capa selecionada layer = iface.activeLayer() if layer is None: iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10) if layer.wkbType() == 1 or layer.wkbType() == 1001: prov = layer.dataProvider() field_names = [field.name() for field in prov.fields()] self.dlg.mycomboBox.clear() for element in field_names: self.dlg.mycomboBox.addItem(element) """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: global index_campo_seleccionado distanciaminima = int(self.dlg.lineEdit_distancia.text()) # "layer" is a QgsVectorLayer instance layer = iface.activeLayer() idx = layer.fields().indexFromName("distanc") if idx == -1: print("ya existe") res = layer.dataProvider().addAttributes( [QgsField("distanc", QVariant.String)]) #layer.addAttribute(QgsField("valido", QVariant.String)) layer.updateFields() features = layer.getFeatures() for feature in features: # retrieve every feature with its geometry and attributes #print("Feature ID: ", feature.id()) # fetch geometry # show some information about the feature geometry geom = feature.geometry() geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType()) if geom.type() == QgsWkbTypes.PointGeometry: punto = geom.asPoint() x = punto.x() y = punto.y() #print("analizo los puntos",x,y) features2 = layer.getFeatures() for feature2 in features2: geom2 = feature2.geometry() punto2 = geom2.asPoint() x3 = punto2.x() y3 = punto2.y() d = ((x3 - x)**2 + (y3 - y)**2)**0.5 if d < distanciaminima: if feature2.id() == feature.id(): pass else: layer.startEditing() feature.setAttribute("distanc", 'no') print(feature2.id()) layer.updateFeature(feature) #Call commit to save the changes layer.commitChanges() categorias = [] sym = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'red', 'size': '3' }) categoria = QgsRendererCategory("no", sym, "No cumple") categorias.append(categoria) sym = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'blue', 'size': '2' }) categoria = QgsRendererCategory("", sym, "Cumple") categorias.append(categoria) renderer = QgsCategorizedSymbolRenderer("distanc", categorias) layer.setRenderer(renderer) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer #Configure label settings settings = QgsPalLayerSettings() settings.fieldName = field_names[ index_campo_seleccionado] #'name' textFormat = QgsTextFormat() textFormat.setSize(10) settings.setFormat(textFormat) #create and append a new rule root = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) rule = QgsRuleBasedLabeling.Rule(settings) #rule.setDescription(fieldName) rule.setFilterExpression(''' "distanc" = 'no' ''') root.appendChild(rule) #Apply label configuration rules = QgsRuleBasedLabeling(root) layer.setLabeling(rules) layer.setLabelsEnabled(True) layer.triggerRepaint() else: iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10)
def save_pois_points(self, points, layername="Geopunt_poi", saveToFile=None, sender=None, startFolder=None): attributes = [ QgsField("id", QVariant.Int), QgsField("thema", QVariant.String), QgsField("categorie", QVariant.String), QgsField("type", QVariant.String), QgsField("naam", QVariant.String), QgsField("telefoon", QVariant.String), QgsField("email", QVariant.String), #address QgsField("straat", QVariant.String), QgsField("huisnr", QVariant.String), QgsField("busnr", QVariant.String), QgsField("postcode", QVariant.String), QgsField("gemeente", QVariant.String), QgsField("link", QVariant.String), QgsField("lastupdate", QVariant.String), QgsField("owner", QVariant.String) ] if not QgsProject.instance().mapLayer(self.poilayerid): self.poilayer = QgsVectorLayer("Point", layername, "memory") self.poiProvider = self.poilayer.dataProvider() self.poiProvider.addAttributes(attributes) self.poilayer.updateFields() fields = self.poilayer.fields() for point in points: pt = QgsPointXY( point['location']['points'][0]['Point']['coordinates'][0], point['location']['points'][0]['Point']['coordinates'][1]) poiId = point["id"] if "categories" in list( point.keys()) and len(point["categories"]) > 0: theme = point["categories"][0]['value'] else: theme = '' if "categories" in list( point.keys()) and len(point["categories"]) > 1: category = point["categories"][1]['value'] else: category = '' if "categories" in point and len(point["categories"]) > 2: poiType = point["categories"][2]['value'] else: poiType = '' name = point["labels"][0]["value"] if "phone" in list(point.keys()): phone = point["phone"] else: phone = "" if "email" in list(point.keys()): email = point["email"] else: email = "" #address if "address" in list(point['location'].keys()): if "street" in list(point['location']["address"].keys()): straat = point['location']["address"]["street"] else: straat = '' if "streetnumber" in list(point['location']["address"].keys()): huisnr = point['location']["address"]["streetnumber"] else: huisnr = '' if "boxnumber" in list(point['location']["address"].keys()): busnr = point['location']["address"]["boxnumber"] else: boxnr = '' postcode = point['location']["address"]["postalcode"] gemeente = point['location']["address"]["municipality"] else: straat = "" huisnr = "" busnr = "" postcode = "" gemeente = "" if "links" in point: link = point["links"][0]['href'] else: link = "" tijd = point["updated"] if "authors" in point: owner = point["authors"][0]["value"] else: owner = "" # add a feature fet = QgsFeature(fields) #set geometry fromCrs = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform(fromCrs, self.poilayer.crs(), QgsProject.instance()) prjPt = xform.transform(pt) fet.setGeometry(QgsGeometry.fromPointXY(prjPt)) fet['id'] = int(poiId) fet['thema'] = theme fet['categorie'] = category fet['type'] = poiType fet['naam'] = name fet["email"] = email fet["telefoon"] = phone #address fet['straat'] = straat fet['huisnr'] = huisnr fet['busnr'] = busnr fet['postcode'] = postcode fet['gemeente'] = gemeente fet['link'] = link fet['lastupdate'] = tijd fet['owner'] = owner self.poiProvider.addFeatures([fet]) self.poilayer.updateExtents() if saveToFile and not QgsProject.instance().mapLayer(self.poilayerid): save = self._saveToFile(sender, startFolder) if save: fpath, flType = save error, msg = QgsVectorFileWriter.writeAsVectorFormat( self.poilayer, fileName=fpath, fileEncoding="utf-8", driverName=flType) if error == QgsVectorFileWriter.NoError: self.poilayer = QgsVectorLayer(fpath, layername, "ogr") self.poiProvider = self.poilayer.dataProvider() else: del self.poilayer, self.poiProvider raise Exception(msg) else: del self.poilayer, self.poiProvider return # add Labels text_format = QgsTextFormat() text_format.setSize(12) buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) palyr = QgsPalLayerSettings() text_format.setBuffer(buffer_settings) palyr.setFormat(text_format) palyr.enabled = True palyr.fieldName = 'naam' palyr.placement = QgsPalLayerSettings.Free self.poilayer.setLabelsEnabled(True) self.poilayer.setLabeling(QgsVectorLayerSimpleLabeling(palyr)) # add layer if not already QgsProject.instance().addMapLayer(self.poilayer) # store layer id and refresh self.poilayerid = self.poilayer.id() self.canvas.refresh()
def getLabels(layer, safeLayerName, outputProjectFileName): label_exp = '' labeltext = "" f = '' palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) if palyr.enabled and palyr.fieldName and palyr.fieldName != "": bgColor = palyr.shapeFillColor.name() borderWidth = palyr.shapeBorderWidth borderColor = palyr.shapeBorderColor.name() x = palyr.shapeSize.x() y = palyr.shapeSize.y() font = palyr.textFont fontSize = font.pointSize() fontFamily = font.family() fontItalic = font.italic() fontBold = font.bold() fontColor = palyr.textColor.name() fontUnderline = font.underline() xOffset = palyr.xOffset yOffset = palyr.yOffset styleStart = "'<div style=\"color: %s; font-size: %dpt; " % (fontColor, fontSize) if palyr.shapeDraw: styleStart += "background-color: %s; " % bgColor styleStart += "border: %dpx solid %s; " % (borderWidth, borderColor) if palyr.shapeSizeType == 0: styleStart += "padding: %dpx %dpx; " % (y, x) if palyr.shapeSizeType == 1: styleStart += "width: %dpx; " % x styleStart += "height: %dpx; " % y if fontBold: styleStart += "font-weight: bold; " if fontItalic: styleStart += "font-style: italic; " styleStart += "font-family: \\'%s\\', sans-serif;\">' + " % fontFamily styleEnd = " + '</div>'" if palyr.isExpression and palyr.enabled: exprFilename = os.path.join(outputProjectFileName, "js", "qgis2web_expressions.js") name = compile_to_file(palyr.getLabelExpression(), "label_%s" % safeLayerName, "Leaflet", exprFilename) js = "%s(context)" % (name) js = js.strip() f = js else: fn = palyr.fieldName f = "layer.feature.properties['%s']" % handleHiddenField(layer, fn) labeltext = ".bindTooltip((" + unicode(f) labeltext += " !== null?String(%s%s)%s:'')" % (styleStart, unicode(f), styleEnd) labeltext += ", {permanent: true, offset: [-0, -16], " labeltext += "className: 'css_%s'}" % safeLayerName labeltext += ").openTooltip();" labeltext = """ layer_%s.eachLayer(function(layer) { layer%s });""" % (safeLayerName, labeltext) else: labeltext = "" return labeltext
def parse_xml(self): """Parse the xml file. Returns false if there is failure.""" xml_file = QFile(self._xml_path) if not xml_file.open(QIODevice.ReadOnly): return False document = QDomDocument() if not document.setContent(xml_file): return False xml_file.close() document_element = document.documentElement() if document_element.tagName() != "qgis_style": return False # Get all the symbols self._symbols = [] symbols_element = document_element.firstChildElement("symbols") symbol_element = symbols_element.firstChildElement() context = QgsReadWriteContext() context.setPathResolver(QgsProject.instance().pathResolver()) while not symbol_element.isNull(): if symbol_element.tagName() == "symbol": symbol = QgsSymbolLayerUtils.loadSymbol( symbol_element, context) if symbol: self._symbols.append({ "name": symbol_element.attribute("name"), "symbol": symbol }) symbol_element = symbol_element.nextSiblingElement() # Get all the colorramps self._colorramps = [] ramps_element = document_element.firstChildElement("colorramps") ramp_element = ramps_element.firstChildElement() while not ramp_element.isNull(): if ramp_element.tagName() == "colorramp": colorramp = QgsSymbolLayerUtils.loadColorRamp(ramp_element) if colorramp: self._colorramps.append({ "name": ramp_element.attribute("name"), "colorramp": colorramp }) ramp_element = ramp_element.nextSiblingElement() # Get all the TextFormats - textformats - textformat self._textformats = [] textformats_element = document_element.firstChildElement("textformats") textformat_element = textformats_element.firstChildElement() while not textformat_element.isNull(): if textformat_element.tagName() == "textformat": textformat = QgsTextFormat() textformat.readXml(textformat_element, QgsReadWriteContext()) if textformat: self._textformats.append({ "name": textformat_element.attribute("name"), "textformat": textformat, }) textformat_element = textformat_element.nextSiblingElement() # Get all the LabelSettings - labelsettings - labelsetting - # QgsPalLayerSettings.readXML? self._labelsettings = [] labels_element = document_element.firstChildElement("labelsettings") label_element = labels_element.firstChildElement() while not label_element.isNull(): if label_element.tagName() == "labelsetting": labelsettings = QgsPalLayerSettings() labelsettings.readXml(label_element, QgsReadWriteContext()) if labelsettings: self._labelsettings.append({ "name": label_element.attribute("name"), "labelsettings": labelsettings, }) label_element = label_element.nextSiblingElement() return True
def utmGridlabelPlacer(self, root_rule, grid_spacing, extentsGeo, extentsUTM, px, py, UTM_num_x, UTM_num_y, trUTMLL, trLLUTM, dx, dy, dy0, dy1, fSize, fontType, scale, geo_bb_or, layer_bound): if grid_spacing > 0: # Bottom ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) ruletest = self.utm_grid_labeler( ruletest, extentsUTM[0], extentsUTM[1], 0, extentsGeo[1], extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, 1, True, dx[0], dy[1], dy0[1], 0, 'UTMBotTest', fSize, fontType, grid_spacing, scale, range(1), geo_bb_or, layer_bound) rulechild = ruletest.children()[0] if rulechild.settings().fieldName == 'fail': rangeUD = range(2, UTM_num_x + 1) else: rangeUD = range(1, UTM_num_x + 1) for u in rangeUD: root_rule = self.utm_grid_labeler( root_rule, extentsUTM[0], extentsUTM[1], 0, extentsGeo[1], extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u, True, dx[0], dy[1], dy0[1] + 0.4 * (scale) * fSize / 1.5, 0, 'UTMBot' + str(u), fSize, fontType, grid_spacing, scale, rangeUD, geo_bb_or, layer_bound) # Upper rangeUD = range(1, UTM_num_x + 1) for u in rangeUD: root_rule = self.utm_grid_labeler( root_rule, extentsUTM[0], extentsUTM[3], 0, extentsGeo[3], extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u, True, dx[1], dy[0], dy0[0] - 1.3 * (scale) * fSize / 1.5, 0, 'UTMUp' + str(u), fSize, fontType, grid_spacing, scale, rangeUD, geo_bb_or, layer_bound) # Left ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) ruletest = self.utm_grid_labeler( ruletest, extentsUTM[0], extentsUTM[1], extentsGeo[0], 0, extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, 1, False, dx[2], dy[3], dy0[3], dy1[1], 'UTMLeftTest', fSize, fontType, grid_spacing, scale, range(1), geo_bb_or, layer_bound) rulechild = ruletest.children()[0] if rulechild.settings().fieldName == 'fail': rangeLat = range(2, UTM_num_y + 1) else: rangeLat = range(1, UTM_num_y + 1) for u in rangeLat: if u == min(rangeLat): extra_dist = -3.2 * scale * fSize / 1.5 else: extra_dist = 0 root_rule = self.utm_grid_labeler( root_rule, extentsUTM[0], extentsUTM[1], extentsGeo[0], 0, extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u, False, dx[2] + extra_dist, dy[3], dy0[3], dy1[1], 'UTMLeft' + str(u), fSize, fontType, grid_spacing, scale, rangeLat, geo_bb_or, layer_bound) # Right rangeLat = range(1, UTM_num_y + 1) for u in rangeLat: root_rule = self.utm_grid_labeler( root_rule, extentsUTM[2], extentsUTM[1], extentsGeo[2], 0, extentsGeo[0], extentsGeo[1], px, py, trUTMLL, trLLUTM, u, False, dx[3], dy[3], dy0[3], dy1[1], 'UTMRight' + str(1), fSize, fontType, grid_spacing, scale, rangeLat, geo_bb_or, layer_bound) return root_rule
def get_style(self): """Get map styles. Get Fill color, label font, outline color. This function takes layer as input and configures style dictionary which is sent as HTTP request in order to adequatly represent map style on GIS Cloud. """ LOGGER.debug('Started map_styles function') if ISQGIS3: self.scale_pixels = \ iface.mapCanvas().mapSettings().outputDpi() / 72 else: self.scale_pixels = \ iface.mapCanvas().mapRenderer().outputDpi() / 72 self.unit_to_px = { "MM": 3.78 * self.scale_pixels, "Point": 1.33 * self.scale_pixels, "Inch": 96 * self.scale_pixels, # these two aren't yet supported by GC rendering, # so defaulting them to value of 1 px "MapUnit": None, "RenderMetersInMapUnits": None } layer_fromlevel = 0 layer_tolevel = 0 if self.qgis_layer.hasScaleBasedVisibility(): dpi = iface.mainWindow().physicalDpiX() max_scale_per_pixel = 156543.04 inches_per_meter = 39.37 factor = dpi * inches_per_meter * max_scale_per_pixel if self.qgis_layer.minimumScale() > 0: layer_fromlevel = int( round( math.log((factor / self.qgis_layer.minimumScale()), 2), 0)) if self.qgis_layer.maximumScale() > 0: layer_tolevel = int( round( math.log((factor / self.qgis_layer.maximumScale()), 2), 0)) if not ISQGIS3: # QGis2 has oposite logic with min/max scales # so we need to switch them (layer_tolevel, layer_fromlevel) = \ (layer_fromlevel, layer_tolevel) styles = [] tmp_dir = self.gc_api.qgis_api.tmp_dir if ISQGIS3: renderer = QgsRuleBasedRenderer.convertFromRenderer( self.qgis_layer.renderer()) else: renderer = QgsRuleBasedRendererV2.convertFromRenderer( self.qgis_layer.rendererV2()) for rule in renderer.rootRule().children(): symbol = rule.symbol() sym_size = 0 if self.layer.type[0] == "point": for layer_sym in symbol.symbolLayers(): temp_style = layer_sym.properties() self.convert_units_to_px(temp_style) if "size" in temp_style and \ float(temp_style["size"]) > sym_size: sym_size = float(temp_style["size"]) is_first_sym = True index = symbol.symbolLayerCount() while index > 0: index = index - 1 layer_sym = symbol.symbolLayer(index) temp_style = layer_sym.properties() self.convert_units_to_px(temp_style) val_label = None # in case of multiple symbolLayers() # labels should be set only once if is_first_sym: if ISQGIS3: if self.qgis_layer.labelsEnabled(): val_label = self.qgis_layer.labeling().settings() else: val_label = QgsPalLayerSettings() val_label.readFromLayer(self.qgis_layer) style = {} line_style = "line_style" line_width = 0 if self.layer.type[0] == "point": size = int(round(sym_size)) + 2 md5 = hashlib.md5() properties = str(temp_style) + self.dump_symbol_properties( layer_sym.subSymbol()) md5.update(properties.encode('utf-8')) symbol_file = "{}_{}.png".format(self.layer.id, md5.hexdigest()) style['iconsoverlap'] = 2 style['url'] = { "full_path": tmp_dir + '/' + symbol_file, "file": symbol_file, "symbol": symbol.clone(), "size": QSize(size, size) } elif self.layer.type[0] == "line": LOGGER.info('entered line_type part of function') LOGGER.info(temp_style) try: if u'line_color' in temp_style: style['color'] = ','.join( temp_style[u'line_color'].split(',')[0:3]) style['bordercolor'] = style['color'] if u'line_width' in temp_style: style['width'] = temp_style[u'line_width'] else: style['width'] = '1' line_width = float(style['width']) except Exception: LOGGER.info( 'Failed while mapping style for line vector layer', exc_info=True) if ('color' or 'bordercolor') not in style: style['color'] = '0,0,0' style['bordercolor'] = '0,0,0' LOGGER.info('Style is{}'.format(style)) # VectorPolygonLayer styles -> dashed line # and offset possibilities elif self.layer.type[0] == "polygon": line_style = "outline_style" has_border = not ("outline_style" in temp_style and temp_style["outline_style"] == "no") if layer_sym.layerType() == 'SimpleFill': if u'outline_color' in temp_style and has_border: style['bordercolor'] = \ ','.join( temp_style[u'outline_color'] .split(',')[0:3]) if u'outline_width' in temp_style and has_border: style['borderwidth'] = temp_style[u'outline_width'] if u'color' in temp_style and \ "style" in temp_style and \ temp_style["style"] == "solid": style['color'] = ','.join( temp_style[u'color'].split(',')[0:3]) elif layer_sym.layerType() == 'SimpleLine': if u'line_color' in temp_style: style['bordercolor'] = \ ','.join( temp_style[u'line_color'] .split(',')[0:3]) if u'line_width' in temp_style: style['line_width'] = temp_style[u'line_width'] elif u'color1' in temp_style: style['color'] = ','.join( temp_style[u'color1'].split(',')[0:3]) style['borderwidth'] = '1' if has_border: style['bordercolor'] = '0,0,0' else: style['bordercolor'] = '0,0,0' if has_border: style['borderwidth'] = '1' style['color'] = '0,0,0' if "borderwidth" in style: line_width = float(style['borderwidth']) if (layer_sym.layerType() != "SimpleFill" and layer_sym.layerType() != "SimpleLine") or \ ("style" in temp_style and not temp_style["style"] in ["solid", "no"]): if layer_sym.layerType() != "SimpleFill": temp_symbol = symbol.clone() tmp_sym_layer = temp_symbol.symbolLayer(index) while temp_symbol.symbolLayerCount() > 1: if temp_symbol.symbolLayer(0) == tmp_sym_layer: temp_symbol.deleteSymbolLayer(1) else: temp_symbol.deleteSymbolLayer(0) else: temp_style_hatch = temp_style.copy() temp_style_hatch["outline_style"] = "no" if ISQGIS3: temp_symbol = QgsFillSymbol.createSimple( temp_style_hatch) else: temp_symbol = QgsFillSymbolV2.createSimple( temp_style_hatch) properties = self.dump_symbol_properties(temp_symbol) md5 = hashlib.md5() md5.update(properties.encode('utf-8')) symbol_file = "{}_{}.png"\ .format(self.layer.id, md5.hexdigest()) style['hatchUrl'] = { "full_path": tmp_dir + '/' + symbol_file, "file": symbol_file, "symbol": temp_symbol, "size": QSize(64, 64) } if "use_custom_dash" in temp_style and \ temp_style["use_custom_dash"] == '1': style['dashed'] = temp_style[u'customdash'].replace( ';', ',') if ("dashed" not in style and line_style in temp_style and not temp_style[line_style] in ["solid", "no"]): process_dash_param(temp_style[line_style], line_width, style) if ISQGIS3: if val_label is not None: label_format = val_label.format() style['fontsize'] = label_format.size() style['labelfield'] = val_label.fieldName.lower() style['fontcolor'] = \ rgb_int2tuple(label_format.color().rgb()) if label_format.buffer().enabled(): style['outline'] = \ rgb_int2tuple( label_format.buffer().color().rgb()) if self.qgis_layer.geometryType() == 1: style['labelfield'] = '' style['textfield'] = val_label.fieldName.lower() if str(label_format.font().family()) in \ self.supported_fonts: style['fontname'] = label_format.font().family() else: style['fontname'] = 'Arial' LOGGER.info( ("Choosen font is not supported, " + "so every font style has been changed " + "to {0}").format(style['fontname'])) self.setup_label_offset(val_label, style) else: if val_label is not None and val_label.enabled: style['fontsize'] = val_label.textFont.pointSize() style['labelfield'] = val_label.fieldName.lower() style['fontcolor'] = rgb_int2tuple( val_label.textColor.rgb()) if val_label.bufferDraw: style['outline'] = rgb_int2tuple( val_label.bufferColor.rgb()) if self.qgis_layer.geometryType() == 1: style['labelfield'] = '' style['textfield'] = val_label.fieldName.lower() if str(val_label.textFont.family()) in \ self.supported_fonts: style['fontname'] = val_label.textFont.family() else: style['fontname'] = 'Arial' LOGGER.info("Choosen font is not supported, so " + "every font style has been changed " + " to {0}".format(style['fontname'])) self.setup_label_offset(val_label, style) if rule.filterExpression(): style['expression'] = rule.filterExpression().replace( '"', '') expression = self.qgis_layer.subsetString().replace('"', '') if expression and expression != '': if 'expression' in style and style['expression'] != '': style['expression'] = "(" + \ style['expression'] + \ ") AND (" + expression + ")" else: style['expression'] = expression if rule.label(): style['label'] = rule.label() style['showlabel'] = 't' \ if val_label is not None and \ 'labelfield' in style \ else 'f' style['visible'] = '1' if self.qgis_layer.hasScaleBasedVisibility(): factor = dpi * inches_per_meter * max_scale_per_pixel if ISQGIS3 and rule.minimumScale() > 0: style['fromlevel'] = \ int(round( math.log((factor / rule.minimumScale()), 2), 0)) elif layer_fromlevel > 0: style['fromlevel'] = layer_fromlevel if ISQGIS3 and rule.maximumScale() > 0: style['tolevel'] = \ int(round( math.log((factor / rule.maximumScale()), 2), 0)) elif layer_tolevel > 0: style['tolevel'] = layer_tolevel if 'borderwidth' in styles and \ style['borderwidth'] and \ float(style['borderwidth']) < 1: style['borderwidth'] = '1' key = "hatchUrl" if "hatchUrl" in style else "url" if key in style: asset = style[key] self.layer.assets.append(asset) LOGGER.info('URL for image upload: {}'.format( asset["file"])) style[key] = '/{}/qgis/map{}/{}'.format( self.gc_api.user.user_md5, self.gc_api.map.map_id, asset["file"]) styles.append(style) is_first_sym = False # all point styles are merged into one as we export the symbol # so it's not required to iterrate symbolLayers() if self.layer.type[0] == "point": break LOGGER.info('Styles function output {}'.format(styles)) LOGGER.debug('Finished map_styles function') return styles
def run_open_pli(self): file = QFileDialog.getOpenFileName( self.dlg, "Select pli-file ", self.directory, '*') # .ldb,*.pol,*.pli,*.xyn,*.xyz') # file = r'd:\projecten\11200569_Maas_G6\20171114 Deltashell2\files\dflowfm\invoer\j17_5-v1_landboundaries.ldb' self.directory, filename = os.path.split(file) layername, extension = os.path.splitext(filename) print(layername) if extension == '.xyz' or extension == '.xyn': vl = QgsVectorLayer("Point", layername, "memory") QgsMapLayerRegistry.instance().addMapLayer(vl) pr = vl.dataProvider() # add fields if extension == 'xyz': attribute = 'z' else: attribute = 'name' pr.addAttributes([QgsField(attribute, QVariant.String)]) vl.updateFields( ) # tell the vector layer to fetch changes from the provider with open(file) as f: for line in f: ls = line.strip().split('\t') X = float(ls[0]) Y = float(ls[1]) Z = ls[2] fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(X, Y))) fet.setAttributes([Z]) pr.addFeatures([fet]) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl.updateExtents() else: D = tek.tekal(file) # initialize D.info(file) # get file meta-data: all blocks vl = QgsVectorLayer("LineString", layername, "memory") QgsMapLayerRegistry.instance().addMapLayer(vl) pr = vl.dataProvider() attribute = "name" # add fields pr.addAttributes([QgsField(attribute, QVariant.String)]) vl.updateFields( ) # tell the vector layer to fetch changes from the provider for ii in range(len(D.blocks)): Name = D.blocks[ii].name M = D.read(ii) P = [] for ix in range(len(M[0])): P.append(QgsPoint(M[0][ix], M[1][ix])) # If line of just one points: duplicate if ix == 0: P.append(QgsPoint(M[0][ix] + 0.01, M[1][ix] + 0.01)) # add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPolyline(P)) fet.setAttributes([Name]) pr.addFeatures([fet]) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl.updateExtents() # Enable labels if attribute == 'name': label = QgsPalLayerSettings() label.readFromLayer(vl) label.enabled = True label.fieldName = attribute label.writeToLayer(vl)
def getLabels(layer, safeLayerName, outputProjectFileName, vts, vtLabels): label_exp = '' labeltext = "" f = '' palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) if palyr.enabled and palyr.fieldName and palyr.fieldName != "": bgColor = palyr.shapeFillColor.name() borderWidth = palyr.shapeBorderWidth borderColor = palyr.shapeBorderColor.name() x = palyr.shapeSize.x() y = palyr.shapeSize.y() font = palyr.textFont fontSize = font.pointSize() fontFamily = font.family() fontItalic = font.italic() fontBold = font.bold() fontColor = palyr.textColor.name() fontUnderline = font.underline() xOffset = palyr.xOffset yOffset = palyr.yOffset styleStart = "'<div style=\"color: %s; font-size: %dpt; " % (fontColor, fontSize) if palyr.shapeDraw: styleStart += "background-color: %s; " % bgColor styleStart += "border: %dpx solid %s; " % (borderWidth, borderColor) if palyr.shapeSizeType == 0: styleStart += "padding: %dpx %dpx; " % (y, x) if palyr.shapeSizeType == 1: styleStart += "width: %dpx; " % x styleStart += "height: %dpx; " % y if fontBold: styleStart += "font-weight: bold; " if fontItalic: styleStart += "font-style: italic; " styleStart += "font-family: \\'%s\\', sans-serif;\">' + " % fontFamily styleEnd = " + '</div>'" if palyr.isExpression and palyr.enabled: exprFilename = os.path.join(outputProjectFileName, "js", "qgis2web_expressions.js") name = compile_to_file(palyr.getLabelExpression(), "label_%s" % safeLayerName, "Leaflet", exprFilename) js = "%s(context)" % (name) js = js.strip() f = js else: fn = palyr.fieldName f = "layer.feature.properties['%s']" % handleHiddenField(layer, fn) labeltext = ".bindTooltip((" + unicode(f) labeltext += " !== null?String(%s%s)%s:'')" % (styleStart, unicode(f), styleEnd) labeltext += ", {permanent: true, offset: [-0, -16], " labeltext += "className: 'css_%s'}" % safeLayerName labeltext += ");" if vts is None: labeltext = """ var i = 0; layer_%s.eachLayer(function(layer) { var context = { feature: layer.feature, variables: {} }; layer%s labels.push(layer); totalMarkers += 1; layer.added = true; addLabel(layer, i); i++; });""" % (safeLayerName, labeltext) else: if palyr.isExpression and palyr.enabled: labelVal = f else: labelVal = "feature.properties['%s']" % palyr.fieldName labeltext = """ if (vtLayer.name === '%s') { var latlng = this.vtGeometryToLatLng(feature.geometry[0], vtLayer, tileCoords) marker = new L.CircleMarker(latlng, {stroke: false, fill: false}); marker.bindTooltip(%s, {permanent: true, direction: 'center'}).openTooltip(); this.addUserLayer(marker, tileCoords); }""" % (layer.name(), labelVal) if vts not in vtLabels: vtLabels[vts] = labeltext else: vtLabels[vts] = vtLabels[vts] + labeltext labeltext = "" else: labeltext = "" return labeltext, vtLabels
def utmGridlabelPlacer(self, root_rule, grid_spacing, geo_bound_bb, bound_UTM_bb, geo_number_x, geo_number_y, UTM_num_x, UTM_num_y, trUTMLL, trLLUTM, dx, dy, dy0, dy1, fSize, fontType, scale, utmcheck, geo_bb_or): xmin_source = float(geo_bound_bb.split()[1]) ymin_source = float(geo_bound_bb.split()[2]) xmax_source = float(geo_bound_bb.split()[3]) ymax_source = float(geo_bound_bb.split()[4]) xmin_UTM = float(bound_UTM_bb.split()[1]) ymin_UTM = float(bound_UTM_bb.split()[2]) xmax_UTM = float(bound_UTM_bb.split()[3]) ymax_UTM = float(bound_UTM_bb.split()[4]) px = (xmax_source - xmin_source) / (geo_number_x + 1) py = (ymax_source - ymin_source) / (geo_number_y + 1) if grid_spacing > 0: # Bottom ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) ruletest = self.utm_grid_labeler( ruletest, xmin_UTM, ymin_UTM, 0, ymin_source, px, py, trUTMLL, trLLUTM, 1, True, 0, dy[1] + 0.4 * (scale) * fSize / 1.5, dy0[1] + 0.4 * (scale) * fSize / 1.5, 0, 'Top', 'Center', 'UTMBotTest', fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, range(1), geo_bb_or) rulechild = ruletest.children()[0] if rulechild.settings().fieldName == 'fail': rangeUD = range(2, UTM_num_x + 1) else: rangeUD = range(1, UTM_num_x + 1) for u in rangeUD: root_rule = self.utm_grid_labeler( root_rule, xmin_UTM, ymin_UTM, 0, ymin_source, px, py, trUTMLL, trLLUTM, u, True, 0, dy[1] + 0.4 * (scale) * fSize / 1.5, dy0[1] + 0.4 * (scale) * fSize / 1.5, 0, 'Top', 'Center', 'UTMBot' + str(u), fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, rangeUD, geo_bb_or) # Upper rangeUD = range(1, UTM_num_x + 1) for u in rangeUD: root_rule = self.utm_grid_labeler( root_rule, xmin_UTM, ymax_UTM, 0, ymax_source, px, py, trUTMLL, trLLUTM, u, True, 0, dy[0] - 1.3 * (scale) * fSize / 1.5, dy0[0] - 1.3 * (scale) * fSize / 1.5, 0, 'Bottom', 'Center', 'UTMUp' + str(u), fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, rangeUD, geo_bb_or) # Left ruletest = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings()) ruletest = self.utm_grid_labeler( ruletest, xmin_UTM, ymin_UTM, xmin_source, 0, px, py, trUTMLL, trLLUTM, 1, False, dx[2] - 3.1 * scale * fSize / 1.5, dy[3], dy0[3], dy1[1], 'Bottom', 'Center', 'UTMLeftTest', fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, range(1), geo_bb_or) rulechild = ruletest.children()[0] if rulechild.settings().fieldName == 'fail': rangeLat = range(2, UTM_num_y + 1) else: rangeLat = range(1, UTM_num_y + 1) for u in rangeLat: if u == min(rangeLat): extra_dist = -2.0 * scale * fSize / 1.5 else: extra_dist = 0 root_rule = self.utm_grid_labeler( root_rule, xmin_UTM, ymin_UTM, xmin_source, 0, px, py, trUTMLL, trLLUTM, u, False, dx[2] + extra_dist, dy[3], dy0[3], dy1[1], 'Bottom', 'Center', 'UTMLeft' + str(u), fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, rangeLat, geo_bb_or) # Right rangeLat = range(1, UTM_num_y + 1) for u in rangeLat: root_rule = self.utm_grid_labeler( root_rule, xmax_UTM, ymin_UTM, xmax_source, 0, px, py, trUTMLL, trLLUTM, u, False, dx[3], dy[3], dy0[3], dy1[1], '', 'Center', 'UTMRight' + str(1), fSize, fontType, grid_spacing, scale, utmcheck, geo_bound_bb, rangeLat, geo_bb_or) return root_rule
def getPopups(layer, safeLayerName, highlight, popupsOnHover, popup, vts): if vts is not None: return "", "" palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) fields = layer.pendingFields() field_names = popup.keys() field_vals = popup.values() html_prov = False f = palyr.fieldName table = "" for field in popup: tablestart = "'<table>\\" row = "" for field, val in zip(field_names, field_vals): fieldIndex = fields.indexFromName(unicode(field)) formCfg = layer.editFormConfig() editorWidget = formCfg.widgetType(fieldIndex) if (editorWidget == QgsVectorLayer.Hidden or editorWidget == 'Hidden'): continue row += """ <tr>\\""" if val == 'inline label': row += """ <th scope="row">""" row += layer.attributeDisplayName(fieldIndex) row += """</th>\\ <td>""" else: row += """ <td colspan="2">""" if val == "header label": row += '<strong>' row += layer.attributeDisplayName(fieldIndex) row += '</strong><br />' row += "' + " row += "(feature.properties[\'" + unicode(field) + "\'] " row += "!== null ? " if (editorWidget == QgsVectorLayer.Photo or editorWidget == 'Photo'): row += "'<img src=\"images/' + " row += "String(feature.properties['" + unicode(field) row += "']).replace(/[\\\/:]/g, '_').trim()" row += " + '\">' : '') + '" else: row += "Autolinker.link(" row += "String(feature.properties['" + unicode(field) row += "'])) : '') + '" row += """</td>\\ </tr>\\""" tableend = """ </table>'""" table = tablestart + row + tableend if popup != 0 and table != "": popFuncs = popFuncsScript(table) else: popFuncs = "" new_pop = popupScript(safeLayerName, popFuncs, highlight, popupsOnHover) return new_pop, popFuncs
def run(self): print("paso por el run") #coloco el puntero arriba del todo QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0) def haceelcruce(x1, y1, ang1, x2, y2, ang2): #saco las pendientes m1 = (1 / math.tan(math.radians(ang1 + 0.000001))) m2 = (1 / math.tan(math.radians(ang2 + 0.000001))) #print ("m1") #print (m1) #print("m2") #print (m2) #saco las coordenadas de x e y x = ((y2 - y1) + (m1 * x1) - (m2 * x2)) / ((m1 - m2) + 0.000001) y = m1 * x + y1 - m1 * x1 #compruebo que el cruce no es erroneo if ang1 > 0 and ang1 < 180 and x < x1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 180 and ang1 < 360 and x > x1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 0 and ang1 < 90 and y < y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 270 and ang1 < 360 and y < y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 0 if ang1 > 90 and ang1 < 270 and y > y1: iface.messageBar().pushMessage( "OJO: LAS VISUALES NO SE CRUZAN", qgisCore.Qgis.Info, 5) x, y, error = 0, 0, 9999999999999999999999999 else: #calculo el error d1a = math.sqrt((x - x1)**2 + (y - y1)**2) d2a = math.sqrt((x - x2)**2 + (y - y2)**2) d12 = math.sqrt((x2 - x1)**2 + (y2 - y1)**2) A = math.acos((d1a**2 + d2a**2 - d12**2) / (2 * d1a * d2a)) if math.degrees(A) > 90: A = math.pi - A distancias = [d1a, d2a] distancias.sort(reverse=True) mayordistancia = distancias[0] error = mayordistancia * erroralidada / (math.sin(A / 2) + 0.000001) #print (ang1,ang2) #print (x,y,error) return x, y, error def generapunto(x, y): #creo una capa de puntos temporal con los resultados # create layer vl = QgsVectorLayer("Point?crs=epsg:25830", "Pto_Cruce", "memory") pr = vl.dataProvider() #print ("ok creada la capa") vl.startEditing() # add fields pr.addAttributes([ QgsField("error", QVariant.Int), QgsField("x", QVariant.Int), QgsField("y", QVariant.Double) ]) vl.updateFields() # tell the vector layer to fetch changes from the provider #print ("ok creados los campos") # add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y))) fet.setAttributes([error, x, y]) pr.addFeatures([fet]) #print ("ok, anadido el elemento con error "+str(error)) #cambio la simbologia symbol = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'orange', 'size': '5', }) vl.renderer().setSymbol(symbol) # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer #vl.updateExtents() vl.commitChanges() #vl.updateExtents() # show the point if x != 0 and y != 0: QgsProject.instance().addMapLayers([vl]) canvas = self.iface.mapCanvas() #canvas.setExtent(vl.extent()) #vl.updateFieldMap() def generalinea(x, y, angulo): m = (1 / math.tan(math.radians(angulo + 0.000001))) x1 = x + 100000 * math.sin(math.radians(angulo + 0.0000001)) y1 = y - m * (x - x1) line_start = QgsPoint(x, y) line_end = QgsPoint(x1, y1) #print (m) # create a new memory layer v_layer = QgsVectorLayer("LineString?crs=epsg:25830", "visual", "memory") pr = v_layer.dataProvider() # create a new feature seg = QgsFeature() # add the geometry to the feature, seg.setGeometry(QgsGeometry.fromPolyline([line_start, line_end])) # add the geometry to the layer pr.addFeatures([seg]) # update extent of the layer (not necessary) v_layer.updateExtents() #cambio la simbologia symbol3 = QgsLineSymbol.createSimple({ 'penstyle': 'solid', 'color': 'yellow', 'width': '2' }) v_layer.renderer().setSymbol(symbol3) # show the line QgsProject.instance().addMapLayers([v_layer]) def deg_to_dms(deg, type='lat'): decimals, number = math.modf(deg) d = int(number) m = int(decimals * 60) s = (deg - d - m / 60) * 3600.00 compass = {'lat': ('N', 'S'), 'lon': ('E', 'W')} compass_str = compass[type][0 if d >= 0 else 1] return '{}º{}\'{:.2f}"{}'.format(abs(d), abs(m), abs(s), compass_str) erroralidada = 1 #selecciono la capa de las torretas global rutapuestosvigiancia layer = QgsVectorLayer(rutapuestosvigiancia, '42_Puestos_vigilancia_etrs89', 'ogr') time.sleep(1) #layer = iface.activeLayer() ## ojo comprobar que layer existe """if layer is None or (layer.type() == RasterLayer): iface.messageBar().pushMessage("Warning:", u"Seleciona la capa de los puestos de vigilancia", QgsMessageBar.WARNING, 10) """ #genero una lista con las torres y ls coordenadas misdatos = [] feats = [feat for feat in layer.getFeatures()] for feature in feats: if feature.geometry().type( ) != 0: #0 es ptos, 1 lineas y 2 poligonos QGis.Point: iface.messageBar().pushMessage( "Warning:", u"Debe selecionar una capa de puntos", QgsMessageBar.WARNING, 10) point = [] idTM = layer.dataProvider().fieldNameIndex('Nombre') idx = layer.dataProvider().fieldNameIndex('x') idy = layer.dataProvider().fieldNameIndex('y') point = [ feature.attributes()[idTM], feature.attributes()[idx], feature.attributes()[idy] ] misdatos.append(point) #trato de rellenar el desplegable con las torretas #self.dlg.cb1.clear() #ordeno por el primer elemento misdatos.sort(key=lambda x: x[0]) #anado un elemneto enblanco en el desplegable self.dlg.cb1.clear() self.dlg.cb2.clear() self.dlg.cb3.clear() self.dlg.cb4.clear() self.dlg.cb1.addItem("") self.dlg.cb2.addItem("") self.dlg.cb3.addItem("") self.dlg.cb4.addItem("") for element in misdatos: self.dlg.cb1.addItem(element[0]) self.dlg.cb2.addItem(element[0]) self.dlg.cb3.addItem(element[0]) self.dlg.cb4.addItem(element[0]) #count vertices if there is layer in project in order to show it when dialog is loaded #layer = self.dlg.cb1.itemData(self.cb1.currentIndex()) """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False #self.dlg = SilvilidarDialog() #la siguiente linea inicia el boton de cargar carpetas, peta al cerrar el qgis, deberia poner algun close o algo #self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder) #print("inicio el boton en el gui") #self.dlg.pushButton_select_path.setEnabled(True) #print ("pone le boton como habiltado") # show the dialog self.dlg.show() #self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder) # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. #print ("lo imprime si le doy a aceptar en el dialogo") #la carpeta la he cogido al pulsar el boton de la carpeta #meto aqui variables que luego deberan estar en la cajita OJO torret1 = self.dlg.cb1.currentIndex() torret2 = self.dlg.cb2.currentIndex() torret3 = self.dlg.cb3.currentIndex() torret4 = self.dlg.cb4.currentIndex() angulo1 = self.dlg.ang1.text() ##displayText() angulo2 = self.dlg.ang2.text() ##displayText() angulo3 = self.dlg.ang3.text() ##displayText() angulo4 = self.dlg.ang4.text() ##displayText() if angulo2 == "": angulo2 = 9999 if angulo3 == "": angulo3 = 9999 if angulo4 == "": angulo4 = 9999 try: ang1 = float(angulo1) ang2 = float(angulo2) ang3 = float(angulo3) ang4 = float(angulo4) except: pass #print (misdatos) torre1 = misdatos[int(torret1) - 1][0] x1 = float(misdatos[int(torret1) - 1][1]) y1 = float(misdatos[int(torret1) - 1][2]) torre2 = misdatos[int(torret2) - 1][0] x2 = float(misdatos[int(torret2) - 1][1]) y2 = float(misdatos[int(torret2) - 1][2]) torre3 = misdatos[int(torret3) - 1][0] x3 = float(misdatos[int(torret3) - 1][1]) y3 = float(misdatos[int(torret3) - 1][2]) torre4 = misdatos[int(torret4) - 1][0] x4 = float(misdatos[int(torret4) - 1][1]) y4 = float(misdatos[int(torret4) - 1][2]) #print (angulo1, angulo2, angulo3, angulo4) #print (torret1) #print (torre1, x1, y1) #print (torret2) #print (torre2, x2, y2) #print (torret3) #print (torret4) generalinea(x1, y1, ang1) resultado = [] if angulo2 != 9999: generalinea(x2, y2, ang2) x, y, error = haceelcruce(x1, y1, ang1, x2, y2, ang2) #print ("hecho el cruce") #print (x,y, error) generapunto(x, y) resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) if angulo3 != 9999: generalinea(x3, y3, ang3) x, y, error = haceelcruce(x1, y1, ang1, x3, y3, ang3) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x2, y2, ang2, x3, y3, ang3) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) if angulo4 != 9999: generalinea(x4, y4, ang4) #print ("empiezo el angulo4") x, y, error = haceelcruce(x1, y1, ang1, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x2, y2, ang2, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) x, y, error = haceelcruce(x3, y3, ang3, x4, y4, ang4) generapunto(x, y) if error < resultado[2]: resultado = [] resultado.append(x) resultado.append(y) resultado.append(error) #hago una nueva capa con el mejor resultado if resultado != []: x, y, error = resultado[0], resultado[1], resultado[2] if x != 0 and y != 0: #creo una capa temporal con los resultados # create layer vl2 = QgsVectorLayer("Point?crs=epsg:25830", "MejorResultado", "memory") pr2 = vl2.dataProvider() #print ("ok creada la capa resultado final") vl2.startEditing() #calculo las coordenadas geograficas huso = 30 origenProj = pyproj.Proj(proj="utm", zone=huso, ellps="WGS84", units="m") destinoProj = pyproj.Proj(proj='longlat', ellps='WGS84', datum='WGS84') xxx, yyy = pyproj.transform(origenProj, destinoProj, x, y) xx = (deg_to_dms(xxx, 'lon')) yy = (deg_to_dms(yyy)) # add fields pr2.addAttributes([ QgsField("error", QVariant.Int), QgsField("x", QVariant.Double), QgsField("y", QVariant.Double), QgsField("xx", QVariant.String), QgsField("yy", QVariant.String) ]) vl2.updateFields() # tell the vector layer to fetch changes from the provider #print ("ok creados los campos") #$add a feature fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y))) fet.setAttributes([error, x, y, xx, yy]) pr2.addFeatures([fet]) print("MEJOR RESULTADO") print(int(resultado[0]), int(resultado[1])) #print ("ok, creda la capa con el resultado final") #cambio la simbologia symbol = QgsMarkerSymbol.createSimple({ 'name': 'circle', 'color': 'red', 'size': '10', }) vl2.renderer().setSymbol(symbol) #etiqueto con la x e y layer_settings = QgsPalLayerSettings() text_format = QgsTextFormat() text_format.setFont(QFont("Arial", 12)) text_format.setSize(12) text_format.setColor(QColor("Orange")) # meto un buffer a la etiqueta buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(1) buffer_settings.setColor(QColor("white")) text_format.setBuffer(buffer_settings) layer_settings.setFormat(text_format) #myexp=QgsExpression('''concat('X: ',"X",' Y: ',"Y")''') layer_settings.fieldName = '''concat('X: ',round("X",0),' Y: ',round("Y",0),'\n','Lat: ',"yy",' Lon: ',"xx")''' layer_settings.isExpression = True #layer_settings.placement = 7 #layer_settings.quadOffset = QgsPalLayerSettings.QuadrantBelow #layer_settings.yOffset = 1 layer_settings.enabled = True layer_settings = QgsVectorLayerSimpleLabeling( layer_settings) vl2.setLabelsEnabled(True) vl2.setLabeling(layer_settings) vl2.triggerRepaint() # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer vl2.updateExtents() vl2.commitChanges() vl2.updateExtents() canvas = self.iface.mapCanvas() canvas.setExtent(vl2.extent()) self.iface.mapCanvas().zoomScale(100000) #QgsProject.instance().addMapLayer(vl) QgsProject.instance().addMapLayer(vl2) pass
def convert2CartoCSS(self, layer): """Convert layer symbology to CartoCSS""" renderer = layer.rendererV2() carto_css = '' label_css = '' label_settings = QgsPalLayerSettings() label_settings.readFromLayer(layer) if label_settings.enabled: d = { 'layername': '#' + layer.tableName(), 'field': label_settings.getLabelExpression().dump(), # TODO Get font size 'size': 11, 'color': label_settings.textColor.name() } filein = open(QgisCartoDB.CartoDBPlugin.PLUGIN_DIR + '/templates/labels.less') label_css = Template(filein.read()) label_css = label_css.substitute(d) # qDebug('Label CSS: ' + label_css) # CSS for single symbols if renderer.type() == 'singleSymbol': symbol = renderer.symbol() carto_css = self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName()) # CSS for categorized symbols elif renderer.type() == 'categorizedSymbol': # qDebug('Categorized: ' + renderer.classAttribute()) for cat in renderer.categories(): symbol = cat.symbol() # qDebug("%s: %s type: %s" % (str(cat.value()), cat.label(), type(cat.value()))) if cat.value() is not None and cat.value() != '' and not isinstance(cat.value(), QPyNullVariant): if isinstance(cat.value(), (int, float, long)) or (isinstance(cat.value(), str) and cat.value().isdecimal()): value = unicode(cat.value()) else: value = unicode('"' + cat.value() + '"') value = str(value.encode('utf8', 'ignore')) # qDebug('Value {}'.format(value)) style_name = '#{}[{}={}]'.format(layer.tableName(), renderer.classAttribute(), value).decode('utf8') carto_css = carto_css + \ self.symbol2CartoCSS(layer, symbol, style_name) else: carto_css = self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName()) + carto_css # CSS for graduated symbols elif renderer.type() == 'graduatedSymbol': # qDebug('Graduated') def upperValue(ran): """Get upper value from range""" return ran.upperValue() ranges = sorted(renderer.ranges(), key=upperValue, reverse=True) for ran in ranges: symbol = ran.symbol() ''' qDebug("%f - %f: %s" % ( ran.lowerValue(), ran.upperValue(), ran.label() )) ''' carto_css = carto_css + \ self.symbol2CartoCSS(layer, symbol, '#' + layer.tableName() + \ '[' + renderer.classAttribute() + '<=' + str(ran.upperValue()) + ']') return '/** Styles designed from QGISCartoDB Plugin */\n\n' + carto_css + '\n' + label_css
def testCreateProperty(self): s = QgsAuxiliaryStorage() self.assertTrue(s.isValid()) # Create a new auxiliary layer with 'pk' as key vl = createLayer() pkf = vl.fields().field(vl.fields().indexOf('pk')) al = s.createAuxiliaryLayer(pkf, vl) self.assertTrue(al.isValid()) vl.setAuxiliaryLayer(al) # Create a new labeling property on layer without labels key = QgsPalLayerSettings.PositionX index = QgsAuxiliaryLayer.createProperty(key, vl) self.assertEqual(index, -1) vl.setLabeling(QgsVectorLayerSimpleLabeling(QgsPalLayerSettings())) index = QgsAuxiliaryLayer.createProperty(key, vl) p = QgsPalLayerSettings.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) # with existing property key = QgsPalLayerSettings.PositionY settings = QgsPalLayerSettings() settings.dataDefinedProperties().setProperty( key, QgsProperty.fromExpression('$y + 20')) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) # without overwriting existing, property should be upgraded to coalesce("aux field", 'existing expression') type index = QgsAuxiliaryLayer.createProperty(key, vl, False) p = QgsPalLayerSettings.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertTrue( settings.dataDefinedProperties().property(key).isActive()) self.assertEqual( settings.dataDefinedProperties().property(key).asExpression(), 'coalesce("auxiliary_storage_labeling_positiony",$y + 20)') # with overwrite existing key = QgsPalLayerSettings.Show settings = QgsPalLayerSettings() settings.dataDefinedProperties().setProperty( key, QgsProperty.fromExpression('$y > 20')) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) # existing property should be discarded index = QgsAuxiliaryLayer.createProperty(key, vl, True) p = QgsPalLayerSettings.propertyDefinitions()[key] afName = QgsAuxiliaryLayer.nameFromProperty(p, True) afIndex = vl.fields().indexOf(afName) self.assertEqual(index, afIndex) settings = vl.labeling().settings() self.assertTrue( settings.dataDefinedProperties().property(key).isActive()) self.assertEqual( settings.dataDefinedProperties().property(key).field(), 'auxiliary_storage_labeling_show')
def __init__(self): QMainWindow.__init__(self) #self.setWindowFlags(Qt.CustomizeWindowHint) #self.setWindowFlags(Qt.WindowMinMaxButtonsHint) # creating map canvas, which draws the maplayers # setting up features like canvas color self.canvas = QgsMapCanvas() self.canvas.setMinimumSize(550, 700) self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.canvas.setCanvasColor(Qt.white) self.canvas.setSelectionColor(QColor(255,255,26,200)) self.canvas.enableAntiAliasing(True) self.canvas.setParallelRenderingEnabled(True) # empty list for selected polygons self.selected_features = [] # setting up label settings: object below houses all of them self.label_settings = QgsPalLayerSettings() # object for text settings text_format = QgsTextFormat() text_format.setFont(QFont("Helvetica", 12)) text_format.setSize(7) # setting up a white buffer around the labels buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(0.65) buffer_settings.setColor(Qt.white) text_format.setBuffer(buffer_settings) # label settings: # fieldName = which field is shown as the label (currently Finnish name) # placement = labels can be placed differently in relation to one another # - see documentation for details self.label_settings.setFormat(text_format) self.label_settings.fieldName = "namefin" self.label_settings.placement = 0 self.label_settings.enabled = True # Qmainwindow requires a central widget. Canvas is placed self.setCentralWidget(self.canvas) # creating each desired action self.actionGet = QAction("Return selected and close", self) self.actionPan = QAction("Pan tool", self) self.actionSelect = QAction("Select tool", self) self.actionClear = QAction("Clear selection", self) self.actionCancel = QAction("Cancel and close", self) # these two function as on/off. the rest are clickable self.actionPan.setCheckable(True) self.actionSelect.setCheckable(True) # when actions are clicked, do corresponding function self.actionPan.triggered.connect(self.pan) self.actionSelect.triggered.connect(self.select) self.actionClear.triggered.connect(self.clearSelection) self.actionGet.triggered.connect(self.finishedSelection) self.actionCancel.triggered.connect(self.cancel) # toolbar at the top of the screen: houses actions as buttons # change order here to change their placement on window self.toolbar = self.addToolBar("Canvas actions") self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu) self.toolbar.setMovable(False) self.toolbar.addAction(self.actionGet) self.toolbar.addAction(self.actionPan) self.toolbar.addAction(self.actionSelect) self.toolbar.addAction(self.actionClear) self.toolbar.addAction(self.actionCancel) # link actions to premade map tools self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(self.actionPan) self.toolSelect = QgsMapToolIdentifyFeature(self.canvas) self.toolSelect.setAction(self.actionSelect) self.toolSelect.featureIdentified.connect(self.selectFeature) self.blocks_flag = False self.selection_rectangle = False # set select tool as default self.select()
def saveToLayer(self): units = self.unitDesignator() canvasCrs = self.canvas.mapSettings().destinationCrs() fields = QgsFields() fields.append(QgsField("label", QVariant.String)) fields.append(QgsField("value", QVariant.Double)) fields.append(QgsField("units", QVariant.String)) fields.append(QgsField("heading_to", QVariant.Double)) fields.append(QgsField("heading_from", QVariant.Double)) fields.append(QgsField("total_dist", QVariant.Double)) layer = QgsVectorLayer("LineString?crs={}".format(canvasCrs.authid()), "Measurements", "memory") dp = layer.dataProvider() dp.addAttributes(fields) layer.updateFields() num = len(self.capturedPoints) total = 0.0 for i in range(1, num): (distance, startA, endA) = self.calcParameters(self.capturedPoints[i - 1], self.capturedPoints[i]) total += distance total = self.unitDistance(total) for i in range(1, num): (distance, startA, endA) = self.calcParameters(self.capturedPoints[i - 1], self.capturedPoints[i]) pts = self.getLinePts(distance, self.capturedPoints[i - 1], self.capturedPoints[i]) distance = self.unitDistance(distance) feat = QgsFeature(layer.fields()) feat.setAttribute(0, "{:.2f} {}".format(distance, units)) feat.setAttribute(1, distance) feat.setAttribute(2, units) feat.setAttribute(3, startA) feat.setAttribute(4, endA) feat.setAttribute(5, total) feat.setGeometry(QgsGeometry.fromPolylineXY(pts)) dp.addFeatures([feat]) label = QgsPalLayerSettings() label.fieldName = 'label' try: label.placement = QgsPalLayerSettings.Line except: label.placement = QgsPalLayerSettings.AboveLine format = label.format() format.setColor(settings.measureTextColor) format.setNamedStyle('Bold') label.setFormat(format) labeling = QgsVectorLayerSimpleLabeling(label) layer.setLabeling(labeling) layer.setLabelsEnabled(True) renderer = layer.renderer() renderer.symbol().setColor(settings.measureLineColor) renderer.symbol().setWidth(0.5) layer.updateExtents() QgsProject.instance().addMapLayer(layer)
def test_line_settings(self): """ Test line settings """ settings = QgsLabelLineSettings() settings.setPlacementFlags(QgsLabeling.LinePlacementFlag.OnLine) self.assertEqual(settings.placementFlags(), QgsLabeling.LinePlacementFlag.OnLine) settings.setPlacementFlags( QgsLabeling.LinePlacementFlag.OnLine | QgsLabeling.LinePlacementFlag.MapOrientation) self.assertEqual( settings.placementFlags(), QgsLabeling.LinePlacementFlag.OnLine | QgsLabeling.LinePlacementFlag.MapOrientation) settings.setMergeLines(True) self.assertTrue(settings.mergeLines()) settings.setMergeLines(False) self.assertFalse(settings.mergeLines()) settings.setAddDirectionSymbol(True) self.assertTrue(settings.addDirectionSymbol()) settings.setAddDirectionSymbol(False) self.assertFalse(settings.addDirectionSymbol()) settings.setLeftDirectionSymbol('left') self.assertEqual(settings.leftDirectionSymbol(), 'left') settings.setRightDirectionSymbol('right') self.assertEqual(settings.rightDirectionSymbol(), 'right') settings.setReverseDirectionSymbol(True) self.assertTrue(settings.reverseDirectionSymbol()) settings.setReverseDirectionSymbol(False) self.assertFalse(settings.reverseDirectionSymbol()) settings.setDirectionSymbolPlacement( QgsLabelLineSettings.DirectionSymbolPlacement.SymbolBelow) self.assertEqual( settings.directionSymbolPlacement(), QgsLabelLineSettings.DirectionSymbolPlacement.SymbolBelow) settings.setDirectionSymbolPlacement( QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove) self.assertEqual( settings.directionSymbolPlacement(), QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove) settings.setOverrunDistance(5.6) self.assertEqual(settings.overrunDistance(), 5.6) settings.setOverrunDistanceUnit(QgsUnitTypes.RenderInches) self.assertEqual(settings.overrunDistanceUnit(), QgsUnitTypes.RenderInches) scale = QgsMapUnitScale(1, 2) settings.setOverrunDistanceMapUnitScale(scale) self.assertEqual(settings.overrunDistanceMapUnitScale().minScale, 1) self.assertEqual(settings.overrunDistanceMapUnitScale().maxScale, 2) settings.setLineAnchorPercent(0.3) self.assertEqual(settings.lineAnchorPercent(), 0.3) # check that compatibility code works pal_settings = QgsPalLayerSettings() pal_settings.placementFlags = QgsPalLayerSettings.OnLine | QgsPalLayerSettings.MapOrientation self.assertEqual(pal_settings.placementFlags, 9) self.assertTrue( pal_settings.lineSettings().placementFlags(), QgsLabeling.LinePlacementFlag.OnLine | QgsLabeling.LinePlacementFlag.MapOrientation) pal_settings.mergeLines = True self.assertTrue(pal_settings.mergeLines) self.assertTrue(pal_settings.lineSettings().mergeLines()) pal_settings.mergeLines = False self.assertFalse(pal_settings.mergeLines) self.assertFalse(pal_settings.lineSettings().mergeLines()) pal_settings.addDirectionSymbol = True self.assertTrue(pal_settings.addDirectionSymbol) self.assertTrue(pal_settings.lineSettings().addDirectionSymbol()) pal_settings.addDirectionSymbol = False self.assertFalse(pal_settings.addDirectionSymbol) self.assertFalse(pal_settings.lineSettings().addDirectionSymbol()) pal_settings.leftDirectionSymbol = 'l' self.assertEqual(pal_settings.leftDirectionSymbol, 'l') self.assertEqual(pal_settings.lineSettings().leftDirectionSymbol(), 'l') pal_settings.rightDirectionSymbol = 'r' self.assertEqual(pal_settings.rightDirectionSymbol, 'r') self.assertEqual(pal_settings.lineSettings().rightDirectionSymbol(), 'r') pal_settings.reverseDirectionSymbol = True self.assertTrue(pal_settings.reverseDirectionSymbol) self.assertTrue(pal_settings.lineSettings().reverseDirectionSymbol()) pal_settings.reverseDirectionSymbol = False self.assertFalse(pal_settings.reverseDirectionSymbol) self.assertFalse(pal_settings.lineSettings().reverseDirectionSymbol()) pal_settings.placeDirectionSymbol = QgsPalLayerSettings.SymbolAbove self.assertEqual(pal_settings.placeDirectionSymbol, 1) self.assertTrue( pal_settings.lineSettings().directionSymbolPlacement(), QgsLabelLineSettings.DirectionSymbolPlacement.SymbolAbove) pal_settings.overrunDistance = 4.2 self.assertEqual(pal_settings.overrunDistance, 4.2) self.assertTrue(pal_settings.lineSettings().overrunDistance(), 4.2) pal_settings.overrunDistanceUnit = QgsUnitTypes.RenderInches self.assertEqual(pal_settings.overrunDistanceUnit, QgsUnitTypes.RenderInches) self.assertTrue(pal_settings.lineSettings().overrunDistanceUnit(), QgsUnitTypes.RenderInches) pal_settings.overrunDistanceMapUnitScale = scale self.assertEqual(pal_settings.overrunDistanceMapUnitScale.minScale, 1) self.assertEqual(pal_settings.overrunDistanceMapUnitScale.maxScale, 2) self.assertTrue( pal_settings.lineSettings().overrunDistanceMapUnitScale().minScale, 1) self.assertTrue( pal_settings.lineSettings().overrunDistanceMapUnitScale().maxScale, 2)
def writeLeaflet(cls, iface, feedback, folder, layer_list, visible, cluster, json, params, popup): outputProjectFileName = folder QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) legends = {} canvas = iface.mapCanvas() project = QgsProject.instance() mapSettings = canvas.mapSettings() title = project.title() pluginDir = os.path.dirname(os.path.realpath(__file__)) stamp = datetime.now().strftime("%Y_%m_%d-%H_%M_%S_%f") outputProjectFileName = os.path.join(outputProjectFileName, 'qgis2web_' + unicode(stamp)) outputIndex = os.path.join(outputProjectFileName, 'index.html') mapLibLocation = params["Data export"]["Mapping library location"] minify = params["Data export"]["Minify GeoJSON files"] precision = params["Data export"]["Precision"] debugLibs = params["Data export"]["Use debug libraries"] extent = params["Scale/Zoom"]["Extent"] minZoom = params["Scale/Zoom"]["Min zoom level"] maxZoom = params["Scale/Zoom"]["Max zoom level"] restrictToExtent = params["Scale/Zoom"]["Restrict to extent"] basemapList = params["Appearance"]["Base layer"] matchCRS = params["Appearance"]["Match project CRS"] addressSearch = params["Appearance"]["Add address search"] locate = params["Appearance"]["Geolocate user"] measure = params["Appearance"]["Measure tool"] highlight = params["Appearance"]["Highlight on hover"] layerSearch = params["Appearance"]["Layer search"] popupsOnHover = params["Appearance"]["Show popups on hover"] template = params["Appearance"]["Template"] usedFields = [ALL_ATTRIBUTES] * len(popup) QgsApplication.initQgis() dataStore, cssStore = writeFoldersAndFiles( pluginDir, feedback, outputProjectFileName, cluster, measure, matchCRS, layerSearch, canvas, mapLibLocation, addressSearch, locate, debugLibs) writeCSS(cssStore, mapSettings.backgroundColor().name(), feedback) wfsLayers = "" labelCode = "" useMultiStyle = False useHeat = False useShapes = False useOSMB = False useWMTS = False useRaster = False scaleDependentLayers = "" labelVisibility = "" new_src = "" crs = QgsCoordinateReferenceSystem.EpsgCrsId exp_crs = QgsCoordinateReferenceSystem(4326, crs) lyrCount = 0 for layer, jsonEncode, eachPopup, clst in zip(layer_list, json, popup, cluster): rawLayerName = layer.name() safeLayerName = re.sub('[\W_]+', '', rawLayerName) + "_" + unicode(lyrCount) if layer.providerType() != 'WFS' or jsonEncode is True and layer: if layer.type() == QgsMapLayer.VectorLayer: feedback.showFeedback('Exporting %s to JSON...' % layer.name()) exportVector(layer, safeLayerName, dataStore, restrictToExtent, iface, extent, precision, exp_crs, minify) new_src += jsonScript(safeLayerName) scaleDependentLabels =\ scaleDependentLabelScript(layer, safeLayerName) labelVisibility += scaleDependentLabels feedback.completeStep() elif layer.type() == QgsMapLayer.RasterLayer: if layer.dataProvider().name() != "wms": layersFolder = os.path.join(outputProjectFileName, "data") exportRaster(layer, lyrCount, layersFolder, feedback, iface, matchCRS) if layer.hasScaleBasedVisibility(): scaleDependentLayers += scaleDependentLayerScript( layer, safeLayerName, clst) lyrCount += 1 if scaleDependentLayers != "": scaleDependentLayers = scaleDependentScript(scaleDependentLayers) crsSrc = mapSettings.destinationCrs() crsAuthId = crsSrc.authid() crsProj4 = crsSrc.toProj4() middle = """ <script>""" if highlight or popupsOnHover: selectionColor = mapSettings.selectionColor().name() middle += highlightScript(highlight, popupsOnHover, selectionColor) if extent == "Canvas extent": pt0 = canvas.extent() crsDest = QgsCoordinateReferenceSystem(4326) xform = QgsCoordinateTransform(crsSrc, crsDest) pt1 = xform.transform(pt0) bbox_canvas = [ pt1.yMinimum(), pt1.yMaximum(), pt1.xMinimum(), pt1.xMaximum() ] bounds = '[[' + unicode(pt1.yMinimum()) + ',' bounds += unicode(pt1.xMinimum()) + '],[' bounds += unicode(pt1.yMaximum()) + ',' bounds += unicode(pt1.xMaximum()) + ']]' if matchCRS and crsAuthId != 'EPSG:4326': middle += crsScript(crsAuthId, crsProj4) else: bounds = 0 if matchCRS and crsAuthId != 'EPSG:4326': middle += crsScript(crsAuthId, crsProj4) middle += mapScript(extent, matchCRS, crsAuthId, measure, maxZoom, minZoom, bounds, locate) middle += featureGroupsScript() if (len(basemapList) == 0 or matchCRS): basemapText = "" else: basemapText = basemapsScript(basemapList, maxZoom) extentCode = extentScript(extent, restrictToExtent) new_src += middle new_src += basemapText new_src += extentCode for count, layer in enumerate(layer_list): rawLayerName = layer.name() safeLayerName = re.sub('[\W_]+', '', rawLayerName) + "_" + unicode(count) if layer.type() == QgsMapLayer.VectorLayer: (new_src, legends, wfsLayers, labelCode, useMultiStyle, useHeat, useShapes, useOSMB) = writeVectorLayer( layer, safeLayerName, usedFields[count], highlight, popupsOnHover, popup[count], outputProjectFileName, wfsLayers, cluster[count], visible[count], json[count], legends, new_src, canvas, count, restrictToExtent, extent, feedback, labelCode, useMultiStyle, useHeat, useShapes, useOSMB) elif layer.type() == QgsMapLayer.RasterLayer: if layer.dataProvider().name() == "wms": feedback.showFeedback('Writing %s as WMS layer...' % layer.name()) new_obj, useWMTS = wmsScript(layer, safeLayerName, useWMTS) feedback.completeStep() else: useRaster = True feedback.showFeedback('Writing %s as raster layer...' % layer.name()) new_obj = rasterScript(layer, safeLayerName) feedback.completeStep() if visible[count]: new_obj += """ map.addLayer(overlay_""" + safeLayerName + """);""" new_src += new_obj new_src += scaleDependentLayers if title != "": titleStart = unicode(titleSubScript(title).decode("utf-8")) new_src += unicode(titleStart) if addressSearch: address_text = addressSearchScript() new_src += address_text if (params["Appearance"]["Add layers list"] and params["Appearance"]["Add layers list"] != "" and params["Appearance"]["Add layers list"] != "None"): new_src += addLayersList( basemapList, matchCRS, layer_list, cluster, legends, params["Appearance"]["Add layers list"] == "Expanded") if project.readBoolEntry("ScaleBar", "/Enabled", False)[0]: placement = project.readNumEntry("ScaleBar", "/Placement", 0)[0] placement = PLACEMENT[placement] end = scaleBar(placement) else: end = '' layerType = "layer" try: if cluster[count]: layerType = "cluster" except: pass searchLayer = "%s_%s" % (layerType, params["Appearance"]["Search layer"]) labelList = [] for count, layer in enumerate(layer_list): safeLayerName = re.sub('[\W_]+', '', layer.name()) + "_" + unicode(count) if layer.type() == QgsMapLayer.VectorLayer: palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) if palyr.enabled and palyr.fieldName and palyr.fieldName != "": labelList.append("layer_%s" % safeLayerName) labelsList = ",".join(labelList) end += endHTMLscript(wfsLayers, layerSearch, labelCode, labelVisibility, searchLayer, useHeat, useRaster, labelsList) new_src += end try: writeHTMLstart(outputIndex, title, cluster, addressSearch, measure, matchCRS, layerSearch, canvas, mapLibLocation, locate, new_src, template, feedback, debugLibs, useMultiStyle, useHeat, useShapes, useOSMB, useWMTS) except Exception as e: QgsMessageLog.logMessage(traceback.format_exc(), "qgis2web", level=QgsMessageLog.CRITICAL) finally: QApplication.restoreOverrideCursor() return outputIndex
def __init__(self): """Dummy assignments, intended to be overriden in subclasses""" self.lyr = QgsPalLayerSettings() self._TestFont = QApplication.font()
def testBlockingItems(self): """ Test rendering map item with blocking items """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) map.setId('map') layout.addLayoutItem(map) map2 = QgsLayoutItemMap(layout) map2.attemptSetSceneRect(QRectF(0, 5, 50, 80)) map2.setFrameEnabled(True) map2.setBackgroundEnabled(False) map2.setId('map2') layout.addLayoutItem(map2) map3 = QgsLayoutItemMap(layout) map3.attemptSetSceneRect(QRectF(150, 160, 50, 50)) map3.setFrameEnabled(True) map3.setBackgroundEnabled(False) map3.setId('map3') layout.addLayoutItem(map3) map.addLabelBlockingItem(map2) map.addLabelBlockingItem(map3) map.setMapFlags(QgsLayoutItemMap.MapItemFlags()) checker = QgsLayoutChecker('composermap_label_blockers', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) doc = QDomDocument("testdoc") elem = layout.writeXml(doc, QgsReadWriteContext()) l2 = QgsLayout(p) self.assertTrue(l2.readXml(elem, doc, QgsReadWriteContext())) map_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map' ][0] map2_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map2' ][0] map3_restore = [ i for i in l2.items() if isinstance(i, QgsLayoutItemMap) and i.id() == 'map3' ][0] self.assertTrue(map_restore.isLabelBlockingItem(map2_restore)) self.assertTrue(map_restore.isLabelBlockingItem(map3_restore))
def parse_symbol_layer(json_layer): json_layout = json_layer['layout'] json_paint = json_layer['paint'] dd_properties = {} TEXT_SIZE_MULTIPLIER = 2 # *2 because of high-res screen? text_size = 16 if 'text-size' in json_layout: json_text_size = json_layout['text-size'] if isinstance(json_text_size, (float, int)): text_size = json_text_size elif isinstance(json_text_size, dict): dd_properties[ QgsPalLayerSettings.Size] = parse_interpolate_by_zoom( json_text_size, TEXT_SIZE_MULTIPLIER) else: print("skipping non-float text-size", json_text_size) # TODO: text-font text_color = Qt.black if 'text-color' in json_paint: json_text_color = json_paint['text-color'] if isinstance(json_text_color, str): text_color = parse_color(json_text_color) else: print("skipping non-string text-color", json_text_color) buffer_color = QColor(0, 0, 0, 0) if 'text-halo-color' in json_paint: json_text_halo_color = json_paint['text-halo-color'] if isinstance(json_text_halo_color, str): buffer_color = parse_color(json_text_halo_color) else: print("skipping non-string text-halo-color", json_text_halo_color) buffer_size = 0 if 'text-halo-width' in json_paint: json_text_halo_width = json_paint['text-halo-width'] if isinstance(json_text_halo_width, (float, int)): buffer_size = json_text_halo_width else: print("skipping non-float text-halo-width", json_text_halo_width) format = QgsTextFormat() format.setColor(text_color) format.setSize(text_size * TEXT_SIZE_MULTIPLIER) format.setSizeUnit(QgsUnitTypes.RenderPixels) #format.setFont(font) if buffer_size > 0: buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(buffer_size * PX_TO_MM * TEXT_SIZE_MULTIPLIER) buffer_settings.setColor(buffer_color) format.setBuffer(buffer_settings) label_settings = QgsPalLayerSettings() label_settings.fieldName = '"name:latin"' # TODO: parse field name label_settings.isExpression = True label_settings.placement = QgsPalLayerSettings.OverPoint label_settings.priority = min(text_size / 3., 10.) label_settings.setFormat(format) if dd_properties: for dd_key, dd_expression in dd_properties.items(): prop_collection = QgsPropertyCollection() prop_collection.setProperty( dd_key, QgsProperty.fromExpression(dd_expression)) label_settings.setDataDefinedProperties(prop_collection) lb = QgsVectorTileBasicLabelingStyle() lb.setGeometryType(QgsWkbTypes.PointGeometry) lb.setLabelSettings(label_settings) return lb
def testPartialLabels(self): """ Test rendering map item with a show partial labels flag """ format = QgsTextFormat() format.setFont(QgsFontUtils.getStandardTestFont("Bold")) format.setSize(20) format.setNamedStyle("Bold") format.setColor(QColor(0, 0, 0)) settings = QgsPalLayerSettings() settings.setFormat(format) settings.fieldName = "'X'" settings.isExpression = True settings.placement = QgsPalLayerSettings.OverPoint vl = QgsVectorLayer("Point?crs=epsg:4326&field=id:integer", "vl", "memory") vl.setRenderer(QgsNullSymbolRenderer()) f = QgsFeature(vl.fields(), 1) for x in range(15): for y in range(15): f.setGeometry(QgsPoint(x, y)) vl.dataProvider().addFeature(f) vl.setLabeling(QgsVectorLayerSimpleLabeling(settings)) vl.setLabelsEnabled(True) p = QgsProject() engine_settings = QgsLabelingEngineSettings() engine_settings.setFlag(QgsLabelingEngineSettings.UsePartialCandidates, False) engine_settings.setFlag(QgsLabelingEngineSettings.DrawLabelRectOnly, True) p.setLabelingEngineSettings(engine_settings) p.addMapLayer(vl) layout = QgsLayout(p) layout.initializeDefaults() p.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) map = QgsLayoutItemMap(layout) map.attemptSetSceneRect(QRectF(10, 10, 180, 180)) map.setFrameEnabled(True) map.zoomToExtent(vl.extent()) map.setLayers([vl]) layout.addLayoutItem(map) # default should always be to hide partial labels self.assertFalse(map.mapFlags() & QgsLayoutItemMap.ShowPartialLabels) # hiding partial labels (the default) map.setMapFlags(QgsLayoutItemMap.MapItemFlags()) checker = QgsLayoutChecker('composermap_label_nomargin', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message) # showing partial labels map.setMapFlags(QgsLayoutItemMap.ShowPartialLabels) checker = QgsLayoutChecker('composermap_show_partial_labels', layout) checker.setControlPathPrefix("composer_map") result, message = checker.testLayout() self.report += checker.report() self.assertTrue(result, message)
def test_AddPALToVectorLayer(self): """Check if we can set a label field, verify that PAL is assigned and that output is rendered correctly""" # TODO: add UTM PAL-specific shps, with 4326 as on-the-fly cross-check # setCanvasCrs(26913) myShpFile = os.path.join(TEST_DATA_DIR, 'lines.shp') myVectorLayer = QgsVectorLayer(myShpFile, 'Lines', 'ogr') self._MapRegistry.addMapLayer(myVectorLayer) myLayers = QStringList() myLayers.append(myVectorLayer.id()) self._MapRenderer.setLayerSet(myLayers) self._MapRenderer.setExtent(myVectorLayer.extent()) self._Canvas.zoomToFullExtent() # check layer labeling is PAL with customProperty access # should not be activated on layer load myPalSet = myVectorLayer.customProperty("labeling").toString() myMessage = '\nExpected: Empty QString\nGot: %s' % (str(myPalSet)) assert str(myPalSet) == '', myMessage # simulate clicking checkbox, setting label field and clicking apply self._testFont.setPointSize(20) myPalLyr = QgsPalLayerSettings() myPalLyr.enabled = True myPalLyr.fieldName = 'Name' myPalLyr.placement = QgsPalLayerSettings.Line myPalLyr.placementFlags = QgsPalLayerSettings.AboveLine myPalLyr.xQuadOffset = 0 myPalLyr.yQuadOffset = 0 myPalLyr.xOffset = 0 myPalLyr.yOffset = 0 myPalLyr.angleOffset = 0 myPalLyr.centroidWhole = False myPalLyr.textFont = self._testFont myPalLyr.textNamedStyle = QString("Medium") myPalLyr.textColor = Qt.black myPalLyr.textTransp = 0 myPalLyr.previewBkgrdColor = Qt.white myPalLyr.priority = 5 myPalLyr.obstacle = True myPalLyr.dist = 0 myPalLyr.scaleMin = 0 myPalLyr.scaleMax = 0 myPalLyr.bufferSize = 1 myPalLyr.bufferColor = Qt.white myPalLyr.bufferTransp = 0 myPalLyr.bufferNoFill = False myPalLyr.bufferJoinStyle = Qt.RoundJoin myPalLyr.formatNumbers = False myPalLyr.decimals = 3 myPalLyr.plusSign = False myPalLyr.labelPerPart = False myPalLyr.displayAll = True myPalLyr.mergeLines = False myPalLyr.minFeatureSize = 0.0 myPalLyr.vectorScaleFactor = 1.0 myPalLyr.rasterCompressFactor = 1.0 myPalLyr.addDirectionSymbol = False myPalLyr.upsidedownLabels = QgsPalLayerSettings.Upright myPalLyr.fontSizeInMapUnits = False myPalLyr.bufferSizeInMapUnits = False myPalLyr.labelOffsetInMapUnits = True myPalLyr.distInMapUnits = False myPalLyr.wrapChar = "" myPalLyr.preserveRotation = True myPalLyr.writeToLayer(myVectorLayer) # check layer labeling is PAL with customProperty access myPalSet = myVectorLayer.customProperty("labeling").toString() myMessage = '\nExpected: pal\nGot: %s' % (str(myPalSet)) assert str(myPalSet) == 'pal', myMessage # check layer labeling is PAL via engine interface myMessage = '\nCould not get whether PAL enabled from labelingEngine' assert self._PalEngine.willUseLayer(myVectorLayer), myMessage # myChecker = QgsRenderChecker() myChecker.setControlName("expected_pal_aboveLineLabeling") myChecker.setMapRenderer(self._MapRenderer) myResult = myChecker.runTest("pal_aboveLineLabeling_python") myMessage = ('\nVector layer \'above line\' label engine ' 'rendering test failed') assert myResult, myMessage # compare against a straight rendering/save as from QgsMapCanvasMap # unnecessary? works a bit different than QgsRenderChecker, though # myImage = os.path.join(unicode(QDir.tempPath()), # 'render_pal_aboveLineLabeling.png') # self._Map.render() # self._Canvas.saveAsImage(myImage) # myChecker.setRenderedImage(myImage) # myResult = myChecker.compareImages("pal_aboveLineLabeling_python") # myMessage = ('\nVector layer \'above line\' label engine ' # 'comparison to QgsMapCanvasMap.render() test failed') # assert myResult, myMessage self._MapRegistry.removeMapLayer(myVectorLayer.id())