def runProcessinAlg(self, layer):
"""
Runs the actual grass process
"""
alg = 'grass7:v.clean.advanced'
#setting tools
tools = 'rmsa,break,rmdupl,rmdangle'
threshold = -1
#getting table extent (bounding box)
extent = layer.extent()
(xmin, xmax, ymin, ymax) = extent.xMinimum(), extent.xMaximum(
), extent.yMinimum(), extent.yMaximum()
extent = '{0},{1},{2},{3}'.format(xmin, xmax, ymin, ymax)
snap = self.parameters['Snap']
minArea = self.parameters['MinArea']
ret = processing.runalg(alg, layer, tools, threshold, extent, snap,
minArea, None, None)
if not ret:
raise Exception(
self.
tr('Problem executing grass7:v.clean.advanced. Check your installed libs.\n'
))
#updating original layer
outputLayer = processing.getObject(ret['output'])
#getting error flags
errorLayer = processing.getObject(ret['error'])
return self.getProcessingErrors(errorLayer), outputLayer
def processAlgorithm(self, progress):
filename = self.getParameterValue(self.LAYERNAME)
layer = processing.getObject(filename)
oldSelection = set(layer.selectedFeaturesIds())
method = self.getParameterValue(self.METHOD)
# Build QGIS request with expression
expression = self.getParameterValue(self.EXPRESSION)
qExp = QgsExpression(expression)
if not qExp.hasParserError():
qReq = QgsFeatureRequest(qExp)
else:
raise GeoAlgorithmExecutionException(qExp.parserErrorString())
selected = [f.id() for f in layer.getFeatures(qReq)]
if method == 1:
selected = list(oldSelection.union(selected))
elif method == 2:
selected = list(oldSelection.difference(selected))
# Set the selection
layer.setSelectedFeatures(selected)
self.setOutputValue(self.RESULT, filename)
def createVrt(inventario, vrt):
#Camada de inventario
layer = processing.getObject(Inventario)
count = 0
size = layer.featureCount()
p = 0
progress.setPercentage(p)
rasterList = []
for feature in layer.getFeatures():
filename = feature['fileName']
raster = QgsRasterLayer(filename, filename)
if Override_CRS:
raster.setCrs(
QgsCoordinateReferenceSystem(
int(CRS.split(':')[-1]),
QgsCoordinateReferenceSystem.EpsgCrsId))
rasterList.append(raster)
ovr = filename + '.ovr'
if not os.path.isfile(ovr):
progress.setText('Fazendo Pirâmides...')
#('gdalogr:overviews', input, levels=8, clean=False, resampling_method=0(nearest), format=1(Gtiff .ovr))
processing.runalg('gdalogr:overviews', raster, '4 8 32 128', True,
0, 1)
if int(float(count) / size * 100) != p:
p = int(float(count) / size * 100)
progress.setPercentage(p)
count += 1
progress.setText('Fazendo raster virtual...')
processing.runalg('gdalogr:buildvirtualraster', rasterList, 0, False,
False, VRT)
def processAlgorithm(self, progress):
filename = self.getParameterValue(self.LAYERNAME)
layer = processing.getObject(filename)
oldSelection = set(layer.selectedFeaturesIds())
method = self.getParameterValue(self.METHOD)
# Build QGIS request with expression
expression = self.getParameterValue(self.EXPRESSION)
qExp = QgsExpression(expression)
if not qExp.hasParserError():
qReq = QgsFeatureRequest(qExp)
else:
raise GeoAlgorithmExecutionException(qExp.parserErrorString())
selected = [f.id() for f in layer.getFeatures(qReq)]
if method == 1:
selected = list(oldSelection.union(selected))
elif method == 2:
selected = list(oldSelection.difference(selected))
# Set the selection
layer.setSelectedFeatures(selected)
self.setOutputValue(self.RESULT, filename)
def capacity(self):
lstStnd_Capa = self.lst_capa()
tempdir = self.gettempdir()
entries = []
try:
for i in range(0, len(lstStnd_Capa)):
raster = lstStnd_Capa[i]
readRst = processing.getObject(raster)
ras1 = QgsRasterCalculatorEntry()
ras1.raster = readRst
ras1.ref = "capa_lyr" + str(i + 1) + "@1"
ras1.bandNumber = 1
entries.append(ras1)
formula = '((' + entries[0].ref + ' * ' + entries[
1].ref + ')^ 0.5)* 1000000'
readRst = QgsRasterLayer(lstStnd_Capa[0])
output = tempdir + "/Capacity.tif"
calc = QgsRasterCalculator(formula, output, 'GTiff',
readRst.extent(), readRst.width(),
readRst.height(), entries)
calc.processCalculation()
return output
except:
self.userWarning(
"Error in Create Adaptive Capacity map",
"Can not create Create Adaptive Capacity map, Exit")
def runPolygonize(self, cl, areaLyr, lineLyr):
"""
runs polygonize to generate coverage areas.
store the polygonize return in the memory area layer with the following attributes:
cl - original area class
"""
QgsMapLayerRegistry.instance().addMapLayer(lineLyr)
ret = processing.runalg('qgis:polygonize', lineLyr, False, True, None)
if not ret:
raise Exception(
self.
tr('Problem executing qgis:polygonize. Check your installed libs.\n'
))
#updating original layer
outputLayer = processing.getObject(ret['OUTPUT'])
addList = []
for feat in outputLayer.getFeatures():
newFeat = QgsFeature(areaLyr.pendingFields())
newFeat['cl'] = cl
area = feat.geometry()
area.convertToMultiType()
newFeat.setGeometry(area)
addList.append(newFeat)
areaLyr.dataProvider().addFeatures(addList)
#removing from registry
QgsMapLayerRegistry.instance().removeMapLayer(lineLyr.id())
def test_SagaVectorAlgorithWithUnsupportedInputAndOutputFormat(self):
"""This tests both the exporting to shp and then the format
change in the output layer.
"""
layer = processing.getObject(polygonsGeoJson())
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
outputs = processing.runalg('saga:polygoncentroids',
polygonsGeoJson(), True,
getTempFilename('geojson'))
layer.setSelectedFeatures([])
output = outputs['CENTROIDS']
layer = dataobjects.getObjectFromUri(output, True)
fields = layer.pendingFields()
expectednames = ['ID', 'POLY_NUM_A', 'POLY_ST_A']
expectedtypes = ['Real', 'Real', 'String']
names = [unicode(f.name()) for f in fields]
types = [unicode(f.typeName()) for f in fields]
self.assertEqual(expectednames, names)
self.assertEqual(expectedtypes, types)
features = processing.features(layer)
self.assertEqual(1, len(features))
feature = features.next()
attrs = feature.attributes()
expectedvalues = ['0', '1.1', 'string a']
values = [unicode(attr) for attr in attrs]
self.assertEqual(expectedvalues, values)
wkt = 'POINT(270787.49991451 4458955.46775295)'
self.assertEqual(wkt, unicode(feature.geometry().exportToWkt()))
def runProcessinAlg(self, layer):
"""
Runs the actual grass process
"""
alg = 'qgis:dissolve'
uri = QgsDataSourceURI(layer.dataProvider().dataSourceUri())
keyColumn = uri.keyColumn()
#field.type() != 6 stands for virtual columns such as area_otf
auxLayer = self.createUnifiedLayer(
[layer],
attributeTupple=True,
attributeBlackList=self.
parameters['AttributeBlackList (comma separated)'])
if self.parameters['MaxDissolveArea'] > 0:
auxLayer = self.addDissolveField(
auxLayer, self.parameters['MaxDissolveArea'])
ret = processing.runalg(alg, auxLayer, False, 'tupple', None)
if not ret:
raise Exception(
self.
tr('Problem executing qgis:dissolve. Check your installed libs.\n'
))
#updating original layer
outputLayer = processing.getObject(ret['OUTPUT'])
QgsMapLayerRegistry.instance().removeMapLayer(auxLayer.id())
self.splitUnifiedLayer(outputLayer, [layer])
return outputLayer
def createVrt(inventario, vrt):
#Camada de inventario
layer = processing.getObject(Inventario)
count = 0
size = layer.featureCount()
p = 0
progress.setPercentage(p)
rasterList = []
for feature in layer.getFeatures():
filename = feature['fileName']
raster = QgsRasterLayer(filename, filename)
if Override_CRS:
raster.setCrs( QgsCoordinateReferenceSystem(int(CRS.split(':')[-1]), QgsCoordinateReferenceSystem.EpsgCrsId) )
rasterList.append(raster)
ovr = filename+'.ovr'
if not os.path.isfile(ovr):
progress.setText('Fazendo Pirâmides...')
#('gdalogr:overviews', input, levels=8, clean=False, resampling_method=0(nearest), format=1(Gtiff .ovr))
processing.runalg('gdalogr:overviews', raster, '4 8 32 128', True, 0, 1)
if int(float(count)/size*100) != p:
p = int(float(count)/size*100)
progress.setPercentage(p)
count += 1
progress.setText('Fazendo raster virtual...')
processing.runalg('gdalogr:buildvirtualraster', rasterList, 0, False, False, VRT)
def getVectorLayerFieldValues(self,vectorLayer, fieldName):
"""
purpose:
return all field values for vector layer using qgis processing conveince function
notes:
takes into account feature selection
returns:
tuple of (message, list of values, boolean status)
"""
# convert attribute name to qgis object using processing convience method
inputLayer = processing.getObject(vectorLayer)
# convert attribute name to qgis object using processing convience method
values = []
# get index of polygon id
idx = inputLayer.fieldNameIndex(fieldName)
# get list of features. takes into account spatial selection
iter = processing.features(inputLayer)
# iterate over each feature and get attribute value wanted
for feature in iter:
values.append(feature.attributes()[idx])
# check values present
if len(values) == 0:
return ("no values for vector layer fieldname provided", None, False)
else:
return ("values present", values, True)
def test_SagaVectorAlgorithmWithSelection(self):
layer = processing.getObject(polygons2());
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
outputs=processing.runalg("saga:polygoncentroids",polygons2(),True,None)
layer.setSelectedFeatures([])
output=outputs['CENTROIDS']
layer=dataobjects.getObjectFromUri(output, True)
fields=layer.pendingFields()
expectednames=['ID','POLY_NUM_B','POLY_ST_B']
expectedtypes=['Real','Real','String']
names=[str(f.name()) for f in fields]
types=[str(f.typeName()) for f in fields]
self.assertEqual(expectednames, names)
self.assertEqual(expectedtypes, types)
features=processing.features(layer)
self.assertEqual(1, len(features))
feature=features.next()
attrs=feature.attributes()
expectedvalues=["2","1","string a"]
values=[str(attr) for attr in attrs]
self.assertEqual(expectedvalues, values)
wkt='POINT(270806.69221918 4458924.97720492)'
self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
def sum_second_impact_pop(self):
# Get temporary directory.
tempdir = self.gettempdir()
# Get layers already created in temporary directory.
first_area_list, second_area_list, first_pop_list, second_pop_list = self.pre_siam(
)
entries = []
for i in range(0, len(second_pop_list)):
raster = second_pop_list[i]
readRst = processing.getObject(str(raster))
ras1 = QgsRasterCalculatorEntry()
ras1.raster = readRst
ras1.ref = "second_impact_pop_" + str(i + 1) + "@1"
ras1.bandNumber = 1
entries.append(ras1)
reflist = " + ".join([ent.ref for ent in entries])
formula = '(' + reflist + ')'
readRst = QgsRasterLayer(second_pop_list[0])
sum_second_impact_pop = tempdir + "/sum_second_impact_pop.tif"
calc = QgsRasterCalculator(formula, sum_second_impact_pop, 'GTiff',
readRst.extent(), readRst.width(),
readRst.height(), entries)
calc.processCalculation()
return sum_second_impact_pop
def difference_saga(filename,
layer1,
layer2,
alg="saga:difference",
save=False):
'''
#This is a warpper-function for "difference"
'''
global OutputFile2
save_name = OutputFile2 + filename + ".shp"
if save == True:
if int(layer2.featureCount()) > 0:
processing.runalg(alg, layer1, layer2, 1, save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
else:
processing.runalg('saga:polygonclipping', layer1, layer1,
save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
else:
if int(layer2.featureCount()) > 0:
diff = processing.runalg('qgis:difference', layer1, layer2, True,
None)
else:
diff = processing.runalg('qgis:clip', layer1, layer1, None)
return processing.getObject(diff['OUTPUT'])
def runProcessinAlg(self, layer):
"""
Runs the actual grass process
"""
qgis_version = qgis.utils.QGis.QGIS_VERSION_INT
if qgis_version < 21800:
alg = 'grass7:v.generalize'
else:
alg = 'grass7:v.generalize.simplify'
#setting tools
tools = 'break,rmsa,rmdangle'
threshold = -1
#getting table extent (bounding box)
extent = layer.extent()
(xmin, xmax, ymin, ymax) = extent.xMinimum(), extent.xMaximum(), extent.yMinimum(), extent.yMaximum()
extent = '{0},{1},{2},{3}'.format(xmin, xmax, ymin, ymax)
tol = self.parameters['Tolerance']
snap = self.parameters['Snap']
minArea = self.parameters['MinArea']
if qgis_version < 21800:
ret = processing.runalg(alg, layer, 0, tol, 7, 50, 0.5, 3, 0, 0, 0, 1, 1, 1,False, True, extent, snap, minArea, 0, None)
else:
ret = processing.runalg(alg, layer, 0, tol, 7, 50, False, True, extent, snap, minArea, 0, None)
if not ret:
raise Exception(self.tr('Problem executing grass7:v.generalize.simplify. Check your installed libs.\n'))
#updating original layer
outputLayer = processing.getObject(ret['output'])
return outputLayer
def test_SagaVectorAlgorithmWithSelection(self):
layer = processing.getObject(polygons2())
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
outputs = processing.runalg('saga:polygoncentroids', polygons2(),
True, None)
layer.setSelectedFeatures([])
output = outputs['CENTROIDS']
layer = dataobjects.getObjectFromUri(output, True)
fields = layer.pendingFields()
expectednames = ['ID', 'POLY_NUM_B', 'POLY_ST_B']
expectedtypes = ['Real', 'Real', 'String']
names = [unicode(f.name()) for f in fields]
types = [unicode(f.typeName()) for f in fields]
self.assertEqual(expectednames, names)
self.assertEqual(expectedtypes, types)
features = processing.features(layer)
self.assertEqual(1, len(features))
feature = features.next()
attrs = feature.attributes()
expectedvalues = ['2', '1', 'string a']
values = [unicode(attr) for attr in attrs]
self.assertEqual(expectedvalues, values)
wkt = 'POINT(270806.69221918 4458924.97720492)'
self.assertEqual(wkt, unicode(feature.geometry().exportToWkt()))
def test_featuresWithSelection(self):
layer = processing.getObject(points())
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
features = processing.features(layer)
self.assertEqual(1, len(features))
layer.setSelectedFeatures([])
def test_attributeValues(self):
layer = processing.getObject(points())
attributeValues = values(layer, "ID")
i = 1
for value in attributeValues['ID']:
self.assertEqual(int(i), int(value))
i+=1
self.assertEquals(13,i)
def test_attributeValues(self):
layer = processing.getObject(points())
attributeValues = values(layer, 'ID')
i = 1
for value in attributeValues['ID']:
self.assertEqual(int(i), int(value))
i += 1
self.assertEquals(13, i)
def test_featuresWithSelection(self):
layer = processing.getObject(points())
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
features = processing.features(layer)
self.assertEqual(1, len(features))
layer.setSelectedFeatures([])
def checkSelectedLine(self):
print 'check if line layer selected'
line_layer = processing.getObject(str(self.uLineLayer.currentText()))
if line_layer:
if line_layer.selectedFeatureCount() != 0:
self.uSelectedLine.setCheckState(Qt.Checked)
else:
self.uSelectedLine.setCheckState(Qt.Unchecked)
def checkSelectedLine(self):
print 'check if line layer selected'
line_layer = processing.getObject(str(self.uLineLayer.currentText()))
if line_layer:
if line_layer.selectedFeatureCount() != 0:
self.uSelectedLine.setCheckState(Qt.Checked)
else:
self.uSelectedLine.setCheckState(Qt.Unchecked)
def makeCentroids(self, lyr, centroidLyr):
"""
Gets each polygon from lyr, calculates its centroid (inner point, not gravitational centroid) and stores it into the centroidLyr
"""
#run PointOnSurface
ret = processing.runalg("qgis:pointonsurface", lyr, None)
#load output lyr
outputLayer = processing.getObject(ret['OUTPUT_LAYER'])
self.updateOriginalLayerV2(centroidLyr, outputLayer)
def createSample(self):
'''
Input sample shapefile points
Create array from shapefile points
Output training (dict) and class (list)
'''
#Open layer sample
layer_sample = processing.getObject(Samples_points_cloud)
#Get index fields
self.idx_field_class = layer_sample.fieldNameIndex(Class_field)
#Get all fields
fields = layer_sample.pendingFields()
#Create list index fields
self.idx_fields_sample = [i for i in range(len(fields))]
print 'self.idx_field_class: ', self.idx_field_class, type(
self.idx_field_class)
self.idx_fields_sample.remove(self.idx_field_class)
print 'self.idx_fields_sample: ', self.idx_fields_sample, type(
self.idx_fields_sample)
#iniciar variaveis auxiliares
classes = []
training = []
#Iterando sobre a geometria
layer_features = layer_sample.getFeatures()
#Atribuir os fields em list
fields_sample = [
str(v.name()) for i, v in enumerate(fields)
if i in self.idx_fields_sample
]
if self.idx_field_class != -1:
#percorrer layer samples
for feat in layer_features:
#Obter atributos
attrs = feat.attributes()
#Criar array para as classes de amostras
classes.append(attrs[self.idx_field_class])
#criar array para os valores z,r,g e b
for i, v in enumerate(self.idx_fields_sample):
training.append(attrs[v])
self.clas = np.asarray(classes)
self.trein = np.asarray(training)
n_col = len(self.idx_fields_sample)
self.trein = self.trein.reshape(self.clas.shape[0], n_col)
print self.clas.shape[0], self.trein.shape, n_col
#Delete variables
del (classes)
del (training)
del (fields)
del (fields_sample)
else:
print 'Error create array'
def getExtent(extentRaster):
fileInfo = QFileInfo(extentRaster)
baseName = fileInfo.baseName()
rlayer = processing.getObject(extentRaster)
extent = rlayer.extent()
xmin = extent.xMinimum()
xmax = extent.xMaximum()
ymin = extent.yMinimum()
ymax = extent.yMaximum()
return "%f,%f,%f,%f"% (xmin, xmax, ymin, ymax)
def multi_single(filename, layer, alg="qgis:multiparttosingleparts", save=False):
global OutputFile
save_name = OutputFile + filename + ".shp"
if save == False:
result = processing.runalg(alg, layer, None)
return processing.getObject(result['OUTPUT'])
else:
processing.runalg(alg, layer, save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
def check_validty(layer1, alg="qgis:checkvalidity", method=0, save=False):
global OutputFile
save_name = OutputFile + filename + ".shp"
if save == False:
remove = processing.runalg(alg, layer1, method, None)
return processing.getObject(remove['OUTPUT_LAYER'])
else:
processing.runalg(alg, layer1, method, save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
def testRoundTripLines():
projectFile = os.path.join(os.path.dirname(__file__), "data", "testlines.qgs")
iface.addProject(projectFile)
layerA = processing.getObject("lines")
folder = tempfile.mkdtemp()
styles = mapboxgl.projectToMapbox(folder)
layerA2 =dataobjects.load(layerA.source(), "lines2")
mapboxgl.setLayerSymbologyFromMapboxStyle(layerA2, styles["layers"][0])
layerB2 =dataobjects.load(layerA.source(), "linesb2")
mapboxgl.setLayerSymbologyFromMapboxStyle(layerB2, styles["layers"][1])
layerC2 =dataobjects.load(layerA.source(), "linesc2")
mapboxgl.setLayerSymbologyFromMapboxStyle(layerC2, styles["layers"][2])
shutil.rmtree(folder, ignore_errors=True)
def VariavelDependente(self, lineEdit_2, lineEdit_4):
VarDepInput = str(
QFileDialog.getOpenFileNames(
self.dlg, "Selecionar um ficehiro raster",
"/Users/bsargento/Desktop/TesteVC/DADOS_BASE/",
"TIFF / BigTIFF / GeoTIFF (*.tif);;Arc/Info Binary Grid (*.adf)"
)[0])
if VarDepInput is not None:
VarDepLayerName = os.path.basename(VarDepInput).rsplit(".")[0]
InFileObject = processing.getObject(VarDepInput)
if InFileObject.type() == QgsMapLayer.RasterLayer:
lineEdit_2.setText(VarDepInput)
lineEdit_4.setText(VarDepLayerName)
def processAlgorithm(self, progress):
if ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED):
progress.setInfo("**********************************************************************\n"\
"WARNING: sDNA ignores your selection and will process the entire layer\n"\
"**********************************************************************")
args = {}
for outname,output in zip(self.outputnames,self.outputs):
if hasattr(output,"getCompatibleFileName"):
args[outname]=output.getCompatibleFileName(self)
elif hasattr(output,"getValueAsCommandLineParameter"):
args[outname]=output.getValueAsCommandLineParameter().replace('"','') # strip quotes - sdna adds them again
else:
assert False # don't know what to do with this output type
for vn in self.varnames:
args[vn]=self.getParameterValue(vn)
if vn in self.selectvaroptions:
args[vn] = self.selectvaroptions[vn][args[vn]]
if args[vn]==None:
args[vn]=""
syntax = self.sdnatool.getSyntax(args)
# convert inputs to shapefiles if necessary, renaming in syntax as appropriate
converted_inputs={}
for name,path in syntax["inputs"].iteritems():
if path:
# convert inputs to shapefiles if they aren't already shp or csv
# do this by hand rather than using dataobjects.exportVectorLayer(processing.getObject(path))
# as we want to ignore selection if present
if path[-4:].lower() not in [".shp",".csv"]:
progress.setInfo("Converting input to shapefile: "+path)
tempfile = system.getTempFilename("shp")
ret = QgsVectorFileWriter.writeAsVectorFormat(processing.getObject(path), tempfile, "utf-8", None, "ESRI Shapefile")
assert(ret == QgsVectorFileWriter.NoError)
converted_inputs[name]=tempfile
else:
converted_inputs[name]=path
syntax["inputs"]=converted_inputs
# figure out where the qgis python installation is
qgisbase = os.path.dirname(os.path.dirname(sys.executable))
pythonexe = qgisbase+os.sep+"bin"+os.sep+"python.exe"
pythonbase = qgisbase+os.sep+"apps"+os.sep+"python27"+os.sep
pythonpath = ";".join([pythonbase+x for x in ["","Lib","Lib/site-packages"]])
retval = self.provider.runsdnacommand(syntax,self.provider.sdnapath,progress,pythonexe,pythonpath)
if retval!=0:
progress.setInfo("ERROR: PROCESS DID NOT COMPLETE SUCCESSFULLY")
def createSample(self):
'''
Input sample shapefile points
Create array from shapefile points
Output training (dict) and class (list)
'''
#Open layer sample
layer_sample = processing.getObject(Samples_points_cloud)
#Get index fields
self.idx_field_class = layer_sample.fieldNameIndex(Class_field)
#Get all fields
fields = layer_sample.pendingFields()
#Create list index fields
self.idx_fields_sample = [i for i in range(len(fields))]
print 'self.idx_field_class: ',self.idx_field_class, type(self.idx_field_class)
self.idx_fields_sample.remove(self.idx_field_class)
print 'self.idx_fields_sample: ',self.idx_fields_sample,type(self.idx_fields_sample)
#iniciar variaveis auxiliares
classes=[]
training=[]
#Iterando sobre a geometria
layer_features = layer_sample.getFeatures()
#Atribuir os fields em list
fields_sample = [str(v.name ()) for i, v in enumerate(fields) if i in self.idx_fields_sample]
if self.idx_field_class != -1:
#percorrer layer samples
for feat in layer_features:
#Obter atributos
attrs = feat.attributes()
#Criar array para as classes de amostras
classes.append(attrs[self.idx_field_class])
#criar array para os valores z,r,g e b
for i, v in enumerate(self.idx_fields_sample):
training.append(attrs[v])
self.clas = np.asarray(classes)
self.trein = np.asarray(training)
n_col = len(self.idx_fields_sample)
self.trein=self.trein.reshape(self.clas.shape[0],n_col )
print self.clas.shape[0], self.trein.shape,n_col
#Delete variables
del(classes)
del(training)
del(fields)
del(fields_sample)
else:
print 'Error create array'
def getFrameOutterBounds(self, frameLayer):
"""
Gets the outter bounds of all frame features composing frame layer.
:param frameLayer: (QgsVectorLayer) frame layer.
:return: (list-of-QgsGeometry) list of all disjuncts outter bounds of features in frame layer.
"""
frameGeomList = []
# dissolve every feature into a single one
result = processing.runalg('qgis:dissolve', frameLayer, True, None,
None)
# get the layer from processing result
outputLayer = processing.getObject(result['OUTPUT'])
# clean possible missinformation from resulting layer
# setting clean parameters
tools = 'rmsa,break,rmdupl,rmdangle'
threshold = -1
extent = outputLayer.extent()
(xmin, xmax, ymin, ymax) = extent.xMinimum(), extent.xMaximum(
), extent.yMinimum(), extent.yMaximum()
extent = '{0},{1},{2},{3}'.format(xmin, xmax, ymin, ymax)
snap = self.parameters['Search Radius']
minArea = 0.0001
result = processing.runalg('grass7:v.clean.advanced', outputLayer,
tools, threshold, extent, snap, minArea,
None, None)
# get resulting layer
outputLayer = processing.getObject(result['output'])
# get all frame outter layer found
for feat in outputLayer.getFeatures():
geom = feat.geometry()
# deaggregate geometry, if necessary
geomList = self.DsgGeometryHandler.deaggregateGeometry(
multiGeom=geom)
# for every deaggregated node, get only the outter bound as a polyline (for intersection purposes)
frameGeomList += [
QgsGeometry().fromPolyline(g.asPolygon()[0]) for g in geomList
]
return frameGeomList
def fourthQuery():
ui.queryResults.clear()
if(ui.nearCombo.currentIndex()==0):
query = db.exec_("""select n.name, ST_Distance(n.geom,s.geom,true) as distance from uta_buildings as n, uta_buildings as s where ST_Distance(n.geom,s.geom,true)>0 and n.description='{}' and s.name ='{}' order by distance asc LIMIT 1""".format(ui.buildNearType.text(),ui.buildNearName.text()))
while(query.next()):
ui.queryResults.append(query.value(0)+" : "+str(round(query.value(1),2))+"(meters)")
if(ui.nearCombo.currentIndex()==1):
query = db.exec_("""select n.id,ST_Distance(n.geom,s.geom,true) as distance from uta_buildings as n, uta_buildings as s where ST_Distance(n.geom,s.geom,true)>0 and n.description='{}' and s.name ='{}' order by distance asc LIMIT 1""".format(ui.buildNearType.text(),ui.buildNearName.text()))
names=[];
while(query.next()):
names.append(query.value(0))
layer=processing.getObject('uta_buildings')
layer.setSelectedFeatures(names)
ui.queryResults.setText("See on UTA Map")
def firstQuery():
ui.queryResults.clear()
if(ui.withinCombo.currentIndex()==0):
query = db.exec_("""select n.name from uta_buildings as n, uta_buildings as s where n.description='{}' and s.name ='{}' and ST_DWithin(n.geom,s.geom,{},true)""".format(ui.buildDescription.text(),ui.BuildName.text(),int(ui.buildRadius.text())))
while(query.next()):
ui.queryResults.append(query.value(0))
if(ui.withinCombo.currentIndex()==1):
query = db.exec_("""select n.id from uta_buildings as n, uta_buildings as s where n.description='{}' and s.name ='{}' and ST_DWithin(n.geom,s.geom,{},true)""".format(ui.buildDescription.text(),ui.BuildName.text(),int(ui.buildRadius.text())))
names=[];
while(query.next()):
names.append(query.value(0))
layer=processing.getObject('uta_buildings')
layer.setSelectedFeatures(names)
ui.queryResults.setText("See on UTA Map")
def runOverlay(self, alg, layerA, inputType, layerB, overlayType, extent, snap, minArea, outputFeatureList = False):
ret = processing.runalg(alg, layerA, inputType % 2, layerB, overlayType, False, extent, snap, minArea, inputType+1, None) #this +1 just worked, programming dog mode on,
# The %2 is to adjust to interface parameter
if not ret:
raise Exception(self.tr('Problem executing grass7:v.overlay. Check your installed libs.\n'))
#updating original layer
outputLayer = processing.getObject(ret['output'])
outputLayer.startEditing()
for field in outputLayer.pendingFields():
if 'a_' == field.name()[0:2]:
idx = outputLayer.fieldNameIndex(field.name())
outputLayer.renameAttribute(idx, field.name()[2::])
outputLayer.commitChanges()
#getting error flags
if 'error' in ret.keys():
errorLayer = processing.getObject(ret['error'])
return {'error':self.getProcessingErrors(errorLayer)}
#if there is no error flag, iterate over outputLayer
if outputFeatureList:
return [feature for feature in outputLayer.getFeatures()]
else:
return outputLayer
def getLineEdges(self, coverageLyr):
extent = coverageLyr.extent()
(xmin, xmax, ymin, ymax) = extent.xMinimum(), extent.xMaximum(
), extent.yMinimum(), extent.yMaximum()
extent = '{0},{1},{2},{3}'.format(xmin, xmax, ymin, ymax)
grass_output = processing.runalg('grass7:v.clean.advanced',
coverageLyr, 'break,rmdupl', -1,
extent, -1, 0.0001, None, None)
if not grass_output:
raise Exception(
self.
tr('Problem executing grass7:v.clean.advanced. Check your installed libs.\n'
))
return processing.getObject(grass_output['output'])
def AddCLC(self): try: layer_list = [] for layer in self.iface.legendInterface().layers(): if layer.type() == QgsMapLayer.VectorLayer: layer_list.append(layer.source()) Path = str(QFileDialog.getOpenFileNames(self.dlg, "Selecionar um ficheiro", "/home/", "ESRI Shapefiles (*.shp *.SHP);;Todos os ficheiros (*)(*.*)")[0]) InFileObject = processing.getObject(Path) layer_list.insert(0, Path) if InFileObject.type() == QgsMapLayer.VectorLayer: self.dlg.comboBox_2.clear() self.dlg.comboBox_2.addItems(layer_list) except: pass
def dsv_load(filename, layer, field="new_id", alg="qgis:dissolve", save=False):
global OutputFile
save_name = OutputFile + filename + ".shp"
if save == True:
processing.runalg(alg, layer, 0, field, save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
else:
clip = processing.runalg(alg, layer, 0, field, None)
return processing.getObject(clip['OUTPUT'])
def merge_grid(filename,
layer,
exp=u'"left_grid"is null',
id="right_grid",
thresh=0.33,
save=False):
global OutputFile
save_name = OutputFile + filename + ".shp"
if save == False:
processing.runalg("qgis:selectbyattribute", layer, u'area', 4, thresh)
processing.runalg("qgis:selectbyexpression", layer, exp, 3)
feature_dict = {f.id(): f for f in layer.selectedFeatures()}
layer.startEditing()
for f in feature_dict.values():
geom = f.geometry()
if f[id] == NULL:
pass
else:
new = f[id]
f[_NEW_ID] = new
layer.updateFeature(f)
layer.commitChanges()
layer.removeSelection()
layer2 = dsv_load(filename, layer)
layer3 = area_cal(filename, layer2)
layer.removeSelection()
return processing.getObject(layer3['OUTPUT'])
else:
processing.runalg("qgis:selectbyattribute", layer, u'area', 4, thresh)
processing.runalg("qgis:selectbyexpression", layer, exp, 3)
feature_dict = {f.id(): f for f in layer.selectedFeatures()}
layer.startEditing()
for f in feature_dict.values():
geom = f.geometry()
new = f[id]
f[_NEW_ID] = new
layer.updateFeature(f)
layer.commitChanges()
layer.removeSelection()
layer2 = dsv_load(filename, layer)
processing.runalg("qgis:fieldcalculator", layer2, "area", 0, 10, 2,
True, "$area/1000000", save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
def reloadFields(self):
print 'reload fields'
self.uZfield.clear()
self.uOrderField.clear()
self.axes.clear()
point_layer = processing.getObject(str(self.uPointLayer.currentText()))
if point_layer.selectedFeatureCount() != 0:
self.uSelectedPoints.setCheckState(Qt.Checked)
else:
self.uSelectedPoints.setCheckState(Qt.Unchecked)
self.uZfield.addItems(utils.getFieldNames(point_layer, [QVariant.Int, QVariant.Double]))
self.uOrderField.addItems(utils.getFieldNames(point_layer, [QVariant.Int, QVariant.Double]))
def union_load(filename, layer1, layer2, alg="qgis:union", save=False):
'''
#This is a warpper-function for "union"
'''
global OutputFile
save_name = OutputFile + filename + ".shp"
if save == False:
union = processing.runalg(alg, layer1, layer2, None)
return processing.getObject(union['OUTPUT'])
else:
processing.runalg(alg, layer1, layer2, save_name)
data_source = save_name
layer_name = filename
provider_name = "ogr"
return iface.addVectorLayer(data_source, layer_name, provider_name)
def buildLine(self, pointSelectFlag):
print 'buildLine'
pointLayer = processing.getObject(str(self.uPointLayer.currentText()))
orderField = self.uOrderField.currentText()
sortOrder = self.uOrder.currentText()
crs = pointLayer.crs().toWkt()
pointList = []
if pointSelectFlag:
pointFeatureList = pointLayer.selectedFeatures()
else:
pointFeatureList = pointLayer.getFeatures()
for pointFeature in pointFeatureList:
pointGeom = pointFeature.geometry()
coords = pointGeom.asPoint()
sortField = pointFeature[orderField]
##store data
pointList.append([coords, sortField])
if not pointFeatureList:
QMessageBox.warning(self,'Error',
'Selected point list is empty')
return 'Error'
###sort data by field
if sortOrder=='Ascending':
pointList = sorted(pointList, key=itemgetter(1))
else:
pointList = sorted(pointList, key=itemgetter(1), reverse=True)
## drop sort field
pointList = list(zip(*pointList)[0])
###build line
# create a new memory layer
newLineLayer = QgsVectorLayer("LineString?crs="+crs, "profileFromPointsLine", "memory")
pr = newLineLayer.dataProvider()
feat = QgsFeature()
geom = QgsGeometry.fromPolyline(pointList)
feat.setGeometry(geom)
pr.addFeatures( [ feat ] )
newLineLayer.updateExtents()
QgsMapLayerRegistry.instance().addMapLayers([newLineLayer])
return newLineLayer
def processAlgorithm(self, progress):
filename = self.getParameterValue(self.LAYERNAME)
layer = processing.getObject(filename)
oldSelection = set(layer.selectedFeaturesIds())
method = self.getParameterValue(self.METHOD)
if method == 0:
behaviour = QgsVectorLayer.SetSelection
elif method == 1:
behaviour = QgsVectorLayer.AddToSelection
elif method == 2:
behavior = QgsVectorLayer.RemoveFromSelection
elif method == 3:
behaviour = QgsVectorLayer.IntersectSelection
expression = self.getParameterValue(self.EXPRESSION)
qExp = QgsExpression(expression)
if qExp.hasParserError():
raise GeoAlgorithmExecutionException(qExp.parserErrorString())
layer.selectByExpression(expression, behaviour)
self.setOutputValue(self.RESULT, filename)
def getQgisTableLayerFilePathInfo(self, tableName, pathKey="dbname"):
"""
purpose:
return user requested file path connection details based on key provided
notes:
returns value based on user supplied key
key is either "dbname" or "table"
returns:
string
"""
# convert attribute name to qgis object using processing convience method
inputLayer = processing.getObject(tableName)
# get qgis data provider for layer
provider = inputLayer.dataProvider()
# get full url connection path ie dbname="some/file/db.sqlite table=some_table"
url = provider.dataSourceUri()
# split on space
dbFilePath = url.split(" ")
if pathKey == "dbname":
# second split on '='
dbFilePath = dbFilePath[0]
# connection path
# get db file path
dbFilePath = dbFilePath.split("=")[1]
return dbFilePath
else:
# second split on '='
dbFilePath = dbFilePath[1]
# connection path
# get db table name
dbFilePath = dbFilePath.split("=")[1]
return dbFilePath
def accept(self):
print 'accepted'
self.axes.clear()
point_layer = processing.getObject(self.uPointLayer.currentText())
line_layer = processing.getObject(self.uLineLayer.currentText())
z_field=(self.uZfield.currentText())
order_field=str(self.uOrderField.currentText())
if str(self.uOrder.currentText())=='Ascending':
sort = 'ASC'
else:
sort = 'DESC'
buff=float(self.uBuffer.displayText())
if self.utabWidget.currentIndex()==0:
createLine=True
else:
createLine=False
if self.uSelectedPoints.isChecked() and \
point_layer.selectedFeatureCount() == 0 or self.uSelectedLine.isChecked() and \
line_layer.selectedFeatureCount() == 0:
QMessageBox.warning(self,
self.tr('No selection'),
self.tr('There is no selection in input '
'layer. Uncheck corresponding option '
'or select some features before '
'running analysis'))
return
if not createLine and not self.uSelectedLine.isChecked() and \
line_layer.featureCount() != 1:
QMessageBox.warning(self,
self.tr('Line Layer Error'),
self.tr('There are multiple line features within the line layer.\n Please select one.'))
return
if utils.checkMultipart(point_layer):
QMessageBox.warning(self,
self.tr('Point Layer Error'),
self.tr('Point layer has multi-part geometery.\n Please convert to single part geometery.'))
return
if not createLine and utils.checkMultipart(line_layer):
QMessageBox.warning(self,
self.tr('Line Layer Error'),
self.tr('Line layer has multi-part geometery.\n Please convert to single part geometery.'))
return
selected_points = self.uSelectedPoints.checkState()
selected_line = self.uSelectedLine.checkState()
self.workThread = profilefrompoints_thread.ProfilefromPointsThread(point_layer,z_field,createLine,order_field,sort,line_layer,buff,selected_points,selected_line)
self.workThread.processFinished.connect(self.processFinished)
self.workThread.processInterrupted.connect(self.processInterrupted)
self.btnOk.setEnabled(False)
self.btnClose.setText(self.tr("Cancel"))
self.buttonBox.rejected.disconnect(self.reject)
self.btnClose.clicked.connect(self.stopProcessing)
self.uprogressBar.setMaximum(0)
self.workThread.start()
self.dbase=os.path.join( os.environ['HOME'],'Desktop','tmp_'+point_layer.name()+'.sqlite')
from processing.core.parameters import Parameter
from PyQt4 import QtCore
from qgis.core import *
from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
from processing.tools.vector import VectorWriter
import os.path
import processing
import sys
import time
import math
# run dissolve processing algorithm
dissolve = processing.runalg("qgis:dissolve", Input_layer, "false", Dissolve_field, Output_layer)
# get output of dissolve algorithm
dissolveLayer = dissolve['OUTPUT']
dissolveLayer = processing.getObject(dissolveLayer)
# get list of statistics to compute for each field
listStats = Statistics.split(';')
# get object for input layer
inputLayer = processing.getObject(Input_layer)
def validation():
# verifies that number of statistics = number of fields in input layer
nbStats = len(listStats)
provider = inputLayer.dataProvider()
fields = provider.fields()
nbFields = len(fields)
if nbStats != nbFields:
raise GeoAlgorithmExecutionException('Number of statistics is not equal to number of fields in input layer ; please check again.')
# once the dissolve output layer is created, calculates its new attributes values
# calculate distances between origin and target feature
D = cdist(geom1,geom2,'euclidean')
H1 = np.max(np.min(D, axis=1))
H2 = np.max(np.min(D, axis=0))
distances.append( max(H1,H2) )
# repeat the calculation in reverse order
D = cdist(geom2,geom1,'euclidean')
H1 = np.max(np.min(D, axis=1))
H2 = np.max(np.min(D, axis=0))
distances.append( max(H1,H2) )
hausdorff = max(distances)
return hausdorff
origin_layer = processing.getObject(origin_layer)
target_layer = processing.getObject(target_layer)
target_id_column_index = target_layer.fieldNameIndex(target_id_column_index)
"""
origin_layer = l1
target_layer = l2
target_id_column_index = 0
interval = 1
"""
target_spatial_index = QgsSpatialIndex()
target_features = processing.features(target_layer)
origin_fields = origin_layer.pendingFields().toList()
origin_fields.append( QgsField("BEST_FIT", QVariant.Int ))
origin_fields.append( QgsField("HAUSDORFF", QVariant.Double ))
self.id_to_centroid[id][1][0] += weight
self.id_to_centroid[id][1][h/6+1] += weight
this_sequence.append(nearest_cell_id)
def create_flow_lines(self):
lines = []
for key,value in self.sequences.iteritems():
p1 = self.id_to_centroid[key[0]][0].geometry().asPoint()
p2 = self.id_to_centroid[key[1]][0].geometry().asPoint()
feat = QgsFeature()
feat.setGeometry(QgsGeometry.fromPolyline([p1,p2]))
feat.setAttributes([key[0],key[1],value])
lines.append(feat)
return lines
centroid_layer = processing.getObject(input_cell_centers)
trajectory_layer = processing.getObject(input_trajectories)
sg = SequenceGenerator(centroid_layer,trajectory_layer, weight_field if use_weight_field else None)
fields = [QgsField('FROM', QVariant.Int),
QgsField('TO', QVariant.Int),
QgsField('COUNT', QVariant.Int)]
geom_type = 2
writer = VectorWriter(flow_lines, None, fields, geom_type, centroid_layer.crs() )
for f in sg.create_flow_lines():
writer.addFeature(f)
del writer
fields = centroid_layer.fields()
fields.append( QgsField('COUNT',QVariant.Int))
fields.append( QgsField('COUNT_Q1',QVariant.Int))
def createDatas (self):
'''
Create shapefile memory points
Input shapefile points
Output shapefile memory points, Datas (numpy)
'''
#Open points cloud datas
self.layer_datas = processing.getObject(Points_clould)
#Get all fields
self.fields_datas = self.layer_datas.pendingFields()
#Get index field Z points cloud
self.idx_z_datas = self.layer_datas.fieldNameIndex(Z_field)
#Create list index fields
self.idx_fields_datas = [i for i in range(len(self.fields_datas))]
print 'self.idx_fields_datas: ', self.idx_fields_datas
#inicia variaveis
attrs_registro=[]
data=[]
self.datasIDs = np.array([])
# create layer temporary
self.vl = QgsVectorLayer("Point?crs=EPSG:32722", "temporary_points", "memory")
#Get provider
pr = self.vl.dataProvider()
#Iniciar edicao
self.vl.startEditing()
#obter apenas fields dos indexs
#fields_vl = [self.fields_datas[v] for v in self.idx_fields_datas]
#Add QgsFileds in temporary file
print 'criou temp e iniciou a edicao'
time.sleep(5)
self.fields_datas=[self.fields_datas[v] for v in range(len(self.fields_datas))]
pr.addAttributes(self.fields_datas)
#Iterando sobre a geometria
layer_features = self.layer_datas.getFeatures()
print 'Add attributes e obtve layers'
time.sleep(5)
for feat in layer_features:
#obter geometria
geom =feat.geometry()
#Obter attributes
attrs = feat.attributes()
#Get FID
self.datasIDs = np.append(self.datasIDs, feat.id())
#criar array para os valores z,r,g e b
attrs_registro = [attrs[i] for i in self.idx_fields_datas]
#Add attributes in data array
data.append(attrs_registro)
fet = QgsFeature()
#Set geometry
fet.setGeometry( QgsGeometry.fromPoint(geom.asPoint() ))
#Set attributes in temporary
fet.setAttributes(attrs_registro)
#Use provider to add features
pr.addFeatures([fet])
#update temporary
self.vl.updateExtents()
#Create array from Datas list
self.datas = np.asarray(data)
#commite changes
self.vl.commitChanges()
#Delete variables
del(data)
#Assign parameters to shortest variable name
vrsx = Roads_layer
speedField = Speed_field_in_kmh
startPts = Starting_points_layer
res = Resolution_in_meters_per_pixel
extent = Extent
rcost = Ouput_time_raster_in_minutes
maxTime = Style_max_travel_time
timeIntervals = Multiple_styles_travel_time_intervals
#CHECK if one or more starting pt are in extent
xmin, xmax, ymin, ymax = map(float, Extent.split(','))
extentRect = QgsRectangle (xmin, ymin, xmax, ymax)
vl = processing.getObject(Starting_points_layer)
"""
# Methode 1
within = False
for feat in vl.getFeatures():
if extentRect.contains(feat.geometry().asPoint()):
within = True
if not within:
raise GeoAlgorithmExecutionException('err starting points not in extent')
"""
# Methode 2 : Request feature with spatial filter
request = QgsFeatureRequest()
request.setFilterRect(extentRect)
subsetFeats = list(vl.getFeatures(request))
if len(subsetFeats) == 0:
raise GeoAlgorithmExecutionException('err starting points not in extent')
def test_getobject(self):
layer = processing.getObject(points());
self.assertIsNotNone(layer)
layer = processing.getObject("points");
self.assertIsNotNone(layer)
def test_featuresWithoutSelection(self):
layer = processing.getObject(points())
features = processing.features(layer)
self.assertEqual(12, len(features))
if Directional:
if fabs(m) > eval(Symmetry_Threshold):
if m > 0:
Class = ' '.join([Class,'1'])
else:
Class = ' '.join([Class,'0'])
data[name] = (g.Width.max(),c,mm,g.Centerline.max(),g.Sinuosity.max(),g.Angle.max(),fabs(m),r2,xMax,Class)
except Exception,e:
progress.setText('%s'%(e))
continue
del df
layer = st.getObject(Update_Feature)
field_names = [('Max_Width',QVariant.Double),('CRatio',QVariant.Double),('CProp',QVariant.Double),('Length',QVariant.Double),('Sinuosity',QVariant.Double),('Angle',QVariant.Double),('Slope',QVariant.Double),('r2',QVariant.Double),('Deviation',QVariant.Double),('Class_Name',QVariant.String)]
for name,type in field_names:
if layer.fieldNameIndex(name) == -1:
layer.dataProvider().addAttributes([QgsField(name,type)])
layer.startEditing()
Total = layer.featureCount()
for enum,feature in enumerate(layer.getFeatures()):
try:
progress.setPercentage(int((100 * Counter)/Total))
values = data[feature["FID"]]
for d,v in zip(field_names[:-1],values[:-1]):
feature[d[0]]=float(v)
layer.updateFeature(feature)
feature[field_names[-1][0]]=values[-1]
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(ConcaveHull.INPUT))
alpha = self.getParameterValue(self.ALPHA)
holes = self.getParameterValue(self.HOLES)
no_multigeom = self.getParameterValue(self.NO_MULTIGEOMETRY)
# Delaunay triangulation from input point layer
progress.setText(self.tr('Creating Delaunay triangles...'))
delone_triangles = processing.runalg("qgis:delaunaytriangulation", layer, None)['OUTPUT']
delaunay_layer = processing.getObject(delone_triangles)
# Get max edge length from Delaunay triangles
progress.setText(self.tr('Computing edges max length...'))
features = delaunay_layer.getFeatures()
if len(features) == 0:
raise GeoAlgorithmExecutionException(self.tr('No Delaunay triangles created.'))
counter = 50. / len(features)
lengths = []
edges = {}
for feat in features:
line = feat.geometry().asPolygon()[0]
for i in range(len(line) - 1):
lengths.append(sqrt(line[i].sqrDist(line[i + 1])))
edges[feat.id()] = max(lengths[-3:])
progress.setPercentage(feat.id() * counter)
max_length = max(lengths)
# Get features with longest edge longer than alpha*max_length
progress.setText(self.tr('Removing features...'))
counter = 50. / len(edges)
i = 0
ids = []
for id, max_len in list(edges.items()):
if max_len > alpha * max_length:
ids.append(id)
progress.setPercentage(50 + i * counter)
i += 1
# Remove features
delaunay_layer.selectByIds(ids)
delaunay_layer.startEditing()
delaunay_layer.deleteSelectedFeatures()
delaunay_layer.commitChanges()
# Dissolve all Delaunay triangles
progress.setText(self.tr('Dissolving Delaunay triangles...'))
dissolved = processing.runalg("qgis:dissolve", delaunay_layer,
True, None, None)['OUTPUT']
dissolved_layer = processing.getObject(dissolved)
# Save result
progress.setText(self.tr('Saving data...'))
feat = QgsFeature()
dissolved_layer.getFeatures(QgsFeatureRequest().setFilterFid(0)).nextFeature(feat)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs())
geom = feat.geometry()
if no_multigeom and geom.isMultipart():
# Only singlepart geometries are allowed
geom_list = geom.asMultiPolygon()
for single_geom_list in geom_list:
single_feature = QgsFeature()
single_geom = QgsGeometry.fromPolygon(single_geom_list)
if not holes:
# Delete holes
deleted = True
while deleted:
deleted = single_geom.deleteRing(1)
single_feature.setGeometry(single_geom)
writer.addFeature(single_feature)
else:
# Multipart geometries are allowed
if not holes:
# Delete holes
deleted = True
while deleted:
deleted = geom.deleteRing(1)
writer.addFeature(feat)
del writer
##Save_Air_Tasking_Order_To=folder
##Master_Flight_Lines_Shapefile=vector
from qgis.core import *
from qgis.utils import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import processing as pro
import os
import time
import csv
from qgis.gui import QgsMapCanvas, QgsLayerTreeMapCanvasBridge
from qgis.PyQt.QtXml import QDomDocument
out_folder = Save_Air_Tasking_Order_To
layer = pro.getObject(Master_Flight_Lines_Shapefile)
gis_files = r'C:/Users/shawn.carter/.qgis2/processing/scripts/gis_files'
if not os.path.exists(os.path.join(out_folder, Survey_Name)):
os.mkdir(os.path.join(out_folder, Survey_Name))
os.chdir(os.path.join(out_folder, Survey_Name))
def get_remarks(lines, layer):
"""Yields input flight lines that are not present in the master
flight line shapefile
"""
all_features_layer = QgsVectorLayer(layer.source(), 'all lines',
layer.providerType())
all_features = all_features_layer.getFeatures()
def accept(self):
print 'run'
pointLayer = processing.getObject(str(self.uPointLayer.currentText()))
# check for selected features
if self.uSelectedPoints.isChecked():
pointSelectFlag = True
else:
pointSelectFlag = False
if self.uSelectedLine.isChecked():
lineSelectFlag = True
else:
lineSelectFlag = False
## check if need to build line
if self.utabWidget.currentIndex()==0:
lineLayer = self.buildLine(pointSelectFlag)
if lineLayer=='Error':
return
else:
lineLayer = processing.getObject(str(self.uLineLayer.currentText()))
zField = self.uZfield.currentText()
pointIdField = self.uPointID.currentText()
try:
noData = float(self.lineEditNoData.text())
except:
QMessageBox.warning(self,'Error',
'No data value must be numeric')
return
if self.uBuffer.displayText() !='':
buff=float(self.uBuffer.displayText())
else:
buff=None
# trap for coordinate system
if lineLayer.crs()!=pointLayer.crs():
QMessageBox.warning(self,'Error',
'Point layer coordinate system does not match line coordinate system')
return
# trap for more than one line feature
counter = 0
if lineSelectFlag:
lineFeatureList = lineLayer.selectedFeatures()
else:
lineFeatureList = lineLayer.getFeatures()
for lineFeatures in lineFeatureList:
counter = counter+1
if counter!=1:
QMessageBox.warning(self,'Error',
'More than one line feature in line layer')
return
if lineSelectFlag:
lineFeat = lineLayer.selectedFeatures()[0]
else:
lineFeat = lineLayer.getFeatures().next()
lineGeom = lineFeat.geometry()
lineShap = LineString(lineGeom.asPolyline())
if buff:
lineBoundary = lineShap.buffer(buff)
if pointSelectFlag:
pointFeatureList = pointLayer.selectedFeatures()
else:
pointFeatureList = pointLayer.getFeatures()
pointList = []
for pointFeature in pointFeatureList:
pointGeom = pointFeature.geometry()
pointShap = Point(pointGeom.asPoint())
if buff:
## check if point is within line buffer
if pointShap.within(lineBoundary):
z = pointFeature[zField]
### get distance along line
dist = lineShap.project(pointShap)
pointId = pointFeature[pointIdField]
##store data
pointList.append([dist, z, pointId])
else:
z = pointFeature[zField]
### get distance along line
dist = lineShap.project(pointShap)
pointId = pointFeature[pointIdField]
##store data
pointList.append([dist, z, pointId])
###sort data by distance
pointList = sorted(pointList, key=itemgetter(0))
###seperate data back into individual lists
zList = []
distList = []
pointIdList = []
for i in pointList:
## only keep data that is not flaged as noData
if i[1]!=noData:
distList.append(i[0])
zList.append(i[1])
pointIdList.append(i[2])
self.values = [distList, zList, pointIdList]
self.refreshPlot()
self.uCopytoClip.setEnabled(True)
##contiguity=string queen
##morans_output=output vector
import pysal
import numpy as np
import processing
from processing.tools.vector import VectorWriter
from qgis.core import *
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)
import processing
from processing.tools.vector import VectorWriter
from PyQt4.QtCore import *
from qgis.core import *
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))
#Definition of inputs and outputs
#==================================
##[SAFARI]=group
##Centerline=vector
##Depositional_Direction=vector
##Distance_Field=string
##Output=output vector
#Algorithm body
#==================================
from qgis.core import *
from PyQt4.QtCore import *
import processing as st
from math import sqrt
layer = st.getObject(Centerline)
layer2 = st.getObject(Depositional_Direction)
if layer.fieldNameIndex("AlongDist") == -1:
layer.dataProvider().addAttributes([QgsField("AlongDist",QVariant.String)])
layer.startEditing()
layer.commitChanges()
data = {f.id():f for f in layer2.getFeatures()}
index = QgsSpatialIndex()
map(index.insertFeature, layer2.getFeatures())
fields= layer.pendingFields()
writer = QgsVectorFileWriter(Output, "CP1250", fields, layer.dataProvider().geometryType(),layer.crs(), "ESRI Shapefile")
fet = QgsFeature(fields)
try:
dir = os.path.join(destination, 'imagens')
if not os.path.exists(dir):
os.makedirs(dir)
f = os.path.join(root, file)
newf = os.path.join(parent, folder, 'imagens', file)
shutil.copy2(f, newf)
except:
raise GeoAlgorithmExecutionException('Problema ao copiar arquivos!')
return os.path.join(parent, folder, 'imagens', basename)
#end of script methods
#Making the actual work
#Camada de inventario
inventario = processing.getObject(Inventario)
#Camada de moldura
frame = processing.getObject(Moldura)
#Indice espacial
frameidx = QgsSpatialIndex()
#Populating a spatial index
populateIndex(frameidx, frame)
#checking crs's, if different, reproject
destCrs = frame.crs()
srcCrs = inventario.crs()
if srcCrs.authid() != destCrs.authid():
progress.setText('CRS diferentes, reprojetando...')
def test_SagaVectorAlgorithWithUnsupportedInputAndOutputFormat(self):
'''this tests both the exporting to shp and then the format change in the output layer'''
layer = processing.getObject(polygonsGeoJson());
feature = layer.getFeatures().next()
selected = [feature.id()]
layer.setSelectedFeatures(selected)
outputs=processing.runalg("saga:polygoncentroids",polygonsGeoJson(),True, getTempFilename("geojson"))
layer.setSelectedFeatures([])
output=outputs['CENTROIDS']
layer=dataobjects.getObjectFromUri(output, True)
fields=layer.pendingFields()
expectednames=['ID','POLY_NUM_A','POLY_ST_A']
expectedtypes=['Real','Real','String']
names=[str(f.name()) for f in fields]
types=[str(f.typeName()) for f in fields]
self.assertEqual(expectednames, names)
self.assertEqual(expectedtypes, types)
features=processing.features(layer)
self.assertEqual(1, len(features))
feature=features.next()
attrs=feature.attributes()
expectedvalues=["0","1.1","string a"]
values=[str(attr) for attr in attrs]
self.assertEqual(expectedvalues, values)
wkt='POINT(270787.49991451 4458955.46775295)'
self.assertEqual(wkt, str(feature.geometry().exportToWkt()))
