implemented saga resampling procedure

some ftools algorithms git-svn-id: http://sextante.googlecode.com/svn/trunk/soft/bindings/qgis-plugin@29 881b9c09-3ef8-f3c2-ec3d-21d735c97f4d
qgis · Mar 6, 2012 · fd72ae8 · fd72ae8
1 parent 562ca20
commit fd72ae8
Show file tree

Hide file tree

Showing 14 changed files with 542 additions and 26 deletions.
diff --git a/src/sextante/core/GeoAlgorithm.py b/src/sextante/core/GeoAlgorithm.py
@@ -84,15 +84,15 @@ def canBeExecuted(self, layersCount):
     def __str__(self):
         s = "ALGORITHM: " + self.name + "\n"
         for param in self.parameters:
-            s+=(str(param) + "\n")
+            s+=("\t" + str(param) + "\n")
         for out in self.outputs:
-            s+=(str(out) + "\n")
+            s+=("\t" + str(out) + "\n")
         s+=("\n")
         return s
 
 
     def commandLineName(self):
-        return self.provider.getName().lower() + ":" + self.name.lower().replace(" ", "")
+        return self.provider.getName().lower() + ":" + self.name.lower().replace(" ", "").replace(",","")
 
 
     def getOutputFromName(self, name):

diff --git a/src/sextante/core/Sextante.py b/src/sextante/core/Sextante.py
@@ -15,6 +15,7 @@
 from sextante.gui.SextantePostprocessing import SextantePostprocessing
 from sextante.modeler.ProviderIcons import ProviderIcons
 from sextante.r.RAlgorithmProvider import RAlgorithmProvider
+from sextante.parameters.ParameterSelection import ParameterSelection
 
 class Sextante:
 
@@ -143,6 +144,23 @@ def alglist(text=None):
                     s+=(alg.name.ljust(50, "-") + "--->" + alg.commandLineName() + "\n")
         print s
 
+
+    @staticmethod
+    def algoptions(name):
+        alg = Sextante.getAlgorithm(name)
+        if alg != None:
+            s =""
+            for param in alg.parameters:
+                if isinstance(param, ParameterSelection):
+                    s+=param.name + "(" + param.description + ")\n"
+                    i=0
+                    for option in param.options:
+                        s+= "\t" + str(i) + " - " + str(option) + "\n"
+                        i+=1
+            print(s)
+        else:
+            print "Algorithm not found"
+
     @staticmethod
     def alghelp(name):
         alg = Sextante.getAlgorithm(name)

