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())
Exemple #2
1
    def save_adres_point(self, point, address, typeAddress='', layername="Geopunt_adres", saveToFile=False, sender=None, startFolder=None ):
        attributes = [QgsField("adres", QVariant.String), QgsField("type", QVariant.String)]
        mapcrs = self.getGetMapCrs(self.iface)
        
        if not QgsProject.instance().mapLayer(self.adreslayerid):
            self.adreslayer = QgsVectorLayer("Point", layername, "memory")
            self.adresProvider = self.adreslayer.dataProvider()
            self.adresProvider.addAttributes(attributes)
            self.adreslayer.updateFields()

        # add a feature
        fields= self.adreslayer.fields()
        fet = QgsFeature(fields)

        #set geometry and project from mapCRS
        xform = QgsCoordinateTransform( mapcrs, self.adreslayer.crs(), QgsProject.instance() )
        prjPoint = xform.transform( point )
        fet.setGeometry(QgsGeometry.fromPointXY(prjPoint))

        #populate fields
        fet['adres'] = address
        fet['type'] = typeAddress
        self.adresProvider.addFeatures([ fet ])
        ""
        # update layer's extent when new features have been added
        # because change of extent in provider is not propagated to the layer
        self.adreslayer.updateExtents()
        
        # save memoryLAYER to file and replace all references    
        if saveToFile and not QgsProject.instance().mapLayer(self.adreslayerid): 
          save = self._saveToFile( sender, startFolder )
          if save:
            fpath, flType = save                
            error, msg = QgsVectorFileWriter.writeAsVectorFormat(self.adreslayer, fileName=fpath, fileEncoding="utf-8", driverName=flType)
            if error == QgsVectorFileWriter.NoError:
              self.adreslayer = QgsVectorLayer( fpath, layername, "ogr")
              self.adresProvider = self.adreslayer.dataProvider()
            else: 
              del self.adreslayer, self.adresProvider 
              return
          else: 
            del self.adreslayer, self.adresProvider 
            return
          
        #  add to map
        QgsProject.instance().addMapLayer(self.adreslayer)
        
        #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 = 'adres' 
        palyr.placement = QgsPalLayerSettings.Free 

        self.adreslayer.setLabelsEnabled(True)
        self.adreslayer.setLabeling( QgsVectorLayerSimpleLabeling(palyr) )
       
        # store layer id and refresh      
        self.adreslayerid = self.adreslayer.id()
        self.canvas.refresh()
    def resultSelectedFeatureByRectTasDraw(self, geom, distance,
                                           direction_bearing):
        # flag = FlightPlanBaseSimpleDlg.btnConstruct_Click(self)
        # if not flag:
        #     return
        if define._userLayers == None:
            mapUnits = define._canvas.mapUnits()
            constructionLayer = AcadHelper.createVectorLayer(
                "Lines", QGis.Line)
            AcadHelper.setGeometryAndAttributesInLayer(
                constructionLayer, geom.asPolyline(), False,
                {"Caption": str(round(distance, 4)) + "m"})

            define._userLayers = constructionLayer
            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, '8', "")
            palSetting.writeToLayer(constructionLayer)
            QgisHelper.appendToCanvas(define._canvas, [constructionLayer],
                                      "Users layer", True)
            # self.resultLayerList = [constructionLayer]
        else:

            # constructionLayer = AcadHelper.createVectorLayer("Lines", QGis.Line)
            constructionLayer = define._userLayers
            iter = define._userLayers.getFeatures()
            equalFlag = 0
            for feat in iter:
                # AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, feat)
                if geom.equals(feat.geometry()):
                    equalFlag += 1
            if equalFlag <= 0:
                AcadHelper.setGeometryAndAttributesInLayer(
                    constructionLayer, geom.asPolyline(), False,
                    {"Caption": str(round(distance, 4)) + "m"})

            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, '8', "")
            palSetting.writeToLayer(constructionLayer)
            # QgisHelper.appendToCanvas(define._canvas,[constructionLayer], "Users layer", True)
            # self.resultLayerList = [constructionLayer]
            QgisHelper.zoomToLayers([constructionLayer])
            define._userLayers = constructionLayer
        pass
 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     lyr.textFont = self._TestFont
     lyr.textNamedStyle = 'Medium'
     return lyr
