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