diff --git a/src/sextante/ftools/Clip.py b/src/sextante/ftools/Clip.py
@@ -0,0 +1,261 @@
+from sextante.core.GeoAlgorithm import GeoAlgorithm
+import os.path
+from PyQt4 import QtGui
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from qgis.core import *
+from sextante.parameters.ParameterVector import ParameterVector
+from sextante.core.QGisLayers import QGisLayers
+from sextante.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
+from sextante.outputs.OutputVector import OutputVector
+from sextante.ftools import ftools_utils
+from sextante.core.SextanteLog import SextanteLog
+from sextante.parameters.ParameterBoolean import ParameterBoolean
+
+class Clip(GeoAlgorithm):
+
+    INPUT = "INPUT"
+    INPUT2 = "INPUT2"
+    OUTPUT = "OUTPUT"
+    USE_SELECTED = "USE_SELECTED"
+    USE_SELECTED2 = "USE_SELECTED2"
+
+    def getIcon(self):
+        return QtGui.QIcon(os.path.dirname(__file__) + "/icons/clip.png")
+
+    def processAlgorithm(self, progress):
+        settings = QSettings()
+        systemEncoding = settings.value( "/UI/encoding", "System" ).toString()
+        output = self.getOutputValue(Clip.OUTPUT)
+        useSelection = self.getParameterValue(Clip.USE_SELECTED)
+        useSelection2 = self.getParameterValue(Clip.USE_SELECTED2)
+        vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Clip.INPUT))
+        vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Clip.INPUT2))
+        GEOS_EXCEPT = True
+        FEATURE_EXCEPT = True
+        vproviderA = self.vlayerA.dataProvider()
+        allAttrsA = vproviderA.attributeIndexes()
+        vproviderA.select( allAttrsA )
+        vproviderB = self.vlayerB.dataProvider()
+        allAttrsB = vproviderB.attributeIndexes()
+        vproviderB.select( allAttrsB )
+        # check for crs compatibility
+        crsA = vproviderA.crs()
+        crsB = vproviderB.crs()
+        if not crsA.isValid() or not crsB.isValid():
+            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Intersection. Invalid CRS. Results might be unexpected")
+        else:
+            if not crsA != crsB:
+                SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Intersection. Non-matching CRSs. Results might be unexpected")
+        fields = vproviderA.fields()
+        writer = QgsVectorFileWriter( output, systemEncoding,fields, vproviderA.geometryType(), vproviderA.crs() )
+
+        inFeatA = QgsFeature()
+        inFeatB = QgsFeature()
+        outFeat = QgsFeature()
+        index = ftools_utils.createIndex( vproviderB )
+        vproviderA.rewind()
+        nElement = 0
+        # there is selection in input layer
+        if useSelection:
+          nFeat = vlayerA.selectedFeatureCount()
+          selectionA = self.vlayerA.selectedFeatures()
+          # we have selection in overlay layer
+          if useSelection2:
+            selectionB = self.vlayerB.selectedFeaturesIds()
+            for inFeatA in selectionA:
+              nElement += 1
+              progress.setPercentage(int(nElement/nFeat * 100))
+              geom = QgsGeometry( inFeatA.geometry() )
+              int_geom = QgsGeometry( geom )
+              atMap = inFeatA.attributeMap()
+              intersects = index.intersects( geom.boundingBox() )
+              found = False
+              first = True
+              for id in intersects:
+                if id in selectionB:
+                  vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
+                  tmpGeom = QgsGeometry( inFeatB.geometry() )
+                  if tmpGeom.intersects( geom ):
+                    found = True
+                    if first:
+                      outFeat.setGeometry( QgsGeometry( tmpGeom ) )
+                      first = False
+                    else:
+                      try:
+                        cur_geom = QgsGeometry( outFeat.geometry() )
+                        new_geom = QgsGeometry( cur_geom.combine( tmpGeom ) )
+                        outFeat.setGeometry( QgsGeometry( new_geom ) )
+                      except:
+                        GEOS_EXCEPT = False
+                        break
+              if found:
+                try:
+                  cur_geom = QgsGeometry( outFeat.geometry() )
+                  new_geom = QgsGeometry( geom.intersection( cur_geom ) )
+                  if new_geom.wkbType() == 7:
+                    int_com = QgsGeometry( geom.combine( cur_geom ) )
+                    int_sym = QgsGeometry( geom.symDifference( cur_geom ) )
+                    new_geom = QgsGeometry( int_com.difference( int_sym ) )
+                  try:
+                    outFeat.setGeometry( new_geom )
+                    outFeat.setAttributeMap( atMap )
+                    writer.addFeature( outFeat )
+                  except:
+                    FEAT_EXCEPT = False
+                    continue
+                except:
+                  GEOS_EXCEPT = False
+                  continue
+          # we have no selection in overlay layer
+          else:
+            for inFeatA in selectionA:
+              nElement += 1
+              progress.setPercentage(int(nElement/nFeat * 100))
+              geom = QgsGeometry( inFeatA.geometry() )
+              atMap = inFeatA.attributeMap()
+              intersects = index.intersects( geom.boundingBox() )
+              found = False
+              first = True
+              for id in intersects:
+                vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
+                tmpGeom = QgsGeometry( inFeatB.geometry() )
+                if tmpGeom.intersects( geom ):
+                  found = True
+                  if first:
+                    outFeat.setGeometry( QgsGeometry( tmpGeom ) )
+                    first = False
+                  else:
+                    try:
+                      cur_geom = QgsGeometry( outFeat.geometry() )
+                      new_geom = QgsGeometry( cur_geom.combine( tmpGeom ) )
+                      outFeat.setGeometry( QgsGeometry( new_geom ) )
+                    except:
+                      GEOS_EXCEPT = False
+                      break
+              if found:
+                try:
+                  cur_geom = QgsGeometry( outFeat.geometry() )
+                  new_geom = QgsGeometry( geom.intersection( cur_geom ) )
+                  if new_geom.wkbType() == 7:
+                    int_com = QgsGeometry( geom.combine( cur_geom ) )
+                    int_sym = QgsGeometry( geom.symDifference( cur_geom ) )
+                    new_geom = QgsGeometry( int_com.difference( int_sym ) )
+                  try:
+                    outFeat.setGeometry( new_geom )
+                    outFeat.setAttributeMap( atMap )
+                    writer.addFeature( outFeat )
+                  except:
+                    FEAT_EXCEPT = False
+                    continue
+                except:
+                  GEOS_EXCEPT = False
+                  continue
+        # there is no selection in input layer
+        else:
+          nFeat = vproviderA.featureCount()
+          # we have selection in overlay layer
+          if useSelection2:
+            selectionB = self.vlayerB.selectedFeaturesIds()
+            while vproviderA.nextFeature( inFeatA ):
+              nElement += 1
+              progress.setPercentage(int(nElement/nFeat * 100))
+              geom = QgsGeometry( inFeatA.geometry() )
+              atMap = inFeatA.attributeMap()
+              intersects = index.intersects( geom.boundingBox() )
+              found = False
+              first = True
+              for id in intersects:
+                if id in selectionB:
+                  vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
+                  tmpGeom = QgsGeometry( inFeatB.geometry() )
+                  if tmpGeom.intersects( geom ):
+                    found = True
+                    if first:
+                      outFeat.setGeometry( QgsGeometry( tmpGeom ) )
+                      first = False
+                    else:
+                      try:
+                        cur_geom = QgsGeometry( outFeat.geometry() )
+                        new_geom = QgsGeometry( cur_geom.combine( tmpGeom ) )
+                        outFeat.setGeometry( QgsGeometry( new_geom ) )
+                      except:
+                        GEOS_EXCEPT = False
+                        break
+              if found:
+                try:
+                  cur_geom = QgsGeometry( outFeat.geometry() )
+                  new_geom = QgsGeometry( geom.intersection( cur_geom ) )
+                  if new_geom.wkbType() == 7:
+                    int_com = QgsGeometry( geom.combine( cur_geom ) )
+                    int_sym = QgsGeometry( geom.symDifference( cur_geom ) )
+                    new_geom = QgsGeometry( int_com.difference( int_sym ) )
+                  try:
+                    outFeat.setGeometry( new_geom )
+                    outFeat.setAttributeMap( atMap )
+                    writer.addFeature( outFeat )
+                  except:
+                    FEAT_EXCEPT = False
+                    continue
+                except:
+                  GEOS_EXCEPT = False
+                  continue
+          # we have no selection in overlay layer
+          else:
+            while vproviderA.nextFeature( inFeatA ):
+              nElement += 1
+              progress.setPercentage(int(nElement/nFeat * 100))
+              geom = QgsGeometry( inFeatA.geometry() )
+              atMap = inFeatA.attributeMap()
+              intersects = index.intersects( geom.boundingBox() )
+              first = True
+              found = False
+              if len( intersects ) > 0:
+                for id in intersects:
+                  vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
+                  tmpGeom = QgsGeometry( inFeatB.geometry() )
+                  if tmpGeom.intersects( geom ):
+                    found = True
+                    if first:
+                      outFeat.setGeometry( QgsGeometry( tmpGeom ) )
+                      first = False
+                    else:
+                      try:
+                        cur_geom = QgsGeometry( outFeat.geometry() )
+                        new_geom = QgsGeometry( cur_geom.combine( tmpGeom ) )
+                        outFeat.setGeometry( QgsGeometry( new_geom ) )
+                      except:
+                        GEOS_EXCEPT = False
+                        break
+                if found:
+                  try:
+                    cur_geom = QgsGeometry( outFeat.geometry() )
+                    new_geom = QgsGeometry( geom.intersection( cur_geom ) )
+                    if new_geom.wkbType() == 7:
+                      int_com = QgsGeometry( geom.combine( cur_geom ) )
+                      int_sym = QgsGeometry( geom.symDifference( cur_geom ) )
+                      new_geom = QgsGeometry( int_com.difference( int_sym ) )
+                    try:
+                      outFeat.setGeometry( new_geom )
+                      outFeat.setAttributeMap( atMap )
+                      writer.addFeature( outFeat )
+                    except:
+                      FEAT_EXCEPT = False
+                      continue
+                  except:
+                    GEOS_EXCEPT = False
+                    continue
+        del writer
+        if not GEOS_EXCEPT:
+            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Geometry exception while computing clip")
+        if not FEATURE_EXCEPT:
+            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Feature exception while computing clip")
+
+    def defineCharacteristics(self):
+        self.name = "Clip"
+        self.group = "Geoprocessing tools"
+        self.addParameter(ParameterVector(Clip.INPUT, "Input layer", ParameterVector.VECTOR_TYPE_ANY))
+        self.addParameter(ParameterVector(Clip.INPUT2, "Clip layer", ParameterVector.VECTOR_TYPE_ANY))
+        self.addParameter(ParameterBoolean(Clip.USE_SELECTED, "Use selected features (input)", False))
+        self.addParameter(ParameterBoolean(Clip.USE_SELECTED2, "Use selected features (clip)", False))
+        self.addOutput(OutputVector(Clip.OUTPUT, "Clipped"))
diff --git a/src/sextante/ftools/Difference.py b/src/sextante/ftools/Difference.py
@@ -44,7 +44,7 @@ def processAlgorithm(self, progress):
         crsA = vproviderA.crs()
         crsB = vproviderB.crs()
         if not crsA.isValid() or not crsB.isValid():
