Esempio n. 1
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
    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
Esempio n. 3
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