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 processAlgorithm(self, progress): """Here is where the processing itself takes place.""" # The first thing to do is retrieve the values of the parameters # entered by the user inputFilename1 = self.getParameterValue(self.INPUT_LAYER1) inputFilename2 = self.getParameterValue(self.INPUT_LAYER2) inputField1 = self.getParameterValue(self.INPUT_FIELD1) inputField2 = self.getParameterValue(self.INPUT_FIELD2) output = self.getOutputValue(self.OUTPUT_LAYER) if inputFilename1 is None: return # Input layers vales are always a string with its location. # That string can be converted into a QGIS object (a # QgsVectorLayer in this case) using the # processing.getObjectFromUri() method. vectorLayer1 = dataobjects.getObjectFromUri(inputFilename1) vectorLayer2 = dataobjects.getObjectFromUri(inputFilename2) settings = QSettings() systemEncoding = settings.value('/UI/encoding', 'System') fields = [QgsField('value', QVariant.Double)] writer = VectorWriter(output, systemEncoding, fields, QGis.WKBPoint, vectorLayer1.crs()) self.copyLayer(vectorLayer1, inputField1, writer) self.copyLayer(vectorLayer2, inputField2, writer) del writer
def getVectorWriter(self, fields, geomType, crs, options=None): """Returns a suitable writer to which features can be added as a result of the algorithm. Use this to transparently handle output values instead of creating your own method. Executing this method might modify the object, adding additional information to it, so the writer can be later accessed and processed within QGIS. It should be called just once, since a new call might result in previous data being replaced, thus rendering a previously obtained writer useless. @param fields a list of QgsField @param geomType a suitable geometry type, as it would be passed to a QgsVectorFileWriter constructor @param crs the crs of the layer to create @return writer instance of the vector writer class """ if self.encoding is None: settings = QSettings() self.encoding = settings.value('/Processing/encoding', 'System', str) w = VectorWriter(self.value, self.encoding, fields, geomType, crs, options) self.memoryLayer = w.memLayer return w
def clip_vectors(vao_layer, line_layer, plugin_name): dlg, bar = QtHandler.progress_dialog(label='Clipping Vectors...') params = __config[plugin_name] success = True new_features = [] lines = {} bar.setValue(20) writer = VectorWriter('memory:', None, vao_layer.pendingFields().toList(), QGis.WKBLineString, vao_layer.crs(), None) vl = writer.layer pr = writer.writer bar.setValue(30) vl.startEditing() for feat_line in line_layer.getFeatures(): key = int(feat_line[params['att_line_id']]) lines[key] = feat_line bar.setValue(40) for feat_vao in vao_layer.getFeatures(): idx = feat_vao.fieldNameIndex(params['att_vao_id']) attr = int(feat_vao.attributes()[idx]) attributes = feat_vao.attributes() try: line = lines[attr] geom = feat_vao.geometry() geom_line = line.geometry() fet = QgsFeature() fet.setGeometry(geom.intersection(geom_line)) fet.setAttributes(attributes) new_features.append(fet) except Exception as e: __logger.error(str(e)) bar.setValue(80) pr.addFeatures(new_features) vl.updateFields() vl.commitChanges() if len(new_features) > 0: QgsMapLayerRegistry.instance().addMapLayer(vl) bar.setValue(100) bar.close() dlg.close() del dlg __logger.info(u'All vectors clipped successfully.') return success, vl
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)
def buffering(plugin_name, progress, layer, destination='memory:', open_output_layer=True): dlg, bar = QtHandler.progress_dialog(label='Buffering...') name = layer.name() __logger.info(u'Buffering layer "{}"...'.format(name)) if not is_vector_layer(layer): __logger.warn( u'Layer "{}" is not QVectorLayer, got layer type {}'.format( name, layer.type())) return bar.setValue(10) writer = VectorWriter(destination, None, layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs(), None) bar.setValue(20) params = __config[plugin_name] __logger.info( u'Running buffering algorithm for "{}"...'.format(destination)) __logger.info(params['dissolve']) buff.buffering(progress, writer, params['distance'], None, False, layer, params['dissolve'], params['segments']) bar.setValue(60) output = writer.layer output_layer_name = u'{}_buffer'.format(name) if output: output.setName(output_layer_name) else: output = QgsVectorLayer(destination, output_layer_name, 'ogr') bar.setValue(80) if output.isValid(): if open_output_layer: QgsMapLayerRegistry.instance().addMapLayers([output]) __logger.info(u'Buffer created with success.') else: __logger.fatal(u'Layer created is invalid.') bar.setValue(100) bar.close() dlg.close() del dlg return output
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"])), )
##Vector table tools=group ##input=vector ##class_field=field input ##value_field=field input ##N_unique_values=output vector from qgis.PyQt.QtCore import QVariant from qgis.core import QgsFeature, QgsField from processing.tools.vector import VectorWriter layer = processing.getObject(input) provider = layer.dataProvider() fields = provider.fields() fields.append(QgsField('UNIQ_COUNT', QVariant.Int)) writer = VectorWriter(N_unique_values, None, fields, provider.geometryType(), layer.crs()) class_field_index = layer.fieldNameIndex(class_field) value_field_index = layer.fieldNameIndex(value_field) outFeat = QgsFeature() classes = {} feats = processing.features(layer) nFeat = len(feats) for n, inFeat in enumerate(feats): progress.setPercentage(int(100 * n / nFeat)) attrs = inFeat.attributes() clazz = attrs[class_field_index] value = attrs[value_field_index] if clazz not in classes: classes[clazz] = []
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException # check values distance_values = Comma_Seperated_Distance_Values.strip().split(',') if len(distance_values) == 0: raise GeoAlgorithmExecutionException( 'Comma seperated ditance values required!') # add distance field input_layer = processing.getObject(Input_Layer) provider = input_layer.dataProvider() output_fields = provider.fields() output_fields.append(QgsField('rind_dist', QVariant.Double)) # write features writer = VectorWriter(Output_Layer, None, output_fields, QGis.WKBPolygon, input_layer.crs()) features = processing.features(input_layer) for feature in features: geometry = feature.geometry() buffered = [] for index in range(len(distance_values)): rind_distance = float(distance_values[index]) buffered.append(geometry.buffer(rind_distance, 24)) #quadrant segments new_feature = QgsFeature() if Outside_Only == True and index > 0: new_feature.setGeometry(buffered[index].difference(buffered[index - 1])) else: new_feature.setGeometry(buffered[index])
# Output_Ring_Value_Field provider = input_layer.dataProvider() ring_fields = provider.fields() ring_fields.append(QgsField("ring_num", QVariant.Int)) ring_fields.append(QgsField(Output_Ring_Value_Field, QVariant.Double)) idx_fields = [] for idx in xrange(ring_num): if (use_ring_count): idx_fields.append(-1) else: idx_fields.append(ring_fields.indexFromName(input_fields[idx])) # create vector writer ring_writer = VectorWriter(Output_ring_maps, None, ring_fields, QGis.WKBPolygon, input_layer.crs()) anchor_writer = VectorWriter(Output_ring_anchor, None, provider.fields(), QGis.WKBLineString, input_layer.crs()) step_angle = 360.0 / feature_count half_step = step_angle / 2.0 for idx_side in xrange(feature_count): from_deg = half_step + (idx_side * step_angle) to_deg = half_step + ((idx_side + 1) * step_angle) default_radius = radius progress.setPercentage(int(100 * idx_side / feature_count)) for idx_radius in xrange(ring_num): cell = create_ring_cell(center_point, from_deg, to_deg, default_radius, default_radius + radius_interval)
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))
import psycopg2 # Create uri from database connection options uri = QgsDataSourceURI() uri.setConnection(Host, str(Port), Database, User, Password) uri.setDataSource(Schema, Table, Geometry_column, Where_clause, 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:
from PyQt4.QtCore import * from processing.tools.vector import VectorWriter from operator import itemgetter To_keep = int(To_keep) if To_keep < 1: progress.setText("At least 1 part to keep") To_keep = 1 polyLayer = processing.getObject(Polygons) polyPrder = polyLayer.dataProvider() n = polyLayer.featureCount() l = 0 writer = VectorWriter(Results, None, polyPrder.fields(), 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))]
if not input_layer.crs().geographicFlag(): raise GeoAlgorithmExecutionException( 'Your layer has a Projected CRS. ' 'This script works only on layers with Geographic CRS.') fields = QgsFields() for field in input_layer.pendingFields(): if field.name().lower() == new_field.lower(): raise GeoAlgorithmExecutionException( 'The input layer already has a field named %s.' 'Please choose a different name for the Area field.' % new_field) fields.append(field) fields.append(QgsField(new_field, QVariant.Double)) writer = VectorWriter(output, None, fields, QGis.WKBMultiPolygon, input_layer.crs()) # Initialize QgsDistanceArea object area = QgsDistanceArea() area.setEllipsoid(ellipsoid) area.setEllipsoidalMode(True) area.computeAreaInit() out_f = QgsFeature() # Get feature count for progress bar features = processing.features(input_layer) num_features = len(features) for i, feat in enumerate(features): progress.setPercentage(int(100 * i / num_features)) geom = feat.geometry()
from PyQt4.QtCore import * # np.random.seed(10) variable_field = variable_field[0:10] # try to handle Shapefile field length limit population_field = population_field[0:10] layer = processing.getObject(input) provider = layer.dataProvider() fields = provider.fields() fields.append(QgsField('MORANS_P', QVariant.Double)) fields.append(QgsField('MORANS_Z', QVariant.Double)) fields.append(QgsField('MORANS_Q', QVariant.Int)) fields.append(QgsField('MORANS_I', QVariant.Double)) fields.append(QgsField('MORANS_C', QVariant.Double)) writer = VectorWriter(morans_output, None,fields, provider.geometryType(), layer.crs() ) if contiguity == 'queen': print 'INFO: Local Moran\'s for rates using queen contiguity' w=pysal.queen_from_shapefile(input) else: print 'INFO: Local Moran\'s for rates using rook contiguity' w=pysal.rook_from_shapefile(input) f = pysal.open(pysal.examples.get_path(input.replace('.shp','.dbf'))) y=np.array(f.by_col[str(variable_field)]) population=np.array(f.by_col[str(population_field)]) lm = pysal.esda.moran.Moran_Local_Rate(y,population,w,transformation = "r", permutations = 999) # http://pysal.readthedocs.org/en/latest/library/esda/moran.html?highlight=local%20moran#pysal.esda.moran.Moran_Local # values indicate quadrat location 1 HH, 2 LH, 3 LL, 4 HL
if not input_layer.crs().geographicFlag(): raise GeoAlgorithmExecutionException( 'Your layer has a Projected CRS. ' 'This script works only on layers with Geographic CRS.') fields = QgsFields() for field in input_layer.pendingFields(): if field.name().lower() == new_field.lower(): raise GeoAlgorithmExecutionException( 'The input layer already has a field named %s.' 'Please choose a different name for the Area field.' % new_field) fields.append(field) fields.append(QgsField(new_field, QVariant.Double)) writer = VectorWriter(output, None, fields, QGis.WKBMultiPolygon, input_layer.crs()) # Initialize QgsDistanceArea object area = QgsDistanceArea() area.setEllipsoid(ellipsoid) area.setEllipsoidalMode(True) area.computeAreaInit() out_f = QgsFeature() # Get feature count for progress bar features = processing.features(input_layer) num_features = len(features) for i, feat in enumerate(features): progress.setPercentage(int(100 *i / num_features)) geom = feat.geometry()
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)
# Ignore fields with non-numeric values pass else: visitor.visit(1) # create and write ring feature cell_feature = QgsFeature(cell_fields) cell_feature.setGeometry(cell) ret = visitor.result() minVal = min(minVal, ret[3]); maxVal = max(maxVal, ret[3]); 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
(field_name in additional_attributes_tile_bound) or \ (field_name in additional_attributes_poly_bound): raise GeoAlgorithmExecutionException('Le champ {} existe deja, modifier le code du script ou la table'.format(field_name)) # ajout des attributs supplementaires for attr in additional_attributes: grid_fields.append(QgsField(attr, QVariant.Int)) for attr in additional_attributes_ord: grid_fields.append(QgsField(attr, QVariant.String)) for attr in additional_attributes_tile_bound: grid_fields.append(QgsField(attr, QVariant.Double)) for attr in additional_attributes_poly_bound: grid_fields.append(QgsField(attr, QVariant.Double)) # preparation de la couche grille vw_grid = VectorWriter(output, None, grid_fields, provider.geometryType(), layer.crs()) id_poly = 0 id_tile = 0 # pour tous les polygones for feature in feats: progress.setPercentage(int(100 * id_poly / nb_feats)) # get the feature bounding box bounding_geom = feature.geometry().boundingBox() min_x_poly = bounding_geom.xMinimum() max_x_poly = bounding_geom.xMaximum() min_y_poly = bounding_geom.yMinimum() max_y_poly = bounding_geom.yMaximum() buffer_geom = feature.geometry()
##[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
else: points = [] for g in geoms: for pt in g.asMultiPoint(): 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)
import psycopg2 # Create uri from database connection options uri = QgsDataSourceURI() uri.setConnection(Host, str(Port), Database, User, Password) uri.setDataSource(Schema, Table, Geometry_column, Where_clause, 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(inputPointLayer, 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:
#iterate features and add edges progress.setText('Building unconstrained network') feats = processing.features(network) n = len(feats) for i, feat in enumerate(feats): DG.add_edge(feat['id_from'],feat['id_to'],weight=feat['cost'],stress=feat['stress']) progress.setPercentage(int(100 * i / n)) #create subgraph using stress tolerance progress.setText('Building stress-constrained network') SG = nx.DiGraph( [ (u,v,d) for u,v,d in DG.edges(data=True) if d['stress'] <= Maximum_stress ] ) #set up the roads provider for copying roads provider = roads.dataProvider() writer = VectorWriter(Output_paths, None, [QgsField("orig", QVariant.String),QgsField("dest",QVariant.String),QgsField("cost", QVariant.Int),QgsField("path_type", QVariant.String)], provider.geometryType(), provider.crs() ) #iterate destinations to get shortest paths destFeats = processing.features(destinations) destIds = [] for i, feat in enumerate(destFeats): destIds.append( (feat['road_id_unconstrained'], feat['road_id_constrained'], feat['name']) ) n = len(destIds) for i, fromId in enumerate(destIds): progress.setText('Getting shortest paths for ' + fromId[2]) for toId in destIds: if not fromId == toId: #get shortest path without stress constraints pathNoStress = nx.shortest_path(DG,source=fromId[0],target=toId[0],weight='weight') progress.setInfo('Shortest unconstrained path: ' + str(pathNoStress))
else: points = [] for g in geoms: for pt in g.asMultiPoint(): 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)
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)
""" origin_layer = l1 target_layer = l2 target_id_column_index = 0 interval = 1 """ target_spatial_index = QgsSpatialIndex() target_features = processing.getfeatures(target_layer) origin_fields = origin_layer.pendingFields().toList() origin_fields.append(QgsField("BEST_FIT", QVariant.Int)) origin_fields.append(QgsField("HAUSDORFF", QVariant.Double)) origin_fields.append(QgsField("LEN_DIFF", QVariant.Double)) writer = VectorWriter(output, None, origin_fields, origin_layer.dataProvider().geometryType(), origin_layer.crs()) outFeat = QgsFeature() # populate the spatial index for feat in target_features: target_spatial_index.insertFeature(feat) origin_features = processing.getfeatures(origin_layer) for origin_feature in origin_features: center = origin_feature.geometry().centroid().asPoint() print str(center) nearest_ids = target_spatial_index.nearestNeighbor(center, 10) best_fit_id = None
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)
# Output_Ring_Value_Field provider = input_layer.dataProvider() ring_fields = provider.fields() ring_fields.append(QgsField("ring_num", QVariant.Int)) ring_fields.append(QgsField(Output_Ring_Value_Field, QVariant.Double)) idx_fields = [] for idx in xrange(ring_num): if (use_ring_count): idx_fields.append(-1) else: idx_fields.append(ring_fields.indexFromName(input_fields[idx])) # create vector writer ring_writer = VectorWriter(Output_ring_maps, None, ring_fields, QGis.WKBPolygon, input_layer.crs()) anchor_writer = VectorWriter(Output_ring_anchor, None, provider.fields(), QGis.WKBLineString, input_layer.crs()) step_angle = 360.0 / feature_count half_step = step_angle / 2.0 for idx_side in xrange(feature_count): from_deg = half_step + (idx_side * step_angle) to_deg = half_step + ((idx_side + 1) * step_angle) default_radius = radius progress.setPercentage(int(100 * idx_side / feature_count)) 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()
from datetime import datetime gmaps = googlemaps.Client(key='AIzaSyCzGi0sPXvbF-XpVugMWxC90c1sjx-QaQo') # Create uri from database connection options uri = QgsDataSourceURI() uri.setConnection(Host, str(Port), Database, User, Password) uri.setDataSource(Schema, Table, Geometry_column, Where_clause, 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(inputRoutingLayer, 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:
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
##[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
150001: [315, 800, 1250], 500001: [500, 1250, 2000] } xmin, ymin, xmax, ymax = lyrInput.extent().toRectF().getCoords() gridWidth = Tamanho_da_celula_da_grade gridHeight = Tamanho_da_celula_da_grade rows = ceil((ymax - ymin) / gridHeight) cols = ceil((xmax - xmin) / gridWidth) ringXleftOrigin = xmin ringXrightOrigin = xmin + gridWidth ringYtopOrigin = ymax ringYbottomOrigin = ymax - gridHeight fields = [QgsCore.QgsField("id", QtCore.QVariant.Int)] lyrOutput = VectorWriter(Areas_de_Inspecao, None, fields, QgsCore.QGis.WKBPolygon, lyrInput.crs()) lyrIntermediate = QgsCore.QgsVectorLayer("Polygon", "temporary_polygons", "memory") lyrIntermediate.setCrs(lyrInput.crs()) id = 1 progress.setInfo("Gerando grade de cobertura da camada...") progress.setInfo("Numero de linhas: " + str(rows)) progress.setInfo("Numero de colunas: " + str(cols)) for i in range(int(cols)): ringYtop = ringYtopOrigin ringYbottom = ringYbottomOrigin for j in range(int(rows)): points = [ QgsCore.QgsPoint(ringXleftOrigin, ringYtop),
##poly=vector ##output=output vector from qgis.core import * from qgis.core import * from qgis.utils import * from processing.tools.vector import VectorWriter from math import sqrt inputLayer = processing.getObject(poly) features = processing.features(inputLayer) fields = inputLayer.pendingFields().toList() outputLayer = VectorWriter(output, None, fields, QGis.WKBPoint, inputLayer.crs()) outFeat = QgsFeature() for inFeat in features: inGeom = inFeat.geometry() if inGeom.isMultipart(): # find largest part in case of multipart maxarea = 0 tmpGeom = QgsGeometry() for part in inGeom.asGeometryCollection(): area = part.area() if area > maxarea: tmpGeom = part maxarea = area inGeom = tmpGeom atMap = inFeat.attributes() if QGis.QGIS_VERSION > '2.4': outGeom = inGeom.pointOnSurface() else: outGeom = inGeom.centroid()
##Results=output vector from qgis.core import * from PyQt4.QtCore import * from processing.tools.vector import VectorWriter from shapely.geometry import Polygon, MultiPolygon from shapely.wkb import loads from shapely.wkt import dumps polyLayer = processing.getObject(Polygons) polyPrder = polyLayer.dataProvider() n = polyLayer.featureCount() 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]
##Vector table tools=group ##input=vector ##class_field=field input ##value_field=field input ##N_unique_values=output vector from qgis.PyQt.QtCore import QVariant from qgis.core import QgsFeature, QgsField from processing.tools.vector import VectorWriter layer = processing.getObject(input) fields = layer.fields() fields.append(QgsField('UNIQ_COUNT', QVariant.Int)) writer = VectorWriter(N_unique_values, None, fields, layer.wkbType(), layer.crs()) class_field_index = layer.fields().lookupField(class_field) value_field_index = layer.fields().lookupField(value_field) outFeat = QgsFeature() classes = {} feats = processing.features(layer) nFeat = len(feats) for n, inFeat in enumerate(feats): progress.setPercentage(int(100 * n / nFeat)) attrs = inFeat.attributes() clazz = attrs[class_field_index] value = attrs[value_field_index] if clazz not in classes: classes[clazz] = [] if value not in classes[clazz]:
##Distance lines between points=name ##Vector=group ##pointLayer=vector ##outputLayer=output vector from qgis.core import * from PyQt4.QtCore import * from processing.tools.vector import VectorWriter inputLayer = processing.getObject(pointLayer) # create new layer for output: fields = [QgsField('distance', QVariant.Double)] writer = VectorWriter(outputLayer, None, fields, QGis.WKBLineString, inputLayer.crs()) # loop all points: iter1 = inputLayer.getFeatures() for feature1 in iter1: p1 = feature1.geometry().asPoint() # loop all points again: iter2 = inputLayer.getFeatures() for feature2 in iter2: # check this to prevent creating double (reversed) lines: if feature1.id() < feature2.id(): # create new line feature: p2 = feature2.geometry().asPoint() l = QgsGeometry.fromPolyline([p1, p2]) feat = QgsFeature() feat.setGeometry(l) feat.setAttributes([l.length()]) writer.addFeature(feat) del writer
* * ***************************************************************************/ """ ##[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
##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))
##Real centroid=name ##Vector=group ##poly=vector ##output=output vector from qgis.core import * from qgis.core import * from qgis.utils import * from processing.tools.vector import VectorWriter from math import sqrt inputLayer = processing.getObject(poly) features = processing.features(inputLayer) fields = inputLayer.pendingFields().toList() outputLayer = VectorWriter(output, None, fields, QGis.WKBPoint, inputLayer.crs()) outFeat = QgsFeature() for inFeat in features: inGeom = inFeat.geometry() if inGeom.isMultipart(): # find largest part in case of multipart maxarea = 0 tmpGeom = QgsGeometry() for part in inGeom.asGeometryCollection(): area = part.area() if area > maxarea: tmpGeom = part maxarea = area inGeom = tmpGeom atMap = inFeat.attributes() if QGis.QGIS_VERSION > '2.4': outGeom = inGeom.pointOnSurface()
##output=output vector from PyQt4.QtCore import QVariant from qgis.core import * from processing.tools.vector import VectorWriter 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)
fields.append(QgsField(createUniqueFieldName("MIN", fields), QVariant.Int)) fields.append(QgsField(createUniqueFieldName("MIN_P", fields), QVariant.Double)) outFeat = QgsFeature() features = processing.features(polygon_layer) n = len(features) # get all unique raster values values = [] for stats in frequency_analysis.itervalues(): freq = stats["freq"] values = values + [v for (v, f) in freq.iteritems()] values = sorted(list(set(values))) print values layer_writer = VectorWriter(Frequency_analysis_layer, None, fields, provider.geometryType(), polygon_layer.crs()) table_writer = TableWriter(Frequency_analysis_table, None, [id_field, "majority"] + ["value: %d" % v for v in values]) for i, feat in enumerate(features): progress.setPercentage(int(100 * i / n)) fid = feat.id() stats = frequency_analysis[fid] count = stats["count"] freq = stats["freq"] if count == 0: majority = 0 minority = 0 majority_p = 0 minority_p = 0 else:
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)
# export to shapefiles provider = layer.dataProvider() new_fields = provider.fields() if Include_gid_column == False: new_fields = QgsFields() for field in provider.fields(): if (field.name().lower() <> 'gid'): new_fields.append(field) # remap fields idx_fields = [] for field in new_fields: idx_fields.append(layer.fieldNameIndex(field.name())) writer = VectorWriter(output_path, None, new_fields, provider.geometryType(), layer.crs()) features = processing.features(layer) for feature in features: new_feature = QgsFeature() new_feature.setGeometry(feature.geometry()) if Include_gid_column: new_feature.setAttributes(feature.attributes()) else: new_attributes = [] for idx in idx_fields: new_attributes.append(feature.attributes()[idx]) new_feature.setAttributes(new_attributes) writer.addFeature(new_feature) del writer
# Create uri from database connection options uri = QgsDataSourceURI() uri.setConnection(Host, str(Port), Database, User, Password) uri.setDataSource(Schema, Table, Geometry_column, Where_clause, 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:
from processing.tools import vector from processing.tools.vector import VectorWriter from processing.core.GeoAlgorithmExecutionException import * layera = processing.getObject(layera) layerb = processing.getObject(layerb) providera = layera.dataProvider() fieldsa = providera.fields() providerb = layerb.dataProvider() fieldsb = providerb.fields() fieldIdx = layerb.fieldNameIndex(category) fields =[] fields.extend(fieldsa) fields.append(QgsField(vector.createUniqueFieldName('MAJ', fieldsa), fieldsb.field(category).type())) writer = VectorWriter(output, None, fields, QGis.WKBMultiPolygon, layera.crs()) outFeat = QgsFeature() index = vector.spatialindex(layerb) featuresa = list(layera.getFeatures()) nfeat = len(featuresa) nprogress = 1 / float(nfeat) * 100 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))))
def start( 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 interation if int, or second if str) spacestep, #space step computevelocity, #bool for comuting velocity paramvx, paramvy, ztri, #tab of values selafincrs, #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): #needed for toolbox processing #Check validity self.processtype = processtype try: #slf = SELAFIN(os.path.normpath(selafinfilepath)) parserhydrau = PostTelemacSelafinParser() parserhydrau.loadHydrauFile(os.path.normpath(selafinfilepath)) slf = parserhydrau.hydraufile except: self.raiseError('fichier selafin n existe pas') #check time #times = slf.tags["times"] times = parserhydrau.getTimes() if isinstance(time, int): #cas des plugins et scripts if not time in range(len(times)): self.raiseError( str(ctime()) + " Time non trouve dans " + str(times)) elif isinstance( time, str): #cas de la ligne de commande python - utilise time en s if time in times: time = list(times).index(int(time)) else: self.raiseError( str(ctime()) + " Time non trouve dans " + str(times)) #check velocity creation """ if parameter is not None: parameters=[str(slf.VARNAMES[i]).strip() for i in range(len(slf.VARNAMES))] if not parameter.isdigit(): if parameter in parameters: #self.slf_param = [parameters.index(parameter), parameter ] parameter = parameters.index(parameter) else: self.raiseError( str(parameter) + " parameter pas trouve dans "+str(parameters)) else : parameter = int(parameter) """ self.worker = SelafinContour2Pts( 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 interation if int, or second if str) spacestep, #space step computevelocity, #bool for comuting velocity paramvx, paramvy, ztri, #tab of values selafincrs, #selafin crs translatex=translatex, translatey=translatey, selafintransformedcrs= selafintransformedcrs, #if no none, specify crs of output file outputshpname= outputshpname, #change generic outputname to specific one outputshppath= outputshppath, #if not none, create shp in this directory outputprocessing=outputprocessing) #needed for toolbox processing if processtype in [0, 1]: self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.status.connect(self.writeOutput) self.worker.error.connect(self.raiseError) self.worker.finished.connect(self.workerFinished) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.finished.connect(self.thread.quit) champ = QgsFields() if processtype in [1]: writercontour = VectorWriter( outputprocessing, None, champ, QGis.WKBMultiPolygon, QgsCoordinateReferenceSystem(str(selafincrs))) self.thread.start() else: self.worker.createShp()
selected_count = len(selected_layers) 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
def main1(self): progress.setPercentage(0) progress.setText(str(ctime()) + " - Initialisation - Debut du script") #Chargement du fichier .res**************************************** slf = SELAFIN(self.donnees_d_entree['pathselafin']) #Recherche du temps a traiter *********************************************** test = False for i, time in enumerate(slf.tags["times"]): progress.setText( str(ctime()) + " - Initialisation - Temps present dans le fichier : " + str(np.float64(time))) #print str(i) +" "+ str(time) + str(type(time)) if float(time) == float(self.donnees_d_entree['temps']): test = True values = slf.getVALUES(i) if test: progress.setText( str(ctime()) + " - Initialisation - Temps traite : " + str(np.float64(self.donnees_d_entree['temps']))) else: raise GeoAlgorithmExecutionException( str(ctime()) + " - Initialisation - Erreur : \ Temps non trouve") #Recherche de la variable a traiter **************************************** test = [False, False] tabparam = [] donnees_d_entree['champs'] = QgsFields() for i, name in enumerate(slf.VARNAMES): progress.setText( str(ctime()) + " - Initialisation - Variable dans le fichier res : " + name.strip()) tabparam.append([i, name.strip()]) donnees_d_entree['champs'].append( QgsField( str(name.strip()).translate(None, "?,!.;"), QVariant.Double)) if self.donnees_d_entree['Parametre_vitesse_X'] != None: if str(name).strip( ) == self.donnees_d_entree['Parametre_vitesse_X'].strip(): test[0] = True self.donnees_d_entree['paramvalueX'] = i if str(name).strip( ) == self.donnees_d_entree['Parametre_vitesse_Y'].strip(): test[1] = True self.donnees_d_entree['paramvalueY'] = i else: self.donnees_d_entree['paramvalueX'] = None self.donnees_d_entree['paramvalueY'] = None if self.donnees_d_entree['Parametre_vitesse_X'] != None: if test == [True, True]: progress.setText( str(ctime()) + " - Initialisation - Parametre trouvee : " + str(tabparam[self.donnees_d_entree['paramvalueX']] [1]).strip() + " " + str(tabparam[ self.donnees_d_entree['paramvalueY']][1]).strip()) else: raise GeoAlgorithmExecutionException( str(ctime()) + " - Initialisation - Erreur : \ Parametre vitesse non trouve") #Chargement de la topologie du .res ******************************************** self.donnees_d_entree['mesh'] = np.array(slf.IKLE3) self.donnees_d_entree['x'] = slf.MESHX self.donnees_d_entree['y'] = slf.MESHY #Verifie que le shp n existe pas if isFileLocked(self.donnees_d_entree['pathshp'], True): raise GeoAlgorithmExecutionException( str(ctime()) + " - Initialisation - Erreur :\ Fichier shape deja charge !!") #Chargement des donnees *********************************** self.donnees_d_entree['ztri'] = [] for i in range(len(tabparam)): self.donnees_d_entree['ztri'].append(values[i]) #Lancement du thread ************************************************************************************** self.worker = Worker(donnees_d_entree) if donnees_d_entree['traitementarriereplan'] == 0: self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.progress.connect(progress.setPercentage) self.worker.status.connect(progress.setText) self.worker.finished.connect(workerFinished) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.finished.connect(self.thread.quit) champ = QgsFields() writercontour = VectorWriter( self.donnees_d_entree['fichierdesortie_point'], None, champ, QGis.WKBMultiPoint, QgsCoordinateReferenceSystem(str( self.donnees_d_entree['crs']))) self.thread.start() else: self.worker.run()
##Max_area=number 100000 ##Results=output vector from qgis.core import * from PyQt4.QtCore import * from processing.tools.vector import VectorWriter from shapely.geometry import Polygon, MultiPolygon from shapely.wkb import loads from shapely.wkt import dumps polyLayer = processing.getObject(Polygons) polyPrder = polyLayer.dataProvider() n = polyLayer.featureCount() 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
p2 = self.id_to_centroid[key[1]][0].geometry().asPoint() feat = QgsFeature() 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())