python/plugins/sextante/about/about.htm

@@ -9,9 +9,11 @@ <h2>SEXTANTE for QGIS</h2>
 <p>A development by Victor Olaya (volayaf@gmail.com).</p>
 <p>Portions of this software contributed by:
 <ul>
-<li>Michael Nimm (mmqgis algorithms)</li>
+<li>Alexander Bruy</li>
 <li>Carson Farmer (fTools algorithms)</li>
 <li>Julien Malik (Orfeo Toolbox connectors)</li>
+<li>Evgeniy Nikulin (Original Field Pyculator code)</li>
+<li>Michael Nimm (mmqgis algorithms)</li>
 <li>Camilo Polymeris (Threading). Developed as part of Google Summer of Code 2012</li>
 </ul>
 </p>

python/plugins/sextante/algs/AddTableField.py

@@ -34,16 +34,14 @@ def defineCharacteristics(self):
     def processAlgorithm(self, progress):
         fieldtype = self.getParameterValue(self.FIELD_TYPE)
         fieldname = self.getParameterValue(self.FIELD_NAME)
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
-        output = self.getOutputValue(self.OUTPUT_LAYER)
+        output = self.getOutputFromName(self.OUTPUT_LAYER)
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
         vprovider = vlayer.dataProvider()
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
         fields[len(fields)] = QgsField(fieldname, self.TYPES[fieldtype])
-        writer = QgsVectorFileWriter( output, systemEncoding,fields, vprovider.geometryType(), vprovider.crs() )
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

python/plugins/sextante/algs/AutoincrementalField.py

@@ -16,16 +16,14 @@ def getIcon(self):
         return QtGui.QIcon(os.path.dirname(__file__) + "/../images/toolbox.png")
 
     def processAlgorithm(self, progress):
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
-        output = self.getOutputValue(self.OUTPUT)
+        output = self.getOutputFromName(self.OUTPUT)
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
         vprovider = vlayer.dataProvider()
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
         fields[len(fields)] = QgsField("AUTO", QVariant.Int)
-        writer = QgsVectorFileWriter( output, systemEncoding,fields, vprovider.geometryType(), vprovider.crs() )
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

python/plugins/sextante/algs/EquivalentNumField.py

@@ -19,16 +19,14 @@ def getIcon(self):
 
     def processAlgorithm(self, progress):
         field_index = self.getParameterValue(self.FIELD)
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
-        output = self.getOutputValue(self.OUTPUT)
+        output = self.getOutputFromName(self.OUTPUT)
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
         vprovider = vlayer.dataProvider()
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
         fields[len(fields)] = QgsField("NUM_FIELD", QVariant.Int)
-        writer = QgsVectorFileWriter( output, systemEncoding,fields, vprovider.geometryType(), vprovider.crs() )
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

python/plugins/sextante/algs/Explode.py

