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 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 getWaypoint(self):
if (self.type == RnavCommonWaypoint.FAWP):
nauticalMiles = float(self.txtDistance.text())
value = float(self.txtBearing.text())
num1 = math.fabs(self.rethr - value)
if (num1 > 180):
num1 = 360 - num1
num2 = math.sin(Unit.smethod_0(num1)) * 0.7559395
num3 = Unit.smethod_1(math.asin(num2 / nauticalMiles))
num4 = math.cos(Unit.smethod_0(num1)) * 0.755939525
num5 = math.cos(Unit.smethod_0(num3)) * nauticalMiles
return RnavWaypoints.smethod_3(self.pos1400m, float(self.txtBearing.text()), Distance(math.fabs(num5 - num4), DistanceUnits.NM))
if (self.type != RnavCommonWaypoint.MAWP):
return RnavWaypoints.smethod_3(self.from1, float(self.txtBearing.text()), Distance(float(self.txtDistance.text()), DistanceUnits.NM))
angle = 90
if (float(self.txtBearing.text()) > self.thrre or float(self.txtBearing.text()) - self.thrre >= 90):
if self.flagStrName == "Y-Bar":
angle = 70
num = self.rethr - angle
if (num < 0):
num = num + 360
else:
num = self.rethr + angle
if (num > 360):
num = num - 360
point3d1 = self.from1
point3d2 = self.getThrPoint3D()
point3d = MathHelper.getIntersectionPoint(point3d1, RnavWaypoints.smethod_3(self.from1, float(self.txtBearing.text()), Distance(1000)), point3d2, RnavWaypoints.smethod_3(self.getThrPoint3D(), num, Distance(1000)))
if point3d == None:
raise UserWarning, Messages.ERR_FAILED_TO_CALCULATE_INTERSECTION_POINT
return RnavWaypoints.smethod_3(self.getThrPoint3D(), num, Distance(MathHelper.calcDistance(point3d2, point3d)))
def btnCalculate_Click(self):
# try:
if self.type == RnavCommonWaypoint.FAWP or self.type == RnavCommonWaypoint.MAWP:
if self.getThrPoint3D() == None or self.getEndPoint3D() == None:
return
if not MathHelper.smethod_112(float(self.txtBearing.text()), self.MinBearing, self.MaxBearing, AngleUnits.Degrees):
if self.type != RnavCommonWaypoint.MAWP or MathHelper.smethod_96(self.MinBearing2) or MathHelper.smethod_96(self.MaxBearing2):
raise UserWarning, Messages.VALUE_NOT_WITHIN_ACCEPTABLE_RANGE
elif not MathHelper.smethod_106(float(self.txtBearing.text()), self.MinBearing2, self.MaxBearing2):
raise UserWarning, Messages.VALUE_NOT_WITHIN_ACCEPTABLE_RANGE
if self.txtDistance.isEnabled() and Distance(float(self.txtDistance.text()),DistanceUnits.NM).Metres < (self.MinDistance.Metres - 100):
raise UserWarning, Validations.VALUE_CANNOT_BE_SMALLER_THAN%self.MinDistance.NauticalMiles
wayPoint = self.getWaypoint()
if self.type == RnavCommonWaypoint.FAWP or self.type == RnavCommonWaypoint.MAWP:
if self.type == RnavCommonWaypoint.FAWP:
self.parent().gbFAWP.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 0:
self.parent().parameterCalcList.pop(0)
self.parent().parameterCalcList.insert(0,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationFAWP.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
else:
self.parent().gbMAWP.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 1:
self.parent().parameterCalcList.pop(1)
self.parent().parameterCalcList.insert(1,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationMAWP.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
self.parent().RwyTHR = self.getThrPoint3D()
self.parent().RwyEND = self.getEndPoint3D()
elif self.type == RnavCommonWaypoint.MAHWP:
self.parent().gbMAHWP.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 2:
self.parent().parameterCalcList.pop(2)
self.parent().parameterCalcList.insert(2,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationMAHWP.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
elif self.type == RnavCommonWaypoint.IWP:
self.parent().gbIWP.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 3:
self.parent().parameterCalcList.pop(3)
self.parent().parameterCalcList.insert(3,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationIWP.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
elif self.type == RnavCommonWaypoint.IAWP1:
self.parent().gbIAWP1.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 4:
self.parent().parameterCalcList.pop(4)
self.parent().parameterCalcList.insert(4,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationIAWP1.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
elif self.type == RnavCommonWaypoint.IAWP2:
self.parent().gbIAWP2.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 5:
self.parent().parameterCalcList.pop(5)
self.parent().parameterCalcList.insert(5,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationIAWP2.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
elif self.type == RnavCommonWaypoint.IAWP3:
self.parent().gbIAWP3.setPosition( wayPoint.x(), wayPoint.y())
if len(self.parent().parameterCalcList) > 6:
self.parent().parameterCalcList.pop(6)
self.parent().parameterCalcList.insert(6,(self.txtBearing.text(), self.txtDistance.text()))
self.parent().annotationIAWP3.setMapPosition(QgsPoint(wayPoint.x(), wayPoint.y()))
self.close()
QDialog.accept(self)
def putDistances(self):
try:
point3dThr = self.parametersPanel.pnlThrPosition.Point3d
point3dFaf = self.parametersPanel.pnlFapPosition.Point3d
point3dThr = self.parametersPanel.pnlThrPosition.Point3d
# point3dFaf = self.parametersPanel.pnlFapPosition.Point3d
inboundTrackRad = MathHelper.smethod_4(
self.parametersPanel.pnlInboundTrack.Value
) #MathHelper.getBearing(point3dFaf, point3dThr)
inboundTrack180Rad = MathHelper.smethod_4(inboundTrackRad +
math.pi)
estimatedAltitdeMeters = self.parametersPanel.pnlEstimatedAltitude.Value.Metres
thrAltitudeMeters = self.parametersPanel.pnlThrPosition.Altitude(
).Metres
heightLossAltitudeMeters = self.parametersPanel.pnlHeightLoss.Value.Metres
rdhAltitudeMeters = self.parametersPanel.pnlRDH.Value.Metres
vpa = Unit.ConvertDegToRad(self.getVPA())
xz = self.parametersPanel.pnlDistXz.Value.Metres
socThrDistMeters = (
(estimatedAltitdeMeters - thrAltitudeMeters -
heightLossAltitudeMeters) / math.tan(vpa)) + xz
daThrDistMeters = (estimatedAltitdeMeters - thrAltitudeMeters -
rdhAltitudeMeters) / math.tan(vpa)
self.parametersPanel.pnlDistOfDaThr.Value = Distance(
daThrDistMeters
) #MathHelper.calcDistance(point3dThr, self.daPoint3d))
self.parametersPanel.pnlDistOfSocThr.Value = Distance(
socThrDistMeters
) #MathHelper.calcDistance(point3dThr, self.socPoint3d))
self.parametersPanel.pnlDistOfFafDA.Value = Distance(
MathHelper.calcDistance(point3dFaf, self.daPoint3d))
except:
pass
def get_Object(self):
point3dArray = [self.Start[0], self.Start[1], self.Start[2], self.Finish[2]]
polyline = PolylineArea(point3dArray)
polyline.SetBulgeAt(0, MathHelper.smethod_60(self.Start[0], self.Middle[0], self.Finish[0]))
polyline.SetBulgeAt(1, MathHelper.smethod_60(self.Start[1], self.Middle[1], self.Finish[1]))
polyline.SetBulgeAt(2, MathHelper.smethod_60(self.Start[2], self.Middle[2], self.Finish[2]))
return QgsGeometry.fromPolyline(polyline.method_14())
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 method_14_closed(self, levelNum=8):
point3dCollection = []
count = len(self)
if self.isCircle:
return MathHelper.constructCircle(self[0].Position, self[0].bulge,
50)
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
point3dCollection.append(position)
# if (not position.smethod_170(point3d)):
if (not MathHelper.smethod_96(bulge)):
if bulge < 0.25 and bulge > -0.25:
levelNum = 3
MathHelper.getArc(position, point3d, bulge, levelNum,
point3dCollection)
i += 1
point3dCollection.append(self[0].position)
return point3dCollection
def method_33(self):
turnDirection = []
try:
if (self.ui.cmbSegmentType.SelectedIndex == 1):
point3d = self.pnlIDF.getPoint3D()
point3d1 = self.pnlHRP.getPoint3D()
num = Unit.smethod_1(MathHelper.getBearing(point3d, point3d1))
num1 = self.smethod_17(
self.ui.txtTakeOffSurfaceTrack.txtRadialPlan.numberBox)
MathHelper.smethod_77(num, num1, AngleUnits.Degrees,
turnDirection)
if (turnDirection[0] == TurnDirection.Left):
pass
# self.ui.chbLeftTurnProhibited.setVisible(False)
# self.ui.chbRightTurnProhibited.setVisible(True)
elif (turnDirection[0] != TurnDirection.Right):
# self.ui.chbLeftTurnProhibited.setVisible(True)
# self.ui.chbRightTurnProhibited.setVisible(True)
if (self.ui.chbLeftTurnProhibited.isChecked()
and self.ui.chbRightTurnProhibited.isChecked()):
self.ui.chbRightTurnProhibited.setChecked(False)
else:
pass
# self.ui.chbRightTurnProhibited.setVisible(False)
# self.ui.chbLeftTurnProhibited.setVisible(True)
except:
pass
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 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 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 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 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 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 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 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 getQgsPointList(self):
pointList = []
for i in range(self.NumberOfVertices):
polylinePoint = self[i]
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 self.Closed:
pointList.append(self[0].point3d)
return pointList
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 canvasReleaseEvent(self, e):
if ( e.button() == Qt.RightButton ):
self.reset()
self.emit(SIGNAL("captureFinished"))
else:
self.rubberBandPt.reset(QGis.Point)
snapPoint = QgisHelper.snapPoint(e.pos(), self.mSnapper, define._canvas, True)
if self.startPoint == None:
self.rubberBand.reset(QGis.Line)
if snapPoint == None:
self.startPoint = self.toMapCoordinates(e.pos())
else:
self.startPoint = snapPoint
self.rubberBand.addPoint(self.startPoint)
self.isDrawing = True
else:
if snapPoint == None:
self.endPoint = self.toMapCoordinates(e.pos())
else:
self.endPoint = snapPoint
self.rubberBand.addPoint(self.endPoint)
dist = MathHelper.calcDistance(self.startPoint, self.endPoint)
self.distance = self.distance + dist
if self.type == DistanceUnits.M:
self.txtBearing.setText("%f"%round(self.distance, 4))
elif self.type == DistanceUnits.NM:
self.txtBearing.setText("%f"%round(Unit.ConvertMeterToNM(self.distance), 4))
elif self.type == DistanceUnits.FT:
self.txtBearing.setText("%f"%round(Unit.ConvertMeterToFeet(self.distance), 4))
elif self.type == DistanceUnits.KM:
self.txtBearing.setText("%f"%round((self.distance / 1000), 4))
elif self.type == DistanceUnits.MM:
self.txtBearing.setText(str(int(self.distance * 1000)))
self.startPoint = self.endPoint
def btnPDTCheck_Click(self):
pdtResultStr = MathHelper.pdtCheckResultToString(
float(self.parametersPanel.txtIsa.Value),
self.parametersPanel.txtAltitude.Value,
float(self.parametersPanel.txtIas.Value.Knots),
float(self.parametersPanel.txtTime.Value))
QMessageBox.warning(self, "PDT Check", pdtResultStr)
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 smethod_8(rnavCommonWaypoint_0, aircraftSpeedCategory_0, double_0):
double0 = None
if (aircraftSpeedCategory_0 == AircraftSpeedCategory.Custom):
raise Messages.CUSTOM_AC_CATEGORY_NOT_SUPPORTED
if rnavCommonWaypoint_0 == RnavCommonWaypoint.MAHWP:
double0 = double_0 + 7
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.MAWP:
return None
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.FAWP:
if (aircraftSpeedCategory_0 != AircraftSpeedCategory.A
and aircraftSpeedCategory_0 != AircraftSpeedCategory.B):
if (aircraftSpeedCategory_0 != AircraftSpeedCategory.H):
double0 = double_0 + 15
else:
double0 = double_0 + 30
else:
double0 = double_0 + 30
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.IWP:
if (aircraftSpeedCategory_0 != AircraftSpeedCategory.H):
double0 = double_0 + 10
else:
double0 = double_0 + 30
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.IAWP1:
double0 = double_0 - 70
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.IAWP2:
if (aircraftSpeedCategory_0 != AircraftSpeedCategory.H):
double0 = double_0 + 30
else:
double0 = double_0 + 60
elif rnavCommonWaypoint_0 == RnavCommonWaypoint.IAWP3:
double0 = double_0 + 90
return MathHelper.smethod_3(double0)
def method_7(self, iwin32Window_0):
distance = self.method_3(True)
if (not distance.IsValid() or distance.Metres < 100):
QMessageBox.warning(iwin32Window_0, "Error",
Messages.ERR_INSUFFICIENT_RWY_LENGTH)
return False
direction = self.Direction
point3dCollection = self.Point3dCollectionValue
num = 0
for i in range(1, point3dCollection.get_Count() - 1):
item = point3dCollection.get_Item(i - 1)
point3d = point3dCollection.get_Item(i)
item1 = point3dCollection.get_Item(i + 1)
num = max(
MathHelper.smethod_84(item, point3d, item1,
AngleUnits.Degrees), num)
if (num < 10):
return True
if (num >= 45):
QMessageBox.warning(iwin32Window_0, "Error",
Messages.ERR_RWY_POSITIONS_TRACK_CHANGE_45)
return False
return QMessageBox.warning(
iwin32Window_0, "Warning",
Confirmations.RWY_POSITIONS_TRACK_CHANGE_INCORRECT,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes
def canvasMoveEvent(self, e):
self.rubberBandPt.reset(QGis.Point)
snapPoint = QgisHelper.snapPoint(e.pos(), self.mSnapper,
define._canvas, True)
if snapPoint != None:
self.rubberBandPt.addPoint(snapPoint)
self.rubberBandPt.show()
if self.isDrawing:
if self.isDrawing:
if snapPoint == None:
self.endPoint = self.toMapCoordinates(e.pos())
else:
self.endPoint = snapPoint
self.rubberBand.movePoint(self.endPoint)
dist1 = MathHelper.calcDistance(self.startPoint, self.endPoint)
dist1 = self.distance + dist1
if self.type == DistanceUnits.M:
self.txtBearing.setText("%f" % round(dist1, 4))
elif self.type == DistanceUnits.NM:
self.txtBearing.setText("%f" %
round(Unit.ConvertMeterToNM(dist1), 4))
elif self.type == DistanceUnits.FT:
self.txtBearing.setText(
"%f" % round(Unit.ConvertMeterToFeet(dist1), 4))
elif self.type == DistanceUnits.KM:
self.txtBearing.setText("%f" % round((dist1 / 1000), 4))
elif self.type == DistanceUnits.MM:
self.txtBearing.setText(str(int(dist1 * 1000)))
def btnEvaluate_Click(self):
point3dCollection = None
point3dCollection1 = None
polylineArea = None
polylineArea1 = None
polylineArea2 = None
primaryObstacleArea = None
# if (self.parametersPanel.cmbSelectionMode.currentText() == "Manual" and not self.pnlSelectionMode.method_0()):
# return;
result, point3dCollection, point3dCollection1, polylineArea, polylineArea1, polylineArea2 = self.method_34(
)
if (not result):
return
point3d = self.parametersPanel.pnlDer.Point3d
num = MathHelper.getBearing(self.parametersPanel.pnlRwyStart.Point3d,
point3d)
percent = float(self.parametersPanel.txtMoc.text())
percent1 = float(self.parametersPanel.txtPdg.text())
ObstacleTable.MocMultiplier = self.parametersPanel.mocSpinBox.value()
self.obstaclesModel = DepartureOmnidirectionalObstacles(
point3d, num,
Altitude(float(self.parametersPanel.txtTurningAltitude.text()),
AltitudeUnits.FT), percent, percent1,
self.parametersPanel.chbCatH.isChecked(), point3dCollection,
point3dCollection1, polylineArea1, polylineArea2,
self.manualPolygon)
#
return FlightPlanBaseDlg.btnEvaluate_Click(self)
