예제 #1
0
   def filletPolyline(self):         
      layer = self.entity1.layer

      transformedRadius = qad_utils.distMapToLayerCoordinates(self.radius, self.plugIn.canvas, layer)
      tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                  self.plugin.canvas, \
                                                                  layer)                              
      f = self.entity1.getFeature()
      geom = f.geometry() 

      self.linearObjectList1.fillet(transformedRadius)
               
      updSubGeom = QgsGeometry.fromPolyline(self.linearObjectList1.asPolyline(tolerance2ApproxCurve))
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
      if updGeom is None:
         return False
      f.setGeometry(updGeom)
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
    def filletPolyline(self):
        layer = self.entity1.layer

        tolerance2ApproxCurve = QadVariables.get(
            QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
        f = self.entity1.getFeature()
        # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
        geom = self.layerToMapCoordinates(layer, f.getGeometry())

        self.linearObjectList1.fillet(self.radius)

        updSubGeom = QgsGeometry.fromPolyline(
            self.linearObjectList1.asPolyline(tolerance2ApproxCurve))
        updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
        if updGeom is None:
            return False
        # trasformo la geometria nel crs del layer
        f.setGeometry(self.mapToLayerCoordinates(layer, updGeom))

        self.plugIn.beginEditCommand("Feature edited", layer)

        # plugIn, layer, feature, refresh, check_validity
        if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False,
                                          False) == False:
            self.plugIn.destroyEditCommand()
            return False

        self.plugIn.endEditCommand()
        self.nOperationsToUndo = self.nOperationsToUndo + 1

        return True
예제 #3
0
   def filletPolyline(self):         
      layer = self.entity1.layer

      tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
      f = self.entity1.getFeature()
      # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
      geom = self.layerToMapCoordinates(layer, f.getGeometry())

      self.linearObjectList1.fillet(self.radius)
               
      updSubGeom = QgsGeometry.fromPolyline(self.linearObjectList1.asPolyline(tolerance2ApproxCurve))
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
      if updGeom is None:
         return False
      # trasformo la geometria nel crs del layer
      f.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
예제 #4
0
def stretchQgsGeometry(geom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve):
   """
   Stira una geometria
   geom = geometria da tirare
   containerGeom = può essere una QgsGeometry rappresentante un poligono contenente i punti di geom da stirare
                   oppure una lista dei punti di geom da stirare
   offSetX = spostamento X
   offSetY = spostamento Y
   tolerance2ApproxCurve = tolleranza per rigenerare le curve
   """
   wkbType = geom.wkbType()
   if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
      pt = stretchPoint(geom.asPoint(), containerGeom, offSetX, offSetY)
      if pt is not None:
         return QgsGeometry.fromPoint(pt)
            
   if wkbType == QGis.WKBMultiPoint:
      stretchedGeom = QgsGeometry(geom)
      points = stretchedGeom.asMultiPoint() # vettore di punti
      atSubGeom = 0
      for pt in points:
         subGeom = QgsGeometry.fromPoint(pt)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])
         atSubGeom = atSubGeom + 1
      return stretchedGeom

   if wkbType == QGis.WKBLineString:
      return stretchQgsLineStringGeometry(geom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve)
   
   if wkbType == QGis.WKBMultiLineString:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asMultiPolyline() # lista di linee
      atSubGeom = 0
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
         
   if wkbType == QGis.WKBPolygon:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asPolygon() # lista di linee
      atSubGeom = 0
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
      
   if wkbType == QGis.WKBMultiPolygon:
      stretchedGeom = QgsGeometry(geom)
      polygons = geom.asMultiPolygon() # vettore di poligoni
      atSubGeom = 0
      for polygon in polygons:
         subGeom = QgsGeometry.fromPolygon(polygon)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
   
   return None
예제 #5
0
def gripStretchQgsGeometry(geom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve):
   """
   Stira una geometria in coordinate piane mediante grip point
   geom = geometria da stirare
   ptListToStretch = lista dei punti di geom da stirare
   offSetX = spostamento X
   offSetY = spostamento Y
   tolerance2ApproxCurve = tolleranza per rigenerare le curve
   """
   wkbType = geom.wkbType()
   if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
      pt = stretchPoint(geom.asPoint(), ptListToStretch, offSetX, offSetY)
      if pt is not None:
         return QgsGeometry.fromPoint(pt)
            
   if wkbType == QGis.WKBMultiPoint:
      stretchedGeom = QgsGeometry(geom)
      points = stretchedGeom.asMultiPoint() # vettore di punti
      atSubGeom = 0
      for pt in points:
         subGeom = QgsGeometry.fromPoint(pt)
         stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom

   if wkbType == QGis.WKBLineString:
      return gripStretchQgsLineStringGeometry(geom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve)
   
   if wkbType == QGis.WKBMultiLineString:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asMultiPolyline() # lista di linee
      atSubGeom = 0
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
         
   if wkbType == QGis.WKBPolygon:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asPolygon() # lista di linee
      atSubGeom = 0
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
      
   if wkbType == QGis.WKBMultiPolygon:
      stretchedGeom = QgsGeometry(geom)
      polygons = geom.asMultiPolygon() # vettore di poligoni
      atSubGeom = 0
      for polygon in polygons:
         subGeom = QgsGeometry.fromPolygon(polygon)
         stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
   
   return None
