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())
