Example #1
0
    def add_geom_columns(context, layer: QgsVectorLayer) -> None:
        """ Add latitude and longitude columns in the layer. """
        fields = [
            QgsField('longitude', type=QVariant.Double),
            QgsField('latitude', type=QVariant.Double),
        ]
        transform = QgsCoordinateTransform(
            layer.crs(), QgsCoordinateReferenceSystem('EPSG:4326'),
            context.project())

        with edit(layer):
            for field in fields:
                layer.addAttribute(field)

            request = QgsFeatureRequest()
            request.setSubsetOfAttributes(['latitude', 'longitude'],
                                          layer.fields())
            for feature in layer.getFeatures(request):
                geom = QgsGeometry(feature.geometry())
                if not geom:
                    continue

                geom.transform(transform)
                geom = geom.centroid().asPoint()
                feature.setAttribute('longitude', geom.x())
                feature.setAttribute('latitude', geom.y())
                layer.updateFeature(feature)
Example #2
0
def snapToPrecision(geom, precision):
    snapped = QgsGeometry(geom)
    if precision == 0.0:
        return snapped

    i = 0
    p = snapped.vertexAt(i)
    while p.x() != 0.0 and p.y() != 0.0:
        x = round(p.x() / precision, 0) * precision
        y = round(p.y() / precision, 0) * precision
        snapped.moveVertex(x, y, i)
        i = i + 1
        p = snapped.vertexAt(i)
    return QgsPointXY(snapped.x(), snapped.y())
Example #3
0
def snapToPrecision(geom, precision):
    snapped = QgsGeometry(geom)
    if precision == 0.0:
        return snapped

    i = 0
    p = snapped.vertexAt(i)
    while p.x() != 0.0 and p.y() != 0.0:
        x = round(p.x() / precision, 0) * precision
        y = round(p.y() / precision, 0) * precision
        snapped.moveVertex(x, y, i)
        i = i + 1
        p = snapped.vertexAt(i)
    return QgsPointXY(snapped.x(), snapped.y())
    def doWork(self):
        #Defining layer type
        for testLayer in self.iface.mapCanvas().layers():
            if testLayer.type() == QgsMapLayer.VectorLayer:
                workFeature = list(testLayer.getSelectedFeatures())
                workCrs = testLayer.crs()
        if not workFeature:
            QMessageBox.critical(self, u"Erro", u"Nenhuma feição selecionada. Selecione ao menos uma feição vetorial.")
            return
        workGeometries = []
        for i in range(len(workFeature)):
            workGeometries.append(workFeature[i].geometry())

        centr = QgsGeometry().collectGeometry(workGeometries).centroid()
        listElem = QgsFeature()
        listElem.setGeometry(centr)
        centrList = []
        centrList.append(listElem)
        centr = centr.asPoint()
		
        #Opening UTM Zones layer and finding intersections
        utmZone = DimensionsVFDialog(self.iface).UTMcheck(centrList, workCrs)[0]
        decl = GeoMag().GeoMag(centr.y(), centr.x()).dec
        conv = DeclConvDockWidget(self.iface).calcConvergence(centr)

        if not utmZone:
            QMessageBox.critical(self, u"Erro", u"Feição selecionada fora do Brasil. Escolha uma feição dentro.")
            return

        pontos = {}
        pointList=[]
        for f in workGeometries:
            for i in f.vertices():
                pointList.append(i)
            pontos[f] = pointList
            pointList=[]
		
        pontos_conv = {}
        pointList=[]
        zoneDict = {'18S':31978,'19N':31973, '19S':31979, '20N':31974, '20S':31980,'21N':31975, '21S':31981, '22N':31976, '22S':31982, '23S':31983, '24S':31984, '25S':31985, '26S':31986}
        transformer = QgsCoordinateTransform(workCrs, QgsCoordinateReferenceSystem(zoneDict[utmZone[0]], QgsCoordinateReferenceSystem.EpsgCrsId), QgsProject.instance())
        for f in workGeometries:
            for i in range(len(list(f.vertices()))):
                pointList.append(pontos[f][i])
                pointList[i].transform(transformer)
            pontos_conv[f] = pointList
            pointList=[]


        self.convEdit.setText(str(conv))
        self.declEdit.setText(str(decl))

        self.final_list = []

        ponto_inicial = pontos[0]
        
        for idx in range(0,len(pontos)-1):
            
            pt1 = pontos_conv[idx]
            pt2 = pontos_conv[idx+1]
            crs1 = pontos[idx][1]
            
            azim = pt1.azimuth(pt2) - decl
            if azim < 0:
                azim = azim + 360
                
            d = QgsDistanceArea()
            dist = format( d.measureLine(pt1,pt2), '.3f' )
            #VERIFICAR UNIDADES DO MAPA
            if crs1.mapUnits in [QGis.Degrees, QGis.DecimalDegrees]:
                #GERAR GRAU, MINUTOS E SEGUNDOS PARA X E Y
                x    = self.gerarGMS( pontos[idx][0].x() )
                y    = self.gerarGMS( pontos[idx][0].y() )
            else:
                x    = str( pontos[idx][0].x() )
                y    = str( pontos[idx][0].y() )

            a    = self.gerarGMS( azim )
            am   = format( self.converterParaMilesimos( azim - decl ), '.3f' )
            
            self.final_list.append( (x, y, a, am, dist, crs1) )

        ponto_final = pontos_conv[len(pontos)-1]
        
        crsFinal = pontos[len(pontos)-1][1]
        
        x = self.gerarGMS( pontos[len(pontos)-1][0].x() ) if crsFinal.mapUnits() in [QGis.Degrees, QGis.DecimalDegrees] else str( pontos[len(pontos)-1][0].x() )
        y = self.gerarGMS( pontos[len(pontos)-1][0].y() ) if crsFinal.mapUnits() in [QGis.Degrees, QGis.DecimalDegrees] else str( pontos[len(pontos)-1][0].y() )

        self.final_list.append( (x, y, u"Final", u"Final", u"Final") )
        
        #CRIAR A TABELA DA INTERFACE
        self.exportDialog.fillTable(self.final_list, decl, conv, ponto_inicial)