Example #1
0
        private static void DecodeAzimuthAndDistance(ref GeoCordSystemDegMinSecUtilities.LatLongClass NewPosition, double Distance, double Azimuth)
        {
            GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass();

            //////////////////////////////////////////////////////////////////////////////////
            //
            // Here loop through the defined radars and determine the source of the data.
            // Once the source is determined calculate the extact position of the target
            // by taking the position of the radar and applying the range and bearing.
            // Display time of reception
            // Extract the cu
            // rrent SIC/SAC so the correct radar can be applied
            //
            ASTERIX.SIC_SAC_Time SIC_SAC_TIME = (ASTERIX.SIC_SAC_Time)CAT01.I001DataItems[CAT01.ItemIDToIndex("010")].value;
            foreach (SystemAdaptationDataSet.Radar RDS in SystemAdaptationDataSet.RadarDataSet)
            {
                // If the current SIC/SAC code matched the code of one of the defined radars
                // then go ahead and calculate the Lat/Long position.
                if (RDS.SIC == SIC_SAC_TIME.SIC.ToString() && RDS.SAC == SIC_SAC_TIME.SAC.ToString())
                {
                    ResultPosition = GeoCordSystemDegMinSecUtilities.CalculateNewPosition(RDS.RadarPosition, Distance, Azimuth);
                }
            }

            NewPosition.SetPosition(ResultPosition.GetLatLongDecimal());
        }
 public Radar(string R_Name, GeoCordSystemDegMinSecUtilities.LatLongClass R_Position, string R_SIC, string R_SAC)
 {
     RadarName = R_Name;
     RadarPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass(R_Position.GetLatLongDecimal().LatitudeDecimal, R_Position.GetLatLongDecimal().LongitudeDecimal);
     SIC = R_SIC;
     SAC = R_SAC;
 }
Example #3
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);
        }
