예제 #1
0
class Qad_stretch_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.basePt = None
      self.SSGeomList = [] # lista di entità da stirare con geom di selezione
      self.__rubberBand = QadRubberBand(self.canvas)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    
   
   
   #============================================================================
   # stretch
   #============================================================================
   def stretch(self, f, containerGeom, offSetX, offSetY, tolerance2ApproxCurve, layerEntitySet, entitySet):
      # verifico se l'entità appartiene ad uno stile di quotatura
      dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id())

      if dimEntity is None:
         # stiro la feature e la rimuovo da entitySet (é la prima)
         stretchedGeom = qad_utils.stretchQgsGeometry(f.geometry(), containerGeom, \
                                                      offSetX, offSetY, \
                                                      tolerance2ApproxCurve)
         
         if stretchedGeom is not None:
            f.setGeometry(stretchedGeom)
            self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer)
         del layerEntitySet.featureIds[0]
      else:
         # stiro la quota e la rimuovo da entitySet
         dimEntitySet = dimEntity.getEntitySet()
         dimEntity.stretch(self.plugIn, containerGeom, offSetX, offSetY)
         self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer())
         self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer())
         self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer())
         entitySet.subtract(dimEntitySet)

   
   #============================================================================
   # addStretchedGeometries
   #============================================================================
   def addStretchedGeometries(self, newPt):
      self.__rubberBand.reset()            

      for SSGeom in self.SSGeomList:
         # copio entitySet
         entitySet = QadEntitySet(SSGeom[0])
         geomSel = SSGeom[1]

         for layerEntitySet in entitySet.layerEntitySetList:
            layer = layerEntitySet.layer

            tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                        self.canvas,\
                                                                        layer)                              

            g = QgsGeometry(geomSel)
            if self.plugIn.canvas.mapRenderer().destinationCrs() != layer.crs():                     
               # Trasformo la geometria nel sistema di coordinate del layer
               coordTransform = QgsCoordinateTransform(self.canvas.mapRenderer().destinationCrs(), \
                                                       layer.crs())          
               g.transform(coordTransform)

               transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt)
               transformedNewPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt)
               offSetX = transformedNewPt.x() - transformedBasePt.x()
               offSetY = transformedNewPt.y() - transformedBasePt.y()
            else:
               offSetX = newPt.x() - self.basePt.x()
               offSetY = newPt.y() - self.basePt.y()

            while len(layerEntitySet.featureIds) > 0:
               featureId = layerEntitySet.featureIds[0]
               f = layerEntitySet.getFeature(featureId)        
               self.stretch(f, g, offSetX, offSetY, tolerance2ApproxCurve, layerEntitySet, entitySet)
            
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
                     
      # noto il punto base si richiede il secondo punto per l'angolo di rotazione
      if self.mode == Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT:
         self.addStretchedGeometries(self.tmpPoint)                           
         
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
   
      # si richiede la selezione del primo punto del rettangolo per selezionare gli oggetti
      if self.mode == Qad_stretch_maptool_ModeEnum.ASK_FOR_FIRST_PT_RECTANGLE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # noto niente il primo punto del rettangolo si richiede il secondo punto
      elif self.mode == Qad_stretch_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)                
      # noto niente si richiede il punto base
      elif self.mode == Qad_stretch_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il punto base si richiede il secondo punto
      elif self.mode == Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.basePt)
예제 #2
0
class Qad_arc_maptool(QadGetPoint):
    
   def __init__(self, plugIn, asToolForMPolygon = False):
      QadGetPoint.__init__(self, plugIn)
                        
      self.arcStartPt = None
      self.arcSecondPt = None
      self.arcEndPt = None
      self.arcCenterPt = None
      self.arcTanOnStartPt = None
      self.arcAngle = None
      self.arcStartPtForRadius = None
      self.arcRadius = None
      self.__rubberBand = QadRubberBand(self.canvas)

      self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono
      if self.asToolForMPolygon:
         self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True)
         self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass


   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()
      if self.asToolForMPolygon: self.__polygonRubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
      if self.asToolForMPolygon: self.__polygonRubberBand.show()
                                   
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      if self.asToolForMPolygon: self.__polygonRubberBand.reset()
      self.mode = None
      
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
      if self.asToolForMPolygon: self.__polygonRubberBand.reset()
      
      result = False
      arc = QadArc()    
       
      # noti il primo e il secondo punto dell'arco si richiede il terzo punto
      if self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT:
         result = arc.fromStartSecondEndPts(self.arcStartPt, self.arcSecondPt, self.tmpPoint)
      # noti il primo punto e il centro dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT:
         result = arc.fromStartCenterEndPts(self.arcStartPt, self.arcCenterPt, self.tmpPoint)
      # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE:
         angle = qad_utils.getAngleBy2Pts(self.arcCenterPt, self.tmpPoint)
         result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.arcCenterPt, angle)
      # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD:     
         chord = qad_utils.getDistance(self.arcStartPt, self.tmpPoint)
         result = arc.fromStartCenterPtsChord(self.arcStartPt, self.arcCenterPt, chord)
      # noti il punto iniziale e finale dell'arco si richiede il centro
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER:     
         result = arc.fromStartCenterEndPts(self.arcStartPt, self.tmpPoint, self.arcEndPt)
      # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE:     
         angle = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
         result = arc.fromStartEndPtsAngle(self.arcStartPt, self.arcEndPt, angle)
      # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN:     
         tan = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
         result = arc.fromStartEndPtsTan(self.arcStartPt, self.arcEndPt, tan)
      # noti il punto iniziale e finale dell'arco si richiede il raggio
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS:     
         radius = qad_utils.getDistance(self.arcEndPt, self.tmpPoint)
         result = arc.fromStartEndPtsRadius(self.arcStartPt, self.arcEndPt, radius)
      # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT:     
         result = arc.fromStartEndPtsTan(self.arcStartPt, self.tmpPoint, self.arcTanOnStartPt)         
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT:     
         result = arc.fromStartEndPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle)
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT:     
         result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle)
      # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION:     
         chordDirection = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
         result = arc.fromStartPtAngleRadiusChordDirection(self.arcStartPt, self.arcAngle, \
                                                           self.arcRadius, chordDirection)
      # noti il punto iniziale e il raggio dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT:     
         result = arc.fromStartEndPtsRadius(self.arcStartPt, self.tmpPoint, self.arcRadius)
      
      if result == True:
         points = arc.asPolyline()
      
         if points is not None:
            self.__rubberBand.setLine(points)
            if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono
               if self.endVertex is not None:
                  points.insert(0, self.endVertex)
                  self.__polygonRubberBand.setPolygon(points)

    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()
      if self.asToolForMPolygon: self.__polygonRubberBand.show()
      
   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
         if self.asToolForMPolygon: self.__polygonRubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il primo punto
      if self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_START_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto dell'arco si richiede il secondo punto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_SECOND_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il primo e il secondo punto dell'arco si richiede il terzo punto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto dell'arco si richiede il centro         
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_CENTER_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il primo punto e il centro dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcCenterPt)
      # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcCenterPt)
      # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda
      elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noto il punto iniziale dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_END_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e finale dell'arco si richiede il centro
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e finale dell'arco si richiede il raggio
      elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)                  
         self.setStartPoint(self.arcEndPt)
      # noto niente si richiede il centro
      elif self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il centro dell'arco si richiede il punto iniziale
      elif self.mode == Qad_arc_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_START_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)                  
         self.setStartPoint(self.arcCenterPt)
      # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)                  
         self.setStartPoint(self.arcStartPt)
      # noto il punto iniziale dell'arco si richiede l'angolo inscritto
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_ANGLE:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il raggio
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_RADIUS:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il secondo punto per misurare il raggio
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_SECONDPTRADIUS:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPtForRadius)
      # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
      # noti il punto iniziale e il raggio dell'arco si richiede il punto finale
      elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.arcStartPt)
