Exemplo n.º 1
0
    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)
Exemplo n.º 2
0
    def method_18(self, double_0):
        if (len(self) == 0):
            raise UserWarning, Messages.ERR_INVALID_POLYLINE_AREA_FOR_OFFSET
        if (MathHelper.smethod_96(double_0)):
            return self
        if (self.isCircle):
            return PolylineArea(None, self.CenterPoint(),
                                self.Radius() + double_0)
        if (len(self) == 1):
            return PolylineArea(None, self[0].position, double_0)
        direction = self.Direction()
        if (direction != TurnDirection.Left):
            if (direction != TurnDirection.Right):
                raise UserWarning, Messages.ERR_INVALID_POLYLINE_AREA_FOR_OFFSET
            num = -1.5707963267949
        else:
            num = 1.5707963267949

        polylineArea = PolylineArea()
        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):
                if not MathHelper.smethod_96(bulge):
                    turnDirection = MathHelper.smethod_7(bulge)
                    point3d1 = MathHelper.smethod_71(position, point3d, bulge)
                    if (turnDirection != direction):
                        point3d2 = MathHelper.distanceBearingPoint(
                            point3d1,
                            MathHelper.getBearing(point3d1, position),
                            MathHelper.calcDistance(point3d1, position) -
                            double_0)
                        point3d3 = MathHelper.distanceBearingPoint(
                            point3d1, MathHelper.getBearing(point3d1, point3d),
                            MathHelper.calcDistance(point3d1, point3d) -
                            double_0)
                    else:
                        point3d2 = MathHelper.distanceBearingPoint(
                            point3d1,
                            MathHelper.getBearing(point3d1, position),
                            MathHelper.calcDistance(point3d1, position) +
                            double_0)
                        point3d3 = MathHelper.distanceBearingPoint(
                            point3d1, MathHelper.getBearing(point3d1, point3d),
                            MathHelper.calcDistance(point3d1, point3d) +
                            double_0)
                    polylineArea.Add(
                        PolylineAreaPoint(
                            point3d2,
                            MathHelper.smethod_57(turnDirection, point3d2,
                                                  point3d3, point3d1)))
                    polylineArea.Add(PolylineAreaPoint(point3d3, 5))
                else:
                    num3 = MathHelper.getBearing(position, point3d)
                    polylineArea.Add(
                        PolylineAreaPoint(
                            MathHelper.distanceBearingPoint(
                                position, num3 + num, double_0)))
                    polylineArea.Add(
                        PolylineAreaPoint(
                            MathHelper.distanceBearingPoint(
                                point3d, num3 + num, double_0), 5))
            i += 1
        count = polylineArea.Count
        j = 0
        while j < count:
            position = polylineArea[j].position
            bulge = polylineArea[j].Bulge
            if j != 0:
                num1 = j - 1
            else:
                num1 = count - 1
            position1 = polylineArea[num1].position
            if j != count - 1:
                num2 = j + 1
            else:
                num2 = 0
            point3d = polylineArea[num2].position
            if (MathHelper.smethod_98(bulge, 5)):
                bulge1 = polylineArea[num1].Bulge
                bulge2 = polylineArea[num2].Bulge
                if (MathHelper.smethod_96(bulge1)
                        and MathHelper.smethod_96(bulge2)):
                    num4 = j + 2
                    if (j == count - 2):
                        num4 = 0
                    elif (j == count - 1):
                        num4 = 1
                    position2 = polylineArea[num4].position
                    num5 = MathHelper.getBearing(position1, position)
                    num6 = MathHelper.getBearing(point3d, position2)
                    turnDirection1 = MathHelper.smethod_63(
                        num5, num6, AngleUnits.Radians)
                    if (turnDirection1 == TurnDirection.Nothing):
                        polylineArea[j].Bulge = 0
                    elif (turnDirection1 != direction):
                        point3d6 = MathHelper.distanceBearingPoint(
                            position,
                            MathHelper.getBearing(position, position1), 100)
                        point3d7 = MathHelper.distanceBearingPoint(
                            point3d, MathHelper.getBearing(point3d, position2),
                            100)
                        point3d4 = MathHelper.getIntersectionPoint(
                            point3d6, position, point3d, point3d7)
                        if point3d4 == None:
                            #                             point3d4 = Point3D.get_Origin()
                            j += 1
                            continue
                        polylineArea[j].position = point3d4
                        polylineArea[j].Bulge = 0
                        polylineArea[num2].position = point3d4
                        polylineArea[num2].Bulge = 0
                    else:
                        point3d8 = MathHelper.distanceBearingPoint(
                            position,
                            MathHelper.getBearing(position, position1) + num,
                            double_0)
                        polylineArea[j].Bulge = MathHelper.smethod_57(
                            direction, position, point3d, point3d8)
                elif not MathHelper.smethod_96(bulge1):
                    turnDirection2 = MathHelper.smethod_7(bulge1)
                    point3d5 = MathHelper.smethod_71(position1, position,
                                                     bulge1)
                    if turnDirection2 != direction:
                        point3d5 = MathHelper.distanceBearingPoint(
                            point3d5,
                            MathHelper.getBearing(point3d5, position),
                            MathHelper.calcDistance(point3d5, position) +
                            double_0)
                    else:
                        point3d5 = MathHelper.distanceBearingPoint(
                            point3d5,
                            MathHelper.getBearing(point3d5, position),
                            MathHelper.calcDistance(point3d5, position) -
                            double_0)
                    polylineArea[j].Bulge = MathHelper.smethod_57(
                        direction, position, point3d, point3d5)
                else:
                    point3d9 = MathHelper.distanceBearingPoint(
                        position,
                        MathHelper.getBearing(position, position1) + num,
                        double_0)
                    polylineArea[j].Bulge = MathHelper.smethod_57(
                        direction, position, point3d, point3d9)
            j += 1
