示例#1
0
        public OutData GetResult()
        {
            // select a reference elllipsoid
            Ellipsoid reference = Ellipsoid.WGS84;
            // instantiate the calculator
            GeodeticCalculator geoCalc = new GeodeticCalculator();
            // Used to calculate the time to the min distance
            GlobalPosition Orig_Track_1_Pos = new GlobalPosition(new GlobalCoordinates(Track_1_Pos.Latitude, Track_1_Pos.Longitude));

            int UpdateStep = 60 / Properties.Settings.Default.SEepToolUpdateRate;

            for (int LookAheadIndex = 1; LookAheadIndex <= ((MaxLookAheadTimeInMinutes * 60) / UpdateStep); LookAheadIndex++)
            {
                // Calculate new position X seconds ahead for track 1
                double Range = (Track_1_SPD / 60) / UpdateStep;
                GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition_1 =
                    GeoCordSystemDegMinSecUtilities.CalculateNewPosition(new GeoCordSystemDegMinSecUtilities.LatLongClass(Track_1_Pos.Latitude.Degrees, Track_1_Pos.Longitude.Degrees), (double)Range, (double)Track_1_TRK);
                GPoint MarkerPositionLocal = FormMain.gMapControl.FromLatLngToLocal(new PointLatLng(ResultPosition_1.GetLatLongDecimal().LatitudeDecimal, ResultPosition_1.GetLatLongDecimal().LongitudeDecimal));
                ReturnData.Track_1_Pos_Min.X = MarkerPositionLocal.X;
                ReturnData.Track_1_Pos_Min.Y = MarkerPositionLocal.Y;

                // Calculate new position X seconds ahead for track 2
                Range = (Track_2_SPD / 60) / 15;
                GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition_2 =
                    GeoCordSystemDegMinSecUtilities.CalculateNewPosition(new GeoCordSystemDegMinSecUtilities.LatLongClass(Track_2_Pos.Latitude.Degrees, Track_2_Pos.Longitude.Degrees), (double)Range, (double)Track_2_TRK);
                MarkerPositionLocal          = FormMain.gMapControl.FromLatLngToLocal(new PointLatLng(ResultPosition_2.GetLatLongDecimal().LatitudeDecimal, ResultPosition_2.GetLatLongDecimal().LongitudeDecimal));
                ReturnData.Track_2_Pos_Min.X = MarkerPositionLocal.X;
                ReturnData.Track_2_Pos_Min.Y = MarkerPositionLocal.Y;

                double distance1 = geoCalc.CalculateGeodeticMeasurement(reference, Track_1_Pos, Track_2_Pos).PointToPointDistance;
                double distance2 = geoCalc.CalculateGeodeticMeasurement(reference, new GlobalPosition(new GlobalCoordinates(ResultPosition_1.GetLatLongDecimal().LatitudeDecimal, ResultPosition_1.GetLatLongDecimal().LongitudeDecimal)),
                                                                        new GlobalPosition(new GlobalCoordinates(ResultPosition_2.GetLatLongDecimal().LatitudeDecimal, ResultPosition_2.GetLatLongDecimal().LongitudeDecimal))).PointToPointDistance;

                // Calculate distance between present and new position
                if ((distance1 < distance2) && (LookAheadIndex != 1))
                {
                    ReturnData.Is_Converging = true;
                    ReturnData.MinDistance   = distance2 * 0.00053996; // Convert to nautical miles

                    double DistanceToTravel = geoCalc.CalculateGeodeticMeasurement(reference, Orig_Track_1_Pos, new GlobalPosition(new GlobalCoordinates(ResultPosition_1.GetLatLongDecimal().LatitudeDecimal, ResultPosition_1.GetLatLongDecimal().LongitudeDecimal))).PointToPointDistance;
                    DistanceToTravel            = DistanceToTravel * 0.00053996; // Convert to nautical miles
                    ReturnData.SecondsToMinimum = (int)((DistanceToTravel / Track_1_SPD) * 60.0 * 60.0);
                    // We have reached the minimum distance
                    break;
                }
                else if ((distance1 < distance2) && (LookAheadIndex == 1))
                {
                    ReturnData.Is_Converging = false;
                    break;
                }

                Track_1_Pos = new GlobalPosition(new GlobalCoordinates(ResultPosition_1.GetLatLongDecimal().LatitudeDecimal, ResultPosition_1.GetLatLongDecimal().LongitudeDecimal));
                Track_2_Pos = new GlobalPosition(new GlobalCoordinates(ResultPosition_2.GetLatLongDecimal().LatitudeDecimal, ResultPosition_2.GetLatLongDecimal().LongitudeDecimal));
            }

            return(ReturnData);
        }