예제 #3
0
class Qad_fillet_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        self.filletMode = 1  # modalità di raccordo; 1=Taglia-estendi, 2=Non taglia-estendi
        self.radius = 0.0

        self.layer = None
        self.linearObjectList = qad_utils.QadLinearObjectList()
        self.partAt1 = 0
        self.vertexAt1 = 0

        self.tolerance2ApproxCurve = None

        self.__rubberBand = QadRubberBand(self.canvas)

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def setEntityInfo(self, layer, featureId, linearObjectList, partAt,
                      pointAt):
        """
      Setta self.entity, self.atSubGeom, self.linearObjectList, self.partAt, self.pointAt
      di primo o del secondo oggetto da raccordare (vedi <firstObj>)
      """
        self.layer = layer
        self.featureId = featureId
        self.linearObjectList.set(linearObjectList)
        self.partAt = partAt
        self.pointAt = pointAt

        self.tolerance2ApproxCurve = QadVariables.get(
            QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()
        tmpLinearObjectList = None

        # si richiede la selezione del secondo oggetto
        if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING:
            if self.tmpEntity.isInitialized():
                # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
                geom = self.layerToMapCoordinates(self.tmpEntity.layer,
                                                  self.tmpEntity.getGeometry())

                # ritorna una tupla (<The squared cartesian distance>,
                #                    <minDistPoint>
                #                    <afterVertex>
                #                    <leftOf>)
                dummy = qad_utils.closestSegmentWithContext(
                    self.tmpPoint, geom)
                if dummy[2] is not None:
                    # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
                    subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(
                        geom, dummy[2])
                    tmpLinearObjectList = qad_utils.QadLinearObjectList()
                    tmpLinearObjectList.fromPolyline(subGeom.asPolyline())

                    # la funzione ritorna una lista con (<minima distanza al quadrato>,
                    #                                    <punto più vicino>
                    #                                    <indice della parte più vicina>
                    #                                    <"a sinistra di">)
                    dummy = tmpLinearObjectList.closestPartWithContext(
                        self.tmpPoint)
                    tmpPartAt = dummy[2]
                    tmpPointAt = dummy[1]

                    # stessa entità e stessa parte
                    if self.layer.id() == self.tmpEntity.layer.id() and \
                       self.featureId == self.tmpEntity.featureId and \
                       self.partAt == tmpPartAt:
                        return

                    # uso il crs del canvas per lavorare con coordinate piane xy
                    epsg = self.canvas.mapRenderer().destinationCrs().authid()

                    if self.tmpShiftKey == True:  # tasto shift premuto durante il movimento del mouse
                        # filletMode = 1 # modalità di raccordo; 1=Taglia-estendi
                        # raggio = 0
                        res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \
                                                                  tmpLinearObjectList, tmpPartAt, tmpPointAt,\
                                                                  1, 0, epsg)
                    else:
                        res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \
                                                                  tmpLinearObjectList, tmpPartAt, tmpPointAt,\
                                                                  self.filletMode, self.radius, epsg)
                    if res is None:  # raccordo non possibile
                        return
                    tmpLinearObjectList = res[0]

        # si richiede la selezione della polilinea
        elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE:
            if self.tmpEntity.isInitialized():
                # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
                geom = self.layerToMapCoordinates(self.tmpEntity.layer,
                                                  self.tmpEntity.getGeometry())
                # ritorna una tupla (<The squared cartesian distance>,
                #                    <minDistPoint>
                #                    <afterVertex>
                #                    <leftOf>)
                dummy = qad_utils.closestSegmentWithContext(
                    self.tmpPoint, geom)
                if dummy[2] is not None:
                    # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
                    subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(
                        geom, dummy[2])
                    tmpLinearObjectList = qad_utils.QadLinearObjectList()
                    tmpLinearObjectList.fromPolyline(subGeom.asPolyline())
                    tmpLinearObjectList.fillet(self.radius)

        if tmpLinearObjectList is not None:
            pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve)
            if self.layer.geometryType() == QGis.Polygon:
                geom = QgsGeometry.fromPolygon([pts])
            else:
                geom = QgsGeometry.fromPolyline(pts)

            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.layer, geom)
            self.__rubberBand.addGeometry(geom, self.layer)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode

        # si richiede la selezione del primo oggetto
        # si richiede la selezione del secondo oggetto
        if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING or \
           self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING:

            if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING:
                self.setSelectionMode(
                    QadGetPointSelectionModeEnum.ENTITY_SELECTION)
            else:
                self.setSelectionMode(
                    QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)

            # solo layer lineari editabili che non appartengano a quote
            layerList = []
            for layer in qad_utils.getVisibleVectorLayers(
                    self.plugIn.canvas):  # Tutti i layer vettoriali visibili
                if layer.geometryType() == QGis.Line and layer.isEditable():
                    if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                        layerList.append(layer)

            self.layersToCheck = layerList
            self.setSnapType(QadSnapTypeEnum.DISABLE)
        # non si richiede niente
        elif self.mode == Qad_fillet_maptool_ModeEnum.NONE:
            self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # si richiede la selezione della polilinea
        elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE:
            self.setSelectionMode(
                QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)

            # solo layer lineari o poligono editabili che non appartengano a quote
            layerList = []
            for layer in qad_utils.getVisibleVectorLayers(
                    self.plugIn.canvas):  # Tutti i layer vettoriali visibili
                if (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
                   layer.isEditable():
                    if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                        layerList.append(layer)

            self.layersToCheck = layerList
            self.setSnapType(QadSnapTypeEnum.DISABLE)
예제 #4
0
class Qad_fillet_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)

      self.filletMode = 1 # modalità di raccordo; 1=Taglia-estendi, 2=Non taglia-estendi
      self.radius = 0.0
      
      self.layer = None 
      self.linearObjectList = qad_utils.QadLinearObjectList()
      self.partAt1 = 0
      self.vertexAt1 = 0
                       
      self.tolerance2ApproxCurve = None

      self.__rubberBand = QadRubberBand(self.canvas)


   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None

   def setEntityInfo(self, layer, featureId, linearObjectList, partAt, pointAt):
      """
      Setta self.entity, self.atSubGeom, self.linearObjectList, self.partAt, self.pointAt
      di primo o del secondo oggetto da raccordare (vedi <firstObj>)
      """
      self.layer = layer
      self.featureId = featureId
      self.linearObjectList.set(linearObjectList)
      self.partAt = partAt
      self.pointAt = pointAt

      self.tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))

   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
      tmpLinearObjectList = None
       
      # si richiede la selezione del secondo oggetto
      if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING:
         if self.tmpEntity.isInitialized():                                                         
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry())
            
            # ritorna una tupla (<The squared cartesian distance>,
            #                    <minDistPoint>
            #                    <afterVertex>
            #                    <leftOf>)
            dummy = qad_utils.closestSegmentWithContext(self.tmpPoint, geom)
            if dummy[2] is not None:
               # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
               subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])               
               tmpLinearObjectList = qad_utils.QadLinearObjectList()               
               tmpLinearObjectList.fromPolyline(subGeom.asPolyline())
               
               # la funzione ritorna una lista con (<minima distanza al quadrato>,
               #                                    <punto più vicino>
               #                                    <indice della parte più vicina>       
               #                                    <"a sinistra di">)
               dummy = tmpLinearObjectList.closestPartWithContext(self.tmpPoint)
               tmpPartAt = dummy[2]
               tmpPointAt = dummy[1]
               
               # stessa entità e stessa parte
               if self.layer.id() == self.tmpEntity.layer.id() and \
                  self.featureId == self.tmpEntity.featureId and \
                  self.partAt == tmpPartAt:
                  return

               # uso il crs del canvas per lavorare con coordinate piane xy
               epsg = self.canvas.mapRenderer().destinationCrs().authid()
               
               if self.tmpShiftKey == True: # tasto shift premuto durante il movimento del mouse
                  # filletMode = 1 # modalità di raccordo; 1=Taglia-estendi
                  # raggio = 0
                  res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \
                                                            tmpLinearObjectList, tmpPartAt, tmpPointAt,\
                                                            1, 0, epsg)
               else:               
                  res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \
                                                            tmpLinearObjectList, tmpPartAt, tmpPointAt,\
                                                            self.filletMode, self.radius, epsg)
               if res is None: # raccordo non possibile
                  return
               tmpLinearObjectList = res[0]
                        
      # si richiede la selezione della polilinea
      elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE:
         if self.tmpEntity.isInitialized():
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry())
            # ritorna una tupla (<The squared cartesian distance>,
            #                    <minDistPoint>
            #                    <afterVertex>
            #                    <leftOf>)
            dummy = qad_utils.closestSegmentWithContext(self.tmpPoint, geom)
            if dummy[2] is not None:
               # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
               subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])               
               tmpLinearObjectList = qad_utils.QadLinearObjectList()
               tmpLinearObjectList.fromPolyline(subGeom.asPolyline())
               tmpLinearObjectList.fillet(self.radius)
      
      if tmpLinearObjectList is not None:
         pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve)
         if self.layer.geometryType() == QGis.Polygon:
            geom = QgsGeometry.fromPolygon([pts])
         else:
            geom = QgsGeometry.fromPolyline(pts)
            
         # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
         geom = self.layerToMapCoordinates(self.layer, geom)            
         self.__rubberBand.addGeometry(geom, self.layer)
      
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode

      # si richiede la selezione del primo oggetto
      # si richiede la selezione del secondo oggetto
      if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING or \
         self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING:
         
         if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING:
            self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
         else:
            self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)

         # solo layer lineari editabili che non appartengano a quote
         layerList = []
         for layer in self.plugIn.canvas.layers():
            if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType() == QGis.Line and layer.isEditable():
               if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.setSnapType(QadSnapTypeEnum.DISABLE)
      # non si richiede niente
      elif self.mode == Qad_fillet_maptool_ModeEnum.NONE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # si richiede la selezione della polilinea
      elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)

         # solo layer lineari o poligono editabili che non appartengano a quote
         layerList = []
         for layer in self.plugIn.canvas.layers():
            if layer.type() == QgsMapLayer.VectorLayer and \
               (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
               layer.isEditable():
               if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.setSnapType(QadSnapTypeEnum.DISABLE)
예제 #5
0
class Qad_mirror_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.firstMirrorPt = None
      self.entitySet = QadEntitySet()
      self.__rubberBand = QadRubberBand(self.canvas)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    
   

   #============================================================================
   # mirror
   #============================================================================
   def mirror(self, f, pt1, pt2, layerEntitySet, entitySet):
      # verifico se la feature appartiene ad una quotatura
      dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id())
      
      if dimEntity is None:
         # specchio la feature e la rimuovo da entitySet (é la prima)
         f.setGeometry(qad_utils.mirrorQgsGeometry(f.geometry(), pt1, pt2))
         self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer)
         del layerEntitySet.featureIds[0]
      else:
         # specchio la quota e la rimuovo da entitySet
         dimEntitySet = dimEntity.getEntitySet()         
         dimEntity.mirror(self.plugIn, pt1, qad_utils.getAngleBy2Pts(pt1, pt2))
         self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer())
         self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer())
         self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer())
         entitySet.subtract(dimEntitySet)
   
   
   def setMirroredGeometries(self, newPt):
      self.__rubberBand.reset()

      # copio entitySet
      entitySet = QadEntitySet(self.entitySet)
                
      for layerEntitySet in entitySet.layerEntitySetList:
         layer = layerEntitySet.layer

         transformedFirstMirrorPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.firstMirrorPt)
         transformedNewPtMirrorPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt)

         while len(layerEntitySet.featureIds) > 0:
            featureId = layerEntitySet.featureIds[0]
            f = layerEntitySet.getFeature(featureId)
            self.mirror(f, transformedFirstMirrorPt, transformedNewPtMirrorPt, layerEntitySet, entitySet)
                     
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
                     
      # noto il primo punto si richiede il secondo punto della linea speculare
      if self.mode == Qad_mirror_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
         self.setMirroredGeometries(self.tmpPoint)                           
         
    
   def activate(self):
      QadGetPoint.activate(self)  
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il primo punto della linea speculare
      if self.mode == Qad_mirror_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto si richiede il secondo punto della linea speculare
      elif self.mode == Qad_mirror_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.firstMirrorPt)
