def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = QGisLayers.getObjectFromUri(filename) method = self.getParameterValue(self.METHOD) featureCount = layer.featureCount() value = int(self.getParameterValue(self.NUMBER)) layer.removeSelection(True) if method == 0: if value > featureCount: raise GeoAlgorithmExecutionException( "Selected number is greater than feature count. Choose a lower value and try again." ) else: if value > 100: raise GeoAlgorithmExecutionException( "Percentage can't be greater than 100. Set a different value and try again." ) value = int(round((value / 100.0000), 4) * featureCount) selran = random.sample(xrange(0, featureCount), value) layer.setSelectedFeatures(selran) self.setOutputValue(self.OUTPUT, filename)
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] == QVariant(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 prepareAlgorithm(self, alg, iAlg): for param in alg.parameters: aap = self.algParameters[iAlg][param.name] if aap == None: continue if isinstance(param, ParameterMultipleInput): value = self.getValueFromAlgorithmAndParameter(aap) tokens = value.split(";") layerslist = [] for token in tokens: i, paramname = token.split("|") aap = AlgorithmAndParameter(int(i), paramname) value = self.getValueFromAlgorithmAndParameter(aap) layerslist.append(str(value)) value = ";".join(layerslist) if not param.setValue(value): raise GeoAlgorithmExecutionException("Wrong value: " + str(value)) else: value = self.getValueFromAlgorithmAndParameter(aap) if not param.setValue(value): raise GeoAlgorithmExecutionException("Wrong value: " + str(value)) for out in alg.outputs: val = self.algOutputs[iAlg][out.name] if val: name = self.getSafeNameForOutput(iAlg, out) out.value = self.getOutputFromName(name).value else: out.value = None
def processAlgorithm(self, progress): '''Here is where the processing itself takes place''' if not gdalAvailable: raise GeoAlgorithmExecutionException("GDAL bindings not installed.") input = self.getParameterValue(self.INPUT_LAYER) ogrLayer = self.ogrConnectionString(input) output = self.getOutputFromName(self.OUTPUT_LAYER) outfile = output.value formatIdx = self.getParameterValue(self.DEST_FORMAT) ext = EXTS[formatIdx] if not outfile.endswith(ext): outfile = outfile + ext; output.value = outfile dst_ds = self.ogrConnectionString(outfile) dst_format = FORMATS[formatIdx] ogr_dsco = [self.getParameterValue(self.DEST_DSCO)] poDS = ogr.Open( ogrLayer, False ) if poDS is None: raise GeoAlgorithmExecutionException(self.failure(ogrLayer)) if dst_format == "SQLite" and os.path.isfile(dst_ds): os.remove(dst_ds) driver = ogr.GetDriverByName(str(dst_format)) poDstDS = driver.CreateDataSource(dst_ds, options = ogr_dsco) if poDstDS is None: raise GeoAlgorithmExecutionException("Error creating %s" % dst_ds) return self.ogrtransform(poDS, poDstDS, bOverwrite = True)
def processAlgorithm(self, progress): hublayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.HUBNAME)) spokelayer = QGisLayers.getObjectFromUri( self.getParameterValue(self.SPOKENAME)) hubattr = self.getParameterValue(self.HUBATTRIBUTE) spokeattr = self.getParameterValue(self.SPOKEATTRIBUTE) if hublayer == spokelayer: raise GeoAlgorithmExecutionException( "Same layer given for both hubs and spokes") hubindex = hublayer.dataProvider().fieldNameIndex(hubattr) spokeindex = spokelayer.dataProvider().fieldNameIndex(spokeattr) outfields = spokelayer.pendingFields() output = self.getOutputFromName(self.SAVENAME) out = output.getVectorWriter(outfields, QGis.WKBLineString, spokelayer.crs()) # Scan spoke points linecount = 0 spokepoints = QGisLayers.features(spokelayer) i = 0 for spokepoint in spokepoints: i += 1 spokex = spokepoint.geometry().boundingBox().center().x() spokey = spokepoint.geometry().boundingBox().center().y() spokeid = unicode(spokepoint.attributes()[spokeindex]) progress.setPercentage(float(i) / len(spokepoints) * 100) # Scan hub points to find first matching hub hubpoints = QGisLayers.features(hublayer) for hubpoint in hubpoints: hubid = unicode(hubpoint.attributes()[hubindex]) if hubid == spokeid: hubx = hubpoint.geometry().boundingBox().center().x() huby = hubpoint.geometry().boundingBox().center().y() # Write line to the output file outfeature = QgsFeature() outfeature.setAttributes(spokepoint.attributes()) polyline = [] polyline.append(QgsPoint(spokex, spokey)) polyline.append(QgsPoint(hubx, huby)) geometry = QgsGeometry() outfeature.setGeometry(geometry.fromPolyline(polyline)) out.addFeature(outfeature) linecount = linecount + 1 break del out if linecount <= 0: raise GeoAlgorithmExecutionException( "No spoke/hub matches found to create lines")
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) layername = layer.name() node_filename = self.getOutputValue(self.NODEFILENAME) attribute_filename = self.getOutputValue(self.ATTRIBUTEFILENAME) print "Layer: " + str(layername) print "Nodes: " + str(node_filename) print "Attributes: " + str(attribute_filename) if self.getParameterValue(self.FIELDDELIMITER) == 1: field_delimiter = "|" elif self.getParameterValue(self.FIELDDELIMITER) == 2: field_delimiter = " " else: field_delimiter = "," if self.getParameterValue(self.LINETERMINATOR) == 1: line_terminator = "\n" else: line_terminator = "\r\n" message = mmqgisx_geometry_export_to_csv(qgis, layername, node_filename, attribute_filename, field_delimiter, line_terminator) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(Centroids.INPUT_LAYER)) provider = layer.dataProvider() writer = self.getOutputFromName( Centroids.OUTPUT_LAYER).getVectorWriter(provider.fields(), QGis.WKBPoint, provider.crs()) allAttrs = provider.attributeIndexes() provider.select(allAttrs) inFeat = QgsFeature() outFeat = QgsFeature() total = provider.featureCount() current = 0 while provider.nextFeature(inFeat): inGeom = inFeat.geometry() attrMap = inFeat.attributeMap() outGeom = QgsGeometry(inGeom.centroid()) if outGeom is None: raise GeoAlgorithmExecutionException( "Error calculating centroid") outFeat.setGeometry(outGeom) outFeat.setAttributeMap(attrMap) writer.addFeature(outFeat) current += 1 progress.setPercentage(int(current / total * 100)) del writer
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) layername = layer.name() savename = self.getOutputValue(self.SAVENAME) index = self.getParameterValue(self.NEWTYPE) splitnodes = 0 if index == 0: newtype = QGis.WKBPoint elif index == 1: newtype = QGis.WKBPoint splitnodes = 1 elif index == 2: newtype = QGis.WKBLineString elif index == 3: newtype = QGis.WKBMultiLineString elif index == 4: newtype = QGis.WKBPolygon else: newtype = QGis.WKBPoint message = mmqgisx_geometry_convert(qgis, layername, newtype, splitnodes, savename, False) if message: raise GeoAlgorithmExecutionException(message)
class PostGISExecuteSQL(GeoAlgorithm): DATABASE = "DATABASE" SQL = "SQL" def getIcon(self): return QIcon(os.path.dirname(__file__) + "/../images/postgis.png") def processAlgorithm(self, progress): connection = self.getParameterValue(self.DATABASE) settings = QSettings() mySettings = "/PostgreSQL/connections/" + connection try: database = settings.value(mySettings + "/database").toString() username = settings.value(mySettings + "/username").toString() host = settings.value(mySettings + "/host").toString() port = int(settings.value(mySettings + "/port").toString()) password = settings.value(mySettings + "/password").toString() except Exception, e: raise GeoAlgorithmExecutionException( "Wrong database connection name: " + connection) try: self.db = postgis_utils.GeoDB(host=host, port=port, dbname=database, user=username, passwd=password) except postgis_utils.DbError, e: raise GeoAlgorithmExecutionException( "Couldn't connect to database:\n" + e.message)
def processAlgorithm(self, progress): commands = [] commands.append(os.path.join(TauDEMUtils.mpiexecPath(), "mpiexec")) processNum = SextanteConfig.getSetting(TauDEMUtils.MPI_PROCESSES) if processNum <= 0: raise GeoAlgorithmExecutionException("Wrong number of MPI processes used.\nPlease set correct number before running TauDEM algorithms.") commands.append("-n") commands.append(str(processNum)) commands.append(os.path.join(TauDEMUtils.taudemPath(), self.cmdName)) commands.append("-plen") commands.append(self.getParameterValue(self.LENGTH_GRID)) commands.append("-ad8") commands.append(self.getParameterValue(self.CONTRIB_AREA_GRID)) commands.append("-par") commands.append(str(self.getParameterValue(self.THRESHOLD))) commands.append(str(self.getParameterValue(self.EXPONENT))) commands.append("-ss") commands.append(self.getOutputValue(self.STREAM_SOURCE_GRID)) loglines = [] loglines.append("TauDEM execution command") for line in commands: loglines.append(line) SextanteLog.addToLog(SextanteLog.LOG_INFO, loglines) TauDEMUtils.executeTauDEM(commands, progress)
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)) savename = self.getOutputValue(self.SAVENAME) index = self.getParameterValue(self.NEWTYPE) splitnodes = 0 if index == 0: newtype = QGis.WKBPoint elif index == 1: newtype = QGis.WKBPoint splitnodes = 1 elif index == 2: newtype = QGis.WKBLineString elif index == 3: newtype = QGis.WKBMultiLineString elif index == 4: newtype = QGis.WKBPolygon else: newtype = QGis.WKBPoint message = mmqgisx_geometry_convert(progress, layer, newtype, splitnodes, savename, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() table = QGisLayers.getObjectFromUri( self.getParameterValue(self.CSVNAME)) csvname = table.name() params = [ self.getParameterValue(self.ADDRESS), self.getParameterValue(self.CITY), self.getParameterValue(self.STATE), self.getParameterValue(self.COUNTRY) ] keys = [] for param in params: if not (param in keys): keys.append(param) shapefilename = self.getOutputValue(self.SHAPEFILENAME) notfoundfile = self.getOutputValue(self.NOTFOUNDFILE) message = mmqgisx_geocode_google(qgis, csvname, shapefilename, notfoundfile, keys, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) layername = layer.name() table = QGisLayers.getObjectFromUri( self.getParameterValue(self.INFILENAME)) infilename = table.name() joinfield = self.getParameterValue(self.JOINFIELD) joinattribute = self.getParameterValue(self.JOINATTRIBUTE) outfilename = self.getOutputValue(self.OUTFILENAME) notfoundname = self.getOutputValue(self.NOTFOUNDNAME) message = mmqgisx_attribute_join(qgis, layername, infilename, joinfield, joinattribute, outfilename, notfoundname, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() outfilename = self.getOutputValue(self.OUTFILENAME) layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) layername = layer.name() if self.getParameterValue(self.FIELDDELIMITER) == 1: field_delimiter = "|" elif self.getParameterValue(self.FIELDDELIMITER) == 2: field_delimiter = " " else: field_delimiter = "," if self.getParameterValue(self.LINETERMINATOR) == 1: line_terminator = "\n" else: line_terminator = "\r\n" message = mmqgisx_attribute_export(qgis, outfilename, layername, None, field_delimiter, line_terminator) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Intersection.INPUT)) vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Intersection.INPUT2)) vproviderA = vlayerA.dataProvider() fields = utils.combineVectorFields(vlayerA, vlayerB) writer = self.getOutputFromName(Intersection.OUTPUT).getVectorWriter(fields, vproviderA.geometryType(), vproviderA.crs() ) inFeatA = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() index = utils.createSpatialIndex(vlayerB) nElement = 0 selectionA = QGisLayers.features(vlayerA) nFeat = len(selectionA) for inFeatA in selectionA: nElement += 1 progress.setPercentage(nElement/float(nFeat) * 100) geom = QgsGeometry( inFeatA.geometry() ) atMapA = inFeatA.attributes() intersects = index.intersects( geom.boundingBox() ) for i in intersects: request = QgsFeatureRequest().setFilterFid(i) inFeatB = vlayerB.getFeatures(request).next() tmpGeom = QgsGeometry(inFeatB.geometry()) try: if geom.intersects( tmpGeom ): atMapB = inFeatB.attributes() int_geom = QgsGeometry( geom.intersection( tmpGeom ) ) if int_geom.wkbType() == 7: int_com = geom.combine( tmpGeom ) int_sym = geom.symDifference( tmpGeom ) int_geom = QgsGeometry( int_com.difference( int_sym ) ) try: outFeat.setGeometry( int_geom ) attrs = [] attrs.extend(atMapA) attrs.extend(atMapB) outFeat.setAttributes(attrs) writer.addFeature( outFeat ) except: raise GeoAlgorithmExecutionException("Feature exception while computing intersection") except: raise GeoAlgorithmExecutionException("Geometry exception while computing intersection") del writer
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(QVariant(dfield.type())) feature.setAttributes(dattributes) out.addFeature(feature) featurecount += 1 progress.setPercentage(float(featurecount) / totalfeaturecount * 100) del out
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.INPUT)) output = self.getOutputValue(self.OUTPUT) fieldName = self.getParameterValue(self.FIELD) provider = layer.dataProvider() allAttrs = layer.pendingAllAttributesList() layer.select(allAttrs) geomType = self.singleToMultiGeom(provider.geometryType()) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( layer.pendingFields(), geomType, provider.crs()) inFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() index = layer.fieldNameIndex(fieldName) unique = layer.uniqueValues(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: #provider.rewind() multi_feature = [] first = True layer.select(allAttrs) features = QGisLayers.features(layer) for inFeat in features: atMap = inFeat.attributeMap() idVar = atMap[index] if idVar.toString().trimmed() == i.toString().trimmed(): if first: attrs = atMap print attrs 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.setAttributeMap(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): formula = self.getParameterValue(self.FORMULA) for i in range(self.AVAILABLE_VARIABLES): name = CalculatorModelerAlgorithm.NUMBER + str(i) num = self.getParameterValue(name) formula = formula.replace(chr(97 + i), str(num)) try: result = eval(formula) self.setOutputValue(self.RESULT, result) except: raise GeoAlgorithmExecutionException("Wrong formula: " + formula)
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 + [QVariant(polygon.area), QVariant(polygon.length)]) writer.addFeature(outFeat) current += 1 progress.setPercentage(50 + int(current * total)) del writer
def processAlgorithm(self, progress): self.producedOutputs = {} executed = [] while len(executed) < len(self.algs) - len(self.deactivated): iAlg = 0 for alg in self.algs: if iAlg not in self.deactivated and iAlg not in executed: canExecute = True required = self.getDependsOnAlgorithms(iAlg) for requiredAlg in required: if requiredAlg not in executed: canExecute = False break if canExecute: try: alg = alg.getCopy() progress.setDebugInfo("Prepare algorithm %i: %s" % (iAlg, alg.name)) self.prepareAlgorithm(alg, iAlg) progress.setText( "Running " + alg.name + " [" + str(iAlg + 1) + "/" + str(len(self.algs) - len(self.deactivated)) + "]") outputs = {} progress.setDebugInfo("Parameters: " + ', '.join([ str(p).strip() + "=" + str(p.value) for p in alg.parameters ])) t0 = time.time() alg.execute(progress) dt = time.time() - t0 for out in alg.outputs: outputs[out.name] = out.value progress.setDebugInfo("Outputs: " + ', '.join([ str(out).strip() + "=" + str(outputs[out.name]) for out in alg.outputs ])) self.producedOutputs[iAlg] = outputs executed.append(iAlg) progress.setDebugInfo( "OK. Execution took %0.3f ms (%i outputs)." % (dt, len(outputs))) except GeoAlgorithmExecutionException, e: progress.setDebugInfo("Failed") raise GeoAlgorithmExecutionException( "Error executing algorithm " + str(iAlg) + "\n" + e.msg) else: progress.setDebugInfo( "Algorithm %s deactivated (or already executed)" % alg.name) iAlg += 1
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) column = self.getParameterValue(self.COLUMN) savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_delete_columns(progress, layer, [column], savename, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) hspacing = self.getParameterValue(self.HSPACING) vspacing = self.getParameterValue(self.VSPACING) savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_gridify_layer(progress, layer, hspacing, vspacing, savename, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): layer1 = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYER1)) layer2 = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYER2)) savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_merge(progress, [layer1, layer2], savename, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) attribute = self.getParameterValue(self.ATTRIBUTE) savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_text_to_float(progress, layer, [attribute], savename, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): connection = self.getParameterValue(self.DATABASE) settings = QSettings() mySettings = "/PostgreSQL/connections/" + connection try: database = settings.value(mySettings + "/database").toString() username = settings.value(mySettings + "/username").toString() host = settings.value(mySettings + "/host").toString() port = int(settings.value(mySettings + "/port").toString()) password = settings.value(mySettings + "/password").toString() except Exception, e: raise GeoAlgorithmExecutionException( "Wrong database connection name: " + connection)
def processAlgorithm(self, progress): layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) attribute = self.getParameterValue(self.ATTRIBUTE) direction = self.directions[self.getParameterValue(self.DIRECTION)] savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_sort(progress, layer, attribute, savename, direction, False) if message: raise GeoAlgorithmExecutionException(message)
def processAlgorithm(self, progress): # Include must be done here to avoid cyclic import from sextante.core.Sextante import Sextante qgis = Sextante.getInterface() layer = QGisLayers.getObjectFromUri( self.getParameterValue(self.LAYERNAME)) savename = self.getOutputValue(self.SAVENAME) message = mmqgisx_voronoi_diagram(qgis, layer, savename, False) if message: raise GeoAlgorithmExecutionException(message)
def multiToSingleGeom(self, wkbType): try: if wkbType in (QGis.WKBPoint, QGis.WKBMultiPoint, QGis.WKBPoint25D, QGis.WKBMultiPoint25D): return QGis.WKBPoint elif wkbType in (QGis.WKBLineString, QGis.WKBMultiLineString, QGis.WKBMultiLineString25D, QGis.WKBLineString25D): return QGis.WKBLineString elif wkbType in (QGis.WKBPolygon, QGis.WKBMultiPolygon, QGis.WKBMultiPolygon25D, QGis.WKBPolygon25D): return QGis.WKBPolygon else: return QGis.WKBUnknown except Exception, err: raise GeoAlgorithmExecutionException(unicode(err))