Exemple #1
0
    def selectGeometry(self, geometry, mode=0, label="", toggleRendering=True):
        """Add the given geometry to the selection.

        Parameters
        ----------
        geometry : QGisCore.QgsGeometry
            Geometry to add to the selection.
        mode : int, optional
            Mode to use for the selected geometry. Defaults to 0.
        label : str, optional
            Label to use for the selected geometry. Defaults to an empty label.
        toggleRendering : boolean, optional
            Redraw the map after changing the tempLayer. Defaults to True.
            When making multiple changes to the selection set only the last
            change to toggleRendering=`True` for improved performance.

        """
        if not self.__getLayer():
            return
        f = QGisCore.QgsFeature()
        f.fields().append(QGisCore.QgsField(
            'mode', QtCore.QVariant.Int, 'int', 1, 0))
        f.fields().append(QGisCore.QgsField(
            'label', QtCore.QVariant.String, 'string', 1, 0))
        f.setGeometry(geometry)
        f.setAttributes([mode, label])
        self.main.iface.mapCanvas().setRenderFlag(False)
        self.layer.addFeature(f)
        if toggleRendering:
            self.main.iface.mapCanvas().setRenderFlag(True)
Exemple #2
0
 def createFeature(self, geom):
     #Método para criar feição
     #Parâmetro de entrada: geom (geometria adquirida)
     if not geom:
         return
     settings = QtCore.QSettings()
     canvas = self.getIface().mapCanvas()
     layer = canvas.currentLayer()
     tolerance = self.getTolerance(layer)
     geom = self.reprojectGeometry(geom)
     simplifyGeometry = self.simplifyGeometry(geom, tolerance)
     fields = layer.fields()
     feature = core.QgsFeature()
     feature.setFields(fields)
     feature.setGeometry(simplifyGeometry)
     provider = layer.dataProvider()
     for i in range(fields.count()):
         defaultClauseCandidate = provider.defaultValueClause(i)
         if defaultClauseCandidate:
             feature.setAttribute(i, defaultClauseCandidate)
     formSuppressOnLayer = layer.editFormConfig().suppress()
     formSuppressOnSettings = self.getFormSuppressStateSettings()
     featureAdded = True
     if (formSuppressOnLayer == core.QgsEditFormConfig.SuppressOn or
         (formSuppressOnLayer == core.QgsEditFormConfig.SuppressDefault
          and formSuppressOnSettings == 'true')):
         self.addFeatureWithoutForm(layer, feature)
     else:
         featureAdded = self.addFeatureWithForm(layer, feature)
     if featureAdded and core.QgsProject.instance().topologicalEditing():
         self.createTopology(feature)
Exemple #3
0
 def exportToMemoryLayer(self, route, srid, valueMaps):
     vectorLyr = core.QgsVectorLayer(
         'LineString?crs=epsg:{0}{1}'.format(
             srid, self.getMemoryLayerFieldsUrl()), 'rota', "memory")
     vl = core.QgsProject().instance().addMapLayer(vectorLyr)
     vl.startEditing()
     feat = core.QgsFeature(vl.fields())
     pavingValueMap = [
         valueMap for valueMap in valueMaps
         if valueMap['attribute'] == 'revestimento'
     ]
     pavingValueMap = pavingValueMap[0][
         'valueMap'] if pavingValueMap else {}
     getPavingValue = lambda code, valueMap=pavingValueMap: list(
         pavingValueMap.keys())[list(pavingValueMap.values()).index(code)]
     for step in route:
         step['covering'] = getPavingValue(
             step['covering']).split('(')[0].strip()
         feat.setAttribute('id', step['seq'])
         feat.setAttribute('nome', step['name'])
         feat.setAttribute('sigla', step['initials'])
         feat.setAttribute('revestimento', step['covering'])
         feat.setAttribute('faixas', step['tracks'])
         feat.setAttribute('velocidade', step['velocity'])
         feat.setAttribute('observacao', step['note'])
         feat.setGeometry(QgsGeometry.fromWkt(step['wkt']))
         vl.addFeature(feat)
     vl.commitChanges()
     return vl
Exemple #4
0
 def create_kaartblad(self, withGrid):
     gridUUID = uuid.uuid4()
     geom = self.rubberBand.asGeometry()
     geom.convertToMultiType()
     layerName = PC.OBJECT["gridlayername"]
     layer = UC.getlayer_byname(layerName)
     targetFeature = QC.QgsFeature()
     targetFields = layer.fields()
     targetFeature.initAttributes(targetFields.count())
     targetFeature.setFields(targetFields)
     targetFeature.setGeometry(geom)
     targetFeature["type"] = 'Kaartblad'
     if self.scale_25000.isChecked():
         targetFeature["scale"] = GH.DEFAULTSCALE
     else:
         targetFeature["scale"] = self.scale_custom.value()
     targetFeature["papersize"] = self.format_combo.currentText()
     if self.orient_landscape.isChecked():
         targetFeature["orientation"] = 'landscape'
     else:
         targetFeature["orientation"] = 'portrait'
     targetFeature["uuid"] = str(gridUUID)
     foreignKey = CH.get_foreign_key_ob(layerName)
     targetFeature[foreignKey] = self.objectId
     UC.write_layer(layer, targetFeature)
     bbox = geom.boundingBox()
     dist = self.distance_grid.value()
     if withGrid:
         self.create_grid(gridUUID, dist, bbox, 'Kaartblad')
     self.canvas.scene().removeItem(self.rubberBand)