예제 #6
0
class Qad_rectangle_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        self.firstCorner = None
        self.secondCorner = None
        self.basePt = None
        self.gapType = 0  # 0 = Angoli retti; 1 = Raccorda i segmenti; 2 = Cima i segmenti
        self.gapValue1 = 0  # se gapType = 1 -> raggio di curvatura; se gapType = 2 -> prima distanza di cimatura
        self.gapValue2 = 0  # se gapType = 2 -> seconda distanza di cimatura
        self.rot = 0
        self.vertices = []

        self.__rubberBand = QadRubberBand(self.canvas, True)
        self.geomType = QGis.Polygon

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        result = False
        del self.vertices[:]  # svuoto la lista

        # noto il primo angolo si richiede l'angolo opposto
        if self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER:
            self.vertices.extend(qad_utils.getRectByCorners(self.firstCorner, self.tmpPoint, self.rot, \
                                                            self.gapType, self.gapValue1, self.gapValue2))
            result = True

        if result == True:
            if self.vertices is not None:
                if self.geomType == QGis.Polygon:
                    self.__rubberBand.setPolygon(self.vertices)
                else:
                    self.__rubberBand.setLine(self.vertices)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo angolo
        if self.mode == Qad_rectangle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_CORNER:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il primo angolo si richiede l'angolo opposto
        elif self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #7
0
class Qad_lengthen_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)

      self.OpMode = None # "DElta" o "Percent" o "Total" o "DYnamic"
      self.OpType = None # "length" o "Angle"
      self.value = None
      self.tmpLinearObjectList = None

      self.__rubberBand = QadRubberBand(self.canvas)


   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None

   def setInfo(self, entity, point):
      # setta: self.layer, self.tmpLinearObjectList e self.move_startPt

      if self.tmpLinearObjectList is not None:
         del self.tmpLinearObjectList
         self.tmpLinearObjectList = None
      
      if entity.isInitialized() == False:
         return False
         
      self.layer = entity.layer
      transformedPt = self.canvas.mapSettings().mapToLayerCoordinates(self.layer, point)
      geom = entity.getGeometry()
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(transformedPt, geom)
      if dummy[2] is None:
         return False
      # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
      subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])               
      self.tmpLinearObjectList = qad_utils.QadLinearObjectList()               
      self.tmpLinearObjectList.fromPolyline(subGeom.asPolyline())
      
      if qad_utils.getDistance(self.tmpLinearObjectList.getStartPt(), transformedPt) <= \
         qad_utils.getDistance(self.tmpLinearObjectList.getEndPt(), transformedPt):
         # si allunga/accorcia dal punto iniziale                 
         self.move_startPt = True
      else:
         # si allunga dal punto finale
         self.move_startPt = False
      return True


   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
      res = False
       
      # si richiede la selezione dell'oggetto da allungare
      if self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_LENGTHEN:
         if self.tmpEntity.isInitialized():
            if self.setInfo(self.tmpEntity, self.tmpPoint) == False:
               return

            if self.OpMode == "DElta":
               newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList)
               if self.OpType == "length":
                  res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, self.value)
               elif self.OpType == "Angle":
                  res = newTmpLinearObjectList.lengthen_deltaAngle(self.move_startPt, self.value)
            elif self.OpMode == "Percent":
               newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList)
               value = newTmpLinearObjectList.length() * self.value / 100
               value = value - newTmpLinearObjectList.length()
               res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, value)
            elif self.OpMode == "Total":
               newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList)
               if self.OpType == "length":
                  value = self.value - self.tmpLinearObjectList.length()
                  res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, value)
               elif self.OpType == "Angle":                     
                  if newTmpLinearObjectList.qty() == 1:
                     linearObject = newTmpLinearObjectList.getLinearObjectAt(0)
                     if linearObject.isArc() == True: # se è un arco
                        value = self.value - linearObject.getArc().totalAngle()
                        res = newTmpLinearObjectList.lengthen_deltaAngle(self.move_startPt, value)
               
      # si richiede un punto per la nuova estremità
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT:
         newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList)
         transformedPt = self.canvas.mapSettings().mapToLayerCoordinates(self.layer, self.tmpPoint)
         
         if self.move_startPt:
            linearObject = newTmpLinearObjectList.getLinearObjectAt(0)
         else:
            linearObject = newTmpLinearObjectList.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 newTmpLinearObjectList.qty() > 1 and linearObject.isSegment():
            ang = linearObject.getTanDirectionOnStartPt()

         if self.move_startPt:
            linearObject.setStartPt(newPt)
         else:
            linearObject.setEndPt(newPt)

         if newTmpLinearObjectList.qty() > 1 and linearObject.isSegment() and \
            qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False:
            res = False
         else:
            res = True
      
      if res == False: # allungamento impossibile
         return
      pts = newTmpLinearObjectList.asPolyline()
      geom = QgsGeometry.fromPolyline(pts)
      self.__rubberBand.addGeometry(geom, self.layer)
      
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode

      # si richiede la selezione dell'oggetto da misurare
      if self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_MISURE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)

         # solo layer di tipo lineari che non appartengano a quote o di tipo poligono 
         layerList = []
         for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili
            if layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon:
               if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.onlyEditableLayers = False
         self.setSnapType(QadSnapTypeEnum.DISABLE)
      # si richiede il delta
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DELTA:
         self.OpMode = "DElta"
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
      # non si richiede niente
      elif self.mode == Qad_lengthen_maptool_ModeEnum.NONE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
      # si richiede la selezione dell'oggetto da allungare
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_LENGTHEN:
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)

         # solo layer lineari editabili che non appartengano a quote
         layerList = []
         for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili
            if layer.geometryType() == QGis.Line and layer.isEditable():
               if len(QadDimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.onlyEditableLayers = True
         self.setSnapType(QadSnapTypeEnum.DISABLE)
      # si richiede la percentuale
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_PERCENT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) 
         self.OpMode = "Percent"
      # si richiede il totale
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_TOTAL:
         self.OpMode = "Total"
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
      # si richiede il nuovo punto dell'estremità in modalità dinamica
      elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT:
         self.OpMode = "DYnamic"
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
예제 #8
0
class Qad_scale_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.basePt = None
      self.Pt1ReferenceLen = None
      self.ReferenceLen = 0
      self.Pt1NewLen = None
      self.entitySet = QadEntitySet()
      self.__rubberBand = QadRubberBand(self.canvas)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    


   #============================================================================
   # scale
   #============================================================================
   def scale(self, f, basePt, scale, layerEntitySet, entitySet):
      # verifico se l'entità appartiene ad uno stile di quotatura
      dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id())
           
      if dimEntity is None:
         # scalo la feature e la rimuovo da entitySet (é la prima)
         f.setGeometry(qad_utils.scaleQgsGeometry(f.geometry(), basePt, scale))
         self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer)
         del layerEntitySet.featureIds[0]
      else:
         # scalo la quota e la rimuovo da entitySet
         dimEntitySet = dimEntity.getEntitySet()
         dimEntity.scale(self.plugIn, basePt, scale)
         self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer())
         self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer())
         self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer())
         entitySet.subtract(dimEntitySet)

   
   #============================================================================
   # addScaledGeometries
   #============================================================================
   def addScaledGeometries(self, scale):
      self.__rubberBand.reset()            
      
      # copio entitySet
      entitySet = QadEntitySet(self.entitySet)
      
      if scale <= 0:
         return
      
      for layerEntitySet in entitySet.layerEntitySetList:
         layer = layerEntitySet.layer

         transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt)

         while len(layerEntitySet.featureIds) > 0:
            featureId = layerEntitySet.featureIds[0]
            f = layerEntitySet.getFeature(featureId)        
            self.scale(f, transformedBasePt, scale, layerEntitySet, entitySet)
            
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
                     
      # noto il punto base si richiede il secondo punto per la scala
      if self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_SCALE_PT:
         scale = qad_utils.getDistance(self.basePt, self.tmpPoint)
         self.addScaledGeometries(scale)                           
      # noto il primo punto si richiede il secondo punto per la lunghezza di riferimento
      elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT:
         len = qad_utils.getDistance(self.basePt, self.tmpPoint)
         scale = len / self.ReferenceLen
         self.addScaledGeometries(scale)                           
      # noto il primo punto si richiede il secondo punto per la nuova lunghezza
      elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_LEN_PT:
         len = qad_utils.getDistance(self.Pt1NewLen, self.tmpPoint)
         scale = len / self.ReferenceLen
         self.addScaledGeometries(scale)                           
         
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il punto base
      if self.mode == Qad_scale_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il punto base si richiede il secondo punto per la scala
      elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_SCALE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.basePt)
      # si richiede il primo punto per la lunghezza di riferimento
      elif self.mode == Qad_scale_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_LEN:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto si richiede il secondo punto per la lunghezza di riferimento
      elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_REFERENCE_LEN:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.Pt1ReferenceLen)
      # noto il punto base si richiede il secondo punto per la nuova lunghezza
      elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.basePt)
      # si richiede il primo punto per la nuova lunghezza
      elif self.mode == Qad_scale_maptool_ModeEnum.ASK_FOR_FIRST_NEW_LEN_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto si richiede il secondo punto per la nuova lunghezza
      elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_LEN_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.Pt1NewLen)