Exemple #5
0
    def prepare_ordered_marker(self, coords, idx):
        """
        Try to display nice marker on a point layer, showing the order of
        the path computed by OSRM.
        """
        self.tsp_marker_lr = QgsVectorLayer(
            "Point?crs=epsg:4326&field=id:integer"
            "&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
            "tsp_markers_osrm{}".format(self.nb_route), "memory")
        symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
        symbol.setSize(4.5)
        symbol.setColor(QtGui.QColor("yellow"))

        ordered_pts = \
            [coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
        print("ordered_pts : ", ordered_pts)

        features = []
        for nb, pt in enumerate(ordered_pts):
            ft = QgsFeature()
            ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
            ft.setAttributes([nb, nb + 1, coords.index(pt)])
            features.append(ft)
        self.tsp_marker_lr.dataProvider().addFeatures(features)

        pal_lyr = QgsPalLayerSettings()
        pal_lyr.readFromLayer(self.tsp_marker_lr)
        pal_lyr.enabled = True
        pal_lyr.fieldName = 'TSP_nb'
        pal_lyr.placement= QgsPalLayerSettings.OverPoint
        pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size,True,True,'12','')
        pal_lyr.writeToLayer(self.tsp_marker_lr)

        self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
        QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)
    def linkProperty(self):
        layer = self.iface.mapCanvas().currentLayer()
        # parameters for advanced labeling -- picked up from a qgs model file
        # generic labeling properties
        layer.setCustomProperty("labeling/fieldName",
                                share.field_list[0][0])  #[0][0] )
        layer.setCustomProperty("labeling",
                                "pal")  # new gen labeling activated
        layer.setCustomProperty("labeling/multiLineLabels",
                                "true")  # default value
        layer.setCustomProperty("labeling/enabled", "true")  # default value
        layer.setCustomProperty("labeling/priority",
                                "10")  # puts a high priority to labeling layer
        layer.setCustomProperty("labeling/multilineAlign",
                                "1")  # multiline align to center

        # line properties case
        layer.setCustomProperty(
            "labeling/placement", "2"
        )  #  OnLine = 1, AboveLine = 2, BelowLine = 4, MapOrientation = 8

        # data defined properties
        layer.setCustomProperty("labeling/dataDefined/PositionX",
                                "1~~0~~~~" + share.field_list[1][0])
        layer.setCustomProperty("labeling/dataDefined/PositionY",
                                "1~~0~~~~" + share.field_list[2][0])
        layer.setCustomProperty("labeling/dataDefined/Rotation",
                                "1~~0~~~~" + share.field_list[3][0])
        layer.setCustomProperty("labeling/dataDefined/Show",
                                "1~~0~~~~" + share.field_list[4][0])
        layer.setCustomProperty("labeling/dataDefined/Hali",
                                "1~~0~~~~" + share.field_list[5][0])
        layer.setCustomProperty("labeling/dataDefined/Vali",
                                "1~~0~~~~" + share.field_list[6][0])

        # set data define in a pyqigs3 way
        # link:https://gis.stackexchange.com/questions/313898/how-to-set-qgspropertycollection-via-an-dict
        pc = QgsPropertyCollection('qpc')

        sp = {
            9: share.field_list[1][0],
            10: share.field_list[2][0],
            96: share.field_list[3][0],
            15: share.field_list[4][0],
            11: share.field_list[5][0],
            12: share.field_list[6][0]
        }

        for k, v in sp.items():
            x = QgsProperty()
            x.setField(v)
            pc.setProperty(k, x)

        pal_layer = QgsPalLayerSettings()
        pal_layer.fieldName = share.field_list[0][0]
        pal_layer.setDataDefinedProperties(pc)
        pal_layer.enabled = True
        labeler = QgsVectorLayerSimpleLabeling(pal_layer)
        layer.setLabeling(labeler)
        layer.setLabelsEnabled(True)
 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     lyr.textFont = self._TestFont
     lyr.textNamedStyle = 'Medium'
     return lyr