Exemple #5
0
 def import_bouwlaag(self, bouwlaagFeature):
     """after the checks the import of the floor can start"""
     childFeature = QC.QgsFeature()
     layerName = 'Bouwlagen'
     layer = UC.getlayer_byname(layerName)
     # get necessary attributes from config file
     foreignKey = CH.get_foreign_key_bl(layerName)
     # construct QgsFeature to save
     childFeature.setGeometry(bouwlaagFeature.geometry())
     fields = layer.fields()
     childFeature.initAttributes(fields.count())
     childFeature.setFields(fields)
     childFeature[foreignKey] = str(self.object_id.text())
     childFeature["bouwlaag"] = int(self.bouwlaag.text())
     newFeatureId = UC.write_layer(layer, childFeature)
     self.bouwlaag_id.setText(str(newFeatureId))
     self.iface.actionPan().trigger()
     self.label2.setVisible(False)
     self.selectId.setVisible(False)
     self.label3.setVisible(True)
     self.label4.setVisible(True)
     self.label5a.setVisible(True)
     self.label5b.setVisible(True)
     self.import_laag.setVisible(True)
     self.check.setVisible(True)
     self.type.setVisible(True)
Exemple #6
0
def writeMeshShapefile(mesh, fileName, crs=None):
    try:
        os.remove(fileName)
    except OSError:
        pass
    fields = {
        0: qgis.QgsField("ID", pyqt.QVariant.Int),
        1: qgis.QgsField("Marker", pyqt.QVariant.Int),
        2: qgis.QgsField("Node1", pyqt.QVariant.Int),
        3: qgis.QgsField("Node2", pyqt.QVariant.Int),
        4: qgis.QgsField("Node3", pyqt.QVariant.Int)
    }
    writer = qgis.QgsVectorFileWriter(fileName, "utf-8", fields,
                                      qgis.QGis.WKBPolygon, crs,
                                      "ESRI Shapefile")
    if writer.hasError() != qgis.QgsVectorFileWriter.NoError:
        print "Error when creating shapefile: ", writer.hasError()
    for index, triangle in enumerate(mesh.elements):
        nodeIDs = triangle[1]
        coordinates = mesh.nodes.coordinates[nodeIDs]
        fet = qgis.QgsFeature()
        fet.setGeometry(
            qgis.QgsGeometry.fromPolygon([[
                qgis.QgsPoint(*coordinates[0]),
                qgis.QgsPoint(*coordinates[1]),
                qgis.QgsPoint(*coordinates[2])
            ]]))
        fet.addAttribute(0, pyqt.QVariant(index))
        fet.addAttribute(1, pyqt.QVariant(1))
        fet.addAttribute(2, pyqt.QVariant(1))
        writer.addFeature(fet)
Exemple #7
0
def construct_feature(layerType, parentLayerName, points, objectId, iface):
    tempFeature = QC.QgsFeature()
    parentId = None
    #converteer lijst van punten naar QgsGeometry, afhankelijk van soort geometrie
    if layerType == "Point":
        tempFeature.setGeometry(QC.QgsGeometry.fromPointXY(points))
        geom = points
    elif layerType == "LineString":
        tempFeature.setGeometry(QC.QgsGeometry.fromPolylineXY(points))
        geom = points[0]
    elif layerType == "Polygon":
        tempFeature.setGeometry(QC.QgsGeometry.fromPolygonXY([points]))
        geom = points[0]
    if parentLayerName != '' and parentLayerName == PC.OBJECT[
            "objectlayername"]:
        parentlayer = getlayer_byname(parentLayerName)
        parentId = int(objectId)
    elif parentLayerName != '' and parentLayerName is not None:
        parentlayer = getlayer_byname(parentLayerName)
        dummy, parentId = nearest_neighbor(iface, parentlayer, geom)
    elif parentLayerName is None:
        parentId = ''
    else:
        parentId = None
    #foutafhandeling ivm als er geen parentId is
    if parentId is None and parentLayerName != '':
        MSG.showMsgBox('noparentfeature')
        return None, None
    else:
        return parentId, tempFeature