예제 #9
0
class Qad_dim_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        dimStyle = None
        self.dimPt1 = None
        self.dimPt2 = None
        self.dimCircle = None

        self.dimArc = None  # per quotatura arco

        self.forcedTextRot = None  # rotazione del testo di quota
        self.measure = None  # misura della quota (se None viene calcolato)
        self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL  # allineamento della linea di quota
        self.forcedDimLineAlignment = None  # allineamento della linea di quota forzato
        self.forcedDimLineRot = 0.0  # rotazione della linea di quota forzato
        self.leader = None  # per disegnare la linea direttrice nella quotatura arco

        self.__rubberBand = QadRubberBand(self.canvas)

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def setDimLineAlignment(self, LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2):
        # < 0 se a sinistra della linea
        sxOfHorizLine1 = True if qad_utils.leftOfLine(LinePosPt, horizLine1[0], horizLine1[1]) < 0 else False
        sxOfHorizLine2 = True if qad_utils.leftOfLine(LinePosPt, horizLine2[0], horizLine2[1]) < 0 else False

        sxOfVerticalLine1 = True if qad_utils.leftOfLine(LinePosPt, verticalLine1[0], verticalLine1[1]) < 0 else False
        sxOfVerticalLine2 = True if qad_utils.leftOfLine(LinePosPt, verticalLine2[0], verticalLine2[1]) < 0 else False

        # se LinePosPt é tra le linee di limite orizzontale e non é tra le linee di limite verticale
        if sxOfHorizLine1 != sxOfHorizLine2 and sxOfVerticalLine1 == sxOfVerticalLine2:
            self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL
        # se LinePosPt non é tra le linee di limite orizzontale ed é tra le linee di limite verticale
        elif sxOfHorizLine1 == sxOfHorizLine2 and sxOfVerticalLine1 != sxOfVerticalLine2:
            self.preferredAlignment = QadDimStyleAlignmentEnum.VERTICAL

        return

    # ============================================================================
    # setLinearDimPtsAndDimLineAlignmentOnCircle
    # ============================================================================
    def setLinearDimPtsAndDimLineAlignmentOnCircle(self, LinePosPt, circle):
        pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, circle.radius)
        pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius)
        horizLine1 = [pt1, pt2]

        pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, -1 * circle.radius)
        pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius)
        horizLine2 = [pt1, pt2]

        pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, circle.radius)
        pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius)
        verticalLine1 = [pt1, pt2]

        pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, -1 * circle.radius)
        pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius)
        verticalLine2 = [pt1, pt2]

        # se non é stato impostato un allineamento forzato, lo calcolo in automatico
        if self.forcedDimLineAlignment is None:
            self.setDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2)
        else:
            self.preferredAlignment = self.forcedDimLineAlignment

        if self.preferredAlignment == QadDimStyleAlignmentEnum.HORIZONTAL:
            self.dimPt1 = horizLine1[0]
            self.dimPt2 = horizLine2[0]
        else:
            self.dimPt1 = verticalLine1[0]
            self.dimPt2 = verticalLine2[0]

    # ============================================================================
    # setLinearDimLineAlignmentOnDimPts
    # ============================================================================
    def setLinearDimLineAlignmentOnDimPts(self, LinePosPt):
        # se non é stato impostato un allineamento forzato, lo calcolo in automatico
        if self.forcedDimLineAlignment is None:
            pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot + math.pi / 2, 1)
            horizLine1 = [self.dimPt1, pt2]

            pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot + math.pi / 2, 1)
            horizLine2 = [self.dimPt2, pt2]

            pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot, 1)
            verticalLine1 = [self.dimPt1, pt2]

            pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot, 1)
            verticalLine2 = [self.dimPt2, pt2]

            self.setDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2)
        else:
            self.preferredAlignment = self.forcedDimLineAlignment

    # ============================================================================
    # canvasMoveEvent
    # ============================================================================
    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        dimEntity = None

        # noti i punti di quotatura si richiede la posizione della linea di quota lineare
        if self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS:
            if self.dimCircle is not None:
                self.setLinearDimPtsAndDimLineAlignmentOnCircle(self.tmpPoint, self.dimCircle)
            else:
                self.setLinearDimLineAlignmentOnDimPts(self.tmpPoint)

            dimEntity, textOffsetRect = self.dimStyle.getLinearDimFeatures(
                self.canvas,
                self.dimPt1,
                self.dimPt2,
                self.tmpPoint,
                self.measure,
                self.preferredAlignment,
                self.forcedDimLineRot,
            )
        # noti i punti di quotatura si richiede la posizione della linea di quota allineata
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS:
            dimEntity, textOffsetRect = self.dimStyle.getAlignedDimFeatures(
                self.canvas, self.dimPt1, self.dimPt2, self.tmpPoint, self.measure
            )
        # noti i punti di quotatura si richiede la posizione della linea di quota arco
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ARC_DIM_LINE_POS:
            dimEntity, textOffsetRect = self.dimStyle.getArcDimFeatures(
                self.canvas, self.dimArc, self.tmpPoint, self.measure
            )

        if dimEntity is not None:
            # testo di quota
            self.__rubberBand.addGeometry(
                dimEntity.textualFeature.geometry(), self.dimStyle.getTextualLayer()
            )  # geom e layer
            self.__rubberBand.addGeometry(textOffsetRect, self.dimStyle.getTextualLayer())  # geom e layer
            for g in dimEntity.getLinearGeometryCollection():
                self.__rubberBand.addGeometry(g, self.dimStyle.getLinearLayer())  # geom e layer
            for g in dimEntity.getSymbolGeometryCollection():
                self.__rubberBand.addGeometry(g, self.dimStyle.getSymbolLayer())  # geom e layer

    def activate(self):
        QadGetPoint.activate(self)
        if self.__rubberBand is not None:
            self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            if self.__rubberBand is not None:
                self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo punto di quotatura
        if self.mode == Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il primo punto si richiede il secondo punto di quotatura
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.dimPt1)
        # noto i punti di quotatura si richiede la posizione della linea di quota
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # si richiede il testo di quota
        elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noti i punti di quotatura si richiede la posizione della linea di quota allineata
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # si richiede un punto sull'arco per la quota arco
        elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_PARTIAL_ARC_PT_FOR_DIM_ARC:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto i punti di quotatura si richiede la posizione della linea di quota
        elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ARC_DIM_LINE_POS:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #10
0
class Qad_pline_maptool(QadGetPoint):
    def __init__(self, plugIn, asToolForMPolygon=False):
        QadGetPoint.__init__(self, plugIn)

        self.firstPt = None
        self.mode = None

        self.asToolForMPolygon = asToolForMPolygon  # se True significa che è usato per disegnare un poligono
        if self.asToolForMPolygon:
            self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True)
            self.endVertex = None  # punta al vertice iniziale e finale del poligono di QadPLINECommandClass
        else:
            self.__polylineTraceRubberBand = QadRubberBand(
                self.plugIn.canvas,
                True)  # da usare in trace di un oggetto esistente

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        if self.asToolForMPolygon:
            self.__polygonRubberBand.hide()
        else:
            self.__polylineTraceRubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        if self.asToolForMPolygon:
            self.__polygonRubberBand.show()
        else:
            self.__polylineTraceRubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        if self.asToolForMPolygon:
            self.__polygonRubberBand.reset()
        else:
            self.__polylineTraceRubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        if self.asToolForMPolygon == True:  # se True significa che è usato per disegnare un poligono
            self.__polygonRubberBand.reset()
        else:
            self.__polylineTraceRubberBand.reset()

        startPoint = self.getStartPoint()
        if startPoint is None: return

        points = None

        # si richiede il punto finale per ricalcare un oggetto esistente
        if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
            if self.tmpEntity.isInitialized():
                # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
                geom = self.layerToMapCoordinates(self.tmpEntity.layer,
                                                  self.tmpEntity.getGeometry())
                ptEnd = qad_utils.closestVertexPtWithContext(
                    self.tmpPoint, geom)
                # leggo la parte di linea tra self.firstPt e ptEnd
                points = qad_utils.getLinePart(geom, startPoint, ptEnd)
        else:
            points = [startPoint, self.tmpPoint]

        # caso di poligono
        if self.asToolForMPolygon:
            if (points is not None) and (self.endVertex is not None) and (
                    startPoint != self.endVertex):
                points.insert(0, self.endVertex)
                self.__polygonRubberBand.setPolygon(points)
        elif self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
            if (points is not None):
                self.__polylineTraceRubberBand.setLine(points)

        del startPoint

    def activate(self):
        QadGetPoint.activate(self)
        if self.asToolForMPolygon:
            self.__polygonRubberBand.show()
        else:
            self.__polylineTraceRubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            if self.asToolForMPolygon:
                self.__polygonRubberBand.hide()
            else:
                self.__polylineTraceRubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode

        # si richiede il punto finale per ricalcare un oggetto esistente
        if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
            self.checkPointLayer = False  # scarto la selezione di punti
            self.checkLineLayer = True
            self.checkPolygonLayer = True
            self.onlyEditableLayers = False
            self.forceSnapTypeOnce(QadSnapTypeEnum.END)

            self.setSelectionMode(
                QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # non si richiede niente
        elif self.mode == Qad_pline_maptool_ModeEnum.NONE:
            self.setSelectionMode(QadGetPointSelectionModeEnum.NONE)
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # si deve tracciare una linea
        elif self.mode == Qad_pline_maptool_ModeEnum.DRAW_LINE:
            self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE
                             )  # imposto la linea elastica