Exemple #8
0
    def pintaLabels(self, campEtiqueta):
        """Pinta sobre el canvas les etiquetas de la capa activa, segons campEtiqueta.
        
        Arguments:
        campEtiqueta {[String]} -- És el nom del camp del que volem pintar etiquetes.
        """

        # layer=self.llegenda.currentLayer()

        layer_settings = QgsPalLayerSettings()
        text_format = QgsTextFormat()

        text_format.setFont(QvConstants.FONTTEXT)
        text_format.setSize(12)

        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)

        layer_settings.fieldName = campEtiqueta
        layer_settings.placement = 0

        layer_settings.enabled = True
        print("layer settings:" + layer_settings.fieldName)
        labeling = QgsVectorLayerSimpleLabeling(layer_settings)

        self.layer.setLabelsEnabled(True)
        self.layer.setLabeling(labeling)
        self.layer.triggerRepaint()
    def showMarkDaSoc(self):
        try:
            flag = FlightPlanBaseDlg.btnConstruct_Click(self)

            self.putDistances()

            point3dMapt = self.parametersPanel.pnlMaPtPosition.Point3d
            socLayer = AcadHelper.createVectorLayer(
                "SOC_MAPt_" + self.surfaceType, QGis.Point)
            AcadHelper.setGeometryAndAttributesInLayer(socLayer,
                                                       self.socPoint3d, False,
                                                       {"Caption": "SOC"})
            AcadHelper.setGeometryAndAttributesInLayer(socLayer, point3dMapt,
                                                       False,
                                                       {"Caption": "MAPt"})

            QgisHelper.appendToCanvas(define._canvas, [socLayer],
                                      self.surfaceType)

            palSetting = QgsPalLayerSettings()
            palSetting.readFromLayer(socLayer)
            palSetting.enabled = True
            palSetting.fieldName = "Caption"
            palSetting.isExpression = True
            palSetting.placement = QgsPalLayerSettings.AroundPoint
            palSetting.setDataDefinedProperty(QgsPalLayerSettings.Size, True,
                                              True, '8', "")
            palSetting.writeToLayer(socLayer)

            self.resultLayerList = [socLayer]

            return socLayer
        except:
            pass
Exemple #10
0
def set_label(layer, field_label):
    """Function that sets the label to a field value. Inspiration found at:
    https://gis.stackexchange.com/questions/277106/loading-labels-from-python-script-in-qgis

    Parameters
    ----------
    layer: QgsVectorLayer
        valid qgis layer.
    field_label: str
        The label of the field

    """
    layer_settings = QgsPalLayerSettings()
    text_format = QgsTextFormat()

    text_format.setFont(QFont("Arial", 12))
    text_format.setSize(12)

    buffer_settings = QgsTextBufferSettings()
    buffer_settings.setEnabled(True)
    buffer_settings.setSize(0.10)
    buffer_settings.setColor(QColor("black"))

    text_format.setBuffer(buffer_settings)
    layer_settings.setFormat(text_format)
    layer_settings.fieldName = field_label
    layer_settings.placement = 4

    layer_settings.enabled = True

    layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
    layer.setLabelsEnabled(True)
    layer.setLabeling(layer_settings)
    layer.triggerRepaint()
Exemple #11
0
def SetDefaultPointStyle(layer):
    """ Point Symbol """
    style = S.getDrawingPoint()
    symbol = QgsMarkerSymbol.createSimple({
        "name": style["NAME"],
        "line_color": style["LINE_COLOR"],
        "line_width": style["LINE_WIDTH"],
        "size": style["SIZE"],
    })

    renderer = QgsSingleSymbolRenderer(symbol)
    layer.setRenderer(renderer)

    layer_settings = QgsPalLayerSettings()
    text_format = QgsTextFormat()

    text_format.setFont(QFont(style["LABEL_FONT"], style["LABEL_FONT_SIZE"]))
    text_format.setColor(QColor(style["LABEL_FONT_COLOR"]))
    text_format.setSize(style["LABEL_SIZE"])

    buffer_settings = QgsTextBufferSettings()
    buffer_settings.setEnabled(True)
    buffer_settings.setSize(1)
    buffer_settings.setColor(QColor(style["LABEL_BUFFER_COLOR"]))

    text_format.setBuffer(buffer_settings)
    layer_settings.setFormat(text_format)

    layer_settings.fieldName = "number"
    layer_settings.placement = 2
    layer_settings.enabled = True

    layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
    layer.setLabelsEnabled(True)
    layer.setLabeling(layer_settings)
