コード例 #1
0
ファイル: DateEvents.cs プロジェクト: sharespy/Astroder
        public DateEvents(DateTimeOffset date)
        {
            try
            {
                if (date.TimeOfDay == TimeSpan.Zero && date.Offset == TimeSpan.Zero)
                {
                    Date = date;
                }
                else
                {
                    Date = new DateTimeOffset(date.UtcDateTime.Date, TimeSpan.Zero);
                }

                MatchRules during = new MatchRules(Date, SearchMode.WithinTheDay);
                Relations = Ephemeris.RelationsWithin(during);

                Positions = new Dictionary <PlanetId, PlanetEvents>();

                for (PlanetId id = PlanetId.SE_SUN; id <= PlanetId.SE_PLUTO; id++)
                {
                    Positions.Add(id, new PlanetEvents(TheEphemeris, Date, id));
                }
                Positions.Add(PlanetId.SE_NORTHNODE, new PlanetEvents(TheEphemeris, Date, PlanetId.SE_NORTHNODE));
                Positions.Add(PlanetId.SE_CHIRON, new PlanetEvents(TheEphemeris, Date, PlanetId.SE_CHIRON));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine(ex.Message);
            }
        }
コード例 #2
0
ファイル: PlanetEvents.cs プロジェクト: sharespy/Astroder
        public PlanetEvents(Ephemeris ephem, DateTimeOffset date, PlanetId id)
        {
            List <Position>       watchedPositions = new List <Position>();
            List <double>         longSpeeds       = new List <double>();
            List <double>         latSpeeds        = new List <double>();
            List <double>         latitudes        = new List <double>();
            List <double>         distSpeeds       = new List <double>();
            List <DateTimeOffset> retroDates       = null;

            try
            {
                TheEphemeris = ephem;
                Date         = date;

                for (int i = -WatchingDays; i <= WatchingDays; i++)
                {
                    Position pos = TheEphemeris[date.AddDays(i), id];
                    watchedPositions.Add(pos);
                    latitudes.Add(pos.Latitude);
                    longSpeeds.Add(pos.LongitudeVelocity);
                    latSpeeds.Add(pos.LatitudeVelocity);
                    distSpeeds.Add(pos.DistanceVelocity);
                }

                Current            = watchedPositions[WatchingDays];
                RelationWithOthers = Ephemeris.RelationsWithin(new MatchRules(date, SearchMode.WithinTheDay), id);

                //List<double> reversedVelocities = Ephemeris.TurningsOf(longSpeeds);

                //if (reversedVelocities.Count != 0)
                //{

                //}


                double minLongVel = (from spd in longSpeeds
                                     orderby Math.Abs(spd)
                                     select spd).FirstOrDefault();

                int            stationIndex = longSpeeds.IndexOf(minLongVel);
                DateTimeOffset around       = Date.AddDays(stationIndex - WatchingDays);
                retroDates = Ephemeris.RetrogradeDateAround(id, around);

                if (retroDates != null)
                {
                    DateTimeOffset nearest = (from keyDay in retroDates
                                              orderby Math.Abs((date - keyDay).TotalDays)
                                              select keyDay).FirstOrDefault();

                    if (!retroDates.Contains(nearest))
                    {
                        LongitudeStatus         = RectascensionMode.None;
                        DaysToRectascensionMode = 100;
                    }
                    else
                    {
                        DaysToRectascensionMode = (int)((date - nearest).TotalDays);

                        if (DaysToRectascensionMode > EffectiveDays || DaysToRectascensionMode < -EffectiveDays)
                        {
                            LongitudeStatus = RectascensionMode.None;
                        }
                        else
                        {
                            switch (retroDates.IndexOf(nearest))
                            {
                            case 0:
                                LongitudeStatus = RectascensionMode.Resisted;
                                break;

                            case 1:
                                LongitudeStatus = RectascensionMode.Retrograde;
                                break;

                            case 2:
                                LongitudeStatus = RectascensionMode.Direct;
                                break;

                            case 3:
                                LongitudeStatus = RectascensionMode.Transcend;
                                break;

                            default:
                                LongitudeStatus = RectascensionMode.None;
                                break;
                            }
                        }
                    }
                }
                else
                {
                    getRectascensionMode(longSpeeds);
                }

                getDeclinationMode(latSpeeds, latitudes);
                getDistanceMode(distSpeeds);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine(ex.Message);
            }
        }