python/plugins/sextante/SextantePlugin.py

@@ -25,12 +25,9 @@
 
 import os, sys
 import inspect
-
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
-
 from qgis.core import *
-
 from sextante.core.Sextante import Sextante
 from sextante.core.QGisLayers import QGisLayers
 from sextante.core.SextanteUtils import SextanteUtils
@@ -94,14 +91,6 @@ def initGui(self):
         self.resultsAction.triggered.connect(self.openResults)
         self.menu.addAction(self.resultsAction)
 
-        #=======================================================================
-        # self.helpAction = QAction(QIcon(":/sextante/images/help.png"),
-        #    QCoreApplication.translate("SEXTANTE", "&SEXTANTE help"),
-        #    self.iface.mainWindow())
-        # self.helpAction.triggered.connect(self.openHelp)
-        # self.menu.addAction(self.helpAction)
-        #=======================================================================
-
         menuBar = self.iface.mainWindow().menuBar()
         menuBar.insertMenu(menuBar.actions()[-1], self.menu)
 
@@ -143,7 +132,3 @@ def openConfig(self):
         dlg = ConfigDialog(self.toolbox)
         dlg.exec_()
 
-    #===========================================================================
-    # def openHelp(self):
-    #    QDesktopServices.openUrl(QUrl(os.path.dirname(__file__) + "/help/index.html"))
-    #===========================================================================

python/plugins/sextante/__init__.py

