Example #1
0
        /// <summary>
        /// Finds intersections (overlaps) of the range with second one.
        /// </summary>
        /// <param name="r">Second angle range to find overlaps with.</param>
        /// <returns>Collection (max 2 items) of angle ranges which represent overlaps of two initial ranges.</returns>
        /// <remarks>
        /// The idea of this method is based on solution provided here:
        /// <see href="https://stackoverflow.com/questions/48984436/finding-the-intersections-between-two-angle-ranges-segments"/>.
        /// </remarks>
        public ICollection <AngleRange> Overlaps(AngleRange r)
        {
            List <AngleRange> ranges = new List <AngleRange>();

            double aStart = Start;
            double aSweep = Range;
            double bStart = r.Start;
            double bSweep = r.Range;

            double greaterAngle;
            double greaterSweep;
            double originAngle;
            double originSweep;

            if (aStart < bStart)
            {
                originAngle  = aStart;
                originSweep  = aSweep;
                greaterSweep = bSweep;
                greaterAngle = bStart;
            }
            else
            {
                originAngle  = bStart;
                originSweep  = bSweep;
                greaterSweep = aSweep;
                greaterAngle = aStart;
            }
            double greaterAngleRel = greaterAngle - originAngle;

            if (greaterAngleRel < originSweep)
            {
                ranges.Add(new AngleRange(greaterAngle, Math.Min(greaterSweep, originSweep - greaterAngleRel)));
            }
            double rouno = greaterAngleRel + greaterSweep;

            if (rouno > 360)
            {
                ranges.Add(new AngleRange(originAngle, Math.Min(rouno - 360, originSweep)));
            }

            return(ranges);
        }
Example #2
0
        /// <summary>
        /// Calculates visibity details for the celestial body,
        /// </summary>
        /// <param name="eqBody">Mean equatorial coordinates of the body for the desired day.</param>
        /// <param name="eqSun">Mean equatorial coordinates of the Sun for the desired day.</param>
        /// <param name="minAltitude">Minimal altitude of the body, in degrees, to be considered as approproate for observations. By default it's 5 degrees for planet.</param>
        /// <returns><see cref="VisibilityDetails"/> instance describing details of visibility.</returns>
        // TODO: tests
        public static VisibilityDetails Details(CrdsEquatorial eqBody, CrdsEquatorial eqSun, CrdsGeographical location, double theta0, double minAltitude = 5)
        {
            var details = new VisibilityDetails();

            // period when the planet is above the horizon and its altitude is larger than "minAltitude"
            RTS body = RiseTransitSet(eqBody, location, theta0, minAltitude);

            // period when the Sun is above the horizon
            RTS sun = RiseTransitSet(eqSun, location, theta0);

            // body reaches minimal altitude but Sun does not rise at all (polar night)
            if (body.TransitAltitude > minAltitude && sun.TransitAltitude <= 0)
            {
                details.Period   = VisibilityPeriod.WholeNight;
                details.Duration = body.Duration * 24;
            }
            // body does not reach the minimal altitude during the day
            else if (body.TransitAltitude <= minAltitude)
            {
                details.Period   = VisibilityPeriod.Invisible;
                details.Duration = 0;
            }
            // there is a day/night change during the day and body reaches minimal altitude
            else if (body.TransitAltitude > minAltitude)
            {
                // "Sun is below horizon" time range, expressed in degrees (0 is midnight, 180 is noon)
                var r1 = new AngleRange(sun.Set * 360, (1 - sun.Duration) * 360);

                // "body is above horizon" time range, expressed in degrees (0 is midnight, 180 is noon)
                var r2 = new AngleRange(body.Rise * 360, body.Duration * 360);

                // find the intersections of two ranges
                var ranges = r1.Overlaps(r2);

                // no intersections of time ranges
                if (!ranges.Any())
                {
                    details.Period   = VisibilityPeriod.Invisible;
                    details.Duration = 0;
                    details.Begin    = double.NaN;
                    details.End      = double.NaN;
                }
                // the body is observable during the day
                else
                {
                    // duration of visibility
                    details.Duration = ranges.Sum(i => i.Range / 360 * 24);

                    // beginning of visibility
                    details.Begin = ranges.First().Start / 360;

                    // end of visibility
                    details.End = (details.Begin + details.Duration / 24) % 1;

                    // Evening time range, expressed in degrees
                    // Start is a sunset time, range is a timespan from sunset to midnight.
                    var rE = new AngleRange(sun.Set * 360, (1 - sun.Set) * 360);

                    // Night time range, expressed in degrees
                    // Start is a midnight time, range is a half of timespan from midnight to sunrise
                    var rN = new AngleRange(0, sun.Rise / 2 * 360);

                    // Morning time range, expressed in degrees
                    // Start is a half of time from midnight to sunrise, range is a time to sunrise
                    var rM = new AngleRange(sun.Rise / 2 * 360, sun.Rise / 2 * 360);

                    foreach (var r in ranges)
                    {
                        var isEvening = r.Overlaps(rE);
                        if (isEvening.Any())
                        {
                            details.Period |= VisibilityPeriod.Evening;
                        }

                        var isNight = r.Overlaps(rN);
                        if (isNight.Any())
                        {
                            details.Period |= VisibilityPeriod.Night;
                        }

                        var isMorning = r.Overlaps(rM);
                        if (isMorning.Any())
                        {
                            details.Period |= VisibilityPeriod.Morning;
                        }
                    }
                }
            }

            return(details);
        }