예제 #6
0
   def trimFeatures(self, geom, toExtend):
      # geom è in map coordinates
      tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
      LineTempLayer = None
      self.plugIn.beginEditCommand("Feature extended" if toExtend else "Feature trimmed", \
                                   self.entitySet.getLayerList())
      
      for layerEntitySet in self.entitySet.layerEntitySetList:
         layer = layerEntitySet.layer

         for featureId in layerEntitySet.featureIds:
            f = qad_utils.getFeatureById(layer, featureId)
            if f is None:
               continue
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            f_geom = self.layerToMapCoordinates(layer, f.geometry())
            
            if geom.type() == QGis.Point:
               # ritorna una tupla (<The squared cartesian distance>,
               #                    <minDistPoint>
               #                    <afterVertex>
               #                    <leftOf>)
               dummy = qad_utils.closestSegmentWithContext(geom.asPoint(), f_geom)
               if dummy[1] is not None:
                  intPts = [dummy[1]]
            else:
               intPts = qad_utils.getIntersectionPoints(geom, f_geom)
               
            for intPt in intPts:               
               if toExtend:
                  newGeom = qad_utils.extendQgsGeometry(self.plugIn.canvas.mapRenderer().destinationCrs(), f_geom, intPt, \
                                                        self.limitEntitySet, self.edgeMode, \
                                                        tolerance2ApproxCurve)
                  if newGeom is not None:
                     # aggiorno la feature con la geometria estesa
                     extendedFeature = QgsFeature(f)
                     # trasformo la geometria nel crs del layer
                     extendedFeature.setGeometry(self.mapToLayerCoordinates(layer, newGeom))
                     # plugIn, layer, feature, refresh, check_validity
                     if qad_layer.updateFeatureToLayer(self.plugIn, layer, extendedFeature, False, False) == False:
                        self.plugIn.destroyEditCommand()
                        return
               else: # trim
                  result = qad_utils.trimQgsGeometry(self.plugIn.canvas.mapRenderer().destinationCrs(), f_geom, intPt, \
                                                     self.limitEntitySet, self.edgeMode, \
                                                     tolerance2ApproxCurve)                  
                  if result is not None:
                     line1 = result[0]
                     line2 = result[1]
                     atSubGeom = result[2]
                     if layer.geometryType() == QGis.Line:
                        updGeom = qad_utils.setSubGeom(f_geom, line1, atSubGeom)
                        if updGeom is None:
                           self.plugIn.destroyEditCommand()
                           return
                        trimmedFeature1 = QgsFeature(f)
                        # trasformo la geometria nel crs del layer
                        trimmedFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
                        # plugIn, layer, feature, refresh, check_validity
                        if qad_layer.updateFeatureToLayer(self.plugIn, layer, trimmedFeature1, False, False) == False:
                           self.plugIn.destroyEditCommand()
                           return
                        if line2 is not None:
                           trimmedFeature2 = QgsFeature(f)      
                           # trasformo la geometria nel crs del layer
                           trimmedFeature2.setGeometry(self.mapToLayerCoordinates(layer, line2))
                           # plugIn, layer, feature, coordTransform, refresh, check_validity
                           if qad_layer.addFeatureToLayer(self.plugIn, layer, trimmedFeature2, None, False, False) == False:
                              self.plugIn.destroyEditCommand()
                              return                        
                     else:
                        # aggiungo le linee nei layer temporanei di QAD
                        if LineTempLayer is None:
                           LineTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Line)
                           self.plugIn.addLayerToLastEditCommand("Feature trimmed", LineTempLayer)
                        
                        lineGeoms = [line1]
                        if line2 is not None:
                           lineGeoms.append(line2)

                        # trasformo la geometria in quella dei layer temporanei
                        # plugIn, pointGeoms, lineGeoms, polygonGeoms, coord, refresh
                        if qad_layer.addGeometriesToQADTempLayers(self.plugIn, None, lineGeoms, None, None, False) == False:
                           self.plugIn.destroyEditCommand()
                           return
                                                      
                        updGeom = qad_utils.delSubGeom(f_geom, atSubGeom)
                        
                        if updGeom is None or updGeom.isGeosEmpty(): # da cancellare
                           # plugIn, layer, feature id, refresh
                           if qad_layer.deleteFeatureToLayer(self.plugIn, layer, f.id(), False) == False:
                              self.plugIn.destroyEditCommand()
                              return
                        else:
                           trimmedFeature1 = QgsFeature(f)
                           # trasformo la geometria nel crs del layer
                           trimmedFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
                           # plugIn, layer, feature, refresh, check_validity
                           if qad_layer.updateFeatureToLayer(self.plugIn, layer, trimmedFeature1, False, False) == False:
                              self.plugIn.destroyEditCommand()
                              return

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
예제 #7
0
   def lengthen(self, point):
      layer = self.entity.layer
      f = self.entity.getFeature()
      if f is None: # non c'è più la feature
         return False
      # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
      geom = self.layerToMapCoordinates(layer, self.entity.getGeometry())
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      res = False
      newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         
      if self.move_startPt:
         linearObject = newLinearObjectList.getLinearObjectAt(0)
      else:
         linearObject = newLinearObjectList.getLinearObjectAt(-1)
         
      if linearObject.isSegment():
         newPt = qad_utils.getPerpendicularPointOnInfinityLine(linearObject.getStartPt(), linearObject.getEndPt(), point)
      else: # arco
         newPt = qad_utils.getPolarPointByPtAngle(linearObject.getArc().center, \
                                                  qad_utils.getAngleBy2Pts(linearObject.getArc().center, point), \
                                                  linearObject.getArc().radius)                  

      if newLinearObjectList.qty() > 1 and linearObject.isSegment():
         ang = linearObject.getTanDirectionOnStartPt()

      if self.move_startPt:
         linearObject.setStartPt(newPt)
      else:
         linearObject.setEndPt(newPt)
         
      if newLinearObjectList.qty() > 1 and linearObject.isSegment() and \
         qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False:
         res = False
      else:
         res = True

      if res == False: # allungamento impossibile
         return False
               
      pts = newLinearObjectList.asPolyline() 
      updSubGeom = QgsGeometry.fromPolyline(pts)
               
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom)
      if updGeom is None:
         return False
      # trasformo la geometria nel crs del layer
      f.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      if self.copyEntities == False:
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      else:
         # plugIn, layer, features, coordTransform, refresh, check_validity
         if qad_layer.addFeatureToLayer(self.plugIn, layer, f, None, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      
      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
예제 #8
0
   def lengthen(self, point):
      layer = self.entity.layer
      f = self.entity.getFeature()
      if f is None: # non c'è più la feature
         return False
      geom = self.entity.getGeometry()
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      res = False
      if self.OpMode == "DElta":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         if self.OpType == "length":
            res = newLinearObjectList.lengthen_delta(self.move_startPt, self.value)
         elif self.OpType == "Angle":
            res = newLinearObjectList.lengthen_deltaAngle(self.move_startPt, self.value)
      elif self.OpMode == "Percent":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         value = newLinearObjectList.length() * self.value / 100
         value = value - newLinearObjectList.length()
         res = newLinearObjectList.lengthen_delta(self.move_startPt, value)
      elif self.OpMode == "Total":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         if self.OpType == "length":
            value = self.value - newLinearObjectList.length()
            res = newLinearObjectList.lengthen_delta(self.move_startPt, value)
         elif self.OpType == "Angle":                     
            if newLinearObjectList.qty() == 1:
               linearObject = newLinearObjectList.getLinearObjectAt(0)
               if linearObject.isArc() == True: # se è un arco
                  value = self.value - linearObject.getArc().totalAngle()
                  res = newLinearObjectList.lengthen_deltaAngle(self.move_startPt, value)
      elif self.OpMode == "DYnamic":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         transformedPt = self.mapToLayerCoordinates(layer, point)
            
         if self.move_startPt:
            linearObject = newLinearObjectList.getLinearObjectAt(0)
         else:
            linearObject = newLinearObjectList.getLinearObjectAt(-1)
            
         if linearObject.isSegment():
            newPt = qad_utils.getPerpendicularPointOnInfinityLine(linearObject.getStartPt(), linearObject.getEndPt(), transformedPt)
         else: # arco
            newPt = qad_utils.getPolarPointByPtAngle(linearObject.getArc().center, \
                                                     qad_utils.getAngleBy2Pts(linearObject.getArc().center, transformedPt), \
                                                     linearObject.getArc().radius)                  

         if newLinearObjectList.qty() > 1 and linearObject.isSegment():
            ang = linearObject.getTanDirectionOnStartPt()

         if self.move_startPt:
            linearObject.setStartPt(newPt)
         else:
            linearObject.setEndPt(newPt)
            
         if newLinearObjectList.qty() > 1 and linearObject.isSegment() and \
            qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False:
            res = False
         else:
            res = True

      if res == False: # allungamento impossibile
         return False
               
      pts = newLinearObjectList.asPolyline() 
      updSubGeom = QgsGeometry.fromPolyline(pts)
               
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom)
      if updGeom is None:
         return False
      f.setGeometry(updGeom)
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
    def fillet(self):
        tolerance2ApproxCurve = QadVariables.get(
            QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))

        # stessa entità e stessa parte
        if self.entity1.layer.id() == self.entity2.layer.id() and \
           self.entity1.featureId == self.entity2.featureId and \
           self.partAt1 == self.partAt2:
            return False

        # uso il crs del canvas per lavorare con coordinate piane xy
        epsg = self.plugIn.canvas.mapSettings().destinationCrs().authid()
        res = qad_utils.getFilletLinearObjectList(self.linearObjectList1, self.partAt1, self.pointAt1, \
                                                  self.linearObjectList2, self.partAt2, self.pointAt2,\
                                                  self.filletMode, self.radius, epsg)
        if res is None:  # raccordo non possibile
            msg = QadMsg.translate("Command_FILLET",
                                   "\nFillet with radius <{0}> impossible.")
            #showMsg
            self.showMsg(msg.format(str(self.radius)))
            return False

        filletLinearObjectList = res[0]
        whatToDoPoly1 = res[1]
        whatToDoPoly2 = res[2]

        self.plugIn.beginEditCommand("Feature edited",
                                     [self.entity1.layer, self.entity2.layer])

        if whatToDoPoly1 == 1:  # 1=modificare
            f = self.entity1.getFeature()
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.entity1.layer, f.geometry())
            updSubGeom = QgsGeometry.fromPolyline(
                filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
            updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
            if updGeom is None:
                self.plugIn.destroyEditCommand()
                return False
            # trasformo la geometria nel crs del layer
            f.setGeometry(
                self.mapToLayerCoordinates(self.entity1.layer, updGeom))

            # plugIn, layer, feature, refresh, check_validity
            if qad_layer.updateFeatureToLayer(self.plugIn, self.entity1.layer,
                                              f, False, False) == False:
                self.plugIn.destroyEditCommand()
                return False
        elif whatToDoPoly1 == 2:  # 2=cancellare
            # se non si tratta della stessa entità
            if self.entity1 != self.entity2:
                # plugIn, layer, featureId, refresh
                if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity1.layer, \
                                                  self.entity1.featureId, False) == False:
                    self.plugIn.destroyEditCommand()
                    return False

        if whatToDoPoly2 == 1:  # 1=modificare
            tolerance2ApproxCurve = QadVariables.get(
                QadMsg.translate("Environment variables",
                                 "TOLERANCE2APPROXCURVE"))

            f = self.entity2.getFeature()
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.entity2.layer, f.geometry())
            updSubGeom = QgsGeometry.fromPolyline(
                filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
            updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom2)
            if updGeom is None:
                self.plugIn.destroyEditCommand()
                return False
            # trasformo la geometria nel crs del layer
            f.setGeometry(
                self.mapToLayerCoordinates(self.entity2.layer, updGeom))

            # plugIn, layer, feature, refresh, check_validity
            if qad_layer.updateFeatureToLayer(self.plugIn, self.entity2.layer,
                                              f, False, False) == False:
                self.plugIn.destroyEditCommand()
                return False
        elif whatToDoPoly2 == 2:  # 2=cancellare
            # se non si tratta della stessa entità
            if self.entity1 != self.entity2:
                # plugIn, layer, featureId, refresh
                if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity2.layer, \
                                                  self.entity2.featureId, False) == False:
                    self.plugIn.destroyEditCommand()
                    return False

        if whatToDoPoly1 == 0 and whatToDoPoly2 == 0:  # 0=niente
            geom = QgsGeometry.fromPolyline(
                filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
            # trasformo la geometria nel crs del layer
            geom = self.mapToLayerCoordinates(self.entity1.layer, geom)

            # plugIn, layer, geom, coordTransform, refresh, check_validity
            if qad_layer.addGeomToLayer(self.plugIn, self.entity1.layer, geom,
                                        None, False, False) == False:
                self.plugIn.destroyEditCommand()
                return False

        self.plugIn.endEditCommand()
        self.nOperationsToUndo = self.nOperationsToUndo + 1

        return True
예제 #10
0
   def fillet(self):
      tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")) 
      
      # stessa entità e stessa parte
      if self.entity1.layer.id() == self.entity2.layer.id() and \
         self.entity1.featureId == self.entity2.featureId and \
         self.partAt1 == self.partAt2:
         return False
   
      # uso il crs del canvas per lavorare con coordinate piane xy
      epsg = self.plugIn.canvas.mapRenderer().destinationCrs().authid()
      res = qad_utils.getFilletLinearObjectList(self.linearObjectList1, self.partAt1, self.pointAt1, \
                                                self.linearObjectList2, self.partAt2, self.pointAt2,\
                                                self.filletMode, self.radius, epsg)
      if res is None: # raccordo non possibile
         msg = QadMsg.translate("Command_FILLET", "\nFillet with radius <{0}> impossible.")
         #showMsg
         self.showMsg(msg.format(str(self.radius)))
         return False
      
      filletLinearObjectList = res[0]
      whatToDoPoly1 = res[1]
      whatToDoPoly2 = res[2]

      self.plugIn.beginEditCommand("Feature edited", [self.entity1.layer, self.entity2.layer])

      if whatToDoPoly1 == 1: # 1=modificare       
         f = self.entity1.getFeature()
         # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
         geom = self.layerToMapCoordinates(self.entity1.layer, f.geometry())
         updSubGeom = QgsGeometry.fromPolyline(filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
         updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
         if updGeom is None:
            self.plugIn.destroyEditCommand()
            return False
         # trasformo la geometria nel crs del layer
         f.setGeometry(self.mapToLayerCoordinates(self.entity1.layer, updGeom))
         
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, self.entity1.layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      elif whatToDoPoly1 == 2: # 2=cancellare
         # se non si tratta della stessa entità
         if self.entity1 != self.entity2:
            # plugIn, layer, featureId, refresh
            if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity1.layer, \
                                              self.entity1.featureId, False) == False:
               self.plugIn.destroyEditCommand()
               return False

      if whatToDoPoly2 == 1: # 1=modificare
         tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))

         f = self.entity2.getFeature()
         # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
         geom = self.layerToMapCoordinates(self.entity2.layer, f.geometry())
         updSubGeom = QgsGeometry.fromPolyline(filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
         updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom2)
         if updGeom is None:
            self.plugIn.destroyEditCommand()
            return False
         # trasformo la geometria nel crs del layer
         f.setGeometry(self.mapToLayerCoordinates(self.entity2.layer, updGeom))
         
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, self.entity2.layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      elif whatToDoPoly2 == 2: # 2=cancellare 
         # se non si tratta della stessa entità
         if self.entity1 != self.entity2:
            # plugIn, layer, featureId, refresh
            if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity2.layer, \
                                              self.entity2.featureId, False) == False:
               self.plugIn.destroyEditCommand()
               return False

      if whatToDoPoly1 == 0 and whatToDoPoly2 == 0: # 0=niente      
         geom = QgsGeometry.fromPolyline(filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
         # trasformo la geometria nel crs del layer
         geom = self.mapToLayerCoordinates(self.entity1.layer, geom)

         # plugIn, layer, geom, coordTransform, refresh, check_validity
         if qad_layer.addGeomToLayer(self.plugIn, self.entity1.layer, geom, None, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1

      return True
예제 #11
0
   def fillet(self):
      transformedRadius = qad_utils.distMapToLayerCoordinates(self.radius, self.plugIn.canvas, self.entity1.layer)
      tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                  self.plugIn.canvas,\
                                                                  self.entity1.layer)                              
      
      if self.entity1.layer.crs() != self.entity2.layer.crs():
         coordTransform = QgsCoordinateTransform(self.entity1.layer.crs(),\
                                                 self.entity2.layer.crs()) # trasformo la geometria
         transformedLinearObjectList2 = self.linearObjectList2.transform(coordTransform)
         transformedPointAt2 = coordTransform.transform(self.pointAt2)         
      else:
         # stessa entità e stessa parte
         if self.entity1.layer.id() == self.entity2.layer.id() and \
            self.entity1.featureId == self.entity2.featureId and \
            self.partAt1 == self.partAt2:
            return False
         
         transformedLinearObjectList2 = qad_utils.QadLinearObjectList(self.linearObjectList2)
         transformedPointAt2 = self.pointAt2
   
      epsg = self.entity1.layer.crs().authid()      
      res = qad_utils.getFilletLinearObjectList(self.linearObjectList1, self.partAt1, self.pointAt1, \
                                                transformedLinearObjectList2, self.partAt2, transformedPointAt2,\
                                                self.filletMode, transformedRadius, epsg)      
      if res is None: # raccordo non possibile
         msg = QadMsg.translate("Command_FILLET", "\nFillet with radius <{0}> impossible.")
         #showMsg
         self.showMsg(msg.format(str(self.radius)))
         return False
      
      filletLinearObjectList = res[0]
      whatToDoPoly1 = res[1]
      whatToDoPoly2 = res[2]

      self.plugIn.beginEditCommand("Feature edited", [self.entity1.layer, self.entity2.layer])

      if whatToDoPoly1 == 1: # 1=modificare       
         f = self.entity1.getFeature()
         geom = f.geometry() 
         updSubGeom = QgsGeometry.fromPolyline(filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
         updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom1)
         if updGeom is None:
            self.plugIn.destroyEditCommand()
            return False
         f.setGeometry(updGeom)
         
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, self.entity1.layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      elif whatToDoPoly1 == 2: # 2=cancellare 
         # plugIn, layer, featureId, refresh
         if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity1.layer, \
                                           self.entity1.featureId, False) == False:
            self.plugIn.destroyEditCommand()
            return False

      if whatToDoPoly2 == 1: # 1=modificare
         
         if self.entity1.layer.crs() != self.entity2.layer.crs():
            coordTransform = QgsCoordinateTransform(self.entity2.layer.crs(),\
                                                    self.entity1.layer.crs()) # trasformo la geometria
            transformedLinearObjectList2 = self.filletLinearObjectList.transform(coordTransform)
         else:
            transformedLinearObjectList2 = filletLinearObjectList
         
         tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                     self.plugIn.canvas,\
                                                                     self.entity2.layer)                              

         f = self.entity2.getFeature()
         geom = f.geometry() 
         updSubGeom = QgsGeometry.fromPolyline(transformedLinearObjectList2.asPolyline(tolerance2ApproxCurve))
         updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom2)
         if updGeom is None:
            self.plugIn.destroyEditCommand()
            return False
         f.setGeometry(updGeom)
         
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, self.entity2.layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      elif whatToDoPoly2 == 2: # 2=cancellare 
         # plugIn, layer, featureId, refresh
         if qad_layer.deleteFeatureToLayer(self.plugIn, self.entity2.layer, \
                                           self.entity2.featureId, False) == False:
            self.plugIn.destroyEditCommand()
            return False

      if whatToDoPoly1 == 0 and whatToDoPoly2 == 0: # 0=niente      
         geom = QgsGeometry.fromPolyline(filletLinearObjectList.asPolyline(tolerance2ApproxCurve))
         # plugIn, layer, geom, coordTransform, refresh, check_validity
         if qad_layer.addGeomToLayer(self.plugIn, self.entity1.layer, geom, None, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1

      return True
예제 #12
0
   def lengthen(self, point):
      layer = self.entity.layer
      f = self.entity.getFeature()
      if f is None: # non c'è più la feature
         return False
      # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
      geom = self.layerToMapCoordinates(layer, self.entity.getGeometry())
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      res = False
      newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         
      if self.move_startPt:
         linearObject = newLinearObjectList.getLinearObjectAt(0)
      else:
         linearObject = newLinearObjectList.getLinearObjectAt(-1)
         
      if linearObject.isSegment():
         newPt = qad_utils.getPerpendicularPointOnInfinityLine(linearObject.getStartPt(), linearObject.getEndPt(), point)
      else: # arco
         newPt = qad_utils.getPolarPointByPtAngle(linearObject.getArc().center, \
                                                  qad_utils.getAngleBy2Pts(linearObject.getArc().center, point), \
                                                  linearObject.getArc().radius)                  

      if newLinearObjectList.qty() > 1 and linearObject.isSegment():
         ang = linearObject.getTanDirectionOnStartPt()

      if self.move_startPt:
         linearObject.setStartPt(newPt)
      else:
         linearObject.setEndPt(newPt)
         
      if newLinearObjectList.qty() > 1 and linearObject.isSegment() and \
         qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False:
         res = False
      else:
         res = True

      if res == False: # allungamento impossibile
         return False
               
      pts = newLinearObjectList.asPolyline() 
      updSubGeom = QgsGeometry.fromPolyline(pts)
               
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom)
      if updGeom is None:
         return False
      # trasformo la geometria nel crs del layer
      f.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      if self.copyEntities == False:
         # plugIn, layer, feature, refresh, check_validity
         if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      else:
         # plugIn, layer, features, coordTransform, refresh, check_validity
         if qad_layer.addFeatureToLayer(self.plugIn, layer, f, None, False, False) == False:
            self.plugIn.destroyEditCommand()
            return False
      
      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