예제 #11
0
class Qad_dim_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)

      dimStyle = None
      self.dimPt1 = None
      self.dimPt2 = None
      self.dimCircle = None
      
      self.forcedTextRot = None # rotazione del testo di quota
      self.measure = None # misura della quota (se None viene calcolato)
      self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # allineamento della linea di quota
      self.forcedDimLineAlignment = None # allineamento della linea di quota forzato
      self.forcedDimLineRot = 0.0 # rotazione della linea di quota forzato
      
      self.__rubberBand = QadRubberBand(self.canvas)      
                              
      
      self.centerPt = None
      self.radius = None
      self.dimPt1 = None
      self.dimPt2 = None
      self.firstDiamPt = None
      self.tan1 = None
      self.tan2 = None
      self.startPtForRadius = None
      self.geomType = QGis.Polygon

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    
            

   def seDimLineAlignment(self, LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2):
      # < 0 se a sinistra della linea
      sxOfHorizLine1 = True if qad_utils.leftOfLine(LinePosPt, horizLine1[0], horizLine1[1]) < 0 else False
      sxOfHorizLine2 = True if qad_utils.leftOfLine(LinePosPt, horizLine2[0], horizLine2[1]) < 0 else False
      
      sxOfVerticalLine1 = True if qad_utils.leftOfLine(LinePosPt, verticalLine1[0], verticalLine1[1]) < 0 else False
      sxOfVerticalLine2 = True if qad_utils.leftOfLine(LinePosPt, verticalLine2[0], verticalLine2[1]) < 0 else False
      
      # se LinePosPt é tra le linee di limite orizzontale e non é tra le linee di limite verticale      
      if sxOfHorizLine1 != sxOfHorizLine2 and sxOfVerticalLine1 == sxOfVerticalLine2:
         self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL
      # se LinePosPt non é tra le linee di limite orizzontale ed é tra le linee di limite verticale      
      elif sxOfHorizLine1 == sxOfHorizLine2 and sxOfVerticalLine1 != sxOfVerticalLine2:
         self.preferredAlignment = QadDimStyleAlignmentEnum.VERTICAL
      
      return
            

   #============================================================================
   # setLinearDimPtsAndDimLineAlignmentOnCircle
   #============================================================================
   def setLinearDimPtsAndDimLineAlignmentOnCircle(self, LinePosPt, circle):
      pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, circle.radius)
      pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius)
      horizLine1 = [pt1, pt2]
      
      pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, -1 * circle.radius)
      pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius)
      horizLine2 = [pt1, pt2]
      
      pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, circle.radius)
      pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius)
      verticalLine1 = [pt1, pt2]
      
      pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, -1 * circle.radius)
      pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius)
      verticalLine2 = [pt1, pt2]
      
      # se non é stato impostato un allineamento forzato, lo calcolo in automatico
      if self.forcedDimLineAlignment is None:         
         self.seDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2)
      else:
         self.preferredAlignment = self.forcedDimLineAlignment
         
      if self.preferredAlignment == QadDimStyleAlignmentEnum.HORIZONTAL:
         self.dimPt1 = horizLine1[0]
         self.dimPt2 = horizLine2[0]
      else:
         self.dimPt1 = verticalLine1[0]
         self.dimPt2 = verticalLine2[0]
         

   #============================================================================
   # setLinearDimLineAlignmentOnDimPts
   #============================================================================
   def setLinearDimLineAlignmentOnDimPts(self, LinePosPt):      
      # se non é stato impostato un allineamento forzato, lo calcolo in automatico
      if self.forcedDimLineAlignment is None:         
         pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot + math.pi / 2, 1)
         horizLine1 = [self.dimPt1, pt2]
         
         pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot + math.pi / 2, 1)
         horizLine2 = [self.dimPt2, pt2]
         
         pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot, 1)
         verticalLine1 = [self.dimPt1, pt2]
         
         pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot, 1)
         verticalLine2 = [self.dimPt2, pt2]
         
         self.seDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2)
      else:
         self.preferredAlignment = self.forcedDimLineAlignment
            
            
   #============================================================================
   # canvasMoveEvent
   #============================================================================
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()            
         
      dimEntity = None
      
      # noti i punti di quotatura si richiede la posizione della linea di quota lineare
      if self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS:
         if self.dimCircle is not None:
            self.setLinearDimPtsAndDimLineAlignmentOnCircle(self.tmpPoint, self.dimCircle)
         else:
            self.setLinearDimLineAlignmentOnDimPts(self.tmpPoint)
                     
         dimEntity, textOffsetRect = self.dimStyle.getLinearDimFeatures(self.canvas, \
                                                                        self.dimPt1, \
                                                                        self.dimPt2, \
                                                                        self.tmpPoint, \
                                                                        self.measure, \
                                                                        self.preferredAlignment, \
                                                                        self.forcedDimLineRot)
      # noti i punti di quotatura si richiede la posizione della linea di quota allineata
      elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS:
         dimEntity, textOffsetRect = self.dimStyle.getAlignedDimFeatures(self.canvas, \
                                                                         self.dimPt1, \
                                                                         self.dimPt2, \
                                                                         self.tmpPoint, \
                                                                         self.measure)

      if dimEntity is not None:
         # testo di quota
         self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), self.dimStyle.getTextualLayer()) # geom e layer
         self.__rubberBand.addGeometry(textOffsetRect, self.dimStyle.getTextualLayer()) # geom e layer
         for g in dimEntity.getLinearGeometryCollection():
            self.__rubberBand.addGeometry(g, self.dimStyle.getLinearLayer()) # geom e layer
         for g in dimEntity.getSymbolGeometryCollection():
            self.__rubberBand.addGeometry(g, self.dimStyle.getSymbolLayer()) # geom e layer
         
          
   def activate(self):
      QadGetPoint.activate(self)            
      if self.__rubberBand is not None:
         self.__rubberBand.show()

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         if self.__rubberBand is not None:
            self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il primo punto di quotatura
      if self.mode == Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto si richiede il secondo punto di quotatura
      elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.dimPt1)
      # noto i punti di quotatura si richiede la posizione della linea di quota
      elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # si richiede il testo di quota
      elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # noti i punti di quotatura si richiede la posizione della linea di quota allineata
      elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #12
0
class Qad_move_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.basePt = None
      self.entitySet = QadEntitySet()
      self.__rubberBand = QadRubberBand(self.canvas)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    

   
   #============================================================================
   # move
   #============================================================================
   def move(self, f, offSetX, offSetY, layerEntitySet, entitySet):
      # verifico se l'entità appartiene ad uno stile di quotatura
      dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id())
      
      if dimEntity is None:
         # sposto la feature e la rimuovo da entitySet (é la prima)
         f.setGeometry(qad_utils.moveQgsGeometry(f.geometry(), offSetX, offSetY))
         self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer)
         del layerEntitySet.featureIds[0]
      else:
         # sposto la quota e la rimuovo da entitySet
         dimEntitySet = dimEntity.getEntitySet()
         dimEntity.move(offSetX, offSetY)
         self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer())
         self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer())
         self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer())
         entitySet.subtract(dimEntitySet)

   
   def addMovedGeometries(self, newPt):
      self.__rubberBand.reset()            

      # copio entitySet
      entitySet = QadEntitySet(self.entitySet)
      
      for layerEntitySet in entitySet.layerEntitySetList:
         layer = layerEntitySet.layer
         
         transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt)
         transformedNewPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt)
         offSetX = transformedNewPt.x() - transformedBasePt.x()
         offSetY = transformedNewPt.y() - transformedBasePt.y()

         while len(layerEntitySet.featureIds) > 0:
            featureId = layerEntitySet.featureIds[0]
            f = layerEntitySet.getFeature(featureId)
            self.move(f, offSetX, offSetY, layerEntitySet, entitySet)
            
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
                     
      # noto il punto base si richiede il secondo punto
      if self.mode == Qad_move_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT:
         self.addMovedGeometries(self.tmpPoint)                           
         
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il punto base
      if self.mode == Qad_move_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il punto base si richiede il secondo punto
      elif self.mode == Qad_move_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.basePt)
예제 #13
0
class Qad_pline_maptool(QadGetPoint):
    
   def __init__(self, plugIn, asToolForMPolygon = False):
      QadGetPoint.__init__(self, plugIn)

      self.firstPt = None
      self.mode = None

      self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono
      if self.asToolForMPolygon:
         self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True)
         self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass
      else:
         self.__polylineTraceRubberBand = QadRubberBand(self.plugIn.canvas, True) # da usare in trace di un oggetto esistente

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      if self.asToolForMPolygon:
         self.__polygonRubberBand.hide()
      else:
         self.__polylineTraceRubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      if self.asToolForMPolygon:
         self.__polygonRubberBand.show()
      else:
         self.__polylineTraceRubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      if self.asToolForMPolygon:
         self.__polygonRubberBand.reset()
      else:
         self.__polylineTraceRubberBand.reset()
      self.mode = None
   
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)

      if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono
         self.__polygonRubberBand.reset()
      else:
         self.__polylineTraceRubberBand.reset()
      
      startPoint = self.getStartPoint()
      if startPoint is None: return
      
      points = None           
       
      # si richiede il punto finale per ricalcare un oggetto esistente
      if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
         if self.tmpEntity.isInitialized():
            # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
            geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry())
            ptEnd = qad_utils.closestVertexPtWithContext(self.tmpPoint, geom)
            # leggo la parte di linea tra self.firstPt e ptEnd
            points = qad_utils.getLinePart(geom, startPoint, ptEnd)
      else:
         points = [startPoint, self.tmpPoint]
      
      # caso di poligono
      if self.asToolForMPolygon:
         if (points is not None) and (self.endVertex is not None) and (startPoint != self.endVertex):
            points.insert(0, self.endVertex)
            self.__polygonRubberBand.setPolygon(points)
      elif self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
         if (points is not None): self.__polylineTraceRubberBand.setLine(points)
      
      del startPoint

    
   def activate(self):
      QadGetPoint.activate(self)
      if self.asToolForMPolygon:
         self.__polygonRubberBand.show()
      else:
         self.__polylineTraceRubberBand.show()

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         if self.asToolForMPolygon:
            self.__polygonRubberBand.hide()
         else:
            self.__polylineTraceRubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
            
      # si richiede il punto finale per ricalcare un oggetto esistente
      if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT:
         self.checkPointLayer = False # scarto la selezione di punti
         self.checkLineLayer = True
         self.checkPolygonLayer = True
         self.onlyEditableLayers = False
         self.forceSnapTypeOnce(QadSnapTypeEnum.END)

         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # non si richiede niente
      elif self.mode == Qad_pline_maptool_ModeEnum.NONE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.NONE)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # si deve tracciare una linea
      elif self.mode == Qad_pline_maptool_ModeEnum.DRAW_LINE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) # imposto la linea elastica