Exemple #8
0
 def copy_layers(self, parentID, newID, layer, bouwlaag):
     """select the features"""
     fields = layer.fields()
     newFeature = QC.QgsFeature()
     newFeature.initAttributes(fields.count())
     newFeature.setFields(fields)
     attrs = CH.get_allkeys_bl(layer.name())
     # get features by bouwlaag ID
     it = layer.getFeatures(
         QC.QgsFeatureRequest().setFilterExpression(attrs[0] + '=' +
                                                    str(parentID)))
     for feat in it:
         newFeature.setGeometry(feat.geometry())
         if attrs[1]:
             if str(feat[attrs[1]]).isdigit():
                 newFeature[attrs[1]] = int(feat[attrs[1]])
             else:
                 newFeature[attrs[1]] = feat[attrs[1]]
         if attrs[2]:
             newFeature[attrs[2]] = feat[attrs[2]]
         if attrs[3]:
             newFeature[attrs[3]] = feat[attrs[3]]
         newFeature[attrs[0]] = int(newID)
         newFeature["bouwlaag"] = bouwlaag
         UC.write_layer(layer, newFeature)
Exemple #9
0
 def draw_feature(self, points, _dummy):
     """create the floor feature and save to the floors layer"""
     minBouwlaag = int(self.bouwlaag_min.text())
     maxBouwlaag = int(self.bouwlaag_max.text())
     childFeature = QC.QgsFeature()
     layerName = PC.PAND["bouwlaaglayername"]
     layer = UC.getlayer_byname(layerName)
     foreignKey = CH.get_foreign_key_bl(layerName)
     # construct QgsFeature to save
     for i in range(minBouwlaag, maxBouwlaag + 1):
         if i != 0:
             childFeature.setGeometry(QC.QgsGeometry.fromPolygonXY([points
                                                                    ]))
             fields = layer.fields()
             childFeature.initAttributes(fields.count())
             childFeature.setFields(fields)
             childFeature[foreignKey] = self.objectId
             childFeature["bouwlaag"] = i
             UC.write_layer(layer, childFeature)
             # block the signals of changing the comboBox to add the new floor
             self.bouwlaag.blockSignals(True)
             self.bouwlaag.clear()
             if i not in self.bouwlaagList:
                 self.bouwlaagList.append(i)
     self.bouwlaagList.sort()
     self.bouwlagen_to_combobox()
     self.bouwlaag.blockSignals(False)
     self.iface.actionPan().trigger()
     # set all layers substring to the right floor
     sub_string = "bouwlaag = " + str(minBouwlaag)
     UG.set_layer_substring(sub_string)
     if maxBouwlaag != minBouwlaag:
         MSG.showMsgBox('bouwlaagcreated')
Exemple #10
0
                    def getFeatures():
                        fields = [
                            'id', 'acquired', 'thumbnail', 'meta_html',
                            'meta_json', 'meta_jsize'
                        ]  # See FIELDs order from createLayer
                        features = []
                        for item in self.scenes:
                            # Fields
                            meta_json = item['properties']
                            vFields = {}
                            vFields[fields[0]] = item['id']
                            vFields[fields[1]] = meta_json['acquired']
                            del meta_json['acquired']
                            vFields[fields[2]] = "Need download thumbnail"
                            meta_json['assets_status'] = {
                                'a_analytic': {
                                    'status': '*Need calculate*'
                                },
                                'a_udm': {
                                    'status': '*Need calculate*'
                                }
                            }
                            vFields[fields[
                                3]] = API_PlanetLabs.getHtmlTreeMetadata(
                                    meta_json, '')
                            vjson = json.dumps(meta_json)
                            vFields[fields[4]] = vjson
                            vFields[fields[5]] = len(vjson)
                            # Geom
                            geomItem = item['geometry']
                            geomCoords = geomItem['coordinates']
                            if geomItem['type'] == 'Polygon':
                                qpolygon = map(
                                    lambda polyline: map(
                                        lambda item: QgsCore.QgsPoint(
                                            item[0], item[1]), polyline),
                                    geomCoords)
                                geom = QgsCore.QgsGeometry.fromMultiPolygon(
                                    [qpolygon])
                            elif geomItem['type'] == 'MultiPolygon':
                                qmultipolygon = []
                                for polygon in geomCoords:
                                    qpolygon = map(
                                        lambda polyline: map(
                                            lambda item: QgsCore.QgsPoint(
                                                item[0], item[1]), polyline),
                                        polygon)
                                    qmultipolygon.append(qpolygon)
                                geom = QgsCore.QgsGeometry.fromMultiPolygon(
                                    qmultipolygon)
                            else:
                                continue
                            feat = QgsCore.QgsFeature()
                            feat.setGeometry(geom)

                            atts = map(lambda item: vFields[item], fields)
                            feat.setAttributes(atts)
                            features.append(feat)

                        return features
