def __init__(self, parent):
FlightPlanBaseSimpleDlg.__init__(self, parent)
self.setObjectName("ApproachAlignmentDesigner")
self.surfaceType = SurfaceTypes.ApproachAlignment
self.initParametersPan()
self.setWindowTitle(SurfaceTypes.ApproachAlignment)
QgisHelper.matchingDialogSize(self, 670, 600)
self.arpFeatureArray = []
self.currentLayer = define._canvas.currentLayer()
self.rwyFeatureArray = []
self.thrPoint3d = None
self.thrEndPoint3d = None
self.resultLayers = []
self.initAerodromeAndRwyCmb()
pt = QaHeadingColumn("ttt", 2, True)
d = pt.__class__.__dict__['Index']
pass
def manualEvent(self, index):
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.manualPolygon = None
if index != 0:
self.toolSelectByPolygon = RubberBandPolygon(define._canvas)
define._canvas.setMapTool(self.toolSelectByPolygon)
self.connect(self.toolSelectByPolygon, SIGNAL("outputResult"), self.outputResultMethod)
else:
self.mapToolPan = QgsMapToolPan(define._canvas)
define._canvas.setMapTool(self.mapToolPan )
def __init__(self, parent):
FlightPlanBaseDlg.__init__(self, parent)
self.setObjectName("PathTerminatorsDlg")
self.surfaceType = SurfaceTypes.ProcedureExport
self.selectedRow = None
self.editingModelIndex = None
self.initParametersPan()
self.setWindowTitle(SurfaceTypes.ProcedureExport)
self.resize(540, 550)
QgisHelper.matchingDialogSize(self, 540, 650)
self.surfaceList = None
self.loaderAixm = DataBaseLoaderAixm()
self.directory = None
self.adding = False
self.newRowIndex = -1
# assa = vars(SurfaceTypes)
# asa = SurfaceTypes.__dict__
pass
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setObjectName("FixToleranceAreaDlg")
self.resize(470, 400)
QgisHelper.matchingDialogSize(self, 650, 450)
ui = Ui_FixToleranceArea()
ui.setupUi(self)
self.parametersPanel = ui
self.uiStateInit()
self.initParametersPan()
self.setWindowTitle(SurfaceTypes.FixToleranceArea)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/btnImage/dlgIcon.png"), QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.resultLayerList1 = []
self.resultLayerList2 = []
self.surfaceType2 = SurfaceTypes.FixConstruction
self.surfaceType1 = SurfaceTypes.OverheadTolerance
def getExtentForLocate(self, sourceRow):
surfaceType = self.source.item(sourceRow, self.IndexSurface).text()
surfaceLayers = QgisHelper.getSurfaceLayers(self.surfaceType)
rect = QgsRectangle()
rect.setMinimal()
for sfLayer in surfaceLayers:
features = sfLayer.getFeatures()
for feature in features:
surfaceString = feature.attribute("surface").toString()
if surfaceString == surfaceType:
geom = feature.geometry()
rect.combineExtentWith(geom.boundingBox())
return rect
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 snapPoint == None:
self.endPoint = self.toMapCoordinates(e.pos())
else:
self.endPoint = snapPoint
self.drawLine()
def imethod_1(self, layers):
linesList = []
pointList = self.paOIS.method_14_closed()
linesList.append((pointList, [
("surface", PinsSurfaceType.PinsSurfaceType_LevelOIS)
]))
polyline = self.paOCS.method_14_closed()
linesList.append(
(polyline, [("surface", PinsSurfaceType.PinsSurfaceType_OCS)]))
resultLayer = QgisHelper.createPolylineLayer(
"Pins Visual Segment Departure Manouvering 2D", linesList,
[QgsField("surface", QVariant.String)])
layers.append(resultLayer)
def criticalLocate(self):
point = None
try:
point = QgsPoint(float(self.ui.txtCriticalX.text()),
float(self.ui.txtCriticalY.text()))
except:
return
if define._units == QGis.Meters:
extent = QgsRectangle(point.x() - 350,
point.y() - 350,
point.x() + 350,
point.y() + 350)
else:
extent = QgsRectangle(point.x() - 0.005,
point.y() - 0.005,
point.x() + 0.005,
point.y() + 0.005)
if extent is None:
return
QgisHelper.zoomExtent(point, extent, 2)
def btnDropDown_Click(self):
self.mnuArea = QtGui.QMenu("")
self.mniCopy = QgisHelper.createAction(self, "Copy", self.menuCopyActionEvent, None, "copy", None)
self.mniPaste = QgisHelper.createAction(self, "Paste", self.menuPasteActionEvent, None, "paste", None)
self.mnuArea.addAction(self.mniCopy)
self.mnuArea.addAction(self.mniPaste)
flag = True;
obstacleArea = self.area;
self.mniCopy.setEnabled(False if(obstacleArea == None) else obstacleArea.IsValid);
if (self.mniCopy.isEnabled()):
self.mniCopy.setText("{%s} {%s}"%(Captions.COPY, obstacleArea.ToString()));
if (self.ClipboardObstacleArea == None):
flag = False;
else:
flag = self.comboBox.count() == 4 if(isinstance(self.ClipboardObstacleArea, ComplexObstacleArea)) else True;
self.mniPaste.setEnabled(flag);
if (self.mniPaste.isEnabled()):
self.mniPaste.setText("{%s} {%s}"%(Captions.PASTE, self.ClipboardObstacleArea.ToString()));
rcRect = self.imgStatus.geometry()
ptPoint = rcRect.bottomRight()
self.mnuArea.exec_( self.mapToGlobal(ptPoint) )
def getExtentForLocate(self, sourceRow):
extent = None
surfaceType = None
if self.IndexSurface < 0:
surfaceType = self.surfaceType
else:
surfaceType = self.source.item(sourceRow, self.IndexSurface).text()
surfaceLayers = QgisHelper.getSurfaceLayers(self.surfaceType)
for sfLayer in surfaceLayers:
lId = sfLayer.name()
if lId.contains(surfaceType):
extent = sfLayer.extent()
break
return extent
def __init__(self, parent):
FlightPlanBaseDlg.__init__(self, parent)
s = QString("safggjkk")
x = s.mid(3, 2)
# dlg = DlgHelp()
# dlg.exec_()
self.setObjectName("PathTerminatorsDlg")
self.surfaceType = SurfaceTypes.FasDataBlock
self.selectedRow = None
self.editingModelIndex = None
self.initParametersPan()
self.setWindowTitle(SurfaceTypes.FasDataBlock)
self.resize(540, 550)
QgisHelper.matchingDialogSize(self, 630, 700)
self.surfaceList = None
ss = bytearray(40)
s = len(ss)
pass
def DrawCanvas(self):
qgsLayerTreeView = define._mLayerTreeView
groupName = self.surfaceType
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.resultLayerList) > 0:
QgisHelper.removeFromCanvas(define._canvas, self.resultLayerList)
self.resultLayerList = []
else:
QtGui.QMessageBox.warning(self, "Warning", "Please remove \"" + self.surfaceType + "\" layer group from LayerTreeView.")
return
constructionLayer = AcadHelper.createVectorLayer(self.surfaceType);
if self.comboBox.currentIndex() == ProtectionAreaType.Primary or self.comboBox.currentIndex() == ProtectionAreaType.Secondary:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, self.area.PreviewArea, True)
elif self.comboBox.currentIndex() == ProtectionAreaType.PrimaryAndSecondary:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, self.area.primaryArea.PreviewArea, True)
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, self.area.secondaryArea1.PreviewArea, True)
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, self.area.secondaryArea2.PreviewArea, True)
else:
for obstacleArea in self.area:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, obstacleArea.PreviewArea, True)
QgisHelper.appendToCanvas(define._canvas, [constructionLayer], self.surfaceType)
self.resultLayerList = [constructionLayer]
def method_3(self): #out Degrees degrees_0, out Degrees degrees_1)
if self.getUnit() != QGis.Meters:
try:
return True, self.resultPoint3d.get_Y(
), self.resultPoint3d.get_X()
except:
return False, None, None
else:
point3dGeo = QgisHelper.CrsTransformPoint(
self.resultPoint3d.get_X(), self.resultPoint3d.get_Y(),
define._xyCrs, define._latLonCrs)
try:
return True, point3dGeo.get_Y(), point3dGeo.get_X()
except:
return False, None, None
def AreaResult(self, area, rubberBand):
if area != None:
rubberBand.setFillColor( QColor(46, 64, 142, 100) )
rubberBand.setBorderColor( QColor(0, 10, 238) )
define._canvas.refresh()
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.complexObstacleArea.Add(area)
self.stdItemModel.setItem(self.itemCount, QStandardItem(area.ToString()))
# polygon = rubberBand.asGeometry()
# lineList = polygon.asPolygon()
# self.resultPolylineAreaListForDrawing.append(PolylineArea(lineList[0]))
self.itemCount += 1
AcadHelper.setGeometryAndAttributesInLayer(self.constructionLayer, area.PreviewArea, True)
def __init__(self, canvas, annotation=None):
self.canvas = canvas
# self.tableView = tableView
# self.standardItemModel = standardItemModel
# self.txtXCoord = txtXCoord
# self.txtYCoord = txtYCoord
QgsMapToolEmitPoint.__init__(self, self.canvas)
self.annotation = annotation
self.mSnapper = QgsMapCanvasSnapper(canvas)
self.rubberBand = QgsRubberBand(canvas, QGis.Point)
self.rubberBand.setColor(Qt.red)
self.rubberBand.setWidth(10)
self.rubberBandClick = QgsRubberBand(canvas, QGis.Point)
self.rubberBandClick.setColor(Qt.green)
self.rubberBandClick.setWidth(3)
self.obstaclesLayerList = QgisHelper.getSurfaceLayers(
SurfaceTypes.Obstacles)
self.demLayerList = QgisHelper.getSurfaceLayers(SurfaceTypes.DEM)
# lblDoc = QTextDocument(label)
# self.annotation.setDocument(lblDoc)
# self.annotation.setFrameBackgroundColor(QColor(0,0,0,0))
# self.annotation.setFrameSize( QSizeF( 30, 20 ) )
self.reset()
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 btnConstruct_Click(self):
if len(self.resultLayerList) > 0:
QgisHelper.removeFromCanvas(define._canvas, self.resultLayerList)
self.resultLayerList = []
try:
point3d = self.parametersPanel.pnlTHR.getPoint3D()
try:
num = MathHelper.smethod_4(
Unit.ConvertDegToRad(
float(self.parametersPanel.txtRwyDir.Value) + 180))
except ValueError:
raise UserWarning, "Runway Direction is invalide!"
altitude = self.parametersPanel.pnlOCAH.method_3(
Altitude(point3d.get_Z()))
metres = altitude.Metres
if (metres < 10):
raise UserWarning, Messages.ERR_INSUFFICIENT_MINIMUM_ALTITUDE
try:
res, point3dCollection = self.method_37(
point3d, num, metres, metres / math.tan(
Unit.ConvertDegToRad(
float(self.parametersPanel.txtDescAngle.Value.
Degrees) - 1.12)))
except ValueError:
raise UserWarning, "DescAngle is invalide!"
if (not res):
return
self.surfaceArea = PrimaryObstacleArea(
PolylineArea(point3dCollection))
layer = AcadHelper.createVectorLayer("Visual Segment Surface")
if (self.parametersPanel.cmbConstructionType.SelectedIndex !=
ConstructionType.Construct2D):
face = [
point3dCollection.get_Item(0),
point3dCollection.get_Item(1),
point3dCollection.get_Item(2),
point3dCollection.get_Item(3),
point3dCollection.get_Item(0)
]
AcadHelper.setGeometryAndAttributesInLayer(layer, face)
# layer = QgisHelper.createPolylineLayer("Visual Segment Surface 3D", [(face, [])], [])
else:
face = point3dCollection
face.append(point3dCollection[0])
AcadHelper.setGeometryAndAttributesInLayer(layer, face)
# layer = QgisHelper.createPolylineLayer("Visual Segment Surface 2D", [(face, [])], [])
QgisHelper.appendToCanvas(define._canvas, [layer],
SurfaceTypes.VisualSegmentSurface)
QgisHelper.zoomToLayers([layer])
self.resultLayerList = [layer]
self.ui.btnEvaluate.setEnabled(True)
except UserWarning as e:
QMessageBox.warning(self, "Error", e.message)
def method_8(self, itemMenu, rnavSpecification_0, aircraftSpeedCategory_0):
# itemMenu = QMenu(menuName)
strrnavGnssFlightPhaseList = RnavGnssTolerance.smethod_0(
rnavSpecification_0)
rnavGnssFlightPhaseList = []
for strRnavGnssFlightPhase in strrnavGnssFlightPhaseList:
if strRnavGnssFlightPhase == "Enroute":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.Enroute)
elif strRnavGnssFlightPhase == "StarSid":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.StarSid)
elif strRnavGnssFlightPhase == "Star30Sid30IfIafMa30":
rnavGnssFlightPhaseList.append(
RnavGnssFlightPhase.Star30Sid30IfIafMa30)
elif strRnavGnssFlightPhase == "Sid15":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.Sid15)
elif strRnavGnssFlightPhase == "Ma15":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.Ma15)
elif strRnavGnssFlightPhase == "Mapt":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.Mapt)
elif strRnavGnssFlightPhase == "Faf":
rnavGnssFlightPhaseList.append(RnavGnssFlightPhase.Faf)
for rnavGnssFlightPhase in rnavGnssFlightPhaseList:
rnavGnssTolerance = RnavGnssTolerance(rnavSpecification_0,
rnavGnssFlightPhase,
aircraftSpeedCategory_0)
rnavGnssFlightPhaseTxt = RnavGnssTolerance.translateParameter(
rnavGnssFlightPhase)
stringBuilder = rnavGnssFlightPhaseTxt
if (self.hasXtt):
xTT = Captions.XTT
distance = rnavGnssTolerance.xtt
stringBuilder = stringBuilder + ", %s = %.2f nm" % (
xTT, round(distance, 2))
if (self.hasAtt):
aTT = Captions.ATT
aTT1 = rnavGnssTolerance.att
stringBuilder = stringBuilder + ", %s = %.2f nm" % (
aTT, round(aTT1, 2))
if (self.hasAsw):
aSW = Captions.ASW
aSW1 = round(rnavGnssTolerance.asw, 2)
stringBuilder = stringBuilder + ", %s = %.2f nm" % (aSW, aSW1)
itemAction = QgisHelper.createAction(self, stringBuilder,
self.setValues, None, None,
None)
itemMenu.addAction(itemAction)
def imethod_2(self, layers):
polyline = self.paOIS.method_14_closed()
# polyline.set_Elevation(self.elevOIS);
linesList = []
for i in range(1, len(self.ptsOCSL)):
face = [
self.ptsOCSL[i - 1], self.ptsOCSL[i], self.ptsOCSR[i],
self.ptsOCSR[i - 1]
]
linesList.append(
(face, [("surface", PinsSurfaceType.PinsSurfaceType_OCS)]))
linesList.append((polyline, [
("surface", PinsSurfaceType.PinsSurfaceType_LevelOIS)
]))
resultLayer = QgisHelper.createPolylineLayer(
"Pins Visual Segment Departure Manouvering 3D", linesList,
[QgsField("surface", QVariant.String)])
layers.append(resultLayer)
def acceptDlg(self):
if self.pnlDetail.Point3d != None and isinstance(
self.pnlDetail.Point3d, Point3D):
xyPoint = QgisHelper.CrsTransformPoint(
self.pnlDetail.Point3d.get_X(), self.pnlDetail.Point3d.get_Y(),
define._latLonCrs, define._xyCrs,
self.pnlDetail.Point3d.get_Z())
self.x = QString(str(xyPoint.get_X()))
self.y = QString(str(xyPoint.get_Y()))
self.latitude = QString(str(self.pnlDetail.Point3d.get_Y()))
self.longitude = QString(str(self.pnlDetail.Point3d.get_X()))
self.altitude = QString(str(self.pnlDetail.Altitude().Metres))
if self.pnlCenter.Point3d != None and isinstance(
self.pnlCenter.Point3d, Point3D):
self.cenLatitude = QString(str(self.pnlCenter.Point3d.get_Y()))
self.cenLongitude = QString(str(self.pnlCenter.Point3d.get_X()))
self.magVariation = self.pnlMagVariation.Value
self.type = self.pnlType.SelectedItem
self.accept()
def canvasMoveEvent(self, e):
self.rubberBand.reset(QGis.Point)
# snapPoint = QgisHelper.snapPoint(e.pos(), self.mSnapper , define._canvas, True)
snapPoint, snapPointID, layer = self.snapPoint(e.pos(), True)
if snapPoint != None:
self.rubberBand.addPoint(snapPoint)
self.rubberBand.show()
if (self.mRubberBand == None):
return
if (self.mRubberBand.numberOfVertices() > 0):
if self.menuString != "Undo":
self.mRubberBand.removeLastPoint(0)
else:
self.menuString = ""
point2 = None
if snapPoint != None:
self.mRubberBand.addPoint(snapPoint)
point2 = snapPoint
else:
self.mRubberBand.addPoint(self.toMapCoordinates(e.pos()))
point2 = self.toMapCoordinates(e.pos())
if self.menuString == "Arc":
point0 = self.resultPolylineArea[self.resultPolylineArea.Count
- 2].Position
point1 = self.resultPolylineArea[self.resultPolylineArea.Count
- 1].Position
# point2 = self.mRubberBand.getPoint(self.mRubberBand.numberOfVertices() - 1)
bulge = MathHelper.smethod_60(point0, point1, point2)
self.resultPolylineArea[self.resultPolylineArea.Count -
2].bulge = bulge
self.mRubberBand = None
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.mRubberBand = QgsRubberBand(self.mCanvas, QGis.Polygon)
self.mRubberBand.setFillColor(self.mFillColor)
self.mRubberBand.setBorderColor(self.mBorderColour)
for pt in self.resultPolylineArea.method_14():
self.mRubberBand.addPoint(pt)
self.mRubberBand.addPoint(point2)
def getParameterList(self):
parameterList = []
parameterList.append(("general", "group"))
parameterList.append(("Navigational Aid", "group"))
longLatPoint = QgisHelper.Meter2Degree(float(self.parametersPanel.pnlNavAid.txtPointX.text()), float(self.parametersPanel.pnlNavAid.txtPointY.text()))
parameterList.append(("Type", self.parametersPanel.cmbNavAidType.SelectedItem))
parameterList.append(("Lat", self.parametersPanel.pnlNavAid.txtLat.Value))
parameterList.append(("Lon", self.parametersPanel.pnlNavAid.txtLong.Value))
parameterList.append(("X", self.parametersPanel.pnlNavAid.txtPointX.text()))
parameterList.append(("Y", self.parametersPanel.pnlNavAid.txtPointY.text()))
parameterList.append(("Parameters", "group"))
parameterList.append(("Radial", "Plan : " + str(self.parametersPanel.txtTrackRadial.txtRadialPlan.Value) + define._degreeStr))
parameterList.append(("", "Geodetic : " + str(self.parametersPanel.txtTrackRadial.txtRadialGeodetic.Value) + define._degreeStr))
# parameterList.append(("Radial", self.parametersPanel.txtTrackRadial.Value))
parameterList.append(("Distance to Start", self.parametersPanel.txtDistStart.text() + "nm"))
parameterList.append(("Distance to Finish", self.parametersPanel.txtDistFinish.text() + "nm"))
parameterList.append(("Tolerance Type", self.parametersPanel.cmbToleranceType.currentText()))
parameterList.append(("MOCmultipiler", self.parametersPanel.mocSpinBox.text()))
if self.parametersPanel.cmbToleranceType.currentIndex() == 2:
parameterList.append(("Selection Mode", self.parametersPanel.cmbSelectionMode.currentText()))
parameterList.append(("Construction Type", self.parametersPanel.cmbConstructionType.currentText()))
parameterList.append(("Primary Moc", self.parametersPanel.txtPrimaryMOC.text() + "m"))
parameterList.append(("", self.parametersPanel.txtPrimaryMOCFt.text() + "ft"))
parameterList.append(("2nm over-head the VOR", str(self.parametersPanel.chbOverhead.isChecked())))
parameterList.append(("Results / Checked Obstacles", "group"))
parameterList.append(("Checked Obstacles", "group"))
c = self.obstaclesModel.rowCount()
parameterList.append(("Number of Checked Obstacles", str(c)))
return parameterList
def method_9(self):
if self.selectedModelIndex == None:
self.ui.frame_Track.setVisible(False)
return
else:
selectedArea = self.complexObstacleArea[self.selectedModelIndex.row()]
QgisHelper.ClearRubberBandInCanvas(define._canvas)
rBand = QgsRubberBand(define._canvas, QGis.Polygon)
for point in selectedArea.PreviewArea.method_14_closed():
rBand.addPoint(point)
rBand.setFillColor( QColor(46, 64, 142, 100) )
rBand.setBorderColor( QColor(0, 10, 238) )
rBand.show()
if not isinstance(selectedArea, SecondaryObstacleArea) or not isinstance(selectedArea.area, SecondaryAreaStraight):
self.ui.frame_Track.setVisible(False)
return
else:
self.ui.txtTrack.setText(str(round(Unit.smethod_1(selectedArea.nominalTrack), 4)));
self.ui.frame_Track.setVisible(True)
def canvasReleaseEvent(self, e):
if ( e.button() == Qt.RightButton ):
self.emit(SIGNAL("resultLineCreate"), self.rubberBand.asGeometry())
self.reset()
self.isDrawing = False
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)
self.startPoint = self.endPoint
def getOffsetCurve(self, distance, level = 8): ###### case in closed
polylineAreaList = []
startPointIndex = 0
for i in range(len(self)):
if i == len(self) - 1:
if self[i].bulge != 0:
temp = PolylineArea()
temp.Add(PolylineAreaPoint(self[i].Position, self[i].bulge))
temp.Add(PolylineAreaPoint(self[0].Position))
polylineAreaList.append(temp)
else:
point3dArray = []
for j in range(startPointIndex, i + 1):
point3dArray.append(self[j].Position)
point3dArray.append(self[0].Position)
polylineAreaList.append(PolylineArea(point3dArray))
elif self[i].bulge != 0:
if startPointIndex != i:
point3dArray = []
for j in range(startPointIndex, i + 1):
point3dArray.append(self[j].Position)
polylineAreaList.append(PolylineArea(point3dArray))
temp = PolylineArea()
temp.Add(PolylineAreaPoint(self[i].Position, self[i].bulge))
temp.Add(PolylineAreaPoint(self[i + 1].Position))
polylineAreaList.append(temp)
startPointIndex = i + 1
pointList = self.method_14_closed(level)
# pointList.append(self[1].Position)
polyline = QgisHelper.offsetCurve(pointList, distance)
polylineAreaNew = PolylineArea()
polylineAreaNew.method_5(polyline)
return polylineAreaNew
def btnPickScreen_Click(self):
self.area = None
self.priviewClickFlag = False
QgisHelper.ClearRubberBandInCanvas(define._canvas)
# self.rubberBand = None
if self.comboBox.currentIndex() == ProtectionAreaType.Complex:
self.complexDlg = DlgComplexAreas(self)
self.complexDlg.show()
self.complexDlg.ui.buttonBoxOkCancel.accepted.connect(
self.ComplexAreaResult)
return
elif self.comboBox.currentIndex(
) == ProtectionAreaType.PrimaryAndSecondary:
obstacleAreaJig = ObstacleAreaJigSelectArea(
define._canvas, self.comboBox.currentIndex())
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, QtCore.SIGNAL("outputResult"),
self.AreaResult)
return
if QtGui.QMessageBox.question(
self, "Question",
"Please click \"Yes\" if you want to create new area.\nPlease click \"No\" if you want to select any area.",
QtGui.QMessageBox.Yes
| QtGui.QMessageBox.No) == QtGui.QMessageBox.Yes:
# if self.comboBox.currentIndex() == ProtectionAreaType.Primary:
obstacleAreaJig = ObstacleAreaJigCreateArea(
define._canvas, self.comboBox.currentIndex())
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, QtCore.SIGNAL("outputResult"),
self.AreaResult)
# elif self.comboBox.currentIndex() == ProtectionAreaType.Secondary:
else:
obstacleAreaJig = ObstacleAreaJigSelectArea(
define._canvas, self.comboBox.currentIndex())
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, QtCore.SIGNAL("outputResult"),
self.AreaResult)
def vmethod_0(self, polylineArea_0, bool_0, bool_1):
point3dArray = self.area.method_14_closed(4)
polylineArea0 = PolylineArea(point3dArray)
polylineAreaList = [] #self.area]
point3dCollection = []
for i in range(4):
matrix = Matrix3d.Displacement(
self.ptBase.GetVectorTo(polylineArea_0[i].Position))
polylinAreaNew = polylineArea0.TransformBy(matrix)
polylineAreaList.append(polylinAreaNew)
point3dCollection = []
for point3d0 in self.bounds:
point3d = point3d0.TransformBy(matrix)
point3dCollection.append(point3d)
point3dCollection.append(self.bounds[0].TransformBy(matrix))
polylineAreaList.append(polylinAreaNew)
polylineAreaList.append(PolylineArea(point3dCollection))
# point3dCollection0 = MathHelper.smethod_190(point3dCollection)
# polylinAreaNew = PolylineArea(point3dCollection0)
# polylineAreaList.append(polylinAreaNew)
# # break
if bool_1:
polylineAreaList.extend(self.method_3(polylineArea_0))
if bool_0:
polylineAreaList.extend(self.method_2(polylineArea_0))
# polylineAreaList.append(polylineArea_0)
#
# return polylineAreaList
pointList = QgisHelper.convexFull(polylineAreaList)
# pointList = QgisHelper.UnionFromPolylineAreaList(polylineAreaList)
polylineArea = PolylineArea()
for point in pointList:
polylineArea.Add(PolylineAreaPoint(point))
return [polylineArea]
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 btnConstruct_Click(self):
qgsLayerTreeView = define._mLayerTreeView
groupName = self.surfaceType1
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.resultLayerList1) > 0:
QgisHelper.removeFromCanvas(define._canvas,
self.resultLayerList1)
self.resultLayerList1 = []
else:
QMessageBox.warning(
self, "Warning", "Please remove \"" + self.surfaceType1 +
"\" layer group from LayerTreeView.")
return
num = None
num1 = None
num2 = None
num3 = None
point3d = None
resultPolylineAreaList = []
# if (!AcadHelper.Ready)
# {
# return;
# }
# if (!self.method_27(true))
# {
# return;
# }
# string constructionLayer = base.ConstructionLayer;
point3d1 = self.parametersPanel.pnlNavAid.Point3d
value = float(self.parametersPanel.txtTrackRadial.Value)
metres = Altitude(float(self.parametersPanel.txtAltitude.text()),
AltitudeUnits.FT).Metres
z = metres - point3d1.get_Z()
if (self.parametersPanel.cmbNavAidType.currentIndex() != 0):
num = 450 - value + 90
num1 = 15
num2 = 25
num3 = z * 0.839099631
else:
num = 450 - value + 90
num1 = 5
num2 = 15
num3 = z * 1.191753593
num4 = Unit.ConvertDegToRad(num1)
num5 = Unit.ConvertDegToRad(360 - num1)
num6 = Unit.ConvertDegToRad(180 - num2)
num7 = Unit.ConvertDegToRad(180 + num2)
num8 = 0
num9 = Unit.ConvertDegToRad(180)
point3d2 = MathHelper.distanceBearingPoint(point3d1, num4, num3)
point3d3 = MathHelper.distanceBearingPoint(point3d1, num5, num3)
point3d = MathHelper.smethod_68(
point3d2, MathHelper.distanceBearingPoint(point3d1, num8, num3),
point3d3)
if (point3d == None):
QMessageBox.warning(self, "Error",
Messages.ERR_FAILED_TO_CALCULATE_CENTER_POINT)
return
# throw new Exception(Messages.ERR_FAILED_TO_CALCULATE_CENTER_POINT);
num10 = MathHelper.smethod_55(
point3d2, point3d3, MathHelper.calcDistance(point3d2, point3d))
point3d2 = MathHelper.distanceBearingPoint(point3d1, num6, num3)
point3d3 = MathHelper.distanceBearingPoint(point3d1, num7, num3)
point3d = MathHelper.smethod_68(
point3d2, MathHelper.distanceBearingPoint(point3d1, num9, num3),
point3d3)
if (point3d == None):
QMessageBox.warning(self, "Error",
Messages.ERR_FAILED_TO_CALCULATE_CENTER_POINT)
# throw new Exception(Messages.ERR_FAILED_TO_CALCULATE_CENTER_POINT);
num11 = MathHelper.smethod_55(
point3d2, point3d3, MathHelper.calcDistance(point3d2, point3d))
matrix3d = Matrix3d.Rotation(Unit.ConvertDegToRad(num),
Vector3d(0, 0, 1), point3d1)
point3d2 = MathHelper.distanceBearingPoint(point3d1, num8, num3)
point3d3 = MathHelper.distanceBearingPoint(point3d1, num9, num3)
line = PolylineArea([point3d2, point3d3])
resultPolylineAreaList.append(
self.TransformBy(line, Unit.ConvertDegToRad(value),
self.parametersPanel.pnlNavAid.Point3d)
) #.TransformBy(matrix3d))
point3d2 = MathHelper.distanceBearingPoint(point3d1, num6, num3)
point3d3 = MathHelper.distanceBearingPoint(point3d1, num4, num3)
point3d4 = MathHelper.distanceBearingPoint(point3d1, num5, num3)
point3d5 = MathHelper.distanceBearingPoint(point3d1, num7, num3)
point3dArray = [point3d2, point3d3, point3d4, point3d5, point3d2]
polyline = AcadHelper.smethod_126(point3dArray)
if self.parametersPanel.cmbNavAidType.currentIndex() == 0:
num10 = 0.0436609429083
num11 = 0.131652497586
else:
num10 = 0.131652497586
num11 = 0.221694662642
polyline.SetBulgeAt(1, num10)
polyline.SetBulgeAt(3, num11)
# polyline.set_Elevation(point3d1.get_Z());
resultPolylineAreaList.append(
self.TransformBy(polyline, Unit.ConvertDegToRad(value),
self.parametersPanel.pnlNavAid.Point3d)
) #polyline.TransformBy(matrix3d))
# polyline.TransformBy(matrix3d);
# AcadHelper.smethod_18(transaction, blockTableRecord, polyline, constructionLayer);
# transaction.Commit();
# AcadHelper.smethod_5();
mapUnits = define._canvas.mapUnits()
constructionLayer = AcadHelper.createVectorLayer(
SurfaceTypes.OverheadTolerance, QGis.Line)
for polylinrArea0 in resultPolylineAreaList:
AcadHelper.setGeometryAndAttributesInLayer(constructionLayer,
polylinrArea0)
QgisHelper.appendToCanvas(define._canvas, [constructionLayer],
SurfaceTypes.OverheadTolerance, True)
self.resultLayerList1 = [constructionLayer]
QgisHelper.zoomToLayers(self.resultLayerList1)
def canvasReleaseEvent(self, e):
self.endPoint, self.pointID, self.layer= self.snapPoint(e.pos())
vlayer = QgsMapToolSelectUtils.getCurrentVectorLayer( self.mCanvas )
if ( vlayer == None ):
if ( self.mRubberBand != None):
self.mRubberBand.reset( QGis.Polygon )
del self.mRubberBand
self.mRubberBand = None
self.mDragging = False
return
if (not self.mDragging ):
QgsMapToolSelectUtils.expandSelectRectangle(self. mSelectRect, vlayer, e.pos() )
else:
if ( self.mSelectRect.width() == 1 ):
self.mSelectRect.setLeft( self.mSelectRect.left() + 1 )
if ( self.mSelectRect.height() == 1 ):
self.mSelectRect.setBottom( self.mSelectRect.bottom() + 1 )
if ( self.mRubberBand != None ):
QgsMapToolSelectUtils.setRubberBand( self.mCanvas, self.mSelectRect, self.mRubberBand )
selectGeom = self.mRubberBand.asGeometry()
selectedFeatures = QgsMapToolSelectUtils.setSelectFeaturesOrRubberband_Tas_1( self.mCanvas, selectGeom, e )
if len(selectedFeatures) > 0:
self.lineCount += 1
geom = selectedFeatures[0].geometry()
resultArray = QgisHelper.findArcOrLineInLineGeometry(geom, selectGeom)
# if resultArray != None:
# bulge = MathHelper.smethod_60(resultArray[0], resultArray[int(len(resultArray)/2)], resultArray[len(resultArray)-1])
# bulge1 = MathHelper.smethod_60(resultArray[len(resultArray)-1], resultArray[int(len(resultArray)/2)], resultArray[0])
# n = 0
pointArray0 = geom.asPolyline()
self.resultGeomList.append(resultArray)
self.geomList.append(pointArray0)
if self.lineCount == 2 and self.areaType != ProtectionAreaType.PrimaryAndSecondary and self.areaType != ProtectionAreaType.Complex:
self.area = self.makeArea(self.resultGeomList, self.areaType)
pointArray = self.getPointArray(self.resultGeomList).method_14_closed()
self.mRubberBandResult = None
self.mRubberBandResult = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBandResult.setFillColor(QColor(255, 255, 255, 100))
self.mRubberBandResult.setBorderColor(QColor(0, 0, 0))
for point in pointArray:
self.mRubberBandResult.addPoint(point)
self.mRubberBandResult.show()
self.emit(SIGNAL("outputResult"), self.area, self.mRubberBandResult)
self.lineCount = 0
self.resultGeomList = []
self.isFinished = True
# self.rubberBandLine.reset(QGis.Line)
elif self.lineCount == 4 and self.areaType == ProtectionAreaType.PrimaryAndSecondary:
self.area = self.makeArea(self.resultGeomList, self.areaType)
pointArray = self.getPointArray([self.resultGeomList[1], self.resultGeomList[3]]).method_14_closed()
self.mRubberBandResult = None
self.mRubberBandResult = QgsRubberBand( self.mCanvas, QGis.Polygon )
self.mRubberBandResult.setFillColor(QColor(255, 255, 255, 100))
self.mRubberBandResult.setBorderColor(QColor(0, 0, 0))
for point in pointArray:
self.mRubberBandResult.addPoint(point)
self.mRubberBandResult.show()
self.emit(SIGNAL("outputResult"), self.area, self.mRubberBandResult)
self.lineCount = 0
self.resultGeomList = []
# else:
# return
del selectGeom
self.mRubberBand.reset( QGis.Polygon )
del self.mRubberBand
self.mRubberBand = None
self.mDragging = False
