def processAlgorithm(self, progress):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
layer.removeSelection()
index = layer.fieldNameIndex(field)
unique = vector.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 = vector.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):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
layer.removeSelection()
index = layer.fieldNameIndex(field)
unique = vector.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 = vector.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, feedback):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getLayerFromString(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
layer.removeSelection()
index = layer.fields().lookupField(field)
unique = vector.getUniqueValues(layer, index)
featureCount = layer.featureCount()
value = int(self.getParameterValue(self.NUMBER))
if method == 0:
if value > featureCount:
raise GeoAlgorithmExecutionException(
self.tr('Selected number is greater that feature count. '
'Choose lesser value and try again.'))
else:
if value > 100:
raise GeoAlgorithmExecutionException(
self.tr("Percentage can't be greater than 100. Set a "
"different value and try again."))
value = value / 100.0
selran = []
inFeat = QgsFeature()
current = 0
total = 100.0 / (featureCount * len(unique))
if not len(unique) == featureCount:
for i in unique:
features = vector.features(layer)
FIDs = []
for inFeat in features:
attrs = inFeat.attributes()
if attrs[index] == i:
FIDs.append(inFeat.id())
current += 1
feedback.setProgress(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.selectByIds(selran)
else:
layer.selectByIds(list(
range(featureCount))) # FIXME: implies continuous feature ids
self.setOutputValue(self.OUTPUT, filename)
def processAlgorithm(self, feedback):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getLayerFromString(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
layer.removeSelection()
index = layer.fields().lookupField(field)
unique = vector.getUniqueValues(layer, index)
featureCount = layer.featureCount()
value = int(self.getParameterValue(self.NUMBER))
if method == 0:
if value > featureCount:
raise GeoAlgorithmExecutionException(
self.tr('Selected number is greater that feature count. '
'Choose lesser value and try again.'))
else:
if value > 100:
raise GeoAlgorithmExecutionException(
self.tr("Percentage can't be greater than 100. Set a "
"different value and try again."))
value = value / 100.0
selran = []
inFeat = QgsFeature()
current = 0
total = 100.0 / (featureCount * len(unique))
if not len(unique) == featureCount:
for i in unique:
features = vector.features(layer)
FIDs = []
for inFeat in features:
attrs = inFeat.attributes()
if attrs[index] == i:
FIDs.append(inFeat.id())
current += 1
feedback.setProgress(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.selectByIds(selran)
else:
layer.selectByIds(list(range(featureCount))) # FIXME: implies continuous feature ids
self.setOutputValue(self.OUTPUT, filename)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
outputFile = self.getOutputValue(self.OUTPUT)
values = vector.getUniqueValues(layer, layer.fields().lookupField(fieldName))
self.createHTML(outputFile, values)
self.setOutputValue(self.TOTAL_VALUES, len(values))
self.setOutputValue(self.UNIQUE_VALUES, ";".join([str(v) for v in values]))
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
outputFile = self.getOutputValue(self.OUTPUT)
values = vector.getUniqueValues(layer, layer.fields().lookupField(fieldName))
self.createHTML(outputFile, values)
self.setOutputValue(self.TOTAL_VALUES, len(values))
self.setOutputValue(self.UNIQUE_VALUES, ';'.join([str(v) for v in
values]))
def processAlgorithm(self, progress):
layer = dataobjects.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 = vector.getUniqueValues(layer, index)
current = 0
features = vector.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 = vector.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):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
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 = vector.getUniqueValues(layer, index)
current = 0
features = vector.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 = vector.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):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
fieldName = self.getParameterValue(self.FIELD)
geomType = self.singleToMultiGeom(layer.wkbType())
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), geomType, layer.crs())
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
index = layer.fields().lookupField(fieldName)
unique = vector.getUniqueValues(layer, index)
current = 0
features = vector.features(layer)
total = 100.0 / (len(features) * len(unique))
if not len(unique) == layer.featureCount():
for i in unique:
multi_feature = []
first = True
features = vector.features(layer)
for inFeat in features:
atMap = inFeat.attributes()
idVar = atMap[index]
if str(idVar).strip() == str(i).strip():
if first:
attrs = atMap
first = False
inGeom = 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(
self.tr('At least two features must have same attribute '
'value! Please choose another field...'))
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = QgsFields()
fieldname = self.getParameterValue(Dissolve.FIELD)
try:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
field = vlayerA.fields().field(fieldname)
fields.append(field)
useField = True
except:
useField = False
countField = QgsField("count", QVariant.Int, '', 10, 0)
fields.append(countField)
writer = self.getOutputFromName(Dissolve.OUTPUT).getVectorWriter(
fields, vproviderA.geometryType(), vproviderA.crs())
outFeat = QgsFeature()
outFeat.initAttributes(fields.count())
nElement = 0
nFeat = vlayerA.selectedFeatureCount()
if nFeat == 0:
nFeat = vlayerA.featureCount()
if not useField:
first = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
if first:
tmpOutGeom = QgsGeometry(inFeat.geometry())
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = nElement
writer.addFeature(outFeat)
else:
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
features = vector.features(vlayerA)
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if len(myDict[unicode(tempItem).strip()]) == 0:
myDict[unicode(tempItem).strip()].append(tempItem)
myDict[unicode(tempItem).strip()].append(tmpInGeom)
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
for i in range(len(value)):
if i == 0:
tempItem = value[i]
continue
else:
tmpInGeom = value[i]
if i == 1:
tmpOutGeom = tmpInGeom
else:
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr(
'Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = tempItem
outFeat[1] = i
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
perc = self.getParameterValue(mcp.PERCENT)
field = self.getParameterValue(mcp.FIELD)
inputLayer = getObjectFromUri(self.getParameterValue(mcp.INPUT))
inputProvider = inputLayer.dataProvider()
try:
inputProvider.select(inputProvider.attributeIndexes())
except:
pass
fields = [QgsField("ID", QVariant.String),
QgsField("Area", QVariant.Double),
QgsField("Perim", QVariant.Double)
]
writer = self.getWriter(mcp.OUTPUT, fields,
QGis.WKBPolygon, inputProvider.crs())
index = inputProvider.fieldNameIndex(field)
try:
uniqueValues = getUniqueValues(inputProvider, index)
except:
uniqueValues = getUniqueValues(inputLayer, index)
GEOS_EXCEPT = True
FEATURE_EXCEPT = True
progress_perc = 100 / len(uniqueValues)
n = 0
for value in uniqueValues:
nElement = 0
hull = []
cx = 0.00 # x of mean coodinate
cy = 0.00 # y of mean coordinate
nf = 0
try:
inputProvider.select(inputProvider.attributeIndexes())
except:
pass
for feature in features(inputLayer):
fieldValue = self.getFeatureAttributes(feature)[index]
if (fieldValue == value):
points = extractPoints(feature.geometry())
cx += points[0].x()
cy += points[0].y()
nf += 1
cx = (cx / nf)
cy = (cy / nf)
meanPoint = QgsPoint(cx, cy)
distArea = QgsDistanceArea()
distanceGeometryMap = {}
for feature in features(inputLayer):
fieldValue = self.getFeatureAttributes(feature)[index]
if (fieldValue == value):
nElement += 1
geometry = QgsGeometry(feature.geometry())
distance = distArea.measureLine(meanPoint,
geometry.asPoint())
distanceGeometryMap[distance] = geometry
if perc == 100:
points = extractPoints(geometry)
hull.extend(points)
if perc != 100:
if perc > 100:
perc = 100
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
"Please insert a valid percentage (0-100%)")
hull = self.percpoints(perc, distanceGeometryMap, nElement)
if len(hull) >= 3:
try:
outGeom = QgsGeometry.fromMultiPoint(hull).convexHull()
outFeat = QgsFeature()
outFeat.setGeometry(outGeom)
measure = QgsDistanceArea()
self.setFeatureAttributes(outFeat, [value,
measure.measure(outGeom),
measure.measurePerimeter(outGeom)])
writer.addFeature(outFeat)
except:
GEOS_EXCEPT = False
continue
n += 1
progress.setPercentage(progress_perc * n)
del writer
if not GEOS_EXCEPT:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
"Geometry exception while computing convex hull")
if not FEATURE_EXCEPT:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
"Feature exception while computing convex hull")
def processAlgorithm(self, feedback):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
index = layer.fields().lookupField(field)
features = vector.features(layer)
featureCount = len(features)
unique = vector.getUniqueValues(layer, index)
value = int(self.getParameterValue(self.NUMBER))
if method == 0:
if value > featureCount:
raise GeoAlgorithmExecutionException(
self.tr('Selected number is greater that feature count. '
'Choose lesser value and try again.'))
else:
if value > 100:
raise GeoAlgorithmExecutionException(
self.tr("Percentage can't be greater than 100. Set "
"correct value and try again."))
value = value / 100.0
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), layer.wkbType(), layer.crs())
selran = []
current = 0
total = 100.0 / (featureCount * len(unique))
features = vector.features(layer)
if not len(unique) == featureCount:
for classValue in unique:
classFeatures = []
for i, feature in enumerate(features):
attrs = feature.attributes()
if attrs[index] == classValue:
classFeatures.append(i)
current += 1
feedback.setProgress(int(current * total))
if method == 1:
selValue = int(round(value * len(classFeatures), 0))
else:
selValue = value
if selValue >= len(classFeatures):
selFeat = classFeatures
else:
selFeat = random.sample(classFeatures, selValue)
selran.extend(selFeat)
else:
selran = list(range(featureCount))
features = vector.features(layer)
total = 100.0 / len(features)
for (i, feat) in enumerate(features):
if i in selran:
writer.addFeature(feat)
feedback.setProgress(int(i * total))
del writer
def processAlgorithm(self, progress):
useField = not self.getParameterValue(Dissolve.DISSOLVE_ALL)
fieldname = self.getParameterValue(Dissolve.FIELD)
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
field = vlayerA.fieldNameIndex(fieldname)
vproviderA = vlayerA.dataProvider()
fields = vproviderA.fields()
writer = self.getOutputFromName(Dissolve.OUTPUT).getVectorWriter(
fields, vproviderA.geometryType(), vproviderA.crs())
outFeat = QgsFeature()
nElement = 0
nFeat = vproviderA.featureCount()
if not useField:
first = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement / nFeat * 100))
if first:
attrs = inFeat.attributes()
tmpInGeom = QgsGeometry(inFeat.geometry())
outFeat.setGeometry(tmpInGeom)
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
tmpOutGeom = QgsGeometry(outFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
else:
unique = vector.getUniqueValues(vlayerA, int(field))
nFeat = nFeat * len(unique)
for item in unique:
first = True
add = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement / nFeat * 100))
atMap = inFeat.attributes()
tempItem = atMap[field]
if unicode(tempItem).strip() == unicode(item).strip():
if first:
QgsGeometry(inFeat.geometry())
tmpInGeom = QgsGeometry(inFeat.geometry())
outFeat.setGeometry(tmpInGeom)
first = False
attrs = inFeat.attributes()
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
tmpOutGeom = QgsGeometry(outFeat.geometry())
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
self.tr(
'Geometry exception while dissolving'))
if add:
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
useField = not self.getParameterValue(Dissolve.DISSOLVE_ALL)
fieldname = self.getParameterValue(Dissolve.FIELD)
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
field = vlayerA.fieldNameIndex(fieldname)
vproviderA = vlayerA.dataProvider()
fields = vproviderA.fields()
writer = self.getOutputFromName(
Dissolve.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat = QgsFeature()
nElement = 0
nFeat = vproviderA.featureCount()
if not useField:
first = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement / nFeat * 100))
if first:
attrs = inFeat.attributes()
tmpInGeom = QgsGeometry(inFeat.geometry())
outFeat.setGeometry(tmpInGeom)
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
tmpOutGeom = QgsGeometry(outFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
'Geometry exception while dissolving')
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
else:
unique = vector.getUniqueValues(vlayerA, int(field))
nFeat = nFeat * len(unique)
for item in unique:
first = True
add = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement / nFeat * 100))
atMap = inFeat.attributes()
tempItem = atMap[field]
if unicode(tempItem).strip() == unicode(item).strip():
if first:
QgsGeometry(inFeat.geometry())
tmpInGeom = QgsGeometry(inFeat.geometry())
outFeat.setGeometry(tmpInGeom)
first = False
attrs = inFeat.attributes()
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
tmpOutGeom = QgsGeometry(outFeat.geometry())
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
'Geometry exception while dissolving')
if add:
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
useField = not self.getParameterValue(Dissolve.DISSOLVE_ALL)
fieldname = self.getParameterValue(Dissolve.FIELD)
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = vlayerA.fields()
writer = self.getOutputFromName(
Dissolve.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat = QgsFeature()
nElement = 0
features = vector.features(vlayerA)
nFeat = len(features)
if not useField:
first = True
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
if first:
attrs = inFeat.attributes()
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty() or not tmpInGeom.isGeosValid():
continue
outFeat.setGeometry(tmpInGeom)
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty() or not tmpInGeom.isGeosValid():
continue
tmpOutGeom = QgsGeometry(outFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
else:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
attrDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
attrDict[unicode(item).strip()] = None
unique = None
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty() or not tmpInGeom.isGeosValid():
continue
if attrDict[unicode(tempItem).strip()] == None:
# keep attributes of first feature
attrDict[unicode(tempItem).strip()] = attrs
myDict[unicode(tempItem).strip()].append(tmpInGeom)
features = None
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
for i in range(len(value)):
tmpInGeom = value[i]
if i == 0:
tmpOutGeom = tmpInGeom
else:
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat.setAttributes(attrDict[key])
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
filename = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(filename)
field = self.getParameterValue(self.FIELD)
method = self.getParameterValue(self.METHOD)
index = layer.fields().lookupField(field)
features = vector.features(layer)
featureCount = len(features)
unique = vector.getUniqueValues(layer, index)
value = int(self.getParameterValue(self.NUMBER))
if method == 0:
if value > featureCount:
raise GeoAlgorithmExecutionException(
self.tr('Selected number is greater that feature count. '
'Choose lesser value and try again.'))
else:
if value > 100:
raise GeoAlgorithmExecutionException(
self.tr("Percentage can't be greater than 100. Set "
"correct value and try again."))
value = value / 100.0
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), layer.wkbType(), layer.crs())
selran = []
current = 0
total = 100.0 / (featureCount * len(unique))
features = vector.features(layer)
if not len(unique) == featureCount:
for classValue in unique:
classFeatures = []
for i, feature in enumerate(features):
attrs = feature.attributes()
if attrs[index] == classValue:
classFeatures.append(i)
current += 1
progress.setPercentage(int(current * total))
if method == 1:
selValue = int(round(value * len(classFeatures), 0))
else:
selValue = value
if selValue >= len(classFeatures):
selFeat = classFeatures
else:
selFeat = random.sample(classFeatures, selValue)
selran.extend(selFeat)
else:
selran = list(range(featureCount))
features = vector.features(layer)
total = 100.0 / len(features)
for (i, feat) in enumerate(features):
if i in selran:
writer.addFeature(feat)
progress.setPercentage(int(i * total))
del writer
def processAlgorithm(self, progress):
useField = not self.getParameterValue(Dissolve.DISSOLVE_ALL)
fieldname = self.getParameterValue(Dissolve.FIELD)
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = vlayerA.fields()
writer = self.getOutputFromName(
Dissolve.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat = QgsFeature()
features = vector.features(vlayerA)
total = 100.0 / len(features)
if not useField:
first = True
for current, inFeat in enumerate(features):
progress.setPercentage(int(current * total))
if first:
attrs = inFeat.attributes()
tmpInGeom = inFeat.geometry()
if tmpInGeom.isEmpty() or tmpInGeom.isGeosEmpty():
continue
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry()'
'error: One or more '
'input features have '
'invalid geometry: ')
+ error.what())
continue
outFeat.setGeometry(tmpInGeom)
first = False
else:
tmpInGeom = inFeat.geometry()
if tmpInGeom.isEmpty() or tmpInGeom.isGeosEmpty():
continue
tmpOutGeom = outFeat.geometry()
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry()'
'error:One or more input'
'features have invalid '
'geometry: ')
+ error.what())
continue
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
else:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
attrDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
attrDict[unicode(item).strip()] = None
unique = None
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty():
continue
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry() '
'error: One or more input'
'features have invalid '
'geometry: ')
+ error.what())
if attrDict[unicode(tempItem).strip()] is None:
# keep attributes of first feature
attrDict[unicode(tempItem).strip()] = attrs
myDict[unicode(tempItem).strip()].append(tmpInGeom)
features = None
nElement = 0
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
try:
tmpOutGeom = QgsGeometry.unaryUnion(value)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat.setAttributes(attrDict[key])
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
currentPath = os.path.dirname(os.path.abspath(__file__))
outputs = os.path.join(currentPath, 'outputs')
if not os.path.exists(outputs):
os.mkdir(outputs)
# Get parameters
perc = self.getParameterValue(kernelDensity.PERCENT)
field = self.getParameterValue(kernelDensity.FIELD)
inputLayer = getObjectFromUri(
self.getParameterValue(kernelDensity.INPUT))
resolution = self.getParameterValue(kernelDensity.RESOLUTION)
bw_method = kernelDensity.BW_METHODS.keys()[
self.getParameterValue(kernelDensity.BW_METHOD)]
addRasterOutputs = self.getParameterValue(
kernelDensity.ADD_RASTER_OUTPUTS)
# Adjust parameters if necessary
if perc > 100:
perc = 100
if bw_method == kernelDensity.BW_METHOD_DEFAULT:
bandwidth = 'normal_reference'
elif bw_method == kernelDensity.BW_METHOD_SCOTT:
bandwidth = 'scott'
elif bw_method == kernelDensity.BW_METHOD_SILVERMAN:
bandwidth = 'silverman'
elif bw_method == kernelDensity.BW_METHOD_CV_ML:
bandwidth = 'cv_ml'
elif bw_method == kernelDensity.BW_METHOD_CV_LS:
bandwidth = 'cv_ls'
elif bw_method == kernelDensity.BW_METHOD_CUSTOM:
if _HAS_SCIPY and 'set_bandwidth' in dir(gaussian_kde):
bandwidth = self.getParameterValue(kernelDensity.BW_VALUE)
else:
bandwidth = [self.getParameterValue(kernelDensity.BW_VALUE)]
# Get layer info and create the writer for the output layer
epsg = inputLayer.crs().srsid()
name = inputLayer.name()
inputProvider = inputLayer.dataProvider()
try:
inputProvider.select(inputProvider.attributeIndexes())
except:
pass
fieldIndex = inputProvider.fieldNameIndex(field)
try:
uniqueValues = getUniqueValues(inputProvider, fieldIndex)
except:
uniqueValues = getUniqueValues(inputLayer, fieldIndex)
fields = [QgsField("ID", QVariant.String),
QgsField("Area", QVariant.Double),
QgsField("Perim", QVariant.Double)]
writer = self.getWriter(kernelDensity.OUTPUT, fields,
QGis.WKBMultiLineString, inputProvider.crs())
# Prepare percentage progress and start
progress_perc = 100 / len(uniqueValues)
n = 0
for value in uniqueValues:
# Filter x,y points with desired field value (value)
xPoints = []
yPoints = []
for feature in features(inputLayer):
fieldValue = self.getFeatureAttributes(feature)[fieldIndex]
if (fieldValue == value):
points = extractPoints(feature.geometry())
xPoints.append(points[0].x())
yPoints.append(points[0].y())
if len(xPoints) == 0: # number of selected features
continue
# Compute kernel (X, Y, Z)
xmin = min(xPoints) - 0.5 * (max(xPoints) - min(xPoints))
xmax = max(xPoints) + 0.5 * (max(xPoints) - min(xPoints))
ymin = min(yPoints) - 0.5 * (max(yPoints) - min(yPoints))
ymax = max(yPoints) + 0.5 * (max(yPoints) - min(yPoints))
# X, Y form a meshgrid
X, Y = np.mgrid[xmin:xmax:complex(resolution),
ymin:ymax:complex(resolution)]
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "X shape : "
+ str(X.shape))
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Y shape : "
+ str(Y.shape))
# Meshgrid in form of stacked array with all possible positions
positions = np.vstack([X.ravel(), Y.ravel()])
# Meshgrid with all the real positions
values = np.vstack([xPoints, yPoints])
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Positions shape : "
+ str(positions.shape))
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Values shape : "
+ str(values.shape))
if self.use_scipy(bw_method):
###############################################################
# Compute kernel Z with scipy.stats.kde.gaussian_kde
# Representation of a kernel-density estimate using Gaussian
# kernels.
# Taken from http://docs.scipy.org/doc/scipy/reference/
# generated/scipy.stats.gaussian_kde.html
# You need at least version 0.11 of scipy
###############################################################
kernel = gaussian_kde(values)
try:
kernel.set_bandwidth(bandwidth)
except:
if bandwidth == 'scott':
kernel.covariance_factor = kernel.scotts_factor
elif bandwidth == 'silverman':
kernel.covariance_factor = kernel.silverman_factor
Z = np.reshape(kernel(positions).T, X.T.shape)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Bandwidth value for '"
+ str(value) + "': "
+ str(kernel.covariance_factor()))
else:
##############################################################
# Compute kernel Z with
# statsmodels.nonparametric.kernel_density.KDEMultivariate
# Representation of a kernel-density estimate
# Taken from http://goo.gl/kwEfD
# You need at least version 0.5 of statsmodels
##############################################################
kernel = kernel_density.KDEMultivariate(data=values,
var_type='cc', bw=bandwidth)
# Evaluate positions using kernel
Z = np.reshape(kernel.pdf(positions).T, X.T.shape)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Bandwidth value for: "
+ str(value) + "': " + str(kernel.bw))
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Shape of evaluation transponse : " + str(Z.T.shape))
# Write kernel to GeoTIFF
raster_name = (str(name) + '_' + str(perc) + '_' +
str(value) + '_' +
str(datetime.date.today()))
fileName = os.path.join(outputs, raster_name)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Writing '"
+ fileName + "' to disc")
self.to_geotiff(fileName, xmin, xmax, ymin, ymax, X, Y, Z, epsg)
if addRasterOutputs:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Adding raster output as layer")
rasterOutput = OutputRaster(fileName, "Raster output")
self.addOutput(rasterOutput)
rasterOutput.setValue(fileName)
# Create contour lines (temporary .shp) from GeoTIFF
basename = "animove_tmp_" + str(n)
shpFile = os.path.join(outputs, basename + ".shp")
args = ['gdal_contour', fileName, '-a', 'values',
'-i', '10', shpFile]
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Creating contour lines for GeoTIFF: " + str(args))
startupinfo = None
try:
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
except:
pass
process = subprocess.Popen(args, startupinfo=startupinfo)
process.wait()
# Read contour lines from temporary .shp
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Reading contour lines from temporary SHP: " + shpFile)
layer = QgsVectorLayer(shpFile, basename, "ogr")
provider = layer.dataProvider()
try:
provider.select(provider.attributeIndexes())
except:
pass
# Create an array containing all polylines in the temporary
# .shp and compute the sum of all areas and perimeters
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Creating polylines from all SHP")
outGeom = []
area = 0
perim = 0
measure = QgsDistanceArea()
for feat in features(layer):
polyline = feat.geometry().asPolyline()
polygon = QgsGeometry.fromPolygon([polyline])
perim += measure.measurePerimeter(polygon)
area += measure.measure(polygon)
outGeom.append(polyline)
# Create feature and write
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Writing polylines features")
outFeat = QgsFeature()
outFeat.setGeometry(QgsGeometry.fromMultiPolyline(outGeom))
self.setFeatureAttributes(outFeat, [value, area, perim])
writer.addFeature(outFeat)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
"Updating progress bar")
n += 1
progress.setPercentage(progress_perc * n)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, "Finished. Removing "
"temporary files and deleting writer")
del writer
for f in os.listdir(outputs):
if re.search("animove_tmp_*", f):
try:
os.remove(os.path.join(outputs, f))
except OSError:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
"Cannot remove " + f)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
fieldName = self.getParameterValue(self.FIELD)
geomType = self.singleToMultiGeom(layer.wkbType())
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 = vector.getUniqueValues(layer, index)
current = 0
features = vector.features(layer)
total = 100.0 / (len(features) * len(unique)) if len(features) * len(unique) > 0 else 1
nullFeatures = []
if not len(unique) == layer.featureCount():
for i in unique:
first = True
multi_feature = []
features = vector.features(layer)
for inFeat in features:
atMap = inFeat.attributes()
idVar = atMap[index]
if idVar in [None, NULL] and inFeat.id() not in nullFeatures:
nullFeatures.append(inFeat.id())
outGeom = QgsGeometry(inFeat.geometry())
outFeat.setAttributes(atMap)
outFeat.setGeometry(outGeom)
writer.addFeature(outFeat)
current += 1
progress.setPercentage(int(current * total))
continue
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))
if len(multi_feature) > 0:
outGeom = QgsGeometry(
self.convertGeometry(multi_feature, vType))
outFeat.setGeometry(outGeom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
del writer
else:
raise GeoAlgorithmExecutionException(
self.tr('At least two features must have same attribute '
'value! Please choose another field...'))
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Reconcile.INPUT))
field = vlayerA.fieldNameIndex(self.getParameterValue(Reconcile.FIELD))
vproviderA = vlayerA.dataProvider()
fields = vproviderA.fields()
fieldsW = vlayerA.pendingFields()
newFields = []
i = 0
for f in fieldsW:
if i == field:
newFields.append(f)
i += 1
writer = self.getOutputFromName(
Reconcile.OUTPUT).getVectorWriter(newFields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat2 = QgsFeature()
nElement = 0
nFeat = vproviderA.featureCount()
unique = vector.getUniqueValues(vlayerA, int(field))
nFeat = nFeat * len(unique)
for item in unique:
first = True
add = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement / nFeat * 100))
atMap = inFeat.attributes()
tempItem = atMap[field]
if unicode(tempItem).strip() == unicode(item).strip():
if first:
QgsGeometry(inFeat.geometry())
tmpInGeom = QgsGeometry(inFeat.geometry())
outFeat2.setGeometry(tmpInGeom)
first = False
attrs = inFeat.attributes()
newAttributes = []
i = 0
for attr in attrs:
if i == field:
newAttributes.append(attr)
i += 1
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
tmpOutGeom = QgsGeometry(outFeat2.geometry())
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
outFeat2.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
'Geometry exception while dissolving')
if add:
outFeat2.setAttributes(newAttributes)
writer.addFeature(outFeat2)
del writer
def processAlgorithm(self, progress):
useField = not self.getParameterValue(Dissolve.DISSOLVE_ALL)
fieldname = self.getParameterValue(Dissolve.FIELD)
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = vlayerA.fields()
writer = self.getOutputFromName(
Dissolve.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat = QgsFeature()
features = vector.features(vlayerA)
total = 100.0 / len(features)
if not useField:
first = True
for current, inFeat in enumerate(features):
progress.setPercentage(int(current * total))
if first:
attrs = inFeat.attributes()
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty():
continue
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry()'
'error: One or more '
'input features have '
'invalid geometry: ')
+ error.what())
continue
outFeat.setGeometry(tmpInGeom)
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty():
continue
tmpOutGeom = QgsGeometry(outFeat.geometry())
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry()'
'error:One or more input'
'features have invalid '
'geometry: ')
+ error.what())
continue
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
outFeat.setGeometry(tmpOutGeom)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
else:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
attrDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
attrDict[unicode(item).strip()] = None
unique = None
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if tmpInGeom.isGeosEmpty():
continue
errors = tmpInGeom.validateGeometry()
if len(errors) != 0:
for error in errors:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('ValidateGeometry() '
'error: One or more input'
'features have invalid '
'geometry: ')
+ error.what())
if attrDict[unicode(tempItem).strip()] is None:
# keep attributes of first feature
attrDict[unicode(tempItem).strip()] = attrs
myDict[unicode(tempItem).strip()].append(tmpInGeom)
features = None
nElement = 0
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
try:
tmpOutGeom = QgsGeometry.unaryUnion(value)
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat.setAttributes(attrDict[key])
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = QgsFields()
fieldname = self.getParameterValue(Dissolve.FIELD)
try:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
field = vlayerA.fields().field(fieldname)
fields.append(field)
useField = True
except:
useField = False
countField = QgsField("count", QVariant.Int, '', 10, 0)
fields.append(countField)
writer = self.getOutputFromName(
Dissolve.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(),
vproviderA.crs())
outFeat = QgsFeature()
outFeat.initAttributes(fields.count())
nElement = 0
nFeat = vlayerA.selectedFeatureCount()
if nFeat == 0:
nFeat = vlayerA.featureCount()
if not useField:
first = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
if first:
tmpOutGeom = QgsGeometry(inFeat.geometry())
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = nElement
writer.addFeature(outFeat)
else:
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
features = vector.features(vlayerA)
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if len(myDict[unicode(tempItem).strip()]) == 0:
myDict[unicode(tempItem).strip()].append(tempItem)
myDict[unicode(tempItem).strip()].append(tmpInGeom)
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
for i in range(len(value)):
if i == 0:
tempItem = value[i]
continue
else:
tmpInGeom = value[i]
if i == 1:
tmpOutGeom = tmpInGeom
else:
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = tempItem
outFeat[1] = i
writer.addFeature(outFeat)
del writer
