def resultPointValueListMethod(self, resultValueList):
flag = FlightPlanBaseDlg.btnConstruct_Click(self)
if not flag:
return
point = Point3D()
try:
point = Point3D(float(resultValueList[1]), float(resultValueList[2]), float(resultValueList[3]))
except:
return
if (not self.flagP):
mapUnits = define._canvas.mapUnits()
self.constructionLayer = AcadHelper.createVectorLayer(self.surfaceType)
self.point3dP = point.smethod_167(0);
self.origin1P = self.method_31(self.polylineP, self.originP, self.point3dP, self.numP, self.metresP, self.speedP, self.num2P, self.orientationTypeP);
AcadHelper.setGeometryAndAttributesInLayer(self.constructionLayer, self.polylineP)
QgisHelper.appendToCanvas(define._canvas, [self.constructionLayer], self.surfaceType)
# polyline.Draw();
else:
mapUnits = define._canvas.mapUnits()
self.constructionLayer = AcadHelper.createVectorLayer(self.surfaceType)
self.originP = point.smethod_167(0);
self.polylineP, self.origin1P = self.method_30(self.originP, self.numP, self.metresP, self.speedP, self.num2P, self.orientationTypeP);
AcadHelper.setGeometryAndAttributesInLayer(self.constructionLayer, self.polylineP)
QgisHelper.appendToCanvas(define._canvas, [self.constructionLayer], self.surfaceType)
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
self.flagP = not self.flagP;
self.resultLayerList = [self.constructionLayer]
if (not self.flagP):
define._messageLabel.setText(Prompts.SECOND_POSITION_FINISH);
else:
define._messageLabel.setText(Prompts.POSITION_FINISH)
pass
def smethod_5(form_0, qasnapshot_0):
try:
# if (AcadHelper.Ready)
# {
# AcadHelper.smethod_2();
# if (!qasnapshot_0.ModelSpace)
# {
# AcadHelper.smethod_27(DrawingSpace.PaperSpace, true);
# }
# else
# {
# AcadHelper.smethod_27(DrawingSpace.ModelSpace, true);
# }
viewCenter = qasnapshot_0.ViewCenter
x = viewCenter.get_X() - qasnapshot_0.ViewSize / float(2)
point3d = qasnapshot_0.ViewCenter
point2d = Point3D(
x,
point3d.get_Y() - qasnapshot_0.ViewSize / float(2))
viewCenter1 = qasnapshot_0.ViewCenter
num = viewCenter1.get_X() + qasnapshot_0.ViewSize / float(2)
point3d1 = qasnapshot_0.ViewCenter
point2d1 = Point3D(
num,
point3d1.get_Y() + qasnapshot_0.ViewSize / float(2))
AcadHelper.smethod_66(point2d, point2d1)
# AcadHelper.smethod_3();
except:
QMessageBox.warning(form_0, "Error",
sys.exc_info()[0])
def openData(self):
try:
fileName = FlightPlanBaseDlg.openData(self)
if fileName == None:
return
doc = DataHelper.loadXmlDocFromFile(fileName)
dialogNodeList = doc.elementsByTagName(self.objectName())
if dialogNodeList.isEmpty():
raise UserWarning, "self file is not correct."
dialogElem = dialogNodeList.at(0).toElement()
trackNodeList = dialogElem.elementsByTagName("Track")
if trackNodeList.isEmpty():
return
elemTrack = trackNodeList.at(0).toElement()
elemStart = elemTrack.elementsByTagName("StartPoint").at(
0).toElement()
elemEnd = elemTrack.elementsByTagName("EndPoint").at(0).toElement()
x, y = DataHelper.getPointValueFromElem(elemStart)
self.parametersPanel.txtTrack.captureRadialTool.startPoint = Point3D(
x, y)
x, y = DataHelper.getPointValueFromElem(elemEnd)
self.parametersPanel.txtTrack.captureRadialTool.endPoint = Point3D(
x, y)
except BaseException as e:
QMessageBox.warning(self, "Error", e.message)
def method_33(self, fasDataBlockFile_0):
if (fasDataBlockFile_0 == None):
self.method_30()
return
self.parametersPanel.pnlOperationType.SelectedIndex = fasDataBlockFile_0.OperationType
self.parametersPanel.pnlSbasProvider.SelectedIndex = fasDataBlockFile_0.SbasProviderId
self.parametersPanel.pnlAirportId.Value = fasDataBlockFile_0.AirportId
self.parametersPanel.txtRunwayDesignator.Value = float(
fasDataBlockFile_0.RunwayNumber)
self.parametersPanel.cmbRunwayLetter.SelectedIndex = fasDataBlockFile_0.RunwayLetter
self.parametersPanel.pnlApproachPerformanceDesignator.SelectedIndex = fasDataBlockFile_0.ApproachPerformanceDesignator
self.parametersPanel.pnlRouteIndicator.SelectedItem = fasDataBlockFile_0.RouteIndicator
self.parametersPanel.pnlReferencePathDataSelector.Value = float(
fasDataBlockFile_0.ReferencePathDataSelector)
self.parametersPanel.pnlReferencePathId.Value = fasDataBlockFile_0.ReferencePathIdentifier
deltaFpapLatitude = fasDataBlockFile_0.LtpFtpLatitude
deltaFpapLongitude = fasDataBlockFile_0.LtpFtpLongitude
self.parametersPanel.pnlLtpFtp.Point3d = Point3D(
deltaFpapLongitude, deltaFpapLatitude)
self.parametersPanel.pnlLtpFtpEllipsoidalHeight.Value = fasDataBlockFile_0.LtpFtpHeight
deltaFpapLatitude = deltaFpapLatitude + fasDataBlockFile_0.DeltaFpapLatitude
deltaFpapLongitude = deltaFpapLongitude + fasDataBlockFile_0.DeltaFpapLongitude
self.parametersPanel.pnlFpap.Point3d = Point3D(deltaFpapLongitude,
deltaFpapLatitude)
self.parametersPanel.txtApproachTCH.Value = fasDataBlockFile_0.ApproachTch
self.parametersPanel.cmbApproachTCHunits.SelectedIndex = fasDataBlockFile_0.ApproachTchUnits
self.parametersPanel.pnlGPA.Value = fasDataBlockFile_0.GPA
self.parametersPanel.pnlCourseWidth.Value = fasDataBlockFile_0.CourseWidth
self.parametersPanel.pnlLengthOffset.Value = fasDataBlockFile_0.DeltaLengthOffset
self.parametersPanel.pnlHAL.Value = fasDataBlockFile_0.HAL
self.parametersPanel.pnlVAL.Value = fasDataBlockFile_0.VAL
self.method_31(False)
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 processMethod(self ,i ,j ,hCount,wCount,block,wStartNumber,hStartNumber,xStartValue,yStartValue,xOffSet, yOffSet,obstacleLayer,obstacleTable,obstacleUnits,mocMultiplier):
featureID = 0
while i <= hCount - 1:
j = 0
while j <= wCount - 1:
# altitude = block.value(wStartNumber, hStartNumber)
name = "DEM"
# startTime = time.time()
# print "startTime" + str(startTime)
if block.isNoData(j + wStartNumber, i + hStartNumber):
j += 1
continue
altitude = block.value(j + wStartNumber, i + hStartNumber)
trees = define._trees
tolerance = define._tolerance
point = QgsPoint(xStartValue + (j + wStartNumber) * xOffSet + xOffSet / 2, yStartValue - (i + hStartNumber) * yOffSet - yOffSet / 2)
position = Point3D()
positionDegree = Point3D()
if obstacleUnits == QGis.Meters:
position = Point3D(point.x(), point.y(), altitude)
if obstacleUnits != define._units:
positionDegree = QgisHelper.Meter2DegreePoint3D(position)
else:
positionDegree = Point3D(point.x(), point.y(), altitude)
if obstacleUnits != define._units:
position = QgisHelper.Degree2MeterPoint3D(positionDegree)
featureId = featureID
layerId = obstacleLayer.id()
obstacle = Obstacle(name, position, layerId, featureId, None, trees, mocMultiplier, tolerance)
obstacle.positionDegree = positionDegree
# middleTime = time.time()
# print "middleTime" + str(middleTime)
# obstacle.positionDegree = positionDegree
obstacleTable.checkObstacle(obstacle)
self.lock.acquire()
try:
obstacleTable.progress.setValue(obstacleTable.progress.value() + 1)
QApplication.processEvents()
finally:
self.lock.release()
# endTime = time.time()
# print "endTime" + str(endTime)
j += 1
featureID += 1
# obstacle = None
# print i
i += 1
def get_Point3d(self):
if (not self.IsValid):
raise Messages.ERR_INVALID_OR_INCOMPLETE_POSITION
if (self.xy):
if (self.altitude == None or math.isinf(self.altitude)):
return Point3D(self.xlat, self.ylon, 0)
return Point3D(self.xlat, self.ylon, self.altitude)
result, num, num1 = Geo.smethod_3(Degrees.smethod_1(self.xlat), Degrees.smethod_5(self.ylon))
if (not result):
raise "Geo.LastError"
if (self.altitude == None or math.isinf(self.altitude)):
return Point3D(num, num1, 0)
return Point3D(num, num1, self.altitude)
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 __init__(self, point3d_0 = None, bulge = 0.0):
# private Point3d position;
if not isinstance(point3d_0, Point3D):
point3d_0 = Point3D(point3d_0.x(), point3d_0.y())
self.position = point3d_0
# private double bulge;
self.bulge = bulge
def autoCalcFinishMagVar(self):
try:
if self.parametersPanel.chbAutoFinishMagVar.Checked:
finishPt = None
finishLat = None
finishLon = None
degree3 = None
num = None
result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3(
)
if (result):
value = float(self.parametersPanel.txtForwardTP.Value)
value1 = float(self.parametersPanel.txtForwardTP.Value)
distance = self.parametersPanel.txtDistanceP.Value
result1, degree2, degree3, num = Geo.smethod_6(
self.parametersPanel.cmbCalculationTypeP.SelectedItem,
degree, degree1, value, distance)
if (result1):
finishPt = Point3D(degree3, degree2)
finishLat = degree2
finishLon = degree3
if finishPt != None and self.model != None and self.date != None:
# result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3();
result2, degree2 = Geo.smethod_7(finishLat, finishLon,
Altitude(0), self.model,
self.date)
if (result2):
degree2 = round(degree2, 2)
self.parametersPanel.pnlVarFinishP.Value = degree2
except:
pass
def basedOnCmbObj_Event_0(self):
if self.currentLayer == None or not self.currentLayer.isValid():
return
if len(self.vorDmeFeatureArray) == 0:
return
layer = self.currentLayer
idx = layer.fieldNameIndex('Type')
idxName = layer.fieldNameIndex('Name')
idxLat = layer.fieldNameIndex('Latitude')
idxLong = layer.fieldNameIndex('Longitude')
idxAltitude = layer.fieldNameIndex('Altitude')
feat = self.vorDmeFeatureArray.__getitem__(
self.parametersPanel.cmbBasedOn.SelectedItem)
attrValue = feat.attributes()[idxLat].toDouble()
lat = attrValue[0]
attrValue = feat.attributes()[idxLong].toDouble()
long = attrValue[0]
attrValue = feat.attributes()[idxAltitude].toDouble()
alt = attrValue[0]
self.parametersPanel.pnlNavAid.Point3d = Point3D(long, lat, alt)
def method_0(self, point3dCollection_0):
self.time = 0.0
point3d = Point3D(0, 0, 0)
matrix3d = Matrix3d.Displacement(self.ptBase.GetVectorTo(point3d))
matrix3d1 = Matrix3d.Rotation(self.trackRad, Vector3d(0, 0, 1),
point3d)
item = point3dCollection_0[0]
point3d1 = item.TransformBy(matrix3d).TransformBy(matrix3d1)
point3d2 = point3d1
point3d3 = point3d1
point3d4 = point3d1
point3d5 = point3d1
for i in range(1, len(point3dCollection_0)):
item1 = point3dCollection_0[i]
point3d6 = item1.TransformBy(matrix3d).TransformBy(matrix3d1)
if (point3d6.get_Y() > point3d5.get_Y()):
point3d5 = point3d6
if (point3d6.get_X() > point3d4.get_X()):
point3d4 = point3d6
if (point3d6.get_Y() < point3d3.get_Y()):
point3d3 = point3d6
if (point3d6.get_X() < point3d2.get_X()):
point3d2 = point3d6
point3d7 = point3d5.TransformBy(Matrix3d.Inverse(matrix3d1))
point3d5 = point3d7.TransformBy(Matrix3d.Inverse(matrix3d))
point3d8 = point3d4.TransformBy(Matrix3d.Inverse(matrix3d1))
point3d4 = point3d8.TransformBy(Matrix3d.Inverse(matrix3d))
point3d9 = point3d3.TransformBy(Matrix3d.Inverse(matrix3d1))
point3d3 = point3d9.TransformBy(Matrix3d.Inverse(matrix3d))
point3d10 = point3d2.TransformBy(Matrix3d.Inverse(matrix3d1))
point3d2 = point3d10.TransformBy(Matrix3d.Inverse(matrix3d))
self.bounds = [point3d5, point3d4, point3d3, point3d2]
def btnConstruct_Click(self):
flag = FlightPlanBaseSimpleDlg.btnConstruct_Click(self)
if not flag:
return
num = 0.0
point3d = Point3D()
point3d1 = Point3D()
if not self.method_27(True):
return
point3d2 = self.parametersPanel.pnlTHR.getPoint3D()
point3d3 = self.parametersPanel.pnlNavAid.getPoint3D()
num1 = Unit.ConvertDegToRad(float(self.parametersPanel.txtDirection.Value))
point3d4 = MathHelper.distanceBearingPoint(point3d2, num1 + 3.14159265358979, 1400)
num2 = -1
if MathHelper.smethod_115(point3d3, point3d2, point3d4):
num2 = 1
point3d5 = MathHelper.distanceBearingPoint(point3d4, num2 * 1.5707963267949 + num1, 150)
point3d6 = MathHelper.distanceBearingPoint(point3d5, num1 + 3.14159265358979, 17120)
if self.parametersPanel.cmbCategory.currentIndex() != 1:
num = 0.267949192
elif self.parametersPanel.cmbCategory.currentIndex() == 1:
num = 0.577350269
point3d7 = MathHelper.distanceBearingPoint(point3d6, num1 - num2 * 1.5707963267949, 150 + num * 17120)
MathHelper.distanceBearingPoint(point3d5, num1, 150 / num)
point3d = MathHelper.getIntersectionPoint(point3d3, MathHelper.distanceBearingPoint(point3d3, num1 + 1.5707963267949, 100), point3d2, point3d4)
if point3d == None:
raise UserWarning, Messages.ERR_FAILED_TO_CALCULATE_INTERSECTION_POINT
num3 = MathHelper.calcDistance(point3d3, point3d) / 0.087488664
if MathHelper.calcDistance(point3d, point3d4) >= num3:
point3d1 = point3d4
MathHelper.distanceBearingPoint(point3d6, num1 - num2 * 1.5707963267949, 1525.321791)
else:
point3d1 = MathHelper.distanceBearingPoint(point3d, num1 + 3.14159265358979, num3)
MathHelper.distanceBearingPoint(point3d6, num1 - num2 * 1.5707963267949, 150 + 0.087488664 * (17120 - MathHelper.calcDistance(point3d4, point3d1)))
MathHelper.distanceBearingPoint(point3d4, num1 + 3.14159265358979, 17120);
constructionLayer = AcadHelper.createVectorLayer("AAConstruction", QGis.Line)
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, PolylineArea([point3d7, point3d4]))
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, PolylineArea([point3d1, point3d4, point3d5]))
QgisHelper.appendToCanvas(define._canvas, [constructionLayer], SurfaceTypes.ApproachAlignment)
QgisHelper.zoomToLayers([constructionLayer])
self.resultLayerList = [constructionLayer]
def resultPointValueListMethod(self, resultValueList):
if len(resultValueList) > 0:
point3d = Point3D(float(resultValueList[1]), float(resultValueList[2]), float(resultValueList[3]))
resultDlg, procEntityBase = DlgAixmSelectPosition.smethod_0(self, self.data, point3d, ProcEntityListType.Holding)
if (resultDlg and procEntityBase != None):
if (not self.pnlBasedOn.Contains(procEntityBase)):
self.pnlBasedOn.Add(procEntityBase);
self.pnlBasedOn.SelectedIndex = self.pnlBasedOn.IndexOf(procEntityBase);
def basedOnCmbFill(self, layer, basedOnCmbObj, vorDmePositionPanelObj):
basedOnCmbObj.Clear()
vorDmePositionPanelObj.Point3d = None
idx = layer.fieldNameIndex('Type')
idxName = layer.fieldNameIndex('Name')
idxLat = layer.fieldNameIndex('Latitude')
idxLong = layer.fieldNameIndex('Longitude')
idxAltitude = layer.fieldNameIndex('Altitude')
vorDmeList = []
vorDmeFeatureList = []
if idx >= 0:
featIter = layer.getFeatures()
for feat in featIter:
attrValue = feat.attributes()[idx].toString()
attrValue = QString(attrValue)
attrValue = attrValue.replace(" ", "")
attrValue = attrValue.replace("/", "")
attrValue = attrValue.toUpper()
if self.parametersPanel.cmbNavAidType.SelectedIndex == 0:
if attrValue == "VOR" or attrValue == "VORDME" or attrValue == "VORTAC" or attrValue == "TACAN":
vorDmeList.append(attrValue)
vorDmeFeatureList.append(feat)
else:
if attrValue == "NDB" or attrValue == "NDBDME":
vorDmeList.append(attrValue)
vorDmeFeatureList.append(feat)
if len(vorDmeList) != 0:
i = -1
basedOnCmbObjItems = []
resultfeatDict = dict()
for feat in vorDmeFeatureList:
typeValue = feat.attributes()[idx].toString()
nameValue = feat.attributes()[idxName].toString()
basedOnCmbObjItems.append(typeValue + " " + nameValue)
resultfeatDict.__setitem__(typeValue + " " + nameValue,
feat)
basedOnCmbObjItems.sort()
basedOnCmbObj.Items = basedOnCmbObjItems
basedOnCmbObj.SelectedIndex = 0
# if idxAttributes
feat = resultfeatDict.__getitem__(basedOnCmbObjItems[0])
attrValue = feat.attributes()[idxLat].toDouble()
lat = attrValue[0]
attrValue = feat.attributes()[idxLong].toDouble()
long = attrValue[0]
attrValue = feat.attributes()[idxAltitude].toDouble()
alt = attrValue[0]
vorDmePositionPanelObj.Point3d = Point3D(long, lat, alt)
self.connect(basedOnCmbObj, SIGNAL("Event_0"),
self.basedOnCmbObj_Event_0)
return resultfeatDict
return dict()
def MovePolyLine(polylineArea, dx, dy):
resultPolylineArea = PolylineArea()
if not isinstance(polylineArea, PolylineArea) or len(polylineArea) == 0:
return None
for polylineAreaPt in polylineArea:
pt = polylineAreaPt.Position
newPt = Point3D(pt.x() - dx, pt.y() - dy, pt.get_Z())
resultPolylineArea.Add(PolylineAreaPoint(newPt, polylineAreaPt.bulge))
return resultPolylineArea
def set_Position(self, point3d):
self.position = point3d
if self.layerType == QGis.Line:
self.geometry = PolylineArea([
point3d,
Point3D(point3d.get_X() + 0.000000001, point3d.get_Y())
])
elif self.layerType == QGis.Point:
self.geometry = point3d
elif self.layerType == QGis.Polygon:
self.geometry = PolylineArea([
point3d,
Point3D(point3d.get_X() + 0.000000001, point3d.get_Y()),
Point3D(point3d.get_X() + 0.000000001,
point3d.get_Y() + 0.000000001),
Point3D(point3d.get_X(),
point3d.get_Y() + 0.000000001), point3d
])
def __init__(self,
point3d_0=Point3D(),
double_0=0.0,
double_1=0.0,
double_2=0.0,
double_3=0.0):
IBaroVnavSurface.__init__(self)
self.Type = "Z"
IBaroVnavSurface.method_2(self, point3d_0, double_0)
self.xstart = double_1
self.tanslope = double_3
self.mocma = double_2
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_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 tableViewObstacleMouseTeleaseEvent_rightButton(self, e):
if self.obstaclesModel == None:
return
featID = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexObjectId)).toString()
layerID = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexLayerId)).toString()
name = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexName)).toString()
xValue = self.obstaclesModel.data(
self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexX)).toString()
yValue = self.obstaclesModel.data(
self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexY)).toString()
altitudeMValue = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexAltM)).toString()
surfaceName = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexSurface)).toString()
ocaMValue = self.obstaclesModel.data(
self.obstaclesModel.index(
self.selectedObstacleMoselIndex.row(),
self.obstaclesModel.IndexOcaM)).toString()
# ocaMValue = self.obstaclesModel.data(self.obstaclesModel.index(self.selectedObstacleMoselIndex.row(), self.obstaclesModel.IndexOcaM)).toString()
obstacle = Obstacle(
name, Point3D(float(xValue), float(yValue), float(altitudeMValue)),
layerID, featID, None, 0.0, self.obstaclesModel.MocMultiplier, 0.0)
self.changedCriticalObstacleValue = {
"Obstacle": obstacle,
"SurfaceName": surfaceName,
"OcaM": float(ocaMValue) if ocaMValue != "" else None
}
menu = QMenu()
actionSetCriticalObst = QgisHelper.createAction(
menu, "Set Most Critical Obstacles", self.menuSetCriticalObstClick)
menu.addAction(actionSetCriticalObst)
menu.exec_(self.ui.tblObstacles.mapToGlobal(e.pos()))
def __init__(self,
point3d_0=Point3D(),
double_0=0.0,
double_1=0.0,
double_2=0.0,
double_3=0.0,
double_4=0.0):
IBaroVnavSurface.__init__(self)
self.Type = "H"
IBaroVnavSurface.method_2(self, point3d_0, double_0)
self.xstart = min([double_1, double_2])
self.tanslope = (max([double_3, double_4]) - min(
[double_3, double_4])) / (max([double_1, double_2]) -
min([double_1, double_2]))
self.mocfa = max([double_3, double_4])
self.mocma = min([double_3, double_4])
def aerodromeCmbObj_Event_0(self):
if len(self.arpFeatureArray) == 0:
return
self.parametersPanel.pnlNavAid.Point3d = None
self.thrPoint3d = None
self.thrEndPoint3d = None
idxName = self.currentLayer.fieldNameIndex('Name')
idxLat = self.currentLayer.fieldNameIndex('Latitude')
idxLong = self.currentLayer.fieldNameIndex('Longitude')
idxAltitude = self.currentLayer.fieldNameIndex('Altitude')
self.rwyFeatureArray = []
# if idxAttributes
for feat in self.arpFeatureArray:
attrValue = feat.attributes()[idxName].toString()
if attrValue != self.parametersPanel.cmbAerodrome.SelectedItem:
continue
attrValue = feat.attributes()[idxLat].toDouble()
lat = attrValue[0]
attrValue = feat.attributes()[idxLong].toDouble()
long = attrValue[0]
attrValue = feat.attributes()[idxAltitude].toDouble()
alt = attrValue[0]
self.parametersPanel.pnlNavAid.Point3d = Point3D(long, lat, alt)
break
idxAttr = self.currentLayer.fieldNameIndex('Attributes')
if idxAttr >= 0:
self.parametersPanel.cmbRwyDir.Clear()
rwyFeatList = []
featIter = self.currentLayer.getFeatures()
for feat in featIter:
attrValue = feat.attributes()[idxAttr].toString()
if attrValue == self.parametersPanel.cmbAerodrome.SelectedItem:
attrValue = feat.attributes()[idxName].toString()
s = attrValue.replace(" ", "")
compStr = s.left(6).toUpper()
if compStr == "THRRWY":
valStr = s.right(s.length() - 6)
self.parametersPanel.cmbRwyDir.Add(
self.parametersPanel.cmbAerodrome.SelectedItem +
" RWY " + valStr)
rwyFeatList.append(feat)
self.rwyFeatureArray = rwyFeatList
self.rwyDirCmbObj_Event_0()
def basedOnCmbFill(self, layer, basedOnCmbObj, vorDmePositionPanelObj):
idx = layer.fieldNameIndex('Type')
idxName = layer.fieldNameIndex('Name')
idxLat = layer.fieldNameIndex('Latitude')
idxLong = layer.fieldNameIndex('Longitude')
idxAltitude = layer.fieldNameIndex('Altitude')
vorDmeList = []
vorDmeFeatureList = []
if idx >= 0:
featIter = layer.getFeatures()
for feat in featIter:
attrValue = feat.attributes()[idx].toString()
attrValue = QString(attrValue)
attrValue = attrValue.replace(" ", "")
attrValue = attrValue.replace("/", "")
attrValue = attrValue.toUpper()
if attrValue == "DME":
vorDmeList.append(attrValue)
vorDmeFeatureList.append(feat)
if len(vorDmeList) != 0:
i = -1
basedOnCmbObjItems = []
for feat in vorDmeFeatureList:
typeValue = feat.attributes()[idx].toString()
nameValue = feat.attributes()[idxName].toString()
basedOnCmbObjItems.append(typeValue + " " + nameValue)
basedOnCmbObjItems.sort()
basedOnCmbObj.Items = basedOnCmbObjItems
basedOnCmbObj.SelectedIndex = 0
# if idxAttributes
feat = vorDmeFeatureList[0]
attrValue = feat.attributes()[idxLat].toDouble()
lat = attrValue[0]
attrValue = feat.attributes()[idxLong].toDouble()
long = attrValue[0]
attrValue = feat.attributes()[idxAltitude].toDouble()
alt = attrValue[0]
vorDmePositionPanelObj.Point3d = Point3D(long, lat, alt)
self.connect(basedOnCmbObj, SIGNAL("Event_0"), self.basedOnCmbObj_Event_0)
return vorDmeFeatureList
def TransformBy(self, matrix3d):
polylineAreaPointList = []
for polylineAreaPoint in self:
point3d = polylineAreaPoint.Position
pointMatrix = [point3d.get_X(), point3d.get_Y(), point3d.get_Z(), 1]
resultMatrix = []
for matrix in matrix3d:
matrix = numpy.multiply(matrix, pointMatrix)
value = 0.0
for num in matrix:
value += num
resultMatrix.append(value)
polylineAreaPointList.append(PolylineAreaPoint(Point3D(resultMatrix[0], resultMatrix[1], resultMatrix[2]), polylineAreaPoint.Bulge))
resultPolylineArea = PolylineArea()
for polylineAreaPoint in polylineAreaPointList:
resultPolylineArea.Add(polylineAreaPoint)
return resultPolylineArea
def IntersectWithNew(self, other, tolerance = 0.0, result = []):
# result = []
minePointList = self.getQgsPointList()
otherPointList = other.getQgsPointList()
for i in range(1, len(minePointList)):
mineGeom = QgsGeometry.fromPolyline([minePointList[i - 1], minePointList[i]])
for j in range(1, len(otherPointList)):
otherGeom = QgsGeometry.fromPolyline([otherPointList[j - 1], otherPointList[j]])
if mineGeom.intersects(otherGeom):
intersectGeom = mineGeom.intersection(otherGeom)
pt = intersectGeom.asPoint()
if pt.x() != 0 and pt.y() != 0:
result.append(Point3D(pt.x(), pt.y()))
elif mineGeom.touches(otherGeom):
pass
return len(result) > 0, result
def LoadData(self, reader, version):
QARecord.LoadData(reader, version)
for case in switch(version):
if case(QAFileVersion.V8) or case(QAFileVersion.V8_1) or case(
QAFileVersion.V10):
self.modelSpace = reader.ReadBoolean()
self.viewSize = reader.ReadDouble()
self.viewCenter = Point3D(reader.ReadDouble(),
reader.ReadDouble(),
reader.ReadDouble())
self.imageFormatType = reader.ReadByte()
self.imageRatio = reader.ReadDouble()
num = reader.ReadInt64()
self.value.SetLength(num)
# self.value.Seek((long)0, SeekOrigin.Begin);
self.value.write(reader.ReadBytes(int(num)), 0, int(num))
return
else:
raise SystemError
def loadObstaclesVector(self, obstacleLayers, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading Vector Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
self.progress.setValue(0)
for ly in obstacleLayers:
maxium += ly.featureCount()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
for obstacleLayer in obstacleLayers:
obstacleUnits = obstacleLayer.crs().mapUnits()
features = QgisHelper.getFeaturesInLayerExtent(
define._canvas, obstacleLayer, surfaceLayers,
SelectionModeType.Automatic)
# print len(features)
for feature in features:
name = feature.attribute("Name").toString()
altitude = feature.attribute("Altitude").toFloat()[0]
trees = define._trees
tolerance = define._tolerance
point = feature.geometry().asPoint()
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
featureId = feature.id()
layerId = obstacleLayer.id()
obstacle = Obstacle(name, position, layerId, featureId, None,
trees, ObstacleTable.MocMultiplier,
tolerance)
obstacle.positionDegree = positionDegree
# obstacle.positionDegree = positionDegree
self.checkObstacle(obstacle)
self.progress.setValue(self.progress.value() + 1)
QApplication.processEvents()
QApplication.processEvents()
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None
def loadObstaclesDEM(self, obstacleLayersDEM, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading DEM Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
offset = 0.0
self.progress.setValue(0)
wCount = 0
hCount = 0
for ly in obstacleLayersDEM:
demDataProvider = ly.dataProvider()
boundDem = demDataProvider.extent()
xMin = boundDem.xMinimum()
xMax = boundDem.xMaximum()
yMin = boundDem.yMinimum()
yMax = boundDem.yMaximum()
bound = QgisHelper.getIntersectExtent(
ly, QgsGeometry.fromRect(boundDem), surfaceLayers)
# boundGeom = QgsGeometry.fromRect(bound)
if bound == None:
continue
block = ly.dataProvider().block(0, ly.extent(), ly.width(),
ly.height())
xMinimum = ly.dataProvider().extent().xMinimum()
yMaximum = ly.dataProvider().extent().yMaximum()
yMinimum = ly.dataProvider().extent().yMinimum()
xMaximum = ly.dataProvider().extent().xMaximum()
xOffSet = ly.extent().width() / ly.width()
yOffSet = ly.extent().height() / ly.height()
offset = xOffSet
if bound.xMinimum() < xMinimum:
wStartNumber = 0
xStartValue = xMinimum
else:
wStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
hStartNumber = 0
yStartValue = yMaximum
else:
hStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / xOffSet)
hCount = int(math.fabs(yEndValue - yStartValue) / yOffSet)
pixelCount = hCount
maxium += pixelCount
cellSizeWnd = cellsizeWnd(offset, wCount * hCount, maxium * 0.04)
cellSizeWnd.setWindowTitle("Input Cell Size")
result = cellSizeWnd.exec_()
cellRate = 1
if result == 1:
offset = cellSizeWnd.cellsize
maxium = cellSizeWnd.cellCount + 2
cellRate = cellSizeWnd.cellRate
# print cellSizeWnd.textedit1.text()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
trees = define._treesDEM
tolerance = define._toleranceDEM
for obstacleLayer in obstacleLayersDEM:
obstacleUnits = obstacleLayer.crs().mapUnits()
demDataProvider = obstacleLayer.dataProvider()
boundDem = demDataProvider.extent()
bound = QgisHelper.getIntersectExtent(
obstacleLayer, QgsGeometry.fromRect(boundDem), surfaceLayers)
if bound == None:
continue
boundGeom = QgsGeometry.fromRect(bound)
if not boundGeom.intersects(QgsGeometry.fromRect(boundDem)):
continue
block = obstacleLayer.dataProvider().block(1,
obstacleLayer.extent(),
obstacleLayer.width(),
obstacleLayer.height())
xMinimum = obstacleLayer.extent().xMinimum()
yMaximum = obstacleLayer.extent().yMaximum()
yMinimum = obstacleLayer.extent().yMinimum()
xMaximum = obstacleLayer.extent().xMaximum()
xOffSet = obstacleLayer.extent().width() / obstacleLayer.width()
yOffSet = obstacleLayer.extent().height() / obstacleLayer.height()
if bound.xMinimum() < xMinimum:
hStartNumber = 0
xStartValue = xMinimum
else:
hStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
wStartNumber = 0
yStartValue = yMaximum
else:
wStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / offset)
hCount = int(math.fabs(yEndValue - yStartValue) / offset)
xPixelWidth = 0.0
yPixelWidth = 0.0
featureID = 0
# i = 0
# k = 0
# altitudeList = []
# self.progress.setValue(0)
# while i <= hCount - 1:
# j = 0
# while j <= wCount - 1:
# if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# altitudeList.append(None)
# continue
# altitude = block.value(j * int(cellRate) + wStartNumber, i * int(cellRate) + hStartNumber)
# altitudeList.append(altitude)
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# i += 1
i = 0
k = 0
name = "DEM"
semiXoffset = xOffSet / 2
semiYoffset = yOffSet / 2
while i <= hCount - 1:
j = 0
while j <= wCount - 1:
if block.isNoData(j * cellRate + wStartNumber,
i * cellRate + hStartNumber):
self.progress.setValue(k)
QApplication.processEvents()
j += 1
k += 1
continue
altitude = block.value(j * cellRate + wStartNumber,
i * cellRate + hStartNumber)
# # if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# # j += 1
# # self.progress.setValue(self.progress.value() + 1)
# # QApplication.processEvents()
# # continue
# # altitude = block.value(j* int(cellRate) + wStartNumber, i* int(cellRate)+ hStartNumber)
# altitude = altitudeList[k]
# if altitude == None:
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# continue
point = QgsPoint(
xStartValue + (i * cellRate) * xOffSet + semiXoffset,
yStartValue - (j * cellRate - 1) * yOffSet -
semiYoffset)
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
obstacle = Obstacle(name, position, obstacleLayer.id(),
featureID, None, trees,
ObstacleTable.MocMultiplier, tolerance)
obstacle.positionDegree = positionDegree
if self.manualPolygon != None:
if not self.manualPolygon.contains(obstacle.Position):
continue
self.checkObstacle(obstacle)
self.progress.setValue(k)
QApplication.processEvents()
j += 1
featureID += 1
k += 1
i += 1
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None