@@ -17,7 +17,7 @@
 ***************************************************************************
 """
 
-from sextante.core.Sextante import runalg, runandload, alghelp, alglist, algoptions, load, loadFromAlg, extent, getObjectFromName, getObjectFromUri
+from sextante.core.Sextante import runalg, runandload, alghelp, alglist, algoptions, load, loadFromAlg, extent, getObjectFromName, getObjectFromUri, features
 
 __author__ = 'Victor Olaya'
 __date__ = 'August 2012'

python/plugins/sextante/algs/AddTableField.py

@@ -63,23 +63,21 @@ def processAlgorithm(self, progress):
         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 = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         outFeat = QgsFeature()
-        inGeom = QgsGeometry()
-        nFeat = vprovider.featureCount()
+        inGeom = QgsGeometry()        
         nElement = 0
         features = QGisLayers.features(vlayer)
+        nFeat = len(features)
         for inFeat in features:
             progress.setPercentage(int((100 * nElement)/nFeat))
             nElement += 1
             inGeom = inFeat.geometry()
             outFeat.setGeometry( inGeom )
             atMap = inFeat.attributeMap()
-            outFeat.setAttributeMap( atMap )
+            atMap.append(QVariant())            
             outFeat.addAttribute( len(vprovider.fields()), QVariant() )
             writer.addFeature( outFeat )
         del writer

python/plugins/sextante/algs/AutoincrementalField.py

@@ -29,8 +29,6 @@
 from sextante.parameters.ParameterVector import ParameterVector
 from sextante.core.QGisLayers import QGisLayers
 from sextante.outputs.OutputVector import OutputVector
-import os
-from PyQt4 import QtGui
 
 class AutoincrementalField(GeoAlgorithm):
 
@@ -46,25 +44,24 @@ def processAlgorithm(self, progress):
         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 = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()
-        nFeat = vprovider.featureCount()
         nElement = 0
-        while vprovider.nextFeature(inFeat):
-          progress.setPercentage(int((100 * nElement)/nFeat))
-          nElement += 1
-          inGeom = inFeat.geometry()
-          outFeat.setGeometry( inGeom )
-          atMap = inFeat.attributeMap()
-          outFeat.setAttributeMap( atMap )
-          outFeat.addAttribute( len(vprovider.fields()), QVariant(nElement) )
-          writer.addFeature( outFeat )
+        features = QGisLayers.features(vlayer)
+        nFeat = len(features)
+        for inFeat in features:
+            progress.setPercentage(int((100 * nElement)/nFeat))
+            nElement += 1
+            inGeom = inFeat.geometry()
+            outFeat.setGeometry( inGeom )
+            atMap = inFeat.attributeMap()
+            atMap.append(QVariant(nElement))
+            outFeat.setAttributeMap( atMap )          
+            writer.addFeature( outFeat )
         del writer
 
     def defineCharacteristics(self):
@@ -73,3 +70,5 @@ def defineCharacteristics(self):
         self.addParameter(ParameterVector(self.INPUT, "Input layer", ParameterVector.VECTOR_TYPE_ANY))
         self.addOutput(OutputVector(self.OUTPUT, "Output layer"))
 
+
+

python/plugins/sextante/algs/CreateConstantRaster.py

@@ -0,0 +1,66 @@
+from sextante.core.SextanteRasterWriter import SextanteRasterWriter
+from sextante.parameters.ParameterRaster import ParameterRaster
+
+
+
+# -*- coding: utf-8 -*-
+
+"""
+***************************************************************************
+    AutoincrementalField.py
+    ---------------------
+    Date                 : August 2012
+    Copyright            : (C) 2012 by Victor Olaya
+    Email                : volayaf at gmail dot com
+***************************************************************************
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) any later version.                                   *
+*                                                                         *
+***************************************************************************
+"""
+
+__author__ = 'Victor Olaya'
+__date__ = 'August 2012'
+__copyright__ = '(C) 2012, Victor Olaya'
+# This will get replaced with a git SHA1 when you do a git archive
+__revision__ = '$Format:%H$'
+
+from sextante.core.GeoAlgorithm import GeoAlgorithm
+from PyQt4.QtCore import *
+from qgis.core import *
+from sextante.parameters.ParameterNumber import ParameterNumber
+from sextante.outputs.OutputRaster import OutputRaster
+from sextante.core.QGisLayers import QGisLayers
+
+class CreateConstantRaster(GeoAlgorithm):
+
+    INPUT = "INPUT"
+    OUTPUT = "OUTPUT"
+    NUMBER = "NUMBER"
+
+    #===========================================================================
+    # def getIcon(self):
+    #    return QtGui.QIcon(os.path.dirname(__file__) + "/../images/toolbox.png")
+    #===========================================================================
+
+    def processAlgorithm(self, progress):
+        output = self.getOutputFromName(self.OUTPUT)
+        value = self.getOutputValue(self.NUMBER)
+        layer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
+        cellsize = (layer.extent().xMaximum() - layer.extent().xMinimum())/layer.width()
+        w = SextanteRasterWriter(output.getCompatibleFileName(self), layer.extent().xMinimum(), layer.extent().yMinimum(), layer.extent().xMaximum(), 
+                                 layer.extent().yMaximum(), cellsize, 1, self.crs)
+        w.matrix[:] = value
+        w.close()
+
+    def defineCharacteristics(self):
+        self.name = "Create constant raster layer"
+        self.group = "Raster tools"
+        self.addParameter(ParameterRaster(self.INPUT, "Reference layer"))
+        self.addParameter(ParameterNumber(self.NUMBER, "Constant value", default = 1.0));
+        self.addOutput(OutputRaster(self.OUTPUT, "Output layer"))
+
+

python/plugins/sextante/algs/EquivalentNumField.py

@@ -29,7 +29,6 @@
 from sextante.parameters.ParameterVector import ParameterVector
 from sextante.core.QGisLayers import QGisLayers
 from sextante.outputs.OutputVector import OutputVector
-from PyQt4 import QtGui
 from sextante.parameters.ParameterTableField import ParameterTableField
 
 class EquivalentNumField(GeoAlgorithm):
@@ -48,37 +47,28 @@ def processAlgorithm(self, progress):
         output = self.getOutputFromName(self.OUTPUT)
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
         vprovider = vlayer.dataProvider()
-        field_index = vprovider.fieldNameIndex(fieldname)
-        allAttrs = vprovider.attributeIndexes()
-        vprovider.select(allAttrs)
+        fieldindex = vlayer.fieldNameIndex(fieldname)        
         fields = vprovider.fields()
-        fields[len(fields)] = QgsField("NUM_FIELD", QVariant.Int)
-        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
-        inFeat = QgsFeature()
+        fields.append(QgsField("NUM_FIELD", QVariant.Int))
+        writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )        
         outFeat = QgsFeature()
-        inGeom = QgsGeometry()
-        nFeat = vprovider.featureCount()
+        inGeom = QgsGeometry()        
         nElement = 0
         classes = {}
-        features = QGisLayers.features(layer)
+        features = QGisLayers.features(vlayer)
+        nFeat = len(features)
         for feature in features:
-          progress.setPercentage(int((100 * nElement)/nFeat))
-          nElement += 1
-          atMap = feature.attributeMap()
-          clazz = atMap[field_index].toString()
-          if clazz not in classes:
-              classes[clazz] = len(classes.keys())
-        features = QGisLayers.features(layer)
-        for feature in features:
-          progress.setPercentage(int((100 * nElement)/nFeat))
-          nElement += 1
-          inGeom = features.geometry()
-          outFeat.setGeometry( inGeom )
-          atMap = inFeat.attributeMap()
-          clazz = atMap[field_index].toString()
-          outFeat.setAttributeMap( atMap )
-          outFeat.addAttribute( len(vprovider.fields()), QVariant(classes[clazz]) )
-          writer.addFeature( outFeat )
+            progress.setPercentage(int((100 * nElement)/nFeat))
+            nElement += 1
+            inGeom = feature.geometry()
+            outFeat.setGeometry( inGeom )
+            atMap = feature.attributes()
+            clazz = atMap[fieldindex].toString()
+            if clazz not in classes:
+                classes[clazz] = len(classes.keys())
+            atMap.append(QVariant(classes[clazz]))
+            outFeat.setAttributes(atMap)                        
+            writer.addFeature( outFeat )
         del writer
 
     def defineCharacteristics(self):

python/plugins/sextante/algs/Explode.py

@@ -24,7 +24,6 @@
 __revision__ = '$Format:%H$'
 
 from sextante.core.GeoAlgorithm import GeoAlgorithm
-from PyQt4 import QtGui
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from qgis.core import *
@@ -46,11 +45,8 @@ def processAlgorithm(self, progress):
         vlayer = QGisLayers.getObjectFromUri(self.getParameterValue(self.INPUT))
         output = self.getOutputFromName(self.OUTPUT)
         vprovider = vlayer.dataProvider()
-        allAttrs = vprovider.attributeIndexes()
-        vprovider.select( allAttrs )
         fields = vprovider.fields()
         writer = output.getVectorWriter(fields, QGis.WKBLineString, vprovider.crs() )
-        inFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()
         nFeat = vprovider.featureCount()
@@ -60,9 +56,9 @@ def processAlgorithm(self, progress):
             nElement += 1
             progress.setPercentage((nElement*100)/nFeat)
             inGeom = feature.geometry()
-            atMap = feature.attributeMap()
+            atMap = feature.attributes()
             segments = self.extractAsSingleSegments( inGeom )
-            outFeat.setAttributeMap( atMap )
+            outFeat.setAttributes( atMap )
             for segment in segments:
                 outFeat.setGeometry(segment)
                 writer.addFeature(outFeat)

python/plugins/sextante/algs/FieldPyculator.py

@@ -70,7 +70,7 @@ def processAlgorithm(self, progress):
         allAttrs = vprovider.attributeIndexes()
         vprovider.select( allAttrs )
         fields = vprovider.fields()
-        fields[len(fields)] = QgsField(fieldname, QVariant.Double)
+        fields.append(QgsField(fieldname, QVariant.Double))
         writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs() )
         outFeat = QgsFeature()
         new_ns = {}
@@ -86,11 +86,13 @@ def processAlgorithm(self, progress):
                             (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():
+        fields = vprovider.fields()
+        num = 0
+        for field in fields:
             field_name = unicode(field.name())
             replval = '__attr[' + str(num) + ']'
             code = code.replace("<"+field_name+">",replval)
+            num += 1
 
         #replace all special vars
         code = code.replace('$id','__id')
@@ -109,18 +111,12 @@ def processAlgorithm(self, progress):
                                  (unicode(sys.exc_info()[0].__name__), unicode(sys.exc_info()[1])))
 
         #run
-        if need_attrs:
-            attr_ind = vprovider.attributeIndexes()
-        else:
-            attr_ind = []
-        vprovider.select(attr_ind, QgsRectangle(), True)
-
         features = QGisLayers.features(layer)
         nFeatures = len(features)
         nElement = 1
         for feat in features:
             progress.setPercentage(int((100 * nElement)/nFeatures))
-            attrMap = feat.attributeMap()
+            attrMap = feat.attributes()
             feat_id = feat.id()
 
             #add needed vars
@@ -132,10 +128,8 @@ def processAlgorithm(self, progress):
                 new_ns['__geom'] = geom
 
             if need_attrs:
-                attr = []
-                for num,a in attrMap.iteritems():
-                    attr.append(self.Qvar2py(a))
-                new_ns['__attr'] = attr
+                pyattrs = [self.Qvar2py(a) for a in attrMap]                
+                new_ns['__attr'] = pyattrs
 
             #clear old result
             if new_ns.has_key(self.RESULT_VAR_NAME):
@@ -165,8 +159,8 @@ def processAlgorithm(self, progress):
             #write feature
             nElement += 1
             outFeat.setGeometry( feat.geometry() )
-            outFeat.setAttributeMap( attrMap )
-            outFeat.addAttribute(len(vprovider.fields()), QVariant(new_ns[self.RESULT_VAR_NAME]))
+            attrMap.append(QVariant(new_ns[self.RESULT_VAR_NAME]))
+            outFeat.setAttributeMap( attrMap )            
             writer.addFeature(outFeat)
 
         del writer

python/plugins/sextante/algs/FieldsCalculator.py

@@ -60,10 +60,8 @@ def processAlgorithm(self, progress):
         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)
+        fields.append(QgsField(fieldname, QVariant.Double))
         writer = output.getVectorWriter(fields, vprovider.geometryType(), vprovider.crs())
         outFeat = QgsFeature()
         inGeom = QgsGeometry()
@@ -72,10 +70,12 @@ def processAlgorithm(self, progress):
         features = QGisLayers.features(vlayer)
         for inFeat in features:
             progress.setPercentage(int((100 * nElement) / nFeat))
-            attrs = inFeat.attributeMap()
+            attrs = inFeat.attributes()
             expression = formula
-            for (k, attr) in attrs.iteritems():
+            k = 0
+            for attr in attrs:
                 expression = expression.replace(str(fields[k].name()), str(attr.toString()))
+                k += 1
             try:
                 result = eval(expression)
             except Exception:
@@ -85,8 +85,8 @@ def processAlgorithm(self, progress):
             inGeom = inFeat.geometry()
             outFeat.setGeometry(inGeom)
             atMap = inFeat.attributeMap()
-            outFeat.setAttributeMap(atMap)
-            outFeat.addAttribute(len(vprovider.fields()), QVariant(result))
+            atMap.append(QVariant(result))
+            outFeat.setAttributeMap(atMap)            
             writer.addFeature(outFeat)
         del writer