예제 #14
0
class Qad_polygon_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)
        self.mode = None

        self.sideNumber = None
        self.centerPt = None
        self.constructionModeByCenter = None
        self.firstEdgePt = None
        self.vertices = []

        self.__rubberBand = QadRubberBand(self.canvas, True)
        self.geomType = QGis.Polygon

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        result = False
        del self.vertices[:]  # svuoto la lista

        if self.mode is not None:
            # noto il centro si richiede il raggio
            if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
                radius = qad_utils.getDistance(self.centerPt, self.tmpPoint)

                InscribedOption = True if self.constructionModeByCenter == QadMsg.translate(
                    "Command_POLYGON", "Inscribed in circle") else False
                self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, radius, \
                                                                              InscribedOption, self.tmpPoint))
                result = True
            # si richiede il secondo punto dello spigolo
            elif self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT:
                self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, \
                                                                         self.tmpPoint))
                result = True

        if result == True:
            if self.vertices is not None:
                if self.geomType == QGis.Polygon:
                    self.__rubberBand.setPolygon(self.vertices)
                else:
                    self.__rubberBand.setLine(self.vertices)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # si richiede il centro
        if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_CENTER_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il centro si richiede il raggio
        if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.centerPt)
        # si richiede il primo punto dello spigolo
        if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_FIRST_EDGE_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # si richiede il secondo punto dello spigolo
        if self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.firstEdgePt)
예제 #15
0
class Qad_pedit_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)

      self.firstPt = None
                       
      self.layer = None 
      self.linearObjectList = qad_utils.QadLinearObjectList()
      self.tolerance2ApproxCurve = None
      self.vertexAt = 0
      self.after = True 
      self.__rubberBand = QadRubberBand(self.canvas)


   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None

   def setLinearObjectList(self, linearObjectList, layer):
      self.linearObjectList.set(linearObjectList)
      self.layer = layer
      self.tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                       self.canvas,\
                                                                       self.layer)                              

   def setVertexAt(self, vertexAt, after = None):
      if vertexAt == self.linearObjectList.qty():
         pt = self.linearObjectList.getLinearObjectAt(-1).getEndPt()
      else:
         pt = self.linearObjectList.getLinearObjectAt(vertexAt).getStartPt()
      
      self.firstPt = self.canvas.mapRenderer().layerToMapCoordinates(self.layer, pt)         
      self.vertexAt = vertexAt
      self.after = after      
    
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
      tmpLinearObjectList = None           
       
      # noti il primo punto e il centro dell'arco si richiede il punto finale
      if self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_NEW_VERTEX:
         newPt = self.canvas.mapRenderer().mapToLayerCoordinates(self.layer, self.tmpPoint)
         tmpLinearObjectList = qad_utils.QadLinearObjectList()
         tmpLinearObjectList.set(self.linearObjectList)
         if self.after: # dopo
            if self.vertexAt == tmpLinearObjectList.qty() and tmpLinearObjectList.isClosed():
               tmpLinearObjectList.insertPoint(0, newPt)
            else:
               tmpLinearObjectList.insertPoint(self.vertexAt, newPt)
         else: # prima
            if self.vertexAt == 0 and tmpLinearObjectList.isClosed():
               tmpLinearObjectList.insertPoint(tmpLinearObjectList.qty() - 1, newPt)
            else:
               tmpLinearObjectList.insertPoint(self.vertexAt - 1, newPt)
      elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_MOVE_VERTEX:
         newPt = self.canvas.mapRenderer().mapToLayerCoordinates(self.layer, self.tmpPoint)
         tmpLinearObjectList = qad_utils.QadLinearObjectList()
         tmpLinearObjectList.set(self.linearObjectList)         
         tmpLinearObjectList.movePoint(self.vertexAt, newPt)
      
      if tmpLinearObjectList is not None:
         pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve) 
         if self.layer.geometryType() == QGis.Polygon:
            geom = QgsGeometry.fromPolygon([pts])
         else:
            geom = QgsGeometry.fromPolyline(pts)
         self.__rubberBand.addGeometry(geom, self.layer)
      
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # si richiede la selezione di un'entità
      if self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_ENTITY_SEL:
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
         
         # solo layer lineari o poligono editabili che non appartengano a quote
         layerList = []
         for layer in self.plugIn.canvas.layers():
            if layer.type() == QgsMapLayer.VectorLayer and \
               (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
               layer.isEditable():
               if len(self.plugIn.dimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.setSnapType(QadSnapTypeEnum.DISABLE)
      # non si richiede niente
      elif self.mode == Qad_pedit_maptool_ModeEnum.NONE:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # si richiede il primo punto per calcolo distanza di approssimazione
      # si richiede la posizione più vicina ad un vertice
      elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_FIRST_TOLERANCE_PT:
         self.onlyEditableLayers = False
         self.checkPointLayer = True
         self.checkLineLayer = True
         self.checkPolygonLayer = True
         self.setSnapType()
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto per calcolo distanza di approssimazione si richiede il secondo punto
      # noto il primo punto per calcolo distanza di approssimazione si richiede il secondo punto
      elif self.mode == Qad_pedit_maptool_ModeEnum.FIRST_TOLERANCE_PT_KNOWN_ASK_FOR_SECOND_PT or \
           self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_NEW_VERTEX or \
           self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_MOVE_VERTEX:         
         self.onlyEditableLayers = False
         self.checkPointLayer = True
         self.checkLineLayer = True
         self.checkPolygonLayer = True
         self.setSnapType()
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.firstPt)
      # si richiede la posizione più vicina ad un vertice
      elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_VERTEX:
         self.setSnapType(QadSnapTypeEnum.DISABLE)
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)   
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #16
0
class Qad_mbuffer_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        self.startPtForBufferWidth = None
        # vedi il numero minimo di punti affinché venga riconosciuto un arco o un cerchio
        # nei files qad_arc.py e qad_circle.py
        self.segments = 12
        self.entitySet = QadEntitySet()
        self.geomType = QGis.Polygon
        self.__rubberBand = QadRubberBand(self.canvas, True)

    def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor):
        if rubberBandBorderColor is not None:
            self.__rubberBand.setBorderColor(rubberBandBorderColor)
        if rubberBandFillColor is not None:
            self.__rubberBand.setFillColor(rubberBandFillColor)

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        # noto il primo punto si richiede la larghezza del buffer
        if self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH:
            width = qad_utils.getDistance(self.startPtForBufferWidth,
                                          self.tmpPoint)
            tolerance = QadVariables.get(
                QadMsg.translate("Environment variables",
                                 "TOLERANCE2APPROXCURVE"))

            for layerEntitySet in self.entitySet.layerEntitySetList:
                layer = layerEntitySet.layer
                geoms = layerEntitySet.getGeometryCollection()

                for geom in geoms:
                    # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
                    newGeom = self.layerToMapCoordinates(layer, geom)
                    bufferGeom = qad_utils.ApproxCurvesOnGeom(newGeom.buffer(width, self.segments), \
                                                              self.segments, self.segments, \
                                                              tolerance)
                    if bufferGeom:
                        # trasformo la geometria nel crs del layer
                        self.__rubberBand.addGeometry(
                            self.mapToLayerCoordinates(layer, bufferGeom),
                            layer)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo punto
        if self.mode == Qad_mbuffer_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il primo punto si richiede la larghezza del buffer
        elif self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.startPtForBufferWidth)
예제 #17
0
class Qad_mbuffer_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.startPtForBufferWidth = None
      # vedi il numero minimo di punti affinché venga riconosciuto un arco o un cerchio
      # nei files qad_arc.py e qad_circle.py
      self.segments = 12
      self.entitySet = QadEntitySet()
      self.geomType = QGis.Polygon
      self.__rubberBand = QadRubberBand(self.canvas, True)

   def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor):
      if rubberBandBorderColor is not None:
         self.__rubberBand.setBorderColor(rubberBandBorderColor)
      if rubberBandFillColor is not None:
         self.__rubberBand.setFillColor(rubberBandFillColor)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    
      
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
               
      # noto il primo punto si richiede la larghezza del buffer
      if self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH:
         width = qad_utils.getDistance(self.startPtForBufferWidth, self.tmpPoint)
         tolerance = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
         
         for layerEntitySet in self.entitySet.layerEntitySetList:
            layer = layerEntitySet.layer
            geoms = layerEntitySet.getGeometryCollection()
            
            for geom in geoms:
               # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
               newGeom = self.layerToMapCoordinates(layer, geom)
               bufferGeom = qad_utils.ApproxCurvesOnGeom(newGeom.buffer(width, self.segments), \
                                                         self.segments, self.segments, \
                                                         tolerance)
               if bufferGeom:
                  # trasformo la geometria nel crs del layer
                  self.__rubberBand.addGeometry(self.mapToLayerCoordinates(layer, bufferGeom), layer)
                           
    
   def activate(self):
      QadGetPoint.activate(self)           
      self.__rubberBand.show() 

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il primo punto
      if self.mode == Qad_mbuffer_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo punto si richiede la larghezza del buffer
      elif self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.startPtForBufferWidth)