Exemple #11
0
 def inlezen(self):
     """import the file after all settings wehere made"""
     targetLayerName = self.import_laag.currentText()
     if targetLayerName == "Ruimten":
         typeLayer = UC.getlayer_byname('ruimten_type')
     targetFeature = QC.QgsFeature()
     targetLayer = UC.getlayer_byname(targetLayerName)
     targetFields = targetLayer.fields()
     targetFeature.initAttributes(targetFields.count())
     identifier = CH.get_identifier_bl(targetLayerName)
     targetFeature.setFields(targetFields)
     self.iface.setActiveLayer(self.importLayer)
     dummy, progressBar = self.progressdialog(0)
     progressBar.setValue(0)
     progressBar.setMaximum(100)
     count = 0
     cntFeat = self.importLayer.featureCount()
     invalidCount = 0
     for feature in self.importLayer.getFeatures():
         count += 1
         if self.mappingDict[feature[self.type.currentText(
         )]] != 'niet importeren' and feature.geometry():
             if self.importTypeFile == 'DXF':
                 if self.importLayer.geometryType(
                 ) == QC.QgsWkbTypes.PolygonGeometry:
                     geom = QC.QgsGeometry.fromPolygonXY(
                         feature.geometry().asPolygon())
                 elif self.importLayer.wkbType(
                 ) == QC.QgsWkbTypes.MultiLineString:
                     geom = QC.QgsGeometry.fromMultiPolylineXY(
                         feature.geometry().asMultiPolyline())
                 else:
                     geom = QC.QgsGeometry.fromPolylineXY(
                         feature.geometry().asPolyline())
             elif self.importTypeFile in ('GPKG', 'SHP'):
                 geom = feature.geometry()
             targetFeature.setGeometry(geom)
             targetFeature["bouwlaag_id"] = int(self.bouwlaag_id.text())
             if targetLayerName == "Ruimten":
                 request = QC.QgsFeatureRequest().setFilterExpression(
                     '"naam" = ' + "'" +
                     self.mappingDict[feature[self.type.currentText()]] +
                     "'")
                 tempFeature = next(typeLayer.getFeatures(request))
                 targetFeature[identifier] = tempFeature["id"]
             else:
                 targetFeature[identifier] = self.mappingDict[feature[
                     self.type.currentText()]]
                 invalidCheck = UC.write_layer(targetLayer, targetFeature,
                                               True)
                 if invalidCheck == 'invalid':
                     invalidCount += 1
         progress = (float(count) / float(cntFeat)) * 100
         progressBar.setValue(progress)
     if invalidCount > 0:
         MSG.showMsgBox('importpartiallysuccesfull',
                        '{}'.format(invalidCount))
     else:
         MSG.showMsgBox('importsuccesfull')
     QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
 def place_feature(self, point):
     childFeature = QC.QgsFeature()
     newFeatureId = None
     self.iface.setActiveLayer(self.drawLayer)
     objectLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
     #set geometry from the point clicked on the canvas
     childFeature.setGeometry(QC.QgsGeometry.fromPointXY(point))
     foreignKey = self.identificatienummer.text()
     buttonCheck, formeleNaam = self.get_attributes(foreignKey,
                                                    childFeature)
     #return of new created feature id
     if buttonCheck != 'Cancel':
         newFeatureId = UC.write_layer(self.drawLayer, childFeature)
         objectLayer.reload()
         if not newFeatureId:
             idx = objectLayer.fields().indexFromName('id')
             maxObjectId = objectLayer.maximumValue(idx)
             request = QC.QgsFeatureRequest().setFilterExpression(
                 '"id" > {}'.format(maxObjectId))
             self.drawLayer.reload()
             tempFeatureIt = objectLayer.getFeatures(request)
             for feat in tempFeatureIt:
                 if feat["formelenaam"] == formeleNaam:
                     newFeatureId = feat["id"]
         #with new created feature run existing object widget
         if newFeatureId:
             self.run_objectgegevens(formeleNaam, newFeatureId)
         else:
             MSG.showMsgBox('newobjectslowanswer')
     else:
         self.iface.actionPan().trigger()
Exemple #13
0
def writeFractureShapefile(fractures, fileName, crs=None):
    try:
        os.remove(fileName)
    except OSError:
        pass
    fields = {
        0: qgis.QgsField("ID", pyqt.QVariant.Int),
        1: qgis.QgsField("Aperture", pyqt.QVariant.Double)
    }
    writer = qgis.QgsVectorFileWriter(fileName, "utf-8", fields,
                                      qgis.QGis.WKBLineString, crs,
                                      "ESRI Shapefile")
    if writer.hasError() != qgis.QgsVectorFileWriter.NoError:
        print "Error when creating shapefile: ", writer.hasError()
    for index, fracture in enumerate(fractures):
        feat = qgis.QgsFeature()
        feat.setGeometry(
            qgis.QgsGeometry.fromPolyline([
                qgis.QgsPoint(fracture[0], fracture[1]),
                qgis.QgsPoint(fracture[2], fracture[3])
            ]))
        # feat.addAttribute(0, pyqt.QVariant(index))
        # feat.addAttribute(1, pyqt.QVariant(1))
        # feat.addAttribute(2, pyqt.QVariant(1))
        writer.addFeature(feat)


# delete the writer to flush features to disk (optional)
    del writer
