def save2PointShape(shapePath, geodata, attribName, attribData, label, spatialRef): """ :param label: :param shapePath: Pfad wo Shapefile agespeichert wird :param geodata: Koordinaten der Punkte :param attribName: Attributname (Feldname) von zusätzlichen Werten :param attribData: Werte für Attribute :param spatialRef: Räumliche Referenz """ # define fields for feature attributes. A QgsFields object is needed fields = QgsFields() fields.append(QgsField("StuetzenNr", QVariant.String)) fields.append(QgsField(attribName, QVariant.Int)) writer = QgsVectorFileWriter(shapePath, "UTF8", fields, QgsWkbTypes.PointZ, spatialRef, "ESRI Shapefile") if writer.hasError() != QgsVectorFileWriter.NoError: # TODO raise Exception("Vector Writer") for idx, (coords, attrib) in enumerate(zip(geodata, attribData)): feature = QgsFeature() feature.setFields(fields) # TODO: Nicht 3D weil Methode fromPoint() nicht existiert. Wird evtl. in der Zukunft implementiert feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(coords[0], coords[1]))) feature.setId(idx) feature.setAttribute("StuetzenNr", label[idx]) feature.setAttribute(attribName, attrib) writer.addFeature(feature) del feature # delete the writer to flush features to disk del writer
def draw_m5x(self): x = self.e_mesh["Lx1d"] - 1 while x <= self.e_mesh["Rx1d"]+1: x1d = math.floor(x) x2d = math.floor((x-x1d)*8) x5x = math.floor((x-x1d-x2d/8.0)*16) y = self.e_mesh["Ly1d"] - 1 while y <= self.e_mesh["Uy1d"]+1: y1d = math.floor(y) y2d = math.floor((y-y1d)*8) y5x = math.floor((y-y1d-y2d/8.0)*16) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/16.0)/1.5), QgsPoint(x+100+1/16.0,(y+1/16.0)/1.5),QgsPoint(x+100+1/16.0,y/1.5)]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m5x_str = str(int(x5x+y5x*2+1)) mesh_str = m1d_str + "-" + m2d_str + "-" + m5x_str f.setAttribute("meshC",mesh_str) self.meshPolyLayer.addFeature(f) y += 1/16.0 x += 1/16.0
def add_gbif_occ_to_layer(occurrences, layer): features = [] dp = layer.dataProvider() for o in occurrences: attrs = [] for k in o.keys(): field_index = dp.fieldNameIndex(k) # Add a layer attribute for each JSON fields(if not already encountered) if field_index == -1: dp.addAttributes([QgsField(k, QtCore.QVariant.String)]) attrs.append({'attr': k, 'val': _get_field_value(o, k)}) feat = QgsFeature() # We should tell the feature which will be its fields # !! We need a variable !! Don't merge the next two lines !! myFields = dp.fields() feat.setFields(myFields) for d in attrs: feat.setAttribute(d['attr'], d['val']) feat.setGeometry(QgsGeometry.fromPoint(QgsPoint(o['decimalLongitude'], o['decimalLatitude']))) features.append(feat) add_features_to_layer(layer, features)
def createGeometry(self, geom): geom = self.reprojectRubberBand(geom) if geom : layer = self.canvas.currentLayer() feature = QgsFeature() fields = layer.pendingFields() feature.setGeometry(geom) feature.initAttributes(fields.count()) provider = layer.dataProvider() for i in range(fields.count()): feature.setAttribute(i, provider.defaultValue(i)) form = QgsAttributeDialog(layer, feature, False) form.setMode(QgsAttributeForm.AddFeatureMode) formSuppress = layer.editFormConfig().suppress() if formSuppress == QgsEditFormConfig.SuppressDefault: if self.getSuppressOptions(): #this is calculated every time because user can switch options while using tool layer.addFeature(feature, True) else: if not form.dialog().exec_(): feature.setAttributes(form.feature().attributes()) elif formSuppress == QgsEditFormConfig.SuppressOff: if not form.dialog().exec_(): feature.setAttributes(form.feature().attributes()) else: layer.addFeature(feature, True) layer.endEditCommand() self.canvas.refresh() self.initVariable()
def test_ExpressionFieldEllipsoidLengthCalculation(self): #create a temporary layer temp_layer = QgsVectorLayer("LineString?crs=epsg:3111&field=pk:int", "vl", "memory") self.assertTrue(temp_layer.isValid()) f1 = QgsFeature(temp_layer.dataProvider().fields(), 1) f1.setAttribute("pk", 1) f1.setGeometry(QgsGeometry.fromPolyline([QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853)])) temp_layer.dataProvider().addFeatures([f1]) # set project CRS and ellipsoid srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4()) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid()) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid()) QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84") QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Meters)) idx = temp_layer.addExpressionField('$length', QgsField('length', QVariant.Double)) # NOQA # check value f = temp_layer.getFeatures().next() expected = 26932.156 self.assertAlmostEqual(f['length'], expected, 3) # change project length unit, check calculation respects unit QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QGis.Feet)) f = temp_layer.getFeatures().next() expected = 88360.0918635 self.assertAlmostEqual(f['length'], expected, 3)
def _create_points(self): """Create points for testing""" point_layer = QgsVectorLayer('Point?crs=EPSG:4326', 'points', 'memory') point_provider = point_layer.dataProvider() point_provider.addAttributes([QgsField('X', QVariant.Double)]) point_provider.addAttributes([QgsField('Y', QVariant.Double)]) x_index = point_provider.fieldNameIndex('X') y_index = point_provider.fieldNameIndex('Y') point_layer.startEditing() for x in [10.0, 20.0, 30.0]: for y in [10.0, 20.0, 30.0]: feature = QgsFeature() feature.initAttributes(2) feature.setAttribute(x_index, x) feature.setAttribute(y_index, y) # noinspection PyCallByClass geom = QgsGeometry.fromPoint(QgsPoint(x, y)) feature.setGeometry(geom) _ = point_layer.dataProvider().addFeatures([feature]) point_layer.commitChanges() return point_layer
def populate_qlayer(self): layer=self.qlayer # shouldn't be necessary layer.dataProvider().deleteFeatures(layer.allFeatureIds()) # takes an existing line memory layer, adds in nodes from g feats=[] valid=[] for j in self.grid.valid_edge_iter(): geom=self.edge_geometry(j) valid.append(j) feat = QgsFeature() feat.initAttributes(len(self.e_attrs)) for idx,eattr in enumerate(self.e_attrs): name=eattr.name() typecode=eattr.type() if name=='edge_id': feat.setAttribute(idx,j) elif name=='c0': feat.setAttribute(idx,int(self.grid.edges['cells'][j,0])) elif name=='c1': feat.setAttribute(idx,int(self.grid.edges['cells'][j,1])) elif typecode==2: # integer feat.setAttribute(idx,int(self.grid.edges[name][j])) elif typecode==6: # double feat.setAttribute(idx,float(self.grid.edges[name][j])) else: continue # QGIS doesn't know about numpy types # feat.setAttribute(3,int(self.grid.edges['mark'][j])) feat.setGeometry(geom) feats.append(feat) (res, outFeats) = layer.dataProvider().addFeatures(feats) self.grid.edges['feat_id'][valid]=[f.id() for f in outFeats]
def rightClicked(self, _): """ The party is over, the reach digitized. Create a feature from the rubberband and show the feature form. """ self.tempRubberband.reset() f = QgsFeature(self.layer.pendingFields()) f.setGeometry(self.rubberband.asGeometry()) if self.firstSnappingResult is not None: req = QgsFeatureRequest(self.firstSnappingResult.snappedAtGeometry) from_networkelement = self.firstSnappingResult.layer.getFeatures(req).next() from_field = self.layer.pendingFields()\ .indexFromName('rp_from_fk_wastewater_networkelement') f.setAttribute(from_field, from_networkelement.attribute('obj_id')) if self.lastSnappingResult is not None: req = QgsFeatureRequest(self.lastSnappingResult.snappedAtGeometry) to_networkelement = self.lastSnappingResult.layer.getFeatures(req).next() to_field = self.layer.pendingFields().indexFromName('rp_to_fk_wastewater_networkelement') f.setAttribute(to_field, to_networkelement.attribute('obj_id')) dlg = self.iface.getFeatureForm(self.layer, f) dlg.setIsAddDialog(True) dlg.exec_() self.rubberband.reset()
def finalCopy(self, l_orig, l_dest, data): """Eléments sélectionnés""" selection = l_orig.selectedFeatures() """Itération par entité""" if l_orig.selectedFeatureCount() < 1: self.msgBarre(2, "1") if self.franc : type1 = {0:"point",1:"ligne",2:"polygone",3:"inconnu", 4:u"aucune géométrie"} type2 = {0:"inconnu",1:"point",2:"ligne",3:"polygone",4:"point",5:"ligne",6:"polygone",7:u"aucune géométrie"} else: type1 = {0:"point",1:"line",2:"polygon",3:"unknown", 4:u"no geometry"} type2 = {0:"unknown",1:"point",2:"line",3:"polygon",4:"point",5:"line",6:"polygon",7:u"no geometry"} for feature in selection : if type1[feature.geometry().type()] == type2[l_dest.wkbType()]: """Création des entités""" caps = l_dest.dataProvider().capabilities() if caps & QgsVectorDataProvider.AddFeatures: feat = QgsFeature(l_dest.pendingFields()) for x in range(0, len(data), 2) : if data[x + 1][:3] == "fld": feat.setAttribute(data[x], feature[data[x + 1].split("|")[1]]) elif data[x + 1] == "null": pass else: feat.setAttribute(data[x], data[x + 1]) feat.setGeometry(feature.geometry()) l_dest.startEditing() l_dest.addFeatures([feat], True) else: self.msgBarre(2, "2|" + type1[feature.geometry().type()] + "_" + type2[l_dest.wkbType()]) break
def processAlgorithm(self, feedback): extent = str(self.getParameterValue(self.EXTENT)).split(',') spacing = float(self.getParameterValue(self.SPACING)) inset = float(self.getParameterValue(self.INSET)) randomize = self.getParameterValue(self.RANDOMIZE) isSpacing = self.getParameterValue(self.IS_SPACING) crsId = self.getParameterValue(self.CRS) crs = QgsCoordinateReferenceSystem() crs.createFromUserInput(crsId) extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, crs) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if randomize: geom = QgsGeometry().fromPoint(QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPoint(QgsPoint(x, y)) if extent_engine.intersects(geom.geometry()): f.setAttribute('id', count) f.setGeometry(geom) writer.addFeature(f) x += pSpacing count += 1 feedback.setProgress(int(count * total)) y = y - pSpacing del writer
def draw_m3d(self): x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 + self.e_mesh["Lx3d"] / 80.0 - 1 / 80.0 while x <= self.e_mesh["Rx1d"] + self.e_mesh["Rx2d"] / 8.0 + self.e_mesh["Rx3d"] / 80.0 + 1 / 80.0: x1d = math.floor(x) x2d = math.floor((x-x1d)*8) x3d = math.floor((x-x1d-x2d/8.0)*80) y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 + self.e_mesh["Ly3d"] / 80.0 - 1 / 80.0 while y <= self.e_mesh["Uy1d"] + self.e_mesh["Uy2d"] / 8.0 + self.e_mesh["Uy3d"] / 80.0 + 1 / 80.0: y1d = math.floor(y) y2d = math.floor((y-y1d)*8) y3d = math.floor((y-y1d-y2d/8.0)*80) f = QgsFeature(self.meshPolyLayer.pendingFields()) f.setGeometry(QgsGeometry.fromPolygon( [[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/80.0)/1.5), QgsPoint(x+100+1/80.0,(y+1/80.0)/1.5),QgsPoint(x+100+1/80.0,y/1.5)]])) m1d_str = str(int(y1d)) + str(int(x1d)) m2d_str = str(int(y2d)) + str(int(x2d)) m3d_str = str(int(y3d)) + str(int(x3d)) mesh_str = m1d_str + m2d_str + m3d_str f.setAttribute("meshC",mesh_str) self.meshPolyLayer.addFeature(f) y += 1/80.0 x += 1/80.0
def processAlgorithm(self, parameters, context, feedback): spacing = self.parameterAsDouble(parameters, self.SPACING, context) inset = self.parameterAsDouble(parameters, self.INSET, context) randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context) isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context) crs = self.parameterAsCrs(parameters, self.CRS, context) extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, crs) if sink is None: raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT)) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine(extent_geom.constGet()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if feedback.isCanceled(): break if randomize: geom = QgsGeometry().fromPointXY(QgsPointXY( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPointXY(QgsPointXY(x, y)) if extent_engine.intersects(geom.constGet()): f.setAttribute('id', count) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) x += pSpacing count += 1 feedback.setProgress(int(count * total)) y = y - pSpacing return {self.OUTPUT: dest_id}
def __createMemoryLayer(self, layer_name, gtype, geometries, attributes, fNames, fTypes): """ Create a memory layer from parameters :param layer_name: name for the layer :param gtype: geometry type of the layer :param geometries: objects geometries :param attributes: objects attributes :param fNames: fields names :param fTypes: fields types """ layerList = QgsMapLayerRegistry.instance().mapLayersByName(layer_name) if layerList: QgsMapLayerRegistry.instance().removeMapLayers([layerList[0].id()]) epsg = self.canvas().mapRenderer().destinationCrs().authid() fieldsParam = "" for i in range(len(fNames)): fieldsParam += "&field=" + fNames[i] + ":" + fTypes[i] layer = QgsVectorLayer(gtype + "?crs=" + epsg + fieldsParam + "&index=yes", layer_name, "memory") QgsMapLayerRegistry.instance().addMapLayer(layer) layer.startEditing() for i in range(len(geometries)): feature = QgsFeature() feature.setGeometry(QgsGeometry().fromWkt(geometries[i])) fields = layer.pendingFields() feature.setFields(fields) for j in range(len(fNames)): feature.setAttribute(fNames[j], attributes[i][j]) layer.addFeature(feature) layer.commitChanges()
def test_ExpressionFieldEllipsoidAreaCalculation(self): #create a temporary layer temp_layer = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl", "memory") self.assertTrue(temp_layer.isValid()) f1 = QgsFeature(temp_layer.dataProvider().fields(), 1) f1.setAttribute("pk", 1) f1.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(2484588, 2425722), QgsPoint(2482767, 2398853), QgsPoint(2520109, 2397715), QgsPoint(2520792, 2425494), QgsPoint(2484588, 2425722)]])) temp_layer.dataProvider().addFeatures([f1]) # set project CRS and ellipsoid srs = QgsCoordinateReferenceSystem(3111, QgsCoordinateReferenceSystem.EpsgCrsId) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSProj4String", srs.toProj4()) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid()) QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid()) QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84") QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMeters)) idx = temp_layer.addExpressionField('$area', QgsField('area', QVariant.Double)) # NOQA # check value f = temp_layer.getFeatures().next() expected = 1009089817.0 self.assertAlmostEqual(f['area'], expected, delta=1.0) # change project area unit, check calculation respects unit QgsProject.instance().writeEntry("Measurement", "/AreaUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.SquareMiles)) f = temp_layer.getFeatures().next() expected = 389.6117565069 self.assertAlmostEqual(f['area'], expected, 3)
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context) minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context) bbox = source.sourceExtent() sourceIndex = QgsSpatialIndex(source, feedback) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, source.sourceCrs()) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount if pointCount else 1 index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: if feedback.isCanceled(): break rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() p = QgsPointXY(rx, ry) geom = QgsGeometry.fromPointXY(p) ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox()) if len(ids) > 0 and \ vector.checkMinDistance(p, index, minDistance, points): request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([]) for f in source.getFeatures(request): if feedback.isCanceled(): break tmpGeom = f.geometry() if geom.within(tmpGeom): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) index.insertFeature(f) points[nPoints] = p nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: feedback.pushInfo(self.tr('Could not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) return {self.OUTPUT: dest_id}
def pixels_to_points( raster, threshold_min=0.0, threshold_max=float('inf'), field_name='value'): """ Convert raster to points. Areas (pixels) with threshold_min < pixel_values < threshold_max will be converted to point layer. :param raster: Raster layer :type raster: QgsRasterLayer :param threshold_min: Value that splits raster to flooded or not flooded. :type threshold_min: float :param threshold_max: Value that splits raster to flooded or not flooded. :type threshold_max: float :param field_name: Field name to store pixel value. :type field_name: string :returns: Point layer of pixels :rtype: QgsVectorLayer """ if raster.bandCount() != 1: msg = "Current version allows using of one-band raster only" raise NotImplementedError(msg) extent = raster.extent() width, height = raster.width(), raster.height() provider = raster.dataProvider() block = provider.block(1, extent, width, height) # Create points crs = raster.crs().toWkt() point_layer = QgsVectorLayer('Point?crs=' + crs, 'pixels', 'memory') point_provider = point_layer.dataProvider() point_provider.addAttributes([QgsField(field_name, QVariant.Double)]) field_index = point_provider.fieldNameIndex(field_name) attribute_count = 1 point_layer.startEditing() for row in range(height): for col in range(width): value = block.value(row, col) x, y = _get_pixel_coordinates(extent, width, height, row, col) # noinspection PyCallByClass,PyTypeChecker,PyArgumentList geom = QgsGeometry.fromPoint(QgsPoint(x, y)) if threshold_min < value < threshold_max: feature = QgsFeature() feature.initAttributes(attribute_count) feature.setAttribute(field_index, value) feature.setGeometry(geom) _ = point_layer.dataProvider().addFeatures([feature]) point_layer.commitChanges() return point_layer
def __ok(self, withVertex, withPoint): """ To apply the interpolation :param withVertex: if we want a new interpolated vertex :param withPoint: if we want a new interpolated point """ line_v2, curved = GeometryV2.asLineV2(self.__selectedFeature.geometry(), self.__iface) vertex_v2 = QgsPointV2() vertex_id = QgsVertexId() line_v2.closestSegment(QgsPointV2(self.__mapPoint), vertex_v2, vertex_id, 0) x0 = line_v2.xAt(vertex_id.vertex-1) y0 = line_v2.yAt(vertex_id.vertex-1) d0 = Finder.sqrDistForCoords(x0, vertex_v2.x(), y0, vertex_v2.y()) x1 = line_v2.xAt(vertex_id.vertex) y1 = line_v2.yAt(vertex_id.vertex) d1 = Finder.sqrDistForCoords(x1, vertex_v2.x(), y1, vertex_v2.y()) z0 = line_v2.zAt(vertex_id.vertex-1) z1 = line_v2.zAt(vertex_id.vertex) z = old_div((d0*z1 + d1*z0), (d0 + d1)) vertex_v2.addZValue(round(z, 2)) if withPoint: pt_feat = QgsFeature(self.__layer.pendingFields()) pt_feat.setGeometry(QgsGeometry(vertex_v2)) for i in range(len(self.__layer.pendingFields())): # default = self.__layer.defaultValue(i, pt_feat) # if default is not None: # print(pt_feat.fields().at(i).name(), pt_feat.fields().at(i).defaultValueExpression(), default) # print(self.__layer.defaultValueExpression(i), self.__layer.expressionField(i)) e = QgsExpression(self.__layer.defaultValueExpression(i)) default = e.evaluate(pt_feat) pt_feat.setAttribute(i, default) if self.__layer.editFormConfig().suppress() == QgsEditFormConfig.SuppressOn: self.__layer.addFeature(pt_feat) else: self.__iface.openFeatureForm(self.__layer, pt_feat) if withVertex: line_v2.insertVertex(vertex_id, vertex_v2) self.__lastLayer.changeGeometry(self.__selectedFeature.id(), QgsGeometry(line_v2)) found_features = self.__lastLayer.selectedFeatures() if len(found_features) > 0: if len(found_features) > 1: self.__iface.messageBar().pushMessage(QCoreApplication.translate("VDLTools", "One feature at a time"), level=QgsMessageBar.INFO) else: self.__selectedFeature = found_features[0] else: self.__iface.messageBar().pushMessage(QCoreApplication.translate("VDLTools", "No more feature selected"), level=QgsMessageBar.INFO) self.__iface.mapCanvas().refresh() self.__done() self.__findVertex = True
def createLayerWithOnePolygon(): layer = QgsVectorLayer("Polygon?crs=epsg:3111&field=pk:int", "vl", "memory") assert layer.isValid() f1 = QgsFeature(layer.dataProvider().fields(), 1) f1.setAttribute("pk", 1) f1.setGeometry(QgsGeometry.fromPolygonXY([[QgsPointXY(2484588, 2425722), QgsPointXY(2482767, 2398853), QgsPointXY(2520109, 2397715), QgsPointXY(2520792, 2425494), QgsPointXY(2484588, 2425722)]])) assert layer.dataProvider().addFeatures([f1]) return layer
def test_setAttribute(self): feat = QgsFeature() feat.initAttributes(1) with self.assertRaises(KeyError): feat.setAttribute(-1, 5) with self.assertRaises(KeyError): feat.setAttribute(10, 5) self.assertTrue(feat.setAttribute(0, 5))
def test_CreateFeature(self): feat = QgsFeature() feat.initAttributes(1) feat.setAttribute(0, "text") feat.setGeometry(QgsGeometry.fromPoint(QgsPoint(123, 456))) myId = feat.id() myExpectedId = 0 myMessage = "\nExpected: %s\nGot: %s" % (myExpectedId, myId) assert myId == myExpectedId, myMessage
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.VECTOR)) pointCount = int(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) bbox = layer.extent() idxLayer = vector.spatialindex(layer) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, layer.crs()) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount index = QgsSpatialIndex() points = dict() request = QgsFeatureRequest() random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox()) if len(ids) > 0 and \ vector.checkMinDistance(pnt, index, minDistance, points): for i in ids: f = next(layer.getFeatures(request.setFilterFid(i))) tmpGeom = f.geometry() if geom.within(tmpGeom): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 progress.setPercentage(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog(ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) del writer
def processAlgorithm(self, feedback): pointCount = int(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) extent = str(self.getParameterValue(self.EXTENT)).split(',') crsId = self.getParameterValue(self.CRS) crs = QgsCoordinateReferenceSystem() crs.createFromUserInput(crsId) xMin = float(extent[0]) xMax = float(extent[1]) yMin = float(extent[2]) yMax = float(extent[3]) extent = QgsGeometry().fromRect( QgsRectangle(xMin, yMin, xMax, yMax)) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, crs) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = xMin + (xMax - xMin) * random.random() ry = yMin + (yMax - yMin) * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if geom.within(extent) and \ vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog(ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) del writer
def randomize(self, inLayer, outPath, minimum, design, value): outFeat = QgsFeature() outFeat.initAttributes(1) if design == self.tr("unstratified"): ext = inLayer.extent() if inLayer.type() == QgsMapLayer.RasterLayer: points = self.simpleRandom( int(value), ext, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points = self.vectorRandom( int(value), inLayer, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points, featErrors = self.loopThruPolygons(inLayer, value, design) if featErrors: if len(featErrors) >= 10: err_msg = "Too many features couldn't be calculated due to conversion error. " err_msg += "Please check out message log for more info." msgLogInstance = QgsMessageLog.instance() msgLogInstance.logMessage("WARNING - fTools: " + self.tr("Random Points")) msgLogInstance.logMessage("The following feature ids should be checked.") for feat in featErrors: msgLogInstance.logMessage("Feature id: %d" % feat.id()) msgLogInstance.logMessage("End of features to be checked.") else: features_ids = [] for feat in featErrors: features_ids.append(unicode(feat.id())) erroneous_ids = ', '.join(features_ids) err_msg = "The following features IDs couldn't be calculated due to conversion error: %s" % erroneous_ids self.iface.messageBar().pushMessage("Errors", err_msg) if len(points): crs = self.iface.mapCanvas().mapRenderer().destinationCrs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) outFeat.setFields(fields) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs) idVar = 0 count = 70.00 add = (100.00 - 70.00) / len(points) for i in points: outFeat.setGeometry(i) outFeat.setAttribute(0, idVar) writer.addFeature(outFeat) idVar = idVar + 1 count = count + add self.progressBar.setValue(count) del writer return True return False
def create_layer(self, parameters, name, is_memory, dest_crs, layer_style=None): save_as = parameters.file_path file_format = parameters.file_format # save paramaters serialized = base64.b64encode(parameters.serialize(with_style=False, with_geometry=False)) # save geometry layer = QgsVectorLayer("MultiPolygon?crs=%s" % dest_crs.authid(), name, "memory") pr = layer.dataProvider() layer.startEditing() layer.addAttribute(QgsField("params", QVariant.String)) fet1 = QgsFeature(0) fet1.setFields(layer.fields()) fet1.setAttribute("params", str(serialized)[2:-1]) fet1.setGeometry(parameters.geometry) pr.addFeatures([fet1]) layer.commitChanges() # copy layer style if layer_style is not None: self.set_layer_style(layer, layer_style) if is_memory: return layer if os.path.isfile(save_as): # delete first if already exists if save_as.endswith(".shp"): QgsVectorFileWriter.deleteShapeFile(save_as) else: os.unlink(save_as) # create the disk layer QgsMessageLog.logMessage("Mask saving '{}' as {}".format(save_as, file_format), 'Extensions') error = QgsVectorFileWriter.writeAsVectorFormat(layer, save_as, "System", dest_crs, file_format) if error == 0: nlayer = QgsVectorLayer(save_as, name, "ogr") if not nlayer.dataProvider().isValid(): return None if not nlayer.hasGeometryType(): return None # force CRS nlayer.setCrs(dest_crs) # copy layer style layer_style = self.get_layer_style(layer) self.set_layer_style(nlayer, layer_style) return nlayer else: raise RuntimeError(error) return None
def testVectorLayerUtilsUniqueWithProviderDefault(self): vl = QgsVectorLayer('%s table="qgis_test"."someData" sql=' % (self.dbconn), "someData", "postgres") default_clause = "nextval('qgis_test.\"someData_pk_seq\"'::regclass)" self.assertEqual(vl.dataProvider().defaultValueClause(0), default_clause) self.assertTrue(QgsVectorLayerUtils.valueExists(vl, 0, 4)) vl.startEditing() f = QgsFeature(vl.fields()) f.setAttribute(0, default_clause) self.assertTrue(vl.addFeatures([f])) self.assertFalse(QgsVectorLayerUtils.valueExists(vl, 0, default_clause))
def processAlgorithm(self, parameters, context, feedback): pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context) minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context) crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context) bbox = self.parameterAsExtent(parameters, self.EXTENT, context, crs) extent = QgsGeometry().fromRect(bbox) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, crs) if sink is None: raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT)) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount if pointCount else 1 index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: if feedback.isCanceled(): break rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() p = QgsPointXY(rx, ry) geom = QgsGeometry.fromPointXY(p) if geom.within(extent) and \ vector.checkMinDistance(p, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) index.addFeature(f) points[nPoints] = p nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: feedback.pushInfo(self.tr('Could not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress): extent = str(self.getParameterValue(self.EXTENT)).split(",") spacing = float(self.getParameterValue(self.SPACING)) inset = float(self.getParameterValue(self.INSET)) randomize = self.getParameterValue(self.RANDOMIZE) isSpacing = self.getParameterValue(self.IS_SPACING) extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) fields = QgsFields() fields.append(QgsField("id", QVariant.Int, "", 10, 0)) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPoint, mapCRS) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.00 / (area / pSpacing) y = extent.yMaximum() - inset while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if randomize: geom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)), ) ) else: geom = QgsGeometry().fromPoint(QgsPoint(x, y)) if geom.intersects(extent): f.setAttribute("id", count) f.setGeometry(geom) writer.addFeature(f) x += pSpacing count += 1 progress.setPercentage(int(count * total)) y = y - pSpacing del writer
def processAlgorithm(self, progress): pointCount = int(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) extent = unicode(self.getParameterValue(self.EXTENT)).split(',') xMin = float(extent[0]) xMax = float(extent[1]) yMin = float(extent[2]) yMax = float(extent[3]) extent = QgsGeometry().fromRect( QgsRectangle(xMin, yMin, xMax, yMax)) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QGis.WKBPoint, mapCRS) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount if pointCount > 0 else 1 index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = xMin + (xMax - xMin) * random.random() ry = yMin + (yMax - yMin) * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if geom.within(extent) and \ vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 progress.setPercentage(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog(ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) del writer
def processAlgorithm(self, parameters, context, feedback): layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.VECTOR), context) pointCount = int(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) bbox = layer.extent() idxLayer = QgsProcessingUtils.createSpatialIndex(layer, context) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() pnt = QgsPointXY(rx, ry) geom = QgsGeometry.fromPoint(pnt) ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox()) if len(ids) > 0 and \ vector.checkMinDistance(pnt, index, minDistance, points): request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([]) for f in layer.getFeatures(request): tmpGeom = f.geometry() if geom.within(tmpGeom): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: QgsMessageLog.logMessage(self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO) del writer
def applySave(self): if not self.editLayer.isEditable(): self.editLayer.startEditing() layer = self.editLayer layer.beginEditCommand("Funderingsgegevens") try: if (self.editFeature == None): idx = layer.pendingFields().indexFromName("id") nextId = layer.maximumValue(idx) feat = QgsFeature() feat.setFields(layer.pendingFields(), True) feat.setAttribute(layer.fieldNameIndex( "pand_id" ), self.pandidLabel.text()) feat.setAttribute(layer.fieldNameIndex( "id" ), nextId + 1) layer.addFeature(feat, False) self.editFeature = feat fid = self.editFeature.id() layer.changeAttributeValue(fid, layer.fieldNameIndex( "pand_id" ), self.idText.text()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "bezit" ), self.bezitCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "onderzocht" ), self.onderzochtCheckBox.isChecked()) if (self.onderzochtCheckBox.isChecked()): layer.changeAttributeValue(fid, layer.fieldNameIndex( "onderzocht_jaar" ), self.onderzochtJaarSpinBox.value()) else: layer.changeAttributeValue(fid, layer.fieldNameIndex( "onderzocht_jaar" ), None) layer.changeAttributeValue(fid, layer.fieldNameIndex( "kwaliteitsklasse" ), self.kwaliteitsklasseCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "hersteld" ), self.hersteldCheckBox.isChecked()) if (self.hersteldCheckBox.isChecked()): layer.changeAttributeValue(fid, layer.fieldNameIndex( "hersteld_jaar" ), self.hersteldJaarSpinBox.value()) else: layer.changeAttributeValue(fid, layer.fieldNameIndex( "hersteld_jaar" ), None) layer.changeAttributeValue(fid, layer.fieldNameIndex( "project" ), self.projectCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "richtlijn" ), self.richtlijnCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "funderingtype" ), self.typefundCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "paallengte" ), self.paallengteSpinBox.value()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "houtsoort" ), self.houtsoortCombo.currentText()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "dekking" ), self.dekkingSpinBox.value()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "droogstand" ), self.droogstandCheckBox.isChecked()) layer.changeAttributeValue(fid, layer.fieldNameIndex( "opmerking" ), self.opmerkingText.toPlainText()) except Exception, e: raise e layer.destroyEditCommand() self.iface.messageBar().pushMessage("Funderingsherstel", "Er is wat misgegaan tijdens het opslaan van dit BAG object!", level=QgsMessageBar.CRITICAL)
def testFieldGroupMultiLayer(self): # create a layer states = QgsVectorLayer("Point?crs=epsg:4326&field=country:string(20)&field=state:string(20)", "points", "memory") attributes = [ ['Australia', 'QLD'], ['NZ', 'state1'], ['Australia', 'VIC'], ['NZ', 'state2'], ['PNG', 'state3'], ['Australia', 'NSW'] ] pr = states.dataProvider() for a in attributes: f = QgsFeature() f.initAttributes(2) f.setAttribute(0, a[0]) f.setAttribute(1, a[1]) self.assertTrue(pr.addFeature(f)) places = QgsVectorLayer("Point?crs=epsg:4326&field=state:string(20)&field=town:string(20)", "points", "memory") attributes = [ ['QLD', 'Brisbane'], ['QLD', 'Emerald'], ['state1', 'town1'], ['VIC', 'Melbourne'], ['state1', 'town2'], ['QLD', 'Beerburrum'], ['VIC', 'Geelong'], ['state3', 'town1'] ] pr = places.dataProvider() for a in attributes: f = QgsFeature() f.initAttributes(2) f.setAttribute(0, a[0]) f.setAttribute(1, a[1]) self.assertTrue(pr.addFeature(f)) p = QgsProject() r = QgsReport(p) # add a child child1 = QgsReportSectionFieldGroup() child1_body = QgsLayout(p) child1.setLayer(states) child1.setBody(child1_body) child1.setBodyEnabled(True) child1.setField('country') r.appendChild(child1) self.assertTrue(r.beginRender()) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child1_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3']) self.assertFalse(r.next()) # another group # remove body from child1 child1.setBodyEnabled(False) child2 = QgsReportSectionFieldGroup() child2_body = QgsLayout(p) child2.setLayer(states) child2.setBody(child2_body) child2.setBodyEnabled(True) child2.setField('state') child1.appendChild(child2) self.assertTrue(r.beginRender()) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3']) self.assertFalse(r.next()) # another group child3 = QgsReportSectionFieldGroup() child3_body = QgsLayout(p) child3.setLayer(places) child3.setBody(child3_body) child3.setBodyEnabled(True) child3.setField('town') child3.setSortAscending(False) child2.appendChild(child3) self.assertTrue(r.beginRender()) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Brisbane']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1']) self.assertFalse(r.next()) # add headers/footers child3_header = QgsLayout(p) child3.setHeader(child3_header) child3.setHeaderEnabled(True) child3_footer = QgsLayout(p) child3.setFooter(child3_footer) child3.setFooterEnabled(True) self.assertTrue(r.beginRender()) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_header) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Brisbane']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_footer) self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_header) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_footer) self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_header) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_footer) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child2_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_header) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_body) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1']) self.assertTrue(r.next()) self.assertEqual(r.layout(), child3_footer) self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1']) self.assertFalse(r.next())
def replaceExpressionText(self, params: Dict[str, str], response: QgsServerResponse, project: QgsProject) -> None: """ Replace expression texts against layer or features In parameters: LAYER=wms-layer-name STRING=A string with expression between [% and %] or STRINGS=["first string with expression", "second string with expression"] or STRINGS={"key1": "first string with expression", "key2": "second string with expression"} // optionals FEATURE={"type": "Feature", "geometry": {}, "properties": {}} or FEATURES=[{"type": "Feature", "geometry": {}, "properties": {}}, {"type": "Feature", "geometry": {}, "properties": {}}] FORM_SCOPE=boolean to add formScope based on provided features """ layername = params.get('LAYER', '') if not layername: raise ExpressionServiceError( "Bad request error", "Invalid 'ReplaceExpressionText' REQUEST: LAYER parameter is mandatory", 400) # get layer layer = findVectorLayer(layername, project) # layer not found if not layer: raise ExpressionServiceError( "Bad request error", "Invalid LAYER parameter for 'ReplaceExpressionText': {} provided" .format(layername), 400) # get strings strings = params.get('STRINGS', '') if not strings: the_string = params.get('STRING', '') if not the_string: raise ExpressionServiceError( "Bad request error", "Invalid 'ReplaceExpressionText' REQUEST: STRING or STRINGS parameter is mandatory", 400) strings = '["{}"]'.format(the_string) # try to load expressions list or dict str_json = None try: str_json = json.loads(strings) except Exception: QgsMessageLog.logMessage( "JSON loads strings '{}' exception:\n{}".format( strings, traceback.format_exc()), "lizmap", Qgis.Critical) raise ExpressionServiceError( "Bad request error", "Invalid 'ReplaceExpressionText' REQUEST: STRINGS '{}' are not well formed" .format(strings), 400) # get features features = params.get('FEATURES', '') if not features: feature = params.get('FEATURE', '') if feature: features = '[' + feature + ']' # create expression context exp_context = QgsExpressionContext() exp_context.appendScope(QgsExpressionContextUtils.globalScope()) exp_context.appendScope( QgsExpressionContextUtils.projectScope(project)) exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer)) # create distance area context da = QgsDistanceArea() da.setSourceCrs(layer.crs(), project.transformContext()) da.setEllipsoid(project.ellipsoid()) # organized strings str_map = {} str_items = [] if isinstance(str_json, list): str_items = enumerate(str_json) elif isinstance(str_json, dict): str_items = str_json.items() for k, s in str_items: str_map[k] = s # create the body body = { 'status': 'success', 'results': [], 'errors': [], 'features': 0 } # without features just replace expression string with layer context if not features: result = {} for k, s in str_map.items(): value = QgsExpression.replaceExpressionText(s, exp_context, da) result[k] = json.loads(QgsJsonUtils.encodeValue(value)) body['results'].append(result) write_json_response(body, response) return # Check features try: geojson = json.loads(features) except Exception: QgsMessageLog.logMessage( "JSON loads features '{}' exception:\n{}".format( features, traceback.format_exc()), "lizmap", Qgis.Critical) raise ExpressionServiceError( "Bad request error", "Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed" .format(features), 400) if not geojson or not isinstance(geojson, list) or len(geojson) == 0: raise ExpressionServiceError( "Bad request error", "Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed" .format(features), 400) if ('type' not in geojson[0]) or geojson[0]['type'] != 'Feature': raise ExpressionServiceError( "Bad request error", "Invalid 'Evaluate' REQUEST: FEATURES '{}' are not well formed: type not defined or not Feature." .format(features), 400) # try to load features # read fields feature_fields = QgsJsonUtils.stringToFields( '{ "type": "FeatureCollection","features":' + features + '}', QTextCodec.codecForName("UTF-8")) # read features feature_list = QgsJsonUtils.stringToFeatureList( '{ "type": "FeatureCollection","features":' + features + '}', feature_fields, QTextCodec.codecForName("UTF-8")) # features not well formed if not feature_list: raise ExpressionServiceError( "Bad request error", "Invalid FEATURES for 'ReplaceExpressionText': not GeoJSON features array provided\n{}" .format(features), 400) # Extend layer fields with this provided in GeoJSON Features feat_fields = QgsFields(layer.fields()) feat_fields.extend(feature_fields) # form scope addFormScope = params.get('FORM_SCOPE', '').lower() in ['true', '1', 't'] # loop through provided features to replace expression strings for f in feature_list: # clone the features with all attributes # those defined in layer + fields from GeoJSON Features feat = QgsFeature(feat_fields) feat.setGeometry(f.geometry()) for field in f.fields(): fname = field.name() if feat_fields.indexOf(fname) != -1: feat.setAttribute(fname, f[fname]) # Add form scope to expression context if addFormScope: exp_context.appendScope( QgsExpressionContextUtils.formScope(feat)) exp_context.setFeature(feat) exp_context.setFields(feat.fields()) # replace expression strings with the new feature result = {} for k, s in str_map.items(): value = QgsExpression.replaceExpressionText(s, exp_context, da) result[k] = json.loads(QgsJsonUtils.encodeValue(value)) body['results'].append(result) write_json_response(body, response) return
def compute(self, bound, xOffset, yOffset, polygon): crs = None layer = ftools_utils.getMapLayerByName( unicode(self.inShape.currentText())) if self.angle.value() != 0.0: bound = self.initRotation(bound) if layer is None: crs = self.iface.mapCanvas().mapRenderer().destinationCrs() else: crs = layer.crs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) fieldCount = 1 if polygon: fields.append(QgsField("X_MIN", QVariant.Double)) fields.append(QgsField("X_MAX", QVariant.Double)) fields.append(QgsField("Y_MIN", QVariant.Double)) fields.append(QgsField("Y_MAX", QVariant.Double)) fieldCount = 5 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPolygon, crs) else: fields.append(QgsField("COORD", QVariant.Double)) fieldCount = 2 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBLineString, crs) outFeat = QgsFeature() outFeat.initAttributes(fieldCount) outFeat.setFields(fields) outGeom = QgsGeometry() idVar = 0 self.progressBar.setValue(0) if not polygon: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.10 y = bound.yMaximum() while y >= bound.yMinimum(): pt1 = QgsPoint(bound.xMinimum(), y) pt2 = QgsPoint(bound.xMaximum(), y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, y) writer.addFeature(outFeat) y = y - yOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 50) self.progressBar.setValue(prog) self.progressBar.setValue(50) # counters for progressbar - update every 5% count = 0 count_max = (bound.xMaximum() - bound.xMinimum()) / xOffset count_update = count_max * 0.10 x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, bound.yMaximum()) pt2 = QgsPoint(x, bound.yMinimum()) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) writer.addFeature(outFeat) x = x + xOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = 50 + int(count / count_max * 50) self.progressBar.setValue(prog) else: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.05 y = bound.yMaximum() while y >= bound.yMinimum(): x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, y) pt2 = QgsPoint(x + xOffset, y) pt3 = QgsPoint(x + xOffset, y - yOffset) pt4 = QgsPoint(x, y - yOffset) pt5 = QgsPoint(x, y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) self.rotatePoint(pt3) self.rotatePoint(pt4) self.rotatePoint(pt5) polygon = [[pt1, pt2, pt3, pt4, pt5]] outFeat.setGeometry(outGeom.fromPolygon(polygon)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) outFeat.setAttribute(2, x + xOffset) outFeat.setAttribute(3, y - yOffset) outFeat.setAttribute(4, y) writer.addFeature(outFeat) idVar = idVar + 1 x = x + xOffset y = y - yOffset count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 100) self.progressBar.setValue(100) del writer
def run(self, fid = 0): ################################## ###### PEGA A LAYER ATIVA ######## ################################## parametros = self.layer.source().split(" ") # recebe todos os parametros em uma lista ( senha, porta, password etc..) #################################### ###### INICIANDO CONEXÃO DB ######## #################################### # Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for. dbname = "" host = "" port = 0 user = "" password = "" for i in parametros: part = i.split("=") # Recebe os parametros guardados na própria Layer if "dbname" in part[0]: dbname = part[1].replace("'", "") elif "host" in part[0]: host = part[1].replace("'", "") elif "port" in part[0]: port = int(part[1].replace("'", "")) elif "user" in part[0]: user = part[1].replace("'", "") elif "password" in part[0]: password = part[1].split("|")[0].replace("'", "") print dbname, host, port, user, password # Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando.. if len(dbname) == 0 or len(host) == 0 or port == 0 or len(user) == 0 or len(password) == 0: self.iface.messageBar().pushMessage("Erro", u'Um dos parametros não foram devidamente recebidos!', level=QgsMessageBar.CRITICAL, duration=4) return #################################### #### SETA VALORES DE CONEXÃO DB #### #################################### connection = QSqlDatabase.addDatabase('QPSQL') connection.setHostName(host) connection.setPort(port) connection.setUserName(user) connection.setPassword(password) connection.setDatabaseName(dbname) if not connection.isOpen(): # Testa se a conexão esta recebendo os parametros adequadamente. if not connection.open(): print 'Error connecting to database!' self.iface.messageBar().pushMessage("Erro", u'Error connecting to database!', level=QgsMessageBar.CRITICAL, duration=4) print connection.lastError().text() return #################################### ###### CRIAÇÃO DE MEMORY LAYER ##### #################################### layerCrs = self.layer.crs().authid() # Passa o formato (epsg: numeros) flagsLayerName = self.layer.name() + "_flags" flagsLayerExists = False for l in QgsMapLayerRegistry.instance().mapLayers().values(): # Recebe todas as camadas que estão abertas if l.name() == flagsLayerName: # ao encontrar o nome pretendido.. self.flagsLayer = l # flagslayer vai receber o nome.. self.flagsLayerProvider = l.dataProvider() flagsLayerExists = True # se encontrado os parametros buscados, recebe True. break if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False. tempString = "Point?crs=" tempString += str(layerCrs) self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName, "memory") self.flagsLayerProvider = self.flagsLayer.dataProvider() self.flagsLayerProvider.addAttributes([QgsField("flagId", QVariant.String), QgsField("geomId", QVariant.String), QgsField("motivo", QVariant.String)]) self.flagsLayer.updateFields() if fid == 0: # Se for 0 então está iniciando e limpa, caso contrário não. self.flagsLayer.startEditing() ids = [feat.id() for feat in self.flagsLayer.getFeatures()] self.flagsLayer.deleteFeatures(ids) self.flagsLayer.commitChanges() lista_fid = [] # Iniciando lista for f in self.layer.getFeatures(): lista_fid.append(str(f.id())) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str". source = self.layer.source().split(" ") self.tableName = "" # Inicia vazio layerExistsInDB = False for i in source: if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for self.tableName = source[source.index(i)].split(".")[1] # Faz split em ponto e pega a segunda parte. self.tableName = self.tableName.replace('"', '') layerExistsInDB = True break if layerExistsInDB == False: self.iface.messageBar().pushMessage("Erro", u"Provedor da camada corrente não provem do banco de dados!", level=QgsMessageBar.CRITICAL, duration=4) return geomType = self.layer.geometryType() if geomType == QGis.Line: # Busca através do SQL sql = """ WITH result AS (SELECT points."{4}", points.anchor, (degrees ( ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2) )::decimal + 360) % 360 as angle FROM (SELECT ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-2)) as pt1, ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")-1)) as anchor, ST_PointN("{3}", generate_series(3, ST_NPoints("{3}"))) as pt2, linestrings."{4}" as "{4}" FROM (SELECT "{4}" as "{4}", (ST_Dump("{3}")).geom as "{3}" FROM only "{0}"."{1}" ) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points) select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format( self.tableSchema, self.tableName, self.angle, self.geometryColumn, self.keyColumn,",".join(lista_fid)) elif geomType == QGis.Polygon: sql = """ WITH result AS (SELECT points."{4}", points.anchor, (degrees ( ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2) )::decimal + 360) % 360 as angle FROM (SELECT ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1)) as pt1, ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1) % (ST_NPoints("{3}")-1)+1) as anchor, ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")) % (ST_NPoints("{3}")-1)+1) as pt2, linestrings."{4}" as "{4}" FROM (SELECT "{4}" as "{4}", (ST_Dump(ST_Boundary(ST_ForceRHR((ST_Dump("{3}")).geom)))).geom as "{3}" FROM only "{0}"."{1}" ) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points) select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format( self.tableSchema, self.tableName, self.angle, self.geometryColumn, self.keyColumn,",".join(lista_fid) ) query = QSqlQuery(sql) self.flagsLayer.startEditing() flagCount = fid # iniciando contador que será referência para os IDs da camada de memória. listaFeatures = [] while query.next(): id = query.value(0) local = query.value(1) angulo = query.value(2) flagId = str(flagCount) flagFeat = QgsFeature() flagFeat.setFields(self.flagsLayer.fields()) # passa quais atributos serão usados. flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro. flagFeat.setGeometry(flagGeom) flagFeat.initAttributes(3) flagFeat.setAttribute(0,flagId) # insere o id definido para a coluna 0 da layer de memória. flagFeat.setAttribute(1, id) # insere o id da geometria para a coluna 1 da layer de memória. flagFeat.setAttribute(2, u"Ângle-ExcededBound") listaFeatures.append(flagFeat) flagCount += 1 # incrementando o contador a cada iteração. self.flagsLayerProvider.addFeatures(listaFeatures) self.flagsLayer.commitChanges() # Aplica as alterações à camada. QgsMapLayerRegistry.instance().addMapLayer(self.flagsLayer) # Adicione a camada no mapa. return flagCount
def draw_circle(self, circle): polygon = [QgsPointXY(*point) for point in circle.to_polygon()] print(circle) print(polygon) print(type(polygon)) #gPnt = QgsGeometry.fromPointXY(QgsPointXY(1,1)) #gLine = QgsGeometry.fromPolyline([QgsPoint(1, 1), QgsPoint(2, 2)]) #gPolygon = QgsGeometry.fromPolygonXY([[QgsPointXY(1, 1), QgsPointXY(2, 2), QgsPointXY(2, 1)]]) #geometry = QgsGeometry.fromPolygon([polygon]) geometry = QgsGeometry.fromPolygonXY([polygon]) feature = QgsFeature() feature.setGeometry(geometry) feature.setFields(self.layer.fields()) destination = self.layer.crs() source = self.layer.crs() xform = self.crs_transform(source, destination) #print circle.center.x, circle.center.y #print(circle.center.x, circle.center.y) #line = [ # QgsPointXY(circle.center.x, circle.center.y), # QgsPointXY(circle.center.x + circle.radius, circle.center.y), #] line = [ QgsPointXY(circle.a, circle.b), QgsPointXY(circle.a + circle.r, circle.b), ] transformed = [ self.transform_point(xform, line[0]), self.transform_point(xform, line[1]), ] print("****",transformed) #new_line_geometry = QgsGeometry.fromPolyline( [ QgsGeometry.fromPointXY(transformed[0]), QgsGeometry.fromPointXY(transformed[1]) ] ) new_line_geometry = QgsGeometry.fromPolyline([QgsPoint(transformed[0][0], transformed[0][1]), QgsPoint(transformed[1][0], transformed[1][1])]) distance_area = self.get_distance_area(self.layer) actual_line_distance = distance_area.measureLength(new_line_geometry) # Translate circle center to units of degrees center_in_degrees = xform.transform(circle.a, circle.b) # circle_feature.id() is NULL for .shp file # and assigned automaticly for .gpkg # order is id, diameter, lon, lat feature.setAttribute('diameter',circle.diameter) feature.setAttribute('center_lon',circle.a) feature.setAttribute('center_lat',circle.b) self.layer.startEditing() self.layer.dataProvider().addFeatures([feature]) #self.layer.addFeature(feature, True) self.layer.commitChanges() # update layer's extent when new features have been added # because change of extent in provider is not propagated to the layer self.layer.updateExtents()
def createFlagFeature(self, attributes, geometry): feat = QgsFeature(self.getFlagFields()) for attrName in attributes: feat.setAttribute(attrName, attributes[attrName]) feat.setGeometry(geometry) return feat
def outattrPrep(self, dlg, lyr): feat = QgsFeature() species = '' production = '' most = QDateTime.currentDateTimeUtc() rn = dlg.tableWidget.rowCount() for i in range(rn): if i==0: species = dlg.tableWidget.item(i, 0).text() production = dlg.tableWidget.item(i, 1).text() else: species = species + ' | ' + dlg.tableWidget.item(i, 0).text() production = production + ' | ' + dlg.tableWidget.item(i, 1).text() flds = lyr.dataProvider().fields() feat.setFields(flds, True) feat.setAttribute(feat.fieldNameIndex('localid'), dlg.lineEdit_3_id.text())#mandatory feat.setAttribute(feat.fieldNameIndex('code'), dlg.lineEdit_5_code.text())#mandatory feat.setAttribute(feat.fieldNameIndex('largescale'), dlg.comboBox_4_large_scale.currentText()) feat.setAttribute(feat.fieldNameIndex('disease'), dlg.comboBox_2_disease.currentText())#mandatory feat.setAttribute(feat.fieldNameIndex('animalno'), dlg.lineEdit_6_num_animals.text())#mandatory feat.setAttribute(feat.fieldNameIndex('species'), species)#mandatory feat.setAttribute(feat.fieldNameIndex('production'), production) feat.setAttribute(feat.fieldNameIndex('year'), self.checkIntValue(dlg.lineEdit_4_year.text()))#mandatory feat.setAttribute(feat.fieldNameIndex('status'), dlg.comboBox_3_status.currentText())#mandatory feat.setAttribute(feat.fieldNameIndex('suspect'), self.dateCheck(dlg.dateEdit_dates_suspect.date())) feat.setAttribute(feat.fieldNameIndex('confirmation'), self.dateCheck(dlg.dateEdit_2_dates_confirmation.date())) feat.setAttribute(feat.fieldNameIndex('expiration'), self.dateCheck(dlg.dateEdit_3_dates_expiration.date())) feat.setAttribute(feat.fieldNameIndex('notes'), self.checkValue(dlg.textEdit_notes.toPlainText())) feat.setAttribute(feat.fieldNameIndex('hrid'), self.hashIDer(most,0)) feat.setAttribute(feat.fieldNameIndex('timestamp'), most.toString('dd/MM/yyyy hh:mm:ss')) return feat
def processAlgorithm(self, feedback): extent = str(self.getParameterValue(self.EXTENT)).split(',') spacing = float(self.getParameterValue(self.SPACING)) inset = float(self.getParameterValue(self.INSET)) randomize = self.getParameterValue(self.RANDOMIZE) isSpacing = self.getParameterValue(self.IS_SPACING) extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, mapCRS) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine( extent_geom.geometry()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if randomize: geom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPoint(QgsPoint(x, y)) if extent_engine.intersects(geom.geometry()): f.setAttribute('id', count) f.setGeometry(geom) writer.addFeature(f) x += pSpacing count += 1 feedback.setProgress(int(count * total)) y = y - pSpacing del writer
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) if source is None: raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context) minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context) bbox = source.sourceExtent() sourceIndex = QgsSpatialIndex(source, feedback) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, source.sourceCrs(), QgsFeatureSink.RegeneratePrimaryKey) if sink is None: raise QgsProcessingException( self.invalidSinkError(parameters, self.OUTPUT)) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount if pointCount else 1 index = QgsSpatialIndex() points = dict() random.seed() while nIterations < maxIterations and nPoints < pointCount: if feedback.isCanceled(): break rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() p = QgsPointXY(rx, ry) geom = QgsGeometry.fromPointXY(p) ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox()) if len(ids) > 0 and \ vector.checkMinDistance(p, index, minDistance, points): request = QgsFeatureRequest().setFilterFids( ids).setSubsetOfAttributes([]) for f in source.getFeatures(request): if feedback.isCanceled(): break tmpGeom = f.geometry() if geom.within(tmpGeom): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) index.addFeature(f) points[nPoints] = p nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: feedback.pushInfo( self.tr( 'Could not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) return {self.OUTPUT: dest_id}
def createFeatureA(self, feat, pos): toInsert = QgsFeature(self.dstLyr.fields()) toInsert.setAttribute('texto_edicao', feat.attribute('nome')) toInsert.setAttribute('estilo_fonte', 'Condensed Italic') toInsert.setAttribute('espacamento', 0) toInsert.setAttribute('carta_simbolizacao', self.getMapType()) labelSize = self.getLabelFontSizeA(feat) toInsert.setAttribute( 'tamanho_txt', labelSize if self.mapTypeSelector.currentText() == 'Carta' else 4.5) if self.productTypeSelector.currentText() == 'Topográfica': toInsert.setAttribute('cor', '#00a0df') elif self.productTypeSelector.currentText() == 'Ortoimagem': toInsert.setAttribute('cor', '#ffffff') toInsert.setAttribute('cor_buffer', '#00a0df') toInsert.setAttribute('tamanho_buffer', '1') toInsertGeom = self.getLabelGeometry(feat, pos, labelSize) toInsert.setGeometry(toInsertGeom) self.dstLyr.startEditing() self.dstLyr.addFeature(toInsert) self.dstLyr.triggerRepaint()
def legend_test(self): self.atlas_map.setAtlasDriven(True) self.atlas_map.setAtlasScalingMode(QgsLayoutItemMap.Auto) self.atlas_map.setAtlasMargin(0.10) # add a point layer ptLayer = QgsVectorLayer( "Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory") pr = ptLayer.dataProvider() f1 = QgsFeature(1) f1.initAttributes(2) f1.setAttribute(0, 1) f1.setAttribute(1, "Test label 1") f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954))) f2 = QgsFeature(2) f2.initAttributes(2) f2.setAttribute(0, 2) f2.setAttribute(1, "Test label 2") f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550))) pr.addFeatures([f1, f2]) # categorized symbology r = QgsCategorizedSymbolRenderer("attr", [ QgsRendererCategory( 1, QgsMarkerSymbol.createSimple({ "color": "255,0,0", 'outline_color': 'black' }), "red"), QgsRendererCategory( 2, QgsMarkerSymbol.createSimple({ "color": "0,0,255", 'outline_color': 'black' }), "blue") ]) ptLayer.setRenderer(r) QgsProject.instance().addMapLayer(ptLayer) # add the point layer to the map settings layers = self.layers layers = [ptLayer] + layers self.atlas_map.setLayers(layers) self.overview.setLayers(layers) # add a legend legend = QgsLayoutItemLegend(self.layout) legend.setTitle("Legend") legend.attemptMove(QgsLayoutPoint(200, 100)) # sets the legend filter parameter legend.setLinkedMap(self.atlas_map) legend.setLegendFilterOutAtlas(True) self.layout.addLayoutItem(legend) self.atlas.beginRender() self.atlas.seekTo(0) self.mLabel1.adjustSizeToText() checker = QgsLayoutChecker('atlas_legend', self.layout) myTestResult, myMessage = checker.testLayout() self.report += checker.report() self.assertTrue(myTestResult, myMessage) self.atlas.endRender() # restore state self.atlas_map.setLayers([layers[1]]) self.layout.removeLayoutItem(legend) QgsProject.instance().removeMapLayer(ptLayer.id())
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) strategy = self.parameterAsEnum(parameters, self.STRATEGY, context) minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context) expression = QgsExpression( self.parameterAsString(parameters, self.EXPRESSION, context)) if expression.hasParserError(): raise ProcessingException(expression.parserErrorString()) expressionContext = self.createExpressionContext(parameters, context) if not expression.prepare(expressionContext): raise ProcessingException( self.tr('Evaluation error: {0}').format( expression.evalErrorString())) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, source.sourceCrs()) da = QgsDistanceArea() da.setSourceCrs(source.sourceCrs()) da.setEllipsoid(context.project().ellipsoid()) total = 100.0 / source.featureCount() if source.featureCount() else 0 for current, f in enumerate(source.getFeatures()): if feedback.isCanceled(): break expressionContext.setFeature(f) value = expression.evaluate(expressionContext) if expression.hasEvalError(): feedback.pushInfo( self.tr('Evaluation error for feature ID {}: {}').format( f.id(), expression.evalErrorString())) continue fGeom = f.geometry() bbox = fGeom.boundingBox() if strategy == 0: pointCount = int(value) else: pointCount = int(round(value * da.measureArea(fGeom))) if pointCount == 0: feedback.pushInfo( "Skip feature {} as number of points for it is 0.") continue index = QgsSpatialIndex() points = dict() nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount if pointCount else 1 random.seed() while nIterations < maxIterations and nPoints < pointCount: if feedback.isCanceled(): break rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() p = QgsPointXY(rx, ry) geom = QgsGeometry.fromPointXY(p) if geom.within(fGeom) and \ vector.checkMinDistance(p, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) index.insertFeature(f) points[nPoints] = p nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: feedback.pushInfo( self.tr('Could not generate requested number of random ' 'points. Maximum number of attempts exceeded.')) feedback.setProgress(0) return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback): source = self.parameterAsSource(parameters, self.INPUT, context) pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context) minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, source.sourceCrs()) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 featureCount = source.featureCount() total = 100.0 / pointCount if pointCount else 1 index = QgsSpatialIndex() points = dict() da = QgsDistanceArea() da.setSourceCrs(source.sourceCrs()) da.setEllipsoid(context.project().ellipsoid()) request = QgsFeatureRequest() random.seed() while nIterations < maxIterations and nPoints < pointCount: if feedback.isCanceled(): break # pick random feature fid = random.randint(0, featureCount - 1) f = next( source.getFeatures( request.setFilterFid(fid).setSubsetOfAttributes([]))) fGeom = f.geometry() if fGeom.isMultipart(): lines = fGeom.asMultiPolyline() # pick random line lineId = random.randint(0, len(lines) - 1) vertices = lines[lineId] else: vertices = fGeom.asPolyline() # pick random segment if len(vertices) == 2: vid = 0 else: vid = random.randint(0, len(vertices) - 2) startPoint = vertices[vid] endPoint = vertices[vid + 1] length = da.measureLine(startPoint, endPoint) dist = length * random.random() if dist > minDistance: d = dist / (length - dist) rx = (startPoint.x() + d * endPoint.x()) / (1 + d) ry = (startPoint.y() + d * endPoint.y()) / (1 + d) # generate random point p = QgsPointXY(rx, ry) geom = QgsGeometry.fromPoint(p) if vector.checkMinDistance(p, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) index.insertFeature(f) points[nPoints] = p nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: feedback.pushInfo( self.tr( 'Could not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.VECTOR)) value = float(self.getParameterValue(self.VALUE)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) strategy = self.getParameterValue(self.STRATEGY) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QGis.WKBPoint, layer.dataProvider().crs()) da = QgsDistanceArea() features = vector.features(layer) for current, f in enumerate(features): fGeom = QgsGeometry(f.geometry()) bbox = fGeom.boundingBox() if strategy == 0: pointCount = int(value) else: pointCount = int(round(value * da.measure(fGeom))) index = QgsSpatialIndex() points = dict() nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if geom.within(fGeom) and \ vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 progress.setPercentage(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog( ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random ' 'points. Maximum number of attempts exceeded.')) progress.setPercentage(0) del writer
def processAlgorithm(self, parameters, context, feedback): spacing = self.parameterAsDouble(parameters, self.SPACING, context) inset = self.parameterAsDouble(parameters, self.INSET, context) randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context) isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context) crs = self.parameterAsCrs(parameters, self.CRS, context) extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, fields, QgsWkbTypes.Point, crs) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine( extent_geom.constGet()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if feedback.isCanceled(): break if randomize: geom = QgsGeometry().fromPointXY( QgsPointXY( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPointXY(QgsPointXY(x, y)) if extent_engine.intersects(geom.constGet()): f.setAttribute('id', count) f.setGeometry(geom) sink.addFeature(f, QgsFeatureSink.FastInsert) x += pSpacing count += 1 feedback.setProgress(int(count * total)) y = y - pSpacing return {self.OUTPUT: dest_id}
def testSpatialiteDefaultValues(self): """Test whether in spatialite table with default values like CURRENT_TIMESTAMP or (datetime('now','localtime')) they are respected. See GH #33383""" # Create the test table dbname = os.path.join(tempfile.gettempdir(), "test.sqlite") if os.path.exists(dbname): os.remove(dbname) con = spatialite_connect(dbname, isolation_level=None) cur = con.cursor() cur.execute("BEGIN") sql = "SELECT InitSpatialMetadata()" cur.execute(sql) # simple table with primary key sql = """ CREATE TABLE test_table_default_values ( id integer primary key autoincrement, comment TEXT, created_at_01 text DEFAULT (datetime('now','localtime')), created_at_02 text DEFAULT CURRENT_TIMESTAMP, anumber INTEGER DEFAULT 123, atext TEXT default 'My default' ) """ cur.execute(sql) cur.execute("COMMIT") con.close() vl = QgsVectorLayer(dbname + '|layername=test_table_default_values', 'test_table_default_values', 'ogr') self.assertTrue(vl.isValid()) # Save it for the test now = datetime.now() # Test default values dp = vl.dataProvider() # FIXME: should it be None? self.assertTrue(dp.defaultValue(0).isNull()) self.assertIsNone(dp.defaultValue(1)) # FIXME: This fails because there is no backend-side evaluation in this provider # self.assertTrue(dp.defaultValue(2).startswith(now.strftime('%Y-%m-%d'))) self.assertTrue( dp.defaultValue(3).startswith(now.strftime('%Y-%m-%d'))) self.assertEqual(dp.defaultValue(4), 123) self.assertEqual(dp.defaultValue(5), 'My default') self.assertEqual(dp.defaultValueClause(0), 'Autogenerate') self.assertEqual(dp.defaultValueClause(1), '') self.assertEqual(dp.defaultValueClause(2), "datetime('now','localtime')") self.assertEqual(dp.defaultValueClause(3), "CURRENT_TIMESTAMP") # FIXME: ogr provider simply returns values when asked for clauses # self.assertEqual(dp.defaultValueClause(4), '') # self.assertEqual(dp.defaultValueClause(5), '') feature = QgsFeature(vl.fields()) for idx in range(vl.fields().count()): default = vl.dataProvider().defaultValue(idx) if not default: feature.setAttribute(idx, 'A comment') else: feature.setAttribute(idx, default) self.assertTrue(vl.dataProvider().addFeature(feature)) del (vl) # Verify vl2 = QgsVectorLayer(dbname + '|layername=test_table_default_values', 'test_table_default_values', 'ogr') self.assertTrue(vl2.isValid()) feature = next(vl2.getFeatures()) self.assertEqual(feature.attribute(1), 'A comment') self.assertTrue( feature.attribute(2).startswith(now.strftime('%Y-%m-%d'))) self.assertTrue( feature.attribute(3).startswith(now.strftime('%Y-%m-%d'))) self.assertEqual(feature.attribute(4), 123) self.assertEqual(feature.attribute(5), 'My default')
def deleteFeatureRequest(featureRequest, layer, undoMessage='Delete features', log=False, logLayer=None, timestamp=None): ok = False if log and (not logLayer or not timestamp): return ok if not isWritable(layer) or (logLayer and not isWritable(logLayer)): return ok # Stash the current subset subset = layer.subsetString() if subset: layer.setSubsetString('') # Copy the requested features wasEditing = layer.isEditable() if (wasEditing or layer.startEditing()) and (logLayer is None or logLayer.isEditable() or logLayer.startEditing()): if wasEditing: layer.beginEditCommand(undoMessage) logFeature = None if log: if wasEditing: logLayer.beginEditCommand(undoMessage) ft = 0 for feature in layer.getFeatures(featureRequest): ft += 1 if log: logFeature = QgsFeature(logLayer.fields()) if feature.geometry(): logFeature.setGeometry(feature.geometry()) for field in layer.fields(): logFeature.setAttribute(field.name(), feature.attribute(field.name())) logFeature.setAttribute('event', 'delete') logFeature.setAttribute('timestamp', timestamp) ok = logLayer.addFeature(logFeature) and layer.deleteFeature( feature.id()) else: ok = layer.deleteFeature(feature.id()) if not ok: break # If was already in edit mode, end or destroy the editing buffer if wasEditing: if ok: if log: logLayer.endEditCommand() layer.endEditCommand() else: if log: logLayer.destroyEditCommand() layer.destroyEditCommand() # If was already in edit mode, is up to caller to commit the log and layer if not wasEditing: if ok and log: ok = logLayer.commitChanges() if ok: ok = layer.commitChanges() if not ok: if log: try: logLayer.rollBack() except: utils.logMessage('TODO: Rollback on log layer???') layer.rollBack() if ft == 0: ok = True # Restore the previous subset if subset: layer.setSubsetString(subset) return ok
def __ok(self, withVertex, withPoint): """ To apply the interpolation :param withVertex: if we want a new interpolated vertex :param withPoint: if we want a new interpolated point """ line_v2, curved = GeometryV2.asLineV2( self.__selectedFeature.geometry(), self.__iface) vertex_v2 = QgsPointV2() vertex_id = QgsVertexId() line_v2.closestSegment(QgsPointV2(self.__mapPoint), vertex_v2, vertex_id, 0) x0 = line_v2.xAt(vertex_id.vertex - 1) y0 = line_v2.yAt(vertex_id.vertex - 1) d0 = Finder.sqrDistForCoords(x0, vertex_v2.x(), y0, vertex_v2.y()) x1 = line_v2.xAt(vertex_id.vertex) y1 = line_v2.yAt(vertex_id.vertex) d1 = Finder.sqrDistForCoords(x1, vertex_v2.x(), y1, vertex_v2.y()) z0 = line_v2.zAt(vertex_id.vertex - 1) z1 = line_v2.zAt(vertex_id.vertex) z = round(old_div((d0 * z1 + d1 * z0), (d0 + d1)), 3) vertex_v2.addZValue(z) if withPoint: pt_feat = QgsFeature(self.__layer.pendingFields()) pt_feat.setGeometry(QgsGeometry(vertex_v2)) primaryKey = QgsDataSourceURI(self.__layer.source()).keyColumn() for i in range(len(self.__layer.pendingFields())): if self.__layer.pendingFields().field(i).name() != primaryKey: e = QgsExpression(self.__layer.defaultValueExpression(i)) default = e.evaluate(pt_feat) pt_feat.setAttribute(i, default) if self.__layer.editFormConfig().suppress( ) == QgsEditFormConfig.SuppressOn: self.__layer.addFeature(pt_feat) else: self.__iface.openFeatureForm(self.__layer, pt_feat) if withVertex: line_v2.insertVertex(vertex_id, vertex_v2) self.__lastLayer.changeGeometry(self.__selectedFeature.id(), QgsGeometry(line_v2)) found_features = self.__lastLayer.selectedFeatures() if len(found_features) > 0: if len(found_features) > 1: self.__iface.messageBar().pushMessage( QCoreApplication.translate("VDLTools", "One feature at a time"), level=QgsMessageBar.INFO) else: self.__selectedFeature = found_features[0] else: self.__iface.messageBar().pushMessage( QCoreApplication.translate("VDLTools", "No more feature selected"), level=QgsMessageBar.INFO) self.__iface.mapCanvas().refresh() self.__done() self.__findVertex = True
def createFeature(self, feat): toInsert = QgsFeature(self.dstLyr.fields()) toInsert.setAttribute('texto_edicao', feat.attribute('nome').upper()) toInsert.setAttribute('estilo_fonte', 'Condensed Italic') toInsert.setAttribute('justificativa_txt', 2) toInsert.setAttribute('espacamento', 0) toInsert.setAttribute('cor', '#00a0df') toInsert.setAttribute('carta_simbolizacao', self.getMapType()) toInsert.setAttribute( 'tamanho_txt', self.getLabelSize(feat) if self.mapTypeSelector.currentText() == 'Carta' else 4.5) if self.productTypeSelector.currentText() == 'Ortoimagem': toInsert.setAttribute('cor_buffer', '#00a0df') toInsert.setAttribute('tamanho_buffer', '1') toInsertGeom = QgsGeometry.fromPointXY(self.currPos) toInsert.setGeometry(toInsertGeom) self.dstLyr.startEditing() self.dstLyr.addFeature(toInsert) self.mapCanvas.refresh()
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.VECTOR)) pointCount = float(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QGis.WKBPoint, layer.dataProvider().crs()) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 featureCount = layer.featureCount() total = 100.0 / pointCount index = QgsSpatialIndex() points = dict() da = QgsDistanceArea() request = QgsFeatureRequest() random.seed() while nIterations < maxIterations and nPoints < pointCount: # pick random feature fid = random.randint(0, featureCount - 1) f = layer.getFeatures(request.setFilterFid(fid)).next() fGeom = QgsGeometry(f.geometry()) if fGeom.isMultipart(): lines = fGeom.asMultiPolyline() # pick random line lineId = random.randint(0, len(lines) - 1) vertices = lines[lineId] else: vertices = fGeom.asPolyline() # pick random segment if len(vertices) == 2: vid = 0 else: vid = random.randint(0, len(vertices) - 2) startPoint = vertices[vid] endPoint = vertices[vid + 1] length = da.measureLine(startPoint, endPoint) dist = length * random.random() if dist > minDistance: d = dist / (length - dist) rx = (startPoint.x() + d * endPoint.x()) / (1 + d) ry = (startPoint.y() + d * endPoint.y()) / (1 + d) # generate random point pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 progress.setPercentage(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: ProcessingLog.addToLog(ProcessingLog.LOG_INFO, self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.')) del writer
def processAlgorithm(self, parameters, context, model_feedback): feedback = QgsProcessingMultiStepFeedback(2, model_feedback) server_name = self.connection_options[self.parameterAsInt(parameters, self.SERVER_NAME, context)] graph_name = self.parameterAsString(parameters, self.GRAPH_NAME, context) graph_version = self.parameterAsString(parameters, self.GRAPH_VERSION, context) save_json_file = self.parameterAsBoolean(parameters, self.SAVE_JSON_FILE, context) json_file = self.parameterAsFileOutput(parameters, self.OUTPUT_JSON, context) # Connect to Graphium feedback.pushInfo("Connect to Graphium server '" + server_name + "' ...") graphium_data = GraphiumGraphDataApi(feedback) graphium_management = GraphiumGraphManagementApi(feedback) selected_connection = self.connection_manager.select_graphium_server(server_name) if selected_connection is None: feedback.reportError('Cannot select connection to Graphium', True) return {self.OUTPUT_SEGMENTS: None} if graphium_management.connect(selected_connection) is False: feedback.reportError('Cannot connect to Graphium', True) return {self.OUTPUT_SEGMENTS: None} if graphium_data.connect(selected_connection) is False: feedback.reportError('Cannot connect to Graphium', True) return {self.OUTPUT_SEGMENTS: None} metadata = graphium_management.get_graph_version_metadata(graph_name, graph_version) if not metadata['type']: feedback.reportError('Cannot correctly retrieve graph metadata', True) return {self.OUTPUT_SEGMENTS: None} feedback.pushInfo("Start downloading task on Graphium server '" + server_name + "' ...") response = graphium_data.export_graph(graph_name, graph_version, metadata.get('type') == 'hdwaysegment') if save_json_file: feedback.pushInfo("Write graph to JSON file...") with open(json_file, 'w') as output_file: output_file.write(json.dumps(response)) feedback.setCurrentStep(1) if 'graphVersionMetadata' in response: # if response['graphVersionMetadata']['segmentsCount'] == 0: # feedback.reportError('No segments available', False) # return {self.OUTPUT_SEGMENT_COUNT: 0} # elif response['graphVersionMetadata']['state'] == 'DELETED': if response['graphVersionMetadata']['state'] == 'DELETED': feedback.reportError('Graph version has been deleted', False) return {self.OUTPUT_SEGMENT_COUNT: 0} elif 'error' in response: if 'msg' in response['error']: feedback.reportError(response['error']['msg'], True) return {self.OUTPUT_SEGMENT_COUNT: 0} else: feedback.reportError('Unknown error', True) return {self.OUTPUT_SEGMENT_COUNT: 0} feedback.pushInfo("Prepare result vector layer ...") vector_layer = self.prepare_vector_layer('segments_' + graph_name + '_' + graph_version, response['graphVersionMetadata']['type']) (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT_SEGMENTS, context, vector_layer.fields(), QgsWkbTypes.LineString, vector_layer.sourceCrs()) total = 100.0 / len(response[response['graphVersionMetadata']['type']]) for current, segment in enumerate(response[response['graphVersionMetadata']['type']]): if feedback.isCanceled(): break feature = QgsFeature() feature.setGeometry(QgsGeometry.fromWkt(segment['geometry'])) feature.setFields(vector_layer.fields(), True) for attribute_key in segment: try: if attribute_key == 'tags' or attribute_key == 'connection': feature.setAttribute(attribute_key, json.dumps(segment[attribute_key])) else: feature.setAttribute(attribute_key, segment[attribute_key]) except KeyError: pass sink.addFeature(feature, QgsFeatureSink.FastInsert) feedback.setProgress(int(current * total)) feedback.pushInfo("Finished preparing vector layer " + dest_id) return {self.OUTPUT_SEGMENTS: dest_id, self.OUTPUT_JSON: json_file if save_json_file else None, self.OUTPUT_SEGMENT_COUNT: response['graphVersionMetadata']['segmentsCount'] }
def processAlgorithm(self, context, feedback): layer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.VECTOR), context) fieldName = self.getParameterValue(self.FIELD) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) strategy = self.getParameterValue(self.STRATEGY) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, layer.crs(), context) da = QgsDistanceArea() features = QgsProcessingUtils.getFeatures(layer, context) for current, f in enumerate(features): fGeom = f.geometry() bbox = fGeom.boundingBox() if strategy == 0: pointCount = int(f[fieldName]) else: pointCount = int(round(f[fieldName] * da.measureArea(fGeom))) if pointCount == 0: feedback.pushInfo( "Skip feature {} as number of points for it is 0.") continue index = QgsSpatialIndex() points = dict() nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 total = 100.0 / pointCount random.seed() while nIterations < maxIterations and nPoints < pointCount: rx = bbox.xMinimum() + bbox.width() * random.random() ry = bbox.yMinimum() + bbox.height() * random.random() pnt = QgsPoint(rx, ry) geom = QgsGeometry.fromPoint(pnt) if geom.within(fGeom) and \ vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: QgsMessageLog.logMessage( self.tr('Can not generate requested number of random ' 'points. Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO) feedback.setProgress(0) del writer
def generate_sampling_points(self, pixel_values, number_of_samples, min_distance, neighbor_aggregation, attempts_by_sampling, progress_bar, random_seed): """Some code base from (by Alexander Bruy): https://github.com/qgis/QGIS/blob/release-2_18/python/plugins/processing/algs/qgis/RandomPointsExtent.py """ self.pixel_values = pixel_values self.number_of_samples = number_of_samples # desired self.total_of_samples = None # total generated self.min_distance = min_distance self.neighbor_aggregation = neighbor_aggregation progress_bar.setValue(0) # init progress bar self.ThematicR_boundaries = QgsGeometry().fromRect( self.ThematicR.extent()) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) thematic_CRS = self.ThematicR.qgs_layer.crs() file_format = \ "GPKG" if self.output_file.endswith(".gpkg") else "ESRI Shapefile" if self.output_file.endswith(".shp") else None writer = QgsVectorFileWriter(self.output_file, "System", fields, QgsWkbTypes.Point, thematic_CRS, file_format) if self.sampling_type == "simple": total_of_samples = self.number_of_samples if self.sampling_type == "stratified": total_of_samples = sum(self.number_of_samples) self.samples_in_categories = [0] * len( self.number_of_samples) # total generated by categories nPoints = 0 nIterations = 0 self.index = QgsSpatialIndex() if attempts_by_sampling: maxIterations = total_of_samples * attempts_by_sampling else: maxIterations = float('Inf') # init the random sampling seed self.random_seed = random_seed random.seed(self.random_seed) points_generated = [] while nIterations < maxIterations and nPoints < total_of_samples: random_sampling_point = RandomPoint(self.ThematicR.extent()) # checks to the sampling point, else discard and continue if not self.check_sampling_point(random_sampling_point): nIterations += 1 continue if self.sampling_type == "stratified": self.samples_in_categories[ random_sampling_point.index_pixel_value] += 1 points_generated.append(random_sampling_point) # it requires tmp save the point to check min distance for the next sample f = QgsFeature(nPoints) f.setGeometry(random_sampling_point.QgsGeom) self.index.insertFeature(f) self.points[nPoints] = random_sampling_point.QgsPnt nPoints += 1 nIterations += 1 # update progress bar progress_bar.setValue(int(nPoints)) # guarantee the random order for the classification random.shuffle(points_generated) self.points = dict() # restart for num_point, point_generated in enumerate(points_generated): # random sampling point passed the checks, save it f = QgsFeature() f.initAttributes(1) f.setFields(fields) f.setAttribute('id', num_point + 1) f.setGeometry(point_generated.QgsGeom) writer.addFeature(f) self.points[num_point] = point_generated.QgsPnt # save the total point generated self.total_of_samples = len(points_generated) del writer, self.index
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 = NewRaptorDialog() self.dlg.cmbSpecies.currentTextChanged.connect( self.evt_cmbSpecies_changed) mc = self.iface.mapCanvas() self.dlg.spbLatitude.setValue(mc.center().y()) self.dlg.spbLongitude.setValue(mc.center().x()) self.dlg.dteLast.setDate(QDate.currentDate()) map_layers = [] for lyr in mc.layers(): map_layers.append(lyr.name()) missing_layers = [] if not "Raptor Nests" in map_layers: missing_layers.append("Raptor Nests") if not "Raptor Buffer" in map_layers: missing_layers.append("Raptor Buffer") if not "Linear Buffer" in map_layers: missing_layers.append("Linear Buffer") if missing_layers: msg = "The following layers are misisng from this project\n" for lyr in missing_layers: msg += "\n{}".format(lyr) QMessageBox.critical(self.dlg, "Missing layers", msg) return # show the dialog self.dlg.show() # 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. lyrNests = QgsProject.instance().mapLayersByName("Raptor Nests")[0] lyrBuffer = QgsProject.instance().mapLayersByName( "Raptor Buffer")[0] lyrLinear = QgsProject.instance().mapLayersByName( "Linear Buffer")[0] idxNestID = lyrNests.fields().indexOf("Nest_ID") valNestID = lyrNests.maximumValue(idxNestID) + 1 valLat = self.dlg.spbLatitude.value() valLng = self.dlg.spbLongitude.value() valSpecies = self.dlg.cmbSpecies.currentText() valBuffer = self.dlg.spbBuffer.value() valStatus = self.dlg.cmbStatus.currentText() valLast = self.dlg.dteLast.date() QMessageBox.information( self.dlg, "Message", "New Nest ID: {}\n\nLatitude: {}\nLongitude: {}\nSpecies: {}\nBuffer: {}\nStatus: {}\nLast Survey: {}" .format(valNestID, valLat, valLng, valSpecies, valBuffer, valStatus, valLast)) ftrNest = QgsFeature(lyrNests.fields()) ftrNest.setAttribute("lat_y_dd", valLat) ftrNest.setAttribute("long_x_dd", valLng) ftrNest.setAttribute("recentspec", valSpecies) ftrNest.setAttribute("buf_dist", valBuffer) ftrNest.setAttribute("recentstat", valStatus) ftrNest.setAttribute("lastsurvey", valLast) ftrNest.setAttribute("Nest_ID", valNestID) geom = QgsGeometry(QgsPoint(valLng, valLat)) ftrNest.setGeometry(geom) pr = lyrNests.dataProvider() pr.addFeatures([ftrNest]) lyrNests.reload() pr = lyrBuffer.dataProvider() buffer = geom.buffer(valBuffer, 10) ftrNest.setGeometry(buffer) pr.addFeatures([ftrNest]) lyrBuffer.reload() dlgTable = DlgTable() dlgTable.setWindowTitle( "Impacts Table for Nest {}".format(valNestID)) # Find linear projects that will be impacted and report them in the table bb = buffer.boundingBox() linears = lyrLinear.getFeatures(bb) for linear in linears: valID = linear.attribute("Project") valType = linear.attribute("type") valDistance = linear.geometry().distance(geom) if valDistance < valBuffer: # Populate table with linear data row = dlgTable.tblImpacts.rowCount() dlgTable.tblImpacts.insertRow(row) dlgTable.tblImpacts.setItem(row, 0, QTableWidgetItem(str(valID))) dlgTable.tblImpacts.setItem(row, 1, QTableWidgetItem(valType)) twi = QTableWidgetItem("{:4.5f}".format(valDistance)) twi.setTextAlignment(QtCore.Qt.AlignRight) dlgTable.tblImpacts.setItem(row, 2, twi) dlgTable.tblImpacts.sortItems(2) dlgTable.show() dlgTable.exec_() else: QMessageBox.information(self.dlg, "Message", "Should only run if cancelled")
def compute(self, inName, weightField="", times=1, uniqueField=""): vlayer = ftools_utils.getVectorLayerByName(inName) provider = vlayer.dataProvider() weightIndex = provider.fieldNameIndex(weightField) uniqueIndex = provider.fieldNameIndex(uniqueField) feat = QgsFeature() sRs = provider.crs() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return if uniqueIndex != -1: uniqueValues = ftools_utils.getUniqueValues( provider, int(uniqueIndex)) single = False else: uniqueValues = [1] single = True if self.function == 2: fieldList = QgsFields() fieldList.append(QgsField("STD_DIST", QVariant.Double)) fieldList.append(QgsField("UID", QVariant.String)) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPolygon, sRs) else: fieldList = QgsFields() fieldList.append(QgsField("MEAN_X", QVariant.Double)) fieldList.append(QgsField("MEAN_Y", QVariant.Double)) fieldList.append(QgsField("UID", QVariant.String)) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPoint, sRs) outfeat = QgsFeature() outfeat.setFields(fieldList) points = [] weights = [] nFeat = provider.featureCount() * len(uniqueValues) nElement = 0 self.progressBar.setValue(0) self.progressBar.setRange(0, nFeat) for j in uniqueValues: cx = 0.00 cy = 0.00 points = [] weights = [] fit = provider.getFeatures() while fit.nextFeature(feat): nElement += 1 self.progressBar.setValue(nElement) if single: check = unicode(j).strip() else: check = unicode(feat[uniqueIndex]).strip() if check == unicode(j).strip(): cx = 0.00 cy = 0.00 if weightIndex == -1: weight = 1.00 else: weight = float(feat[weightIndex]) geom = QgsGeometry(feat.geometry()) geom = ftools_utils.extractPoints(geom) for i in geom: cx += i.x() cy += i.y() points.append(QgsPoint((cx / len(geom)), (cy / len(geom)))) weights.append(weight) sumWeight = sum(weights) cx = 0.00 cy = 0.00 item = 0 for item, i in enumerate(points): cx += i.x() * weights[item] cy += i.y() * weights[item] cx = cx / sumWeight cy = cy / sumWeight meanPoint = QgsPoint(cx, cy) if self.function == 2: values = [] md = 0.00 sd = 0.00 dist = QgsDistanceArea() item = 0 for i in points: tempDist = dist.measureLine(i, meanPoint) values.append(tempDist) item += 1 md += tempDist md = md / item for i in values: sd += (i - md) * (i - md) sd = sqrt(sd / item) outfeat.setGeometry( QgsGeometry.fromPoint(meanPoint).buffer(sd * times, 10)) outfeat.setAttribute(0, sd) outfeat.setAttribute(1, j) else: outfeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outfeat.setAttribute(0, cx) outfeat.setAttribute(1, cy) outfeat.setAttribute(2, j) writer.addFeature(outfeat) if single: break del writer
def legend_test(self): self.mAtlasMap.setAtlasDriven(True) self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto) self.mAtlasMap.setAtlasMargin(0.10) # add a point layer ptLayer = QgsVectorLayer( "Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory") pr = ptLayer.dataProvider() f1 = QgsFeature(1) f1.initAttributes(2) f1.setAttribute(0, 1) f1.setAttribute(1, "Test label 1") f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954))) f2 = QgsFeature(2) f2.initAttributes(2) f2.setAttribute(0, 2) f2.setAttribute(1, "Test label 2") f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550))) pr.addFeatures([f1, f2]) # categorized symbology r = QgsCategorizedSymbolRenderer("attr", [ QgsRendererCategory( 1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"), QgsRendererCategory( 2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue") ]) ptLayer.setRenderer(r) QgsProject.instance().addMapLayer(ptLayer) # add the point layer to the map settings layers = self.layers layers = [ptLayer] + layers self.mAtlasMap.setLayers(layers) self.mOverview.setLayers(layers) # add a legend legend = QgsComposerLegend(self.mComposition) legend.moveBy(200, 100) # sets the legend filter parameter legend.setComposerMap(self.mAtlasMap) legend.setLegendFilterOutAtlas(True) self.mComposition.addComposerLegend(legend) self.mAtlas.beginRender() self.mAtlas.prepareForFeature(0) self.mLabel1.adjustSizeToText() checker = QgsCompositionChecker('atlas_legend', self.mComposition) myTestResult, myMessage = checker.testComposition() assert myTestResult self.mAtlas.endRender() # restore state self.mAtlasMap.setLayers([layers[1]]) self.mComposition.removeComposerItem(legend) QgsProject.instance().removeMapLayer(ptLayer.id())
def processAlgorithm(self, parameters, context, feedback): try: # read out algorithm parameters input_points = self.parameterAsVectorLayer(parameters, self.INPUT, context) distance_treshold = parameters[self.DISTANCE_TRESHOLD] result_type_str = [ self.predicates[i][0] for i in self.parameterAsEnums(parameters, self.RESULT_TYPE, context) ][0] result_type = LsType[result_type_str] input_fields = [x.strip() for x in parameters[self.FIELDS].split(",")] input_layer_fields = input_points.fields() input_layer_fields_names = [field.name() for field in input_layer_fields] field_mapping = {} for input_field in input_fields: mapped_field_name = input_field if input_field == "weergavenaam": mapped_field_name = f"weergavenaam_{result_type.value}" # TODO: improve field mapping, since no check if ls_{input_field} exists # in input_layer_fields_names if mapped_field_name in input_layer_fields_names: mapped_field_name = f"ls_{input_field}" field_mapping[input_field] = mapped_field_name for input_field in input_fields: input_layer_fields.append( QgsField(field_mapping[input_field], QVariant.String) ) (sink, dest_id) = self.parameterAsSink( parameters, self.OUTPUT, context, input_layer_fields, QgsWkbTypes.Point, input_points.sourceCrs(), ) # Setup transformation if required in_crs = input_points.crs() out_crs = QgsCoordinateReferenceSystem.fromEpsgId(28992) transform = None if in_crs.authid() != "EPSG:28992": transform = QgsCoordinateTransform( in_crs, out_crs, QgsProject.instance() ) if feedback.isCanceled(): return {} # start processing features for point in input_points.getFeatures(): geom = point.geometry() fid = point.id() if transform: geom.transform(transform) point_geom = QgsGeometry.asPoint(geom) pxy = QgsPointXY(point_geom) x = pxy.x() y = pxy.y() # afstand field required, add if not requested by user if "afstand" not in input_fields: input_fields.append("afstand") data = reverse_lookup(x, y, input_fields, TypeFilter([result_type])) # TODO: add exception handling reverse_lookup result = None if len(data) > 0: if ( distance_treshold != None and data[0]["afstand"] > distance_treshold ): distance = data[0]["afstand"] feedback.pushInfo( f"feature id: {fid} - distance treshold ({distance_treshold}) exceeded: {distance}" ) pass else: result = {} for key in field_mapping: if key in data[0]: result[key] = data[0][key] else: feedback.pushInfo( f'feature id: {fid} - field "{key}" not in response' ) else: feedback.pushInfo( f"feature id: {fid} - no objects found for x,y ({x},{y}) with result_type: {result_type.value}" ) attrs = point.attributes() new_ft = QgsFeature(input_layer_fields) for i in range(len(attrs)): attr = attrs[i] field_name = input_layer_fields_names[i] new_ft.setAttribute(field_name, attr) for key in result: new_ft.setAttribute(field_mapping[key], result[key]) new_ft.setGeometry(point.geometry()) sink.addFeature(new_ft, QgsFeatureSink.FastInsert) if feedback.isCanceled(): return {} results = {} results[self.OUTPUT] = dest_id return results except Exception as e: traceback_str = traceback.format_exc() raise QgsProcessingException( f"Unexpected error occured while running PDOKReverseGeocoder: {str(e)} - {traceback_str}" )
def processAlgorithm(self, parameters, context, feedback): layer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.VECTOR), context) pointCount = float(self.getParameterValue(self.POINT_NUMBER)) minDistance = float(self.getParameterValue(self.MIN_DISTANCE)) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, layer.crs(), context) nPoints = 0 nIterations = 0 maxIterations = pointCount * 200 featureCount = layer.featureCount() total = 100.0 / pointCount if pointCount else 1 index = QgsSpatialIndex() points = dict() da = QgsDistanceArea() da.setSourceCrs(layer.sourceCrs()) da.setEllipsoid(QgsProject.instance().ellipsoid()) request = QgsFeatureRequest() random.seed() while nIterations < maxIterations and nPoints < pointCount: # pick random feature fid = random.randint(0, featureCount - 1) f = next( layer.getFeatures( request.setFilterFid(fid).setSubsetOfAttributes([]))) fGeom = f.geometry() if fGeom.isMultipart(): lines = fGeom.asMultiPolyline() # pick random line lineId = random.randint(0, len(lines) - 1) vertices = lines[lineId] else: vertices = fGeom.asPolyline() # pick random segment if len(vertices) == 2: vid = 0 else: vid = random.randint(0, len(vertices) - 2) startPoint = vertices[vid] endPoint = vertices[vid + 1] length = da.measureLine(startPoint, endPoint) dist = length * random.random() if dist > minDistance: d = dist / (length - dist) rx = (startPoint.x() + d * endPoint.x()) / (1 + d) ry = (startPoint.y() + d * endPoint.y()) / (1 + d) # generate random point pnt = QgsPointXY(rx, ry) geom = QgsGeometry.fromPoint(pnt) if vector.checkMinDistance(pnt, index, minDistance, points): f = QgsFeature(nPoints) f.initAttributes(1) f.setFields(fields) f.setAttribute('id', nPoints) f.setGeometry(geom) writer.addFeature(f, QgsFeatureSink.FastInsert) index.insertFeature(f) points[nPoints] = pnt nPoints += 1 feedback.setProgress(int(nPoints * total)) nIterations += 1 if nPoints < pointCount: QgsMessageLog.logMessage( self.tr('Can not generate requested number of random points. ' 'Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO) del writer
def processAlgorithm(self, parameters, context, feedback): input_layer = self.parameterAsVectorLayer(parameters, self.INPUT_LAYER, context) impact_field = self.parameterAsString(parameters, self.IMPACT_FIELD, context) scenario_name = self.parameterAsString(parameters, self.SCENARIO_NAME, context) scenario_layer = self.parameterAsVectorLayer(parameters, self.SCENARIO_LAYER, context) # Only for compensation if self.project_type == ProjectType.Compensation: risque_field = self.parameterAsString( parameters, self.RISQUE_COEFFICIENT_CHAMP, context) delais_field = self.parameterAsString( parameters, self.RISQUE_COEFFICIENT_CHAMP, context) else: risque_field = None delais_field = None self._output_layer = self.parameterAsVectorLayer( parameters, self.OUTPUT_LAYER, context) index = input_layer.fields().indexOf(impact_field) unique_values = input_layer.uniqueValues(index) if self.expected_values and not unique_values.issubset( self.expected_values): feedback.reportError('Valeur possible pour la {} : {}'.format( self.project_type.label, ', '.join([str(i) for i in self.expected_values]))) diff = unique_values - self.expected_values raise QgsProcessingException( 'Valeur inconnue pour la {} : {}'.format( self.project_type.label, ', '.join([str(i) for i in diff]))) params = { 'INPUT': input_layer, 'DISTANCE': 0, 'OUTPUT': 'TEMPORARY_OUTPUT' } results = processing.run("native:buffer", params, context=context, feedback=feedback, is_child_algorithm=True) params = { 'INPUT': results['OUTPUT'], 'FIELD': [impact_field], 'OUTPUT': 'TEMPORARY_OUTPUT' } results = processing.run( "native:collect", params, context=context, feedback=feedback, is_child_algorithm=True, ) params = {'INPUT': results['OUTPUT'], 'OUTPUT': 'TEMPORARY_OUTPUT'} results = processing.run("native:promotetomulti", params, context=context, feedback=feedback, is_child_algorithm=True) if input_layer.crs() != self.output_layer.crs(): feedback.pushInfo( 'Le CRS de la couche de destination est différent. Reprojection en {}…' .format(self.output_layer.crs().authid())) params = { 'INPUT': results['OUTPUT'], 'TARGET_CRS': self.output_layer.crs(), 'OUTPUT': 'TEMPORARY_OUTPUT' } results = processing.run("native:reprojectlayer", params, context=context, feedback=feedback, is_child_algorithm=True) params = { 'INPUT': results['OUTPUT'], 'DISTANCE': 0, 'OUTPUT': 'memory:' } results = processing.run("native:buffer", params, context=context, feedback=feedback, is_child_algorithm=True) layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context, True) self.scenario_id = self.insert_scenario(scenario_layer, scenario_name) feedback.pushInfo('Création du scénario numéro {} : {}'.format( self.scenario_id, scenario_name)) request = QgsFeatureRequest() requested_fields = [impact_field] if self.project_type == ProjectType.Compensation: requested_fields.append(delais_field) requested_fields.append(risque_field) request.setSubsetOfAttributes(requested_fields, input_layer.fields()) for input_feature in layer.getFeatures(request): if feedback.isCanceled(): break output_feature = QgsFeature(self.output_layer.fields()) output_feature.setGeometry(input_feature.geometry()) output_feature.setAttribute('scenario_id', self.scenario_id) output_feature.setAttribute(self.destination_impact_field, input_feature[impact_field]) if self.project_type == ProjectType.Compensation: output_feature.setAttribute('coeff_risque', input_feature[risque_field]) output_feature.setAttribute('coeff_delais', input_feature[delais_field]) with edit(self.output_layer): self.output_layer.addFeature(output_feature) if not self.output_layer.setSubsetString('"scenario_id" = {}'.format( self.scenario_id)): raise QgsProcessingException('Subset string is not valid') apply_calcul = self.parameterAsBoolean( parameters, self.APPLY_CALCUL_HABITAT_IMPACT_ETAT_ECOLOGIQUE, context) # Si apply_calcul = False # Alors l'algo s'arrête ici if not apply_calcul: return {} habitat = self.parameterAsVectorLayer(parameters, self.HABITAT_LAYER, context) habitat_impact = self.parameterAsVectorLayer(parameters, self.HABITAT_IMPACT_LAYER, context) # Vérification de l'unicité des couples habitat/faciès params = {'INPUT': habitat, 'OUTPUT': 'TEMPORARY_OUTPUT'} results = processing.run("mercicor:calcul_unicity_habitat", params, context=context, feedback=feedback, is_child_algorithm=True) # Si les couple habitat/faciès ne sont pas unique # Alors le calcul ne se fait pas if results['NUMBER_OF_NON_UNIQUE']: feedback.pushDebugInfo( '{} couple(s) habitat/faciès non unique !'.format( results['NUMBER_OF_NON_UNIQUE'])) feedback.reportError( 'Les couples habitat/faciès ne sont pas uniques !') msg = ( 'Utiliser l\'algorithme Mercicor "Calcul unicité habitat/faciès" pour corriger le problème.' ) feedback.pushInfo(msg) return {} params = { 'HABITAT_LAYER': habitat, '{}_LAYER'.format(self.project_type.label.upper()): self.output_layer, 'HABITAT_{}_ETAT_ECOLOGIQUE_LAYER'.format(self.project_type.label.upper( )): habitat_impact } processing.run( "mercicor:calcul_habitat_{}_etat_ecologique".format( self.project_type.label), params, context=context, feedback=feedback, is_child_algorithm=True, ) return {}
def processAlgorithm(self, progress): extent = self.getParameterValue(self.EXTENT).split(',') xSpace = self.getParameterValue(self.STEP_X) ySpace = self.getParameterValue(self.STEP_Y) bbox = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) fields.append(QgsField('coord', QVariant.Double, '', 24, 15)) fieldCount = 2 writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.LineString, mapCRS) feat = QgsFeature() feat.initAttributes(fieldCount) feat.setFields(fields) geom = QgsGeometry() idVar = 0 count = 0 count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace count_update = count_max * 0.10 y = bbox.yMaximum() while y >= bbox.yMinimum(): pt1 = QgsPoint(bbox.xMinimum(), y) pt2 = QgsPoint(bbox.xMaximum(), y) line = [pt1, pt2] feat.setGeometry(geom.fromPolyline(line)) feat.setAttribute(0, idVar) feat.setAttribute(1, y) writer.addFeature(feat) y = y - ySpace idVar += 1 count += 1 if int(math.fmod(count, count_update)) == 0: progress.setPercentage(int(count / count_max * 50)) progress.setPercentage(50) # counters for progressbar - update every 5% count = 0 count_max = (bbox.xMaximum() - bbox.xMinimum()) / xSpace count_update = count_max * 0.10 x = bbox.xMinimum() while x <= bbox.xMaximum(): pt1 = QgsPoint(x, bbox.yMaximum()) pt2 = QgsPoint(x, bbox.yMinimum()) line = [pt1, pt2] feat.setGeometry(geom.fromPolyline(line)) feat.setAttribute(0, idVar) feat.setAttribute(1, x) writer.addFeature(feat) x = x + xSpace idVar += 1 count += 1 if int(math.fmod(count, count_update)) == 0: progress.setPercentage(50 + int(count / count_max * 50)) del writer