def calcRwyBearing(self):
     try:
         point3dThr = self.parametersPanel.pnlThrPosition.Point3d
         point3dFap = self.parametersPanel.pnlFapPosition.Point3d
         if point3dThr == None:
             self.parametersPanel.pnlInboundTrack.Value = 0.0
             return
         if point3dFap == None:
             self.parametersPanel.pnlInboundTrack.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dThr, self.parametersPanel.pnlRwyEndPosition.Point3d)), 4)
             point3dFap = self.rwyEndPosition
         else:
             self.parametersPanel.pnlInboundTrack.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dFap, point3dThr)), 4)
         self.showMarkDaSoc()
     except:
         pass
    def calcRwyBearing(self):
        try:
            point3End = self.parametersPanel.pnlRwyEnd.Point3d
            point3dThr = self.parametersPanel.pnlTHR.Point3d

            self.parametersPanel.txtRwyDir.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dThr, point3End)), 4)
        except:
            pass
    def calcRwyBearing(self):
        try:
            point3End = self.thrEndPoint3d
            point3dThr = self.thrPoint3d

            self.parametersPanel.txtDirection.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dThr, point3End)), 4)
        except:
            pass
 def calcBearing(self):
     try:
         thrPoint = self.parametersPanel.pnlTHR.Point3d
         endPoint = self.parametersPanel.pnlEnd.Point3d
     except:
         return
     bearing = Unit.ConvertRadToDeg(MathHelper.getBearing(thrPoint, endPoint))
     self.parametersPanel.txtDirection.Value = bearing
 def calcRwyBearing(self):
     try:
         point3dMapt = self.parametersPanel.pnlMaPtPosition.Point3d
         point3dFaf = self.parametersPanel.pnlFafPosition.Point3d
         if point3dMapt == None:
             self.parametersPanel.pnlInboundTrack.Value = 0.0
             return
         self.parametersPanel.pnlInboundTrack.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dFaf, point3dMapt)), 4)
         self.showMarkDaSoc()
     except:
         pass
    def otherBearingCalc(self, basicAngle, basicUnit):
        positionPanelOfParent = None
        existPositionPanelValid = False
        if len(self.parentP.findChildren(PositionPanel)) > 0:
            for pnl in self.parentP.findChildren(PositionPanel):
                if pnl.IsValid():
                    positionPanelOfParent = pnl
                    existPositionPanelValid = True
                    break
        basicBearing = Unit.ConvertDegToRad(basicAngle)
        unit = positionPanelOfParent.getUnit()
        basicPoint3d = None
        if existPositionPanelValid:
            basicPoint3d = positionPanelOfParent.Point3d
        else:
            if basicUnit == QGis.Meters:
                basicPoint3d = Point3D(656565, 6565656)
            else:
                basicPoint3d = Point3D(17, 59)

        resultBearing = None
        if unit == None:
            return
        elif unit == QGis.Meters:
            if basicUnit == QGis.Meters:
                point3dStart = basicPoint3d
                point3dEnd = MathHelper.distanceBearingPoint(
                    point3dStart, basicBearing, 500, QGis.Meters)
                point3dStartGeo = MathHelper.CrsTransformPoint(
                    point3dStart.get_X(), point3dStart.get_Y(), define._xyCrs,
                    define._latLonCrs, point3dStart.get_Z())
                point3dEndGeo = MathHelper.CrsTransformPoint(
                    point3dEnd.get_X(), point3dEnd.get_Y(), define._xyCrs,
                    define._latLonCrs, point3dEnd.get_Z())
                resultBearing = MathHelper.getBearing(point3dStartGeo,
                                                      point3dEndGeo,
                                                      QGis.DecimalDegrees)
            else:
                point3dStart = basicPoint3d
                point3dStartGeo = MathHelper.CrsTransformPoint(
                    point3dStart.get_X(), point3dStart.get_Y(), define._xyCrs,
                    define._latLonCrs, point3dStart.get_Z())

                point3dEndGeo = MathHelper.distanceBearingPoint(
                    point3dStartGeo, basicBearing, 500, QGis.DecimalDegrees)
                point3dEnd = MathHelper.CrsTransformPoint(
                    point3dEndGeo.get_X(), point3dEndGeo.get_Y(),
                    define._latLonCrs, define._xyCrs, point3dEndGeo.get_Z())
                resultBearing = MathHelper.getBearing(point3dStart, point3dEnd,
                                                      QGis.Meters)
        else:
            if basicUnit == QGis.Meters:
                point3dStartGeo = basicPoint3d
                point3dStart = MathHelper.CrsTransformPoint(
                    point3dStartGeo.get_X(), point3dStartGeo.get_Y(),
                    define._latLonCrs, define._xyCrs, point3dStartGeo.get_Z())

                point3dEnd = MathHelper.distanceBearingPoint(
                    point3dStart, basicBearing, 500, QGis.Meters)
                point3dEndGeo = MathHelper.CrsTransformPoint(
                    point3dEnd.get_X(), point3dEnd.get_Y(), define._xyCrs,
                    define._latLonCrs, point3dEnd.get_Z())
                resultBearing = MathHelper.getBearing(point3dStartGeo,
                                                      point3dEndGeo,
                                                      QGis.DecimalDegrees)
            else:
                point3dStartGeo = basicPoint3d
                point3dEndGeo = MathHelper.distanceBearingPoint(
                    point3dStartGeo, basicBearing, 500, QGis.DecimalDegrees)

                point3dStart = MathHelper.CrsTransformPoint(
                    point3dStartGeo.get_X(), point3dStartGeo.get_Y(),
                    define._latLonCrs, define._xyCrs, point3dStartGeo.get_Z())
                point3dEnd = MathHelper.CrsTransformPoint(
                    point3dEndGeo.get_X(), point3dEndGeo.get_Y(),
                    define._latLonCrs, define._xyCrs, point3dEndGeo.get_Z())
                resultBearing = MathHelper.getBearing(point3dStart, point3dEnd,
                                                      QGis.Meters)
        return Unit.ConvertRadToDeg(resultBearing)
    def canvasPressEvent(self, e):
        #self.isEmittingPoint = True
        self.rubberBandPt.reset(QGis.Point)
        snapPoint = QgisHelper.snapPoint(e.pos(), self.mSnapper,
                                         define._canvas, True)
        if self.isDrawing == False:
            if snapPoint == None:
                self.startPoint = self.toMapCoordinates(e.pos())
            else:
                self.startPoint = snapPoint
            self.isDrawing = True
        else:
            self.isDrawing = False
            if snapPoint == None:
                self.endPoint = self.toMapCoordinates(e.pos())
            else:
                self.endPoint = snapPoint
            self.drawLine()
            self.reset()
            startPointPlan = None
            endPointPlan = None
            startPointGeodetic = None
            endPointGeodetic = None
            unitDefault = None
            try:
                if self.txtBearingGeodetic == None:
                    startPointPlan = self.startPoint
                    endPointPlan = self.endPoint
                else:
                    if define._units == QGis.Meters:
                        startPointPlan = self.startPoint
                        endPointPlan = self.endPoint

                        startPointGeodetic = QgisHelper.CrsTransformPoint(
                            startPointPlan.x(), startPointPlan.y(),
                            define._xyCrs, define._latLonCrs)
                        endPointGeodetic = QgisHelper.CrsTransformPoint(
                            endPointPlan.x(), endPointPlan.y(), define._xyCrs,
                            define._latLonCrs)

                    else:
                        startPointGeodetic = self.startPoint
                        endPointGeodetic = self.endPoint

                        startPointPlan = QgisHelper.CrsTransformPoint(
                            startPointGeodetic.x(), startPointGeodetic.y(),
                            define._latLonCrs, define._xyCrs)
                        endPointPlan = QgisHelper.CrsTransformPoint(
                            endPointGeodetic.x(), endPointGeodetic.y(),
                            define._latLonCrs, define._xyCrs)
                    unitDefault = QGis.Meters

                pass
            except:
                return

            if isinstance(self.txtBearing, NumberBoxPanel):
                al = MathHelper.getBearing(startPointPlan, endPointPlan,
                                           unitDefault)
                al = Unit.ConvertRadToDeg(al)
                self.txtBearing.Value = round(al, 4)
            else:
                al = MathHelper.getBearing(startPointPlan, endPointPlan,
                                           unitDefault)
                al = Unit.ConvertRadToDeg(al)
                self.txtBearing.setText(str(round(al, 4)))

            if self.txtBearingGeodetic != None:
                al = MathHelper.getBearing(startPointGeodetic,
                                           endPointGeodetic,
                                           QGis.DecimalDegrees)
                al = Unit.ConvertRadToDeg(al)
                self.txtBearingGeodetic.Value = round(al, 4)