示例#2
0
 public SEP_Tool_Calculator(GlobalPosition Track_1_Position, GlobalPosition Track_2_Position,
                            double Track_1_Speed, double Track_2_Speed,
                            double Track_1_Track, double Track_2_Track,
                            int LookAheadTimeInMinutes)
 {
     Track_1_Pos = new GlobalPosition(new GlobalCoordinates(Track_1_Position.Latitude, Track_1_Position.Longitude));
     Track_2_Pos = new GlobalPosition(new GlobalCoordinates(Track_2_Position.Latitude, Track_2_Position.Longitude));
     Track_1_SPD = Track_1_Speed;
     Track_2_SPD = Track_2_Speed;
     Track_1_TRK = Track_1_Track;
     Track_2_TRK = Track_2_Track;
     MaxLookAheadTimeInMinutes = LookAheadTimeInMinutes;
 }
示例#3
0
        public override void OnRender(Graphics g)
        {
            g.DrawLine(new Pen(Brush_To_Use), StartPosition, EndPosition);

            // select a reference elllipsoid
            Ellipsoid reference = Ellipsoid.WGS84;
            // instantiate the calculator
            GeodeticCalculator  geoCalc    = new GeodeticCalculator();
            GlobalPosition      Start      = new GlobalPosition(new GlobalCoordinates(this.Position.Lat, this.Position.Lng));
            PointLatLng         End_LatLng = FormMain.FromLocalToLatLng(EndPosition.X, EndPosition.Y);
            GlobalPosition      End        = new GlobalPosition(new GlobalCoordinates(End_LatLng.Lat, End_LatLng.Lng));
            GeodeticMeasurement GM         = geoCalc.CalculateGeodeticMeasurement(reference, Start, End);

            // Now compute position half way between two points.
            double distance = GM.PointToPointDistance / 2.0;

            if (distance > 0.0)
            {
                GlobalCoordinates GC         = geoCalc.CalculateEndingGlobalCoordinates(reference, new GlobalCoordinates(this.Position.Lat, this.Position.Lng), GM.Azimuth, distance);
                GPoint            GP         = FormMain.FromLatLngToLocal(new PointLatLng(GC.Latitude.Degrees, GC.Longitude.Degrees));
                double            Distane_NM = 0.00053996 * GM.PointToPointDistance;
                g.DrawString(Math.Round(GM.Azimuth.Degrees).ToString() + "°/" + Math.Round(Distane_NM, 1).ToString() + "nm", new Font(FontFamily.GenericSansSerif, 9), Brush_To_Use, new PointF(GP.X, GP.Y));
            }
        }
