Python qad_utils.getAngleBy2Pts函数代码示例

 def canvasMoveEvent(self, event):
    QadGetPoint.canvasMoveEvent(self, event)
    
    self.__rubberBand.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)

    def fromStartEndPtsTan(self, startPt, endPt, tan):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      direzione della tangente sul punto iniziale
      """
        if startPt == endPt:
            return False

        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        if tan == angleSegment or tan == angleSegment - math.pi:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        angle = tan + (math.pi / 2)
        angle = angleSegment - angle
        distFromCenter = math.tan(angle) * half_chord
        self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment - (math.pi / 2), distFromCenter)
        pt = qad_utils.getPolarPointByPtAngle(startPt, tan, chord)

        if qad_utils.leftOfLine(endPt, startPt, pt) < 0:
            # arco si sviluppa a sinistra della tangente
            self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
            self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        else:
            # arco si sviluppa a destra della tangente
            self.startAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
            self.endAngle = qad_utils.getAngleBy2Pts(self.center, startPt)

        self.radius = qad_utils.getDistance(startPt, self.center)
        return True

    def fromStartEndPtsRadius(self, startPt, endPt, radius):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      raggio
      """
        if startPt == endPt or radius <= 0:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        if radius < half_chord:
            return False

        self.radius = radius
        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        # Pitagora
        distFromCenter = math.sqrt((self.radius * self.radius) - (half_chord * half_chord))
        # aggiungo 90 gradi
        self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment + (math.pi / 2), distFromCenter)
        self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        return True

    def fromStartEndPtsAngle(self, startPt, endPt, angle):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      angolo inscritto
      """
        if startPt == endPt or angle == 0:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        # Teorema della corda
        self.radius = half_chord / math.sin(angle / 2)

        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        # Pitagora
        distFromCenter = math.sqrt((self.radius * self.radius) - (half_chord * half_chord))
        if angle < math.pi:  # se angolo < 180 gradi
            # aggiungo 90 gradi per cercare il centro a sinistra del segmento
            self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment + (math.pi / 2), distFromCenter)
        else:
            # sottraggo 90 gradi per cercare il centro a destra del segmento
            self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment - (math.pi / 2), distFromCenter)
        self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        return True

    def fromStartCenterEndPts(self, startPt, centerPt, endPt):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      punto finale
      """
        if startPt == centerPt or startPt == endPt or endPt == centerPt:
            return False

        self.center = centerPt
        self.radius = qad_utils.getDistance(centerPt, startPt)
        self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(centerPt, endPt)
        return True

 def isPtOnArc(self, point):
     dist = qad_utils.getDistance(self.center, point)
     if qad_utils.doubleNear(self.radius, dist):
         angle = qad_utils.getAngleBy2Pts(self.center, point)
         return qad_utils.isAngleBetweenAngles(self.startAngle, self.endAngle, angle)
     else:
         return False

