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