Exemple #14
0
 def createFeature(self, geom):
     #Método para criar feição
     #Parâmetro de entrada: geom (geometria adquirida)
     if geom:
         settings = QtCore.QSettings()
         canvas = self.getIface().mapCanvas()
         layer = canvas.currentLayer()
         tolerance = self.getTolerance(layer)
         geom = self.reprojectGeometry(geom)
         simplifyGeometry = self.simplifyGeometry(geom, tolerance)
         fields = layer.fields()
         feature = core.QgsFeature()
         feature.setGeometry(simplifyGeometry)
         feature.initAttributes(fields.count())
         provider = layer.dataProvider()
         for i in range(fields.count()):
             defaultClauseCandidate = provider.defaultValueClause(i)
             if defaultClauseCandidate:
                 feature.setAttribute(i, defaultClauseCandidate)
         formSuppressOnLayer = layer.editFormConfig().suppress()
         formSuppressOnSettings = self.getFormSuppressStateSettings()
         if formSuppressOnLayer == core.QgsEditFormConfig.SuppressOff or \
             (formSuppressOnLayer == core.QgsEditFormConfig.SuppressDefault \
                 and formSuppressOnSettings):
             self.addFeatureWithoutForm(layer, feature)
         else:
             self.addFeatureWithForm(layer, feature)
 def setData(self, data):
     self.idWorker = data['idWorker']
     self.lstSources = data['sources']
     self.featTemplate = QgsCore.QgsFeature(data['provLayer'].fields())
     self.ct = QgsCore.QgsCoordinateTransform()
     self.ct.setDestCRS(data['provLayer'].crs())
     self.foot = Footprint(data['hasValidPixels'], data['wktCrsImages'])
 def createFeature(self, geom):
   #Método para criar feição
   #Parâmetro de entrada: geom (geometria adquirida)
   if geom :
       settings = QtCore.QSettings()
       canvas = self.getIface().mapCanvas()
       layer = canvas.currentLayer() 
       tolerance = self.getTolerance(layer)
   
       geom = self.reprojectGeometry(geom) 
       simplifyGeometry = self.simplifyGeometry(geom, tolerance) 
  
       fields = layer.pendingFields()
       feature = core.QgsFeature()
       feature.setGeometry(simplifyGeometry)
       feature.initAttributes(fields.count())            
       provider = layer.dataProvider()              
       for i in range(fields.count()):
           feature.setAttribute(i, provider.defaultValue(i))
       formSuppressOnLayer = layer.featureFormSuppress()
       formSuppressOnSettings = self.getFormSuppressStateSettings()
       if formSuppressOnLayer or (formSuppressOnSettings == u"true"):
           self.addFeatureWithoutForm(layer, feature)
       else:
           self.addFeatureWithForm(layer, feature)
Exemple #17
0
 def addFeature(self, layer, fieldValues, geometry):
     feat = core.QgsFeature()
     feat.setFields(layer.fields())
     feat.setGeometry(geometry)
     for key in fieldValues:
         feat[key] = fieldValues[key]
     provider = layer.dataProvider()
     provider.addFeature(feat)
Exemple #18
0
 def make_feature(self, feat_id, rect):
     feat = qc.QgsFeature()
     feat.setFeatureId(feat_id)
     if rect[0] != rect[1] or rect[2] != rect[3]:
         print("WARNING: can only deal with point geometries right now")
     gPnt = qc.QgsGeometry.fromPoint(qc.QgsPoint(rect[0], rect[2]))
     feat.setGeometry(gPnt)
     return feat
Exemple #19
0
 def addRelationship(self, attributes, layer):
     relationshipFeature = core.QgsFeature()
     relationshipFeature.setFields(layer.fields())
     for name in attributes:
         relationshipFeature[name] = attributes[name]
     layer.startEditing()
     layer.addFeature(relationshipFeature)
     layer.commitChanges()
Exemple #20
0
    def inlezen(self):
        """import the file after all settings wehere made"""
        importAttr = self.type.currentText()
        invalidCount = 0
        for importType in self.mappingDict:
            if self.mappingDict[importType]["targetType"] != 'niet importeren':
                checkConv = False
                expr = QC.QgsExpression('"{}"= \'{}\''.format(
                    importAttr, importType))
                featureIt = self.importLayer.getFeatures(
                    QC.QgsFeatureRequest(expr))
                targetFeature = QC.QgsFeature()
                targetLayerName = self.mappingDict[importType]["layerName"]
                if 'Labels' in targetLayerName:
                    LabelDialog.attributes = [
                        self.type.itemText(i) for i in range(self.type.count())
                    ]
                    LabelDialog.importType = importType
                    labelField, dummy = LabelDialog.getLabelAtrribute()
                targetLayer = UC.getlayer_byname(targetLayerName)
                targetFields = targetLayer.fields()
                targetFeature.initAttributes(targetFields.count())
                targetFeature.setFields(targetFields)
                if self.mappingDict[importType][
                        "convType"] != self.layerImportType:
                    checkConv = True
                query = "SELECT foreign_key, identifier, input_label FROM config_object WHERE child_layer = '{}'".format(
                    targetLayerName)
                attrs = UC.read_settings(query, False)[0]
                targetFeature[
                    attrs[1]] = self.mappingDict[importType]["targetType"]
                targetFeature[attrs[0]] = self.object_id.text()
                targetLayer.startEditing()

                for feat in featureIt:
                    geom = None
                    if not checkConv:
                        geom = EF.getfeature_geometry(feat.geometry(),
                                                      self.layerImportType)
                        if 'Labels' in targetLayerName:
                            if feat[labelField]:
                                targetFeature[attrs[2]] = feat[labelField]
                            else:
                                targetFeature[attrs[2]] = 'geen label'
                    if geom:
                        targetFeature.setGeometry(geom)
                        invalidCheck = UC.write_layer(targetLayer,
                                                      targetFeature, True)
                        if invalidCheck == 'invalid':
                            invalidCount += 1
                targetLayer.commitChanges()
        if invalidCount > 0:
            MSG.showMsgBox('importpartiallysuccesfull',
                           '{}'.format(invalidCount))
        else:
            MSG.showMsgBox('importsuccesfull')
        QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
 def canvasReleaseEvent(self, mouseEvent):
     """handle mouse release event and return indetified feature"""
     tempfeature = QC.QgsFeature()
     results = self.identify(mouseEvent.x(), mouseEvent.y(), self.TopDownStopAtFirst, self.VectorLayer)
     if not results == []:
         tempfeature = results[0].mFeature
         idlayer = results[0].mLayer
         self.geomIdentified.emit(idlayer, tempfeature)
     else:
         self.geomIdentified.emit(None, tempfeature)
def add_feature(data_provider, geom_container):
    """
    Adds a vector feature based on the geometry and point object
    :param data_provider:
    :param geom_container:
    :return: None
    :rtype: None
    """
    new_feature = q_core.QgsFeature()
    new_feature.setGeometry(geom_container)
    data_provider.addFeatures([new_feature])
 def pointBuffer(self,p):
     infoLayer = self.infoBoxManager.getInfolayer()
     toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance())
     toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance())
     # create layer and replicate fields
     bufferLayer = core.QgsVectorLayer("Point?crs="+infoLayer.crs().toWkt(), "temporary_points", "memory")
     #bufferLayer.setCrs(infoLayer.crs()) #This generates alert message
     bufferLayer.startEditing()
     bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String))
     bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String))
     bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String))
     bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int))
     self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p)))
     fetched = 0
     self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p))
     for featId in self.featsId:
         feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__()
         if fetched < 200:
             if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry:
                 fGeom = feat.geometry().pointOnSurface()
             elif infoLayer.geometryType() == core.QgsWkbTypes.PointGeometry:
                 fGeom = feat.geometry()
             if fGeom.isMultipart():
                 multipoint = fGeom.asMultiPoint()
                 point = multipoint[0]
             else:
                 point = fGeom.asPoint()
             fetched += 1
             newGeom = core.QgsGeometry.fromPointXY(core.QgsPointXY(point))
             newFeat = core.QgsFeature()
             newFeat.setGeometry(newGeom)
             newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)])
             bufferLayer.addFeature(newFeat)
         else:
             core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning)
             break
     bufferLayer.commitChanges()
     core.QgsMessageLog.logMessage("markers context rebuilt", tag="go2streetview", level=core.Qgis.Info)
     #StreetView markers
     tmpfile = os.path.join(self.dirPath,"tmp","tmp_markers.geojson")
     core.QgsVectorFileWriter.writeAsVectorFormat (bufferLayer, tmpfile,"UTF8",toWGS84,"GeoJSON")
     with open(tmpfile) as f:
         geojson = f.read().replace('\n','')
     os.remove(tmpfile)
     #js = geojson.replace("'",'')
     #js = js.replace("\n",'\n')
     js = """this.markersJson = %s""" % json.dumps(geojson)
     self.view.SV.page().mainFrame().evaluateJavaScript(js)
     self.view.BE.page().mainFrame().evaluateJavaScript(js)
     js = """this.readJson() """
     self.view.SV.page().mainFrame().evaluateJavaScript(js)
     self.view.BE.page().mainFrame().evaluateJavaScript(js)
     core.QgsMessageLog.logMessage("webview markers refreshed", tag="go2streetview", level=core.Qgis.Info)