@@ -17,16 +17,13 @@ def getIcon(self):
         return QtGui.QIcon(os.path.dirname(__file__) + "/../images/toolbox.png")
 
     def processAlgorithm(self, progress):
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
-        output = self.getOutputValue(self.OUTPUT)
+        output = self.getOutputFromName(self.OUTPUT)
         vprovider = vlayer.dataProvider()
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
-        writer = QgsVectorFileWriter( output, systemEncoding,
-            fields, QGis.WKBLineString, vprovider.crs() )
+        writer = output.getVectorWriter(fields, QGis.WKBLineString, vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

python/plugins/sextante/algs/FieldPyculator.py

@@ -0,0 +1,214 @@
+from sextante.core.GeoAlgorithm import GeoAlgorithm
+from sextante.outputs.OutputVector import OutputVector
+from sextante.parameters.ParameterVector import ParameterVector
+from qgis.core import *
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from sextante.parameters.ParameterString import ParameterString
+from sextante.core.QGisLayers import QGisLayers
+import os
+from PyQt4 import QtGui
+from sextante.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
+from sextante.parameters.ParameterBoolean import ParameterBoolean
+import sys
+
+
+class FieldsPyculator(GeoAlgorithm):
+
+    INPUT_LAYER = "INPUT_LAYER"
+    USE_SELECTED = "USE_SELECTED"
+    FIELD_NAME = "FIELD_NAME"
+    GLOBAL = "GLOBAL"
+    FORMULA = "FORMULA"
+    OUTPUT_LAYER ="OUTPUT_LAYER"
+    RESULT_VAR_NAME = "value"
+
+    def getIcon(self):
+        return QtGui.QIcon(os.path.dirname(__file__) + "/../images/toolbox.png")
+
+    def defineCharacteristics(self):
+        self.name = "Field Pyculator"
+        self.group = "Algorithms for vector layers"
+        self.addParameter(ParameterVector(self.INPUT_LAYER, "Input layer", ParameterVector.VECTOR_TYPE_ANY, False))
+        self.addParameter(ParameterBoolean(self.USE_SELECTED, "Use only selected features", False))
+        self.addParameter(ParameterString(self.FIELD_NAME, "Result field name", "NewField"))
+        self.addParameter(ParameterString(self.GLOBAL, "Global expression", multiline = True))
+        self.addParameter(ParameterString(self.FORMULA, "Formula", "value = ", multiline = True))
+        self.addOutput(OutputVector(self.OUTPUT_LAYER, "Output layer"))
+
+
+    def processAlgorithm(self, progress):
+        fieldname = self.getParameterValue(self.FIELD_NAME)
+        code = self.getParameterValue(self.FORMULA)
+        globalExpression = self.getParameterValue(self.GLOBAL)
+        useSelected = self.getParameterValue(self.USE_SELECTED)
+        settings = QSettings()
+        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
+        output = self.getOutputFromName(self.OUTPUT_LAYER)
+        layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
+        vprovider = layer.dataProvider()
+        allAttrs = vprovider.attributeIndexes()
+        vprovider.select( allAttrs )
+        fields = vprovider.fields()
+        fields[len(fields)] = QgsField(fieldname, QVariant.Double)
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
+        outFeat = QgsFeature()
+        nFeatures = vprovider.featureCount()
+        nElement = 0
+        new_ns = {}
+
+        #run global code
+        if globalExpression.strip() != "":
+            try:
+                bytecode = compile(globalExpression, '<string>', 'exec')
+                exec bytecode in new_ns
+            except:
+                raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n" +
+                            "Global code block can't be executed!%s \n %s" %
+                            (unicode(sys.exc_info()[0].__name__), unicode(sys.exc_info()[1])))
+
+        #replace all fields tags
+        field_map = vprovider.fields()
+        for num, field in field_map.iteritems():
+            field_name = unicode(field.name())
+            replval = '__attr[' + str(num) + ']'
+            code = code.replace("<"+field_name+">",replval)
+
+        #replace all special vars
+        code = code.replace('$id','__id')
+        code = code.replace('$geom','__geom')
+        need_id = code.find("__id") != -1
+        need_geom = code.find("__geom") != -1
+        need_attrs = code.find("__attr") != -1
+
+
+        #compile
+        try:
+            bytecode = compile(code, '<string>', 'exec')
+        except:
+            raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n"+
+                                 "Field code block can't be executed! %s \n %s"
+                                 (unicode(sys.exc_info()[0].__name__), unicode(sys.exc_info()[1])))
+
+
+        #run
+        if not useSelected:
+            feat = QgsFeature()
+            if need_attrs:
+                attr_ind = vprovider.attributeIndexes()
+            else:
+                attr_ind = []
+            vprovider.select(attr_ind, QgsRectangle(), True)
+
+            while vprovider.nextFeature(feat):
+                progress.setPercentage(int((100 * nElement)/nFeatures))
+                attrMap = feat.attributeMap()
+                feat_id = feat.id()
+
+                #add needed vars
+                if need_id:
+                    new_ns['__id'] = feat_id
+
+                if need_geom:
+                    geom = feat.geometry()
+                    new_ns['__geom'] = geom
+
+                if need_attrs:
+                    attr = []
+                    for num,a in attrMap.iteritems():
+                        attr.append(self.Qvar2py(a))
+                    new_ns['__attr'] = attr
+
+                #clear old result
+                if new_ns.has_key(self.RESULT_VAR_NAME):
+                    del new_ns[self.RESULT_VAR_NAME]
+
+
+                #exec
+                #try:
+                exec bytecode in new_ns
+                #except:
+                #    raise e
+                #===============================================================
+                # GeoAlgorithmExecutionException("FieldPyculator code execute error\n"+
+                #            "Field code block can't be executed for feature %s\n%s\n%s" %
+                #            (unicode(sys.exc_info()[0].__name__),
+                #            unicode(sys.exc_info()[1]),
+                #            unicode(feat_id)))
+                #===============================================================
+
+                #check result
+                if not new_ns.has_key(self.RESULT_VAR_NAME):
+                    raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n" +
+                            "Field code block does not return '%s1' variable! Please declare this variable in your code!" %
+                            self.RESULT_VAR_NAME)
+
+
+                #write feature
+                nElement += 1
+                outFeat.setGeometry( feat.geometry() )
+                outFeat.setAttributeMap( attrMap )
+                outFeat.addAttribute(len(vprovider.fields()), QVariant(new_ns[self.RESULT_VAR_NAME]))
+                writer.addFeature(outFeat)
+
+        else:
+            features = layer.selectedFeatures()
+            nFeatures = len(features)
+            for feat in features:
+                progress.setPercentage(int((100 * nElement)/nFeatures))
+                attrMap = feat.attributeMap()
+                feat_id = feat.id()
+
+                #add needed vars
+                if need_id:
+                    new_ns['__id'] = feat_id
+
+                if need_geom:
+                    geom = feat.geometry()
+                    new_ns['__geom'] = geom
+
+                if need_attrs:
+                    attrMap = feat.attributeMap()
+                    attr = []
+                    for num,a in attrMap.iteritems():
+                        attr.append(self.Qvar2py(a))
+                    new_ns['__attr'] = attr
+
+                #clear old result
+                if new_ns.has_key(self.RESULT_VAR_NAME):
+                    del new_ns[self.RESULT_VAR_NAME]
+
+                #exec
+                exec bytecode in new_ns
+
+                #check result
+                if not new_ns.has_key(self.RESULT_VAR_NAME):
+                    raise GeoAlgorithmExecutionException("FieldPyculator code execute error\n" +
+                            "Field code block does not return '%s1' variable! Please declare this variable in your code!" %
+                            self.RESULT_VAR_NAME)
+
+                #write feature
+                nElement += 1
+                outFeat.setGeometry( feat.geometry() )
+                outFeat.setAttributeMap( attrMap )
+                outFeat.addAttribute(len(vprovider.fields()), QVariant(new_ns[self.RESULT_VAR_NAME]))
+                writer.addFeature(outFeat)
+
+        del writer
+
+
+    def Qvar2py(self,qv):
+        if qv.type() == 2:
+            return qv.toInt()[0]
+        if qv.type() == 10:
+            return unicode(qv.toString())
+        if qv.type() == 6:
+            return qv.toDouble()[0]
+        return None
+
+
+    def checkParameterValuesBeforeExecuting(self):
+        ##TODO check that formula is correct and fields exist
+        pass
+
+