Example #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);
            }
        }
        private static void DecodeAzimuthAndDistance(ref GeoCordSystemDegMinSecUtilities.LatLongClass NewPosition, out double Distance, out double Azimuth, Bit_Ops BO)
        {
            double Distance_Loc = 0.0;
            double Azimuth_Loc = 0.0;
            GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass();
            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Distance
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit16] == true)
                Distance_Loc = RHO_1;
            if (BO.DWord[Bit_Ops.Bit17] == true)
                Distance_Loc = Distance_Loc + RHO_2;
            if (BO.DWord[Bit_Ops.Bit18] == true)
                Distance_Loc = Distance_Loc + RHO_3;
            if (BO.DWord[Bit_Ops.Bit19] == true)
                Distance_Loc = Distance_Loc + RHO_4;
            if (BO.DWord[Bit_Ops.Bit20] == true)
                Distance_Loc = Distance_Loc + RHO_5;
            if (BO.DWord[Bit_Ops.Bit21] == true)
                Distance_Loc = Distance_Loc + RHO_6;
            if (BO.DWord[Bit_Ops.Bit22] == true)
                Distance_Loc = Distance_Loc + RHO_7;
            if (BO.DWord[Bit_Ops.Bit23] == true)
                Distance_Loc = Distance_Loc + RHO_8;
            if (BO.DWord[Bit_Ops.Bit24] == true)
                Distance_Loc = Distance_Loc + RHO_9;
            if (BO.DWord[Bit_Ops.Bit25] == true)
                Distance_Loc = Distance_Loc + RHO_10;
            if (BO.DWord[Bit_Ops.Bit26] == true)
                Distance_Loc = Distance_Loc + RHO_11;
            if (BO.DWord[Bit_Ops.Bit27] == true)
                Distance_Loc = Distance_Loc + RHO_12;
            if (BO.DWord[Bit_Ops.Bit28] == true)
                Distance_Loc = Distance_Loc + RHO_13;
            if (BO.DWord[Bit_Ops.Bit29] == true)
                Distance_Loc = Distance_Loc + RHO_14;
            if (BO.DWord[Bit_Ops.Bit30] == true)
                Distance_Loc = Distance_Loc + RHO_15;
            if (BO.DWord[Bit_Ops.Bit31] == true)
                Distance_Loc = Distance_Loc + RHO_16;

            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Azimuth
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit0] == true)
                Azimuth_Loc = THETA_1;
            if (BO.DWord[Bit_Ops.Bit1] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_2;
            if (BO.DWord[Bit_Ops.Bit2] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_3;
            if (BO.DWord[Bit_Ops.Bit3] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_4;
            if (BO.DWord[Bit_Ops.Bit4] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_5;
            if (BO.DWord[Bit_Ops.Bit5] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_6;
            if (BO.DWord[Bit_Ops.Bit6] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_7;
            if (BO.DWord[Bit_Ops.Bit7] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_8;
            if (BO.DWord[Bit_Ops.Bit8] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_9;
            if (BO.DWord[Bit_Ops.Bit9] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_10;
            if (BO.DWord[Bit_Ops.Bit10] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_11;
            if (BO.DWord[Bit_Ops.Bit11] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_12;
            if (BO.DWord[Bit_Ops.Bit12] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_13;
            if (BO.DWord[Bit_Ops.Bit13] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_14;
            if (BO.DWord[Bit_Ops.Bit14] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_15;
            if (BO.DWord[Bit_Ops.Bit15] == true)
                Azimuth_Loc = Azimuth_Loc + THETA_16;

            Azimuth = Azimuth_Loc;
            Distance = Distance_Loc;

            //////////////////////////////////////////////////////////////////////////////////
            //
            // Here loop through the defined radars and determine the source of the data.
            // Once the source is determined calculate the extact position of the target
            // by taking the position of the radar and applying the range and bearing.
            // Display time of reception
            //
            // Extract the current SIC/SAC so the correct radar can be applied
            //
            ASTERIX.SIC_SAC_Time SIC_SAC_TIME = (ASTERIX.SIC_SAC_Time)CAT48.I048DataItems[CAT48.ItemIDToIndex("010")].value;
            foreach (SystemAdaptationDataSet.Radar RDS in SystemAdaptationDataSet.RadarDataSet)
            {
                // If the current SIC/SAC code matched the code of one of the defined radars
                // then go ahead and calculate the Lat/Long position.
                if (RDS.SIC == SIC_SAC_TIME.SIC.ToString() && RDS.SAC == SIC_SAC_TIME.SAC.ToString())
                {
                    ResultPosition = GeoCordSystemDegMinSecUtilities.CalculateNewPosition(RDS.RadarPosition, Distance_Loc, Azimuth_Loc);
                }
            }

            NewPosition.SetPosition(ResultPosition.GetLatLongDecimal());
        }
        private static void DecodeAzimuthAndDistance(ref GeoCordSystemDegMinSecUtilities.LatLongClass NewPosition, double Distance, double Azimuth)
        {
            GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass();

            //////////////////////////////////////////////////////////////////////////////////
            //
            // Here loop through the defined radars and determine the source of the data.
            // Once the source is determined calculate the extact position of the target
            // by taking the position of the radar and applying the range and bearing.
            // Display time of reception
            // Extract the cu
            // rrent SIC/SAC so the correct radar can be applied
            //
            ASTERIX.SIC_SAC_Time SIC_SAC_TIME = (ASTERIX.SIC_SAC_Time)CAT01.I001DataItems[CAT01.ItemIDToIndex("010")].value;
            foreach (SystemAdaptationDataSet.Radar RDS in SystemAdaptationDataSet.RadarDataSet)
            {
                // If the current SIC/SAC code matched the code of one of the defined radars
                // then go ahead and calculate the Lat/Long position.
                if (RDS.SIC == SIC_SAC_TIME.SIC.ToString() && RDS.SAC == SIC_SAC_TIME.SAC.ToString())
                {
                    ResultPosition = GeoCordSystemDegMinSecUtilities.CalculateNewPosition(RDS.RadarPosition, Distance, Azimuth);
                }
            }

            NewPosition.SetPosition(ResultPosition.GetLatLongDecimal());
        }
Example #7
0
        private static void DecodeAzimuthAndDistance(ref GeoCordSystemDegMinSecUtilities.LatLongClass NewPosition, out double Distance, out double Azimuth, Bit_Ops BO)
        {
            double Distance_Loc = 0.0;
            double Azimuth_Loc  = 0.0;

            GeoCordSystemDegMinSecUtilities.LatLongClass ResultPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass();
            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Distance
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit16] == true)
            {
                Distance_Loc = RHO_1;
            }
            if (BO.DWord[Bit_Ops.Bit17] == true)
            {
                Distance_Loc = Distance_Loc + RHO_2;
            }
            if (BO.DWord[Bit_Ops.Bit18] == true)
            {
                Distance_Loc = Distance_Loc + RHO_3;
            }
            if (BO.DWord[Bit_Ops.Bit19] == true)
            {
                Distance_Loc = Distance_Loc + RHO_4;
            }
            if (BO.DWord[Bit_Ops.Bit20] == true)
            {
                Distance_Loc = Distance_Loc + RHO_5;
            }
            if (BO.DWord[Bit_Ops.Bit21] == true)
            {
                Distance_Loc = Distance_Loc + RHO_6;
            }
            if (BO.DWord[Bit_Ops.Bit22] == true)
            {
                Distance_Loc = Distance_Loc + RHO_7;
            }
            if (BO.DWord[Bit_Ops.Bit23] == true)
            {
                Distance_Loc = Distance_Loc + RHO_8;
            }
            if (BO.DWord[Bit_Ops.Bit24] == true)
            {
                Distance_Loc = Distance_Loc + RHO_9;
            }
            if (BO.DWord[Bit_Ops.Bit25] == true)
            {
                Distance_Loc = Distance_Loc + RHO_10;
            }
            if (BO.DWord[Bit_Ops.Bit26] == true)
            {
                Distance_Loc = Distance_Loc + RHO_11;
            }
            if (BO.DWord[Bit_Ops.Bit27] == true)
            {
                Distance_Loc = Distance_Loc + RHO_12;
            }
            if (BO.DWord[Bit_Ops.Bit28] == true)
            {
                Distance_Loc = Distance_Loc + RHO_13;
            }
            if (BO.DWord[Bit_Ops.Bit29] == true)
            {
                Distance_Loc = Distance_Loc + RHO_14;
            }
            if (BO.DWord[Bit_Ops.Bit30] == true)
            {
                Distance_Loc = Distance_Loc + RHO_15;
            }
            if (BO.DWord[Bit_Ops.Bit31] == true)
            {
                Distance_Loc = Distance_Loc + RHO_16;
            }

            ///////////////////////////////////////////////////////////////////////////////////////
            // Decode Azimuth
            ///////////////////////////////////////////////////////////////////////////////////////
            if (BO.DWord[Bit_Ops.Bit0] == true)
            {
                Azimuth_Loc = THETA_1;
            }
            if (BO.DWord[Bit_Ops.Bit1] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_2;
            }
            if (BO.DWord[Bit_Ops.Bit2] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_3;
            }
            if (BO.DWord[Bit_Ops.Bit3] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_4;
            }
            if (BO.DWord[Bit_Ops.Bit4] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_5;
            }
            if (BO.DWord[Bit_Ops.Bit5] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_6;
            }
            if (BO.DWord[Bit_Ops.Bit6] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_7;
            }
            if (BO.DWord[Bit_Ops.Bit7] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_8;
            }
            if (BO.DWord[Bit_Ops.Bit8] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_9;
            }
            if (BO.DWord[Bit_Ops.Bit9] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_10;
            }
            if (BO.DWord[Bit_Ops.Bit10] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_11;
            }
            if (BO.DWord[Bit_Ops.Bit11] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_12;
            }
            if (BO.DWord[Bit_Ops.Bit12] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_13;
            }
            if (BO.DWord[Bit_Ops.Bit13] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_14;
            }
            if (BO.DWord[Bit_Ops.Bit14] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_15;
            }
            if (BO.DWord[Bit_Ops.Bit15] == true)
            {
                Azimuth_Loc = Azimuth_Loc + THETA_16;
            }

            Azimuth  = Azimuth_Loc;
            Distance = Distance_Loc;

            //////////////////////////////////////////////////////////////////////////////////
            //
            // Here loop through the defined radars and determine the source of the data.
            // Once the source is determined calculate the extact position of the target
            // by taking the position of the radar and applying the range and bearing.
            // Display time of reception
            //
            // Extract the current SIC/SAC so the correct radar can be applied
            //
            ASTERIX.SIC_SAC_Time SIC_SAC_TIME = (ASTERIX.SIC_SAC_Time)CAT01.I001DataItems[CAT01.ItemIDToIndex("010")].value;
            foreach (SystemAdaptationDataSet.Radar RDS in SystemAdaptationDataSet.RadarDataSet)
            {
                // If the current SIC/SAC code matched the code of one of the defined radars
                // then go ahead and calculate the Lat/Long position.
                if (RDS.SIC == SIC_SAC_TIME.SIC.ToString() && RDS.SAC == SIC_SAC_TIME.SAC.ToString())
                {
                    ResultPosition = GeoCordSystemDegMinSecUtilities.CalculateNewPosition(RDS.RadarPosition, Distance_Loc, Azimuth_Loc);
                }
            }

            NewPosition.SetPosition(ResultPosition.GetLatLongDecimal());
        }
 public Waypoint(string W_Name, GeoCordSystemDegMinSecUtilities.LatLongClass W_Position, bool Is_COP_In)
 {
     WaypointName = W_Name;
     WaypointPosition = new GeoCordSystemDegMinSecUtilities.LatLongClass(W_Position.GetLatLongDecimal().LatitudeDecimal, W_Position.GetLatLongDecimal().LongitudeDecimal);
     Is_COP = Is_COP_In;
 }