Exemple #24
0
 def copy_bag_bouwlaag(self, ilayer, ifeature):
     """copy the floor drom the BAG features"""
     if ilayer.name() == PC.PAND["bouwlaaglayername"] or ilayer.name(
     ) == PC.bagpand_layername():
         childFeature = QC.QgsFeature()
         layerName = PC.PAND["bouwlaaglayername"]
         # get active floor from dockwidget
         minBouwlaag = int(self.bouwlaag_min.text())
         maxBouwlaag = int(self.bouwlaag_max.text())
         layer = UC.getlayer_byname(layerName)
         # get necessary attributes from config file
         foreignKey = CH.get_foreign_key_bl(layerName)
         # construct QgsFeature to save
         for i in range(minBouwlaag, maxBouwlaag + 1):
             if i != 0:
                 childFeature.setGeometry(ifeature.geometry())
                 fields = layer.fields()
                 childFeature.initAttributes(fields.count())
                 childFeature.setFields(fields)
                 childFeature[foreignKey] = self.objectId
                 childFeature["bouwlaag"] = i
                 newFeatureId = UC.write_layer(layer, childFeature)
                 # copy also the selected layers
                 if ilayer.name() == PC.PAND["bouwlaaglayername"]:
                     self.copy_selected_layers(ifeature, newFeatureId, i)
                 # block the signals of changing the comboBox to add the new floor
                 self.bouwlaag.blockSignals(True)
                 self.bouwlaag.clear()
                 if i not in self.bouwlaagList:
                     self.bouwlaagList.append(i)
         self.bouwlaagList.sort()
         self.bouwlagen_to_combobox()
         self.bouwlaag.blockSignals(False)
         self.iface.actionPan().trigger()
         # set all layers substring to the right floor
         sub_string = "bouwlaag = " + str(minBouwlaag)
         UG.set_layer_substring(sub_string)
         try:
             self.parent.selectTool.geomSelected.disconnect()
         except:  # pylint: disable=bare-except
             pass
         if maxBouwlaag >= minBouwlaag:
             MSG.showMsgBox('bouwlaagcreated')
     else:
         MSG.showMsgBox('nobouwlaagselected')
         try:
             self.parent.selectTool.geomSelected.disconnect()
         except:  # pylint: disable=bare-except
             pass
         self.parent.selectTool.geomSelected.connect(self.copy_bag_bouwlaag)