Exemple #12
0
    def createLayer(self):
        '''Create a memory layer from the zoom to locations'''
        if self.numcoord == 0:
            return
        ptLayer = QgsVectorLayer("Point?crs=epsg:4326", "Lat Lon Locations",
                                 "memory")
        provider = ptLayer.dataProvider()
        provider.addAttributes([
            QgsField("latitude", QVariant.Double),
            QgsField("longitude", QVariant.Double),
            QgsField("label", QVariant.String)
        ])
        ptLayer.updateFields()

        for item in self.llitems:
            feature = QgsFeature()
            feature.setGeometry(
                QgsGeometry.fromPoint(QgsPoint(item.lon, item.lat)))
            feature.setAttributes([item.lat, item.lon, item.label])
            provider.addFeatures([feature])

        ptLayer.updateExtents()

        if self.settings.multiZoomStyleID == 1:
            label = QgsPalLayerSettings()
            label.readFromLayer(ptLayer)
            label.enabled = True
            label.fieldName = 'label'
            label.placement = QgsPalLayerSettings.AroundPoint
            label.writeToLayer(ptLayer)
        elif self.settings.multiZoomStyleID == 2 and os.path.isfile(
                self.settings.customQMLFile()):
            ptLayer.loadNamedStyle(self.settings.customQMLFile())

        QgsProject.instance().addMapLayer(ptLayer)
Exemple #13
0
    def createDefinedProperties(self):
        props = (('"auxiliary_storage_labeling_positionx"', QgsPalLayerSettings.PositionX),
                 ('"auxiliary_storage_labeling_positiony"',
                  QgsPalLayerSettings.PositionY),
                 ('case when "auxiliary_storage_labeling_positionx" is NULL then NULL when  "auxiliary_storage_labeling_positionx" < x( if( layer_property( @layer_name, \'geometry_type\' ) = \'Line\', closest_point( $geometry, make_point("auxiliary_storage_labeling_positionx", "auxiliary_storage_labeling_positiony") ), centroid($geometry) ) ) then \'Right\' else \'Left\' end', QgsPalLayerSettings.Hali),
                 ('\'Half\'', QgsPalLayerSettings.Vali),
                 ('if( "auxiliary_storage_labeling_positionx" is not NULL, True, False )', QgsPalLayerSettings.BufferDraw)
                 # ,('10', QgsPalLayerSettings.BufferSize)
                 )

        pc = QgsPropertyCollection('labelConnector')
        for prop in props:
            p = QgsProperty()
            p.setExpressionString(prop[0])
            pc.setProperty(prop[1], p)

        pal_layer = QgsPalLayerSettings()
        pal_layer.setDataDefinedProperties(pc)
        labeling = self.layer.labeling()
        if labeling is None:
            pal_layer.fieldName = self.layer.fields()[0].name()
            pal_layer.isExpression = False
        else:
            pal_layer.fieldName = labeling.settings().fieldName
            pal_layer.isExpression = labeling.settings().isExpression
        if self.layer.geometryType() == QgsWkbTypes.LineGeometry:
            pal_layer.placement = QgsPalLayerSettings.Line
        pal_layer.enabled = True

        labeler = QgsVectorLayerSimpleLabeling(pal_layer)

        self.layer.setLabeling(labeler)
        self.layer.setLabelsEnabled(True)
def createProfileLayers(heightSource):
    lyrCrs = heightSource.spatialRef.authid()
    pointA = heightSource.getFirstPoint()
    pointE = heightSource.getLastPoint()

    # Create profile layer
    surveyLineLayer = QgsVectorLayer('Linestring?crs=' + lyrCrs,
                                     tr('Felddaten-Profil'), 'memory')
    pr = surveyLineLayer.dataProvider()
    feature = QgsFeature()
    feature.setGeometry(
        QgsGeometry.fromPolyline(
            [QgsPoint(*tuple(pointA)),
             QgsPoint(*tuple(pointE))]))
    pr.addFeatures([feature])
    surveyLineLayer.updateExtents()
    QgsProject.instance().addMapLayers([surveyLineLayer])

    # Create survey point layer
    surveyPointLayer = QgsVectorLayer('Point?crs=' + lyrCrs,
                                      tr('Felddaten-Messpunkte'), 'memory')
    pr = surveyPointLayer.dataProvider()
    pr.addAttributes([QgsField("nr", QVariant.String)])
    surveyPointLayer.updateFields()
    features = []
    # TODO: Survey points are NOT rounded
    for x, y, nr, notes in zip(heightSource.x, heightSource.y, heightSource.nr,
                               heightSource.plotNotes):
        feature = QgsFeature()
        feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
        feature.setId(int(nr + 1))
        labelText = f"{nr}{':' if notes else ''} {notes if len(notes) <= 25 else notes[:22] + '...'}"
        feature.setAttributes([labelText])
        features.append(feature)
    pr.addFeatures(features)
    surveyPointLayer.updateExtents()
    QgsProject.instance().addMapLayers([surveyPointLayer])

    # Add Labels for point layer
    layer_settings = QgsPalLayerSettings()
    text_format = QgsTextFormat()
    text_format.setFont(QFont("Arial", 12))
    text_format.setSize(12)
    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)
    layer_settings.fieldName = "nr"
    layer_settings.placement = 2
    layer_settings.enabled = True
    layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
    surveyPointLayer.setLabelsEnabled(True)
    surveyPointLayer.setLabeling(layer_settings)
    surveyPointLayer.triggerRepaint()

    return surveyLineLayer, surveyPointLayer
