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 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 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 __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)
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]:
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])
"""
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
##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 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)
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 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()
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
##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
# 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:
##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)
##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
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),
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)
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()
##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()
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:
# 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
# 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)
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:
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))
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()
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: