예제 #1
0
 def processAlgorithm(self, progress):
     useSelection = self.getParameterValue(Difference.USE_SELECTED)
     useSelection2 = self.getParameterValue(Difference.USE_SELECTED2)
     vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.INPUT))
     vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.INPUT2))
     GEOS_EXCEPT = True
     FEATURE_EXCEPT = True
     vproviderA = vlayerA.dataProvider()
     allAttrsA = vproviderA.attributeIndexes()
     vproviderA.select( allAttrsA )
     vproviderB = vlayerB.dataProvider()
     allAttrsB = vproviderB.attributeIndexes()
     vproviderB.select( allAttrsB )
     fields = vproviderA.fields()
     # check for crs compatibility
     crsA = vproviderA.crs()
     crsB = vproviderB.crs()
     if not crsA.isValid() or not crsB.isValid():
         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")
     writer = self.getOutputFromName(Difference.OUTPUT).getVectorWriter(fields, vproviderA.geometryType(), vproviderA.crs() )
     inFeatA = QgsFeature()
     inFeatB = QgsFeature()
     outFeat = QgsFeature()
     index = ftools_utils.createIndex( vproviderB )
     nElement = 0
     # there is selection in input layer
     if useSelection:
       nFeat = vlayerA.selectedFeatureCount()
       selectionA = vlayerA.selectedFeatures()
       # we have selection in overlay layer
       if useSelection2:
         selectionB = vlayerB.selectedFeaturesIds()
         for inFeatA in selectionA:
           nElement += 1
           progress.setPercentage(int(nElement/nFeat * 100))
           add = True
           geom = QgsGeometry( inFeatA.geometry() )
           diff_geom = QgsGeometry( geom )
           atMap = inFeatA.attributeMap()
           intersects = index.intersects( geom.boundingBox() )
           for id in intersects:
             # is intersect feature in selection
             if id in selectionB:
               vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
               tmpGeom = QgsGeometry( inFeatB.geometry() )
               try:
                 if diff_geom.intersects( tmpGeom ):
                   diff_geom = QgsGeometry( diff_geom.difference( tmpGeom ) )
               except:
                 GEOS_EXCEPT = False
                 add = False
                 break
           if add:
             try:
               outFeat.setGeometry( diff_geom )
               outFeat.setAttributeMap( atMap )
               writer.addFeature( outFeat )
             except:
               FEATURE_EXCEPT = False
               continue
       # we have no selection in overlay layer
       else:
         for inFeatA in selectionA:
           nElement += 1
           progress.setPercentage(int(nElement/nFeat * 100))
           add = True
           geom = QgsGeometry( inFeatA.geometry() )
           diff_geom = QgsGeometry( geom )
           atMap = inFeatA.attributeMap()
           intersects = index.intersects( geom.boundingBox() )
           for id in intersects:
             vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
             tmpGeom = QgsGeometry( inFeatB.geometry() )
             try:
               if diff_geom.intersects( tmpGeom ):
                 diff_geom = QgsGeometry( diff_geom.difference( tmpGeom ) )
             except:
               GEOS_EXCEPT = False
               add = False
               break
           if add:
             try:
               outFeat.setGeometry( diff_geom )
               outFeat.setAttributeMap( atMap )
               writer.addFeature( outFeat )
             except:
               FEATURE_EXCEPT = False
               continue
     # there is no selection in input layer
     else:
       nFeat = vproviderA.featureCount()
       vproviderA.rewind()
       # we have selection in overlay layer
       if useSelection2:
         selectionB = vlayerB.selectedFeaturesIds()
         while vproviderA.nextFeature( inFeatA ):
           nElement += 1
           add = True
           progress.setPercentage(int(nElement/nFeat * 100))
           geom = QgsGeometry( inFeatA.geometry() )
           diff_geom = QgsGeometry( geom )
           atMap = inFeatA.attributeMap()
           intersects = index.intersects( geom.boundingBox() )
           for id in intersects:
             # now check if id in selection
             if id in selectionB:
               vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
               tmpGeom = QgsGeometry( inFeatB.geometry() )
               try:
                 if diff_geom.intersects( tmpGeom ):
                   diff_geom = QgsGeometry( diff_geom.difference( tmpGeom ) )
               except:
                 GEOS_EXCEPT = False
                 add = False
                 break
           if add:
             try:
               outFeat.setGeometry( diff_geom )
               outFeat.setAttributeMap( atMap )
               writer.addFeature( outFeat )
             except:
               FEATURE_EXCEPT = False
               continue
       # we have no selection in overlay layer
       else:
         while vproviderA.nextFeature( inFeatA ):
           nElement += 1
           add = True
           progress.setPercentage(int(nElement/nFeat * 100))
           geom = QgsGeometry( inFeatA.geometry() )
           diff_geom = QgsGeometry( geom )
           atMap = inFeatA.attributeMap()
           intersects = index.intersects( geom.boundingBox() )
           for id in intersects:
             vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
             tmpGeom = QgsGeometry( inFeatB.geometry() )
             try:
               if diff_geom.intersects( tmpGeom ):
                 diff_geom = QgsGeometry( diff_geom.difference( tmpGeom ) )
             except:
               GEOS_EXCEPT = False
               add = False
               break
           if add:
             try:
               outFeat.setGeometry( diff_geom )
               outFeat.setAttributeMap( atMap )
               writer.addFeature( outFeat )
             except:
               FEATURE_EXCEPT = False
               continue
     del writer
     if not GEOS_EXCEPT:
         SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Geometry exception while computing difference")
     if not FEATURE_EXCEPT:
         SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Feature exception while computing difference")
예제 #2
0
파일: Union.py 프로젝트: Nald/Quantum-GIS
    def processAlgorithm(self, progress):
        vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Union.INPUT))
        vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Union.INPUT2))
        GEOS_EXCEPT = True
        FEATURE_EXCEPT = True
        vproviderA = vlayerA.dataProvider()
        allAttrsA = vproviderA.attributeIndexes()
        vproviderA.select( allAttrsA )
        vproviderB = 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, "Union. Invalid CRS. Results might be unexpected")
        else:
            if not crsA != crsB:
                SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Union. Non-matching CRSs. Results might be unexpected")
        fields = ftools_utils.combineVectorFields(vlayerA, vlayerB )
        longNames = ftools_utils.checkFieldNameLength( fields )
        if not longNames.isEmpty():
            raise GeoAlgorithmExecutionException("Following field names are longer than 10 characters:\n" +  longNames.join('\n') )
        writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(fields, vproviderA.geometryType(), vproviderA.crs() )
        inFeatA = QgsFeature()
        inFeatB = QgsFeature()
        outFeat = QgsFeature()
        indexA = ftools_utils.createIndex( vproviderB )
        indexB = ftools_utils.createIndex( vproviderA )
        nFeat = vproviderA.featureCount() * vproviderB.featureCount()
        vproviderA.rewind()
        count = 0
        nElement = 0

        while vproviderA.nextFeature( inFeatA ):
          progress.setPercentage(int(nElement/nFeat * 100))
          nElement += 1
          found = False
          geom = QgsGeometry( inFeatA.geometry() )
          diff_geom = QgsGeometry( geom )
          atMapA = inFeatA.attributeMap()
          intersects = indexA.intersects( geom.boundingBox() )
          if len( intersects ) < 1:
            try:
              outFeat.setGeometry( geom )
              outFeat.setAttributeMap( atMapA )
              writer.addFeature( outFeat )
            except:
              # this really shouldn't happen, as we
              # haven't edited the input geom at all
              FEATURE_EXCEPT = False
          else:
            for id in intersects:
              count += 1
              vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
              atMapB = inFeatB.attributeMap()
              tmpGeom = QgsGeometry( inFeatB.geometry() )
              try:
                if geom.intersects( tmpGeom ):
                  found = True
                  int_geom = geom.intersection( tmpGeom )

                  if int_geom is None:
                    # There was a problem creating the intersection
                    GEOS_EXCEPT = False
                    int_geom = QgsGeometry()
                  else:
                    int_geom = QgsGeometry(int_geom)

                  if diff_geom.intersects( tmpGeom ):
                    diff_geom = diff_geom.difference( tmpGeom )
                    if diff_geom is None:
                      # It's possible there was an error here?
                      diff_geom = QgsGeometry()
                    else:
                      diff_geom = QgsGeometry(diff_geom)

                  if int_geom.wkbType() == 0:
                    # intersection produced different geomety types
                    temp_list = int_geom.asGeometryCollection()
                    for i in temp_list:
                      if i.type() == geom.type():
                          int_geom = QgsGeometry( i )
                  try:
                    outFeat.setGeometry( int_geom )
                    outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) )
                    writer.addFeature( outFeat )
                  except Exception, err:
                    FEATURE_EXCEPT = False
                else:
                  # this only happends if the bounding box
                  # intersects, but the geometry doesn't
                  try:
                    outFeat.setGeometry( geom )
                    outFeat.setAttributeMap( atMapA )
                    writer.addFeature( outFeat )
                  except:
                    # also shoudn't ever happen
                    FEATURE_EXCEPT = False
              except Exception, err:
                GEOS_EXCEPT = False
                found = False