示例#4
0
        public override void OnRender(Graphics g)
        {
            Pen MyPen = new Pen(new SolidBrush(LabelAttributes.TargetColor), LabelAttributes.TargetSize);

            MyPen.DashStyle = LabelAttributes.TargetStyle;

            // Draw AC Symbol
            g.DrawRectangle(MyPen, LocalPosition.X - 5, LocalPosition.Y - 5, 10, 10);
            AC_SYMB_START_X = LocalPosition.X - 5;
            AC_SYMB_START_Y = LocalPosition.Y - 5;

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Here handle drawing of Range/Bearing & SEP tool
            if (TargetToMonitor != -1)
            {
                Point StartPosition = new Point(LocalPosition.X, LocalPosition.Y);
                Point EndPosition   = DynamicDisplayBuilder.GetTargetPositionByIndex(TargetToMonitor);
                g.DrawLine(new Pen(Brushes.Yellow, 1), StartPosition, EndPosition);

                // select a reference elllipsoid
                Ellipsoid reference = Ellipsoid.WGS84;
                // instantiate the calculator
                GeodeticCalculator  geoCalc    = new GeodeticCalculator();
                GlobalPosition      Start      = new GlobalPosition(new GlobalCoordinates(this.Position.Lat, this.Position.Lng));
                PointLatLng         End_LatLng = FormMain.FromLocalToLatLng(EndPosition.X, EndPosition.Y);
                GlobalPosition      End        = new GlobalPosition(new GlobalCoordinates(End_LatLng.Lat, End_LatLng.Lng));
                GeodeticMeasurement GM         = geoCalc.CalculateGeodeticMeasurement(reference, End, Start);

                ////////////////////////////////////////////////////////////////////////////////////////////
                // Handle SEP Tool
                double TRK1_SPD = 0.0, TRK2_SPD = 0.0;
                double TRK1_AZ = 0.0, TRK2_AZ = 0.0;
                bool   Sep_Data_Is_Valid = true;

                if (!double.TryParse(CALC_GSPD_STRING, out TRK1_SPD))
                {
                    if (!double.TryParse(DAP_GSPD, out TRK1_SPD))
                    {
                        Sep_Data_Is_Valid = false;
                    }
                }

                if (!double.TryParse(DynamicDisplayBuilder.GetTarget_CALC_GSPD_ByIndex(TargetToMonitor), out TRK2_SPD))
                {
                    if (!double.TryParse(DynamicDisplayBuilder.GetTarget_DAP_GSPD_ByIndex(TargetToMonitor), out TRK2_SPD))
                    {
                        Sep_Data_Is_Valid = false;
                    }
                }

                if (!double.TryParse(CALC_HDG_STRING, out TRK1_AZ))
                {
                    if (!double.TryParse(TRK, out TRK1_AZ))
                    {
                        if (!double.TryParse(DAP_HDG, out TRK1_AZ))
                        {
                            Sep_Data_Is_Valid = false;
                        }
                    }
                }

                if (!double.TryParse(DynamicDisplayBuilder.GetTarget_CALC_HDG_ByIndex(TargetToMonitor), out TRK2_AZ))
                {
                    if (!double.TryParse(DynamicDisplayBuilder.GetTargetTRKByIndex(TargetToMonitor), out TRK2_AZ))
                    {
                        if (!double.TryParse(DynamicDisplayBuilder.GetTargetM_HDGByIndex(TargetToMonitor), out TRK2_AZ))
                        {
                            Sep_Data_Is_Valid = false;
                        }
                    }
                }

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // If all the necessary data is avilable
                // then pass it on to the SEP tool calculator
                // and then draw the result
                string SepToolActive = "N/A";
                if (Sep_Data_Is_Valid)
                {
                    SEP_Tool_Calculator         SepTool       = new SEP_Tool_Calculator(Start, End, TRK1_SPD, TRK2_SPD, TRK1_AZ, TRK2_AZ, 20);
                    SEP_Tool_Calculator.OutData Sep_Tool_Data = SepTool.GetResult();

                    if (Sep_Tool_Data.Is_Converging)
                    {
                        g.DrawRectangle(new Pen(Brushes.Yellow, LabelAttributes.TargetSize), Sep_Tool_Data.Track_1_Pos_Min.X - 5, Sep_Tool_Data.Track_1_Pos_Min.Y - 5, 10, 10);
                        g.DrawRectangle(new Pen(Brushes.Yellow, LabelAttributes.TargetSize), Sep_Tool_Data.Track_2_Pos_Min.X - 5, Sep_Tool_Data.Track_2_Pos_Min.Y - 5, 10, 10);
                        g.DrawLine(new Pen(Brushes.Yellow, LabelAttributes.TargetSize), new Point(Sep_Tool_Data.Track_1_Pos_Min.X, Sep_Tool_Data.Track_1_Pos_Min.Y), new Point(StartPosition.X, StartPosition.Y));
                        g.DrawLine(new Pen(Brushes.Yellow, LabelAttributes.TargetSize), new Point(Sep_Tool_Data.Track_2_Pos_Min.X, Sep_Tool_Data.Track_2_Pos_Min.Y), new Point(EndPosition.X, EndPosition.Y));
                        TimeSpan T = TimeSpan.FromSeconds(Sep_Tool_Data.SecondsToMinimum);
                        SepToolActive = "min d:" + Math.Round(Sep_Tool_Data.MinDistance, 1).ToString() + "/" + T.Minutes.ToString() + ":" + T.Seconds.ToString();
                    }
                }

                // Now compute position half way between two points.
                double distance = GM.PointToPointDistance / 2.0;
                if (distance > 0.0)
                {
                    GlobalCoordinates GC         = geoCalc.CalculateEndingGlobalCoordinates(reference, new GlobalCoordinates(End_LatLng.Lat, End_LatLng.Lng), GM.Azimuth, distance);
                    GPoint            GP         = FormMain.FromLatLngToLocal(new PointLatLng(GC.Latitude.Degrees, GC.Longitude.Degrees));
                    double            Distane_NM = 0.00053996 * GM.PointToPointDistance;
                    g.DrawString(Math.Round(GM.Azimuth.Degrees).ToString() + "°/" + Math.Round(Distane_NM, 1).ToString() + "nm", new Font(FontFamily.GenericSansSerif, 9), Brushes.Yellow, new PointF(GP.X, GP.Y));

                    if (Sep_Data_Is_Valid && SepToolActive != "N/A")
                    {
                        g.DrawString(SepToolActive, new Font(FontFamily.GenericSansSerif, 9), Brushes.Yellow, new PointF(GP.X, GP.Y + 15));
                    }
                }
            }

            // Here handle history points
            // First draw all previous history points
            int Number_of_Points_Drawn = 0;

            for (int Index = HistoryPoints.Count - 2; Index >= 0; Index--)
            {
                if (Number_of_Points_Drawn < Properties.Settings.Default.HistoryPoints)
                {
                    HistoryPointsType I = HistoryPoints.ElementAt(Index);
                    GPoint            MarkerPositionLocal = FormMain.gMapControl.FromLatLngToLocal(new PointLatLng(I.LatLong.Lat, I.LatLong.Lng));
                    g.DrawEllipse(MyPen, MarkerPositionLocal.X, MarkerPositionLocal.Y, 3, 3);
                    Number_of_Points_Drawn++;
                }
            }



            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // Here draw speed vector
            // // Find out what data should be used for speed vector? IAS, TAS, GSPD, MACH?
            if ((DataItemValidator(CALC_HDG_STRING) || DataItemValidator(DAP_HDG) || DataItemValidator(TRK)) && (DataItemValidator(DAP_GSPD) || DataItemValidator(CALC_GSPD_STRING)))
            {
                double Azimuth = 0.0;
                double Range   = 0.0;

                if (DataItemValidator(CALC_GSPD_STRING))
                {
                    Range = double.Parse(CALC_GSPD_STRING);
                }
                else
                {
                    Range = double.Parse(DAP_GSPD);
                }

                if (DataItemValidator(CALC_HDG_STRING))
                {
                    Azimuth = double.Parse(CALC_HDG_STRING);
                }
                else if (DataItemValidator(TRK))
                {
                    Azimuth = double.Parse(TRK);
                }
                else
                {
                    Azimuth = double.Parse(DAP_HDG);
                }

                Range = (Range / 60) * (double)Properties.Settings.Default.SpeedVector;

                GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition =
                    GeoCordSystemDegMinSecUtilities.CalculateNewPosition(new GeoCordSystemDegMinSecUtilities.LatLongClass(Position.Lat, Position.Lng), (double)Range, (double)Azimuth);

                GPoint MarkerPositionLocal = FormMain.gMapControl.FromLatLngToLocal(new PointLatLng(ResultPosition.GetLatLongDecimal().LatitudeDecimal, ResultPosition.GetLatLongDecimal().LongitudeDecimal));
                g.DrawLine(MyPen, new Point(LocalPosition.X, LocalPosition.Y), new Point(MarkerPositionLocal.X, MarkerPositionLocal.Y));
            }
            else
            {
                int T = 9;
                int r = T;
            }
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            MyPen           = new Pen(new SolidBrush(LabelAttributes.LineColor), LabelAttributes.LineWidth);
            MyPen.DashStyle = LabelAttributes.LineStyle;

            // Draw leader line
            g.DrawLine(MyPen, new Point(LocalPosition.X, LocalPosition.Y), new Point(LocalPosition.X - LabelOffset.X, LocalPosition.Y - LabelOffset.Y));

            // Draw label box
            Point LabelStartPosition = GetLabelStartingPoint();

            // Recalculate Label Width each cycle to adjust for the possible changes in the number of lines
            // and changes in the text size
            LabelHeight = 0;

            // Draw ModeA and coast indicator
            g.DrawString(ModeA_CI_STRING, ModeA_CI_FONT, ModeA_CI_BRUSH, LabelStartPosition.X + ModeA_CI_OFFSET.X, LabelStartPosition.Y + SpacingIndex);
            LabelHeight = LabelHeight + (int)ModeA_CI_FONT.Size + SpacingIndex * 2;


            if (CALLSIGN_STRING != "--------")
            {
                // Draw CALLSIGN
                g.DrawString(CALLSIGN_STRING, CALLSIGN_FONT, CALLSIGN_BRUSH, LabelStartPosition.X + CALLSIGN_OFFSET.X, LabelStartPosition.Y + LabelHeight);
                LabelHeight = LabelHeight + (int)CALLSIGN_FONT.Size + SpacingIndex * 2;
            }

            // Draw ModeC
            g.DrawString(ModeC_STRING, ModeC_FONT, ModeC_BRUSH, LabelStartPosition.X + ModeC_OFFSET.X, LabelStartPosition.Y + LabelHeight);

            // Draw CFL on the same line
            if (ModeC_STRING == null)
            {
                ModeC_STRING = "---";
            }
            CFL_OFFSET.X = ModeC_STRING.Length * (int)ModeC_FONT.Size;
            CFL_OFFSET.Y = LabelStartPosition.Y + LabelHeight;
            g.DrawString(CFL_STRING, CFL_FONT, CFL_BRUSH, LabelStartPosition.X + CFL_OFFSET.X, CFL_OFFSET.Y);
            CFL_START_X = LabelStartPosition.X + CFL_OFFSET.X;
            CFL_START_Y = CFL_OFFSET.Y;

            // Draw GSPD on the same line
            GSPD_OFFSET.X = (ModeC_STRING.Length * (int)ModeC_FONT.Size) + (CFL_STRING.Length * (int)CFL_FONT.Size);
            GSPD_OFFSET.Y = LabelStartPosition.Y + LabelHeight;

            if (CALC_GSPD_STRING != " ---")
            {
                g.DrawString(CALC_GSPD_STRING, GSPD_FONT, GSPD_BRUSH, LabelStartPosition.X + GSPD_OFFSET.X, GSPD_OFFSET.Y);
            }
            else if (DAP_GSPD != "N/A")
            {
                g.DrawString(DAP_GSPD, GSPD_FONT, GSPD_BRUSH, LabelStartPosition.X + GSPD_OFFSET.X, GSPD_OFFSET.Y);
            }
            else
            {
                g.DrawString(" ---", GSPD_FONT, GSPD_BRUSH, LabelStartPosition.X + GSPD_OFFSET.X, GSPD_OFFSET.Y);
            }

            GSPD_START_X = LabelStartPosition.X + GSPD_OFFSET.X;
            GSPD_START_Y = GSPD_OFFSET.Y;

            LabelHeight = LabelHeight + (int)GSPD_FONT.Size + SpacingIndex * 2;

            if (ShowLabelBox == true)
            {
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //  DRAW Assigned HDG, SPD and ROC
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                // HDG
                g.DrawString(A_HDG_STRING, A_HDG_FONT, A_HDG_BRUSH, LabelStartPosition.X + A_HDG_OFFSET.X, LabelStartPosition.Y + LabelHeight);
                HDG_START_X = LabelStartPosition.X + A_HDG_OFFSET.X;
                HDG_START_Y = LabelStartPosition.Y + LabelHeight;

                // SPD
                A_SPD_OFFSET.X = A_HDG_STRING.Length * (int)A_HDG_FONT.Size;
                A_SPD_OFFSET.Y = LabelStartPosition.Y + LabelHeight;
                g.DrawString(A_SPD_STRING, A_SPD_FONT, A_SPD_BRUSH, LabelStartPosition.X + A_SPD_OFFSET.X, A_SPD_OFFSET.Y);
                SPD_START_X = LabelStartPosition.X + A_SPD_OFFSET.X;
                SPD_START_Y = A_SPD_OFFSET.Y;

                // ROC
                //A_ROC_OFFSET.X = A_SPD_OFFSET.X + A_SPD_OFFSET.X + A_SPD_STRING.Length * (int)A_SPD_FONT.Size;
                //A_ROC_OFFSET.Y = LabelStartPosition.Y + LabelHeight;
                // g.DrawString(A_ROC_STRING, A_ROC_FONT, A_ROC_BRUSH, LabelStartPosition.X + A_ROC_OFFSET.X, A_ROC_OFFSET.Y);

                LabelHeight = LabelHeight + (int)A_SPD_FONT.Size + SpacingIndex * 2;

                // Add the final spacing index and draw the box
                LabelHeight = LabelHeight + SpacingIndex * 2;
                g.DrawRectangle(MyPen, LabelStartPosition.X, LabelStartPosition.Y, LabelWidth, LabelHeight);
            }
        }
