Exemplo n.º 1
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_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)
Exemplo n.º 3
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)
Exemplo n.º 4
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)
Exemplo n.º 5
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_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)
Exemplo n.º 7
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
Exemplo n.º 8
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
Exemplo n.º 9
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)