예제 #3
0
    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 = vlayerA.dataProvider()
        allAttrsA = vproviderA.attributeIndexes()
        vproviderA.select( allAttrsA )
        vproviderB = 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 = vlayerA.selectedFeatures()
          # we have selection in overlay layer
          if useSelection2:
            selectionB = 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 = 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")
예제 #4
0
    def processAlgorithm(self, progress):
        useSelection = SextanteConfig.getSetting(SextanteConfig.USE_SELECTED)
        vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Intersection.INPUT))
        vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Intersection.INPUT2))
        GEOS_EXCEPT = True
        FEATURE_EXCEPT = True
        vproviderA = vlayerA.dataProvider()
        allAttrsA = vproviderA.attributeIndexes()
        vproviderA.select( allAttrsA )
        vproviderB = 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 = ftools_utils.combineVectorFields(vlayerA, vlayerB)
        longNames = ftools_utils.checkFieldNameLength( fields )
        if not longNames.isEmpty():
            raise GeoAlgorithmExecutionException("Following field names are longer than 10 characters:\n" +  longNames.join('\n') )
        writer = self.getOutputFromName(Intersection.OUTPUT).getVectorWriter(fields, vproviderA.geometryType(), vproviderA.crs() )
        inFeatA = QgsFeature()
        inFeatB = QgsFeature()
        outFeat = QgsFeature()
        index = ftools_utils.createIndex( vproviderB )
        nElement = 0
        # there is selection in input layer
        if useSelection:
            nFeat = vlayerA.selectedFeatureCount()
            selectionA = vlayerA.selectedFeatures()
            selectionB = vlayerB.selectedFeaturesIds()
            for inFeatA in selectionA:
              nElement += 1
              progress.setPercentage(int(nElement/nFeat * 100))
              geom = QgsGeometry( inFeatA.geometry() )
              atMapA = inFeatA.attributeMap()
              intersects = index.intersects( geom.boundingBox() )
              for id in intersects:
                if id in selectionB:
                  vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
                  tmpGeom = QgsGeometry( inFeatB.geometry() )
                  try:
                    if geom.intersects( tmpGeom ):
                      atMapB = inFeatB.attributeMap()
                      int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
                      if int_geom.wkbType() == 7:
                        int_com = geom.combine( tmpGeom )
                        int_sym = geom.symDifference( tmpGeom )
                        int_geom = QgsGeometry( int_com.difference( int_sym ) )
                      try:
                        outFeat.setGeometry( int_geom )
                        outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) )
                        writer.addFeature( outFeat )
                      except:
                        FEATURE_EXCEPT = False
                        continue
                  except:
                    GEOS_EXCEPT = False
                    break

        else:
            nFeat = vproviderA.featureCount()
            vproviderA.rewind()
            while vproviderA.nextFeature( inFeatA ):
              nElement += 1
              progress.setPercentage(int(nElement/nFeat * 100))
              geom = QgsGeometry( inFeatA.geometry() )
              atMapA = inFeatA.attributeMap()
              intersects = index.intersects( geom.boundingBox() )
              for id in intersects:
                vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB )
                tmpGeom = QgsGeometry( inFeatB.geometry() )
                try:
                  if geom.intersects( tmpGeom ):
                    atMapB = inFeatB.attributeMap()
                    int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
                    if int_geom.wkbType() == 7:
                      int_com = geom.combine( tmpGeom )
                      int_sym = geom.symDifference( tmpGeom )
                      int_geom = QgsGeometry( int_com.difference( int_sym ) )
                    try:
                      outFeat.setGeometry( int_geom )
                      outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) )
                      writer.addFeature( outFeat )
                    except:
                      FEATURE_EXCEPT = False
                      continue
                except:
                  GEOS_EXCEPT = False
                  break

        del writer
        if not GEOS_EXCEPT:
            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Geometry exception while computing intersection")
        if not FEATURE_EXCEPT:
            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Feature exception while computing intersection")