Exemple #15
0
 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = "text"  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     lyr.textFont = font
     lyr.textNamedStyle = "Roman"
     return lyr
Exemple #16
0
 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     font = self.getTestFont()
     font.setPointSize(48)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     return lyr
Exemple #17
0
 def defaultSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in data sources
     font = self.getTestFont()
     font.setPointSize(48)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     return lyr
 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     lyr.bufferJoinStyle = Qt.BevelJoin  # handle change of default join style
     return lyr
 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     lyr.textFont = font
     lyr.textNamedStyle = 'Roman'
     lyr.bufferJoinStyle = Qt.BevelJoin  # handle change of default join style
     return lyr
    def setCollectionSettings(self):
        lyrids, lyrnames = self.lyrPair()
        coll = self.setFieldsCollection()
        arial = self.setArialDict()
        ssnr = self.setSsnrDict()
        swi = self.setSwiDict()
        times = self.setTimesDict()

        for names in lyrnames.values():
            lyr = QgsProject.instance().mapLayersByName(names)[0]
            iface.setActiveLayer(lyr)
            pc = QgsPropertyCollection('qpc')
            lyr_settings = QgsPalLayerSettings()
            txt_format = QgsTextFormat()
            txt_format.setSizeUnit(QgsUnitTypes.RenderPoints)

            for nColl, fColl in coll.items():
                x = QgsProperty()
                x.setField(fColl)
                pc.setProperty(nColl, x)
                pc.setProperty(31, '/')
                pc.setProperty(32, 0.8)

                if names in arial.values():
                    txt_format.setFont(QFont("Arial"))
                    txt_format.setColor(QColor(0, 0, 0))
                elif names in ssnr.values():
                    txt_format.setFont(QFont("Xerox Sans Serif Narrow"))
                    txt_format.setColor(QColor(0, 0, 0))
                elif names in swi.values():
                    txt_format.setFont(QFont("Xerox Serif Wide"))
                    if re.search(r"\Bcotado", names):
                        txt_format.setColor(QColor(140, 58, 61))
                    elif re.search(r"\Bcurva", names):
                        txt_format.setColor(QColor(140, 58, 61))
                    else:
                        txt_format.setColor(QColor(0, 119, 189))
                elif names in times.values():
                    txt_format.setFont(QFont("Times New Roman"))
                    txt_format.setColor(QColor(0, 0, 0))
                pass

            lyr_settings.setFormat(txt_format)
            lyr_settings.setDataDefinedProperties(pc)
            lyr_settings.enabled = True
            if names == "rel_ponto_cotado_altimetrico_p":
                lyr_settings.fieldName = "cota"
            else:
                lyr_settings.fieldName = "legenda"
            lyr_settings = QgsVectorLayerSimpleLabeling(lyr_settings)
            lyr.setLabelsEnabled(True)
            lyr.setLabeling(lyr_settings)
            lyr.triggerRepaint()
 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     format = lyr.format()
     format.setFont(font)
     format.setNamedStyle('Roman')
     format.setSize(32)
     format.setSizeUnit(QgsUnitTypes.RenderPoints)
     format.buffer().setJoinStyle(Qt.BevelJoin)
     lyr.setFormat(format)
     return lyr
 def defaultLayerSettings(self):
     lyr = QgsPalLayerSettings()
     lyr.enabled = True
     lyr.fieldName = 'text'  # default in test data sources
     font = self.getTestFont()
     font.setPointSize(32)
     format = lyr.format()
     format.setFont(font)
     format.setNamedStyle('Roman')
     format.setSize(32)
     format.setSizeUnit(QgsUnitTypes.RenderPoints)
     format.buffer().setJoinStyle(Qt.BevelJoin)
     lyr.setFormat(format)
     return lyr
 def setLayerLabels(self, layer, fieldName):
     firstCondition = layer.geometryType(
     ) == 0 and self.cbNodeLabels.isChecked()
     secondCondition = layer.geometryType(
     ) != 0 and self.cbLinkLabels.isChecked()
     if firstCondition or secondCondition:
         pal_layer = QgsPalLayerSettings()
         pal_layer.fieldName = fieldName
         pal_layer.enabled = True
         pal_layer.placement = QgsPalLayerSettings.Line
         labels = QgsVectorLayerSimpleLabeling(pal_layer)
         layer.setLabeling(labels)
         layer.setLabelsEnabled(True)
         layer.triggerRepaint()
