vectorLayer = processing.getObject(input) dtmLayer = processing.getObject(dtm) measureStep = measure fields = QgsFields() fields.append(QgsField('id_poly', QVariant.Int)) fields.append(QgsField('elevation', QVariant.Double)) fields.append(QgsField('step', QVariant.Double)) pointSamplewriter = VectorWriter(output, None, fields, QgsWKBTypes.Point, vectorLayer.crs()) features = processing.features(vectorLayer) for feat in features: currentLen = 0 while currentLen < feat.geometry().length(): point = feat.geometry().interpolate(currentLen).asPoint() elevFeat = QgsFeature(fields) elevValue = dtmLayer.dataProvider().identify( point, QgsRaster.IdentifyFormatValue).results()[1] elevFeat['elevation'] = elevValue elevFeat['step'] = currentLen elevFeat['id_poly'] = feat.id() elevGeom = QgsGeometry.fromPoint(point) elevFeat.setGeometry(elevGeom) pointSamplewriter.addFeature(elevFeat) currentLen += measureStep del pointSamplewriter
line = geom.asPolyline() funcExist = existNodeCheckFid populateListFidNode(fid, line, l_fid_node, funcExist ) # Remove Exists nodes for id in reversed( xrange( len( l_fid_node ) ) ): if l_fid_node[ id ]['exists']: l_fid_node.pop( id ) # Remove nodes with same FID line ids_remove = [] for id in xrange( len( l_fid_node )-1 ): fid1, fid2 = l_fid_node[ id ]['fid'], l_fid_node[ id+1 ]['fid'] if fid1 == fid2: ids_remove.append( id ) ids_remove.append( id+1 ) ids_remove.reverse() for id in ids_remove: l_fid_node.pop( id ) # Output fields = [ QgsCore.QgsField("fid_line", QtCore.QVariant.Int ) ] lyrSource = VectorWriter( Nascentes, None, fields, QgsCore.QGis.WKBPoint, lyrRiver.crs() ) for fn in l_fid_node: feat = QgsCore.QgsFeature() feat.setAttributes( [ fn['fid'] ]) feat.setGeometry( QgsCore.QgsGeometry.fromPoint( fn['node']) ) lyrSource.addFeature( feat ) del feat del lyrSource
l = 0 writer = VectorWriter(Results, None, polyPrder.fields(), QGis.WKBMultiPolygon, polyPrder.crs()) resgeom = QgsGeometry() resfeat = QgsFeature() for feat in processing.features(polyLayer): progress.setPercentage(int(100*l/n)) l+=1 g = loads(feat.geometry().asWkb()) if g.geom_type == 'MultiPolygon': resg = [Polygon(p.exterior, [r for r in p.interiors if Polygon(r).area > Max_area]) for p in g] else: resg = [Polygon(g.exterior, [r for r in g.interiors if Polygon(r).area > Max_area])] resgeom = QgsGeometry().fromWkt(dumps(MultiPolygon(resg))) resfeat.setAttributes(feat.attributes()) resfeat.setGeometry(resgeom) writer.addFeature(resfeat) del writer
for selected in selected_layers: layer = processing.getObject(selected) output_path = os.path.join(Output_Folder, layer.name() + '.shp') projected += 1 progress.setPercentage(int(100 * projected / selected_count)) # check exist Ovewrite if os.path.isfile(output_path) and Ovewrite == False: print "Already exists: " + output_path continue trans.setSourceCrs(layer.crs()) # reprojecting layers writer = VectorWriter(output_path, None, layer.dataProvider().fields(), layer.dataProvider().geometryType(), dest_crs) features = processing.features(layer) for feature in features: # transform geometry http://www.qgis.org/api/classQgsGeometry.html geometry = feature.geometry() geometry.transform(trans) # create & insert feature new_feature = QgsFeature() new_feature.setGeometry(geometry) new_feature.setAttributes(feature.attributes()) writer.addFeature(new_feature) del writer output = selected_count
grid = Grid(bbox,max_radius) print("Inserting {} points ...".format(len(points))) grid.insert_points(points) print("Redistributing {} points ...".format(len(points))) grid.redistribute_points(points) fields = [QgsField('GROUP', QVariant.Int)] geom_type = 1 # point writer_pts = VectorWriter(grouped_points, None, fields, geom_type, l.crs() ) writer_centroids = VectorWriter(group_centroids, None, fields, geom_type, l.crs() ) print("Writing {} groups ...".format(len(grid.resulting_groups))) for id,g in enumerate(grid.resulting_groups): fet2 = QgsFeature() fet2.setGeometry(QgsGeometry.fromPoint(g.centroid)) fet2.setAttributes([id]) writer_centroids.addFeature(fet2) for pt in g.points: fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(pt)) fet.setAttributes([id]) writer_pts.addFeature(fet) del writer_pts del writer_centroids
* * ***************************************************************************/ """ ##[My Scripts]=group ##Vector Field Case Converter=name ##Vector_Layer=vector ##Upper_Case=boolean ##Output=output vector from qgis.core import * from processing.tools.vector import VectorWriter vectorLayer = processing.getObject(Vector_Layer) provider = vectorLayer.dataProvider() # rebuild fields new_fields = QgsFields() for field in provider.fields(): field_name = field.name().upper() if Upper_Case else field.name().lower() field.setName(field_name) new_fields.append(field) # write features writer = VectorWriter(Output, None, new_fields, provider.geometryType(), vectorLayer.crs()) features = processing.features(vectorLayer) for feature in features: writer.addFeature(feature) del writer
if count == 0: majority = 0 minority = 0 majority_p = 0 minority_p = 0 else: minority, majority = freq_min_max(freq) minority = int(minority) majority = int(majority) minority_p = float(freq[minority]) / count majority_p = float(freq[majority]) / count # write to layer outFeat.setGeometry(feat.geometry()) attrs = feat.attributes() + [majority, majority_p, minority, minority_p] outFeat.setAttributes(attrs) layer_writer.addFeature(outFeat) # write to table row = [feat[id_field], majority] for v in values: if v in freq: row.append(float(freq[v]) / count) else: row.append(0) table_writer.addRecord(row) progress.setPercentage(100) del table_writer del layer_writer
##Centroids=name ##Geometry=group ##INPUT_LAYER=vector ##OUTPUT_LAYER=output vector from qgis.core import QgsWkbTypes, QgsGeometry from processing.tools.vector import VectorWriter layer = processing.getObject(INPUT_LAYER) fields = layer.fields() writer = VectorWriter(OUTPUT_LAYER, 'utf-8', fields, QgsWkbTypes.Point, layer.crs()) features = processing.features(layer) count = len(features) if count == 0: raise GeoAlgorithmExecutionException('Input layer contains no features.') total = 100.0 / len(features) for count, f in enumerate(features): outputFeature = f if f.hasGeometry(): outputGeometry = f.geometry().centroid() outputFeature.setGeometry(outputGeometry) writer.addFeature(outputFeature) feedback.setProgress(int(count * total))
class SelafinContour2Shp(QtCore.QObject): def __init__( self, processtype, # 0 : thread inside qgis plugin) - 1 : thread processing - 2 : modeler (no thread) - 3 : modeler + shpouput - 4: outsideqgis selafinfilepath, # path to selafin file time, # time to process (selafin time in iteration) parameter, # parameter to process name (string) or id (int) levels, # levels to create selafincrs="EPSG:2154", # selafin crs translatex=0, translatey=0, selafintransformedcrs=None, # if no none, specify crs of output file quickprocessing=False, # quickprocess option - don't make ring outputshpname=None, # change generic outputname to specific one outputshppath=None, # if not none, create shp in this directory forcedvalue=None, # force value for plugin outputprocessing=None, ): # case of use in modeler QtCore.QObject.__init__(self) # donnees process self.processtype = processtype self.quickprocessing = quickprocessing # self.quickprocessing = True # donnes delafin self.parserhydrau = PostTelemacSelafinParser() self.parserhydrau.loadHydrauFile(os.path.normpath(selafinfilepath)) # slf = SELAFIN(os.path.normpath(selafinfilepath)) slf = self.parserhydrau.hydraufile """ self.slf_x = slf.MESHX self.slf_y = slf.MESHY self.slf_mesh = np.array(slf.IKLE3) """ # self.slf_x, self.slf_y = self.parserhydrau.getMesh() self.slf_x, self.slf_y = self.parserhydrau.getFacesNodes() self.slf_x = self.slf_x + translatex self.slf_y = self.slf_y + translatey # self.slf_mesh = np.array( self.parserhydrau.getIkle() ) self.slf_mesh = np.array(self.parserhydrau.getElemFaces()) if self.processtype == 0: # self.slf_param = [0,parameter] # self.slf_param = [parameter,self.parserhydrau.getVarnames()[parameter].strip()] self.slf_param = [parameter, parameter] else: # self.slf_param = [parameter,slf.VARNAMES[parameter].strip()] self.slf_param = [ parameter, self.parserhydrau.getVarNames()[parameter].strip() ] # slf_time = [time,slf.tags["times"][time]] slf_time = [time, self.parserhydrau.getTimes()[time]] if forcedvalue is None: # self.slf_value = slf.getVALUES(slf_time[0])[self.slf_param[0]] self.slf_value = self.parserhydrau.getValues( slf_time[0])[self.slf_param[0]] else: self.slf_value = forcedvalue # donnees shp champs = QgsFields() champs.append(QgsField("min", QVariant.Double)) champs.append(QgsField("max", QVariant.Double)) if self.quickprocessing: champs.append(QgsField("int", QVariant.String)) # donnees shp - outside qgis if not outputshpname: outputshpname = (os.path.basename( os.path.normpath(selafinfilepath)).split(".")[0] + "_" + str(self.slf_param[1]).translate(None, "?,!.;") + "_t_" + str(slf_time[1]) + str(".shp")) else: outputshpname = (os.path.basename( os.path.normpath(selafinfilepath)).split(".")[0] + "_" + str(outputshpname) + str(".shp")) if not outputshppath: outputshppath = os.path.dirname(os.path.normpath(selafinfilepath)) self.outputshpfile = os.path.join(outputshppath, outputshpname) if isFileLocked(self.outputshpfile, True): self.raiseError( str(ctime()) + " - Initialisation - Erreur : \ Fichier shape deja charge !!") self.slf_crs = selafincrs if selafintransformedcrs: self.slf_shpcrs = selafintransformedcrs self.xform = QgsCoordinateTransform( QgsCoordinateReferenceSystem(str(self.slf_crs)), QgsCoordinateReferenceSystem(str(self.slf_shpcrs))) else: self.slf_shpcrs = self.slf_crs self.xform = None if self.processtype in [0, 1, 3, 4]: if sys.version_info.major == 2: self.writerw_shp = QgsVectorFileWriter( self.outputshpfile, None, champs, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(self.slf_shpcrs), "ESRI Shapefile", ) elif sys.version_info.major == 3: self.writerw_shp = QgsVectorFileWriter( self.outputshpfile, "utf-8", champs, qgis.core.QgsWkbTypes.MultiPolygon, QgsCoordinateReferenceSystem(self.slf_shpcrs), driverName="ESRI Shapefile", ) # donnees shp - processing result try: if self.processtype in [2, 3]: self.writerw_process = VectorWriter( outputprocessing, None, champs, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(str(self.slf_shpcrs)), "ESRI Shapefile", ) except Exception as e: pass # donnees matplotlib self.levels = levels def createShp(self): # ******** Informations de lancement de la tache ***************************************************** fet = QgsFeature() strtxt = str(ctime()) + " - creation shapefile :" + "\n" + str( self.outputshpfile) self.writeOutput(strtxt) # ******** Iteration sur les niveaux ******************************************************************* for lvltemp in range(len(self.levels) - 1): lvltemp1 = [self.levels[lvltemp], self.levels[lvltemp + 1]] strtxt = (str(ctime()) + " - " + str(self.slf_param[1]) + " - lvl " + str(lvltemp1) + " - Matplotlib integration") self.writeOutput(strtxt) triplotcontourf = plt.tricontourf( self.slf_x, self.slf_y, self.slf_mesh, self.slf_value, lvltemp1) # l'outil de matplotlib qui cree la triangulation # Iteration sur les contours fournis par triplotcontourf et inclusion des outers et inners dans une table temporaire************** vlInnerTemp, vlOuterTemp, vlOuterTempIndex = self.createInnerOutertempLayer( triplotcontourf) # *********** Debut du traitement des iles************************************************************ strtxt = str(ctime()) + " - " + str( self.slf_param[1]) + " - lvl " + str( lvltemp1) + " - Ring process" self.writeOutput(strtxt) allfeatures2 = { feature.id(): feature for (feature) in vlOuterTemp.getFeatures() } # creation d'un index spatial des inners pour aller plus vite map(vlOuterTempIndex.insertFeature, allfeatures2.values()) if self.quickprocessing: for f1 in vlInnerTemp.getFeatures(): fet.setGeometry(f1.geometry()) fet.setAttributes([lvltemp1[0], lvltemp1[1], "False"]) if self.processtype in [0, 2]: self.writerw_shp.addFeature(fet) if self.processtype in [1, 2]: self.writerw_process.addFeature(fet) for f2 in vlOuterTemp.getFeatures(): fet.setGeometry(f2.geometry()) fet.setAttributes([lvltemp1[0], lvltemp1[1], "True"]) if self.processtype in [0, 2]: self.writerw_shp.addFeature(fet) if self.processtype in [1, 2]: self.writerw_process.addFeature(fet) else: counttotal = int(vlInnerTemp.featureCount()) # *Iteration sur tous les outer *********************************************************************** for f1 in vlInnerTemp.getFeatures(): if int(f1.id()) % 50 == 0: self.verboseOutput(self.slf_param[1], lvltemp1, f1.id(), counttotal) fet = self.InsertRinginFeature(f1, allfeatures2, vlOuterTempIndex, lvltemp1, counttotal) if self.processtype in [0, 1, 3, 4]: self.writerw_shp.addFeature(fet) if self.processtype in [2, 3]: self.writerw_process.addFeature(fet) # Clear thongs vlInnerTemp = None vlOuterTemp = None pr1 = None pr2 = None vlOuterTempIndex = None if self.processtype in [0, 1, 3, 4]: del self.writerw_shp if self.processtype in [2, 3]: del self.writerw_process # Emit finish if self.processtype in [0, 1]: self.finished.emit(self.outputshpfile) if self.processtype in [2, 3]: t = workerFinished(self.outputshpfile) if self.processtype in [4]: self.writeOutput("Process finished - " + str(self.outputshpfile)) def verboseOutput(self, param, lvl, geomelem=None, geomtot=None, ileelem=None, iletot=None): strtxt = str(ctime()) + " - " + str(param) + " - lvl : " + str(lvl) if geomelem: strtxt = strtxt + " - geom : " + str(geomelem) + "/" + str(geomtot) if ileelem: strtxt = strtxt + " - ring : " + str(ileelem) + "/" + str(iletot) self.writeOutput(strtxt) def writeOutput(self, str1): if self.processtype in [0, 1, 2, 3]: self.status.emit(str(str1)) elif self.processtype == 4: print(str1) def raiseError(self, str1): self.error.emit(str(str1)) def createInnerOutertempLayer(self, triplotcontourf): fet = QgsFeature() for collection in triplotcontourf.collections: vl1temp1 = QgsVectorLayer("Multipolygon?crs=" + str(self.slf_crs), "temporary_poly_outer ", "memory") pr1 = vl1temp1.dataProvider() vl2temp1 = QgsVectorLayer("Multipolygon?crs=" + str(self.slf_crs), "temporary_poly_inner ", "memory") pr2 = vl2temp1.dataProvider() vl1temp1.startEditing() vl2temp1.startEditing() for path in collection.get_paths(): for polygon in path.to_polygons(): if len(polygon) >= 3: fet.setGeometry(self.get_outerinner(polygon)[0]) fet.setAttributes([]) if np.cross(polygon, np.roll(polygon, -1, axis=0)).sum() / 2.0 > 0: pr1.addFeatures([fet]) vl1temp1.commitChanges() else: pr2.addFeatures([fet]) vl2temp1.commitChanges() index2 = QgsSpatialIndex(vl2temp1.getFeatures()) return (vl1temp1, vl2temp1, index2) def get_outerinner(self, geom1): geomtemp1 = [] if (str(geom1.__class__) == "<class 'qgis.core.QgsGeometry'>" or str(geom1.__class__) == "<class 'qgis._core.QgsGeometry'>"): geompolygon = geom1.asPolygon() for i in range(len(geompolygon)): geomtemp2 = [] if sys.version_info.major == 2: for j in range(len(geompolygon[i])): geomtemp2.append( QgsPoint(geompolygon[i][j][0], geompolygon[i][j][1])) geomcheck = QgsGeometry.fromPolygon([geomtemp2]) elif sys.version_info.major == 3: for j in range(len(geompolygon[i])): geomtemp2.append( QgsPointXY(geompolygon[i][j][0], geompolygon[i][j][1])) geomcheck = QgsGeometry.fromPolygonXY([geomtemp2]) if len(geomcheck.validateGeometry()) != 0: geomcheck = geomcheck.buffer(0.01, 5) geomtemp1.append(geomcheck) else: geomtemp2 = [] if sys.version_info.major == 2: for i in range(len(geom1)): geomtemp2.append(QgsPoint(geom1[i][0], geom1[i][1])) geomtemp1.append(QgsGeometry.fromPolygon([geomtemp2])) elif sys.version_info.major == 3: for i in range(len(geom1)): geomtemp2.append(QgsPointXY(geom1[i][0], geom1[i][1])) geomtemp1.append(QgsGeometry.fromPolygonXY([geomtemp2])) return geomtemp1 def InsertRinginFeature(self, f1, allfeatures2, vlOuterTempIndex, lvltemp1, counttotal): try: # Correction des erreurs de geometrie des outers if len(f1.geometry().validateGeometry()) != 0: if True: f1geom = f1.geometry().buffer(0.01, 5) if f1geom.area() < f1.geometry().area(): f1geom = f1.geometry() self.writeOutput(ctime() + " - Warning : geometry " + str(f1.id()) + " not valid before inserting rings") else: geomshpapely = loads(f1.geometry().asWkb()) resulttemp = self.repairPolygon(geomshpapely) if resulttemp != None: geom3 = [ QgsPointXY(point[0], point[1]) for point in list(resulttemp.exterior.coords) ] geom2 = QgsGeometry.fromPolygon([geom3]) f1geom = geom2 self.writeOutput(ctime() + " - geometry correction") else: f1geom = f1.geometry() else: f1geom = f1.geometry() # requete spatiale pour avoir les inner dans les outers ids = vlOuterTempIndex.intersects(f1geom.boundingBox()) fet1surface = f1geom.area() # Iteration sur tous les inners pour les inclures dans les outers **** # creation d un tableau pour trier les inners par ordre de S decroissant tab = [] for id in ids: f2geom = allfeatures2[id].geometry() if len(f2geom.validateGeometry()) != 0: f2geom = f2geom.buffer(0.00, 5) tab.append([f2geom.area(), f2geom]) if len(tab) > 0: tab.sort(reverse=True) # Iteration pour enlever les inner des outers - coeur du script for k in range(len(tab)): try: if int(k) % 100 == 0 and k != 0: self.verboseOutput(self.slf_param[1], lvltemp1, f1.id(), counttotal, k, len(ids)) if tab[k][0] >= fet1surface: continue else: ring = self.do_ring(tab[k][1]) tt1 = f1geom.addRing(ring) if tt1 == 5 and f1geom.intersects(tab[k][1]): f1geom = f1geom.difference(tab[k][1]) except Exception as e: strtxt = (str(ctime()) + " - " + str(self.slf_param[1]) + " - Thread - Traitement du niveau " + str(lvltemp1) + " - geometry n " + str(f1.id()) + "/" + str(counttotal) + " - ile n " + str(k) + "/" + str(len(ids)) + " - Probleme d integration ******** : " + str(e) + " " + str(tab[k][0]) + " " + str(self.get_outerinner(tab[k][1]))) self.writeOutput(strtxt) if len(f1geom.validateGeometry()) != 0: f1geomtemp = f1geom.buffer(0.01, 5) if f1geomtemp.area() > f1geom.area(): f1geom = f1geomtemp else: self.writeOutput(ctime() + " - Warning : geometry " + str(f1.id()) + " not valid after inserting rings") if self.xform: f1geom.transform(self.xform) fet = QgsFeature() fet.setGeometry(f1geom) fet.setAttributes([lvltemp1[0], lvltemp1[1]]) return fet except Exception as e: self.writeOutput( str(ctime()) + " - Erreur creation ring : " + str(e)) return f1 def do_ring(self, geom3): ring = [] polygon = geom3.asPolygon()[0] if sys.version_info.major == 2: for i in range(len(polygon)): ring.append(QgsPoint(polygon[i][0], polygon[i][1])) ring.append(QgsPoint(polygon[0][0], polygon[0][1])) if sys.version_info.major == 3: for i in range(len(polygon)): ring.append(QgsPointXY(polygon[i][0], polygon[i][1])) ring.append(QgsPointXY(polygon[0][0], polygon[0][1])) return ring def repairPolygon(self, geometry): buffer_worker = True try: geometry = geometry.buffer(0) except: buffer_worker = False if buffer_worker: return geometry polygons = [] if geometry.geom_type == "Polygon": polygons.append(geometry) elif geometry.geom_type == "MultiPolygon": polygons.extend(geometry.geoms) fixed_polygons = [] for n, polygon in enumerate(polygons): if not self.linear_ring_is_valid(polygon.exterior): continue # "unable to fix" interiors = [] for ring in polygon.interiors: if self.linear_ring_is_valid(ring): interiors.append(ring) fixed_polygon = shapely.geometry.Polygon(polygon.exterior, interiors) try: fixed_polygon = fixed_polygon.buffer(0) except: continue if fixed_polygon.geom_type == "Polygon": fixed_polygons.append(fixed_polygon) elif fixed_polygon.geom_type == "MultiPolygon": fixed_polygons.extend(fixed_polygon.geoms) if len(fixed_polygons) > 0: return shapely.geometry.MultiPolygon(fixed_polygons) else: return None def linear_ring_is_valid(self, ring): points = set() for x, y in ring.coords: points.add((x, y)) if len(points) < 3: return False else: return True progress = QtCore.pyqtSignal(int) status = QtCore.pyqtSignal(str) error = QtCore.pyqtSignal(str) killed = QtCore.pyqtSignal() finished = QtCore.pyqtSignal(str)
##[Example scripts]=group ##input=vector ##output=output vector from qgis.core import * from processing.tools.vector import VectorWriter vectorLayer = processing.getObject(input) provider = vectorLayer.dataProvider() writer = VectorWriter(output, None, provider.fields(), provider.geometryType(), vectorLayer.crs()) features = processing.features(vectorLayer) writer.addFeature(next(features.iter)) del writer
# l'intersection se fait avec le polygone bufferise if not no_blank or (no_blank and rectangle.intersects(buffer_geom)): id_tile += 1 id_poly_tile += 1 new_feat = QgsFeature() new_feat.setGeometry(rectangle) # attributs standards attribute_values = feature.attributes()[:] # attributs supplementaires attribute_values.extend([id_poly, id_tile, id_poly_tile, row_poly_tile, col_poly_tile]) # attribut supplementaire pour tri if ord_field: attribute_values.append('{}#{:04d}'.format(feature[ord_field], id_poly_tile)) # attributs supplementaires coord dalle if tile_bound: attribute_values.extend([min_x_tile, max_x_tile, min_y_tile, max_y_tile]) # attributs supplementaires coord enveloppe if poly_bound: attribute_values.extend([min_x_poly, max_x_poly, min_y_poly, max_y_poly]) # ajoute les geometries et valeurs des enregistrements new_feat.setAttributes(attribute_values) vw_grid.addFeature(new_feat) del vw_grid # pour memoire : #QMessageBox.information(None, 'DEBUGn: ' , 'texte') # pas recommande ! #progress.setInfo('texte') #progress.setText('texte') #raise GeoAlgorithmExecutionException('texte')
from qgis.core import * from qgis.utils import iface from processing.tools.vector import VectorWriter from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException # import from WKT geometry try: geometry = QgsGeometry.fromWkt(Well_Known_Text) except Exception as detail: raise GeoAlgorithmExecutionException('Invalid WKT Geometry: %s' % detail) # set CRS crs = iface.mapCanvas().mapRenderer().destinationCrs() # create vector layer fields = QgsFields() fields.append(QgsField('id', QVariant.Int)) fields.append(QgsField('type', QVariant.String)) writer = VectorWriter(Output, None, fields, geometry.wkbType(), crs) # create & write feature feature = QgsFeature(fields) feature.setGeometry(geometry) feature.setAttribute('id', 1) feature.setAttribute('type', geometry.wkbType()) writer.addFeature(feature) del writer
cell_feature.setAttributes(ret) centroid_features[idx_side] = cell_feature #. write features cell_writer = VectorWriter(Output_layer, None, cell_fields, QGis.WKBPolygon, input_layer.crs()) for idx_side in xrange(DEFAULT_SEGS): cell_feature = centroid_features[idx_side] value = cell_feature.attributes()[3] linear_trans_value = (value - minVal) / (maxVal - minVal); adjusted_radius = linear_trans_value * radius if adjusted_radius > 0: from_deg = (idx_side * step_angle) - half_step to_deg = ((idx_side + 1) * step_angle) - half_step cell = create_cell(center_point, from_deg, to_deg, adjusted_radius) cell_feature.setGeometry(cell) cell_writer.addFeature(cell_feature) del cell_writer #. write anchor cell_fields = QgsFields() cell_fields.append(QgsField("distance", QVariant.Double)) cell_fields.append(QgsField("direction", QVariant.String)) anchor_writer = VectorWriter(Output_Anchor, None, cell_fields, QGis.WKBLineString, input_layer.crs()) radius_step = radius / 5 center = QgsGeometry.fromPoint(center_point) for idx_side in xrange(5): buffer_radius = radius_step * (idx_side + 1) anchor_feature = QgsFeature(cell_fields) anchor_feature.setGeometry(center.buffer(buffer_radius, 32))
else: polygon = geom.asPolygon() polygon_area = area.measurePolygon(polygon[0]) # calculated area is in sq. metres if units_selection == 'sq_km': final_area = polygon_area / 1e6 elif units_selection == 'sq_ft': final_area = area.convertMeasurement( polygon_area, QGis.Meters, QGis.Feet, True)[0] elif units_selection == 'sq_miles': final_area = area.convertMeasurement( polygon_area, QGis.Meters, QGis.Feet, True)[0] / (5280.0 * 5280.0) elif units_selection == 'sq_nm': final_area = area.convertMeasurement( polygon_area, QGis.Meters, QGis.NauticalMiles, True)[0] elif units_selection == 'sq_degrees': final_area = area.convertMeasurement( polygon_area, QGis.Meters, QGis.Degrees, True)[0] else: final_area = polygon_area attrs = feat.attributes() attrs.append(final_area) out_f.setGeometry(geom) out_f.setAttributes(attrs) writer.addFeature(out_f) progress.setPercentage(100) del writer
default_radius + radius_interval) cell_centroid_point = cell.centroid().asPoint() # find nearest feature & create anchor line if (idx_radius == 0): fids = spatial_index.nearestNeighbor(cell_centroid_point, 1) for fid in fids: nearest_feature = centroid_features[fid] nearest_point = nearest_feature.geometry().asPoint() anchor_feature = QgsFeature() anchor_feature.setGeometry( QgsGeometry.fromPolyline( [nearest_point, cell_centroid_point])) anchor_feature.setAttributes(nearest_feature.attributes()) anchor_writer.addFeature(anchor_feature) spatial_index.deleteFeature(nearest_feature) # create and write ring feature ring_feature = QgsFeature(ring_fields) ring_feature.setGeometry(cell) ring_attributes = nearest_feature.attributes() ring_attributes.append(idx_radius + 1) # ring_num if (idx_fields[idx_radius] == -1): ring_attributes.append(0) # default value = 0 else: ring_attributes.append( ring_attributes[idx_fields[idx_radius]]) # ring_val ring_feature.setAttributes(ring_attributes)
polygon_layer = processing.getObject(Polygon_Layer) provider = polygon_layer.dataProvider() # write features writer = VectorWriter(Output, None, provider.fields(), QGis.WKBPoint, polygon_layer.crs()) point_feature = QgsFeature() features = processing.features(polygon_layer) total = 100.0 / float(len(features)) current = 0 for feature in features: geometry = feature.geometry() attributes = feature.attributes() point = geometry.centroid() if Point_On_Surface and not geometry.contains(point): point = geometry.pointOnSurface() if point is None: raise GeoAlgorithmExecutionException('Error calculating point') point_feature.setGeometry(point) point_feature.setAttributes(attributes) writer.addFeature(point_feature) current += 1 progress.setPercentage(int(current * total)) del writer
def perform(self): geo_transform = self.raster_ds.GetGeoTransform() raster_b_box = self.__get_raster_b_box(geo_transform) raster_geom = QgsGeometry.fromRect(raster_b_box) crs = self.__create_spatial_reference() if self.use_global_extent: src_offset, src_array, new_geo_transform = self.__get_global_extent( raster_b_box, geo_transform) else: src_offset = None src_array = None new_geo_transform = None mem_vector_driver = ogr.GetDriverByName('Memory') mem_raster_driver = gdal.GetDriverByName('MEM') self.__populate_fields_operations() writer = VectorWriter(self.destination, None, self.fields.toList(), self.layer.wkbType(), self.layer.crs(), None) out_feat = QgsFeature() out_feat.initAttributes(len(self.fields)) out_feat.setFields(self.fields) features = vector.features(self.layer) last_progress = 0 total = 100.0 / len(features) if len(features) > 0 else 1 dlg, bar = QtHandler.progress_dialog( label='Fill grid with {}...'.format(self.basename_raster)) start_time = datetime.now() str_start_time = start_time.strftime(self.pt_br_format) self.logger.info('Running zonal stats to "{}" at {}...'.format( self.basename_raster, str_start_time)) for current, f in enumerate(features): geom = f.geometry() intersected_geom = raster_geom.intersection(geom) ogr_geom = ogr.CreateGeometryFromWkt( intersected_geom.exportToWkt()) if not self.use_global_extent: bbox = intersected_geom.boundingBox() x_min = bbox.xMinimum() x_max = bbox.xMaximum() y_min = bbox.yMinimum() y_max = bbox.yMaximum() (startColumn, startRow) = mapToPixel(x_min, y_max, geo_transform) (endColumn, endRow) = mapToPixel(x_max, y_min, geo_transform) width = endColumn - startColumn height = endRow - startRow if width == 0 or height == 0: continue src_offset = (startColumn, startRow, width, height) src_array = self.raster_band.ReadAsArray(*src_offset) src_array = src_array * self.scale + self.offset new_geo_transform = ( geo_transform[0] + src_offset[0] * geo_transform[1], geo_transform[1], 0.0, geo_transform[3] + src_offset[1] * geo_transform[5], 0.0, geo_transform[5], ) # Create a temporary vector layer in memory mem_vds = mem_vector_driver.CreateDataSource('out') mem_layer = mem_vds.CreateLayer('poly', crs, ogr.wkbPolygon) ft = ogr.Feature(mem_layer.GetLayerDefn()) ft.SetGeometry(ogr_geom) mem_layer.CreateFeature(ft) ft.Destroy() # Rasterize it rasterized_ds = mem_raster_driver.Create('', src_offset[2], src_offset[3], 1, gdal.GDT_Byte) rasterized_ds.SetGeoTransform(new_geo_transform) gdal.RasterizeLayer(rasterized_ds, [1], mem_layer, burn_values=[1]) rasterized_array = rasterized_ds.ReadAsArray() out_feat.setGeometry(geom) masked = numpy.ma.MaskedArray( src_array, mask=numpy.logical_or(src_array == self.no_data, numpy.logical_not(rasterized_array))) attrs = self.__zonal_stats(f, masked) out_feat.setAttributes(attrs) writer.addFeature(out_feat) del mem_vds del rasterized_ds progress = int(current * total) if progress != last_progress and progress % 10 == 0: self.logger.debug('{}%'.format(str(progress))) bar.setValue(progress) last_progress = progress if last_progress != 100: bar.setValue(100) bar.close() dlg.close() del dlg del writer del self.raster_ds end_time = datetime.now() time_elapsed = end_time - start_time str_end_time = end_time.strftime(self.pt_br_format) self.logger.info( 'Summing up, done at {}! Time elapsed {}(hh:mm:ss.ms)'.format( str_end_time, time_elapsed))
centroid_features[idx_side] = cell_feature #. write features cell_writer = VectorWriter(Output_layer, None, cell_fields, QGis.WKBPolygon, input_layer.crs()) for idx_side in xrange(DEFAULT_SEGS): cell_feature = centroid_features[idx_side] value = cell_feature.attributes()[3] linear_trans_value = (value - minVal) / (maxVal - minVal) adjusted_radius = linear_trans_value * radius if adjusted_radius > 0: from_deg = (idx_side * step_angle) - half_step to_deg = ((idx_side + 1) * step_angle) - half_step cell = create_cell(center_point, from_deg, to_deg, adjusted_radius) cell_feature.setGeometry(cell) cell_writer.addFeature(cell_feature) del cell_writer #. write anchor cell_fields = QgsFields() cell_fields.append(QgsField("distance", QVariant.Double)) cell_fields.append(QgsField("direction", QVariant.String)) anchor_writer = VectorWriter(Output_Anchor, None, cell_fields, QGis.WKBLineString, input_layer.crs()) radius_step = radius / 5 center = QgsGeometry.fromPoint(center_point) for idx_side in xrange(5): buffer_radius = radius_step * (idx_side + 1) anchor_feature = QgsFeature(cell_fields)
outGeom = inGeom.centroid() if not inGeom.contains(outGeom): # weight point outside the polygon # find intersection of horizontal line through the weight pont rect = inGeom.boundingBox() horiz = QgsGeometry.fromPolyline([ QgsPoint(rect.xMinimum(), outGeom.asPoint()[1]), QgsPoint(rect.xMaximum(), outGeom.asPoint()[1]) ]) line = horiz.intersection(inGeom) if line.isMultipart(): # find longest intersection mline = line.asMultiPolyline() l = 0 for i in range(len(mline)): d = sqrt((mline[i][0][0] - mline[i][1][0])**2 + (mline[i][0][1] - mline[i][1][1])**2) if d > l: l = d xMid = (mline[i][0][0] + mline[i][1][0]) / 2.0 yMid = (mline[i][0][1] + mline[i][1][1]) / 2.0 else: xMid = (line.vertexAt(0).x() + line.vertexAt(1).x()) / 2.0 yMid = (line.vertexAt(0).y() + line.vertexAt(1).y()) / 2.0 outGeom = QgsGeometry.fromPoint(QgsPoint(xMid, yMid)) outFeat.setAttributes(atMap) outFeat.setGeometry(outGeom) outputLayer.addFeature(outFeat)
feat.setGeometry(QgsGeometry.fromPolyline([p1,p2])) feat.setAttributes([key[0],key[1],value]) lines.append(feat) return lines centroid_layer = processing.getObject(input_cell_centers) trajectory_layer = processing.getObject(input_trajectories) sg = SequenceGenerator(centroid_layer,trajectory_layer, weight_field if use_weight_field else None) fields = [QgsField('FROM', QVariant.Int), QgsField('TO', QVariant.Int), QgsField('COUNT', QVariant.Int)] geom_type = 2 writer = VectorWriter(flow_lines, None, fields, geom_type, centroid_layer.crs() ) for f in sg.create_flow_lines(): writer.addFeature(f) del writer fields = centroid_layer.fields() fields.append( QgsField('COUNT',QVariant.Int)) fields.append( QgsField('COUNT_Q1',QVariant.Int)) fields.append( QgsField('COUNT_Q2',QVariant.Int)) fields.append( QgsField('COUNT_Q3',QVariant.Int)) fields.append( QgsField('COUNT_Q4',QVariant.Int)) writer = VectorWriter(cell_counts, None, fields, 1, centroid_layer.crs() ) for key, value in sg.id_to_centroid.iteritems(): (in_feature, n) = value out_feature = QgsFeature() out_feature.setGeometry(in_feature.geometry()) attributes = in_feature.attributes() attributes.append(n[0])
try: for n, feat in enumerate(featuresa): geom = feat.geometry() attrs = feat.attributes() intersects = index.intersects(geom.boundingBox()) maxArea = -1 cat = None nintersects = len(intersects) for m, i in enumerate(intersects): progress.setPercentage((nprogress * n) + (nprogress * (m / float(nintersects)))) request = QgsFeatureRequest().setFilterFid(i) featb = layerb.getFeatures(request).next() tmpGeom = featb.geometry() if geom.intersects(tmpGeom): intGeom = geom.intersection(tmpGeom) if not intGeom: continue area = intGeom.area() if area > maxArea: maxArea = area cat = featb.attributes()[fieldIdx] outFeat.setGeometry(geom) attrs.append(cat) outFeat.setAttributes(attrs) writer.addFeature(outFeat) except Exception, e: raise GeoAlgorithmExecutionException(e.args[0]) del writer
class SelafinContour2Shp(QtCore.QObject): def __init__( self, processtype, #0 : thread inside qgis plugin) - 1 : thread processing - 2 : modeler (no thread) - 3 : modeler + shpouput - 4: outsideqgis selafinfilepath, #path to selafin file time, #time to process (selafin time in iteration) parameter, #parameter to process name (string) or id (int) facteurz=None, #z amplify azimuth=None, #azimuth for hillshade zenith=None, #zenith for hillshade selafincrs='EPSG:2154', #selafin crs translatex=0, translatey=0, selafintransformedcrs=None, #if no none, specify crs of output file outputshpname=None, #change generic outputname to specific one outputshppath=None, #if not none, create shp in this directory outputprocessing=None): #case of use in modeler QtCore.QObject.__init__(self) #donnees process self.processtype = processtype #donnes delafin self.parserhydrau = PostTelemacSelafinParser() self.parserhydrau.loadHydrauFile(os.path.normpath(selafinfilepath)) #slf = SELAFIN(os.path.normpath(selafinfilepath)) slf = self.parserhydrau.hydraufile """ self.slf_x = slf.MESHX self.slf_y = slf.MESHY self.slf_mesh = np.array(slf.IKLE3) """ #self.slf_x, self.slf_y = self.parserhydrau.getMesh() self.slf_x, self.slf_y = self.parserhydrau.getFacesNodes() self.slf_x = self.slf_x + translatex self.slf_y = self.slf_y + translatey #self.slf_mesh = np.array( self.parserhydrau.getIkle() ) self.slf_mesh = np.array(self.parserhydrau.getElemFaces()) #slf_time = [time,slf.tags["times"][time]] #slf_time = [time,slf.tags["times"][time]] slf_time = [time, self.parserhydrau.getTimes()[time]] #print('parameter',parameter) if parameter is not None: #self.slf_param = [parameter,slf.VARNAMES[parameter]] #self.slf_value = slf.getVALUES(slf_time[0])[self.slf_param[0]] #print('param',parameter, self.parserhydrau.getVarNames()) self.slf_param = [ parameter, self.parserhydrau.getVarNames()[parameter] ] self.slf_value = slf.getVALUES(slf_time[0])[self.slf_param[0]] else: self.slf_value = None #donnees shp champs = QgsFields() if self.slf_value is not None: self.facteurz_si_hillshade = facteurz self.azimuth_rad = float(azimuth) / 180.0 * math.pi self.zenith_rad = float(zenith) / 180.0 * math.pi champs.append(QgsField("slope", QVariant.Double)) champs.append(QgsField("aspect", QVariant.Double)) champs.append(QgsField("hillshade", QVariant.Double)) #donnees shp - outside qgis if not outputshpname: outputshpname = (os.path.basename( os.path.normpath(selafinfilepath)).split('.')[0] + "_mesh" + str('.shp')) else: outputshpname = (os.path.basename( os.path.normpath(selafinfilepath)).split('.')[0] + "_" + str(outputshpname) + str('.shp')) if not outputshppath: outputshppath = os.path.dirname(os.path.normpath(selafinfilepath)) self.outputshpfile = os.path.join(outputshppath, outputshpname) if isFileLocked(self.outputshpfile, True): self.raiseError( str(ctime()) + " - Initialisation - Erreur : \ Fichier shape deja charge !!") self.slf_crs = selafincrs if selafintransformedcrs: self.slf_shpcrs = selafintransformedcrs self.xform = QgsCoordinateTransform( QgsCoordinateReferenceSystem(str(self.slf_crs)), QgsCoordinateReferenceSystem(str(self.slf_shpcrs))) else: self.slf_shpcrs = self.slf_crs self.xform = None if self.processtype in [0, 1, 3, 4]: self.writerw_shp = QgsVectorFileWriter( self.outputshpfile, None, champs, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(self.slf_shpcrs), "ESRI Shapefile") #donnees shp - processing result try: if self.processtype in [2, 3]: self.writerw_process = VectorWriter( outputprocessing, None, champs, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(str(self.slf_shpcrs)), "ESRI Shapefile") except Exception as e: pass def get_slope_azi(self, geom, z1, z2, z3, facteurz_si_hillshade): zfactor = facteurz_si_hillshade p = [] p.append([geom.asPolygon()[0][0][0], geom.asPolygon()[0][0][1], z1]) p.append([geom.asPolygon()[0][1][0], geom.asPolygon()[0][1][1], z2]) p.append([geom.asPolygon()[0][2][0], geom.asPolygon()[0][2][1], z3]) a = [ p[1][0] - p[0][0], p[1][1] - p[0][1], zfactor * (p[1][2] - p[0][2]) ] b = [ p[2][0] - p[0][0], p[2][1] - p[0][1], zfactor * (p[2][2] - p[0][2]) ] norm = np.cross(a, b) slope = math.acos(norm[2] / np.linalg.norm(norm)) if slope != 0: asptemp = math.atan2(norm[1], norm[0]) if asptemp < 0: asptemp = asptemp + 2.0 * math.pi else: asptemp = math.pi / 2.0 return [slope, asptemp] def createShp(self): #******** Informations de lancement de la tache ***************************************************** fet = QgsFeature() strtxt = (str(ctime()) + ' - creation shapefile :' + '\n' + str(self.outputshpfile)) self.writeOutput(strtxt) nombre = len(self.slf_mesh) for i in range(len(self.slf_mesh)): if i % 5000 == 0: strtxt = (str(ctime()) + " - Thread element n " + str(i) + "/" + str(nombre)) self.writeOutput(strtxt) geom = [] geom.append( QgsPoint(self.slf_x[self.slf_mesh[i][0]], self.slf_y[self.slf_mesh[i][0]])) geom.append( QgsPoint(self.slf_x[self.slf_mesh[i][1]], self.slf_y[self.slf_mesh[i][1]])) geom.append( QgsPoint(self.slf_x[self.slf_mesh[i][2]], self.slf_y[self.slf_mesh[i][2]])) f1geom = QgsGeometry.fromPolygon([geom]) if self.xform: f1geom.transform(self.xform) fet.setGeometry(f1geom) if self.slf_value is not None: z1 = float(self.slf_value[self.slf_mesh[i][0]]) z2 = float(self.slf_value[self.slf_mesh[i][1]]) z3 = float(self.slf_value[self.slf_mesh[i][2]]) tab = self.get_slope_azi(f1geom, z1, z2, z3, self.facteurz_si_hillshade) Hillshade = max( 0, 255.0 * ((math.cos(self.zenith_rad) * math.cos(tab[0])) + (math.sin(self.zenith_rad) * math.sin(tab[0]) * math.cos(self.azimuth_rad - tab[1])))) fet.setAttributes([z1, z2, z3, tab[0], tab[1], Hillshade]) if self.slf_value is not None: fet.setAttributes([tab[0], tab[1], Hillshade]) if self.processtype in [0, 1, 3, 4]: self.writerw_shp.addFeature(fet) if self.processtype in [2, 3]: self.writerw_process.addFeature(fet) if self.processtype in [0, 1, 3, 4]: del self.writerw_shp if self.processtype in [2, 3]: del self.writerw_process #Emit finish if self.processtype in [0, 1]: self.finished.emit(self.outputshpfile) if self.processtype in [2, 3]: t = workerFinished(self.outputshpfile) if self.processtype in [4]: self.writeOutput('Process finished - ' + str(self.outputshpfile)) def verboseOutput(self, param, lvl, geomelem=None, geomtot=None, ileelem=None, iletot=None): strtxt = str(ctime()) + " - " + str(param) + " - lvl : " + str(lvl) if geomelem: strtxt = strtxt + " - geom : " + str(geomelem) + "/" + str(geomtot) if ileelem: strtxt = strtxt + " - ring : " + str(ileelem) + "/" + str(iletot) self.writeOutput(strtxt) def writeOutput(self, str1): if self.processtype in [0, 1, 2, 3]: self.status.emit(str(str1)) elif self.processtype == 4: print(str1) def raiseError(self, str1): self.error.emit(str(str1)) progress = QtCore.pyqtSignal(int) status = QtCore.pyqtSignal(str) error = QtCore.pyqtSignal(str) killed = QtCore.pyqtSignal() finished = QtCore.pyqtSignal(str)
funcExist = existNodeCheckFid populateListFidNode(fid, line, l_fid_node, funcExist) # Remove Exists nodes for id in reversed(xrange(len(l_fid_node))): if l_fid_node[id]['exists']: l_fid_node.pop(id) # Remove nodes with same FID line ids_remove = [] for id in xrange(len(l_fid_node) - 1): fid1, fid2 = l_fid_node[id]['fid'], l_fid_node[id + 1]['fid'] if fid1 == fid2: ids_remove.append(id) ids_remove.append(id + 1) ids_remove.reverse() for id in ids_remove: l_fid_node.pop(id) # Output fields = [QgsCore.QgsField("fid_line", QtCore.QVariant.Int)] lyrSource = VectorWriter(Nascentes, None, fields, QgsCore.QGis.WKBPoint, lyrRiver.crs()) for fn in l_fid_node: feat = QgsCore.QgsFeature() feat.setAttributes([fn['fid']]) feat.setGeometry(QgsCore.QgsGeometry.fromPoint(fn['node'])) lyrSource.addFeature(feat) del feat del lyrSource
def perform(self): geo_transform = self.raster_ds.GetGeoTransform() raster_b_box = self.__get_raster_b_box(geo_transform) raster_geom = QgsGeometry.fromRect(raster_b_box) crs = self.__create_spatial_reference() if self.use_global_extent: src_offset, src_array, new_geo_transform = self.__get_global_extent( raster_b_box, geo_transform) else: src_offset = None src_array = None new_geo_transform = None mem_vector_driver = ogr.GetDriverByName('Memory') mem_raster_driver = gdal.GetDriverByName('MEM') self.__populate_fields_operations() writer = VectorWriter(self.destination, None, self.fields.toList(), self.layer.wkbType(), self.layer.crs(), None) out_feat = QgsFeature() out_feat.initAttributes(len(self.fields)) out_feat.setFields(self.fields) features = vector.features(self.layer) total = 100.0 / len(features) if len(features) > 0 else 1 # _, bar = QtHandler.progress_dialog(label='Zonal Statistics...') # remove progress_previous = 0.0 for current, f in enumerate(features): geom = f.geometry() intersected_geom = raster_geom.intersection(geom) ogr_geom = ogr.CreateGeometryFromWkt( intersected_geom.exportToWkt()) if not self.use_global_extent: bbox = intersected_geom.boundingBox() x_min = bbox.xMinimum() x_max = bbox.xMaximum() y_min = bbox.yMinimum() y_max = bbox.yMaximum() (startColumn, startRow) = mapToPixel(x_min, y_max, geo_transform) (endColumn, endRow) = mapToPixel(x_max, y_min, geo_transform) width = endColumn - startColumn height = endRow - startRow if width == 0 or height == 0: continue src_offset = (startColumn, startRow, width, height) src_array = self.raster_band.ReadAsArray(*src_offset) src_array = src_array * self.scale + self.offset new_geo_transform = ( geo_transform[0] + src_offset[0] * geo_transform[1], geo_transform[1], 0.0, geo_transform[3] + src_offset[1] * geo_transform[5], 0.0, geo_transform[5], ) # Create a temporary vector layer in memory mem_vds = mem_vector_driver.CreateDataSource('out') mem_layer = mem_vds.CreateLayer('poly', crs, ogr.wkbPolygon) ft = ogr.Feature(mem_layer.GetLayerDefn()) ft.SetGeometry(ogr_geom) mem_layer.CreateFeature(ft) ft.Destroy() # Rasterize it rasterized_ds = mem_raster_driver.Create('', src_offset[2], src_offset[3], 1, gdal.GDT_Byte) rasterized_ds.SetGeoTransform(new_geo_transform) gdal.RasterizeLayer(rasterized_ds, [1], mem_layer, burn_values=[1]) rasterized_array = rasterized_ds.ReadAsArray() out_feat.setGeometry(geom) masked = numpy.ma.MaskedArray( src_array, mask=numpy.logical_or(src_array == self.no_data, numpy.logical_not(rasterized_array))) attrs = self.__zonal_stats(f, masked) out_feat.setAttributes(attrs) writer.addFeature(out_feat) mem_vds = None rasterized_ds = None progress = int(current * total) # bar.setValue(progress) if round(progress, 1) != round(progress_previous, 1): print(progress) progress_previous = progress raster_ds = None del writer
for idx_radius in xrange(ring_num): cell = create_ring_cell(center_point, from_deg, to_deg, default_radius, default_radius + radius_interval) cell_centroid_point = cell.centroid().asPoint() # find nearest feature & create anchor line if (idx_radius == 0): fids = spatial_index.nearestNeighbor(cell_centroid_point, 1) for fid in fids: nearest_feature = centroid_features[fid] nearest_point = nearest_feature.geometry().asPoint() anchor_feature = QgsFeature() anchor_feature.setGeometry(QgsGeometry.fromPolyline([nearest_point, cell_centroid_point])) anchor_feature.setAttributes(nearest_feature.attributes()) anchor_writer.addFeature(anchor_feature) spatial_index.deleteFeature(nearest_feature) # create and write ring feature ring_feature = QgsFeature(ring_fields) ring_feature.setGeometry(cell) ring_attributes = nearest_feature.attributes() ring_attributes.append(idx_radius + 1) # ring_num if (idx_fields[idx_radius] == -1): ring_attributes.append(0) # default value = 0 else: ring_attributes.append(ring_attributes[idx_fields[idx_radius]]) # ring_val ring_feature.setAttributes(ring_attributes) ring_writer.addFeature(ring_feature)
##[Example scripts]=group ##input=vector ##output=output vector from qgis.core import * from processing.tools.vector import VectorWriter vectorLayer = processing.getObject(input) provider = vectorLayer.dataProvider() writer = VectorWriter(output, None, provider.fields(), provider.geometryType(), vectorLayer.crs()) features = processing.features(vectorLayer) writer.addFeature(features.iter.next()) del writer
step = lyrIntermediate.featureCount( ) // dicSampleLength[index1][Nivel_de_Inspecao] module = randomNum % step progress.setInfo("Numero aleatorio: " + str(randomNum)) progress.setInfo('Amostra: ' + str(dicSampleLength[index1][Nivel_de_Inspecao])) progress.setInfo('Passo: ' + str(step)) progress.setInfo('Sorteado: ' + str(randomNum)) # Selecionando celulas da amostra progress.setInfo('Selecionando celulas da amostra...') listIds = range(featureCount) isSelectedId = [] x = 1 for i in listIds: if x <= sample_size: if (i) % step == module: isSelectedId.append(i) x += 1 for i, feat in enumerate(features): if i in isSelectedId: lyrOutput.addFeature(feat) del lyrOutput progress.setInfo('Numero de amostras selecionadas: ' + str(len(isSelectedId))) progress.setInfo('Alex Santos and Viviane Diniz') QMessageBox.about(None, "Amostragem aleatoria sistematica", "Unidades de amostragem criadas")
progress.setText("Individuazione dei vertici degli archi del grafo ...") for k, feature in enumerate(processing.features(linee_layer)): progress.setPercentage(int(100 * i / n)) i += 1 lista_vertici = feature.geometry().asPolyline() grafo_feature = QgsFeature() attributi = [feature.id()] grafo_feature.setGeometry(feature.geometry()) for campo, estremo in ({ 1: lista_vertici[0], 2: lista_vertici[-1] }).items(): id_nodo = aggiungi_nodo(estremo) attributi.append(id_nodo) grafo_feature.setAttributes(attributi) grafo_writer.addFeature(grafo_feature) i = 0 n = len(lista_nodi) progress.setText("Creazione dei nodi ...") for i, nodo in enumerate(lista_nodi): progress.setPercentage(int(100 * i / n)) nodo_feature = QgsFeature() nodo_feature.setAttributes([i]) nodo_feature.setGeometry(QgsGeometry.fromPoint(nodo)) nodi_writer.addFeature(nodo_feature) del nodi_writer del grafo_writer
##Centroids=name ##Geometry=group ##INPUT_LAYER=vector ##OUTPUT_LAYER=output vector from qgis.core import QgsWkbTypes, QgsGeometry from processing.tools.vector import VectorWriter from processing.tools import dataobjects layer = dataobjects.getLayerFromString(INPUT_LAYER) fields = layer.fields() writer = VectorWriter(OUTPUT_LAYER, 'utf-8', fields, QgsWkbTypes.Point, layer.crs()) features = processing.features(layer) count = len(features) if count == 0: raise GeoAlgorithmExecutionException('Input layer contains no features.') total = 100.0 / len(features) for count, f in enumerate(features): outputFeature = f if f.hasGeometry(): outputGeometry = f.geometry().centroid() outputFeature.setGeometry(outputGeometry) writer.addFeature(outputFeature) feedback.setProgress(int(count * total))
class Worker_pts(QtCore.QObject): def __init__(self, donnees_d_entree): QtCore.QObject.__init__(self) self.pathshp = donnees_d_entree['pathshp'] self.mesh = donnees_d_entree['mesh'] self.x = donnees_d_entree['x'] self.y = donnees_d_entree['y'] self.ztri = donnees_d_entree['ztri'] self.vlayer = "" self.pasespace = donnees_d_entree['pasdespace'] self.vitesse = '0' self.paramvalueX = donnees_d_entree['paramvalueX'] self.paramvalueY = donnees_d_entree['paramvalueY'] self.traitementarriereplan = donnees_d_entree['traitementarriereplan'] fields = donnees_d_entree['champs'] if self.paramvalueX != None: fields.append(QgsField("UV", QVariant.Double)) fields.append(QgsField("VV", QVariant.Double)) fields.append(QgsField("norme", QVariant.Double)) fields.append(QgsField("angle", QVariant.Double)) self.vitesse = '1' if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1 = QgsVectorFileWriter( self.pathshp, None, donnees_d_entree['champs'], QGis.WKBPoint, QgsCoordinateReferenceSystem(str(donnees_d_entree['crs'])), "ESRI Shapefile") if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2 = VectorWriter( donnees_d_entree['fichierdesortie_point'], None, donnees_d_entree['champs'], QGis.WKBMultiPoint, QgsCoordinateReferenceSystem(str(donnees_d_entree['crs']))) def run(self): strtxt = (str(ctime()) + ' - Thread - repertoire : ' + os.path.dirname(self.pathshp) + ' - fichier : ' + os.path.basename(self.pathshp)) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) fet = QgsFeature() try: if True: if self.paramvalueX == None: boolvitesse = False else: boolvitesse = True #------------------------------------- TRaitement de tous les points if self.pasespace == 0: noeudcount = len(self.x) strtxt = (str(ctime()) + " - Thread - Traitement des vitesses - " + str(noeudcount) + " noeuds") if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) for k in range(len(self.x)): if k % 5000 == 0: strtxt = (str(ctime()) + " - Thread - noeud n " + str(k) + "/" + str(noeudcount)) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit(int(100.0 * k / noeudcount)) else: progress.setPercentage( int(100.0 * k / noeudcount)) fet.setGeometry( QgsGeometry.fromPoint( QgsPoint(float(self.x[k]), float(self.y[k])))) tabattr = [] for l in range(len(self.ztri)): tabattr.append(float(self.ztri[l][k])) if boolvitesse: norme = ( (float(self.ztri[self.paramvalueX][k]))**2.0 + (float(self.ztri[self.paramvalueY][k]))** 2.0)**(0.5) atanUVVV = math.atan2( float(self.ztri[self.paramvalueY][k]), float(self.ztri[self.paramvalueX][k])) angle = atanUVVV / math.pi * 180.0 if angle < 0: angle = angle + 360 #angle YML #angle = atanUVVV*180.0/math.pi+min(atanUVVV,0)/atanUVVV*360.0 tabattr.append( float(self.ztri[self.paramvalueX][k])) tabattr.append( float(self.ztri[self.paramvalueY][k])) tabattr.append(norme) tabattr.append(angle) fet.setAttributes(tabattr) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1.addFeature(fet) if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2.addFeature(fet) #------------------------------------- Traitement du pas d'espace des points else: triangul = tri.Triangulation(self.x, self.y, self.mesh) lineartri = [] for i in range(len(self.ztri)): lineartri.append( tri.LinearTriInterpolator(triangul, self.ztri[i])) xmin = np.min(self.x) xmax = np.max(self.x) ymin = np.min(self.y) ymax = np.max(self.y) pasx = int((xmax - xmin) / self.pasespace) pasy = int((ymax - ymin) / self.pasespace) strtxt = ( str(ctime()) + " - Thread - Traitement des vitesses - pas d espace : " + str(self.pasespace) + "m - nombre de points : " + str(pasx) + "*" + str(pasy) + "=" + str(pasx * pasy)) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) compt = 0 for x2 in range(pasx): xtemp = float(xmin + x2 * self.pasespace) for y2 in range(pasy): compt = compt + 1 if (compt) % 5000 == 0: strtxt = (str(ctime()) + " - Thread - noeud n " + str(compt) + "/" + str(pasx * pasy)) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit( int(100.0 * compt / (pasy * pasx))) else: progress.setPercentage( int(100.0 * compt / (pasy * pasx))) ytemp = float(ymin + y2 * self.pasespace) fet.setGeometry( QgsGeometry.fromPoint(QgsPoint(xtemp, ytemp))) tabattr1 = [] if str(float(lineartri[0].__call__( xtemp, ytemp))) == 'nan': continue for j in range(len(lineartri)): tabattr1.append( float(lineartri[j].__call__(xtemp, ytemp))) if boolvitesse: VX = float( lineartri[self.paramvalueX].__call__( xtemp, ytemp)) VY = float( lineartri[self.paramvalueY].__call__( xtemp, ytemp)) norme = ((VX)**2.0 + (VY)**2.0)**(0.5) angle = math.atan2(VY, VX) / math.pi * 180.0 if angle < 0: angle = angle + 360 tabattr1.append(VX) tabattr1.append(VY) tabattr1.append(norme) tabattr1.append(angle) fet.setAttributes(tabattr1) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1.addFeature(fet) if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2.addFeature(fet) #del self.writerw except Exception, e: strtxt = (str(ctime()) + " ************ PROBLEME CALCUL DES VITESSES : " + str(e)) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit(int(100.0)) else: progress.setPercentage(int(100.0)) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: del self.writerw1 if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: del self.writerw2 strtxt = (str(ctime()) + " - Thread - fichier " + self.pathshp + " cree") if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) #self.status.emit("Fichier " + self.nomrept+ '\ '.strip()+ self.nomfilet + " cree") if self.traitementarriereplan == 0: self.finished.emit(self.pathshp) if self.traitementarriereplan == 2: t = workerFinished(self.pathshp)
resgeom = QgsGeometry() resfeat = QgsFeature() for feat in processing.features(polyLayer): progress.setPercentage(int(100 * l / n)) l += 1 g = loads(feat.geometry().asWkb()) if g.geom_type == 'MultiPolygon': resg = [ Polygon(p.exterior, [r for r in p.interiors if Polygon(r).area > Max_area]) for p in g ] else: resg = [ Polygon(g.exterior, [r for r in g.interiors if Polygon(r).area > Max_area]) ] resgeom = QgsGeometry().fromWkt(dumps(MultiPolygon(resg))) resfeat.setAttributes(feat.attributes()) resfeat.setGeometry(resgeom) writer.addFeature(resfeat) del writer
QGis.WKBMultiPolygon, polyPrder.crs()) for feat in processing.features(polyLayer): progress.setPercentage(int(100*l/n)) l+=1 geom = feat.geometry() if geom.isMultipart(): featres = feat geoms = geom.asGeometryCollection() geomlength = [(i, geoms[i].area()) for i in range(len(geoms))] geomlength.sort(key=itemgetter(1)) if To_keep == 1: featres.setGeometry(geoms[geomlength[-1][0]]) else: geomres = [geoms[i].asPolygon() for i,a in geomlength[-1 * To_keep]] featres.setGeometry(QgsGeometry.fromMultiPolygon(geomres)) writer.addFeature(featres) else: writer.addFeature(feat) del writer
maxarea = area inGeom = tmpGeom atMap = inFeat.attributes() if QGis.QGIS_VERSION > '2.4': outGeom = inGeom.pointOnSurface() else: outGeom = inGeom.centroid() if not inGeom.contains(outGeom): # weight point outside the polygon # find intersection of horizontal line through the weight pont rect = inGeom.boundingBox() horiz = QgsGeometry.fromPolyline([QgsPoint(rect.xMinimum(), outGeom.asPoint()[1]), QgsPoint(rect.xMaximum(), outGeom.asPoint()[1])]) line = horiz.intersection(inGeom) if line.isMultipart(): # find longest intersection mline = line.asMultiPolyline() l = 0 for i in range(len(mline)): d = sqrt((mline[i][0][0] - mline[i][1][0])**2 + (mline[i][0][1] - mline[i][1][1])**2) if d > l: l = d xMid = (mline[i][0][0] + mline[i][1][0]) / 2.0 yMid = (mline[i][0][1] + mline[i][1][1]) / 2.0 else: xMid = (line.vertexAt(0).x() + line.vertexAt(1).x()) / 2.0 yMid = (line.vertexAt(0).y() + line.vertexAt(1).y()) / 2.0 outGeom = QgsGeometry.fromPoint(QgsPoint(xMid, yMid)) outFeat.setAttributes(atMap) outFeat.setGeometry(outGeom) outputLayer.addFeature(outFeat)
fieldindex = vlayer.fieldNameIndex(fieldname) fields = vprovider.fields() fields.append(QgsField('NUM_FIELD', QVariant.Int)) layer_writer = VectorWriter(Equivalent_numerical_field_layer, None, fields, vprovider.geometryType(), vlayer.crs()) table_writer = TableWriter(Equivalent_numerical_field_table, None, [fieldname, 'num']) outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 classes = {} features = vector.features(vlayer) nFeat = len(features) for feature in features: progress.setPercentage(int(100 * nElement / nFeat)) nElement += 1 inGeom = feature.geometry() outFeat.setGeometry(inGeom) atMap = feature.attributes() clazz = atMap[fieldindex] if clazz not in classes: classes[clazz] = len(classes.keys()) table_writer.addRecord([clazz, classes[clazz]]) atMap.append(classes[clazz]) outFeat.setAttributes(atMap) layer_writer.addFeature(outFeat) del layer_writer del table_writer
points.append(pt) bbox = l.extent() grid = Grid(bbox, max_radius) print("Inserting {} points ...".format(len(points))) grid.insert_points(points) print("Redistributing {} points ...".format(len(points))) grid.redistribute_points(points) fields = [QgsField('GROUP', QVariant.Int)] geom_type = 1 # point writer_pts = VectorWriter(grouped_points, None, fields, geom_type, l.crs()) writer_centroids = VectorWriter(group_centroids, None, fields, geom_type, l.crs()) print("Writing {} groups ...".format(len(grid.resulting_groups))) for id, g in enumerate(grid.resulting_groups): fet2 = QgsFeature() fet2.setGeometry(QgsGeometry.fromPoint(g.centroid)) fet2.setAttributes([id]) writer_centroids.addFeature(fet2) for pt in g.points: fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPoint(pt)) fet.setAttributes([id]) writer_pts.addFeature(fet) del writer_pts del writer_centroids
input_layer.crs()) features = processing.features(input_layer) for feature in features: geometry = feature.geometry() # QgsGeometry nameVal = feature.attribute(Name_Field) uidVal = feature.attribute(UniqueId_Field) bbox, columns, rows = calculate_columns_rows(geometry.boundingBox(), width, height, Readjust_Center) tileID = 1 # Tile ID direction: upper left --> lower right for row in range(rows, 0, -1): ymax = bbox.yMinimum() + (height * row) for column in range(columns): xmin = bbox.xMinimum() + (width * column) bounds = QgsRectangle(xmin, ymax - height, xmin + width, ymax) polygon = QgsGeometry.fromRect(bounds) if geometry.disjoint(polygon): continue tile_feature = QgsFeature(tile_fields) tile_feature.setGeometry(polygon) #tile_feature.setAttributes([nameVal, uidVal, tileID]) tile_feature.setAttribute(Name_Field, nameVal) tile_feature.setAttribute(UniqueId_Field, uidVal) tile_feature.setAttribute(Tid_Field, tileID) writer.addFeature(tile_feature) tileID += 1 del writer
if nx.has_path(SG,source=fromId[1],target=toId[1]): hasPath = True pathStress = nx.shortest_path(SG,source=fromId[1],target=toId[1],weight='weight') progress.setInfo('Shortest constrained path: ' + str(pathStress)) #iterate roads and write features in the path for feat in processing.features(roads): if feat.attribute('id') in pathNoStress: newFeat = QgsFeature() newFeat.setGeometry(feat.geometry()) newFeat.initAttributes(4) newFeat.setAttribute(0,fromId[2]) newFeat.setAttribute(1,toId[2]) newFeat.setAttribute(2,feat.attribute('cost')) newFeat.setAttribute(3,'Not constrained') writer.addFeature( newFeat ) if hasPath: if feat.attribute('id') in pathStress: newFeat = QgsFeature() newFeat.setGeometry(feat.geometry()) newFeat.initAttributes(4) newFeat.setAttribute(0,fromId[2]) newFeat.setAttribute(1,toId[2]) newFeat.setAttribute(2,feat.attribute('cost')) newFeat.setAttribute(3,'Stress constrained') writer.addFeature( newFeat ) progress.setPercentage(int(100 * i / n)) del writer
class ClassificationDecisionTree: def createSample(self): ''' Input sample vector Create array from vector Output training (list(dict)) and class (list) ''' #Open layer sample layer_sample = processing.getObject(Vector_samples) #Get index fields idx_field_class = layer_sample.fieldNameIndex(Classes_field) #iniciar variaveis auxiliares self.classes=[] self.training=[] #Get names fields sample layer_features = layer_sample.getFeatures() fields = layer_sample.pendingFields() #Get names fields sample fields_names = [str(i.name()) for i in fields] #Remover field class fields_names.remove(Classes_field) #Loop about features sample for feat in layer_features: #Get values attibutes attributes = feat.attributes() #Remove values classes e add in variable v_class = attributes.pop(idx_field_class) #Append value class self.classes.append(v_class) #Create dict from attr atr = dict(zip(fields_names, attributes)) #Append in training self.training.append(atr) def createDatas(self): ''' Input datas vector Create array from vector Output datas (list(dict)) ''' #Open layer datas self.layer_datas = processing.getObject(Vector_datas) #iniciar variaveis auxiliares self.datas=[] #Get names fields sample features_datas = self.layer_datas.getFeatures() #Get fields vector datas fields = self.layer_datas.pendingFields() #Get names fields sample fields_names = [str(i.name()) for i in fields] #Loop features datas vector for feat in features_datas: #create datas from dict atr = dict(zip(fields_names, feat.attributes())) self.datas.append(atr) def classifierTree(self,Max_depth): ''' Create model tree Input training (list(dicy)), class (list) and datas (list(dict)) Output list with classification of Datas ''' #Create fit transform trans_train = vec.fit_transform(self.training).toarray() del(self.training) trans_datas = vec.fit_transform(self.datas).toarray() #Choose type classification clf = tree.DecisionTreeClassifier( max_depth = Max_depth) #Crate model classification tree modelTree = clf.fit(trans_train, self.classes) print 'max_n_classes, ', modelTree.tree_.max_n_classes print 'node_count: ', modelTree.tree_.node_count print 'min_density: ', modelTree.tree_.min_density print 'n_outputs: ', modelTree.tree_.n_outputs print 'n_features: ', modelTree.tree_.n_features print 'n__classes: ', modelTree.tree_.n_classes print 'n_samples: ', modelTree.tree_.n_samples del(trans_train) del(self.classes) #Apply model classification in Datas self.classificationDatas = modelTree.predict(trans_datas) with open("/home/ruiz/tree.dot", 'w') as f: f = tree.export_graphviz(modelTree, out_file=f) def writeClassification(self): #Create vector to write provider = self.layer_datas.dataProvider() #fields fields = provider.fields() fields=[i for i in fields] fields.append(QgsField("class", QVariant.Int)) #Create shape writer self.writer = VectorWriter(Output_classification, None, fields, provider.geometryType(), self.layer_datas.crs()) for i, feat in enumerate(self.layer_datas.getFeatures()): #Add features write fet = QgsFeature() fet.setGeometry(feat.geometry()) attrs=feat.attributes() attrs.append(int(self.classificationDatas[i])) fet.setAttributes(attrs) self.writer.addFeature(fet) del(self.writer)
# category - scatter plot quadrant - autocorrelation - interpretation # high-high - upper right (red) - positive - Cluster - "I'm high and my neighbors are high." # high-low - lower right (pink) - negative - Outlier - "I'm a high outlier among low neighbors." # low-low - lower left (med. blue) - positive - Cluster - "I'm low and my neighbors are low." # low-high - upper left (light blue) - negative - Outlier - "I'm a low outlier among high neighbors." # http://help.arcgis.com/en/arcgisdesktop/10.0/help/index.html#/What_is_a_z_score_What_is_a_p_value/005p00000006000000/ # z-score (Standard Deviations) | p-value (Probability) | Confidence level # < -1.65 or > +1.65 | < 0.10 | 90% # < -1.96 or > +1.96 | < 0.05 | 95% # < -2.58 or > +2.58 | < 0.01 | 99% sig_q = lm.q * (lm.p_sim <= 0.01) # could make significance level an option outFeat = QgsFeature() i = 0 for inFeat in processing.features(layer): inGeom = inFeat.geometry() outFeat.setGeometry(inGeom) attrs = inFeat.attributes() attrs.append(float(lm.p_sim[i])) attrs.append(float(lm.z_sim[i])) attrs.append(int(lm.q[i])) attrs.append(float(lm.Is[i])) attrs.append(int(sig_q[i])) outFeat.setAttributes(attrs) writer.addFeature(outFeat) i+=1 del writer
centroid_layer = processing.getObject(input_cell_centers) trajectory_layer = processing.getObject(input_trajectories) sg = SequenceGenerator(centroid_layer, trajectory_layer) fields = [ QgsField('FROM', QVariant.Int), QgsField('TO', QVariant.Int), QgsField('COUNT', QVariant.Int) ] geom_type = 2 writer = VectorWriter(flow_lines, None, fields, geom_type, centroid_layer.crs()) for f in sg.create_flow_lines(): writer.addFeature(f) del writer fields = centroid_layer.fields() fields.append(QgsField('COUNT', QVariant.Int)) fields.append(QgsField('COUNT_Q1', QVariant.Int)) fields.append(QgsField('COUNT_Q2', QVariant.Int)) fields.append(QgsField('COUNT_Q3', QVariant.Int)) fields.append(QgsField('COUNT_Q4', QVariant.Int)) writer = VectorWriter(cell_counts, None, fields, 1, centroid_layer.crs()) for key, value in sg.id_to_centroid.iteritems(): (in_feature, n) = value out_feature = QgsFeature() out_feature.setGeometry(in_feature.geometry()) attributes = in_feature.attributes() attributes.append(n[0])
Unique_id_field_name) # Create the vector layer layer = QgsVectorLayer(uri.uri(), 'vlayer', 'postgres') # Output the vector layer if layer.isValid(): # Create writer writer = VectorWriter(output, None, layer.dataProvider().fields(), layer.dataProvider().geometryType(), layer.crs()) # Export features features = layer.getFeatures() for feat in features: writer.addFeature(feat) del writer else: progress.setText( '<b>## The layer is invalid - Please check the connection parameters.</b>' ) try: conn = psycopg2.connect(database=Database, host="localhost", user="******", password="******") #conn = psycopg2.connect("dbname= osm host='localhost' user='******' password='******'") except:
else: polygon = geom.asPolygon() polygon_area = area.measurePolygon(polygon[0]) # calculated area is in sq. metres if units_selection == 'sq_km': final_area = polygon_area / 1e6 elif units_selection == 'sq_ft': final_area = area.convertMeasurement(polygon_area, QGis.Meters, QGis.Feet, True)[0] elif units_selection == 'sq_miles': final_area = area.convertMeasurement( polygon_area, QGis.Meters, QGis.Feet, True)[0] / (5280.0 * 5280.0) elif units_selection == 'sq_nm': final_area = area.convertMeasurement(polygon_area, QGis.Meters, QGis.NauticalMiles, True)[0] elif units_selection == 'sq_degrees': final_area = area.convertMeasurement(polygon_area, QGis.Meters, QGis.Degrees, True)[0] else: final_area = polygon_area attrs = feat.attributes() attrs.append(final_area) out_f.setGeometry(geom) out_f.setAttributes(attrs) writer.addFeature(out_f) progress.setPercentage(100) del writer
from qgis.networkanalysis import * # create the graph layer = processing.getObject('network_pgr') director = QgsLineVectorLayerDirector(layer,-1,'','','',3) director.addProperter(QgsDistanceArcProperter()) builder = QgsGraphBuilder(layer.crs()) from_point = QgsPoint(2.73343,3.00581) to_point = QgsPoint(0.483584,2.01487) tied_points = director.makeGraph(builder,[from_point,to_point]) graph = builder.graph() # compute the route from from_id to to_id from_id = graph.findVertex(tied_points[0]) to_id = graph.findVertex(tied_points[1]) (tree,cost) = QgsGraphAnalyzer.dijkstra(graph,from_id,0) # assemble the route route_points = [] curPos = to_id while (curPos != from_id): in_vertex = graph.arc(tree[curPos]).inVertex() route_points.append(graph.vertex(in_vertex).point()) curPos = graph.arc(tree[curPos]).outVertex() route_points.append(from_point) # write the results to a Shapefile result = 'C:\\temp\\route.shp' writer = VectorWriter(result,None,[],2,layer.crs()) fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPolyline(route_points)) writer.addFeature(fet) del writer processing.load(result)
class Worker_pts(QtCore.QObject): def __init__(self, donnees_d_entree): QtCore.QObject.__init__(self) self.pathshp = donnees_d_entree["pathshp"] self.mesh = donnees_d_entree["mesh"] self.x = donnees_d_entree["x"] self.y = donnees_d_entree["y"] self.ztri = donnees_d_entree["ztri"] self.vlayer = "" self.pasespace = donnees_d_entree["pasdespace"] self.vitesse = "0" self.paramvalueX = donnees_d_entree["paramvalueX"] self.paramvalueY = donnees_d_entree["paramvalueY"] self.traitementarriereplan = donnees_d_entree["traitementarriereplan"] fields = donnees_d_entree["champs"] if self.paramvalueX != None: fields.append(QgsField("UV", QVariant.Double)) fields.append(QgsField("VV", QVariant.Double)) fields.append(QgsField("norme", QVariant.Double)) fields.append(QgsField("angle", QVariant.Double)) self.vitesse = "1" if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1 = QgsVectorFileWriter( self.pathshp, None, donnees_d_entree["champs"], QGis.WKBPoint, QgsCoordinateReferenceSystem(str(donnees_d_entree["crs"])), "ESRI Shapefile", ) if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2 = VectorWriter( donnees_d_entree["fichierdesortie_point"], None, donnees_d_entree["champs"], QGis.WKBMultiPoint, QgsCoordinateReferenceSystem(str(donnees_d_entree["crs"])), ) def run(self): strtxt = ( str(ctime()) + " - Thread - repertoire : " + os.path.dirname(self.pathshp) + " - fichier : " + os.path.basename(self.pathshp) ) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) fet = QgsFeature() try: if True: if self.paramvalueX == None: boolvitesse = False else: boolvitesse = True # ------------------------------------- TRaitement de tous les points if self.pasespace == 0: noeudcount = len(self.x) strtxt = str(ctime()) + " - Thread - Traitement des vitesses - " + str(noeudcount) + " noeuds" if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) for k in range(len(self.x)): if k % 5000 == 0: strtxt = str(ctime()) + " - Thread - noeud n " + str(k) + "/" + str(noeudcount) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit(int(100.0 * k / noeudcount)) else: progress.setPercentage(int(100.0 * k / noeudcount)) fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(self.x[k]), float(self.y[k])))) tabattr = [] for l in range(len(self.ztri)): tabattr.append(float(self.ztri[l][k])) if boolvitesse: norme = ( (float(self.ztri[self.paramvalueX][k])) ** 2.0 + (float(self.ztri[self.paramvalueY][k])) ** 2.0 ) ** (0.5) atanUVVV = math.atan2( float(self.ztri[self.paramvalueY][k]), float(self.ztri[self.paramvalueX][k]) ) angle = atanUVVV / math.pi * 180.0 if angle < 0: angle = angle + 360 # angle YML # angle = atanUVVV*180.0/math.pi+min(atanUVVV,0)/atanUVVV*360.0 tabattr.append(float(self.ztri[self.paramvalueX][k])) tabattr.append(float(self.ztri[self.paramvalueY][k])) tabattr.append(norme) tabattr.append(angle) fet.setAttributes(tabattr) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1.addFeature(fet) if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2.addFeature(fet) # ------------------------------------- Traitement du pas d'espace des points else: triangul = tri.Triangulation(self.x, self.y, self.mesh) lineartri = [] for i in range(len(self.ztri)): lineartri.append(tri.LinearTriInterpolator(triangul, self.ztri[i])) xmin = np.min(self.x) xmax = np.max(self.x) ymin = np.min(self.y) ymax = np.max(self.y) pasx = int((xmax - xmin) / self.pasespace) pasy = int((ymax - ymin) / self.pasespace) strtxt = ( str(ctime()) + " - Thread - Traitement des vitesses - pas d espace : " + str(self.pasespace) + "m - nombre de points : " + str(pasx) + "*" + str(pasy) + "=" + str(pasx * pasy) ) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) compt = 0 for x2 in range(pasx): xtemp = float(xmin + x2 * self.pasespace) for y2 in range(pasy): compt = compt + 1 if (compt) % 5000 == 0: strtxt = str(ctime()) + " - Thread - noeud n " + str(compt) + "/" + str(pasx * pasy) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit(int(100.0 * compt / (pasy * pasx))) else: progress.setPercentage(int(100.0 * compt / (pasy * pasx))) ytemp = float(ymin + y2 * self.pasespace) fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(xtemp, ytemp))) tabattr1 = [] if str(float(lineartri[0].__call__(xtemp, ytemp))) == "nan": continue for j in range(len(lineartri)): tabattr1.append(float(lineartri[j].__call__(xtemp, ytemp))) if boolvitesse: VX = float(lineartri[self.paramvalueX].__call__(xtemp, ytemp)) VY = float(lineartri[self.paramvalueY].__call__(xtemp, ytemp)) norme = ((VX) ** 2.0 + (VY) ** 2.0) ** (0.5) angle = math.atan2(VY, VX) / math.pi * 180.0 if angle < 0: angle = angle + 360 tabattr1.append(VX) tabattr1.append(VY) tabattr1.append(norme) tabattr1.append(angle) fet.setAttributes(tabattr1) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: self.writerw1.addFeature(fet) if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: self.writerw2.addFeature(fet) # del self.writerw except Exception, e: strtxt = str(ctime()) + " ************ PROBLEME CALCUL DES VITESSES : " + str(e) if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) if self.traitementarriereplan == 0: self.progress.emit(int(100.0)) else: progress.setPercentage(int(100.0)) if self.traitementarriereplan == 0 or self.traitementarriereplan == 2: del self.writerw1 if self.traitementarriereplan == 1 or self.traitementarriereplan == 2: del self.writerw2 strtxt = str(ctime()) + " - Thread - fichier " + self.pathshp + " cree" if self.traitementarriereplan == 0: self.status.emit(strtxt) else: progress.setText(strtxt) # self.status.emit("Fichier " + self.nomrept+ '\ '.strip()+ self.nomfilet + " cree") if self.traitementarriereplan == 0: self.finished.emit(self.pathshp) if self.traitementarriereplan == 2: t = workerFinished(self.pathshp)