예제 #18
0
class Qad_line_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        self.firstPt = None
        self.tan1 = None
        self.per1 = None
        self.geom1 = None
        self.__rubberBand = QadRubberBand(self.canvas)

    def __del__(self):
        QadGetPoint.__del__(self)

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        line = None

        # noto il primo punto si richiede il secondo punto
        if self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
            if self.firstPt is not None:
                line = [self.firstPt, self.tmpPoint]
        # nota l'entita del primo punto di tangenza si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT:
            snapper = QadSnapper()
            snapper.setSnapPointCRS(self.canvas.mapSettings().destinationCrs())
            snapper.setSnapType(QadSnapTypeEnum.TAN)
            snapper.setStartPoint(self.tmpPoint)
            oSnapPoints = snapper.getSnapPoint(self.geom1, self.tan1, self.canvas.mapSettings().destinationCrs())
            # memorizzo il punto di snap in point (prendo il primo valido)
            for item in oSnapPoints.items():
                points = item[1]
                if points is not None:
                    line = [points[0], self.tmpPoint]
                    break
        # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT:
            snapper = QadSnapper()
            snapper.setSnapPointCRS(self.canvas.mapSettings().destinationCrs())
            snapper.setSnapType(QadSnapTypeEnum.PER)
            snapper.setStartPoint(self.tmpPoint)
            oSnapPoints = snapper.getSnapPoint(self.geom1, self.per1, self.canvas.mapSettings().destinationCrs())
            # memorizzo il punto di snap in point (prendo il primo valido)
            for item in oSnapPoints.items():
                points = item[1]
                if points is not None:
                    line = [points[0], self.tmpPoint]
                    break

        if line is not None:
            self.__rubberBand.setLine(line)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo punto
        if self.mode == Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
            self.setStartPoint(None)
        # noto il primo punto si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.firstPt)
        # nota l'entita del primo punto di tangenza si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #19
0
class Qad_rectangle_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.firstCorner = None
      self.secondCorner = None
      self.basePt = None
      self.gapType = 0 # 0 = Angoli retti; 1 = Raccorda i segmenti; 2 = Cima i segmenti
      self.gapValue1 = 0 # se gapType = 1 -> raggio di curvatura; se gapType = 2 -> prima distanza di cimatura
      self.gapValue2 = 0 # se gapType = 2 -> seconda distanza di cimatura
      self.rot = 0
      self.vertices = []

      self.__rubberBand = QadRubberBand(self.canvas, True)   
      self.geomType = QGis.Polygon

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None                
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()

      result = False
      del self.vertices[:] # svuoto la lista
               
      # noto il primo angolo si richiede l'angolo opposto
      if self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER:
         self.vertices.extend(qad_utils.getRectByCorners(self.firstCorner, self.tmpPoint, self.rot, \
                                                         self.gapType, self.gapValue1, self.gapValue2))
         result = True

      if result == True:
         if self.vertices is not None:
            if self.geomType == QGis.Polygon:
               self.__rubberBand.setPolygon(self.vertices)
            else:
               self.__rubberBand.setLine(self.vertices)            
         
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il primo angolo
      if self.mode == Qad_rectangle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_CORNER:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il primo angolo si richiede l'angolo opposto
      elif self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_arc_maptool(QadGetPoint):
    def __init__(self, plugIn, asToolForMPolygon=False):
        QadGetPoint.__init__(self, plugIn)

        self.arcStartPt = None
        self.arcSecondPt = None
        self.arcEndPt = None
        self.arcCenterPt = None
        self.arcTanOnStartPt = None
        self.arcAngle = None
        self.arcStartPtForRadius = None
        self.arcRadius = None
        self.__rubberBand = QadRubberBand(self.canvas)

        self.asToolForMPolygon = asToolForMPolygon  # se True significa che è usato per disegnare un poligono
        if self.asToolForMPolygon:
            self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True)
            self.endVertex = None  # punta al vertice iniziale e finale del poligono di QadPLINECommandClass

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()
        if self.asToolForMPolygon: self.__polygonRubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()
        if self.asToolForMPolygon: self.__polygonRubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        if self.asToolForMPolygon: self.__polygonRubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()
        if self.asToolForMPolygon: self.__polygonRubberBand.reset()

        result = False
        arc = QadArc()

        # noti il primo e il secondo punto dell'arco si richiede il terzo punto
        if self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT:
            result = arc.fromStartSecondEndPts(self.arcStartPt,
                                               self.arcSecondPt, self.tmpPoint)
        # noti il primo punto e il centro dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT:
            result = arc.fromStartCenterEndPts(self.arcStartPt,
                                               self.arcCenterPt, self.tmpPoint)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE:
            angle = qad_utils.getAngleBy2Pts(self.arcCenterPt, self.tmpPoint)
            result = arc.fromStartCenterPtsAngle(self.arcStartPt,
                                                 self.arcCenterPt, angle)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD:
            chord = qad_utils.getDistance(self.arcStartPt, self.tmpPoint)
            result = arc.fromStartCenterPtsChord(self.arcStartPt,
                                                 self.arcCenterPt, chord)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e finale dell'arco si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER:
            result = arc.fromStartCenterEndPts(self.arcStartPt, self.tmpPoint,
                                               self.arcEndPt)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE:
            angle = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
            result = arc.fromStartEndPtsAngle(self.arcStartPt, self.arcEndPt,
                                              angle)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN:
            tan = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
            result = arc.fromStartEndPtsTan(self.arcStartPt, self.arcEndPt,
                                            tan)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e finale dell'arco si richiede il raggio
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS:
            radius = qad_utils.getDistance(self.arcEndPt, self.tmpPoint)
            result = arc.fromStartEndPtsRadius(self.arcStartPt, self.arcEndPt,
                                               radius)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT:
            result = arc.fromStartEndPtsTan(self.arcStartPt, self.tmpPoint,
                                            self.arcTanOnStartPt)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT:
            result = arc.fromStartEndPtsAngle(self.arcStartPt, self.tmpPoint,
                                              self.arcAngle)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT:
            result = arc.fromStartCenterPtsAngle(self.arcStartPt,
                                                 self.tmpPoint, self.arcAngle)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION:
            chordDirection = qad_utils.getAngleBy2Pts(self.arcStartPt,
                                                      self.tmpPoint)
            result = arc.fromStartPtAngleRadiusChordDirection(self.arcStartPt, self.arcAngle, \
                                                              self.arcRadius, chordDirection)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()
        # noti il punto iniziale e il raggio dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT:
            result = arc.fromStartEndPtsRadius(self.arcStartPt, self.tmpPoint,
                                               self.arcRadius)
            if result == True and self.tmpCtrlKey:  # cambio direzione
                arc.inverse()

        if result == True:
            points = arc.asPolyline()

            if points is not None:
                self.__rubberBand.setLine(points)
                if self.asToolForMPolygon == True:  # se True significa che è usato per disegnare un poligono
                    if self.endVertex is not None:
                        points.insert(0, self.endVertex)
                        self.__polygonRubberBand.setPolygon(points)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()
        if self.asToolForMPolygon: self.__polygonRubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
            if self.asToolForMPolygon: self.__polygonRubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo punto
        if self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_START_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il primo punto dell'arco si richiede il secondo punto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il primo e il secondo punto dell'arco si richiede il terzo punto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il primo punto dell'arco si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_CENTER_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il primo punto e il centro dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcCenterPt)
        # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcCenterPt)
        # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda
        elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noto il punto iniziale dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e finale dell'arco si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e finale dell'arco si richiede il raggio
        elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcEndPt)
        # noto niente si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noto il centro dell'arco si richiede il punto iniziale
        elif self.mode == Qad_arc_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_START_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcCenterPt)
        # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noto il punto iniziale dell'arco si richiede l'angolo inscritto
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_ANGLE:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il raggio
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_RADIUS:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il secondo punto per misurare il raggio
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_SECONDPTRADIUS:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPtForRadius)
        # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
        # noti il punto iniziale e il raggio dell'arco si richiede il punto finale
        elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.arcStartPt)
예제 #21
0
class Qad_line_maptool(QadGetPoint):
    def __init__(self, plugIn):
        QadGetPoint.__init__(self, plugIn)

        self.firstPt = None
        self.tan1 = None
        self.per1 = None
        self.geom1 = None
        self.__rubberBand = QadRubberBand(self.canvas)

    def __del__(self):
        QadGetPoint.__del__(self)

    def hidePointMapToolMarkers(self):
        QadGetPoint.hidePointMapToolMarkers(self)
        self.__rubberBand.hide()

    def showPointMapToolMarkers(self):
        QadGetPoint.showPointMapToolMarkers(self)
        self.__rubberBand.show()

    def clear(self):
        QadGetPoint.clear(self)
        self.__rubberBand.reset()
        self.mode = None

    def canvasMoveEvent(self, event):
        QadGetPoint.canvasMoveEvent(self, event)

        self.__rubberBand.reset()

        line = None

        # noto il primo punto si richiede il secondo punto
        if self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
            if (self.firstPt is not None):
                line = [self.firstPt, self.tmpPoint]
        # nota l'entita del primo punto di tangenza si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT:
            snapper = QadSnapper()
            snapper.setSnapPointCRS(self.canvas.mapRenderer().destinationCrs())
            snapper.setSnapType(QadSnapTypeEnum.TAN)
            snapper.setStartPoint(self.tmpPoint)
            oSnapPoints = snapper.getSnapPoint(
                self.geom1, self.tan1,
                self.canvas.mapRenderer().destinationCrs())
            # memorizzo il punto di snap in point (prendo il primo valido)
            for item in oSnapPoints.items():
                points = item[1]
                if points is not None:
                    line = [points[0], self.tmpPoint]
                    break
        # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT:
            snapper = QadSnapper()
            snapper.setSnapPointCRS(self.canvas.mapRenderer().destinationCrs())
            snapper.setSnapType(QadSnapTypeEnum.PER)
            snapper.setStartPoint(self.tmpPoint)
            oSnapPoints = snapper.getSnapPoint(
                self.geom1, self.per1,
                self.canvas.mapRenderer().destinationCrs())
            # memorizzo il punto di snap in point (prendo il primo valido)
            for item in oSnapPoints.items():
                points = item[1]
                if points is not None:
                    line = [points[0], self.tmpPoint]
                    break

        if line is not None:
            self.__rubberBand.setLine(line)

    def activate(self):
        QadGetPoint.activate(self)
        self.__rubberBand.show()

    def deactivate(self):
        try:  # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
            QadGetPoint.deactivate(self)
            self.__rubberBand.hide()
        except:
            pass

    def setMode(self, mode):
        self.mode = mode
        # noto niente si richiede il primo punto
        if self.mode == Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
            self.setStartPoint(None)
        # noto il primo punto si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
            self.setStartPoint(self.firstPt)
        # nota l'entita del primo punto di tangenza si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
        # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto
        elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT:
            self.setDrawMode(QadGetPointDrawModeEnum.NONE)