-            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Differnece. Invalid CRS. Results might be unexpected")
+            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Difference. Invalid CRS. Results might be unexpected")
         else:
             if not crsA != crsB:
                 SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Difference. Non-matching CRSs. Results might be unexpected")

diff --git a/src/sextante/ftools/FToolsAlgorithmProvider.py b/src/sextante/ftools/FToolsAlgorithmProvider.py
@@ -23,6 +23,8 @@
 from sextante.ftools.Dissolve import Dissolve
 from sextante.ftools.Difference import Difference
 from sextante.ftools.Intersection import Intersection
+from sextante.ftools.Union import Union
+from sextante.ftools.Clip import Clip
 
 class FToolsAlgorithmProvider(AlgorithmProvider):
 
@@ -39,7 +41,7 @@ def _loadAlgorithms(self):
                      SumLines(), BasicStatistics(), PointsInPolygon(),
                      NearestNeighbourAnalysis(), MeanCoords(), LinesIntersection(),
                      ConvexHull(), FixedDistanceBuffer(), VariableDistanceBuffer(),
-                     Dissolve(), Difference(), Intersection()]
+                     Dissolve(), Difference(), Intersection(), Union(), Clip()]
         for alg in self.algs:
             alg.provider = self
 

diff --git a/src/sextante/ftools/Intersection.py b/src/sextante/ftools/Intersection.py
@@ -43,10 +43,10 @@ def processAlgorithm(self, progress):
         crsA = vproviderA.crs()
         crsB = vproviderB.crs()
         if not crsA.isValid() or not crsB.isValid():
-            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Differnece. Invalid CRS. Results might be unexpected")
+            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Intersection. Invalid CRS. Results might be unexpected")
         else:
             if not crsA != crsB:
-                SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Difference. Non-matching CRSs. Results might be unexpected")
+                SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Intersection. Non-matching CRSs. Results might be unexpected")
         fields = ftools_utils.combineVectorFields( self.vlayerA, self.vlayerB )
         longNames = ftools_utils.checkFieldNameLength( fields )
         if not longNames.isEmpty():