def getContactWithBearingOfTangent(self, bearingOfContact, spiralNumber = None, turnDirection = None):
if spiralNumber == None:
contactPt = self.method_0(bearingOfContact, AngleUnits.Radians)
if round(self.Radius[0], 2) == round(MathHelper.calcDistance(self.Center[0], contactPt), 2):
centerPt = self.Center[0]
spiralNumber = 0
elif round(self.Radius[1], 2) == round(MathHelper.calcDistance(self.Center[1], contactPt), 2):
centerPt = self.Center[1]
spiralNumber = 1
else:
centerPt = self.Center[2]
spiralNumber = 2
bearing = MathHelper.getBearing(centerPt, contactPt)
if self.Direction == TurnDirection.Right:
leftMiddlePt = MathHelper.distanceBearingPoint(centerPt, MathHelper.smethod_4(bearing - 0.01), self.Radius[spiralNumber])
rightMiddlePt = MathHelper.distanceBearingPoint(centerPt, MathHelper.smethod_4(bearing + 0.01), self.Radius[spiralNumber])
return leftMiddlePt, contactPt, rightMiddlePt
else:
rightMiddlePt = MathHelper.distanceBearingPoint(centerPt, MathHelper.smethod_4(bearing + 0.01), self.Radius[spiralNumber])
leftMiddlePt = MathHelper.distanceBearingPoint(centerPt, MathHelper.smethod_4(bearing - 0.01), self.Radius[spiralNumber])
return leftMiddlePt, contactPt, rightMiddlePt
if self.Direction == TurnDirection.Right:
bearing = MathHelper.smethod_4(bearingOfContact - math.pi /2)
contactPt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], bearing, self.Radius[spiralNumber])
leftMiddlePt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], MathHelper.smethod_4(bearing - 0.01), self.Radius[spiralNumber])
rightMiddlePt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], MathHelper.smethod_4(bearing + 0.01), self.Radius[spiralNumber])
return leftMiddlePt, contactPt, rightMiddlePt
else:
bearing = MathHelper.smethod_4(bearingOfContact + math.pi /2)
contactPt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], bearing, self.Radius[spiralNumber])
rightMiddlePt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], MathHelper.smethod_4(bearing + 0.01), self.Radius[spiralNumber])
leftMiddlePt = MathHelper.distanceBearingPoint(self.Center[spiralNumber], MathHelper.smethod_4(bearing - 0.01), self.Radius[spiralNumber])
return leftMiddlePt, contactPt, rightMiddlePt
def nominal2Layer(self):
resultLayer = AcadHelper.createVectorLayer(
"NominalTrack_" +
self.surfaceType.replace(" ", "_").replace("-", "_"), QGis.Line)
startPoint3d = self.parametersPanel.pnlRwyStart.Point3d
derPoint3d = self.parametersPanel.pnlDer.Point3d
bearing = MathHelper.getBearing(startPoint3d, derPoint3d)
derPoint3d1 = MathHelper.distanceBearingPoint(derPoint3d, bearing, 100)
derPoint3d2 = MathHelper.distanceBearingPoint(derPoint3d, bearing,
self.circleArea[0].bulge)
geom = QgsGeometry.fromPolyline(self.area123).intersection(
QgsGeometry.fromPolyline([derPoint3d1, derPoint3d2]))
intersectionPoint1 = geom.asPoint()
derPoint3d1 = MathHelper.distanceBearingPoint(derPoint3d, bearing, 100)
bearing = MathHelper.smethod_4(bearing + math.pi)
derPoint3d2 = MathHelper.distanceBearingPoint(
derPoint3d, bearing,
MathHelper.calcDistance(derPoint3d, startPoint3d) + 200)
geom = QgsGeometry.fromPolyline(
PolylineArea(self.area123).method_14_closed()).intersection(
QgsGeometry.fromPolyline([derPoint3d1, derPoint3d2]))
intersectionPoint2 = geom.asPoint()
AcadHelper.setGeometryAndAttributesInLayer(
resultLayer, [intersectionPoint1, derPoint3d])
return resultLayer
def getContact(self,
point3d,
radBetweenTangentAndPoint=None,
spiralNumber=None,
turnDirection=None):
a = MathHelper.calcDistance(point3d, self.Center[spiralNumber])
b = MathHelper.calcDistance(self.Center[spiralNumber],
self.Finish[spiralNumber])
A = math.pi / 2 - radBetweenTangentAndPoint
B = math.asin(math.sin(A) * b / a)
C = math.pi - A - B
bearing = 0.0
middlePt = Point3D()
if self.Direction == TurnDirection.Right:
bearing = MathHelper.smethod_4(
MathHelper.getBearing(self.Center[spiralNumber], point3d) - C)
middlePt = MathHelper.distanceBearingPoint(
self.Center[spiralNumber],
MathHelper.smethod_4(bearing - 0.001),
self.Radius[spiralNumber])
elif self.Direction == TurnDirection.Left:
bearing = MathHelper.smethod_4(
MathHelper.getBearing(self.Center[spiralNumber], point3d) + C)
middlePt = MathHelper.distanceBearingPoint(
self.Center[spiralNumber],
MathHelper.smethod_4(bearing + 0.001),
self.Radius[spiralNumber])
return middlePt, MathHelper.distanceBearingPoint(
self.Center[spiralNumber], bearing, self.Radius[0])
def method_37(self, point3d_0, double_0, point3d_1, point3d_2, double_1, ficorInput_0):
point3d = None;
point3d = MathHelper.getIntersectionPoint(point3d_1, point3d_2, point3d_0, MathHelper.distanceBearingPoint(point3d_0, double_0 + Unit.ConvertDegToRad(90), 100))
if (point3d != None):
num = MathHelper.getBearing(point3d_0, point3d);
num1 = MathHelper.calcDistance(point3d_0, point3d);
if (num1 <= double_1):
num2 = math.acos(num1 / double_1);
point3d1 = MathHelper.distanceBearingPoint(point3d_0, num + num2, double_1);
point3d2 = MathHelper.distanceBearingPoint(point3d_0, num - num2, double_1);
if (ficorInput_0 == FicorInput.C):
if (MathHelper.smethod_99(MathHelper.getBearing(point3d_1, point3d2), MathHelper.getBearing(point3d_1, point3d1), 0.1)):
return FicorResult(FicorStatus.TWO);
return FicorResult(FicorStatus.ONE);
if (ficorInput_0 == FicorInput.F):
if (MathHelper.smethod_99(MathHelper.getBearing(point3d_1, point3d_2), MathHelper.getBearing(point3d_1, point3d1), 0.1)):
return FicorResult(point3d1);
return FicorResult(point3d2);
if (ficorInput_0 == FicorInput.L):
if (MathHelper.calcDistance(point3d_1, point3d2) < MathHelper.calcDistance(point3d_1, point3d1)):
return FicorResult(point3d1);
return FicorResult(point3d2);
if (ficorInput_0 == FicorInput.S):
if (MathHelper.calcDistance(point3d_1, point3d2) > MathHelper.calcDistance(point3d_1, point3d1)):
return FicorResult(point3d1);
return FicorResult(point3d2);
return FicorResult(None, FicorStatus.NID);
def method_3(self, polylineArea_0):
point3dCollection = self.area.method_14_closed(4)
polylineArea0 = PolylineArea(point3dCollection)
num = MathHelper.calcDistance(self.ptBase, polylineArea_0[0].Position)
num1 = self.trackRad
point3d = MathHelper.distanceBearingPoint(self.ptBase, num1, num)
matrix = Matrix3d.Displacement(self.ptE.GetVectorTo(point3d))
polylineArea = polylineArea0.TransformBy(matrix)
polylineAreaList = []
polylineAreaList.append(polylineArea)
# Region transformedCopy = region1.GetTransformedCopy(Matrix3d.Displacement(self.ptE.GetVectorTo(point3d))) as Region;
for i in range(1, 72):
point3d = MathHelper.distanceBearingPoint(
self.ptBase, num1 + i * 0.0872664625997165, num)
polylineArea = polylineArea0.TransformBy(
Matrix3d.Displacement(self.ptE.GetVectorTo(point3d)))
polylineAreaList.append(polylineArea)
# Region transformedCopy1 = region1.GetTransformedCopy(Matrix3d.Displacement(self.ptE.GetVectorTo(point3d))) as Region;
# try
# {
# transformedCopy.BooleanOperation(0, transformedCopy1);
# }
# finally
# {
# AcadHelper.smethod_24(transformedCopy1);
# }
# }
# region = transformedCopy;
# }
# finally
# {
# AcadHelper.smethod_24(region1);
# }
return polylineAreaList
def smethod_131(polylineArea_0):
polylineArea = PolylineArea()
if (not polylineArea_0.isCircle):
for i in range(len(polylineArea_0)):
item = polylineArea_0[i]
x = item.Position.get_X()
position = item.Position
polylineArea.Add(item)
else:
point3d = MathHelper.distanceBearingPoint(
polylineArea_0.CenterPoint(), 0, polylineArea_0.Radius())
point3d1 = MathHelper.distanceBearingPoint(
polylineArea_0.CenterPoint(), 1.5707963267949,
polylineArea_0.Radius())
point3d2 = MathHelper.distanceBearingPoint(
polylineArea_0.CenterPoint(), 3.14159265358979,
polylineArea_0.Radius())
point3d3 = MathHelper.distanceBearingPoint(
polylineArea_0.CenterPoint(), 4.71238898038469,
polylineArea_0.Radius())
polylineArea.Add(
PolylineAreaPoint(
point3d, MathHelper.smethod_60(point3d, point3d1,
point3d2)))
polylineArea.Add(
PolylineAreaPoint(
point3d2, MathHelper.smethod_60(point3d2, point3d3,
point3d)))
polylineArea.Add(PolylineAreaPoint(point3d))
return polylineArea
def method_2(self, point3d_0, double_0):
self.tr = double_0
self.tr180 = MathHelper.smethod_4(double_0 + 3.14159265358979)
self.trm90 = MathHelper.smethod_4(double_0 - 1.5707963267949)
self.trp90 = MathHelper.smethod_4(double_0 + 1.5707963267949)
self.ptTHR = point3d_0
self.ptEND = MathHelper.distanceBearingPoint(self.ptTHR, self.tr, 1000)
self.ptTHRm90 = MathHelper.distanceBearingPoint(
self.ptTHR, self.trm90, 1000)
def getPointWithShortestDist(self, point3d, closed=True):
if self.Count == 0:
return None
if closed:
point3dList = self.method_14_closed()
else:
point3dList = self.method_14()
# i = 0
# for point3d0 in point3dList:
# if i == 0:
# i += 1
# continue
# previousPoint = point3dList[i - 1]
# currentPoint = point3d0
# f = QgsGeometry.fromPolyline([previousPoint, currentPoint]).contains(point3d)
# if f:
# return point3d
i = 0
for point3d0 in point3dList:
if i == 0:
i += 1
continue
previousPoint = point3dList[i - 1]
currentPoint = point3d0
f = QgsGeometry.fromPolyline([previousPoint,
currentPoint]).contains(point3d)
dist = MathHelper.calcDistance(point3d, previousPoint)
bearing = MathHelper.smethod_4(
MathHelper.getBearing(previousPoint, currentPoint) -
math.pi / 2)
vPoint1 = MathHelper.distanceBearingPoint(point3d, bearing, dist)
bearing = MathHelper.smethod_4(
MathHelper.getBearing(previousPoint, currentPoint) +
math.pi / 2)
dist = MathHelper.calcDistance(point3d, previousPoint)
vPoint2 = MathHelper.distanceBearingPoint(point3d, bearing, dist)
geom = QgsGeometry.fromPolyline([
previousPoint, currentPoint
]).intersection(QgsGeometry.fromPolyline([vPoint1, vPoint2]))
intersectionPoint = geom.asPoint()
if intersectionPoint.x() == 0 and intersectionPoint.y() == 0:
i += 1
continue
pt = None
if point3d.x() > intersectionPoint.x():
pt = Point3D(intersectionPoint.x() + 1, intersectionPoint.y())
else:
pt = Point3D(intersectionPoint.x() - 1, intersectionPoint.y())
geom = QgsGeometry.fromPolyline(point3dList).intersection(
QgsGeometry.fromPolyline([point3d, pt]))
intersectionPoint1 = geom.asPoint()
if intersectionPoint1.x() != 0 and intersectionPoint1.y() != 0:
i += 1
continue
return Point3D(intersectionPoint.x(), intersectionPoint.y())
return self.getClosestPointTo(point3d, False)
def method_1(self, obstacle_0):
point3d1 = MathHelper.distanceBearingPoint(obstacle_0.Position,
self.tr180,
obstacle_0.tolerance)
point3d = MathHelper.getIntersectionPoint(
self.ptTHR, self.ptEND, point3d1,
MathHelper.distanceBearingPoint(point3d1, self.trm90, 100))
num = MathHelper.calcDistance(self.ptTHR, point3d)
if (MathHelper.smethod_119(point3d, self.ptTHR, self.ptTHRm90)):
num = num * -1
return num
def initModel(self, surfacesList, oasCategory_0, point3d_0, double_0, double_1, double_2, oasMaEvaluationMethod_0, hlAltitude):
self.cat = oasCategory_0;
self.ptTHR = point3d_0;
self.ptTHR2 = MathHelper.distanceBearingPoint(point3d_0, double_0, 100);
self.ptTHRm90 = MathHelper.distanceBearingPoint(point3d_0, double_0 - 1.5707963267949, 100);
self.tr90p = double_0 + 1.5707963267949;
self.tanmacg = double_1 / 100.0;
self.tangpa = math.tan(Unit.ConvertDegToRad(double_2));
self.method = oasMaEvaluationMethod_0;
self.xe = OasObstacles.constants.ZC / OasObstacles.constants.ZA
self.surfacesList = surfacesList
self.hlAltitude = hlAltitude
def makePrimaryAreaOrSecondaryArea(self, geomList, areaType):
pointArrayInner = geomList[0]
pointArray1Outer = geomList[1]
innerStartPoint = pointArrayInner[0]
innerEndPoint = pointArrayInner[1]
innerBulge = pointArrayInner[2]
outerStartPoint = pointArray1Outer[0]
outerEndPoint = pointArray1Outer[1]
outerBulge = pointArray1Outer[2]
line0 = QgsGeometry.fromPolyline([innerStartPoint, outerStartPoint])
line1 = QgsGeometry.fromPolyline([innerEndPoint, outerEndPoint])
# for i in range(1, len(pointArray0)):
if line0.intersects(line1):
tempPoint = Point3D(outerStartPoint.get_X(), outerStartPoint.get_Y())
outerStartPoint = Point3D(outerEndPoint.get_X(), outerEndPoint.get_Y())
outerEndPoint = Point3D(tempPoint.get_X(), tempPoint.get_Y())
outerBulge = -outerBulge
if areaType == ProtectionAreaType.Primary:
polylineArea = PolylineArea()
polylineArea.Add(PolylineAreaPoint(innerStartPoint, innerBulge))
polylineArea.Add(PolylineAreaPoint(innerEndPoint))
polylineArea.Add(PolylineAreaPoint(outerEndPoint, -outerBulge))
polylineArea.Add(PolylineAreaPoint(outerStartPoint))
return PrimaryObstacleArea(polylineArea)
elif areaType == ProtectionAreaType.Secondary:
if innerBulge == 0 and outerBulge == 0:
return SecondaryObstacleArea(innerStartPoint, innerEndPoint, outerStartPoint, outerEndPoint, MathHelper.getBearing(innerStartPoint, innerEndPoint))
elif innerBulge != 0 and outerBulge != 0:
if round(innerBulge, 1) != round(outerBulge, 1):
return None
innerCenterPoint = MathHelper.smethod_71(innerStartPoint, innerEndPoint, innerBulge)
outerCenterPoint = MathHelper.smethod_71(outerStartPoint, outerEndPoint, outerBulge)
innerRadius = MathHelper.calcDistance(innerCenterPoint, innerStartPoint);
outerRadius = MathHelper.calcDistance(outerCenterPoint, outerStartPoint);
bearing = (MathHelper.getBearing(innerCenterPoint, innerStartPoint) + MathHelper.getBearing(innerCenterPoint, innerEndPoint)) / 2
innerMiddlePoint = MathHelper.distanceBearingPoint(innerCenterPoint, bearing, innerRadius)
if round(MathHelper.smethod_60(innerStartPoint, innerMiddlePoint, innerEndPoint), 4) != round(outerBulge, 4):
bearing += 3.14159265358979
innerMiddlePoint = MathHelper.distanceBearingPoint(innerCenterPoint, bearing, innerRadius)
bearing = (MathHelper.getBearing(outerCenterPoint, outerStartPoint) + MathHelper.getBearing(outerCenterPoint, outerEndPoint)) / 2
outerMiddlePoint = MathHelper.distanceBearingPoint(outerCenterPoint, bearing, outerRadius)
if round(MathHelper.smethod_60(outerStartPoint, outerMiddlePoint, outerEndPoint), 4) != round(outerBulge, 4):
bearing += 3.14159265358979
outerMiddlePoint = MathHelper.distanceBearingPoint(outerCenterPoint, bearing, outerRadius)
return SecondaryObstacleArea(innerStartPoint, innerMiddlePoint, innerEndPoint, outerStartPoint, None, outerMiddlePoint, outerEndPoint, innerBulge, innerBulge)
return None
def getGeometry(self):
pointList = []
polygonsList = []
width = self[0].startWidth
if MathHelper.smethod_96(self[0].bulge):
pt0 = MathHelper.distanceBearingPoint(self[0].point3d, MathHelper.getBearing(self[0].point3d, self[1].point3d) - Unit.ConvertDegToRad(90), width / 2.0,)
pt1 = MathHelper.distanceBearingPoint(self[0].point3d, MathHelper.getBearing(self[0].point3d, self[1].point3d) + Unit.ConvertDegToRad(90), width / 2.0,)
pt2 = MathHelper.distanceBearingPoint(self[1].point3d, MathHelper.getBearing(self[0].point3d, self[1].point3d) + Unit.ConvertDegToRad(90), width / 2.0,)
pt3 = MathHelper.distanceBearingPoint(self[1].point3d, MathHelper.getBearing(self[0].point3d, self[1].point3d) - Unit.ConvertDegToRad(90), width / 2.0,)
geom = QgsGeometry.fromPolygon([[pt0, pt1, pt2, pt3]])
polygonsList.append(geom)
else:
polylineArea = PolylineArea()
polylineArea.Add(PolylineAreaPoint(self[0].point3d, self[0].bulge))
polylineArea.Add(PolylineAreaPoint(self[1].point3d))
pointArray = polylineArea.method_14(4)
pt0 = MathHelper.distanceBearingPoint(self[0].point3d, MathHelper.getBearing(self[0].point3d, pointArray[1]) - Unit.ConvertDegToRad(90), width / 2.0,)
pt1 = MathHelper.distanceBearingPoint(self[0].point3d, MathHelper.getBearing(self[0].point3d, pointArray[1]) + Unit.ConvertDegToRad(90), width / 2.0,)
pt2 = MathHelper.distanceBearingPoint(self[1].point3d, MathHelper.getBearing(pointArray[len(pointArray) - 2], self[1].point3d) + Unit.ConvertDegToRad(90), width / 2.0,)
pt3 = MathHelper.distanceBearingPoint(self[1].point3d, MathHelper.getBearing(pointArray[len(pointArray) - 2], self[1].point3d) - Unit.ConvertDegToRad(90), width / 2.0,)
polylineArea0 = PolylineArea()
polylineArea0.Add(PolylineAreaPoint(pt0, self[0].bulge))
polylineArea0.Add(PolylineAreaPoint(pt3))
polylineArea1 = PolylineArea()
polylineArea1.Add(PolylineAreaPoint(pt2, -self[0].bulge))
polylineArea1.Add(PolylineAreaPoint(pt1))
pointArrayResult = []
for pt in polylineArea0.method_14(4):
pointArrayResult.append(pt)
for pt in polylineArea1.method_14(4):
pointArrayResult.append(pt)
geom = QgsGeometry.fromPolygon([pointArrayResult])
polygonsList.append(geom)
return polygonsList
# for i in range(self.NumberOfVertices):
# polylinePoint = self[i]
#
# if polylinePoint.startWidth != width:
# if len(pointList) > 1:
# geom = QgsGeometry.fromPolyline(pointList)
# polygon = geom.buffer(width / 2.0, 0, 2, 0, 0)
# polygonsList.append(polygon)
# width = polylinePoint.startWidth
# pointList = []
# pointList.append(polylinePoint.point3d)
# if not MathHelper.smethod_96(polylinePoint.bulge):
# if i != self.NumberOfVertices - 1:
# point3d = self[i + 1].point3d
# else:
# point3d = self[0].point3d
# MathHelper.getArc(polylinePoint.point3d, point3d, polylinePoint.bulge, 4, pointList)
#
# if len(pointList) > 1:
# geom = QgsGeometry.fromPolyline(pointList)
# polygon = geom.buffer(width / 2.0, 0, 2, 0, 0)
# polygonsList.append(polygon)
return polygonsList
def checkObstacle(self, obstacle_0):
if self.manualPolygon != None:
if not self.manualPolygon.contains(obstacle_0.Position):
return
mocMultiplier = None;
z = None;
num = None;
z1 = None;
point3d = None;
point3d1 = None;
num1 = None;
num2 = None;
if (not self.area12.pointInPolygon(obstacle_0.Position, obstacle_0.Tolerance)):
if (not self.area3a.pointInPolygon(obstacle_0.Position, obstacle_0.Tolerance) and not self.area3b.pointInPolygon(obstacle_0.Position, obstacle_0.Tolerance)):
return;
closestPointTo = self.area.getPointWithShortestDist(obstacle_0.Position);
point = QgsGeometry.fromPolyline(self.area.method_14()).closestVertex(obstacle_0.Position)
point3d1 = MathHelper.getIntersectionPoint(closestPointTo, MathHelper.distanceBearingPoint(closestPointTo, self.track, 100), self.ptDER, self.ptDER2);
num1 = MathHelper.calcDistance(closestPointTo, point3d1) if (MathHelper.smethod_119(closestPointTo, self.ptDER, self.ptDER2)) else 1E-08;
if num1 == 0:
num1 = 1E-08
num2 = max([1E-08, MathHelper.calcDistance(obstacle_0.Position, closestPointTo) - obstacle_0.Tolerance]);
mocMultiplier = max([self.moc / 100 * (num1 + num2) * obstacle_0.MocMultiplier, self.minMoc]);
z = self.ta + self.pdg / 100 * num2;
position = obstacle_0.Position;
num = position.get_Z() + obstacle_0.Trees + mocMultiplier;
z1 = 100 * ((num - self.ta) / num2);
else:
point3d2 = MathHelper.distanceBearingPoint(obstacle_0.Position, self.track + 3.14159265358979, obstacle_0.Tolerance);
point3d3 = MathHelper.distanceBearingPoint(point3d2, self.track, 100);
point3d = MathHelper.getIntersectionPoint(self.ptDER, self.ptDER2, point3d2, point3d3);
num1 = 1E-08 if (not MathHelper.smethod_119(point3d2, self.ptDER, self.ptDER2)) else MathHelper.calcDistance(point3d, point3d2);
if num1 == 0:
num1 = 1E-08
mocMultiplier = self.moc / 100 * num1 * obstacle_0.MocMultiplier;
z = self.ptDER.get_Z() + 5 + self.pdg / 100 * num1;
position1 = obstacle_0.Position;
num = position1.get_Z() + obstacle_0.Trees + mocMultiplier;
z1 = 100 * ((num - (self.ptDER.get_Z() + 5)) / num1);
if num1 < 0.00001:
num1 = None
criticalObstacleType = CriticalObstacleType.No;
if (z1 > self.pdg):
criticalObstacleType = CriticalObstacleType.Yes;
closeInObstacleType = CloseInObstacleType.No;
if (num <= self.ptDER.get_Z() + 60):
closeInObstacleType = CloseInObstacleType.Yes;
checkResult = [num1, num2, mocMultiplier, z, num, z1, criticalObstacleType, closeInObstacleType];
self.addObstacleToModel(obstacle_0, checkResult)
def getOffsetCurveNoClosed(self, distance, segment = 0, joinStyle = 0, mitreLimit = 0):
pointList = []
count = len(self)
i = 0
radiusDifference = 0
for item in self:
i += 1
if i == 1:
bearing = MathHelper.getBearing(self[i-1].Position, self[i].Position)
point = MathHelper.distanceBearingPoint(self[i - 1].Position, bearing - Unit.ConvertDegToRad(90) , distance)
pointList.append(point)
# if self[i-1].Bulge != 0:
# radiusDifference = distance if distance >= 0 else distance * (-1)
elif i == count:
bearing = MathHelper.getBearing(self[i-1].Position, self[i - 2].Position)
point = MathHelper.distanceBearingPoint(self[i-1].Position, bearing + Unit.ConvertDegToRad(90) , distance)
line = QgsGeometry.fromPolyline([self[i-1].Position, self[i - 2].Position])
newLine = QgsGeometry.fromPolyline([pointList[i-2], point])
if line.intersects(newLine):
bearing = MathHelper.getBearing(self[i-1].Position, self[i - 2].Position)
point = MathHelper.distanceBearingPoint(self[i-1].Position, bearing + Unit.ConvertDegToRad(270) , distance)
pointList.append(point)
else:
turnDirection = MathHelper.smethod_65([self[i-2].Position, self[i-1].Position, self[i].Position])
angle = 0
if turnDirection == TurnDirection.Right:
angle = Unit.ConvertDegToRad(360) - math.fabs(MathHelper.getBearing(self[i-1].Position, self[i].Position) - MathHelper.getBearing(self[i-1].Position, self[i-2].Position))
else:
angle = math.fabs(MathHelper.getBearing(self[i-1].Position, self[i].Position) - MathHelper.getBearing(self[i-1].Position, self[i-2].Position))
angle = math.fabs(Unit.ConvertDegToRad(90) - angle / 2)
dist = distance / math.cos(angle)
angle = (MathHelper.getBearing(self[i-1].Position, self[i].Position) + MathHelper.getBearing(self[i-1].Position, self[i-2].Position)) / 2
point = MathHelper.distanceBearingPoint(self[i-1].Position, angle , dist)
line = QgsGeometry.fromPolyline([self[i-1].Position, self[i - 2].Position])
newLine = QgsGeometry.fromPolyline([pointList[i-2], point])
if line.intersects(newLine):
bearing = MathHelper.getBearing(self[i-1].Position, self[i - 2].Position)
point = MathHelper.distanceBearingPoint(self[i-1].Position, angle + Unit.ConvertDegToRad(180) , dist)
if self[i-1].Bulge != 0:
radiusDifference = dist if dist >= 0 else dist * (-1)
pointList.append(point)
polylineAreaNew = PolylineArea()
for i in range(count):
polylineAreaNew.Add(PolylineAreaPoint(pointList[i], self[i].Bulge))
return polylineAreaNew
def Direction(self):
point3dCollection = []
count = len(self)
i = 0
while i < count:
position = self[i].position
bulge = self[i].Bulge
if i != count - 1:
point3d = self[i + 1].position
else:
point3d = self[0].position
if (not position.smethod_170(point3d)):
point3dCollection.append(position)
if (not MathHelper.smethod_96(bulge)):
# if int(position.get_X()) == 688211:
# nn= 1
point3d1 = MathHelper.smethod_71(position, point3d, bulge)
# if point3d1 == None:
# nn = 0
num1 = MathHelper.smethod_5(bulge) / 2
if MathHelper.smethod_66(bulge) != TurnDirection.Left:
num = MathHelper.getBearing(point3d1, position) + num1
else:
num = MathHelper.getBearing(point3d1, position) - num1
point3dCollection.append(MathHelper.distanceBearingPoint(point3d1, num, MathHelper.calcDistance(point3d1, position)));
i += 1
return MathHelper.smethod_65(point3dCollection);
def __init__(self, point3d_0, double_0, altitude_0, double_1, double_2,
bool_0, point3dCollection_0, point3dCollection_1,
polylineArea_0, polylineArea_1, manualPoly):
ObstacleTable.__init__(self, None)
self.manualPolygon = manualPoly
self.surfaceType = SurfaceTypes.DepartureOmnidirectional
self.track = double_0
self.ptDER = point3d_0
self.ptDER2 = MathHelper.distanceBearingPoint(
point3d_0, double_0 - 1.5707963267949, 100)
self.moc = double_1
self.minMoc = 80 if (bool_0) else 90
self.pdg = double_2
self.ta = altitude_0.Metres
point3dCollection = []
if (point3dCollection_0 != None and len(point3dCollection_0) > 0):
point3dCollection.append(point3dCollection_0[0])
for point3d in point3dCollection_1:
point3dCollection.append(point3d)
if (point3dCollection_0 != None and len(point3dCollection_0) > 0):
point3dCollection.append(point3dCollection_0[3])
self.area = PolylineArea.smethod_133(point3dCollection, True)
self.area12 = PrimaryObstacleArea(PolylineArea(point3dCollection_1))
self.area3a = PrimaryObstacleArea(polylineArea_0)
self.area3b = PrimaryObstacleArea(polylineArea_1)
def imethod_0(self, obstacle_0):
criticalObstacleType = CriticalObstacleType.No
if (self.poaOIS.pointInPolygon(obstacle_0.Position,
obstacle_0.Tolerance)):
z = self.elevOIS
num = 1
if (self.poaOCS.pointInPolygon(obstacle_0.Position,
obstacle_0.Tolerance)):
point3d1 = MathHelper.distanceBearingPoint(
obstacle_0.Position, self.track, 100)
point3d = MathHelper.getIntersectionPoint(
obstacle_0.Position, point3d1, self.ptsOCSL[0],
self.ptsOCSR[0])
num1 = max(
MathHelper.calcDistance(point3d, obstacle_0.Position) -
obstacle_0.Tolerance, 0)
z = num1 * self.tang + self.ptHRP.get_Z()
num = 0
position = obstacle_0.Position
z1 = position.get_Z() + obstacle_0.Trees - z
if (z1 > 0):
criticalObstacleType = CriticalObstacleType.Yes
return [
z, z1, criticalObstacleType,
PinsSurfaceType.PinsSurfaceType_OCS
if num == 0 else PinsSurfaceType.PinsSurfaceType_LevelOIS
]
def TransformBy(self, polylineArea, angle_radian, centerPoint):
resultPoilylineArea = PolylineArea()
for polylineAreaPoint in polylineArea:
point3d = polylineAreaPoint.Position
bearing = MathHelper.smethod_4(MathHelper.getBearing(centerPoint, point3d) + angle_radian + Unit.ConvertDegToRad(180))
resultPoilylineArea.Add(PolylineAreaPoint(MathHelper.distanceBearingPoint(centerPoint, bearing, MathHelper.calcDistance(point3d, centerPoint)), polylineAreaPoint.Bulge))
return resultPoilylineArea
def checkObstacle(self, obstacle_0):
if not self.surfaceArea.pointInPolygon(obstacle_0.Position,
obstacle_0.Tolerance):
return
point3d = MathHelper.getIntersectionPoint(
self.ptStart, self.ptStart2, obstacle_0.Position,
MathHelper.distanceBearingPoint(obstacle_0.Position,
self.outbound + 3.14159265358979,
obstacle_0.Tolerance))
num = max([
0.001,
MathHelper.calcDistance(obstacle_0.Position, point3d) -
obstacle_0.Tolerance
])
z = num * self.tang + self.ptStart.get_Z()
position = obstacle_0.Position
z1 = position.get_Z() + obstacle_0.Trees - z
criticalObstacleType = CriticalObstacleType.No
if (z1 > 0):
criticalObstacleType = CriticalObstacleType.Yes
disregardableObstacleType = DisregardableObstacleType.No
if (obstacle_0.Position.get_Z() + obstacle_0.Trees <=
self.ptStart.get_Z() + 15):
disregardableObstacleType = DisregardableObstacleType.Yes
self.addObstacleToModel(
obstacle_0,
[z, z1, criticalObstacleType, disregardableObstacleType])
def initObstaclesModel(self):
if self.surfaceArea == None:
return
self.obstaclesModel = VisualSegmentSurfaceObstacles([self.surfaceArea], self.ui.chbHideDisregardableObst.isChecked())
try:
double_0 = float(self.parametersPanel.txtRwyDir.Value)
except ValueError:
raise UserWarning, "Runway Direction is invalid!"
try:
double_1 = math.tan(Unit.ConvertDegToRad(float(self.parametersPanel.txtDescAngle.Value.Degrees) - 1.12))
except ValueError:
raise UserWarning, "DescAngle is invalid!"
point3d_0 = MathHelper.distanceBearingPoint(self.parametersPanel.pnlTHR.getPoint3D(), double_0, 60)
self.obstaclesModel.ptStart = point3d_0;
self.obstaclesModel.ptStart2 = MathHelper.distanceBearingPoint(point3d_0, double_0 - 1.5707963267949, 100);
self.obstaclesModel.outbound = double_0;
self.obstaclesModel.tang = double_1;
return FlightPlanBaseDlg.initObstaclesModel(self)
def vmethod_0(self, obstacle_0, returnList):
obstacleAreaResult_0 = ObstacleAreaResult.Primary
double_0 = None
double_1 = self.mocma
double_2 = double_1
double_3 = None
# if (MathHelper.smethod_44(self.selectionArea, obstacle_0.Position, obstacle_0.tolerance)):
#obstacleAreaResult_0 = self.primaryArea.imethod_1(obstacle_0.Position, obstacle_0.tolerance, double_1, out double_2, out double_0);
if not MathHelper.pointInPolygon(self.primaryArea, obstacle_0.Position,
obstacle_0.tolerance):
double_0 = 0.0
double_2 = 0.0
#List<SecondaryObstacleArea>.Enumerator enumerator = self.secondaryAreas.GetEnumerator();
for current in self.secondaryAreas:
try:
num = None
num1 = None
resultList = []
obstacleAreaResult = current.imethod_1(
obstacle_0.Position, obstacle_0.tolerance, double_1,
resultList)
if obstacleAreaResult == ObstacleAreaResult.Outside or len(
resultList) < 2:
obstacleAreaResult_0 = ObstacleAreaResult.Outside
continue
num = resultList[0]
num1 = resultList[1]
if obstacleAreaResult == ObstacleAreaResult.Primary:
obstacleAreaResult_0 = obstacleAreaResult
double_2 = num
double_0 = num1
break
elif obstacleAreaResult == ObstacleAreaResult.Secondary and (
num > double_2 or double_2 == 0.0):
obstacleAreaResult_0 = obstacleAreaResult
double_2 = num
double_0 = num1
break
except IndexError:
pass
if obstacleAreaResult_0 != ObstacleAreaResult.Outside:
obstacle_0.area = obstacleAreaResult_0
point3d = MathHelper.distanceBearingPoint(obstacle_0.Position,
self.tr180,
obstacle_0.tolerance)
double_3 = self.vmethod_3(point3d, False)
if obstacleAreaResult_0 == ObstacleAreaResult.Primary:
double_3 = double_3 + (double_1 - double_2)
returnList.append(double_0)
returnList.append(double_1)
returnList.append(double_2)
returnList.append(double_3)
return True
return False
def GetPointAtDist(self, length_0, startAndEndPoint3ds=None):
if length_0 == 0:
return self[0].Position
length = 0.0
for i in range(len(self)):
if i > 0:
length = MathHelper.calcDistance(self[i - 1].Position,
self[i].Position)
if length_0 == length:
startAndEndPoint3ds.append(self[i - 1].Position)
startAndEndPoint3ds.append(self[i].Position)
return self[i].Position
elif length_0 > length:
length_0 -= length
continue
else:
# length_0 = (length - length_0)
bearing = MathHelper.getBearing(self[i - 1].Position,
self[i].Position)
startAndEndPoint3ds.append(self[i - 1].Position)
startAndEndPoint3ds.append(self[i].Position)
return MathHelper.distanceBearingPoint(
self[i - 1].Position, bearing, length_0)
# if bearing >= 0 and bearing <= math.pi / 2:
# alpha = math.pi / 2 - bearing
#
# startAndEndPoint3ds.append(self[i - 1].Position)
# startAndEndPoint3ds.append(self[i].Position)
#
# return Point3D(self[i - 1].Position.get_X() + math.cos(alpha) * length_0, self[i - 1].Position.get_Y() + math.sin(alpha) * length_0)
# elif bearing > math.pi / 2 and bearing <= math.pi:
# alpha = bearing - math.pi / 2
#
# startAndEndPoint3ds.append(self[i - 1].Position)
# startAndEndPoint3ds.append(self[i].Position)
#
# return Point3D(self[i - 1].Position.get_X() + math.cos(alpha) * length_0, self[i - 1].Position.get_Y() - math.sin(alpha) * length_0)
# elif bearing > math.pi and bearing <= math.pi * 3 / 2:
# alpha = math.pi * 3 / 2 - bearing
#
# startAndEndPoint3ds.append(self[i - 1].Position)
# startAndEndPoint3ds.append(self[i].Position)
#
# return Point3D(self[i - 1].Position.get_X() - math.cos(alpha) * length_0, self[i - 1].Position.get_Y() - math.sin(alpha) * length_0)
# elif bearing > math.pi * 3 / 2 and bearing <= 2 * math.pi:
# alpha = bearing - math.pi * 3 / 2
#
# startAndEndPoint3ds.append(self[i - 1].Position)
# startAndEndPoint3ds.append(self[i].Position)
#
# return Point3D(self[i - 1].Position.get_X() - math.cos(alpha) * length_0, self[i - 1].Position.get_Y() + math.sin(alpha) * length_0)
pass
def putDistances(self):
try:
point3dThr = self.parametersPanel.pnlThrPosition.Point3d
point3dFaf = self.parametersPanel.pnlFafPosition.Point3d
point3dMapt = self.parametersPanel.pnlMaPtPosition.Point3d
speedTas = self.parametersPanel.pnlTas.Value
inboundTrackRad = Unit.ConvertDegToRad(self.parametersPanel.pnlInboundTrack.Value)
inboundTrack180Rad = MathHelper.smethod_4(inboundTrackRad + math.pi)
dDist = Distance(MathHelper.calcDistance(point3dFaf, point3dMapt))
self.parametersPanel.pnlDistOfFafMapt.Value = dDist
aDist = self.parametersPanel.pnlDistA.Value
bDist = self.parametersPanel.pnlDistB.Value
tasMin = Speed.smethod_0(self.parametersPanel.pnlIas.Value, -10, self.parametersPanel.pnlAerodromeAltitude.Value)
tasMax = Speed.smethod_0(self.parametersPanel.pnlIas.Value, 15, self.parametersPanel.pnlAerodromeAltitude.Value)
# calculate Distance from earliest MAPt to nominal MAPt:
x1 = math.sqrt(math.pow(aDist.NauticalMiles, 2) + math.pow(tasMin.Knots * 10 / float(3600), 2) + math.pow(30 * dDist.NauticalMiles / tasMin.Knots, 2))
x2 = math.sqrt(math.pow(aDist.NauticalMiles, 2) + math.pow(tasMax.Knots * 10 / float(3600), 2) + math.pow(30 * dDist.NauticalMiles / tasMax.Knots, 2))
distEarliestMaptToNominalMapt = Distance(max(x1, x2), DistanceUnits.NM)
self.parametersPanel.pnlDistOfEarliestToNominalMapt.Value = distEarliestMaptToNominalMapt
#calculate Distance from nominal MAPt to latest MAPt
x3 = math.sqrt(math.pow(bDist.NauticalMiles, 2) + math.pow(tasMin.Knots * 13 / float(3600), 2) + math.pow(30 * dDist.NauticalMiles / tasMin.Knots, 2))
x4 = math.sqrt(math.pow(bDist.NauticalMiles, 2) + math.pow(tasMax.Knots * 13 / float(3600), 2) + math.pow(30 * dDist.NauticalMiles / tasMax.Knots, 2))
distNominalMaptToLatestMapt = Distance(max(x3, x4), DistanceUnits.NM)
self.parametersPanel.pnlDistOfNominalToLatestMapt.Value = distNominalMaptToLatestMapt
#calculate Distance from Mapt to SOC
x5 = x3 + 15 * (tasMin.Knots + 10) / float(3600)
x6 = x4 + 15 * (tasMax.Knots + 10) / float(3600)
distMaptSoc = Distance(max(x5, x6), DistanceUnits.NM)
socMaptDistMeters = distMaptSoc.Metres
socThrDistMeters = MathHelper.calcDistance(point3dMapt, point3dThr) - socMaptDistMeters
sockBearing = inboundTrackRad
self.socPoint3d = MathHelper.distanceBearingPoint(point3dMapt, sockBearing, socMaptDistMeters).smethod_167(self.calcSocAltitude())
self.parametersPanel.pnlDistOfMaptSoc.Value = Distance(socMaptDistMeters)
self.parametersPanel.pnlDistOfSocThr.Value = Distance(MathHelper.calcDistance(self.socPoint3d, point3dThr))
self.parametersPanel.pnlDistOfFafMapt.Value = Distance(MathHelper.calcDistance(point3dFaf, point3dMapt))#MathHelper.calcDistance(point3dThr, self.socPoint3d))
self.parametersPanel.pnlDistOfMaptThr.Value = Distance(MathHelper.calcDistance(point3dMapt, point3dThr))
except:
pass
def RotatePolyLine(polylineArea, originPt, angle):
resultPolylineArea = PolylineArea()
if not isinstance(polylineArea, PolylineArea) or len(polylineArea) == 0:
return None
for polylineAreaPt in polylineArea:
pt = polylineAreaPt.Position
dist = MathHelper.calcDistance(pt, originPt)
bearing = MathHelper.getBearing(originPt, pt) + angle
newPt = MathHelper.distanceBearingPoint(originPt, bearing, dist)
resultPolylineArea.Add(PolylineAreaPoint(newPt, polylineAreaPt.bulge))
return resultPolylineArea
def btnConstruct_Click(self):
flag = FlightPlanBaseDlg.btnConstruct_Click(self)
if not flag:
return
# self.parametersPanel.txtRadius.setText("")
point3dCollection = None;
point3dCollection1 = None;
polylineArea = None;
polylineArea1 = None;
polylineArea2 = None;
point3dArrayResult = []
mapUnits = define._canvas.mapUnits()
constructionLayer = None
result, point3dCollection, point3dCollection1, polylineArea, polylineArea1, polylineArea2 = self.method_34()
if result:
point3dCollection2 = [];
if (point3dCollection != None and len(point3dCollection) > 0):
point3dCollection2.append(point3dCollection[0]);
for point3d in point3dCollection1:
point3dCollection2.append(point3d);
if (point3dCollection != None and len(point3dCollection) > 0):
point3dCollection2.append(point3dCollection[3]);
# point3dCollection2.pop(3)
# point3dCollection2.pop(3)
# point3dArrayResult.append(polylineArea1.method_14_closed())
# point3dArrayResult.append(polylineArea2.method_14_closed())
point3dArrayResult.append(PolylineArea(point3dCollection2))
self.area123 = point3dCollection2
self.circleArea = polylineArea
nominalPointTest1 = point3dCollection2[2]
nominalPointTest2 = point3dCollection2[3]
self.nominalPoint = MathHelper.distanceBearingPoint(nominalPointTest1, MathHelper.getBearing(nominalPointTest1, nominalPointTest2), MathHelper.calcDistance(nominalPointTest1, nominalPointTest2) / 2)
# if polylineArea.isCircle:
# self.parametersPanel.txtRadius.setText(str(polylineArea.Radius()))
point3dArrayResult.append(polylineArea)
if not len(point3dArrayResult) > 0 :
return
constructionLayer = AcadHelper.createVectorLayer(self.surfaceType, QGis.Line)
for point3dArray in point3dArrayResult:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3dArray, True)
nominalTrackLayer = self.nominal2Layer()
QgisHelper.appendToCanvas(define._canvas, [constructionLayer, nominalTrackLayer], self.surfaceType)
self.resultLayerList = [constructionLayer, nominalTrackLayer]
QgisHelper.zoomToLayers(self.resultLayerList)
self.ui.btnEvaluate.setEnabled(True)
def vmethod_3(self, point3d_0, bool_0):
point3d = Point3D()
point3d = MathHelper.getIntersectionPoint(
self.ptTHR, self.ptEND, point3d_0,
MathHelper.distanceBearingPoint(point3d_0, self.trm90, 100))
num = MathHelper.calcDistance(self.ptTHR, point3d)
if not MathHelper.smethod_115(point3d, self.ptTHR, self.ptTHRm90):
num = num + self.xstart
else:
num = self.xstart - min([num, self.xstart])
num1 = num * self.tanslope
if (bool_0):
num1 = num1 + self.mocma
return self.ptTHR.z() + num1
def vmethod_0(self, obstacle_0, returnList):
point3d = MathHelper.distanceBearingPoint(obstacle_0.Position, self.tr,
obstacle_0.tolerance)
obstacleAreaResult_0 = ObstacleAreaResult.Primary
double_0 = None
double_1 = self.getMOC(point3d)
double_3 = None
double_2 = double_1
if not MathHelper.pointInPolygon(self.primaryArea, obstacle_0.Position,
obstacle_0.tolerance):
double_0 = 0.0
double_2 = 0.0
for current in self.secondaryAreas:
try:
num = None
num1 = None
resultList = []
obstacleAreaResult = current.imethod_1(
obstacle_0.Position, obstacle_0.tolerance, double_1,
resultList)
if obstacleAreaResult == ObstacleAreaResult.Outside:
obstacleAreaResult_0 = ObstacleAreaResult.Outside
continue
num = resultList[0]
num1 = resultList[1]
if (obstacleAreaResult == ObstacleAreaResult.Primary):
obstacleAreaResult_0 = obstacleAreaResult
double_2 = num
double_0 = num1
break
elif obstacleAreaResult == ObstacleAreaResult.Secondary and (
num > double_2 or double_2 == 0.0):
obstacleAreaResult_0 = obstacleAreaResult
double_2 = num
double_0 = num1
except IndexError:
pass
if obstacleAreaResult_0 != ObstacleAreaResult.Outside:
obstacle_0.area = obstacleAreaResult_0
double_3 = self.vmethod_3(point3d, False)
if obstacleAreaResult_0 == ObstacleAreaResult.Secondary:
double_3 = double_3 + (double_1 - double_2)
returnList.append(double_0)
returnList.append(double_1)
returnList.append(double_2)
returnList.append(double_3)
return True
return False
def vmethod_3(self, point3d_0, bool_0):
point3d = Point3D()
point3d = MathHelper.getIntersectionPoint(
self.ptTHR, self.ptEND, point3d_0,
MathHelper.distanceBearingPoint(point3d_0, self.trm90, 100))
num = 0
if (MathHelper.smethod_115(point3d, self.ptTHR, self.ptTHRm90)):
num = max([
MathHelper.calcDistance(self.ptTHR, point3d), self.xstart
]) - self.xstart
num1 = 0
if (bool_0):
num1 = self.mocma + num * self.tanslope
return self.ptTHR.z() + num1
def vmethod_3(self, point3d_0, bool_0):
point3d = MathHelper.getIntersectionPoint(
self.ptTHR, self.ptEND, point3d_0,
MathHelper.distanceBearingPoint(point3d_0, self.trm90, 100))
item = 0
if (MathHelper.smethod_115(point3d, self.ptTHR, self.ptTHRm90)):
num = MathHelper.calcDistance(self.ptTHR, point3d)
num1 = 0
count = len(self.segments)
while (num1 < count):
if (num < self.segments[num1].xstart):
if (not bool_0):
return self.ptTHR.z() + item
item = item + self.segments[num1].moc
return self.ptTHR.z() + item
elif (num < self.segments[num1].xstart
or num >= self.segments[num1].xend):
if (num1 + 1 >= len(self.segments)):
item = (self.segments[num1].xend -
self.segments[num1].xfas
) * self.segments[num1].tanafas
if (bool_0):
item = item + self.segments[num1].moc
elif (num <= self.segments[num1 + 1].xstart):
item = (self.segments[num1].xend -
self.segments[num1].xfas
) * self.segments[num1].tanafas
if (not bool_0):
return self.ptTHR.z() + item
item1 = self.segments[num1].moc
item2 = self.segments[num1 + 1].moc
num2 = (item2 -
item1) / (self.segments[num1 + 1].xstart -
self.segments[num1].xend)
item3 = item1 + (num - self.segments[num1].xend) * num2
item = item + item3
return self.ptTHR.z() + item
num1 += 1
else:
item = (num - self.segments[num1].xfas
) * self.segments[num1].tanafas
if (not bool_0):
return self.ptTHR.z() + item
item = item + self.segments[num1].moc
return self.ptTHR.z() + item
elif (bool_0):
item = item + self.segments[0].moc
return self.ptTHR.z() + item
def putDistances(self):
try:
point3dThr = self.parametersPanel.pnlThrPosition.Point3d
point3dFaf = self.parametersPanel.pnlFafPosition.Point3d
point3dMapt = self.parametersPanel.pnlMaPtPosition.Point3d
self.parametersPanel.pnlDistOfFafMapt.Value = Distance(
MathHelper.calcDistance(point3dFaf, point3dMapt))
inboundTrackRad = Unit.ConvertDegToRad(
self.parametersPanel.pnlInboundTrack.Value)
inboundTrack180Rad = MathHelper.smethod_4(inboundTrackRad +
math.pi)
speedTas = self.parametersPanel.pnlTas.Value
xDist = self.calcDAndXDistance(speedTas, Speed(10), 15)
self.parametersPanel.pnlDistX.Caption = "X(10kts/15s)"
if self.parametersPanel.cmbAircraftCategory.SelectedIndex == 5:
xDist = self.calcDAndXDistance(speedTas, Speed(10), 5)
self.parametersPanel.pnlDistX.Caption = "X(10kts/5s)"
dDist = self.calcDAndXDistance(speedTas, Speed(10), 3)
fixTolerance = 0.0
if self.dlgType == "NpaOnFix":
fixTolerance = self.parametersPanel.pnlDistFixTolerance.Value.Metres
socMaptDistMeters = fixTolerance + dDist + xDist
socThrDistMeters = MathHelper.calcDistance(
point3dMapt, point3dThr) - socMaptDistMeters
sockBearing = inboundTrackRad
self.socPoint3d = MathHelper.distanceBearingPoint(
point3dMapt, sockBearing,
socMaptDistMeters).smethod_167(self.calcSocAltitude())
self.parametersPanel.pnlDistD.Value = Distance(dDist)
self.parametersPanel.pnlDistX.Value = Distance(xDist)
self.parametersPanel.pnlDistOfMaptSoc.Value = Distance(
socMaptDistMeters)
self.parametersPanel.pnlDistOfSocThr.Value = Distance(
MathHelper.calcDistance(self.socPoint3d, point3dThr)
) #MathHelper.calcDistance(point3dThr, self.daPoint3d))
# self.parametersPanel.pnlDistOfFafMapt.Value = Distance(MathHelper.calcDistance(point3dFaf, point3dMapt))#MathHelper.calcDistance(point3dThr, self.socPoint3d))
self.parametersPanel.pnlDistOfMaptThr.Value = Distance(
MathHelper.calcDistance(point3dMapt, point3dThr))
except:
pass
