コード例 #1
0
        public static bool TryParse(DateTime?startDate, DateTime?endDate, out SharedCalendarEvent?calendarEvent)
        {
            if (startDate.HasValue && endDate.HasValue)
            {
                DateTime StartTime = startDate.Value.ToUniversalTime();
                DateTime EndTime   = endDate.Value.ToUniversalTime();

                int       MoonMonth;
                MoonPhase MoonPhase;
                DateTime  PhaseStartTime;
                DateTime  PhaseEndTime;
                double    ProgressToFullMoon;
                DateTime  NextFullMoonTime;
                PhaseCalculator.DateTimeToMoonPhase(StartTime, out MoonMonth, out MoonPhase, out PhaseStartTime, out PhaseEndTime, out ProgressToFullMoon, out NextFullMoonTime);

                if (PhaseStartTime == StartTime && PhaseEndTime == EndTime)
                {
                    calendarEvent = new SharedCalendarEvent(MoonPhase, MoonMonth, PhaseStartTime, PhaseEndTime);
                    return(true);
                }
            }

            calendarEvent = null;
            return(false);
        }
コード例 #2
0
        private void BuildCalendar()
        {
            CalendarEntryList.Clear();

            DateTime Time = CalendarStartTime;

            for (int i = 0; i < 5; i++)
            {
                CalendarEntry CalendarEntry;

                if (!CalendarEntryTable.ContainsKey(Time))
                {
                    int       MoonMonth;
                    MoonPhase MoonPhase;
                    DateTime  PhaseStartTime;
                    DateTime  PhaseEndTime;
                    double    ProgressToFullMoon;
                    DateTime  NextFullMoonTime;
                    PhaseCalculator.DateTimeToMoonPhase(Time, out MoonMonth, out MoonPhase, out PhaseStartTime, out PhaseEndTime, out ProgressToFullMoon, out NextFullMoonTime);

                    if (!CalendarEntryTable.ContainsKey(PhaseStartTime))
                    {
                        CalendarEntry NewCalendarEntry = new CalendarEntry(MoonMonth, MoonPhase, PhaseStartTime, PhaseEndTime, MushroomInfoList);
                        CalendarEntryTable.Add(PhaseStartTime, NewCalendarEntry);
                    }

                    Time = PhaseStartTime;
                }

                CalendarEntry = CalendarEntryTable[Time];
                CalendarEntryList.Add(CalendarEntry);

                Time = CalendarEntry.EndTime;
            }
        }
コード例 #3
0
        public void RaysPhase_Test()
        {
            var microphone = new List <MicrophoneSphere>()
            {
                new MicrophoneSphere(new System.Numerics.Vector3(2, 1.6f, 1.7f), 0.1f)
            };
            var rayGeometryGenerator = new RayGeometry(new Vector3(0, 0.5f, 0),
                                                       microphone,
                                                       1000,
                                                       3,
                                                       200);

            rayGeometryGenerator.GenerateRays();

            var rays = rayGeometryGenerator.GetIntersectedRays(microphone[0]);

            rays.Sort((first, second) => first.GetDistance().CompareTo(second.GetDistance()));

            var myRays = new Dictionary <int, List <AcousticRay> >();

            myRays.Add(microphone[0].Id, rays);

            var intensityCalculator = new IntensityCalculator(myRays, microphone, 1);

            intensityCalculator.ComputePower();

            var phaseCalculator = new PhaseCalculator(myRays, microphone, intensityCalculator.Intensities);

            phaseCalculator.ComputePhase(1000);

            double epsilon = 1e-4;

            Assert.IsTrue(Math.Abs(phaseCalculator.EchogramMagnitudePhase[microphone[0].Id][0].Real + 0.002589105375) < epsilon);
        }
コード例 #4
0
        private void OnUpdateMoonPhase()
        {
            // IncreaseNow(); //Debug only
            PhaseCalculator.Update();
            NotifyPropertyChanged(nameof(TimeToNextPhaseText));
            NotifyPropertyChanged(nameof(TimeToFullMoonText));
            NotifyPropertyChanged(nameof(IsFullMoon));
            NotifyPropertyChanged(nameof(IsNextPhaseFullMoon));
            NotifyPropertyChanged(nameof(ToolTipText));

            IsToolTipChanged = true;

            DateTime LastTimeKey = DateTime.MinValue;
            DateTime LastTime    = DateTime.MinValue;

            foreach (KeyValuePair <DateTime, CalendarEntry> Entry in CalendarEntryTable)
            {
                CalendarEntry Item = Entry.Value;
                Item.Update();

                LastTimeKey = Entry.Key;
                LastTime    = Item.EndTime;
            }

            if (LastTime < Now() && !PreviousUpdateChanged)
            {
                CalendarStartTime = LastTimeKey;
                BuildCalendar();
            }

            PreviousUpdateChanged = false;

            PostSharedEvents();
        }
コード例 #5
0
        public void PostSharedEvents(ICollection <MushroomInfo> mushroomInfoList)
        {
            if (mushroomInfoList == null)
            {
                return;
            }

            if (!IsEventActive)
            {
                return;
            }

            if (CredentialToken == null)
            {
                ObtainCredentialToken(true);
            }

            if (CredentialToken == null || SelectedCalendarEntry == SharedCalendarEntry.None)
            {
                return;
            }

            if (!ReadExistingEvents(out List <SharedCalendarEvent> ExistingEvents))
            {
                return;
            }

            DateTime Now           = MainWindow.Now();
            DateTime NextEventTime = ExistingEvents.Count > 0 ? ExistingEvents[ExistingEvents.Count - 1].PhaseEndTime + TimeSpan.FromHours(1) : Now;
            DateTime MaxEventTime  = Now + TimeSpan.FromDays(UpcomingDays);
            List <SharedCalendarEvent> MissingEvents = new List <SharedCalendarEvent>();

            for (;;)
            {
                int       MoonMonth;
                MoonPhase MoonPhase;
                DateTime  PhaseStartTime;
                DateTime  PhaseEndTime;
                double    ProgressToFullMoon;
                DateTime  NextFullMoonTime;
                PhaseCalculator.DateTimeToMoonPhase(NextEventTime, out MoonMonth, out MoonPhase, out PhaseStartTime, out PhaseEndTime, out ProgressToFullMoon, out NextFullMoonTime);

                if (PhaseStartTime >= MaxEventTime)
                {
                    break;
                }

                PhaseStartTime = new DateTime(PhaseStartTime.Year, PhaseStartTime.Month, PhaseStartTime.Day, PhaseStartTime.Hour, 0, 0, PhaseStartTime.Kind);
                PhaseEndTime   = new DateTime(PhaseEndTime.Year, PhaseEndTime.Month, PhaseEndTime.Day, PhaseEndTime.Hour, 0, 0, PhaseEndTime.Kind);

                SharedCalendarEvent NewEvent = new SharedCalendarEvent(MoonPhase, MoonMonth, PhaseStartTime, PhaseEndTime);
                MissingEvents.Add(NewEvent);

                NextEventTime = PhaseEndTime + TimeSpan.FromHours(1);
            }

            if (MissingEvents.Count > 0)
            {
                WriteMissingEvents(MissingEvents, mushroomInfoList);
            }
        }