예제 #13
0
   def lengthen(self, point):
      layer = self.entity.layer
      f = self.entity.getFeature()
      if f is None: # non c'è più la feature
         return False
      geom = self.entity.getGeometry()
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      res = False
      if self.OpMode == "DElta":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         if self.OpType == "length":
            res = newLinearObjectList.lengthen_delta(self.move_startPt, self.value)
         elif self.OpType == "Angle":
            res = newLinearObjectList.lengthen_deltaAngle(self.move_startPt, self.value)
      elif self.OpMode == "Percent":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         value = newLinearObjectList.length() * self.value / 100
         value = value - newLinearObjectList.length()
         res = newLinearObjectList.lengthen_delta(self.move_startPt, value)
      elif self.OpMode == "Total":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         if self.OpType == "length":
            value = self.value - newLinearObjectList.length()
            res = newLinearObjectList.lengthen_delta(self.move_startPt, value)
         elif self.OpType == "Angle":                     
            if newLinearObjectList.qty() == 1:
               linearObject = newLinearObjectList.getLinearObjectAt(0)
               if linearObject.isArc() == True: # se è un arco
                  value = self.value - linearObject.getArc().totalAngle()
                  res = newLinearObjectList.lengthen_deltaAngle(self.move_startPt, value)
      elif self.OpMode == "DYnamic":
         newLinearObjectList = qad_utils.QadLinearObjectList(self.linearObjectList)
         transformedPt = self.mapToLayerCoordinates(layer, point)
            
         if self.move_startPt:
            linearObject = newLinearObjectList.getLinearObjectAt(0)
         else:
            linearObject = newLinearObjectList.getLinearObjectAt(-1)
            
         if linearObject.isSegment():
            newPt = qad_utils.getPerpendicularPointOnInfinityLine(linearObject.getStartPt(), linearObject.getEndPt(), transformedPt)
         else: # arco
            newPt = qad_utils.getPolarPointByPtAngle(linearObject.getArc().center, \
                                                     qad_utils.getAngleBy2Pts(linearObject.getArc().center, transformedPt), \
                                                     linearObject.getArc().radius)                  

         if newLinearObjectList.qty() > 1 and linearObject.isSegment():
            ang = linearObject.getTanDirectionOnStartPt()

         if self.move_startPt:
            linearObject.setStartPt(newPt)
         else:
            linearObject.setEndPt(newPt)
            
         if newLinearObjectList.qty() > 1 and linearObject.isSegment() and \
            qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False:
            res = False
         else:
            res = True

      if res == False: # allungamento impossibile
         return False
               
      pts = newLinearObjectList.asPolyline() 
      updSubGeom = QgsGeometry.fromPolyline(pts)
               
      updGeom = qad_utils.setSubGeom(geom, updSubGeom, self.atSubGeom)
      if updGeom is None:
         return False
      f.setGeometry(updGeom)
         
      self.plugIn.beginEditCommand("Feature edited", layer)
      
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1
      
      return True