示例#5
0
        // This method takes in two Target Positions and determines if horizontal
        // separation is infringed. The first parameter is passed by reference as
        // the method will, in the case it determines that separation is infringed
        // set appropriate inication in the passed in Target. It actually sets all
        // items in the STCA_List
        private static void Check_And_Set_Horizontal_Infringed(ref DynamicDisplayBuilder.TargetType T1, DynamicDisplayBuilder.TargetType T2)
        {
            ////////////////////////////////////////////////////////////////////////////////////////////////
            // First extract and validate all the data
            //
            GlobalPosition Track_1_Pos = new GlobalPosition(new GlobalCoordinates(T1.Lat, T1.Lon));
            GlobalPosition Track_2_Pos = new GlobalPosition(new GlobalCoordinates(T2.Lat, T2.Lon));
            bool           DataValid   = false;
            double         Track_1_SPD;
            double         Track_2_SPD;
            double         Track_1_TRK;
            double         Track_2_TRK;

            if (!double.TryParse(T1.CALC_GSPD, out Track_1_SPD))
            {
                DataValid = false;
            }
            if (!double.TryParse(T2.CALC_GSPD, out Track_2_SPD))
            {
                DataValid = false;
            }
            if (!double.TryParse(T1.TRK, out Track_1_TRK))
            {
                if (!double.TryParse(T1.DAP_HDG, out Track_1_TRK))
                {
                    DataValid = false;
                }
            }
            if (!double.TryParse(T2.TRK, out Track_2_TRK))
            {
                if (!double.TryParse(T2.DAP_HDG, out Track_2_TRK))
                {
                    DataValid = false;
                }
            }

            // Data validated
            if (DataValid)
            {
                // select a reference elllipsoid
                Ellipsoid reference = Ellipsoid.WGS84;
                // instantiate the calculator
                GeodeticCalculator geoCalc = new GeodeticCalculator();
                // Used to calculate the time to the min distance
                GlobalPosition Track_1 = new GlobalPosition(new GlobalCoordinates(Track_1_Pos.Latitude, Track_1_Pos.Longitude));
                GlobalPosition Track_2 = new GlobalPosition(new GlobalCoordinates(Track_2_Pos.Latitude, Track_2_Pos.Longitude));

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                // First check if the two targets are already in separation violation status.
                // If so, then add the STCA items to the STCA pair target
                double DistanceToTravel = geoCalc.CalculateGeodeticMeasurement(reference, Track_1, Track_2).PointToPointDistance;
                DistanceToTravel = DistanceToTravel * 0.00053996; // Convert to nautical miles

                if (DistanceToTravel < Min_Horizontal_Separation_Nm)
                {
                    STCA_Target_Item STCA_Item = new STCA_Target_Item();
                    STCA_Item.CurrentDistance   = DistanceToTravel;
                    STCA_Item.STCA_Partner      = T2.TrackNumber;
                    STCA_Item.STCA_Status       = STCA_Status_Type.Violation;
                    STCA_Item.TimeToImpact_Sec  = 10;
                    STCA_Item.TimeToConflictSec = 0;
                    T1.STCA_List.Add(STCA_Item);
                }

                // No they are not, then check if the two targets are going to be in
                // the separation violation status a parameter set time in the future
                // This is so called "violation prediction status"
            }
        }