예제 #5
0
    def processAlgorithm(self, progress):
        vlayerA = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.INPUT))
        vlayerB = QGisLayers.getObjectFromUri(self.getParameterValue(Difference.INPUT2))
        GEOS_EXCEPT = True
        FEATURE_EXCEPT = True
        vproviderA = vlayerA.dataProvider()
        allAttrsA = vproviderA.attributeIndexes()
        vproviderA.select(allAttrsA)
        vproviderB = vlayerB.dataProvider()
        allAttrsB = vproviderB.attributeIndexes()
        vproviderB.select(allAttrsB)
        fields = vproviderA.fields()
        # check for crs compatibility
        crsA = vproviderA.crs()
        crsB = vproviderB.crs()
        if not crsA.isValid() or not crsB.isValid():
            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Difference. Invalid CRS. Results might be unexpected")
        else:
            if crsA != crsB:
                SextanteLog.addToLog(
                    SextanteLog.LOG_WARNING, "Difference. Non-matching CRSs. Results might be unexpected"
                )
        writer = self.getOutputFromName(Difference.OUTPUT).getVectorWriter(
            fields, vproviderA.geometryType(), vproviderA.crs()
        )
        inFeatA = QgsFeature()
        inFeatB = QgsFeature()
        outFeat = QgsFeature()
        index = ftools_utils.createIndex(QGisLayers.features(vlayerB))
        nElement = 0
        selectionA = QGisLayers.features(vlayerA)
        nFeat = len(selectionA)
        for inFeatA in selectionA:
            nElement += 1
            progress.setPercentage(nElement / float(nFeat) * 100)
            add = True
            geom = QgsGeometry(inFeatA.geometry())
            diff_geom = QgsGeometry(geom)
            atMap = inFeatA.attributeMap()
            intersects = index.intersects(geom.boundingBox())
            for id in intersects:
                vproviderB.featureAtId(int(id), inFeatB, True, allAttrsB)
                tmpGeom = QgsGeometry(inFeatB.geometry())
                try:
                    if diff_geom.intersects(tmpGeom):
                        diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
                except:
                    GEOS_EXCEPT = False
                    add = False
                    break
            if add:
                try:
                    outFeat.setGeometry(diff_geom)
                    outFeat.setAttributeMap(atMap)
                    writer.addFeature(outFeat)
                except:
                    FEATURE_EXCEPT = False
                    continue

        del writer
        if not GEOS_EXCEPT:
            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Geometry exception while computing difference")
        if not FEATURE_EXCEPT:
            SextanteLog.addToLog(SextanteLog.LOG_WARNING, "Feature exception while computing difference")