예제 #14
0
def stretchQgsGeometry(geom, containerGeom, offSetX, offSetY, tolerance2ApproxCurve = None):
   """
   Stira una geometria
   geom = geometria da tirare
   containerGeom = può essere una QgsGeometry rappresentante un poligono contenente i punti di geom da stirare
                   oppure una lista dei punti di geom da stirare
   offSetX = spostamento X
   offSetY = spostamento Y
   tolerance2ApproxCurve = tolleranza per rigenerare le curve
   """   
   if tolerance2ApproxCurve == None:
      tolerance = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
   else:
      tolerance = tolerance2ApproxCurve

   wkbType = geom.wkbType()
   if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
      pt = stretchPoint(geom.asPoint(), containerGeom, offSetX, offSetY)
      if pt is not None:
         return QgsGeometry.fromPoint(pt)
            
   if wkbType == QGis.WKBMultiPoint:
      stretchedGeom = QgsGeometry(geom)
      points = stretchedGeom.asMultiPoint() # vettore di punti
      atSubGeom = 0
      for pt in points:
         subGeom = QgsGeometry.fromPoint(pt)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])
         atSubGeom = atSubGeom + 1
      return stretchedGeom

   if wkbType == QGis.WKBLineString:
      return stretchQgsLineStringGeometry(geom, containerGeom, offSetX, offSetY, tolerance)
   
   if wkbType == QGis.WKBMultiLineString:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asMultiPolyline() # lista di linee
      atSubGeom = 0
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = stretchQgsGeometry(subGeom, containerGeom, offSetX, offSetY, tolerance)
         stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [atSubGeom])    
         atSubGeom = atSubGeom + 1
      return stretchedGeom
         
   if wkbType == QGis.WKBPolygon:
      stretchedGeom = QgsGeometry(geom)
      lines = stretchedGeom.asPolygon() # lista di linee
      iRing = -1
      for line in lines:        
         subGeom = QgsGeometry.fromPolyline(line)
         stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance)
         if iRing == -1: # si tratta della parte più esterna
            stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [0])
         else:
            stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [0, iRing])
         iRing = iRing + 1
      return stretchedGeom

   if wkbType == QGis.WKBMultiPolygon:
      stretchedGeom = QgsGeometry(geom)
      polygons = geom.asMultiPolygon() # vettore di poligoni
      iPart = 0
      for polygon in polygons:
         iRing = -1
         for line in polygon:
            subGeom = QgsGeometry.fromPolyline(line)
            stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt, ptListToStretch, offSetX, offSetY, tolerance)
            if iRing == -1: # si tratta della parte più esterna
               stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [iPart])
            else:
               stretchedGeom = qad_utils.setSubGeom(stretchedGeom, stretchedSubGeom, [iPart, iRing])
            iRing = iRing + 1
         iPart = iPart + 1
      return stretchedGeom
   
   return None
