Python QadRubberBand.setPolygon方法代码示例

# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import setPolygon [as 别名]
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)
#.........这里部分代码省略.........

# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import setPolygon [as 别名]
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)

# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import setPolygon [as 别名]
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)

# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import setPolygon [as 别名]

#.........这里部分代码省略.........
      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

# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import setPolygon [as 别名]
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)

#.........这里部分代码省略.........