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 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 getBearingOfTangentWithOutPt(self, outPt, spiralNumber, turnDirection = None):
if self.Direction == TurnDirection.Right:
B = math.asin(self.Radius[spiralNumber] / MathHelper.calcDistance(self.Center[spiralNumber], outPt))
return MathHelper.smethod_4(MathHelper.getBearing(self.Center[spiralNumber], outPt) + B)
else:
B = math.asin(self.Radius[spiralNumber] / MathHelper.calcDistance(self.Center[spiralNumber], outPt))
return MathHelper.smethod_4(MathHelper.getBearing(self.Center[spiralNumber], outPt) - B)
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 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 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 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 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)
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 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 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 calcRwyBearing(self):
try:
point3End = self.thrEndPoint3d
point3dThr = self.thrPoint3d
self.parametersPanel.txtDirection.Value = round(Unit.ConvertRadToDeg(MathHelper.getBearing(point3dThr, point3End)), 4)
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 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 method_0(self):
str0 = ""
try:
position = self.method_1(PositionType.START)
position1 = self.method_1(PositionType.END)
str0 = "{0:00}".format(Unit.smethod_1(MathHelper.getBearing(position.Point3d, position1.Point3d)) / 10)
except:
str0 = ""
return str0
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 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 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 method_20(self, double_0, bool_0):
if (self.Direction() == TurnDirection.Nothing):
return
self[0].Bulge = double_0
position = self[0].position
position1 = self[1].position
turnDirection = MathHelper.smethod_66(double_0)
point3d = MathHelper.smethod_71(position, position1, double_0)
if (turnDirection != TurnDirection.Left):
if turnDirection != TurnDirection.Right :
num = MathHelper.getBearing(position, position1)
else:
num = MathHelper.getBearing(position1, point3d) - 1.5707963267949
else:
num = MathHelper.getBearing(position1, point3d) + 1.5707963267949
count = len(self)
i = 1
while i < count:
position = self[i].position
if (i != count - 1):
position1 = self[i + 1].position
else:
if (not bool_0):
return
position1 = self[0].position
point3d = MathHelper.smethod_75(num, position, position1)
self[i].Bulge = MathHelper.smethod_59(num, position, position1)
turnDirection = MathHelper.smethod_63(num, MathHelper.getBearing(position, position1), AngleUnits.Radians)
if (turnDirection == TurnDirection.Left):
num = MathHelper.getBearing(position1, point3d) + 1.5707963267949
elif (turnDirection == TurnDirection.Right):
num = MathHelper.getBearing(position1, point3d) - 1.5707963267949
i += 1
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 __init__(self, parent, thrPos, rwyPos=None, track=None):
QDialog.__init__(self, parent)
self.baseTrack = track
self.resize(290, 136)
self.setWindowTitle("Calculate FAP")
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
verticalLayoutDlg = QVBoxLayout(self)
verticalLayoutDlg.setObjectName(("verticalLayoutDlg"))
self.groupBox = GroupBox(self)
verticalLayoutDlg.addWidget(self.groupBox)
self.pnlThrPosition = PositionPanel(self.groupBox)
self.pnlThrPosition.Point3d = thrPos
self.groupBox.Add = self.pnlThrPosition
self.pnlThrPosition.Visible = False
self.pnlRwyEndPosition = PositionPanel(self.groupBox)
self.pnlRwyEndPosition.Point3d = rwyPos
self.groupBox.Add = self.pnlRwyEndPosition
self.pnlRwyEndPosition.Visible = False
self.pnlTrack = TrackRadialBoxPanel(self.groupBox)
self.pnlTrack.Caption = "Track"
if rwyPos == None:
self.pnlTrack.Value = track
else:
self.pnlTrack.Value = MathHelper.getBearing(thrPos, rwyPos)
self.pnlTrack.LabelWidth = 100
self.groupBox.Add = self.pnlTrack
self.pnlDist = DistanceBoxPanel(self.groupBox, DistanceUnits.M,
DistanceUnits.NM)
self.pnlDist.Caption = "Distance"
self.pnlDist.Value = Distance(5, DistanceUnits.NM)
self.pnlDist.LabelWidth = 100
self.groupBox.Add = self.pnlDist
self.btnBoxOkCancel = QDialogButtonBox(self)
self.btnBoxOkCancel.setObjectName(("btnBoxOkCancel"))
self.btnBoxOkCancel.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.connect(self.btnBoxOkCancel, SIGNAL("accepted()"), self.acceptDlg)
self.connect(self.btnBoxOkCancel, SIGNAL("rejected()"), self.reject)
verticalLayoutDlg.addWidget(self.btnBoxOkCancel)
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 method_0(self):
str0 = ""
try:
position = self.method_1(PositionType.THR)
position1 = self.method_1(PositionType.END)
str0 = str(
int(
round(
Unit.smethod_1(
MathHelper.getBearing(position.Point3d,
position1.Point3d)) / 10)))
if len(str0) == 1:
str0 = "0" + str0
except:
str0 = ""
return str0
def method_6(self, polyline_0, point3d_0, double0, point3d1):
double_0 = double0
point3d_1 = point3d1
# Point3d point3d;
flag = False
origin = Point3D.get_Origin()
i = 0
for plylineAreaPoint in polyline_0:
bulgeAt = plylineAreaPoint.Bulge
if (bulgeAt != 0):
point3dAt = plylineAreaPoint.Position
point3d1 = polyline_0[0].Position if (
i == polyline_0.Count - 1) else polyline_0[i + 1].Position
point3d = MathHelper.smethod_71(point3dAt, point3d1, bulgeAt)
if (point3d != None):
point3d2 = MathHelper.distanceBearingPoint(
point3d, MathHelper.getBearing(point3d_0, point3d),
MathHelper.calcDistance(point3d, point3dAt))
if (flag):
if (self.orientation == OrientationType.Left):
if (not MathHelper.smethod_119(
point3d2, point3d_0, origin)):
num = MathHelper.calcDistance(
point3d_0, point3d2)
if (num > double_0):
double_0 = num
point3d_1 = point3d2
origin = point3d1
flag = True
continue
continue
elif (MathHelper.smethod_115(point3d2, point3d_0,
origin)):
continue
num = MathHelper.calcDistance(point3d_0, point3d2)
if (num > double_0):
double_0 = num
point3d_1 = point3d2
origin = point3d1
flag = True
i += 1
return (double_0, point3d_1)
def smethod_1(position_0, position_1):
# double_0 = Unit.smethod_1(MathHelper.getBearing(position_1, position_0))
return Unit.smethod_1(MathHelper.getBearing(position_0, position_1))
def smethod_0(position_0, position_1):
return Unit.smethod_1(MathHelper.getBearing(position_0, position_1))
def btnConstruct2_Click(self):
qgsLayerTreeView = define._mLayerTreeView
groupName = self.surfaceType2
layerTreeModel = qgsLayerTreeView.layerTreeModel()
layerTreeGroup = layerTreeModel.rootGroup()
rowCount = layerTreeModel.rowCount()
groupExisting = False
if rowCount > 0:
for i in range(rowCount):
qgsLayerTreeNode = layerTreeModel.index2node(
layerTreeModel.index(i, 0))
if qgsLayerTreeNode.nodeType() == 0:
qgsLayerTreeNode._class_ = QgsLayerTreeGroup
if isinstance(qgsLayerTreeNode, QgsLayerTreeGroup
) and qgsLayerTreeNode.name() == groupName:
groupExisting = True
if groupExisting:
if len(self.resultLayerList2) > 0:
QgisHelper.removeFromCanvas(define._canvas,
self.resultLayerList2)
self.resultLayerList2 = []
else:
QMessageBox.warning(
self, "Warning", "Please remove \"" + self.surfaceType2 +
"\" layer group from LayerTreeView.")
return
num = None
num1 = None
line = None
polyline = None
point3d = None
point3d1 = None
point3d2 = None
point3d3 = None
point3d4 = None
point3d5 = None
point3d6 = None
point3d7 = None
point3d8 = None
ficorResult = None
point = []
value = None
resultPolylineAreaList = []
# if (!AcadHelper.Ready)
# {
# return;
# }
# if (!self.method_27(true))
# {
# return;
# }
# string constructionLayer = base.ConstructionLayer;
point3d9 = self.parametersPanel.pnlTrackingPosition.Point3d
point3d10 = self.parametersPanel.pnlIntersectingPosition.Point3d
value1 = float(self.parametersPanel.txtTrackingRadialTrack.Value)
value2 = float(self.parametersPanel.txtIntersectingRadialTrack.Value)
num2 = Unit.ConvertDegToRad(value1)
num3 = Unit.ConvertDegToRad(value2)
if (self.parametersPanel.cmbTrackingType.currentIndex() != 0):
num = Unit.ConvertDegToRad(2.4) if (
self.parametersPanel.cmbTrackingType.currentIndex() != 1
) else Unit.ConvertDegToRad(6.9)
else:
num = Unit.ConvertDegToRad(5.2)
num1 = Unit.ConvertDegToRad(6.2) if (
self.parametersPanel.cmbIntersectingType.currentIndex() != 0
) else Unit.ConvertDegToRad(4.5)
num4 = num2 + num
point3d11 = MathHelper.distanceBearingPoint(point3d9, num4, 100)
num5 = num2 - num
point3d12 = MathHelper.distanceBearingPoint(point3d9, num5, 100)
point3d13 = MathHelper.distanceBearingPoint(point3d9, num2, 100)
point3d = MathHelper.getIntersectionPoint(
point3d9, point3d13, point3d10,
MathHelper.distanceBearingPoint(point3d10, num3, 100))
if (self.parametersPanel.cmbIntersectingType.currentIndex() >= 2):
metres = Distance(
float(self.parametersPanel.txtIntersectingDistance.text()),
DistanceUnits.NM).Metres
if (self.parametersPanel.chb0dmeAtThr.isChecked()):
value = Distance(
float(self.parametersPanel.txtDmeOffset.text()))
metres = metres + value.Metres
num6 = 460 + metres * 0.0125
num7 = metres + num6
num8 = metres - num6
if (MathHelper.smethod_102(point3d9, point3d10)):
point3d14 = MathHelper.distanceBearingPoint(
point3d9, num4, num8)
point3d15 = MathHelper.distanceBearingPoint(
point3d9, num2, num8)
point3d16 = MathHelper.distanceBearingPoint(
point3d9, num5, num8)
point3d17 = MathHelper.distanceBearingPoint(
point3d9, num5, num7)
point3d18 = MathHelper.distanceBearingPoint(
point3d9, num2, num7)
point3d19 = MathHelper.distanceBearingPoint(
point3d9, num4, num7)
point = [point3d14, point3d16, point3d17, point3d19]
polyline = AcadHelper.smethod_126(point)
polyline.SetBulgeAt(
0, MathHelper.smethod_60(point3d14, point3d15, point3d16))
polyline.SetBulgeAt(
2, MathHelper.smethod_60(point3d17, point3d18, point3d19))
polyline.set_Closed(True)
resultPolylineAreaList.append(polyline)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
point3d14 = MathHelper.distanceBearingPoint(
point3d9, num2, num8)
point3d15 = MathHelper.distanceBearingPoint(
point3d9, num2, num7)
resultPolylineAreaList.append(
PolylineArea([point3d14, point3d15]))
# line = new Line(point3d14, point3d15);
# AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer);
point3d14 = MathHelper.distanceBearingPoint(
point3d9, num4, metres)
point3d15 = MathHelper.distanceBearingPoint(
point3d9, num2, metres)
point3d16 = MathHelper.distanceBearingPoint(
point3d9, num5, metres)
point = [point3d14, point3d16]
polyline = AcadHelper.smethod_126(point)
polyline.SetBulgeAt(
0, MathHelper.smethod_60(point3d14, point3d15, point3d16))
resultPolylineAreaList.append(polyline)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
else:
ficorResult1 = self.method_37(point3d10, num2, point3d9,
point3d13, num8, FicorInput.C)
ficorResult2 = self.method_37(point3d10, num2, point3d9,
point3d13, metres, FicorInput.C)
ficorResult3 = self.method_37(point3d10, num2, point3d9,
point3d13, num7, FicorInput.C)
if (ficorResult1.Status != FicorStatus.TWO
and ficorResult2.Status != FicorStatus.TWO):
if (ficorResult3.Status == FicorStatus.TWO):
ficorResult = FicorResult(None, FicorStatus.TWO)
else:
ficorResult = FicorResult(None, ficorResult2.Status)
else:
ficorResult = FicorResult(None, FicorStatus.TWO)
if (ficorResult.Status != FicorStatus.NID):
ficorInput = FicorInput.F
num9 = 1
if (ficorResult.Status == FicorStatus.TWO):
QMessageBox.warning(
self, "Infomation",
Messages.TWO_POSSIBLE_FIX_POSITIONS)
ficorInput = FicorInput.L
num9 = 2
num10 = 0
while (num10 < num9):
ficorResult4 = self.method_37(point3d10, num4,
point3d9, point3d11,
num8, ficorInput)
ficorResult5 = self.method_37(point3d10, num2,
point3d9, point3d13,
num8, ficorInput)
ficorResult6 = self.method_37(point3d10, num5,
point3d9, point3d12,
num8, ficorInput)
ficorResult7 = self.method_37(point3d10, num4,
point3d9, point3d11,
metres, ficorInput)
ficorResult8 = self.method_37(point3d10, num2,
point3d9, point3d13,
metres, ficorInput)
ficorResult9 = self.method_37(point3d10, num5,
point3d9, point3d12,
metres, ficorInput)
ficorResult10 = self.method_37(point3d10, num4,
point3d9, point3d11,
num7, ficorInput)
ficorResult11 = self.method_37(point3d10, num2,
point3d9, point3d13,
num7, ficorInput)
ficorResult12 = self.method_37(point3d10, num5,
point3d9, point3d12,
num7, ficorInput)
if (ficorResult4.Status == FicorStatus.NID
or ficorResult5.Status == FicorStatus.NID
or ficorResult6.Status == FicorStatus.NID
or ficorResult7.Status == FicorStatus.NID
or ficorResult9.Status == FicorStatus.NID
or ficorResult10.Status == FicorStatus.NID
or ficorResult11.Status == FicorStatus.NID
or ficorResult12.Status == FicorStatus.NID
or ficorResult8.Status == FicorStatus.NID):
eRRFAILEDTOCONSTRUCTTHEFIXAUTOMATICALLY = Messages.ERR_FAILED_TO_CONSTRUCT_THE_FIX_AUTOMATICALLY
value = Distance(
float(self.parametersPanel.
txtIntersectingDistance.text()),
DistanceUnits.NM)
str000 = str(round(value.Metres, 4)) + "m"
value = str(round(Distance(num6).Metres, 4)) + "m"
QMessageBox.warning(
self, "Error",
eRRFAILEDTOCONSTRUCTTHEFIXAUTOMATICALLY %
(str000, value))
# ErrorMessageBox.smethod_0(self, string.Format(eRRFAILEDTOCONSTRUCTTHEFIXAUTOMATICALLY, str, value.method_0(":m")));
return
elif (MathHelper.calcDistance(point3d9,
ficorResult8.Point)
< MathHelper.calcDistance(
ficorResult5.Point, ficorResult8.Point)):
QMessageBox.warning(
self, "Error", Messages.
ERR_FIX_TOO_CLOSE_USE_OVERHEAD_TOLERANCE)
# ErrorMessageBox.smethod_0(self, Messages.ERR_FIX_TOO_CLOSE_USE_OVERHEAD_TOLERANCE);
return
else:
point = [
ficorResult4.Point, ficorResult6.Point,
ficorResult12.Point, ficorResult10.Point
]
polyline = AcadHelper.smethod_126(point)
polyline.SetBulgeAt(
0,
MathHelper.smethod_60(ficorResult4.Point,
ficorResult5.Point,
ficorResult6.Point))
polyline.SetBulgeAt(
2,
MathHelper.smethod_60(ficorResult12.Point,
ficorResult11.Point,
ficorResult10.Point))
polyline.set_Closed(True)
resultPolylineAreaList.append(polyline)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
resultPolylineAreaList.append(
PolylineArea(
[ficorResult5.Point, ficorResult11.Point]))
# line = new Line(ficorResult5.Point, ficorResult11.Point);
# AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer);
point = [ficorResult7.Point, ficorResult9.Point]
polyline = AcadHelper.smethod_126(point)
polyline.SetBulgeAt(
0,
MathHelper.smethod_60(ficorResult7.Point,
ficorResult8.Point,
ficorResult9.Point))
resultPolylineAreaList.append(polyline)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
if (ficorResult.Status == FicorStatus.TWO):
ficorInput = FicorInput.S
num10 += 1
else:
QMessageBox.warning(
self, "Error", Messages.
ERR_RADIAL_TRACK_DME_DISTANCE_DO_NOT_INTERSECT)
# ErrorMessageBox.smethod_0(self, Messages.ERR_RADIAL_TRACK_DME_DISTANCE_DO_NOT_INTERSECT);
return
elif (point3d == None):
QMessageBox.warning(self, "Error",
Messages.ERR_RADIALS_TRACKS_ARE_PARALLEL)
# ErrorMessageBox.smethod_0(self, Messages.ERR_RADIALS_TRACKS_ARE_PARALLEL);
return
elif (MathHelper.smethod_99(MathHelper.getBearing(point3d9, point3d),
num2, 0.001)):
point3d20 = MathHelper.distanceBearingPoint(
point3d10, num3 + num1, 100)
point3d21 = MathHelper.distanceBearingPoint(
point3d10, num3 - num1, 100)
point3d1 = MathHelper.getIntersectionPoint(point3d9, point3d12,
point3d10, point3d20)
point3d2 = MathHelper.getIntersectionPoint(point3d9, point3d12,
point3d10, point3d21)
point3d3 = MathHelper.getIntersectionPoint(point3d9, point3d11,
point3d10, point3d21)
point3d4 = MathHelper.getIntersectionPoint(point3d9, point3d11,
point3d10, point3d20)
point3d5 = MathHelper.getIntersectionPoint(point3d9, point3d,
point3d10, point3d20)
point3d6 = MathHelper.getIntersectionPoint(point3d9, point3d,
point3d10, point3d21)
point3d7 = MathHelper.getIntersectionPoint(point3d9, point3d11,
point3d10, point3d)
point3d8 = MathHelper.getIntersectionPoint(point3d9, point3d12,
point3d10, point3d)
if (MathHelper.calcDistance(point3d9, point3d) <
MathHelper.calcDistance(point3d5, point3d)
or MathHelper.calcDistance(point3d10, point3d) <
MathHelper.calcDistance(point3d5, point3d)
or MathHelper.calcDistance(point3d9, point3d) <
MathHelper.calcDistance(point3d8, point3d)
or MathHelper.calcDistance(point3d10, point3d) <
MathHelper.calcDistance(point3d8, point3d)):
QMessageBox.warning(
self, "Error",
Messages.ERR_FIX_TOO_CLOSE_USE_OVERHEAD_TOLERANCE)
# ErrorMessageBox.smethod_0(self, Messages.ERR_FIX_TOO_CLOSE_USE_OVERHEAD_TOLERANCE);
return
else:
resultPolylineAreaList.append(
PolylineArea([point3d5, point3d6]))
# line = new Line(point3d5, point3d6);
# AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer);
resultPolylineAreaList.append(
PolylineArea([point3d7, point3d8]))
# line = new Line(point3d7, point3d8);
# AcadHelper.smethod_18(transaction, blockTableRecord, line, constructionLayer);
point = [point3d1, point3d2, point3d3, point3d4]
polyline = AcadHelper.smethod_126(point)
polyline.set_Closed(True)
resultPolylineAreaList.append(polyline)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
else:
QMessageBox.warning(self, "Error",
Messages.ERR_RADIALS_TRACKS_DO_NOT_INTERSECT)
# ErrorMessageBox.smethod_0(self, Messages.ERR_RADIALS_TRACKS_DO_NOT_INTERSECT);
return
mapUnits = define._canvas.mapUnits()
constructionLayer = AcadHelper.createVectorLayer(
SurfaceTypes.FixConstruction, QGis.Line)
for polylinrArea0 in resultPolylineAreaList:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer,
polylinrArea0)
QgisHelper.appendToCanvas(define._canvas, [constructionLayer],
SurfaceTypes.FixConstruction, True)
self.resultLayerList2 = [constructionLayer]
QgisHelper.zoomToLayers(self.resultLayerList2)
def canvasPressEvent( self, e ):
define._messageLabel.setText("")
self.menuString = ""
pointBackground = e.pos()
# self.Point = QgisHelper.snapPoint(e.pos(), self.mSnapper, define._canvas)
self.Point, self.pointID, self.layer= self.snapPoint(e.pos())
self.selectedLayerFromSnapPoint = None
if ( self.mRubberBand == None ):
self.resultPolylineArea = PolylineArea()
self.mRubberBand0.reset( QGis.Polygon )
# define._canvas.clearCache ()
self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBand0 = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBand.setFillColor( self.mFillColor )
self.mRubberBand.setBorderColor( self.mBorderColour )
self.mRubberBand0.setFillColor( QColor(255, 255, 255, 100) )
self.mRubberBand0.setBorderColor( QColor(0, 0, 0) )
if ( e.button() == Qt.LeftButton ):
if self.Point == None:
self.mRubberBand.addPoint( self.toMapCoordinates( e.pos() ) )
self.resultPolylineArea.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() )))
if self.isPrimaryPolylineStarted:
self.primaryPolyline.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() )))
else:
self.mRubberBand.addPoint( self.Point )
self.resultPolylineArea.Add(PolylineAreaPoint(self.Point))
if self.isPrimaryPolylineStarted:
self.primaryPolyline.Add(PolylineAreaPoint(self.toMapCoordinates( e.pos() )))
else:
menu = None
if self.areaType == ProtectionAreaType.Secondary and len(self.resultPolylineArea) == 0:
menu = self.createContextMenu(self.areaType, True)
menu.exec_( define._canvas.mapToGlobal(e.pos() ))
return
if ( self.mRubberBand.numberOfVertices() > 2 ):
self.polygonGeom = self.mRubberBand.asGeometry()
else:
return
# QgsMapToolSelectUtils.setSelectFeatures( self.mCanvas, polygonGeom, e )
menu = self.createContextMenu(self.areaType)
menu.exec_( define._canvas.mapToGlobal(e.pos() ))
if self.menuString == "Cancel" or self.menuString == "Arc":
return
elif self.menuString == "Undo":
if ( self.mRubberBand.numberOfVertices() > 0 ):
self.mRubberBand = None
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.mRubberBand = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBand.setFillColor( self.mFillColor )
self.mRubberBand.setBorderColor( self.mBorderColour )
self.resultPolylineArea[self.resultPolylineArea.Count - 2].bulge = 0.0
self.resultPolylineArea.pop(self.resultPolylineArea.Count - 1)
if self.isPrimaryPolylineStarted and len(self.primaryPolyline) > 0:
self.primaryPolyline.pop(self.primaryPolyline.Count - 1)
for pt in self.resultPolylineArea.method_14():
self.mRubberBand.addPoint(pt)
return
elif self.menuString == "Enter":
# if self.areaType == ProtectionAreaType.Secondary:
# if self.resultPolylineArea.Count != 4:
# define._messageLabel.setText("The count of point of Secondary Area must be 4.")
# return
self.mRubberBand.reset( QGis.Polygon )
self.mRubberBand0.reset( QGis.Polygon )
# define._canvas.clearCache ()
self.mRubberBand0 = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBand0.setFillColor( QColor(255, 255, 255, 100) )
self.mRubberBand0.setBorderColor( QColor(0, 0, 0) )
for pt in self.resultPolylineArea.method_14():
self.mRubberBand0.addPoint(pt)
# self.mRubberBand0.addGeometry(self.polygonGeom, None)
n = self.mRubberBand0.numberOfVertices()
self.mRubberBand0.show()
self.mRubberBand = None
area = None
if self.areaType == ProtectionAreaType.Primary:
area = PrimaryObstacleArea(self.resultPolylineArea)
elif self.areaType == ProtectionAreaType.Secondary:
if len(self.resultPolylineArea) == 4:
area = SecondaryObstacleArea(self.resultPolylineArea[0].Position, self.resultPolylineArea[1].Position, self.resultPolylineArea[3].Position, self.resultPolylineArea[2].Position, MathHelper.getBearing(self.resultPolylineArea[0].Position, self.resultPolylineArea[1].Position))
else:
if self.primaryPolyline.Count < 2:
define._messageLabel.setText("The PrimaryLine in Secondary Area must exist.")
return
if self.isPrimaryPolylineStarted:
define._messageLabel.setText("You must finish the input of PrimaryLine.")
return
area = SecondaryObstacleAreaWithManyPoints(self.resultPolylineArea, self.primaryPolyline)
self.emit(SIGNAL("outputResult"), area, self.mRubberBand0)
n = 0