Exemple #25
0
 def saveShapeFile(self):
     #The line below is commented to disable saving of static images in local directory to not violate point 10.1.3.b) of https://developers.google.com/maps/terms
     self.saveImg()
     #fov = str(int(90/max(1,float(self.pov['zoom']))))
     zoom = float(self.pov['zoom'])
     fov = 3.9018 * pow(zoom, 2) - 42.432 * zoom + 123
     urlimg = "http://maps.googleapis.com/maps/api/streetview?size=640x400&location=" + self.pov[
         'lat'] + "," + self.pov['lon'] + "&heading=" + self.pov[
             'heading'] + "&pitch=" + self.pov[
                 'pitch'] + "&sensor=false" + "&fov=" + str(
                     fov) + "&key=" + self.parent.APIkey
     self.cb.setText(urlimg)
     sfPath = os.path.join(self.sessionDirectory(),
                           "Streetview_snapshots_log.shp")
     if not os.path.isfile(sfPath):
         self.createShapefile(sfPath)
     vlayer = core.QgsVectorLayer(sfPath, "Streetview_snapshots_log", "ogr")
     testIfLayPresent = None
     for lay in self.canvas.layers():
         if lay.name() == "Streetview_snapshots_log":
             testIfLayPresent = True
     if not testIfLayPresent:
         vlayer.loadNamedStyle(os.path.join(self.path, "snapshotStyle.qml"))
         #self.iface.actionFeatureAction().trigger()
         core.QgsProject.instance().addMapLayer(vlayer)
         set = QtCore.QSettings()
         set.setValue("/qgis/showTips", True)
     feat = core.QgsFeature()
     feat.initAttributes(8)
     feat.setAttribute(
         0,
         datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     feat.setAttribute(1, self.pov['lon'])
     feat.setAttribute(2, self.pov['lat'])
     feat.setAttribute(3, self.pov['heading'])
     feat.setAttribute(4, self.pov['pitch'])
     feat.setAttribute(5, self.pov['address'])  #self.getAddress())
     feat.setAttribute(6, self.snapshotNotes)
     #feat.setAttribute(7,self.file_name)
     feat.setAttribute(7, QtCore.QUrl(urlimg).toString())
     feat.setGeometry(
         core.QgsGeometry.fromPointXY(
             core.QgsPointXY(float(self.pov['lon']),
                             float(self.pov['lat']))))
     vlayer.dataProvider().addFeatures([feat])
     vlayer.triggerRepaint()
Exemple #26
0
 def create_grid(self,
                 gridUUID=None,
                 dist=None,
                 extent=None,
                 gridType='Grid'):
     if not gridUUID:
         gridUUID = uuid.uuid4()
     if not dist and not extent:
         extent = self.canvas.extent()
         dist = self.distance.value()
     layerName = PC.OBJECT["gridlayername"]
     layer = UC.getlayer_byname(layerName)
     targetFeature = QC.QgsFeature()
     targetFields = layer.fields()
     targetFeature.initAttributes(targetFields.count())
     targetFeature.setFields(targetFields)
     foreignKey = CH.get_foreign_key_ob(layerName)
     xmin, dummy, ymin, dummy, xIt, yIt = self.calculate_extent(
         dist, extent, gridType)
     objectId = self.objectId
     targetFeature[foreignKey] = objectId
     targetFeature["type"] = 'Grid'
     for x in range(0, xIt):
         for y in range(0, yIt):
             yLabel = str(y + 1)
             if xIt < 26:
                 xLabel = chr(x + 97).upper()
             elif xIt >= 26:
                 xLabel = chr(int(math.floor(x / 26)) +
                              97).upper() + chr(x % 26 + 97).upper()
             geom = self.calculate_geometry(dist, xmin, ymin, x, y,
                                            gridType)
             targetFeature['vaknummer'] = xLabel + yLabel
             if x != 0:
                 yLabel = ''
             if y != 0:
                 xLabel = ''
             targetFeature.setGeometry(geom)
             targetFeature['y_as_label'] = yLabel
             targetFeature['x_as_label'] = xLabel
             targetFeature['afstand'] = dist
             targetFeature["uuid"] = str(gridUUID)
             UC.write_layer(layer, targetFeature)
     MSG.showMsgBox('gridcreated')
Exemple #27
0
 def place_feature(self, point):
     childFeature = QC.QgsFeature()
     objectLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
     # set geometry from the point clicked on the canvas
     childFeature.setGeometry(QC.QgsGeometry.fromPointXY(point))
     foreignKey = self.identificatienummer.text()
     buttonCheck, formeleNaam = self.get_attributes(foreignKey,
                                                    childFeature)
     # return of new created feature id
     if buttonCheck != 'Cancel':
         UC.write_layer(self.drawLayer, childFeature)
         objectLayer.reload()
         self.close_objectnieuw_show_base()
     else:
         self.iface.actionPan().trigger()
     try:
         self.parent.pinTool.canvasClicked.disconnect()
     except:
         pass
Exemple #28
0
 def getFeatureById(self, layer, featureId):
     f = core.QgsFeature()
     it = layer.getFeatures(core.QgsFeatureRequest(featureId))
     it.nextFeature(f)
     return f
Exemple #29
0
 def addFeature(self, attributes, geometry, layer):
     feat = core.QgsFeature()
     feat.setAttributes(attributes)
     feat.setGeometry(geometry)
     layer.addFeature(feat)
Exemple #30
0
    def inlezen_validatie(self):
        """import the file after all settings wehere made"""
        targetLayerName = self.import_laag.currentText()
        targetLayer = UC.getlayer_byname(targetLayerName)
        targetFields = targetLayer.fields()

        if targetLayerName == "Ruimten":
            typeLayer = UC.getlayer_byname('ruimten_type')
            tempImportLayer = self.init_layer_fields(
                targetFields,
                ["MultiPolygon?crs=epsg:28992", "tempImport", "memory"])
            tempImportLayerInvalid = self.init_layer_fields(
                targetFields, [
                    "MultiPolygon?crs=epsg:28992", "tempImport_invalid",
                    "memory"
                ])
        else:
            tempImportLayer = self.init_layer_fields(
                targetFields,
                ["MultiLinestring?crs=epsg:28992", "tempImport", "memory"])
            tempImportLayerInvalid = self.init_layer_fields(
                targetFields, [
                    "MultiLinestring?crs=epsg:28992", "tempImport_invalid",
                    "memory"
                ])

        identifier = CH.get_identifier_bl(targetLayerName)

        bouwlaagGeomCentroid = self.get_centroid()
        dummy, progressBar = self.progressdialog(0)
        count = 0
        cntFeat = self.importLayer.featureCount()
        invalidCount = 0
        validFeatures = []
        invalidFeatures = []
        geomCheck = True

        for feature in self.importLayer.getFeatures():
            targetFeature = QC.QgsFeature()
            targetFeature.initAttributes(targetFields.count())
            targetFeature.setFields(targetFields)
            count += 1
            if self.mappingDict[feature[self.type.currentText(
            )]] != 'niet importeren' and feature.geometry():
                if self.importTypeFile == 'DXF':
                    geom, geomCheck = self.check_feature_validity(
                        feature, bouwlaagGeomCentroid)
                elif self.importTypeFile in ('GPKG', 'SHP'):
                    geom = feature.geometry()
                targetFeature.setGeometry(geom)
                targetFeature["bouwlaag_id"] = int(self.bouwlaag_id.text())
                if targetLayerName == "Ruimten":
                    req = '"naam" = ' + "'" + self.mappingDict[feature[
                        self.type.currentText()]] + "'"
                    request = QC.QgsFeatureRequest().setFilterExpression(req)
                    tempFeature = next(typeLayer.getFeatures(request))
                    targetFeature[identifier] = tempFeature["id"]
                else:
                    targetFeature[identifier] = self.mappingDict[feature[
                        self.type.currentText()]]
                    if geomCheck:
                        validFeatures.append(targetFeature)
                    else:
                        invalidFeatures.append(targetFeature)
                        invalidCount += 1
            progress = (float(count) / float(cntFeat)) * 100
            progressBar.setValue(progress)

        if validFeatures:
            UC.write_layer(tempImportLayer, validFeatures, False, False)
        if invalidFeatures:
            UC.write_layer(tempImportLayerInvalid, invalidFeatures, False,
                           False)
        QC.QgsProject.instance().addMapLayer(tempImportLayer, True)
        QC.QgsProject.instance().addMapLayer(tempImportLayerInvalid, True)
        if invalidCount > 0:
            MSG.showMsgBox('importpartiallysuccesfull',
                           '{}'.format(invalidCount))
        else:
            MSG.showMsgBox('importsuccesfull')
        QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
        self.label8.setVisible(True)
        self.import_file.setVisible(True)