def arrayPolarEntity(plugIn, ent, basePt, centerPt, itemsNumber, angleBetween, rows, distanceBetweenRows, itemsRotation, \
                     addToLayer, highlightObj):
   """
   serie polare
   ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
   basePt = punto base in map coordinate (QgsPoint)
   centerPt = punto centrale in map coordinate (QgsPoint)
   itemsNumber = numero di copie da fare
   angleBetween = angolo tra un elemento e l'altro (radianti)
   rows = numero di righe
   distanceBetweenRows = distanza tra le righe in map coordinate
   itemsRotation = True se si vuole ruotare gli elementi intorno al cerchio
   addToLayer = se è True aggiunge le nuove entità al layer
   highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
   """
   g = None
   coordTransform = None
   f = None
   if ent.whatIs() == "ENTITY":
      f = ent.getFeature()
      # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
      CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # CRS corrente
      coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
      g = f.geometry()
      g.transform(coordTransform)
      coordTransform = QgsCoordinateTransform(CRS, ent.crs())

      rotFldName = ""
      if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
         # se la rotazione dipende da un solo campo
         rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
         if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
            rotFldName = rotFldNames[0]         
      elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
         rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)

   firstAngle = qad_utils.getAngleBy2Pts(centerPt, basePt)
   dist = qad_utils.getDistance(centerPt, basePt)
   for row in range(0, rows):
      angle = firstAngle
      for i in range(0, itemsNumber):
         newBasePt = qad_utils.getPolarPointByPtAngle(centerPt, angle, dist)
         offSetX = newBasePt.x() - basePt.x()
         offSetY = newBasePt.y() - basePt.y()
      
         if g is not None: # se l'entità non è una quotatura
            if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
                                   i * angleBetween if itemsRotation else None, rotFldName, \
                                   newBasePt, coordTransform, addToLayer, highlightObj) == False:
               return False
         else: # se l'entità è una quotatura
            if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
                                        i * angleBetween if itemsRotation else None, \
                                        newBasePt, addToLayer, highlightObj) == False:
               return False
         angle = angle + angleBetween 

      dist = dist + distanceBetweenRows

   return True

 def setEndAngleByPt(self, pt):
     # da usare per modificare un arco già definito
     angle = qad_utils.getAngleBy2Pts(self.center, pt)
     if angle == self.startAngle:
         return False
     else:
         self.endAngle = angle
         return True

 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_rotate_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_ROTATION_PT:
       angle = qad_utils.getAngleBy2Pts(self.basePt, self.tmpPoint)
       self.addRotatedGeometries(angle)                           
    # noto il punto base si richiede il secondo punto per il nuovo angolo
    elif self.mode == Qad_rotate_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_ROTATION_PT:
       angle = qad_utils.getAngleBy2Pts(self.basePt, self.tmpPoint)
       diffAngle = angle - self.ReferenceAng
       self.addRotatedGeometries(diffAngle)                           
    # noto il primo punto si richiede il secondo punto per il nuovo angolo
    elif self.mode == Qad_rotate_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_ROTATION_PT:
       angle = qad_utils.getAngleBy2Pts(self.Pt1NewAng, self.tmpPoint)
       diffAngle = angle - self.ReferenceAng
       self.addRotatedGeometries(diffAngle)                           

   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":
               if self.OpType == "length":
                  res = self.tmpLinearObjectList.lengthen_delta(self.move_startPt, self.value)
               elif self.OpType == "Angle":
                  res = self.tmpLinearObjectList.lengthen_deltaAngle(self.move_startPt, self.value)
            elif self.OpMode == "Percent":
               value = self.tmpLinearObjectList.length() * self.value / 100
               value = value - self.tmpLinearObjectList.length()
               res = self.tmpLinearObjectList.lengthen_delta(self.move_startPt, value)
            elif self.OpMode == "Total":
               if self.OpType == "length":
                  value = self.value - self.tmpLinearObjectList.length()
                  res = self.tmpLinearObjectList.lengthen_delta(self.move_startPt, value)
               elif self.OpType == "Angle":                     
                  if self.tmpLinearObjectList.qty() == 1:
                     linearObject = self.tmpLinearObjectList.getLinearObjectAt(0)
                     if linearObject.isArc() == True: # se è un arco
                        value = self.value - linearObject.getArc().totalAngle()
                        res = self.tmpLinearObjectList.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:
         if self.tmpLinearObjectList.qty() == 1:
            transformedPt = self.canvas.mapRenderer().mapToLayerCoordinates(self.layer, self.tmpPoint)
            
            linearObject = self.tmpLinearObjectList.getLinearObjectAt(0)
            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 self.move_startPt:
               linearObject.setStartPt(newPt)
            else:
               linearObject.setEndPt(newPt)
            res = True
      

      if res == False: # allungamento impossibile
         return
      pts = self.tmpLinearObjectList.asPolyline()
      geom = QgsGeometry.fromPolyline(pts)
      self.__rubberBand.addGeometry(geom, self.layer)

    def fromStartPtAngleRadiusChordDirection(self, startPt, angle, radius, chordDirection):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      angolo inscritto
      raggio
      direzione della corda
      """
        if angle == 0 or angle == 2 * math.pi or radius <= 0:
            return False

        a = chordDirection + (math.pi / 2) - (angle / 2)
        self.radius = radius
        self.center = qad_utils.getPolarPointByPtAngle(startPt, a, radius)
        endPt = qad_utils.getPolarPointByPtAngle(self.center, a + math.pi + angle, radius)

        self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        return True

    def getPerpendicularPoints(self, point):
        result = []
        angle = qad_utils.getAngleBy2Pts(self.center, point)
        if qad_utils.isAngleBetweenAngles(self.startAngle, self.endAngle, angle) == True:
            result.append(qad_utils.getPolarPointByPtAngle(self.center, angle, self.radius))

        angle = angle + math.pi
        if qad_utils.isAngleBetweenAngles(self.startAngle, self.endAngle, angle) == True:
            result.append(qad_utils.getPolarPointByPtAngle(self.center, angle, self.radius))

        return result

   def mirror(self, entity, pt1, pt2, rotFldName):
      # entity = entità da specchiare
      # pt1 e pt2 = linea di simmetria
      # rotFldName = campo della tabella che memorizza la rotazione
      # verifico se l'entità appartiene ad uno stile di quotatura
      if entity.whatIs() == "ENTITY":
         f = entity.getFeature()
         # specchio l'entità
         f.setGeometry(qad_utils.mirrorQgsGeometry(entity.getGeometry(), pt1, pt2))
         if len(rotFldName) > 0:
            rotValue = f.attribute(rotFldName)
            # a volte vale None e a volte null (vai a capire...)
            rotValue = 0 if rotValue is None or isinstance(rotValue, QPyNullVariant) else qad_utils.toRadians(rotValue) # la rotazione é in gradi nel campo della feature
            ptDummy = qad_utils.getPolarPointByPtAngle(pt1, rotValue, 1)
            mirrorAngle = qad_utils.getAngleBy2Pts(pt1, pt2)
            ptDummy = qad_utils.mirrorPoint(ptDummy, pt1, mirrorAngle)
            rotValue = qad_utils.getAngleBy2Pts(pt1, ptDummy)
            f.setAttribute(rotFldName, qad_utils.toDegrees(qad_utils.normalizeAngle(rotValue)))               
                  
         if self.copyEntities == False:
            # plugIn, layer, feature, refresh, check_validity
            if qad_layer.updateFeatureToLayer(self.plugIn, entity.layer, f, False, False) == False:
               return False
         else:             
            # plugIn, layer, features, coordTransform, refresh, check_validity
            if qad_layer.addFeatureToLayer(self.plugIn, entity.layer, f, None, False, False) == False:
               return False
      elif entity.whatIs() == "DIMENTITY":
         mirrorAngle = qad_utils.getAngleBy2Pts(pt1, pt2)
         # specchio la quota
         if self.copyEntities == False:
            if entity.deleteToLayers(self.plugIn) == False:
               return False
            
         newDimEntity = QadDimEntity(entity) # la copio
         newDimEntity.mirror(pt1, mirrorAngle)
         if newDimEntity.addToLayers(self.plugIn) == False:
            return False             

      return True

    def getTanPoints(self, point):
        result = []

        circle = QadCircle()
        circle.set(self.center, self.radius)
        points = circle.getTanPoints(point)
        tot = len(points)
        for p in points:
            angle = qad_utils.getAngleBy2Pts(self.center, p)
            if qad_utils.isAngleBetweenAngles(self.startAngle, self.endAngle, angle) == True:
                result.append(p)

        return result

    def fromStartCenterPtsAngle(self, startPt, centerPt, angle):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      angolo inscritto
      """
        if startPt == centerPt or angle == 0:
            return False

        self.center = centerPt
        self.radius = qad_utils.getDistance(centerPt, startPt)
        self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
        self.endAngle = self.startAngle + angle
        if self.endAngle > math.pi * 2:
            self.endAngle = self.endAngle % (math.pi * 2)  # modulo
        return True