예제 #15
0
def gripStretchQgsGeometry(geom, basePt, ptListToStretch, offSetX, offSetY,
                           tolerance2ApproxCurve):
    """
   Stira una geometria in coordinate piane mediante grip point
   geom = geometria da stirare
   ptListToStretch = lista dei punti di geom da stirare
   offSetX = spostamento X
   offSetY = spostamento Y
   tolerance2ApproxCurve = tolleranza per rigenerare le curve
   """
    wkbType = geom.wkbType()
    if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
        pt = stretchPoint(geom.asPoint(), ptListToStretch, offSetX, offSetY)
        if pt is not None:
            return QgsGeometry.fromPoint(pt)

    if wkbType == QGis.WKBMultiPoint:
        stretchedGeom = QgsGeometry(geom)
        points = stretchedGeom.asMultiPoint()  # vettore di punti
        atSubGeom = 0
        for pt in points:
            subGeom = QgsGeometry.fromPoint(pt)
            stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt,
                                                      ptListToStretch, offSetX,
                                                      offSetY,
                                                      tolerance2ApproxCurve)
            stretchedGeom = qad_utils.setSubGeom(stretchedGeom,
                                                 stretchedSubGeom, [atSubGeom])
            atSubGeom = atSubGeom + 1
        return stretchedGeom

    if wkbType == QGis.WKBLineString:
        return gripStretchQgsLineStringGeometry(geom, basePt, ptListToStretch,
                                                offSetX, offSetY,
                                                tolerance2ApproxCurve)

    if wkbType == QGis.WKBMultiLineString:
        stretchedGeom = QgsGeometry(geom)
        lines = stretchedGeom.asMultiPolyline()  # lista di linee
        atSubGeom = 0
        for line in lines:
            subGeom = QgsGeometry.fromPolyline(line)
            stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt,
                                                      ptListToStretch, offSetX,
                                                      offSetY,
                                                      tolerance2ApproxCurve)
            stretchedGeom = qad_utils.setSubGeom(stretchedGeom,
                                                 stretchedSubGeom, [atSubGeom])
            atSubGeom = atSubGeom + 1
        return stretchedGeom

    if wkbType == QGis.WKBPolygon:
        stretchedGeom = QgsGeometry(geom)
        lines = stretchedGeom.asPolygon()  # lista di linee
        iRing = -1
        for line in lines:
            subGeom = QgsGeometry.fromPolyline(line)
            stretchedSubGeom = gripStretchQgsGeometry(subGeom, basePt,
                                                      ptListToStretch, offSetX,
                                                      offSetY,
                                                      tolerance2ApproxCurve)
            if iRing == -1:  # si tratta della parte più esterna
                stretchedGeom = qad_utils.setSubGeom(stretchedGeom,
                                                     stretchedSubGeom, [0])
            else:
                stretchedGeom = qad_utils.setSubGeom(stretchedGeom,
                                                     stretchedSubGeom,
                                                     [0, iRing])
            iRing = iRing + 1
        return stretchedGeom

    if wkbType == QGis.WKBMultiPolygon:
        stretchedGeom = QgsGeometry(geom)
        polygons = geom.asMultiPolygon()  # vettore di poligoni
        iPart = 0
        for polygon in polygons:
            iRing = -1
            for line in polygon:
                subGeom = QgsGeometry.fromPolyline(line)
                stretchedSubGeom = gripStretchQgsGeometry(
                    subGeom, basePt, ptListToStretch, offSetX, offSetY,
                    tolerance2ApproxCurve)
                if iRing == -1:  # si tratta della parte più esterna
                    stretchedGeom = qad_utils.setSubGeom(
                        stretchedGeom, stretchedSubGeom, [iPart])
                else:
                    stretchedGeom = qad_utils.setSubGeom(
                        stretchedGeom, stretchedSubGeom, [iPart, iRing])
                iRing = iRing + 1
            iPart = iPart + 1
        return stretchedGeom

    return None