#         i = 0
#         while i < len(polylineArea):
#             if polylineArea[i].position == None:
#                 polylineArea.pop(i)
#                 i -= 1
#             i += 1
#         for i in range(len(polylineArea:
#             if polylineAreaPoint.position == None:
#                 polylineArea.pop(polylineArea.index(polylineAreaPoint))
        return polylineArea
Exemplo n.º 3
0
 def method_21(self, int_0, bool_0, bool_1):
     polylineArea = PolylineArea()
     if (not self.isCircle):
         direction = self.Direction()
         count = len(self)
         if (direction != TurnDirection.Nothing):
             i = 0
             while (i < count):
                 item = self[i]
                 position = item.position
                 bulge = item.Bulge
                 if i != count - 1:
                     point3d = self[i + 1].position
                 else:
                     point3d = self[0].position
                 if (not position.smethod_170(point3d)):
                     if (not MathHelper.smethod_96(bulge)):
                         point3d2 = position
                         point3d3 = point3d
                         turnDirection = MathHelper.smethod_66(bulge)
                         point3d1 = MathHelper.smethod_71(
                             point3d2, point3d3, bulge)
                         num = MathHelper.calcDistance(point3d1, point3d2)
                         num1 = MathHelper.smethod_5(bulge)
                         if (turnDirection == direction):
                             if (not bool_0):
                                 polylineArea.method_5(
                                     MathHelper.smethod_137(
                                         point3d2, point3d1, num, num1,
                                         int_0, turnDirection))
                             else:
                                 polylineArea.method_5(
                                     MathHelper.smethod_138(
                                         point3d2, point3d1, num, num1,
                                         int_0, turnDirection))
                         elif (not bool_0):
                             polylineArea.method_5(
                                 MathHelper.smethod_138(
                                     point3d2, point3d1, num, num1, int_0,
                                     turnDirection))
                         else:
                             polylineArea.method_5(
                                 MathHelper.smethod_137(
                                     point3d2, point3d1, num, num1, int_0,
                                     turnDirection))
                     else:
                         polylineArea.method_1(position)
                 i += 1
     else:
         point3d4 = MathHelper.distanceBearingPoint(self.CenterPoint, 0,
                                                    self.Radius)
         if (not bool_0):
             polylineArea.method_5(
                 MathHelper.smethod_137(point3d4, self.CenterPoint(),
                                        self.Radius(), 6.28318530717959,
                                        int_0, TurnDirection.Right))
         else:
             polylineArea.method_5(
                 MathHelper.smethod_138(point3d4, self.CenterPoint(),
                                        self.Radius(), 6.28318530717959,
                                        int_0, TurnDirection.Right))
     if (bool_1):
         polylineArea.method_10()
     return polylineArea
Exemplo n.º 4
0
    def getClosestPointTo(self, point, bExtend):
        if not bExtend:
            closestPoint = self[0].Position
            for polylineAreaPoint in self:
                if MathHelper.calcDistance(
                        point,
                        polylineAreaPoint.Position) < MathHelper.calcDistance(
                            closestPoint, point):
                    closestPoint = polylineAreaPoint.Position
            return closestPoint

        pointList = self.getQgsPointList()
        minDistance = 9.0E+9
        index = 0
        for linePoint in pointList:
            distance = MathHelper.calcDistance(linePoint, point)
            if minDistance > distance:
                minDistance = distance
                index = pointList.index(linePoint)

        pointAt = pointList[index]
        if index != 0 and index != len(pointList) - 1:
            pointBefore = pointList[index - 1]
            pointAfter = pointList[index + 1]
            projPointB = MathHelper.getProjectionPoint(pointBefore, pointAt,
                                                       point)
            if projPointB != None:
                lenBeforeSegment = MathHelper.calcDistance(
                    pointBefore, pointAt)
                lenBeforeProj = MathHelper.calcDistance(
                    pointBefore, projPointB)
                if lenBeforeProj < lenBeforeSegment:
                    return projPointB

            projPointA = MathHelper.getProjectionPoint(pointAt, pointAfter,
                                                       point)
            if projPointA != None:
                lenAfterSegment = MathHelper.calcDistance(pointAt, pointAfter)
                lenAfterProj = MathHelper.calcDistance(pointAt, projPointA)
                if lenAfterProj < lenAfterSegment:
                    return projPointA
        elif index == 0:
            pointAfter = pointList[index + 1]
            projPointA = MathHelper.getProjectionPoint(pointAt, pointAfter,
                                                       point)
            if projPointA != None:
                lenAfterSegment = MathHelper.calcDistance(pointAt, pointAfter)
                lenAfterProj = MathHelper.calcDistance(pointAt, projPointA)
                if lenAfterProj < lenAfterSegment:
                    return projPointA
        elif index == len(pointList) - 1:
            pointBefore = pointList[index - 1]
            projPointB = MathHelper.getProjectionPoint(pointBefore, pointAt,
                                                       point)
            if projPointB != None:
                lenBeforeSegment = MathHelper.calcDistance(
                    pointBefore, pointAt)
                lenBeforeProj = MathHelper.calcDistance(
                    pointBefore, projPointB)
                if lenBeforeProj < lenBeforeSegment:
                    return projPointB

        return pointAt