示例#6
0
        /// <summary>
        /// Calculate the three dimensional geodetic measurement between two positions
        /// measured in reference to a specified ellipsoid.
        ///
        /// This calculation is performed by first computing a new ellipsoid by expanding or contracting
        /// the reference ellipsoid such that the new ellipsoid passes through the average elevation
        /// of the two positions.  A geodetic curve across the new ellisoid is calculated.  The
        /// point-to-point distance is calculated as the hypotenuse of a right triangle where the length
        /// of one side is the ellipsoidal distance and the other is the difference in elevation.
        /// </summary>
        /// <param name="refEllipsoid">reference ellipsoid to use</param>
        /// <param name="start">starting position</param>
        /// <param name="end">ending position</param>
        /// <returns></returns>
        public GeodeticMeasurement CalculateGeodeticMeasurement(Ellipsoid refEllipsoid, GlobalPosition start, GlobalPosition end)
        {
            // get the coordinates
            GlobalCoordinates startCoords = start.Coordinates;
            GlobalCoordinates endCoords   = end.Coordinates;

            // calculate elevation differences
            double elev1  = start.Elevation;
            double elev2  = end.Elevation;
            double elev12 = (elev1 + elev2) / 2.0;

            // calculate latitude differences
            double phi1  = startCoords.Latitude.Radians;
            double phi2  = endCoords.Latitude.Radians;
            double phi12 = (phi1 + phi2) / 2.0;

            // calculate a new ellipsoid to accommodate average elevation
            double    refA      = refEllipsoid.SemiMajorAxis;
            double    f         = refEllipsoid.Flattening;
            double    a         = refA + elev12 * (1.0 + f * Math.Sin(phi12));
            Ellipsoid ellipsoid = Ellipsoid.FromAAndF(a, f);

            // calculate the curve at the average elevation
            GeodeticCurve averageCurve = CalculateGeodeticCurve(ellipsoid, startCoords, endCoords);

            // return the measurement
            return(new GeodeticMeasurement(averageCurve, elev2 - elev1));
        }