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