Exemple #24
0
 def _set_labeling():
     pal_layer = QgsPalLayerSettings()
     pal_layer.fieldName = 'value'
     pal_layer.enabled = True
     pal_layer.placementFlags = QgsLabeling.OnLine
     pal_layer.placement = QgsPalLayerSettings.PerimeterCurved
     text_format = pal_layer.format()
     buffer = text_format.buffer()
     buffer.setColor(QColor(255, 255, 255))
     buffer.setOpacity(0.5)
     buffer.setEnabled(True)
     text_format.setBuffer(buffer)
     pal_layer.setFormat(text_format)
     labels = QgsVectorLayerSimpleLabeling(pal_layer)
     return labels
 def setLabelFormatter(self, layer): # remove topicType
     try:
         palyr = QgsPalLayerSettings()
         palyr.readFromLayer(layer)
         palyr.enabled = True
         palyr.fontBold = True
         palyr.shapeDraw = True
         palyr.shapeTransparency = 0
         palyr.shapeType = QgsPalLayerSettings.ShapeRectangle
         palyr.textColor = QColor(255,255,255) # white
         palyr.placement = QgsPalLayerSettings.OverPoint
         palyr.quadOffset = QgsPalLayerSettings.QuadrantBelow
         palyr.multilineAlign = QgsPalLayerSettings.MultiCenter
         palyr.yOffset = 0.01
         palyr.fieldName = '$format_label'
         palyr.writeToLayer(layer)
         Log.debug("Palyr Settings updated")
     except Exception as e:
         Log.debug("Error setting Label Format " + str(e))
 def setLabelFormatter(self, layer):  # remove topicType
     try:
         palyr = QgsPalLayerSettings()
         palyr.readFromLayer(layer)
         palyr.enabled = True
         palyr.fontBold = True
         palyr.shapeDraw = True
         palyr.shapeTransparency = 0
         palyr.shapeType = QgsPalLayerSettings.ShapeRectangle
         palyr.textColor = QColor(255, 255, 255)  # white
         palyr.placement = QgsPalLayerSettings.OverPoint
         palyr.quadOffset = QgsPalLayerSettings.QuadrantBelow
         palyr.multilineAlign = QgsPalLayerSettings.MultiCenter
         palyr.yOffset = 2
         palyr.labelOffsetInMapUnits = False
         self.setPalLabelSettings(palyr)  # obj so pass by reference
         palyr.writeToLayer(layer)
         Log.debug("Palyr Settings updated")
     except Exception as e:
         Log.debug("Error setting Label Format " + str(e))