예제 #22
0
class Qad_polygon_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
      self.mode = None    
                        
      self.sideNumber = None
      self.centerPt = None
      self.constructionModeByCenter = None   
      self.firstEdgePt = None
      self.vertices = []

      self.__rubberBand = QadRubberBand(self.canvas, True)   
      self.geomType = QGis.Polygon

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None                
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()

      result = False
      del self.vertices[:] # svuoto la lista
      
      if self.mode is not None:
         # noto il centro si richiede il raggio
         if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
            radius = qad_utils.getDistance(self.centerPt, self.tmpPoint)
      
            InscribedOption = True if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Inscribed in circle") else False            
            self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, radius, \
                                                                          InscribedOption, self.tmpPoint))
            result = True
         # si richiede il secondo punto dello spigolo
         elif self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT:
            self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, \
                                                                     self.tmpPoint))
            result = True
            
      if result == True:         
         if self.vertices is not None:
            if self.geomType == QGis.Polygon:
               self.__rubberBand.setPolygon(self.vertices)
            else:
               self.__rubberBand.setLine(self.vertices)            
         
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # si richiede il centro
      if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_CENTER_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il centro si richiede il raggio
      if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:         
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.centerPt)
      # si richiede il primo punto dello spigolo
      if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_FIRST_EDGE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # si richiede il secondo punto dello spigolo
      if self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.firstEdgePt)
class Qad_circle_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.centerPt = None
      self.radius = None
      self.firstPt = None
      self.secondPt = None
      self.firstDiamPt = None
      self.tan1 = None
      self.tan2 = None
      self.startPtForRadius = None
            
      self.__rubberBand = QadRubberBand(self.canvas, False)
      self.geomType = QGis.Polygon

   def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor):
      if rubberBandBorderColor is not None:
         self.__rubberBand.setBorderColor(rubberBandBorderColor)
      if rubberBandFillColor is not None:
         self.__rubberBand.setFillColor(rubberBandFillColor)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None
      
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()
         
      result = False
      circle = QadCircle()    
      
      # noto il centro del cerchio si richiede il raggio
      if self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
         radius = qad_utils.getDistance(self.centerPt, self.tmpPoint)
         circle.set(self.centerPt, radius)
         result = True
      # noto il centro del cerchio si richiede il diametro
      elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM:
         diam = qad_utils.getDistance(self.centerPt, self.tmpPoint)
         result = circle.set(self.centerPt, diam / 2)
         result = True
      # noto il primo e il secondo punto si richiede il terzo punto
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT:
         if (self.firstPt is not None) and (self.secondPt is not None):
            result = circle.from3Pts(self.firstPt, self.secondPt, self.tmpPoint)
      # noto il primo punto di estremità diam si richiede il secondo punto di estremità diam
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT:
         if self.firstDiamPt is not None:
            result = circle.fromDiamEnds(self.firstDiamPt, self.tmpPoint)
      # noto note la prima, la seconda entita dei punti di tangenza e il primo punto per misurare il raggio
      # si richiede il secondo punto per misurare il raggio
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS:
         radius = qad_utils.getDistance(self.startPtForRadius, self.tmpPoint)
         result = circle.from2TanPtsRadius(self.tanGeom1, self.tanPt1, \
                                           self.tanGeom2, self.tanPt2, radius)
      
      if result == True:
         points = circle.asPolyline()
      
         if points is not None:
            if self.geomType == QGis.Polygon:
               self.__rubberBand.setPolygon(points)
            else:
               self.__rubberBand.setLine(points)

                      
   def activate(self):
      QadGetPoint.activate(self)
      self.__rubberBand.show()


   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.mode = mode
      # noto niente si richiede il centro
      if self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto il centro del cerchio si richiede il raggio
      elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.centerPt)
      # noto il centro del cerchio si richiede il diametro
      elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM:
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.centerPt)
      # noto niente si richiede il primo punto
      elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # noto il primo punto si richiede il secondo punto
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # noto il primo e il secondo punto si richiede il terzo punto
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)         
      # noto niente si richiede il primo punto di estremità diam
      elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_DIAM_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)                 
      # noto il primo punto di estremità diam si richiede il secondo punto di estremità diam
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
      # noto niente si richiede l'entita del primo punto di tangenza
      elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_TAN:
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
         self.forceSnapTypeOnce(QadSnapTypeEnum.TAN_DEF)         
      # nota l'entita del primo punto di tangenza si richiede quella del secondo punto di tangenza
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_TAN:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
         self.forceSnapTypeOnce(QadSnapTypeEnum.TAN_DEF)         
      # note la prima e la seconda entita dei punti di tangenza si richiede il raggio
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_KNOWN_ASK_FOR_RADIUS:     
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         # siccome il puntatore era stato variato in ENTITY_SELECTION dalla selez precedente
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)         
      # noto note la prima, la seconda entita dei punti di tangenza e il primo punto per misurare il raggio
      # si richiede il secondo punto per misurare il raggio
      elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS:     
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.startPtForRadius)
예제 #24
0
class Qad_offset_maptool(QadGetPoint):
    
   def __init__(self, plugIn):
      QadGetPoint.__init__(self, plugIn)
                        
      self.firstPt = None
      self.layer = None
      self.subGeom = None
      self.offSet = 0
      self.lastOffSetOnLeftSide = 0
      self.lastOffSetOnRightSide = 0
      self.gapType = 0     
      self.__rubberBand = QadRubberBand(self.canvas)

   def hidePointMapToolMarkers(self):
      QadGetPoint.hidePointMapToolMarkers(self)
      self.__rubberBand.hide()

   def showPointMapToolMarkers(self):
      QadGetPoint.showPointMapToolMarkers(self)
      self.__rubberBand.show()
                             
   def clear(self):
      QadGetPoint.clear(self)
      self.__rubberBand.reset()
      self.mode = None    
   
   def addOffSetGeometries(self, newPt):
      self.__rubberBand.reset()            
            
      transformedPt = self.plugIn.canvas.mapRenderer().mapToLayerCoordinates(self.layer, newPt)
      
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(transformedPt, self.subGeom)
      if self.offSet < 0:
         afterVertex = dummy[2]
         pt = qad_utils.getPerpendicularPointOnInfinityLine(self.subGeom.vertexAt(afterVertex - 1), \
                                                            self.subGeom.vertexAt(afterVertex), \
                                                            transformedPt)
         offSetDistance = qad_utils.getDistance(transformedPt, pt)
      else:           
         offSetDistance = qad_utils.distMapToLayerCoordinates(self.offSet, \
                                                              self.plugIn.canvas,\
                                                              self.layer)
         if dummy[3] < 0: # alla sinistra
            offSetDistance = offSetDistance + self.lastOffSetOnLeftSide
         else: # alla destra
            offSetDistance = offSetDistance + self.lastOffSetOnRightSide         
      
      tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                  self.plugIn.canvas,\
                                                                  self.layer)
      epsg = self.layer.crs().authid()      
      lines = qad_utils.offSetPolyline(self.subGeom.asPolyline(), epsg, \
                                       offSetDistance, \
                                       "left" if dummy[3] < 0 else "right", \
                                       self.gapType, \
                                       tolerance2ApproxCurve)

      for line in lines:
         if self.layer.geometryType() == QGis.Polygon:
            if line[0] == line[-1]: # se é una linea chiusa
               offsetGeom = QgsGeometry.fromPolygon([line])
            else:
               offsetGeom = QgsGeometry.fromPolyline(line)
         else:
            offsetGeom = QgsGeometry.fromPolyline(line)

         self.__rubberBand.addGeometry(offsetGeom, self.layer)
            
      
   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      # nota la distanza di offset si richiede il punto per stabilire da che parte
      if self.mode == Qad_offset_maptool_ModeEnum.OFFSET_KNOWN_ASK_FOR_SIDE_PT:
         self.addOffSetGeometries(self.tmpPoint)                           
      # si richiede il punto di passaggio per stabilire da che parte e a quale offset
      elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT:
         self.addOffSetGeometries(self.tmpPoint)                           
         
    
   def activate(self):
      QadGetPoint.activate(self)            
      self.__rubberBand.show()          

   def deactivate(self):
      try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool !
         QadGetPoint.deactivate(self)
         self.__rubberBand.hide()
      except:
         pass

   def setMode(self, mode):
      self.clear()
      self.mode = mode
      # si richiede il primo punto per calcolo offset
      if self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_FIRST_OFFSET_PT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.onlyEditableLayers = False
      # noto il primo punto per calcolo offset si richiede il secondo punto
      if self.mode == Qad_offset_maptool_ModeEnum.FIRST_OFFSET_PT_KNOWN_ASK_FOR_SECOND_PT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
         self.setStartPoint(self.firstPt)
         self.onlyEditableLayers = False
      # nota la distanza di offset si richiede il punto per stabilire da che parte
      elif self.mode == Qad_offset_maptool_ModeEnum.OFFSET_KNOWN_ASK_FOR_SIDE_PT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.onlyEditableLayers = False
      # si richiede il punto di passaggio per stabilire da che parte e a quale offset
      elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT:
         self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.onlyEditableLayers = False
      # si richiede la selezione di un oggetto
      elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_ENTITY_SELECTION:
         self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
         # solo layer lineari o poligono editabili che non appartengano a quote
         layerList = []
         for layer in self.plugIn.canvas.layers():
            if layer.type() == QgsMapLayer.VectorLayer and \
               (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
               layer.isEditable():
               if len(self.plugIn.dimStyles.getDimListByLayer(layer)) == 0:
                  layerList.append(layer)
         
         self.layersToCheck = layerList
         self.setDrawMode(QadGetPointDrawModeEnum.NONE)
         self.onlyEditableLayers = True