python/plugins/sextante/algs/FieldsCalculator.py

@@ -32,16 +32,14 @@ def defineCharacteristics(self):
     def processAlgorithm(self, progress):
         fieldname = self.getParameterValue(self.FIELD_NAME)
         formula = self.getParameterValue(self.FORMULA)
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
-        output = self.getOutputValue(self.OUTPUT_LAYER)
+        output = self.getOutputFromName(self.OUTPUT_LAYER)
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
         vprovider = vlayer.dataProvider()
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
         fields[len(fields)] = QgsField(fieldname, QVariant.Double)
-        writer = QgsVectorFileWriter( output, systemEncoding,fields, vprovider.geometryType(), vprovider.crs() )
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()

python/plugins/sextante/algs/SaveSelectedFeatures.py

@@ -50,7 +50,7 @@ def processAlgorithm(self, progress):
         #the first thing to do is retrieve the values of the parameters
         #entered by the user
         inputFilename = self.getParameterValue(self.INPUT_LAYER)
-        output = self.getOutputValue(self.OUTPUT_LAYER)
+        output = self.getOutputFromName(self.OUTPUT_LAYER)
 
         #input layers values are always a string with its location.
         #That string can be converted into a QGIS object (a QgsVectorLayer in this case))
@@ -60,12 +60,10 @@ def processAlgorithm(self, progress):
         #And now we can process
 
         #First we create the output layer.
-        #The output value entered by the user is a string containing a filename,
-        #so we can use it directly
-        settings = QSettings()
-        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
+        #To do so, we call the getVectorWriter method in the Output object.
+        #That will give as a SextanteVectorWriter, that we can later use to add features.
         provider = vectorLayer.dataProvider()
-        writer = QgsVectorFileWriter( output, systemEncoding, provider.fields(), provider.geometryType(), provider.crs() )
+        writer = output.getVectorWriter( provider.fields(), provider.geometryType(), provider.crs() )
 
         #Now we take the selected features and add them to the output layer
         selection = vectorLayer.selectedFeatures()

python/plugins/sextante/algs/SextanteAlgorithmProvider.py

@@ -6,13 +6,14 @@
 from sextante.algs.SaveSelectedFeatures import SaveSelectedFeatures
 from sextante.algs.Explode import Explode
 from sextante.algs.AutoincrementalField import AutoincrementalField
+from sextante.algs.FieldPyculator import FieldsPyculator
 
 class SextanteAlgorithmProvider(AlgorithmProvider):
 
     def __init__(self):
         AlgorithmProvider.__init__(self)
         self.alglist = [AddTableField(), FieldsCalculator(), SaveSelectedFeatures(),
-                        AutoincrementalField(), Explode()]
+                        AutoincrementalField(), Explode(), FieldsPyculator()]
 
     def initializeSettings(self):
         AlgorithmProvider.initializeSettings(self)
@@ -33,3 +34,6 @@ def getIcon(self):
 
     def _loadAlgorithms(self):
         self.algs = self.alglist
+
+    def supportsNonFileBasedOutput(self):
+        return True