Exemple #27
0
 def getLayers(self):
     text = self.layersText.toPlainText()
     names = text.split("\n")
     crs = self.crsText.toPlainText()
     for name in names:
         subprocess.run([
             "scp", "acald013@hn:/tmp/edges{}.wkt".format(name),
             "/home/and/tmp/edges/edges{}.wkt".format(name)
         ])
     instance = QgsProject.instance()
     for name in names:
         layers = instance.mapLayersByName(name)
         for layer in layers:
             instance.removeMapLayer(layer)
     iface.mapCanvas().refresh()
     for name in names:
         uri = "file:///home/and/tmp/edges/edges{}.wkt?delimiter={}&useHeader=no&crs=epsg:{}&wktField={}".format(
             name, "\\t", crs, "field_1")
         layer = iface.addVectorLayer(uri, name, "delimitedtext")
         if name == "Cells":
             symbol = QgsFillSymbol.createSimple({
                 'color_border': 'blue',
                 'style': 'no',
                 'style_border': 'dash'
             })
             layer.renderer().setSymbol(symbol)
             layer.triggerRepaint()
         if name == "Faces":
             symbol = QgsFillSymbol.createSimple({'color': 'green'})
             layer.renderer().setSymbol(symbol)
             pal_layer = QgsPalLayerSettings()
             pal_layer.fieldName = 'field_2'
             pal_layer.enabled = True
             pal_layer.placement = QgsPalLayerSettings.Free
             labels = QgsVectorLayerSimpleLabeling(pal_layer)
             layer.setLabeling(labels)
             layer.setLabelsEnabled(True)
             layer.triggerRepaint()
     with open(os.path.join(os.path.dirname(__file__), 'history.txt'),
               'w') as f:
         f.write("{}\n{}".format(text, crs))
Exemple #28
0
    def __calculate_Lane_IDs__(self):
        "..."

        laneList = ad.map.lane.getLanes()

        for each_layer in self.layer_group:
            layer = QgsProject.instance().mapLayersByName(each_layer)[0]
            for each_lane in laneList:
                lane = ad.map.lane.getLane(each_lane)

                text_format = QgsTextFormat()
                label = QgsPalLayerSettings()
                label.fieldName = 'Id'
                label.__setattr__('Id', lane.id)
                label.enabled = True
                label.setFormat(text_format)
                label.placement = QgsPalLayerSettings.OverPoint

                labeler = QgsVectorLayerSimpleLabeling(label)
                layer.setLabelsEnabled(True)
                layer.setLabeling(labeler)
                layer.triggerRepaint(True)
Exemple #29
0
    def setLayerLabels(self, layer, fieldName):
        firstCondition = layer.geometryType(
        ) == 0 and self.cbNodeLabels.isChecked()
        secondCondition = layer.geometryType(
        ) != 0 and self.cbLinkLabels.isChecked()
        if firstCondition or secondCondition:
            layer_settings = QgsPalLayerSettings()
            text_format = QgsTextFormat()
            text_format.setFont(QFont("Arial", 10))
            color = "black"
            if secondCondition:
                color = "blue"
            text_format.setColor(QColor(color))
            layer_settings.setFormat(text_format)

            layer_settings.fieldName = fieldName
            layer_settings.placement = QgsPalLayerSettings.Line
            layer_settings.enabled = True
            labels = QgsVectorLayerSimpleLabeling(layer_settings)
            layer.setLabeling(labels)
            layer.setLabelsEnabled(True)
            layer.triggerRepaint()
 def createPointLayer(self):
     layername = self.layerLineEdit.text()
     self.pointLayer = QgsVectorLayer("point?crs=epsg:4326", layername,
                                      "memory")
     self.provider = self.pointLayer.dataProvider()
     if self.detailedAddressCheckBox.checkState():
         self.provider.addAttributes([
             QgsField("osm_type", QVariant.String),
             QgsField("class", QVariant.String),
             QgsField("type", QVariant.String),
             QgsField("source_addr", QVariant.String),
             QgsField("display_name", QVariant.String),
             QgsField("house_number", QVariant.String),
             QgsField("road", QVariant.String),
             QgsField("neighbourhood", QVariant.String),
             QgsField("locality", QVariant.String),
             QgsField("town", QVariant.String),
             QgsField("city", QVariant.String),
             QgsField("county", QVariant.String),
             QgsField("state", QVariant.String),
             QgsField("postcode", QVariant.String),
             QgsField("country", QVariant.String),
             QgsField("country_code", QVariant.String)
         ])
     else:
         self.provider.addAttributes(
             [QgsField("display_name", QVariant.String)])
     self.pointLayer.updateFields()
     if self.showLabelCheckBox.checkState():
         # Display labels
         label = QgsPalLayerSettings()
         label.readFromLayer(self.pointLayer)
         label.enabled = True
         label.fieldName = 'display_name'
         label.placement = QgsPalLayerSettings.AroundPoint
         label.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True,
                                      '8', '')
         label.writeToLayer(self.pointLayer)
