def handleAlgorithmResults(alg, progress, showResults = True): wrongLayers = [] htmlResults = False; progress.setText("Loading resulting layers") i = 0 for out in alg.outputs: progress.setPercentage(100 * i / float(len(alg.outputs))) if out.hidden or not out.open: continue if isinstance(out, (OutputRaster, OutputVector, OutputTable)): try: if out.value.startswith("memory:"): layer = out.memoryLayer QgsMapLayerRegistry.instance().addMapLayers([layer]) else: if ProcessingConfig.getSetting(ProcessingConfig.USE_FILENAME_AS_LAYER_NAME): name = os.path.basename(out.value) else: name = out.description QGisLayers.load(out.value, name, alg.crs, RenderingStyles.getStyle(alg.commandLineName(),out.name)) except Exception, e: wrongLayers.append(out) #QMessageBox.critical(None, "Error", str(e)) elif isinstance(out, OutputHTML): ProcessingResults.addResult(out.description, out.value) htmlResults = True
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) tolerance =self.getParameterValue(self.TOLERANCE) pointsBefore = 0 pointsAfter = 0 writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), layer.wkbType(), layer.crs()) current = 0 selection = QGisLayers.features(layer) total = 100.0 / float(len(selection)) for f in selection: featGeometry = QgsGeometry(f.geometry()) attrs = f.attributes() pointsBefore += self.geomVertexCount(featGeometry) newGeometry = featGeometry.simplify(tolerance) pointsAfter += self.geomVertexCount(newGeometry) feature = QgsFeature() feature.setGeometry(newGeometry) feature.setAttributes(attrs) writer.addFeature(feature) current += 1 progress.setPercentage(int(current * total)) del writer ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Simplify: Input geometries have been simplified from" + str(pointsBefore) + " to " + str(pointsAfter) + " points.")
def processAlgorithm(self, progress): fieldname = self.getParameterValue(self.FIELD) output = self.getOutputFromName(self.OUTPUT) vlayer = QGisLayers.getObjectFromUri(self.getParameterValue( self.INPUT)) vprovider = vlayer.dataProvider() fieldindex = vlayer.fieldNameIndex(fieldname) fields = vprovider.fields() fields.append(QgsField("NUM_FIELD", QVariant.Int)) writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 classes = {} features = QGisLayers.features(vlayer) nFeat = len(features) for feature in features: progress.setPercentage(int((100 * nElement) / nFeat)) nElement += 1 inGeom = feature.geometry() outFeat.setGeometry(inGeom) atMap = feature.attributes() clazz = atMap[fieldindex] if clazz not in classes: classes[clazz] = len(classes.keys()) atMap.append(classes[clazz]) outFeat.setAttributes(atMap) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): fieldname = self.getParameterValue(self.FIELD) output = self.getOutputFromName(self.OUTPUT) vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) vprovider = vlayer.dataProvider() fieldindex = vlayer.fieldNameIndex(fieldname) fields = vprovider.fields() fields.append(QgsField("NUM_FIELD", QVariant.Int)) writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs() ) outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 classes = {} features = QGisLayers.features(vlayer) nFeat = len(features) for feature in features: progress.setPercentage(int((100 * nElement)/nFeat)) nElement += 1 inGeom = feature.geometry() outFeat.setGeometry( inGeom ) atMap = feature.attributes() clazz = atMap[fieldindex] if clazz not in classes: classes[clazz] = len(classes.keys()) atMap.append(classes[clazz]) outFeat.setAttributes(atMap) writer.addFeature( outFeat ) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) interval = self.getParameterValue(self.INTERVAL) isPolygon = layer.geometryType() == QGis.Polygon writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), layer.wkbType(), layer.crs()) features = QGisLayers.features(layer) total = 100.0 / float(len(features)) current = 0 for f in features: featGeometry = QgsGeometry(f.geometry()) attrs = f.attributes() newGeometry = self.densifyGeometry(featGeometry, interval, isPolygon) feature = QgsFeature() feature.setGeometry(newGeometry) feature.setAttributes(attrs) writer.addFeature(feature) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): fieldType = self.getParameterValue(self.FIELD_TYPE) fieldName = self.getParameterValue(self.FIELD_NAME) fieldLength = self.getParameterValue(self.FIELD_LENGTH) fieldPrecision = self.getParameterValue(self.FIELD_PRECISION) output = self.getOutputFromName(self.OUTPUT_LAYER) layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.INPUT_LAYER)) provider = layer.dataProvider() fields = provider.fields() fields.append( QgsField(fieldName, self.TYPES[fieldType], "", fieldLength, fieldPrecision)) writer = output.getVectorWriter(fields, provider.geometryType(), layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 features = QGisLayers.features(layer) nFeat = len(features) for inFeat in features: progress.setPercentage(int((100 * nElement) / nFeat)) nElement += 1 inGeom = inFeat.geometry() outFeat.setGeometry(inGeom) atMap = inFeat.attributes() atMap.append(None) outFeat.setAttributes(atMap) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), QGis.WKBLineString, layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: inGeom = f.geometry() attrs = f.attributes() lineList = self.extractAsLine(inGeom) outFeat.setAttributes(attrs) for h in lineList: outFeat.setGeometry(outGeom.fromPolyline(h)) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) inputLayer = QGisLayers.getObjectFromUri(filename) method = self.getParameterValue(self.METHOD) filename = self.getParameterValue(self.INTERSECT) selectLayer = QGisLayers.getObjectFromUri(filename) oldSelection = set(inputLayer.selectedFeaturesIds()) index = spatialIndex = utils.createSpatialIndex(inputLayer) feat = QgsFeature() geom = QgsGeometry() selectedSet = [] current = 0 features = QGisLayers.features(selectLayer) total = 100.0 / float(len(features)) for f in features: geom = QgsGeometry(f.geometry()) intersects = index.intersects(geom.boundingBox()) for i in intersects: request = QgsFeatureRequest().setFilterFid(i) feat = inputLayer.getFeatures(request).next() tmpGeom = QgsGeometry(feat.geometry()) if geom.intersects(tmpGeom): selectedSet.append(feat.id()) current += 1 progress.setPercentage(int(current * total)) if method == 1: selectedSet = list(oldSelection.union(selectedSet)) elif method == 2: selectedSet = list(oldSelection.difference(selectedSet)) inputLayer.setSelectedFeatures(selectedSet) self.setOutputValue(self.OUTPUT, filename)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.INPUT_LAYER)) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( layer.pendingFields().toList(), QGis.WKBPoint, layer.crs()) outFeat = QgsFeature() features = QGisLayers.features(layer) total = 100.0 / float(len(features)) current = 0 for inFeat in features: inGeom = inFeat.geometry() attrs = inFeat.attributes() outGeom = QgsGeometry(inGeom.centroid()) if outGeom is None: raise GeoAlgorithmExecutionException( "Error calculating centroid") outFeat.setGeometry(outGeom) outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): fieldType = self.getParameterValue(self.FIELD_TYPE) fieldName = self.getParameterValue(self.FIELD_NAME) fieldLength = self.getParameterValue(self.FIELD_LENGTH) fieldPrecision = self.getParameterValue(self.FIELD_PRECISION) output = self.getOutputFromName(self.OUTPUT_LAYER) layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER)) provider = layer.dataProvider() fields = provider.fields() fields.append(QgsField(fieldName, self.TYPES[fieldType], "", fieldLength, fieldPrecision)) writer = output.getVectorWriter(fields, provider.geometryType(), layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 features = QGisLayers.features(layer) nFeat = len(features) for inFeat in features: progress.setPercentage(int((100 * nElement)/nFeat)) nElement += 1 inGeom = inFeat.geometry() outFeat.setGeometry( inGeom ) atMap = inFeat.attributes() atMap.append(None) outFeat.setAttributes(atMap) writer.addFeature( outFeat ) del writer
def convertUnsupportedFormats(self, progress): i = 0 progress.setText("Converting outputs") for out in self.outputs: if isinstance(out, OutputVector): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) if layer is None: # for the case of memory layer, if the getCompatible method has been called continue provider = layer.dataProvider() writer = out.getVectorWriter(provider.fields(), provider.geometryType(), layer.crs()) features = QGisLayers.features(layer) for feature in features: writer.addFeature(feature) elif isinstance(out, OutputRaster): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) provider = layer.dataProvider() writer = QgsRasterFileWriter(out.value) format = self.getFormatShortNameFromFilename(out.value) writer.setOutputFormat(format) writer.writeRaster(layer.pipe(), layer.width(), layer.height(), layer.extent(), layer.crs()) elif isinstance(out, OutputTable): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) provider = layer.dataProvider() writer = out.getTableWriter(provider.fields()) features = QGisLayers.features(layer) for feature in features: writer.addRecord(feature) progress.setPercentage(100 * i / float(len(self.outputs)))
def getSafeExportedLayers(self): '''Returns not the value entered by the user, but a string with semicolon-separated filenames which contains the data of the selected layers, but saved in a standard format (currently shapefiles for vector layers and GeoTiff for raster) so that they can be opened by most external applications. If there is a selection and QGIS is configured to use just the selection, if exports the layer even if it is already in a suitable format. Works only if the layer represented by the parameter value is currently loaded in QGIS. Otherwise, it will not perform any export and return the current value string. If the current value represents a layer in a suitable format, it does no export at all and returns that value. Currently, it works just for vector layer. In the case of raster layers, it returns the parameter value. The layers are exported just the first time the method is called. The method can be called several times and it will always return the same string, performing the export only the first time.''' if self.exported: return self.exported self.exported = self.value layers = self.value.split(";") if layers == None or len(layers) == 0: return self.value if self.datatype == ParameterMultipleInput.TYPE_RASTER: for layerfile in layers: layer = QGisLayers.getObjectFromUri(layerfile, False) if layer: filename = LayerExporter.exportRasterLayer(layer) self.exported = self.exported.replace(layerfile, filename) return self.exported else: for layerfile in layers: layer = QGisLayers.getObjectFromUri(layerfile, False) if layer: filename = LayerExporter.exportVectorLayer(layer) self.exported = self.exported.replace(layerfile, filename) return self.exported
def exportVectorLayer(self, orgFilename): #TODO: improve this. We are now exporting if it is not a shapefile, #but the functionality of v.in.ogr could be used for this. #We also export if there is a selection if not os.path.exists(orgFilename) or not orgFilename.endswith("shp"): layer = QGisLayers.getObjectFromUri(orgFilename, False) if layer: filename = LayerExporter.exportVectorLayer(layer) else: layer = QGisLayers.getObjectFromUri(orgFilename, False) if layer: useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED) if useSelection and layer.selectedFeatureCount() != 0: filename = LayerExporter.exportVectorLayer(layer) else: filename = orgFilename else: filename = orgFilename destFilename = self.getTempFilename() self.exportedLayers[orgFilename]= destFilename command = "v.in.ogr" min_area = self.getParameterValue(self.GRASS_MIN_AREA_PARAMETER); command += " min_area=" + str(min_area) snap = self.getParameterValue(self.GRASS_SNAP_TOLERANCE_PARAMETER); command += " snap=" + str(snap) command += " dsn=\"" + os.path.dirname(filename) + "\"" command += " layer=" + os.path.basename(filename)[:-4] command += " output=" + destFilename; command += " --overwrite -o" return command
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) geomType = self.multiToSingleGeom(layer.dataProvider().geometryType()) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), geomType, layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: inGeom = f.geometry() attrs = f.attributes() geometries = self.extractAsSingle(inGeom) outFeat.setAttributes(attrs) for g in geometries: outFeat.setGeometry(g) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) vertices = self.getParameterValue(self.VERTICES) isPolygon = layer.geometryType() == QGis.Polygon writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), layer.wkbType(), layer.crs()) features = QGisLayers.features(layer) total = 100.0 / float(len(features)) current = 0 for f in features: featGeometry = QgsGeometry(f.geometry()) attrs = f.attributes() newGeometry = self.densifyGeometry(featGeometry, int(vertices), isPolygon) feature = QgsFeature() feature.setGeometry(newGeometry) feature.setAttributes(attrs) writer.addFeature(feature) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs()) outFeat = QgsFeature() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: outGeomList = [] if f.geometry().isMultipart(): outGeomList = f.geometry().asMultiPolyline() else: outGeomList.append(f.geometry().asPolyline()) polyGeom = self.removeBadLines(outGeomList) if len(polyGeom) <> 0: outFeat.setGeometry(QgsGeometry.fromPolygon(polyGeom)) attrs = f.attributes() outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): '''Here is where the processing itself takes place''' #the first thing to do is retrieve the values of the parameters #entered by the user inputFilename = self.getParameterValue(self.INPUT_LAYER) output = self.getOutputFromName(self.OUTPUT_LAYER) #input layers values are always a string with its location. #That string can be converted into a QGIS object (a QgsVectorLayer in this case)) #using the Processing.getObject() method vectorLayer = QGisLayers.getObjectFromUri(inputFilename) #And now we can process #First we create the output layer. #To do so, we call the getVectorWriter method in the Output object. #That will give as a ProcessingVectorWriter, that we can later use to add features. provider = vectorLayer.dataProvider() writer = output.getVectorWriter( provider.fields(), provider.geometryType(), vectorLayer.crs() ) #Now we take the selected features and add them to the output layer features = QGisLayers.features(vectorLayer) total = len(features) i = 0 for feat in features: writer.addFeature(feat) progress.setPercentage(100 * i / float(total)) i += 1 del writer
def processAlgorithm(self, progress): inLayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.INPUT_LAYER)) inField = self.getParameterValue(self.INPUT_FIELD) targetLayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.TARGET_LAYER)) targetField = self.getParameterValue(self.TARGET_FIELD) matType = self.getParameterValue(self.MATRIX_TYPE) nPoints = self.getParameterValue(self.NEAREST_POINTS) outputFile = self.getOutputValue(self.DISTANCE_MATRIX) if nPoints < 1: nPoints = len(QGisLayers.features(targetLayer)) # prepare CSV file writer csvFile = open(outputFile, "wb") self.writer = UnicodeWriter(csvFile) if matType == 0: # Linear distance matrix self.linearMatrix(inLayer, inField, targetLayer, targetField, matType, nPoints, progress) elif matType == 1: # Standard distance matrix self.regularMatrix(inLayer, inField, targetLayer, targetField, nPoints, progress) elif matType == 2: # Summary distance matrix self.linearMatrix(inLayer, inField, targetLayer, targetField, matType, nPoints, progress) csvFile.close() del self.writer
def processAlgorithm(self, progress): inLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER)) inField = self.getParameterValue(self.INPUT_FIELD) targetLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.TARGET_LAYER)) targetField = self.getParameterValue(self.TARGET_FIELD) matType = self.getParameterValue(self.MATRIX_TYPE) nPoints = self.getParameterValue(self.NEAREST_POINTS) outputFile = self.getOutputValue(self.DISTANCE_MATRIX) if nPoints < 1: nPoints = len(QGisLayers.features(targetLayer)) # prepare CSV file writer csvFile = open(outputFile, "wb") self.writer = UnicodeWriter(csvFile) if matType == 0: # Linear distance matrix self.linearMatrix(inLayer, inField, targetLayer, targetField, matType, nPoints, progress) elif matType == 1: # Standard distance matrix self.regularMatrix(inLayer, inField, targetLayer, targetField, nPoints, progress) elif matType == 2: # Summary distance matrix self.linearMatrix(inLayer, inField, targetLayer, targetField, matType, nPoints, progress) csvFile.close() del self.writer
def processAlgorithm(self, progress): source = self.getParameterValue(self.INPUT) vlayer = QGisLayers.getObjectFromUri(source) output = self.getOutputFromName(self.OUTPUT) vprovider = vlayer.dataProvider() fields = vprovider.fields() writer = output.getVectorWriter(fields, QGis.WKBPoint, self.crs) xfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.XFIELD)) yfieldindex = vlayer.fieldNameIndex(self.getParameterValue(self.YFIELD)) crsId = self.getParameterValue(self.TARGET_CRS) targetCrs = QgsCoordinateReferenceSystem(crsId) self.crs = targetCrs outFeat = QgsFeature() nElement = 0 features = QGisLayers.features(vlayer) nFeat = len(features) for feature in features: nElement += 1 progress.setPercentage((nElement*100)/nFeat) attrs = feature.attributes() try: x = float(attrs[xfieldindex]) y = float(attrs[yfieldindex]) except: continue pt = QgsPoint(x, y) outFeat.setGeometry(QgsGeometry.fromPoint(pt)) outFeat.setAttributes(attrs) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER)) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( layer.pendingFields().toList(), QGis.WKBPoint, layer.crs() ) outFeat = QgsFeature() features = QGisLayers.features(layer) total = 100.0 / float(len(features)) current = 0 for inFeat in features: inGeom = inFeat.geometry() attrs = inFeat.attributes() outGeom = QgsGeometry(inGeom.centroid()) if outGeom is None: raise GeoAlgorithmExecutionException("Error calculating centroid") outFeat.setGeometry(outGeom) outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.LAYERNAME)) attribute = self.getParameterValue(self.ATTRIBUTE) idx = layer.fieldNameIndex(attribute) fields = layer.pendingFields() fields[idx] = QgsField(fields[idx].name(), QVariant.Double) output = self.getOutputFromName(self.SAVENAME) out = output.getVectorWriter(fields, layer.wkbType(), layer.crs()) i = 0 features = QGisLayers.features(layer) featurecount = len(features) for feature in features: i+=1 progress.setPercentage(float(i) / featurecount * 100) attributes = feature.attributes() try: v = unicode(attributes[idx]) if '%' in v: v = v.replace('%', "") attributes[idx] = float(attributes[idx]) / float(100) else: attributes[idx] = float(attributes[idx]) except: attributes[idx] = None feature.setAttributes(attributes) out.addFeature(feature) del out
def calculateResamplingExtent(self): '''this method calculates the resampling extent, but it might set self.resample to false if, with the current layers, there is no need to resample''' auto = ProcessingConfig.getSetting(SagaUtils.SAGA_AUTO_RESAMPLING) if auto: first = True; self.inputExtentsCount = 0 for param in self.parameters: if param.value: if isinstance(param, ParameterRaster): if isinstance(param.value, QgsRasterLayer): layer = param.value else: layer = QGisLayers.getObjectFromUri(param.value) self.addToResamplingExtent(layer, first) first = False if isinstance(param, ParameterMultipleInput): if param.datatype == ParameterMultipleInput.TYPE_RASTER: layers = param.value.split(";") for layername in layers: layer = QGisLayers.getObjectFromUri(layername) self.addToResamplingExtent(layer, first) first = False if self.inputExtentsCount < 2: self.resample = False else: self.xmin = ProcessingConfig.getSetting(SagaUtils.SAGA_RESAMPLING_REGION_XMIN) self.xmax = ProcessingConfig.getSetting(SagaUtils.SAGA_RESAMPLING_REGION_XMAX) self.ymin = ProcessingConfig.getSetting(SagaUtils.SAGA_RESAMPLING_REGION_YMIN) self.ymax = ProcessingConfig.getSetting(SagaUtils.SAGA_RESAMPLING_REGION_YMAX) self.cellsize = ProcessingConfig.getSetting(SagaUtils.SAGA_RESAMPLING_REGION_CELLSIZE)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.LAYERNAME)) idx = layer.fieldNameIndex(self.getParameterValue(self.COLUMN)) output = self.getOutputFromName(self.SAVENAME) fields = layer.pendingFields() newFields = [] i = 0 for field in fields: if i != idx: newFields.append(field) i += 1 outfile = output.getVectorWriter(newFields, layer.wkbType(), layer.crs() ) features = QGisLayers.features(layer) featurecount = len(features) i = 0 outFeat = QgsFeature() for feature in features: progress.setPercentage(float(i) /featurecount * 100) i += 1 outFeat.setGeometry(feature.geometry()) attributes = feature.attributes() newAttributes = [] i = 0 for attr in attributes: if i != idx: newAttributes.append(attr) i += 1 feature.setAttributes(newAttributes) outfile.addFeature(feature)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) crsId = self.getParameterValue(self.TARGET_CRS) targetCrs = QgsCoordinateReferenceSystem(crsId) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), layer.wkbType(), targetCrs) layerCrs = layer.crs() crsTransform = QgsCoordinateTransform(layerCrs, targetCrs) outFeat = QgsFeature() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: geom = f.geometry() geom.transform(crsTransform) outFeat.setGeometry(geom) outFeat.setAttributes(f.attributes()) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer self.crs = targetCrs
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) geomType = self.multiToSingleGeom(layer.dataProvider().geometryType()) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), geomType, layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: inGeom = f.geometry() attrs = f.attributes() geometries = self.extractAsSingle(inGeom) outFeat.setAttributes(attrs) for g in geometries: outFeat.setGeometry(g) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def getDefaultCellsize(self): cellsize = 0 for param in self.parameters: if param.value: if isinstance(param, ParameterRaster): if isinstance(param.value, QgsRasterLayer): layer = param.value else: layer = QGisLayers.getObjectFromUri(param.value) cellsize = max(cellsize, (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width()) elif isinstance(param, ParameterMultipleInput): layers = param.value.split(";") for layername in layers: layer = QGisLayers.getObjectFromUri(layername) if isinstance(layer, QgsRasterLayer): cellsize = max(cellsize, (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width()) if cellsize == 0: cellsize = 1 return cellsize
def convertUnsupportedFormats(self, progress): i = 0 progress.setText("Converting outputs") for out in self.outputs: if isinstance(out, OutputVector): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) if layer is None: # for the case of memory layer, if the getCompatible method has been called continue provider = layer.dataProvider() writer = out.getVectorWriter( provider.fields(), provider.geometryType(), layer.crs()) features = QGisLayers.features(layer) for feature in features: writer.addFeature(feature) elif isinstance(out, OutputRaster): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) provider = layer.dataProvider() writer = QgsRasterFileWriter(out.value) format = self.getFormatShortNameFromFilename(out.value) writer.setOutputFormat(format); writer.writeRaster(layer.pipe(), layer.width(), layer.height(), layer.extent(), layer.crs()) elif isinstance(out, OutputTable): if out.compatible is not None: layer = QGisLayers.getObjectFromUri(out.compatible) provider = layer.dataProvider() writer = out.getTableWriter(provider.fields()) features = QGisLayers.features(layer) for feature in features: writer.addRecord(feature) progress.setPercentage(100 * i / float(len(self.outputs)))
def getMinCoveringExtent(self): first = True found = False for param in self.params: if param.value: if isinstance(param, (ParameterRaster, ParameterVector)): if isinstance(param.value, (QgsRasterLayer, QgsVectorLayer)): layer = param.value else: layer = QGisLayers.getObjectFromUri(param.value) if layer: found = True self.addToRegion(layer, first) first = False elif isinstance(param, ParameterMultipleInput): layers = param.value.split(";") for layername in layers: layer = QGisLayers.getObjectFromUri(layername, first) if layer: found = True self.addToRegion(layer, first) first = False if found: return str(self.xmin) + "," + str(self.xmax) + "," + str(self.ymin) + "," + str(self.ymax) else: return None
def processAlgorithm(self, progress): source = self.getParameterValue(self.INPUT) vlayer = QGisLayers.getObjectFromUri(source) output = self.getOutputFromName(self.OUTPUT) vprovider = vlayer.dataProvider() fields = vprovider.fields() writer = output.getVectorWriter(fields, QGis.WKBPoint, self.crs) xfieldindex = vlayer.fieldNameIndex(self.getParameterValue( self.XFIELD)) yfieldindex = vlayer.fieldNameIndex(self.getParameterValue( self.YFIELD)) crsId = self.getParameterValue(self.TARGET_CRS) targetCrs = QgsCoordinateReferenceSystem(crsId) self.crs = targetCrs outFeat = QgsFeature() nElement = 0 features = QGisLayers.features(vlayer) nFeat = len(features) for feature in features: nElement += 1 progress.setPercentage((nElement * 100) / nFeat) attrs = feature.attributes() try: x = float(attrs[xfieldindex]) y = float(attrs[yfieldindex]) except: continue pt = QgsPoint(x, y) outFeat.setGeometry(QgsGeometry.fromPoint(pt)) outFeat.setAttributes(attrs) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): output = self.getOutputFromName(self.OUTPUT) vlayer = QGisLayers.getObjectFromUri(self.getParameterValue( self.INPUT)) vprovider = vlayer.dataProvider() fields = vprovider.fields() fields.append(QgsField("AUTO", QVariant.Int)) writer = output.getVectorWriter(fields, vprovider.geometryType(), vlayer.crs()) inFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() nElement = 0 features = QGisLayers.features(vlayer) nFeat = len(features) for inFeat in features: progress.setPercentage(int((100 * nElement) / nFeat)) nElement += 1 inGeom = inFeat.geometry() outFeat.setGeometry(inGeom) attrs = inFeat.attributes() attrs.append(nElement) outFeat.setAttributes(attrs) writer.addFeature(outFeat) del writer
def exportVectorLayer(self, orgFilename): # TODO: improve this. We are now exporting if it is not a shapefile, # but the functionality of v.in.ogr could be used for this. # We also export if there is a selection if not os.path.exists(orgFilename) or not orgFilename.endswith("shp"): layer = QGisLayers.getObjectFromUri(orgFilename, False) if layer: filename = LayerExporter.exportVectorLayer(layer) else: layer = QGisLayers.getObjectFromUri(orgFilename, False) if layer: useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED) if useSelection and layer.selectedFeatureCount() != 0: filename = LayerExporter.exportVectorLayer(layer) else: filename = orgFilename else: filename = orgFilename destFilename = self.getTempFilename() self.exportedLayers[orgFilename] = destFilename command = "v.in.ogr" min_area = self.getParameterValue(self.GRASS_MIN_AREA_PARAMETER) command += " min_area=" + str(min_area) snap = self.getParameterValue(self.GRASS_SNAP_TOLERANCE_PARAMETER) command += " snap=" + str(snap) command += ' dsn="' + os.path.dirname(filename) + '"' command += " layer=" + os.path.basename(filename)[:-4] command += " output=" + destFilename command += " --overwrite -o" return command
def getMinCoveringExtent(self): first = True found = False for param in self.params: if param.value: if isinstance(param, (ParameterRaster, ParameterVector)): if isinstance(param.value, (QgsRasterLayer, QgsVectorLayer)): layer = param.value else: layer = QGisLayers.getObjectFromUri(param.value) if layer: found = True self.addToRegion(layer, first) first = False elif isinstance(param, ParameterMultipleInput): layers = param.value.split(";") for layername in layers: layer = QGisLayers.getObjectFromUri(layername, first) if layer: found = True self.addToRegion(layer, first) first = False if found: return str(self.xmin) + "," + str(self.xmax) + "," + str( self.ymin) + "," + str(self.ymax) else: return None
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER)) valuesFieldName = self.getParameterValue(self.VALUES_FIELD_NAME) categoriesFieldName = self.getParameterValue(self.CATEGORIES_FIELD_NAME) output = self.getOutputFromName(self.OUTPUT) valuesField = layer.fieldNameIndex(valuesFieldName) categoriesField = layer.fieldNameIndex(categoriesFieldName) features = QGisLayers.features(layer) nFeats = len(features) values = {} nFeat = 0 for feat in features: nFeat += 1 progress.setPercentage(int((100 * nFeats) / nFeat)) attrs = feat.attributes() try: value = float(attrs[valuesField]) cat = unicode(attrs[categoriesField]) if cat not in values: values[cat] = [] values[cat].append(value) except: pass fields = [QgsField("category", QVariant.String), QgsField("min", QVariant.Double), QgsField("max", QVariant.Double), QgsField("mean", QVariant.Double), QgsField("stddev", QVariant.Double)] writer = output.getTableWriter(fields) for cat, v in values.items(): min, max, mean, stddev = calculateStats(v) record = [cat, min, max, mean, stddev] writer.addRecord(record)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), QGis.WKBPoint, layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: inGeom = f.geometry() attrs = f.attributes() points = utils.extractPoints(inGeom) outFeat.setAttributes(attrs) for i in points: outFeat.setGeometry(outGeom.fromPoint(i)) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) crsId = self.getParameterValue(self.TARGET_CRS) targetCrs = QgsCoordinateReferenceSystem(crsId) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.pendingFields().toList(), layer.wkbType(), targetCrs) layerCrs = layer.crs() crsTransform = QgsCoordinateTransform(layerCrs, targetCrs) outFeat = QgsFeature() current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) for f in features: geom = f.geometry() geom.transform(crsTransform) outFeat.setGeometry(geom) outFeat.setAttributes(f.attributes()) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer self.crs = targetCrs
def processAlgorithm(self, progress): '''Here is where the processing itself takes place''' # the first thing to do is retrieve the values of the parameters # entered by the user inputFilename = self.getParameterValue(self.INPUT_LAYER) output = self.getOutputValue(self.OUTPUT_LAYER) # input layers vales are always a string with its location. # That string can be converted into a QGIS object (a QgsVectorLayer in # this case) using the Processing.getObjectFromUri() method. vectorLayer = QGisLayers.getObjectFromUri(inputFilename) # And now we can process # First we create the output layer. The output value entered by the user # is a string containing a filename, so we can use it directly settings = QSettings() systemEncoding = settings.value( "/UI/encoding", "System" ) provider = vectorLayer.dataProvider() writer = QgsVectorFileWriter(output, systemEncoding, provider.fields(), provider.geometryType(), provider.crs() ) # Now we take the features from input layer and add them to the output. # Method features() returns an iterator, considering the selection that # might exist in layer and the configuration that indicates # should algorithm use only selected features or all of them features = QGisLayers.features(vectorLayer) for f in features: writer.addFeature(f)
def processAlgorithm(self, progress): polyLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.POLYGONS)) pointLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.POINTS)) fieldName = self.getParameterValue(self.FIELD) fieldIdx = pointLayer.fieldNameIndex(self.getParameterValue(self.WEIGHT)) polyProvider = polyLayer.dataProvider() idxCount, fieldList = utils.findOrCreateField(polyLayer, polyLayer.pendingFields(), fieldName) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList.toList(), polyProvider.geometryType(), polyProvider.crs()) spatialIndex = utils.createSpatialIndex(pointLayer) ftPoint = QgsFeature() outFeat = QgsFeature() geom = QgsGeometry() current = 0 hasIntersections = False features = QGisLayers.features(polyLayer) total = 100.0 / float(len(features)) for ftPoly in features: geom = ftPoly.geometry() attrs = ftPoly.attributes() count = 0 hasIntersections = False points = spatialIndex.intersects(geom.boundingBox()) if len(points) > 0: hasIntersections = True if hasIntersections: progress.setText(str(len(points))) for i in points: request = QgsFeatureRequest().setFilterFid(i) ftPoint = pointLayer.getFeatures(request).next() tmpGeom = QgsGeometry(ftPoint.geometry()) if geom.contains(tmpGeom): weight = str(ftPoint.attributes()[fieldIdx]) try: count += float(weight) except: pass #ignore fields with non-numeric values outFeat.setGeometry(geom) if idxCount == len(attrs): attrs.append(count) else: attrs[idxCount] = count outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def getFileFilter(self): if self.datatype == ParameterMultipleInput.TYPE_RASTER: exts = QGisLayers.getSupportedOutputRasterLayerExtensions() else: exts = QGisLayers.getSupportedOutputVectorLayerExtensions() for i in range(len(exts)): exts[i] = exts[i].upper() + " files(*." + exts[i].lower() + ")" return ";;".join(exts)
def processAlgorithm(self, progress): layerA = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.INPUT)) layerB = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.OVERLAY)) GEOS_EXCEPT = True FEATURE_EXCEPT = True writer = self.getOutputFromName(Difference.OUTPUT).getVectorWriter(layerA.pendingFields(), layerA.dataProvider().geometryType(), layerA.dataProvider().crs()) inFeatA = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() index = utils.createSpatialIndex(layerB) selectionA = QGisLayers.features(layerA) current = 0 total = 100.0 / float(len(selectionA)) for inFeatA in selectionA: add = True geom = QgsGeometry(inFeatA.geometry()) diff_geom = QgsGeometry(geom) attrs = inFeatA.attributes() intersections = index.intersects(geom.boundingBox()) for i in intersections: request = QgsFeatureRequest().setFilterFid(i) inFeatB = layerB.getFeatures(request).next() tmpGeom = QgsGeometry(inFeatB.geometry()) try: if diff_geom.intersects(tmpGeom): diff_geom = QgsGeometry(diff_geom.difference(tmpGeom)) except: GEOS_EXCEPT = False add = False break if add: try: outFeat.setGeometry(diff_geom) outFeat.setAttributes(attrs) writer.addFeature(outFeat) except: FEATURE_EXCEPT = False continue current += 1 progress.setPercentage(int(current * total)) del writer if not GEOS_EXCEPT: ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, "Geometry exception while computing difference") if not FEATURE_EXCEPT: ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, "Feature exception while computing difference")
def processAlgorithm(self, progress): layer1 = QGisLayers.getObjectFromUri(self.getParameterValue(self.LAYER1)) layer2 = QGisLayers.getObjectFromUri(self.getParameterValue(self.LAYER2)) fields = [] layers = [layer1, layer2] totalfeaturecount = 0 if (layer1.dataProvider().geometryType() != layer2.dataProvider().geometryType()): raise GeoAlgorithmExecutionException("Merged layers must all be same type of geometry (" + \ mmqgisx_wkbtype_to_text(layer2.dataProvider().geometryType()) + " != " + \ mmqgisx_wkbtype_to_text(layer2.dataProvider().geometryType()) + ")") for layer in layers: totalfeaturecount += layer.featureCount() # Add any fields not in the composite field list for sfield in layer.pendingFields(): found = None for dfield in fields: if (dfield.name() == sfield.name()) and (dfield.type() == sfield.type()): found = dfield break if not found: fields.append(sfield) output = self.getOutputFromName(self.SAVENAME) out = output.getVectorWriter(fields, layer1.wkbType(), layer1.crs()) # Copy layer features to output file featurecount = 0 for layer in layers: idx = {} for dfield in fields: i = 0 for sfield in layer.pendingFields(): if (sfield.name() == dfield.name()) and (sfield.type() == dfield.type()): idx[dfield] = i break i += 1 features = QGisLayers.features(layer) for feature in features: sattributes = feature.attributes() dattributes = [] for dfield in fields: if (dfield in idx): dattributes.append(sattributes[idx[dfield]]) else: dattributes.append(dfield.type()) feature.setAttributes(dattributes) out.addFeature(feature) featurecount += 1 progress.setPercentage(float(featurecount) / totalfeaturecount * 100) del out
def processAlgorithm(self, progress): polyLayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.POLYGONS)) pointLayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.POINTS)) fieldName = self.getParameterValue(self.FIELD) polyProvider = polyLayer.dataProvider() idxCount, fieldList = utils.findOrCreateField( polyLayer, polyLayer.pendingFields(), fieldName) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fieldList.toList(), polyProvider.geometryType(), polyProvider.crs()) spatialIndex = utils.createSpatialIndex(pointLayer) ftPoly = QgsFeature() ftPoint = QgsFeature() outFeat = QgsFeature() geom = QgsGeometry() current = 0 hasIntersections = False features = QGisLayers.features(polyLayer) total = 100.0 / float(len(features)) for ftPoly in features: geom = ftPoly.geometry() attrs = ftPoly.attributes() count = 0 hasIntersections = False points = spatialIndex.intersects(geom.boundingBox()) if len(points) > 0: hasIntersections = True if hasIntersections: for i in points: request = QgsFeatureRequest().setFilterFid(i) ftPoint = pointLayer.getFeatures(request).next() tmpGeom = QgsGeometry(ftPoint.geometry()) if geom.contains(tmpGeom): count += 1 outFeat.setGeometry(geom) if idxCount == len(attrs): attrs.append(count) else: attrs[idxCount] = count outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): polyLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.POLYGONS)) pointLayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.POINTS)) fieldName = self.getParameterValue(self.FIELD) classFieldName = self.getParameterValue(self.CLASSFIELD) polyProvider = polyLayer.dataProvider() classFieldIndex = pointLayer.fieldNameIndex(classFieldName) idxCount, fieldList = utils.findOrCreateField(polyLayer, polyLayer.pendingFields(), fieldName) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fieldList.toList(), polyProvider.geometryType(), polyProvider.crs() ) spatialIndex = utils.createSpatialIndex(pointLayer) ftPoint = QgsFeature() outFeat = QgsFeature() geom = QgsGeometry() current = 0 hasIntersections = False features = QGisLayers.features(polyLayer) total = 100.0 / float(len(features)) for ftPoly in features: geom = ftPoly.geometry() attrs = ftPoly.attributes() classes = [] hasIntersections = False points = spatialIndex.intersects(geom.boundingBox()) if len(points) > 0: hasIntersections = True if hasIntersections: for i in points: request = QgsFeatureRequest().setFilterFid(i) ftPoint = pointLayer.getFeatures(request).next() tmpGeom = QgsGeometry(ftPoint.geometry()) if geom.contains(tmpGeom): clazz = ftPoint.attributes()[classFieldIndex] if not clazz in classes: classes.append(clazz) outFeat.setGeometry(geom) if idxCount == len(attrs): attrs.append(len(classes)) else: attrs[idxCount] = len(classes) outFeat.setAttributes(attrs) writer.addFeature(outFeat) current += 1 progress.setPercentage(current / total) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs()) inFeat = QgsFeature() outFeat = QgsFeature() extent = layer.extent() height = extent.height() width = extent.width() c = voronoi.Context() pts = [] ptDict = {} ptNdx = -1 features = QGisLayers.features(layer) for inFeat in features: geom = QgsGeometry(inFeat.geometry()) point = geom.asPoint() x = point.x() - extent.xMinimum() y = point.y() - extent.yMinimum() pts.append((x, y)) ptNdx += 1 ptDict[ptNdx] = inFeat.id() if len(pts) < 3: raise GeoAlgorithmExecutionException( "Input file should contain at least 3 points. Choose another file and try again." ) uniqueSet = Set(item for item in pts) ids = [pts.index(item) for item in uniqueSet] sl = voronoi.SiteList([ voronoi.Site(i[0], i[1], sitenum=j) for j, i in enumerate(uniqueSet) ]) voronoi.voronoi(sl, c) inFeat = QgsFeature() current = 0 total = 100.0 / float(len(c.polygons)) for site, edges in c.polygons.iteritems(): request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]]) inFeat = layer.getFeatures(request).next() lines = self.clip_voronoi(edges, c, width, height, extent, 0, 0) geom = QgsGeometry.fromMultiPoint(lines) geom = QgsGeometry(geom.convexHull()) outFeat.setGeometry(geom) outFeat.setAttributes(inFeat.attributes()) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue( self.POINTS)) weightField = self.getParameterValue(self.WEIGHT) uniqueField = self.getParameterValue(self.UID) weightIndex = layer.fieldNameIndex(weightField) uniqueIndex = layer.fieldNameIndex(uniqueField) fieldList = [ QgsField("MEAN_X", QVariant.Double, "", 24, 15), QgsField("MEAN_Y", QVariant.Double, "", 24, 15), QgsField("UID", QVariant.String, "", 255) ] writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fieldList, QGis.WKBPoint, layer.crs()) current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) means = {} for feat in features: current += 1 progress.setPercentage(current * total) clazz = str(feat.attributes()[uniqueIndex]).strip() if weightIndex == -1: weight = 1.00 else: try: weight = float(feat.attributes()[weightIndex]) except: weight = 1.00 if clazz not in means: means[clazz] = (0, 0, 0) cx, cy, totalweight = means[clazz] geom = QgsGeometry(feat.geometry()) geom = utils.extractPoints(geom) for i in geom: cx += i.x() * weight cy += i.y() * weight totalweight += weight means[clazz] = (cx, cy, totalweight) for clazz, values in means.iteritems(): outFeat = QgsFeature() cx = values[0] / values[2] cy = values[1] / values[2] meanPoint = QgsPoint(cx, cy) outFeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outFeat.setAttributes([cx, cy, clazz]) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = QGisLayers.getObjectFromUri(filename) field = self.getParameterValue(self.FIELD) method = self.getParameterValue(self.METHOD) layer.removeSelection() index = layer.fieldNameIndex(field) unique = utils.getUniqueValues(layer, index) featureCount = layer.featureCount() value = int(self.getParameterValue(self.NUMBER)) if method == 0: if value > featureCount: raise GeoAlgorithmExecutionException("Selected number is greater that feature count. Choose lesser value and try again.") else: if value > 100: raise GeoAlgorithmExecutionException("Persentage can't be greater than 100. Set corrent value and try again.") value = value / 100.0 selran = [] inFeat = QgsFeature() current = 0 total = 100.0 / float(featureCount * len(unique)) features = QGisLayers.features(layer) if not len(unique) == featureCount: for i in unique: FIDs= [] for inFeat in features: attrs = inFeat.attributes() if attrs[index] == i: FIDs.append(inFeat.id()) current += 1 progress.setPercentage(int(current * total)) if method == 1: selValue = int(round(value * len(FIDs), 0)) else: selValue = value if selValue >= len(FIDs): selFeat = FIDs else: selFeat = random.sample(FIDs, selValue) selran.extend(selFeat) layer.setSelectedFeatures(selran) else: layer.setSelectedFeatures(range(0, featureCount)) self.setOutputValue(self.OUTPUT, filename)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.POINTS)) weightField = self.getParameterValue(self.WEIGHT) uniqueField = self.getParameterValue(self.UID) weightIndex = layer.fieldNameIndex(weightField) uniqueIndex = layer.fieldNameIndex(uniqueField) fieldList = [QgsField("MEAN_X", QVariant.Double, "", 24, 15), QgsField("MEAN_Y", QVariant.Double, "", 24, 15), QgsField("UID", QVariant.String, "", 255) ] writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QGis.WKBPoint, layer.crs()) current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features)) means = {} for feat in features: current += 1 progress.setPercentage(current * total) clazz = str(feat.attributes()[uniqueIndex]).strip() if weightIndex == -1: weight = 1.00 else: try: weight = float(feat.attributes()[weightIndex]) except: weight = 1.00 if clazz not in means: means[clazz] = (0,0,0) cx,cy, totalweight = means[clazz] geom = QgsGeometry(feat.geometry()) geom = utils.extractPoints(geom) for i in geom: cx += i.x() * weight cy += i.y() * weight totalweight += weight means[clazz] = (cx, cy, totalweight) for clazz, values in means.iteritems(): outFeat = QgsFeature() cx = values[0] / values[2] cy = values[1] / values[2] meanPoint = QgsPoint(cx, cy) outFeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outFeat.setAttributes([cx, cy, clazz]) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): try: from shapely.ops import polygonize from shapely.geometry import Point, MultiLineString except ImportError: raise GeoAlgorithmExecutionException( 'Polygonize algorithm requires shapely module!') vlayer = QGisLayers.getObjectFromUri(self.getParameterValue( self.INPUT)) output = self.getOutputFromName(self.OUTPUT) vprovider = vlayer.dataProvider() if self.getParameterValue(self.FIELDS): fields = vprovider.fields() else: fields = QgsFields() if self.getParameterValue(self.GEOMETRY): fieldsCount = fields.count() fields.append(QgsField("area", QVariant.Double, "double", 16, 2)) fields.append( QgsField("perimeter", QVariant.Double, "double", 16, 2)) allLinesList = [] features = QGisLayers.features(vlayer) current = 0 total = 40.0 / float(len(features)) for inFeat in features: inGeom = inFeat.geometry() if inGeom.isMultipart(): allLinesList.extend(inGeom.asMultiPolyline()) else: allLinesList.append(inGeom.asPolyline()) current += 1 progress.setPercentage(int(current * total)) progress.setPercentage(40) allLines = MultiLineString(allLinesList) allLines = allLines.union(Point(0, 0)) progress.setPercentage(45) polygons = list(polygonize([allLines])) progress.setPercentage(50) writer = output.getVectorWriter(fields, QGis.WKBPolygon, vlayer.crs()) outFeat = QgsFeature() current = 0 total = 50.0 / float(len(polygons)) for polygon in polygons: outFeat.setGeometry(QgsGeometry.fromWkt(polygon.wkt)) if self.getParameterValue(self.GEOMETRY): outFeat.setAttributes([None] * fieldsCount + [polygon.area, polygon.length]) writer.addFeature(outFeat) current += 1 progress.setPercentage(50 + int(current * total)) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT)) output = self.getOutputValue(self.OUTPUT) fieldName = self.getParameterValue(self.FIELD) geomType = self.singleToMultiGeom(layer.dataProvider().geometryType()) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields().toList(), geomType, layer.crs()) inFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() index = layer.fieldNameIndex(fieldName) unique = utils.getUniqueValues(layer, index) current = 0 features = QGisLayers.features(layer) total = 100.0 / float(len(features) * len(unique)) if not len(unique) == layer.featureCount(): for i in unique: multi_feature = [] first = True features = QGisLayers.features(layer) for inFeat in features: atMap = inFeat.attributes() idVar = atMap[index] if unicode(idVar).strip() == unicode(i).strip(): if first: attrs = atMap first = False inGeom = QgsGeometry(inFeat.geometry()) vType = inGeom.type() feature_list = self.extractAsMulti(inGeom) multi_feature.extend(feature_list) current += 1 progress.setPercentage(int(current * total)) outFeat.setAttributes(attrs) outGeom = QgsGeometry( self.convertGeometry(multi_feature, vType)) outFeat.setGeometry(outGeom) writer.addFeature(outFeat) del writer else: raise GeoAlgorithmExecutionException("Invalid unique ID field")
def processAlgorithm(self, progress): fieldName = self.getParameterValue(self.FIELD_NAME) fieldType = self.getParameterValue(self.FIELD_TYPE) fieldLength = self.getParameterValue(self.FIELD_LENGTH) fieldPrecision = self.getParameterValue(self.FIELD_PRECISION) formula = self.getParameterValue(self.FORMULA) output = self.getOutputFromName(self.OUTPUT_LAYER) layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.INPUT_LAYER)) provider = layer.dataProvider() fields = provider.fields() fields.append( QgsField(fieldName, self.TYPES[fieldType], "", fieldLength, fieldPrecision)) writer = output.getVectorWriter(fields, provider.geometryType(), layer.crs()) outFeat = QgsFeature() inGeom = QgsGeometry() nFeat = provider.featureCount() nElement = 0 features = QGisLayers.features(layer) fieldnames = [field.name() for field in provider.fields()] fieldnames.sort(key=len, reverse=False) fieldidx = [ fieldnames.index(field.name()) for field in provider.fields() ] print fieldidx for inFeat in features: progress.setPercentage(int((100 * nElement) / nFeat)) attrs = inFeat.attributes() expression = formula for idx in fieldidx: expression = expression.replace(unicode(fields[idx].name()), unicode(attrs[idx])) try: result = eval(expression) except Exception: result = None nElement += 1 inGeom = inFeat.geometry() outFeat.setGeometry(inGeom) attrs = inFeat.attributes() attrs.append(result) outFeat.setAttributes(attrs) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): input = self.getParameterValue(self.INPUT_LAYER) input2 = self.getParameterValue(self.INPUT_LAYER_2) output = self.getOutputFromName(self.OUTPUT_LAYER) field = self.getParameterValue(self.TABLE_FIELD) field2 = self.getParameterValue(self.TABLE_FIELD_2) # Layer 1 layer = QGisLayers.getObjectFromUri(input) provider = layer.dataProvider() joinField1Index = layer.fieldNameIndex(field) # Layer 2 layer2 = QGisLayers.getObjectFromUri(input2) provider2 = layer2.dataProvider() joinField2Index = layer2.fieldNameIndex(field2) # Output outFields = [] outFields.extend(provider.fields()) outFields.extend(provider2.fields()) writer = output.getVectorWriter(outFields, provider.geometryType(), layer.crs()) inFeat = QgsFeature() inFeat2 = QgsFeature() outFeat = QgsFeature() # Create output vector layer with additional attribute features = QGisLayers.features(layer); for inFeat in features: inGeom = inFeat.geometry() attrs = inFeat.attributes() joinValue1 = attrs[joinField1Index] features2 = QGisLayers.features(layer2); for inFeat2 in features2: ## Maybe it should cache this entries... attrs2 = inFeat2.attributes() joinValue2 = attrs2[joinField2Index] if joinValue1 == joinValue2: # create the new feature outFeat.setGeometry(inGeom) attrs.extend(attrs2) break; outFeat.setAttributes(attrs) writer.addFeature(outFeat) del writer
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER)) byFeature = self.getParameterValue(self.BY_FEATURE) fields = [ QgsField("MINX", QVariant.Double), QgsField("MINY", QVariant.Double), QgsField("MAXX", QVariant.Double), QgsField("MAXY", QVariant.Double), QgsField("CNTX", QVariant.Double), QgsField("CNTY", QVariant.Double), QgsField("AREA", QVariant.Double), QgsField("PERIM", QVariant.Double), QgsField("HEIGHT", QVariant.Double), QgsField("WIDTH", QVariant.Double) ] writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPolygon, layer.crs()) if byFeature: self.featureExtent(layer, writer, progress) else: self.layerExtent(layer, writer, progress) del writer