Exemple #31
0
    def apply_label(self):
        '''
        apply the label of the currently selected label field to the output
        layer
        '''
        layer = self.input.layer if self.input else None
        if not layer:
            return
        self.label_field_name = self.label_field_combo.currentData()
        self.label_cache[layer.id] = self.label_field_name

        layer = self.output.layer if self.output else None
        if not layer:
            return
        if not self.label_field_name:
            layer.setLabelsEnabled(False)
            layer.reload()
            return

        layer.setLabelsEnabled(True)
        labeling = layer.labeling()
        if not labeling:
            settings = QgsPalLayerSettings()
            settings.enabled = True
            buffer = QgsTextBufferSettings()
            buffer.setEnabled(True)
            buffer.setSize(0.8)
            text_format = QgsTextFormat()
            text_format.setBuffer(buffer)
            text_format.setSize(8)
            settings.setFormat(text_format)
            labeling = QgsVectorLayerSimpleLabeling(settings)
        settings = labeling.settings()
        settings.fieldName = self.label_field_name
        labeling.setSettings(settings)
        layer.setLabeling(labeling)
        layer.reload()
Exemple #32
0
    def prepare_ordered_marker(self, coords, idx):
        """
        Try to display nice marker on a point layer, showing the order of
        the path computed by OSRM.
        """
        self.tsp_marker_lr = QgsVectorLayer(
            "Point?crs=epsg:4326&field=id:integer"
            "&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
            "tsp_markers_osrm{}".format(self.nb_route), "memory")
        symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
        symbol.setSize(4.5)
        symbol.setColor(QtGui.QColor("yellow"))

        ordered_pts = \
            [coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
        print("ordered_pts : ", ordered_pts)

        features = []
        for nb, pt in enumerate(ordered_pts):
            ft = QgsFeature()
            ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
            ft.setAttributes([nb, nb + 1, coords.index(pt)])
            features.append(ft)
        self.tsp_marker_lr.dataProvider().addFeatures(features)

        pal_lyr = QgsPalLayerSettings()
        pal_lyr.readFromLayer(self.tsp_marker_lr)
        pal_lyr.enabled = True
        pal_lyr.fieldName = 'TSP_nb'
        pal_lyr.placement = QgsPalLayerSettings.OverPoint
        pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True,
                                       '12', '')
        pal_lyr.writeToLayer(self.tsp_marker_lr)

        self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
        QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)
Exemple #33
0
    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 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)
Exemple #35
0
    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 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_()
Exemple #37
0
    def run(self):
        print("paso por el run")
        vl = iface.activeLayer()
        if vl.wkbType() == QgsWkbTypes.Polygon or vl.wkbType(
        ) == QgsWkbTypes.MultiPolygon:
            vl.startEditing()

            fields = vl.fields()
            idx = fields.indexFromName('hectareas')

            if idx == -1:
                myField = QgsField('hectareas', QVariant.Double)
                vl.dataProvider().addAttributes([myField])
                vl.updateFields()

            for f in vl.getFeatures():
                f.setAttribute(f.fieldNameIndex('hectareas'),
                               f.geometry().area() / 10000)
                #f[idx] = '"$area"*1000'
                vl.updateFeature(f)

            vl.commitChanges()
            #coloco el puntero arriba del todo
            #QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 )

            #defino simbologia
            sym1 = QgsFillSymbol.createSimple({
                'style': 'vertical',
                'color': '0,0,0,0',
                'outline_color': 'red'
            })
            renderer = QgsSingleSymbolRenderer(sym1)
            #defino formato etiquetas
            layer_settings = QgsPalLayerSettings()
            text_format = QgsTextFormat()
            text_format.setFont(QFont("Arial", 12))
            text_format.setSize(12)
            text_format.setColor(QColor("Red"))
            layer_settings.setFormat(text_format)

            # defino etiquetas
            layer_settings.fieldName = '''concat(format_number("hectareas",2),' ha.')'''
            layer_settings.isExpression = True
            layer_settings.enabled = True
            layer_settings = QgsVectorLayerSimpleLabeling(layer_settings)
            vl.setLabelsEnabled(True)
            vl.setLabeling(layer_settings)
            vl.triggerRepaint()
            vl.setRenderer(renderer)
            #QgsProject.instance().addMapLayer(v1)
            #QgsProject.instance().removeMapLayer(layer)
            #canvas.freeze(False)
            vl.updateExtents()
            vl.commitChanges()
            vl.updateExtents()
            #canvas.setExtent(lyr9.extent())
        """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
Exemple #38
0
    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 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 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 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