def get_phase_name(location: Optional[ephem.Observer] = None, wiggle_room: float = 1.5) -> str:
"""Return name of the phase of the moon."""
if location:
date = location.date
else:
date = ephem.now()
if abs(ephem.next_first_quarter_moon(date) - date) < wiggle_room or \
abs(ephem.previous_first_quarter_moon(date) - date) < wiggle_room:
return 'first quarter moon'
elif abs(ephem.next_full_moon(date) - date) < wiggle_room or \
abs(ephem.previous_full_moon(date) - date) < wiggle_room:
return 'full moon'
elif abs(ephem.next_last_quarter_moon(date) - date) < wiggle_room or \
abs(ephem.previous_last_quarter_moon(date) - date) < wiggle_room:
return 'last quarter moon'
elif abs(ephem.next_new_moon(date) - date) < wiggle_room or \
abs(ephem.previous_new_moon(date) - date) < wiggle_room:
return 'new moon'
elif ephem.next_first_quarter_moon(date) - ephem.previous_new_moon(date) < 29:
return 'waxing crescent'
elif ephem.next_full_moon(date) - ephem.previous_first_quarter_moon(date) < 29:
return 'waxing gibbous'
elif ephem.next_last_quarter_moon(date) - ephem.previous_full_moon(date) < 29:
return 'waning gibbous'
elif ephem.next_new_moon(date) - ephem.previous_last_quarter_moon(date) < 29:
return 'waning crescent'
return ''
def __init__(self, year, timezone='Europe/Copenhagen', outformat='text'):
"""Compute moon phases for a whole year"""
# Backtrack and look ahead to be sure to catch moons around newyear
start_date = ephem.Date((year - 1, 9, 1))
end_date = ephem.Date((year + 1, 3, 1))
self.moon_phases = {}
new_moon = ephem.next_new_moon(start_date)
first_quarter = ephem.next_first_quarter_moon(start_date)
full_moon = ephem.next_full_moon(start_date)
last_quarter = ephem.next_last_quarter_moon(start_date)
while True:
local_new_moon = utc2localtime(new_moon.datetime())
local_first_quarter = utc2localtime(first_quarter.datetime())
local_full_moon = utc2localtime(full_moon.datetime())
local_last_quarter = utc2localtime(last_quarter.datetime())
if local_new_moon.year == year:
self.moon_phases[local_new_moon] = \
self.moon_phase_names('new_moon', outformat)
if local_first_quarter.year == year:
self.moon_phases[local_first_quarter] = \
self.moon_phase_names('first_quarter', outformat)
if local_full_moon.year == year:
self.moon_phases[local_full_moon] = \
self.moon_phase_names('full_moon', outformat)
if local_last_quarter.year == year:
self.moon_phases[local_last_quarter] = \
self.moon_phase_names('last_quarter', outformat)
new_moon = ephem.next_new_moon(new_moon)
first_quarter = ephem.next_first_quarter_moon(first_quarter)
full_moon = ephem.next_full_moon(full_moon)
last_quarter = ephem.next_last_quarter_moon(last_quarter)
if (new_moon > end_date) and (first_quarter > end_date) and \
(full_moon > end_date) and (last_quarter > end_date):
break
def get_moons_in_year(year, month, day):
"""Returns a list of the full moons, first quarter moons, last quarter moons and new moons in a year."""
moons = []
date = ephem.Date(datetime.date(year, month, day))
while date.datetime().year == year:
date = ephem.next_full_moon(date)
moons.append((date, 'Luna Llena'))
date = ephem.Date(datetime.date(year, month, day))
while date.datetime().year == year:
date = ephem.next_first_quarter_moon(date)
moons.append((date, 'Cuarto Creciente'))
date = ephem.Date(datetime.date(year, month, day))
while date.datetime().year == year:
date = ephem.next_last_quarter_moon(date)
moons.append((date, 'Cuarto Menguante'))
date = ephem.Date(datetime.date(year, month, day))
while date.datetime().year == year:
date = ephem.next_new_moon(date)
moons.append((date, 'Luna Nueva'))
moons_sorted = sorted(moons, key=lambda x: x[0].datetime())
moons_in_year = []
for i in moons_sorted:
moons_in_year.append((i[0].datetime().ctime(), i[1]))
return moons_in_year
def getMoonPhases():
date = ephem.now()
new_moon = str(ephem.next_new_moon(date))
first_quarter_moon = str(ephem.next_first_quarter_moon(date))
full_moon = str(ephem.next_full_moon(date))
last_quarter_moon = str(ephem.next_last_quarter_moon(date))
return new_moon, first_quarter_moon, full_moon, last_quarter_moon
def __init__(self):
self.__logger = logging.getLogger(self.__class__.__name__)
#find current moon phase
now = ephem.now()
new_date = ephem.next_new_moon(now)
first_quarter_date = ephem.next_first_quarter_moon(now)
full_date = ephem.next_full_moon(now)
last_quarter_date = ephem.next_last_quarter_moon(now)
delta = float('inf')
if new_date - now < delta:
delta = new_date - now
self.__current_phase = MoonUpdater.LAST_QUARTER_MOON
self.__current_phase_date = ephem.previous_last_quarter_moon(
now).datetime()
if first_quarter_date - now < delta:
delta = first_quarter_date - now
self.__current_phase = MoonUpdater.NEW_MOON
self.__current_phase_date = ephem.previous_new_moon(now).datetime()
if full_date - now < delta:
delta = full_date - now
self.__current_phase = MoonUpdater.FIRST_QUARTER_MOON
self.__current_phase_date = ephem.previous_first_quarter_moon(
now).datetime()
if last_quarter_date - now < delta:
delta = last_quarter_date - now
self.__current_phase = MoonUpdater.FULL_MOON
self.__current_phase_date = ephem.previous_full_moon(
now).datetime()
def get_next_date_special(self, date_tuple, utc_offset=0):
"""
Returns next ephemeris date the given time.
The date tuple should be in the local time.
return date tupple
"""
cpm = None
if self.string_tab == '@fullmoon':
cpm = ephem.next_full_moon(date_tuple)
elif self.string_tab == '@newmoon':
cpm = ephem.next_new_moon(date_tuple)
elif self.string_tab == '@firstquarter':
cpm = ephem.next_first_quarter_moon(date_tuple)
elif self.string_tab == '@lastquarter':
cpm = ephem.next_last_quarter_moon(date_tuple)
elif self.string_tab == '@equinox':
cpm = ephem.next_equinox(date_tuple)
elif self.string_tab == '@solstice':
cpm = ephem.next_solstice(date_tuple)
elif self.string_tab in ['@dawn', '@dusk']:
bobs = ephem.Sun()
date = "{0}/{1}/{2}".format(date_tuple[0], date_tuple[1],
date_tuple[2])
if self.string_tab == '@dawn':
cpm = self._city.next_rising(bobs, start=date)
else:
cpm = self._city.next_setting(bobs, start=date)
if cpm:
return cpm.tuple()[:-1]
return None
def moon_phases(start, end, output_format):
d = ephem.previous_full_moon(start)
d = ephem.previous_full_moon(d)
print("Starting from", d)
def output_moon_phase(d, phasename, img, attr):
if output_format == "sql":
print("('%s', 'astronomy', 'naked eye', '%s', '%s', '%s', "
"'%s', 240, 240, '%s')," %
(phasename + " moon", datestr(d), datestr(d),
phasename + " moon", img, attr))
else:
print(datestr(d), ":", phasename + " moon")
while d <= end:
d = ephem.next_first_quarter_moon(d)
output_moon_phase(
d, "First quarter", 'astronomy/Phase-088.jpg',
'<a href=\"http://commons.wikimedia.org/wiki/'
'File:Phase-088.jpg\">Jay Tanner</a>')
d = ephem.next_full_moon(d)
output_moon_phase(
d, "Full", 'astronomy/Phase-180.jpg',
'<a href=\"http://commons.wikimedia.org/wiki/'
'File:Phase-180.jpg\">Jay Tanner</a>')
d = ephem.next_last_quarter_moon(d)
output_moon_phase(
d, "Last quarter", 'astronomy/Phase-270.jpg',
'<a href=\"http://commons.wikimedia.org/wiki/'
'File:Phase-270.jpg\">Jay Tanner</a>')
d = ephem.next_new_moon(d)
output_moon_phase(
d, "New", 'astronomy/New_Moon.jpg',
'<a href="https://commons.wikimedia.org/wiki/'
'File:New_Moon.jpg">QuimGil</a>')
def phases(start):
j = ephem.Moon()
#start = '2015-10-1'
moon_phases = {}
for x in range(20):
if x > 0:
new_moon = ephem.next_new_moon(third_quarter)
j.compute(new_moon)
print j.earth_distance * ephem.meters_per_au / 1000, j.phase
else:
year_c = str(start)
new_moon = ephem.next_new_moon(year_c)
first_quarter = ephem.next_first_quarter_moon(new_moon)
full_moon = ephem.next_full_moon(first_quarter)
# j = ephem.Moon()
j.compute(full_moon)
print j.earth_distance * ephem.meters_per_au / 1000, j.phase
third_quarter = ephem.next_last_quarter_moon(full_moon)
moon_phases[x] = new_moon, first_quarter, full_moon, third_quarter
print 'New Moon :', new_moon
# print 'First Quarter:', first_quarter
print 'Full Moon :', full_moon
# print 'Third Quarter:', third_quarter
#print '------------------------'
#print moon_phases
moon_phase_pd = pd.DataFrame(moon_phases)#, index=['new_moon', 'first_quarter', 'full_moon', 'third_quarter'])
moon_phase_pd = moon_phase_pd.T
print moon_phase_pd
moon_phase_pd.to_csv('astro/data/planet_stations/moon_phases.csv')
return (moon_phases)
def _check_trigger_special(self, date_tuple, utc_offset=0):
"""
Returns boolean indicating if the trigger is active at the given time.
The date tuple should be in the local time.
"""
cpm = False
if self.string_tab == '@fullmoon':
cpm = ephem.next_full_moon(date_tuple)
elif self.string_tab == '@newmoon':
cpm = ephem.next_new_moon(date_tuple)
elif self.string_tab == '@firstquarter':
cpm = ephem.next_first_quarter_moon(date_tuple)
elif self.string_tab == '@lastquarter':
cpm = ephem.next_last_quarter_moon(date_tuple)
elif self.string_tab == '@equinox':
cpm = ephem.next_equinox(date_tuple)
elif self.string_tab == '@solstice':
cpm = ephem.next_solistice(date_tuple)
elif self.string_tab in ['@dawn', '@dusk']:
bobs = ephem.Sun()
if self.string_tab == '@dawn':
cpm = self._city.next_rising(bobs)
else:
cpm = self._city.next_setting(bobs)
if cpm:
""" Do compare """
print cpm
return True
else:
return False
def get_next_date_special(self, date_tuple, utc_offset=0):
"""
Returns next ephemeris date the given time.
The date tuple should be in the local time.
return date tupple
"""
cpm = None;
if self.string_tab == '@fullmoon':
cpm = ephem.next_full_moon(date_tuple)
elif self.string_tab == '@newmoon':
cpm = ephem.next_new_moon(date_tuple)
elif self.string_tab == '@firstquarter':
cpm = ephem.next_first_quarter_moon(date_tuple)
elif self.string_tab == '@lastquarter':
cpm = ephem.next_last_quarter_moon(date_tuple)
elif self.string_tab == '@equinox':
cpm = ephem.next_equinox(date_tuple)
elif self.string_tab == '@solstice':
cpm = ephem.next_solstice(date_tuple)
elif self.string_tab in ['@dawn', '@dusk']:
bobs = ephem.Sun()
date = "{0}/{1}/{2}".format(date_tuple[0], date_tuple[1], date_tuple[2])
if self.string_tab == '@dawn':
cpm = self._city.next_rising(bobs, start=date)
else:
cpm = self._city.next_setting(bobs, start=date)
if cpm:
return cpm.tuple()[:-1]
return None
def get_moon_phase(observer):
target_date_utc = observer.date
target_date_local = ephem.localtime(target_date_utc).date()
next_full = ephem.localtime(ephem.next_full_moon(target_date_utc)).date()
next_new = ephem.localtime(ephem.next_new_moon(target_date_utc)).date()
next_last_quarter = ephem.localtime(
ephem.next_last_quarter_moon(target_date_utc)).date()
next_first_quarter = ephem.localtime(
ephem.next_first_quarter_moon(target_date_utc)).date()
previous_full = ephem.localtime(
ephem.previous_full_moon(target_date_utc)).date()
previous_new = ephem.localtime(
ephem.previous_new_moon(target_date_utc)).date()
previous_last_quarter = ephem.localtime(
ephem.previous_last_quarter_moon(target_date_utc)).date()
previous_first_quarter = ephem.localtime(
ephem.previous_first_quarter_moon(target_date_utc)).date()
if target_date_local in (next_full, previous_full):
return 'Full'
elif target_date_local in (next_new, previous_new):
return 'New'
elif target_date_local in (next_first_quarter, previous_first_quarter):
return 'First Quarter'
elif target_date_local in (next_last_quarter, previous_last_quarter):
return 'Last Quarter'
elif previous_new < next_first_quarter < next_full < next_last_quarter < next_new:
return 'Waxing Crescent'
elif previous_first_quarter < next_full < next_last_quarter < next_new < next_first_quarter:
return 'Waxing Gibbous'
elif previous_full < next_last_quarter < next_new < next_first_quarter < next_full:
return 'Waning Gibbous'
elif previous_last_quarter < next_new < next_first_quarter < next_full < next_last_quarter:
return 'Waning Crescent'
def phases(start):
j = ephem.Moon()
#start = '2015-10-1'
moon_phases = {}
for x in range(12):
if x > 0:
new_moon = ephem.next_new_moon(third_quarter)
j.compute(new_moon)
#print j.earth_distance * ephem.meters_per_au / 1000, j.phase
else:
year_c = str(start)
new_moon = ephem.next_new_moon(year_c)
first_quarter = ephem.next_first_quarter_moon(new_moon)
full_moon = ephem.next_full_moon(first_quarter)
# j = ephem.Moon()
j.compute(full_moon)
#print j.earth_distance * ephem.meters_per_au / 1000, j.phase
third_quarter = ephem.next_last_quarter_moon(full_moon)
moon_phases[x] = {'new moon' : str(new_moon), 'first quarter' : str(first_quarter), 'full moon' : str(full_moon), 'third quarter' : str(third_quarter)}
#print 'New Moon :', new_moon
#print 'First Quarter:', first_quarter
#print 'Full Moon :', full_moon
#print 'Third Quarter:', third_quarter
#print '------------------------'
#print moon_phases
moon_phase_pd = pd.DataFrame(moon_phases)#, index=['new_moon', 'first_quarter', 'full_moon', 'third_quarter'])
moon_phase_pd = moon_phase_pd.T
#print moon_phase_pd
moon_phase_pd.to_csv('astro/data/planet_stations/moon_phases.csv')
return (moon_phases)
def _check_trigger_special(self, date_tuple, utc_offset=0):
"""
Returns boolean indicating if the trigger is active at the given time.
The date tuple should be in the local time.
"""
cpm = False;
if self.string_tab == '@fullmoon':
cpm = ephem.next_full_moon(date_tuple)
elif self.string_tab == '@newmoon':
cpm = ephem.next_new_moon(date_tuple)
elif self.string_tab == '@firstquarter':
cpm = ephem.next_first_quarter_moon(date_tuple)
elif self.string_tab == '@lastquarter':
cpm = ephem.next_last_quarter_moon(date_tuple)
elif self.string_tab == '@equinox':
cpm = ephem.next_equinox(date_tuple)
elif self.string_tab == '@solstice':
cpm = ephem.next_solistice(date_tuple)
elif self.string_tab in ['@dawn', '@dusk']:
bobs = ephem.Sun()
if self.string_tab == '@dawn':
cpm = self._city.next_rising(bobs)
else:
cpm = self._city.next_setting(bobs)
if cpm:
""" Do compare """
print cpm
return True
else:
return False
def __init__(self, moonphase, date):
self.info_pass = ""
if moonphase == "full":
self.moon = ephem.next_full_moon(date)
elif moonphase == "new":
self.moon = ephem.next_new_moon(date)
elif moonphase == "first_quarter":
self.moon = ephem.next_first_quarter_moon(date)
elif moonphase == "last_quarter":
self.moon = ephem.next_last_quarter_moon(date)
def next_moon_phase_date(self):
if self.__current_phase == MoonUpdater.NEW_MOON:
return ephem.next_first_quarter_moon(
self.__current_phase_date).datetime()
elif self.__current_phase == MoonUpdater.FIRST_QUARTER_MOON:
return ephem.next_full_moon(self.__current_phase_date).datetime()
elif self.__current_phase == MoonUpdater.FULL_MOON:
return ephem.next_last_quarter_moon(
self.__current_phase_date).datetime()
elif self.__current_phase == MoonUpdater.LAST_QUARTER_MOON:
return ephem.next_new_moon(self.__current_phase_date).datetime()
def lunar_start(year, month, day):
# 🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘 🌑
# >>> ephem.next_full_moon((2013, 11, 17)).tuple()[:3]
# (2013, 11, 17)
if (year, month, day) == ephem.next_full_moon((year, month, day)).tuple()[:3]:
return u"🌕"
elif (year, month, day) == ephem.next_first_quarter_moon((year, month, day)).tuple()[:3]:
return u"🌓"
elif (year, month, day) == ephem.next_last_quarter_moon((year, month, day)).tuple()[:3]:
return u"🌗"
elif (year, month, day) == ephem.next_new_moon((year, month, day)).tuple()[:3]:
return u"🌑"
def findNextFourPhases(self):
'''
This function returns a sorted tuple of the next four phases with the key being the short
name for the phase. The value is a modified Julian date for the phase.
@return: A list of tuples sorted by the value date.
'''
phases = {}
phases["new"] = ephem.next_new_moon(self._observer.date)
phases["fq"] = ephem.next_first_quarter_moon(self._observer.date)
phases["full"] = ephem.next_full_moon(self._observer.date)
phases["tq"] = ephem.next_last_quarter_moon(self._observer.date)
return sorted(phases.items(), key=lambda x: x[1])
def findNextFourPhases(self):
'''
This function returns a sorted tuple of the next four phases with the key being the short
name for the phase. The value is a modified Julian date for the phase.
@return: A list of tuples sorted by the value date.
'''
phases = {}
phases["new"] = ephem.next_new_moon(self._observer.date)
phases["fq"] = ephem.next_first_quarter_moon(self._observer.date)
phases["full"] = ephem.next_full_moon(self._observer.date)
phases["tq"] = ephem.next_last_quarter_moon(self._observer.date)
return sorted(phases.items(), key=lambda x:x[1])
def moon_is(adate): " Find the next moon shape, returns FM .. NM." # TODO(mohsin) This is expensive, should cache it for whole month. # ephem.previous_new_moon(date) # ephem.previous_first_quarter_moon(date) # ephem.previous_full_moon(date) # ephem.previous_last_quarter_moon(date) date = ephem.Date(adate) if cmp_ymd(ephem.next_new_moon(date) , date): return 'NM' if cmp_ymd(ephem.next_first_quarter_moon(date), date): return 'FQ' if cmp_ymd(ephem.next_full_moon(date) , date): return 'FM' if cmp_ymd(ephem.next_last_quarter_moon(date) , date): return 'LQ' return ''
def make_moon_stuff(outer_canv, inner_canv, begin_day, no_days, chart,
obs):
small_moon_rad = 0.12
large_moon_rad = 0.16
moon = ephem.Moon()
moon2 = ephem.Moon()
for doy in range(no_days) :
obs.date = begin_day + doy
mpc = obs.date + 0.5 # moon phase check
moon_set = obs.next_setting(moon)
moon2.compute(moon_set)
X = moon2.moon_phase
# Waxing moon (moonsets)
x, y = to_chart_coord(moon_set, chart)
if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) :
# full moon
outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
elif ((X < 0.55 and X > 0.45) or
fabs(ephem.next_first_quarter_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_first_quarter_moon(mpc) - mpc) < 0.5) :
# first quarter
outer_canv.stroke(first_quarter_moon(large_moon_rad, x,y),[mooncolordark,pyx.deco.filled([mooncolordark])])
elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5):
# new moon
outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])])
else :
inner_canv.fill(waxing_moon(X, small_moon_rad, x, y),
[style.linejoin.bevel,mooncolordark])
# Waning moon (moonrises)
moon_rise = obs.next_rising(moon)
moon2.compute(moon_rise)
X = moon2.moon_phase
x, y = to_chart_coord(moon_rise, chart)
if (fabs(ephem.next_full_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_full_moon(mpc) - mpc) < 0.5) :
# full moon
outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
elif ((X < 0.55 and X > 0.45) or
fabs(ephem.next_last_quarter_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_last_quarter_moon(mpc) - mpc) < 0.5) :
# last quarter
outer_canv.stroke(last_quarter_moon(large_moon_rad, x,y),[mooncolorlight,pyx.deco.filled([mooncolorlight])])
elif (fabs(ephem.next_new_moon(mpc) - mpc) < 0.5 or
fabs(ephem.previous_new_moon(mpc) - mpc) < 0.5):
# new moon
outer_canv.stroke(path.circle(x,y,large_moon_rad),[mooncolorlight,pyx.deco.filled([mooncolordark])])
else :
inner_canv.fill(waning_moon(X, small_moon_rad, x, y),
[style.linejoin.bevel,mooncolorlight])
def __init__(self, year, timezone='Europe/Copenhagen',
outformat='text'):
"""Compute moon phases for a whole year"""
# Backtrack and look ahead to be sure to catch moons around newyear
start_date = ephem.Date((year-1, 9, 1))
end_date = ephem.Date((year+1, 3, 1))
self.moon_phases = {}
new_moon = ephem.next_new_moon(start_date)
first_quarter = ephem.next_first_quarter_moon(start_date)
full_moon = ephem.next_full_moon(start_date)
last_quarter = ephem.next_last_quarter_moon(start_date)
while True:
local_new_moon = utc2localtime(new_moon.datetime())
local_first_quarter = utc2localtime(first_quarter.datetime())
local_full_moon = utc2localtime(full_moon.datetime())
local_last_quarter = utc2localtime(last_quarter.datetime())
if local_new_moon.year == year:
self.moon_phases[local_new_moon] = \
self.moon_phase_names('new_moon', outformat)
if local_first_quarter.year == year:
self.moon_phases[local_first_quarter] = \
self.moon_phase_names('first_quarter', outformat)
if local_full_moon.year == year:
self.moon_phases[local_full_moon] = \
self.moon_phase_names('full_moon', outformat)
if local_last_quarter.year == year:
self.moon_phases[local_last_quarter] = \
self.moon_phase_names('last_quarter', outformat)
new_moon = ephem.next_new_moon(new_moon)
first_quarter = ephem.next_first_quarter_moon(first_quarter)
full_moon = ephem.next_full_moon(full_moon)
last_quarter = ephem.next_last_quarter_moon(last_quarter)
if (new_moon > end_date) and (first_quarter > end_date) and \
(full_moon > end_date) and (last_quarter > end_date):
break
def next_four_phases(self):
"""The next for phases in date sorted order (closest phase first).
Returns
-------
list[(str, float)]
Set of moon phases specified by an abbreviated phase name and Modified Julian Date.
"""
phases = {}
phases["new_moon"] = ephem.next_new_moon(self.observer.date)
phases["first_quarter"] = ephem.next_first_quarter_moon(self.observer.date)
phases["full_moon"] = ephem.next_full_moon(self.observer.date)
phases["last_quarter"] = ephem.next_last_quarter_moon(self.observer.date)
sorted_phases = sorted(phases.items(), key=itemgetter(1))
sorted_phases = [(phase[0], mjd_to_date_tuple(phase[1])) for phase in sorted_phases]
return sorted_phases
def moonPhase(date):
mydate = ephem.date(
date.replace(hour=00, minute=0, second=0, microsecond=0))
nnm = ephem.next_new_moon(mydate)
nqm = ephem.next_first_quarter_moon(mydate)
nfm = ephem.next_full_moon(mydate)
nlm = ephem.next_last_quarter_moon(mydate)
quarter = ""
if nfm > nqm:
quarter = "Waxing Crescent"
if nqm > nfm:
quarter = "Waxing Gibbous"
if nfm > nlm:
quarter = "Waning Gibbous"
if nlm > nnm:
quarter = "Waning Crescent"
if nnm.datetime().replace(hour=0, minute=0, second=0,
microsecond=0) == date.replace(hour=0,
minute=0,
second=0,
microsecond=0):
quarter = "New %s" % nnm.datetime().strftime("%H:%M:%S")
if nfm.datetime().replace(hour=0, minute=0, second=0,
microsecond=0) == date.replace(hour=0,
minute=0,
second=0,
microsecond=0):
quarter = "Full %s " % nfm.datetime().strftime("%H:%M:%S")
if nqm.datetime().replace(hour=0, minute=0, second=0,
microsecond=0) == date.replace(hour=0,
minute=0,
second=0,
microsecond=0):
quarter = "First quarter %s " % nqm.datetime().strftime("%H:%M:%S")
if nlm.datetime().replace(hour=0, minute=0, second=0,
microsecond=0) == date.replace(hour=0,
minute=0,
second=0,
microsecond=0):
quarter = "Last quarter %s " % nlm.datetime().strftime("%H:%M:%S")
return quarter
def is_major_phase(date):
"""Returns a code if the date coincides with a major Moon phase, i.e. first
quarter, full Moon, last quarter or new Moon.
Keyword arguments:
date -- a PyEphem Date object.
"""
# Calculate the exact date and time of each upcoming major Moon phase.
next_new_moon = ephem.next_new_moon(date)
next_first_quarter_moon = ephem.next_first_quarter_moon(date)
next_full_moon = ephem.next_full_moon(date)
next_last_quarter_moon = ephem.next_last_quarter_moon(date)
# Format the major Moon phase dates by resetting their hour, minute and
# second values to zero, positioning each day at midnight so that they can
# be directly compared against the date argument.
next_new_moon_date = helpers.set_date_to_midnight(next_new_moon)
next_first_quarter_moon_date = helpers.set_date_to_midnight(
next_first_quarter_moon)
next_full_moon_date = helpers.set_date_to_midnight(next_full_moon)
next_last_quarter_moon_date = helpers.set_date_to_midnight(
next_last_quarter_moon)
# Convert the `date` arugment to an Ephem Date for comparison.
date = ephem.Date(date)
# Return the appropriate code based on if there is a match. No matches will
# return `None`.
if (next_new_moon_date == date):
return 'new_moon'
if (next_first_quarter_moon_date == date):
return 'first_quarter'
if (next_full_moon_date == date):
return 'full_moon'
if (next_last_quarter_moon_date == date):
return 'last_quarter'
return None
def get_lunation_day(today, number_of_phase_ids=28):
'''Given a date (of type ephem.Date), return a lunar cycle day ID number
(integer in [0:(number_of_phase_ids - 1)]), corresponding to the lunation
for the given date. 0 = new moon.
Arguments:
today (ephem.date): the date for which to get the lunation day number
Optional:
number_of_phase_ids (integer, default = 28): the number of unique
lunar cycle day identifiers, e.g. the number of moon phase icons
available to display the lunation each day.
Returns:
integer in range(0, number_of_phase_ids - 1), today's lunation phase
ID number.
The lunation day is calibrated to the quarter phases
calculated by pyephem, but it does not always agree exactly with
percent illumination, which is a different calculation entirely.'''
last_new = ephem.previous_new_moon(today)
next_new = ephem.next_new_moon(today)
num = number_of_phase_ids - 1
first_approx = round((today - last_new) / (next_new - last_new) * num)
if first_approx < np.ceil(num / 4):
next_fq = ephem.next_first_quarter_moon(last_new)
if today < next_fq:
return round((today - last_new) / (next_fq - last_new)
* (num / 4))
if first_approx < np.ceil(num / 2):
next_full = ephem.next_full_moon(last_new)
if today < next_full:
return round((today - last_new) / (next_full - last_new)
* (num / 2))
if first_approx < np.ceil(num * 3 / 4):
next_lq = ephem.next_last_quarter_moon(last_new)
if today < next_lq:
return round((today - last_new) / (next_lq - last_new)
* (num * 3 / 4))
return first_approx
def gen_moon_phases(self, start, until, lunar_phase=None):
'''Return an interator of moon phases over the given dates.'''
phase_date = start
while phase_date < until:
elong = self.get_degrees(ephem.Moon(phase_date).elong)
if elong < -90:
nxt_phase = ephem.next_last_quarter_moon(phase_date)
phase = RuleLunar.moon_3q
elif elong < 0:
nxt_phase = ephem.next_new_moon(phase_date)
phase = RuleLunar.moon_new
elif elong < 90:
nxt_phase = ephem.next_first_quarter_moon(phase_date)
phase = RuleLunar.moon_1q
else:
nxt_phase = ephem.next_full_moon(phase_date)
phase = RuleLunar.moon_full
phase_date = self.get_datetime(nxt_phase)
if phase_date < until and (not lunar_phase
or lunar_phase == phase):
yield phase, phase_date
phase_date += datetime.timedelta(days=1)
def new_moon(bot, update):
dfu = update.message.text
moon = {
"Предыдущий цикл": {
"Последняя четверть луны": ephem.previous_last_quarter_moon(dfu),
"Новолуние": ephem.previous_new_moon(dfu),
"Первая четверть луны": ephem.previous_first_quarter_moon(dfu),
"Полнолуние": ephem.previous_full_moon(dfu),
},
"Следующий цикл": {
"Последняя четверть луны": ephem.next_last_quarter_moon(dfu),
"Новолуние": ephem.next_new_moon(dfu),
"Первая четверть луны": ephem.next_first_quarter_moon(dfu),
"Полнолуние": ephem.next_full_moon(dfu),
}
}
for key in moon:
bot.sendMessage(update.message.chat_id, text=key)
for row_key in moon[key]:
bot.sendMessage(update.message.chat_id,
text=(row_key, ":", moon[key][row_key]))
def get_moons_in_year(year):
"""
Returns a list of the full and new moons in a year. The list contains tuples
of either the form (DATE,'full') or the form (DATE,'new')
Data is truncated at hours and minutes; round to nearest Minute by
adding 30 seconds to date
"""
moons = []
date = ephem.Date(datetime.date(year, 1, 1))
end = ephem.Date(datetime.datetime(year, 12, 31, 23, 59))
while date.datetime().year == year:
date = ephem.next_full_moon(date)
if date < end:
moons.append(pom_format('Full Moon', date))
date = ephem.Date(datetime.date(year, 1, 1))
while date.datetime().year == year:
date = ephem.next_new_moon(date)
if date < end:
moons.append(pom_format('New Moon', date))
date = ephem.Date(datetime.date(year, 1, 1))
while date.datetime().year == year:
date = ephem.next_first_quarter_moon(date)
if date < end:
moons.append(pom_format('First Quarter', date))
date = ephem.Date(datetime.date(year, 1, 1))
while date.datetime().year == year:
date = ephem.next_last_quarter_moon(date)
if date < end:
moons.append(pom_format('Last Quarter', date))
moons.sort(key=lambda x: float(x.split()[0]))
return moons
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 13 14:07:43 2020
https://rhodesmill.org/pyephem/quick.html#phases-of-the-moon
@author: PC
"""
import ephem
d1 = ephem.next_full_moon('1984')
print(d1)
d2 = ephem.next_new_moon(d1)
print(d2)
print(ephem.previous_new_moon('2020'))
print(ephem.next_new_moon('2020'))
print(ephem.previous_first_quarter_moon('2020'))
print(ephem.next_first_quarter_moon('2020'))
print(ephem.previous_full_moon('2020'))
print(ephem.next_full_moon('2020'))
print(ephem.previous_last_quarter_moon('2020'))
print(ephem.next_last_quarter_moon('2020'))
def main():
sun = ephem.Sun()
moon = ephem.Moon()
# define observer
home = ephem.Observer()
home.date = ephem.date(datetime.utcnow())
home.lat, home.lon = '50.46', '9.61'
sun.compute(home)
sunrise, sunset = (home.next_rising(sun),
home.next_setting(sun))
moon.compute(home)
moonrise, moonset = (home.next_rising(moon),
home.next_setting(moon))
home.horizon = '-6'
m6_start, m6_end = (home.next_rising(sun, use_center=True),
home.next_setting(sun, use_center=True))
home.horizon = '-12'
m12_start, m12_end = (home.next_rising(sun, use_center=True),
home.next_setting(sun, use_center=True))
home.horizon = '-18'
m18_start, m18_end = (home.next_rising(sun, use_center=True),
home.next_setting(sun, use_center=True))
print home.date
e = {}
e[sunrise] = " Sunrise: "
e[sunset] = " Sunset: "
e[moonrise] = " Moonrise: "
e[moonset] = " Moonset: "
e[m6_start] = " Civil twilight starts: "
e[m6_end] = " Civil twilight ends: "
e[m12_start] = " Nautical twilight starts: "
e[m12_end] = " Nautical twilight ends: "
e[m18_start] = " Astronomical twilight starts: "
e[m18_end] = " Astronomical twilight ends: "
for time in sorted(e.keys()):
print e[time], ephem.localtime(time).ctime()
# Here start the moon specific data
print " ---"
print " Moon phase: %d%% " % moon.phase
e = {}
e1 = ephem.previous_new_moon(home.date)
e[e1] = " Previous new moon: "
e1 = ephem.previous_first_quarter_moon(home.date)
e[e1] = " Previous first quarter moon: "
e1 = ephem.previous_full_moon(home.date)
e[e1] = " Previous full moon: "
e1 = ephem.previous_last_quarter_moon(home.date)
e[e1] = " Previous last quarter moon: "
e1 = ephem.next_new_moon(home.date)
e[e1] = " Next new moon: "
e1 = ephem.next_first_quarter_moon(home.date)
e[e1] = " Next first quarter moon: "
e1 = ephem.next_full_moon(home.date)
e[e1] = " Next full moon: "
e1 = ephem.next_last_quarter_moon(home.date)
e[e1] = " Next last quarter moon: "
for time in sorted(e.keys()):
print e[time], ephem.localtime(time).ctime()
#!/usr/bin/python # Print next moon quarter (requires PyEphem) # 2014-07-08 import ephem n = ephem.now() # Unicode symbols are for inverted text (white on black): p = [[ephem.next_full_moon(n),"🌑 Vollmond"], [ephem.next_last_quarter_moon(n),"🌓 Letztes Viertel"], [ephem.next_new_moon(n),"🌕 Neumond"], [ephem.next_first_quarter_moon(n),"🌗 Erstes Viertel"]] p.sort() a = p[0] h = 24*(a[0]-n) def nat(h): h2 = round(h) if h > 24: d = h2//24 if d > 1: dh = "%u Tagen" % d else: dh = "einem Tag" hh = h2 - 24*d if hh > 1: hhh = "%u Stunden" % hh
now = datetime.now() #Past Moon phases d5 = ephem.previous_new_moon(now) d6 = ephem.previous_first_quarter_moon(now) d7 = ephem.previous_full_moon(now) d8 = ephem.previous_last_quarter_moon(now) print print (d5), " | Previous new Moon" print (d6), " | Previous quarter Moon" print (d7), " | Previous full Moon" print (d8), " | Previous last quarter Moon" print #Next Moon phases d1 = ephem.next_full_moon(now) d2 = ephem.next_new_moon(now) d3 = ephem.next_first_quarter_moon(now) d4 = ephem.next_last_quarter_moon(now) print (d2), " | Next new Moon" print (d3), " | Next quarter Moon" print (d1), " | Next full Moon" print (d4), " | Next last quarter Moon" print m=ephem.Moon(now) print "Moon is actually:", (ephem.constellation(m)) quit()
data['sun']['altitude'] = sun.alt data['sun']['azimuth'] = sun.az # MOON DATA moonrise = observer.previous_rising(ephem.Moon()) moonnoon = observer.next_transit (ephem.Moon()) moonset = observer.next_setting (ephem.Moon()) data['moon']['rise'] = calendar.timegm(moonrise.datetime().utctimetuple()) data['moon']['noon'] = calendar.timegm(moonnoon.datetime().utctimetuple()) data['moon']['set'] = calendar.timegm(moonset.datetime().utctimetuple()) data['moon']['radius'] = ephem.moon_radius previous_new_moon = ephem.previous_new_moon(time) next_new_moon = ephem.next_new_moon(time) previous_first_quarter_moon = ephem.previous_first_quarter_moon(time) next_first_quarter_moon = ephem.next_first_quarter_moon(time) previous_full_moon = ephem.previous_full_moon(time) next_full_moon = ephem.next_full_moon(time) previous_last_quarter_moon = ephem.previous_last_quarter_moon(time) next_last_quarter_moon = ephem.next_last_quarter_moon(time) data['moon']['previous_new_moon'] = calendar.timegm(previous_new_moon.datetime().utctimetuple()) data['moon']['next_new_moon'] = calendar.timegm(next_new_moon.datetime().utctimetuple()) data['moon']['previous_first_quarter_moon'] = calendar.timegm(previous_first_quarter_moon.datetime().utctimetuple()) data['moon']['next_first_quarter_moon'] = calendar.timegm(next_first_quarter_moon.datetime().utctimetuple()) data['moon']['previous_full_moon'] = calendar.timegm(previous_full_moon.datetime().utctimetuple()) data['moon']['next_full_moon'] = calendar.timegm(next_full_moon.datetime().utctimetuple()) data['moon']['previous_last_quarter_moon'] = calendar.timegm(previous_last_quarter_moon.datetime().utctimetuple()) data['moon']['next_last_quarter_moon'] = calendar.timegm(next_last_quarter_moon.datetime().utctimetuple()) moon = ephem.Moon()
def onHeartbeat(self):
Domoticz.Debug("onHeartbeat")
self.__runAgain -= 1
if self.__runAgain <= 0:
self.__runAgain = self.__HEARTBEATS2MIN * self.__MINUTES
#
utc_now = datetime.datetime.utcnow()
target_date = datetime.datetime.now().date()
#
self.__observer.date = utc_now
self.__sun.compute(self.__observer)
#
################################################################################
# Sun data
################################################################################
#
# -------------------------------------------------------------------------------
# Sun altitude
# -------------------------------------------------------------------------------
value = round(deg(self.__sun.alt), 2)
UpdateDevice(unit.SUN_ALT, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Sun azimuth
# -------------------------------------------------------------------------------
value = round(deg(self.__sun.az), 2)
UpdateDevice(unit.SUN_AZ, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Sun distance
# -------------------------------------------------------------------------------
value = round(self.__sun.earth_distance * ephem.meters_per_au / 1000)
UpdateDevice(unit.SUN_DIST, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Sun transit
# -------------------------------------------------------------------------------
value = (
ephem.localtime(self.__observer.next_transit(self.__sun)) + self.__SEC30
)
UpdateDevice(
unit.SUN_TRANSIT, 0, "{}".format(value.strftime(self.__DT_FORMAT))
)
#
# -------------------------------------------------------------------------------
# Sun rise & set today
# -------------------------------------------------------------------------------
self.__observer.date = target_date
self.__sun.compute(self.__observer)
i = 0
for t in self.__TWILIGHTS:
# Zero the horizon
self.__observer.horizon = t[0]
try:
next_rising = (
ephem.localtime(
self.__observer.next_rising(self.__sun, use_center=t[1])
)
+ self.__SEC30
)
UpdateDevice(
unit.SUN_RISE + i,
0,
"{}".format(next_rising.strftime(self.__DT_FORMAT)),
)
except:
UpdateDevice(
unit.SUN_RISE + i,
0,
"{}".format("No time available"),
)
try:
next_setting = (
ephem.localtime(
self.__observer.next_setting(self.__sun, use_center=t[1])
)
+ self.__SEC30
)
UpdateDevice(
unit.SUN_SET + i,
0,
"{}".format(next_setting.strftime(self.__DT_FORMAT)),
)
except:
UpdateDevice(
unit.SUN_RISE + i,
0,
"{}".format("No time available"),
)
if i == 0:
value = (next_setting - next_rising).total_seconds()
hh = divmod(value, 3600)
mm = divmod(hh[1], 60)
min = int(divmod(value, 60)[0])
UpdateDevice(
unit.DAY_LENGTH_M,
min,
"{}".format(min),
)
UpdateDevice(
unit.DAY_LENGTH_T,
0,
"{:02}:{:02}".format(int(hh[0]), int(mm[0])),
)
i += 1
#
# Reset horizon for further calculations
self.__observer.horizon = "0"
#
################################################################################
# Moon data
################################################################################
#
self.__observer.date = utc_now
self.__moon.compute(self.__observer)
#
# -------------------------------------------------------------------------------
# Moon rise
# -------------------------------------------------------------------------------
value = (
ephem.localtime(self.__observer.next_rising(self.__moon)) + self.__SEC30
)
UpdateDevice(
unit.MOON_RISE, 0, "{}".format(value.strftime(self.__DT_FORMAT))
)
#
# -------------------------------------------------------------------------------
# Moon set
# -------------------------------------------------------------------------------
value = (
ephem.localtime(self.__observer.next_setting(self.__moon))
+ self.__SEC30
)
UpdateDevice(
unit.MOON_SET, 0, "{}".format(value.strftime(self.__DT_FORMAT))
)
#
# -------------------------------------------------------------------------------
# Moon altitude
# -------------------------------------------------------------------------------
self.__moon.compute(self.__observer)
#
value = round(deg(self.__moon.alt), 2)
UpdateDevice(unit.MOON_ALT, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Moon azimuth
# -------------------------------------------------------------------------------
value = round(deg(self.__moon.az), 2)
UpdateDevice(unit.MOON_AZ, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Moon distance
# -------------------------------------------------------------------------------
value = round(self.__moon.earth_distance * ephem.meters_per_au / 1000)
UpdateDevice(unit.MOON_DIST, int(value), str(value))
#
# -------------------------------------------------------------------------------
# Next new moon
# -------------------------------------------------------------------------------
next_new = ephem.localtime(ephem.next_new_moon(utc_now))
value = next_new + self.__SEC30
UpdateDevice(
unit.MOON_NEXT_NEW, 0, "{}".format(value.strftime(self.__DT_FORMAT))
)
#
# -------------------------------------------------------------------------------
# Next first quarter
# -------------------------------------------------------------------------------
next_first_quarter = ephem.localtime(ephem.next_first_quarter_moon(utc_now))
value = next_first_quarter + self.__SEC30
UpdateDevice(
unit.MOON_NEXT_FIRST_QUARTER,
0,
"{}".format(value.strftime(self.__DT_FORMAT)),
)
#
# -------------------------------------------------------------------------------
# Next full moon
# -------------------------------------------------------------------------------
next_full = ephem.localtime(ephem.next_full_moon(utc_now))
value = next_full + self.__SEC30
UpdateDevice(
unit.MOON_NEXT_FULL,
0,
"{}".format(value.strftime(self.__DT_FORMAT)),
)
#
# -------------------------------------------------------------------------------
# Next last quarter
# -------------------------------------------------------------------------------
next_last_quarter = ephem.localtime(ephem.next_last_quarter_moon(utc_now))
value = next_last_quarter + self.__SEC30
UpdateDevice(
unit.MOON_NEXT_LAST_QUARTER,
0,
"{}".format(value.strftime(self.__DT_FORMAT)),
)
#
# -------------------------------------------------------------------------------
# Moon phase
# -------------------------------------------------------------------------------
next_full = next_full.date()
next_new = next_new.date()
next_last_quarter = next_last_quarter.date()
next_first_quarter = next_first_quarter.date()
previous_full = ephem.localtime(ephem.previous_full_moon(utc_now)).date()
previous_new = ephem.localtime(ephem.previous_new_moon(utc_now)).date()
previous_last_quarter = ephem.localtime(
ephem.previous_last_quarter_moon(utc_now)
).date()
previous_first_quarter = ephem.localtime(
ephem.previous_first_quarter_moon(utc_now)
).date()
#
# Domoticz.Debug("target_date: {}".format(target_date))
# Domoticz.Debug("next_full: {}".format(next_full))
# Domoticz.Debug("next_new: {}".format(next_new))
# Domoticz.Debug("next_last_quarter: {}".format(next_last_quarter))
# Domoticz.Debug("next_first_quarter: {}".format(next_first_quarter))
# Domoticz.Debug("previous_full: {}".format(previous_full))
# Domoticz.Debug("previous_new: {}".format(previous_new))
# Domoticz.Debug("previous_last_quarter: {}".format(previous_last_quarter))
# Domoticz.Debug("previous_first_quarter: {}".format(previous_first_quarter))
if target_date in (next_new, previous_new):
phase = 0
elif target_date in (next_first_quarter, previous_first_quarter):
phase = 2
elif target_date in (next_full, previous_full):
phase = 4
elif target_date in (next_last_quarter, previous_last_quarter):
phase = 6
elif (
previous_new
< next_first_quarter
< next_full
< next_last_quarter
< next_new
):
phase = 1
elif (
previous_first_quarter
< next_full
< next_last_quarter
< next_new
< next_first_quarter
):
phase = 3
elif (
previous_full
< next_last_quarter
< next_new
< next_first_quarter
< next_full
):
phase = 5
elif (
previous_last_quarter
< next_new
< next_first_quarter
< next_full
< next_last_quarter
):
phase = 7
else:
phase = 4
UpdateDevice(unit.MOON_PHASE, 0, self.__MOON_PHASE_DESCRIPTIONS[phase])
UpdateDeviceImage(
unit.MOON_PHASE, images.PREFIX_IMAGE + images.PREFIX_PHASE + str(phase)
)
#
self.__moon.compute(self.__observer)
#
# -------------------------------------------------------------------------------
# Moon illumination
# -------------------------------------------------------------------------------
value = round(deg(self.__moon.moon_phase), 2)
UpdateDevice(unit.MOON_ILLUMINATION, int(value), str(value))
UpdateDeviceImage(
unit.MOON_ILLUMINATION,
images.PREFIX_IMAGE + images.PREFIX_PHASE + str(phase),
)
#
else:
Domoticz.Debug(
"onHeartbeat called, run again in {} heartbeats.".format(
self.__runAgain
)
)
def do_thread_loop(self):
while(self.running):
if ( self.mqtt_connected ):
nowtime=datetime.datetime.now()
if(nowtime.year != self.year):
self.year = nowtime.year
self.mqttc.publish("/raw/clock/year", self.year, retain=True)
if(nowtime.month != self.month):
self.month = nowtime.month
self.mqttc.publish("/raw/clock/month", self.month, retain=True)
if(nowtime.day != self.day):
self.day = nowtime.day
self.mqttc.publish("/raw/clock/day", self.day, retain=True)
self.weekday=nowtime.weekday()
self.mqttc.publish("/raw/clock/weekday", self.weekday, retain=True)
self.utc_sunrise=self.observer.next_rising(self.sun)
# self.mqttc.publish("/raw/clock/utc_sunrise", str(self.utc_sunrise), retain=True)
self.sunrise=ephem.localtime(self.observer.next_rising(self.sun))
self.mqttc.publish("/raw/clock/sunrise", str(self.sunrise), retain=True)
self.utc_sunset=self.observer.next_setting(self.sun)
# self.mqttc.publish("/raw/clock/utc_sunset", str(self.utc_sunset), retain=True)
self.sunset=ephem.localtime(self.observer.next_setting(self.sun))
self.mqttc.publish("/raw/clock/sunset", str(self.sunset), retain=True)
self.utc_moonrise=self.observer.next_rising(self.moon)
# self.mqttc.publish("/raw/clock/utc_moonrise", str(self.utc_moonrise), retain=True)
self.moonrise=ephem.localtime(self.observer.next_rising(self.moon))
self.mqttc.publish("/raw/clock/moonrise", str(self.moonrise), retain=True)
self.utc_moonset=self.observer.next_setting(self.moon)
# self.mqttc.publish("/raw/clock/utc_moonset", str(self.utc_moonset), retain=True)
self.moonset=ephem.localtime(self.observer.next_setting(self.moon))
self.mqttc.publish("/raw/clock/moonset", str(self.moonset), retain=True)
self.nextnewmoon=ephem.next_new_moon(nowtime)
self.mqttc.publish("/raw/clock/nextnewmoon", str(self.nextnewmoon), retain=True)
self.nextfirstquartermoon=ephem.next_first_quarter_moon(nowtime)
self.mqttc.publish("/raw/clock/nextfirstquartermoon", str(self.nextfirstquartermoon), retain=True)
self.nextlastquartermoon=ephem.next_last_quarter_moon(nowtime)
self.mqttc.publish("/raw/clock/nextlastquartermoon", str(self.nextlastquartermoon), retain=True)
self.nextfullmoon=ephem.next_full_moon(nowtime)
self.mqttc.publish("/raw/clock/nextfullmoon", str(self.nextfullmoon), retain=True)
if(nowtime.hour != self.mil_hour):
self.mil_hour = nowtime.hour
self.hour = self.mil_hour % 12
if (self.hour == 0):
self.hour = 12
self.mqttc.publish("/raw/clock/hour", self.hour, retain=True)
self.mqttc.publish("/raw/clock/militaryhour", self.mil_hour, retain=True)
if(self.mil_hour > 11):
self.ampm = "PM"
else:
self.ampm = "AM"
if((self.mil_hour == 12) or (self.mil_hour == 0)):
self.mqttc.publish("/raw/clock/ampm", self.ampm, retain=True)
if(nowtime.minute != self.minute):
self.minute = nowtime.minute
self.mqttc.publish("/raw/clock/minute", self.minute, retain=True)
if(nowtime < self.sunrise): # is this right???
temp = "set"
elif(nowtime > self.sunset):
temp="set"
else:
temp="rise"
if(temp != self.sunstate):
self.sunstate=temp
self.mqttc.publish("/raw/clock/sunstate", self.sunstate, retain=True)
if ( self.interval ):
print "Waiting ", self.interval, " seconds for next update."
time.sleep(self.interval)
def get_data(object_list: List[Tuple[ephem.Body, str]],
location: Optional[ephem.Observer] = None) -> list:
"""Create data dictionary for object list."""
body_data = {}
if location:
body_data['query_date'] = location.date.datetime()
for o, body_type in object_list:
if location:
o.compute(location)
else:
o.compute()
data = {
# Split name if multiple designations are given. The separator is a pipe (|).
'name': o.name.split('|') if o.name.find('|') >= 0 else o.name,
'ra': format_ra(o.ra),
'dec': format_angle(o.dec),
'size': o.size,
'mag': o.mag,
'elong': o.elong,
}
if location: # altitude and azimuth only available with a valid location
data['alt'] = format_angle(o.alt)
data['az'] = format_angle(o.az)
if body_type == 'star': # spectral type is (usually) available with a star body type
data['spectral_type'] = o._spect
if body_type == 'solar_system': # special properties available for solar system objects
data['earth_dist'] = {
'au': o.earth_distance,
'km': o.earth_distance * 149597870.700,
'mi': o.earth_distance * 149597870700 / 1604.344
}
data['constellation'] = ephem.constellation(o)
# date for calculations below
date = location.date if location else ephem.now()
if o.name != 'Sun': # we don't need "phase" or "sun_dist" for the sun itself
data['sun_dist'] = {
'au': o.sun_distance,
'km': o.sun_distance * 149597870.700,
'mi': o.sun_distance * 149597870700 / 1604.344
}
data['phase'] = o.phase
if o.name == 'Moon': # special properties available for the moon
data['illuminated_surface'] = o.moon_phase * 100
data['phase_name'] = get_phase_name(location)
data['next_new_moon'] = (ephem.next_new_moon(date)).datetime()
data['next_first_quarter'] = (ephem.next_first_quarter_moon(date)).datetime()
data['next_full_moon'] = (ephem.next_full_moon(date)).datetime()
data['next_last_quarter'] = (ephem.next_last_quarter_moon(date)).datetime()
if o.name == 'Sun': # special properties available for the sun
data['next_solstice'] = (ephem.next_solstice(date)).datetime()
data['next_equinox'] = (ephem.next_equinox(date)).datetime()
elif body_type == 'satellite': # special properties available for satellites
data['elev'] = {'m' :o.elevation, 'mi': o.elevation / 1604.344}
data['eclipsed'] = o.eclipsed
if location:
data['range'] = {'m': o.range, 'mi': o.range / 1604.344}
data['range_velocity'] = o.range_velocity
rise_time, rise_az, max_alt_time, max_alt, set_time, set_az = location.next_pass(o)
data['next_pass'] = {
'rise_time': rise_time.datetime(),
'rise_az': format_angle(rise_az),
'max_altitude_time': max_alt_time.datetime(),
'max_altitude': format_angle(max_alt),
'set_time': set_time.datetime(),
'set_az': format_angle(set_az),
}
elif body_type == 'planetary_moon': # special properties available for planetary moons
data['visible'] = o.earth_visible
data['pos'] = o.x, o.y, o.z
# computed last, since these calculations change time, body position
if body_type not in ['satellite', 'planetary_moon'] and location:
# compute antitransit time of object
antitransit = location.previous_antitransit(o)
data['rise_time'] = (location.next_rising(o, start = antitransit)).datetime()
data['rise_az'] = format_angle(o.az)
data['transit_time'] = (location.next_transit(o, start = antitransit)).datetime()
data['transit_alt'] = format_angle(o.alt)
data['set_time'] = (location.next_setting(o, start = antitransit)).datetime()
data['set_az'] = format_angle(o.az)
if o.name == 'Sun':
# computed last, since these calculations change the horizon
location.horizon = '-18'
astro_dawn = location.next_rising(o, start = antitransit)
astro_dusk = location.next_setting(o, start = antitransit)
location.horizon = '-12'
nautical_dawn = location.next_rising(o, start = antitransit)
nautical_dusk = location.next_setting(o, start = antitransit)
location.horizon = '-6'
civil_dawn = location.next_rising(o, start = antitransit)
civil_dusk = location.next_setting(o, start = antitransit)
# The US Naval Observatory uses -34' as a constant for sunrise/sunset,
# rather than using atmospheric refraction.
# Setting pressure to 0 has the effect of ignoring effects of refraction.
# Save pressure for reset after calculations.
pressure, location.pressure = location.pressure, 0
location.horizon = '-0:34'
usno_dawn = location.next_rising(o, start = antitransit)
usno_dusk = location.next_setting(o, start = antitransit)
data['astronomical_dawn'] = astro_dawn.datetime()
data['nautical_dawn'] = nautical_dawn.datetime()
data['civil_dawn'] = civil_dawn.datetime()
data['USNO_sunrise'] = usno_dawn.datetime()
data['USNO_sunset'] = usno_dusk.datetime()
data['civil_dusk'] = civil_dusk.datetime()
data['nautical_dusk'] = nautical_dusk.datetime()
data['astronomical_dusk'] = astro_dusk.datetime()
#reset pressure and horizon
location.pressure = pressure
location.horizon = 0
body_data[o.name] = data
return body_data
while True:
user_answer = (input("date: ").lower())
moon = {
"Предыдущий цикл": {
"Последняя четверть луны":
ephem.previous_last_quarter_moon(user_answer),
"Новолуние":
ephem.previous_new_moon(user_answer),
"Первая четверть луны":
ephem.previous_first_quarter_moon(user_answer),
"Полнолуние":
ephem.previous_full_moon(user_answer),
},
"Следующий цикл": {
"Последняя четверть луны":
ephem.next_last_quarter_moon(user_answer),
"Новолуние": ephem.next_new_moon(user_answer),
"Первая четверть луны": ephem.next_first_quarter_moon(user_answer),
"Полнолуние": ephem.next_full_moon(user_answer),
}
}
for key in moon:
print(key)
for row_key in moon[key]:
print(row_key, ":", moon[key][row_key])
if user_answer == "exit":
break
def update(self):
date = ephem.Date(datetime.now().date())
self.seasondata.update({
'Autumnal (Fall) Equinox':
ephem.next_autumn_equinox(date).datetime().date()
})
self.moondata.update({
'First Quarter':
ephem.next_first_quarter_moon(date).datetime().date()
})
self.moondata.update(
{'Full Moon': ephem.next_full_moon(date).datetime().date()})
self.moondata.update({
'Last Quarter':
ephem.next_last_quarter_moon(date).datetime().date()
})
self.moondata.update(
{'New Moon': ephem.next_new_moon(date).datetime().date()})
self.seasondata.update({
'Vernal (Spring) Equinox':
ephem.next_spring_equinox(date).datetime().date()
})
self.seasondata.update({
'Summer Solstice':
ephem.next_summer_solstice(date).datetime().date()
})
self.seasondata.update({
'Winter Solstice':
ephem.next_winter_solstice(date).datetime().date()
})
moon_keys = sorted(self.moondata.keys(),
key=lambda y: (self.moondata[y]))
moon_keys.reverse()
b = {}
state1 = True
while moon_keys:
a = moon_keys.pop()
b.update({a: self.moondata[a]})
if self.moondata[a] != datetime.now().date() and state1:
self.nextphase = [
a, self.moondata[a],
daysaway(self.moondata[a])
]
state1 = False
if self.moondata[a] == datetime.now().date():
self.currentphase = a
##### elif
self.moondata = b
season_keys = sorted(self.seasondata.keys(),
key=lambda y: (self.seasondata[y]))
season_keys.reverse()
b = {}
state2 = True
while season_keys:
a = season_keys.pop()
b.update({a: self.seasondata[a]})
if self.seasondata[a] != datetime.now().date() and state2:
self.nextseason = [
a, self.seasondata[a],
daysaway(self.seasondata[a])
]
state2 = False
self.seasondata = b
if self.nextphase[0] == 'Last Quarter' and datetime.now().date(
) < self.nextphase[1]:
self.currentphase = 'Waning Gibbus'
if self.nextphase[0] == 'Last Quarter' and datetime.now().date(
) == self.nextphase[1]:
self.currentphase = 'Last Quarter'
if self.nextphase[0] == 'New Moon' and datetime.now().date(
) < self.nextphase[1]:
self.currentphase = 'Waning Crescent'
if self.nextphase[0] == 'New Moon' and datetime.now().date(
) == self.nextphase[1]:
self.currentphase = 'New Moon'
if self.nextphase[0] == 'First Quarter' and datetime.now().date(
) < self.nextphase[1]:
self.currentphase = 'Waxing Crescent'
if self.nextphase[0] == 'First Quarter' and datetime.now().date(
) == self.nextphase[1]:
self.currentphase = 'First Quarter'
if self.nextphase[0] == 'Full Moon' and datetime.now().date(
) < self.nextphase[1]:
self.currentphase = 'Waxing Gibbus'
if self.nextphase[0] == 'Full Moon' and datetime.now().date(
) == self.nextphase[1]:
self.currentphase = 'Full Moon'
#!/usr/bin/python # Print next moon quarter (requires PyEphem) # 2017-10-29 import ephem n = ephem.now() p = [[ephem.next_full_moon(n),"🌕 Vollmond"], [ephem.next_last_quarter_moon(n),"🌗 Letztes Viertel"], [ephem.next_new_moon(n),"🌑 Neumond"], [ephem.next_first_quarter_moon(n),"🌓 Erstes Viertel"]] p.sort() a = p[0] h = 24*(a[0]-n) def nat(h): h2 = round(h) if h > 24: d = h2//24 if d > 1: dh = "%u Tagen" % d else: dh = "einem Tag" hh = h2 - 24*d if hh > 1: hhh = "%u Stunden" % hh else:
(planet.name, planet.az, planet.alt, planet.mag,
planet.earth_distance),
end="")
if planet.transit_time != None:
print(" Transit time: %.2d:%.2d:%.2d" %
(ephem.localtime(planet.transit_time).hour,
ephem.localtime(planet.transit_time).minute,
ephem.localtime(planet.transit_time).second))
else:
print("")
if planet.name == "Moon":
print(color + "Next new Moon: %s" % ephem.next_new_moon(x))
print(color +
"Next first quarter Moon: %s" % ephem.next_first_quarter_moon(x))
print(color + "Next full Moon: %s" % ephem.next_full_moon(x))
print(color +
"Next last quarter Moon: %s" % ephem.next_last_quarter_moon(x))
print(color + "Moon distance from earth: %.2f meters\n" %
(planet.earth_distance * ephem.meters_per_au))
if planet.name == "Sun":
if planet.alt > 0:
print("Sunset: %s" %
(ephem.localtime(observer.next_setting(planet))))
else:
print("Sunset: %s" %
(ephem.localtime(observer.previous_setting(planet))))
print("Sunrise: %s" %
(ephem.localtime(observer.previous_rising(planet))))
print("")
def GetMoonInfo(self):
try:
now = datetime.datetime.now()
moon = ephem.Moon()
moon.compute(self.myObserver)
moon_altitude = moon.alt
moon_azimuth = moon.az
moon_compass = AU.AzimuthToCompassDirection(moon_azimuth)
moon_constellation = ephem.constellation(moon)[1]
moon_visible = True if moon_altitude > 0 else False
rise_time_ut = self.myObserver.next_rising(moon)
rise_time_local = str(ephem.localtime(rise_time_ut))
set_time_ut = self.myObserver.next_setting(moon)
set_time_local = str(ephem.localtime(set_time_ut))
altitude_string = str(moon_altitude)
rise_details = ""
set_details = ""
if moon_altitude <= 0:
altitude_string += " (Not visible)"
time_until_rise = ephem.localtime(rise_time_ut) - datetime.datetime.now()
hours_until_rise = time_until_rise.seconds / 60 / 60
minutes_until_rise = time_until_rise.seconds / 60
if hours_until_rise > 0:
minutes_until_rise -= hours_until_rise * 60
rise_details += str(hours_until_rise)
if hours_until_rise > 1:
rise_details += " hours"
else:
rise_details += " hour"
rise_details += " " + str(minutes_until_rise) + " minutes from now"
else:
altitude_string = altitude_string + " (Visible)"
time_until_set = ephem.localtime(set_time_ut) - datetime.datetime.now()
hours_until_set = time_until_set.seconds / 60 / 60
minutes_until_set = time_until_set.seconds / 60
if hours_until_set > 0:
minutes_until_set -= hours_until_set * 60
set_details += str(hours_until_set)
if hours_until_set > 1:
set_details += " hours"
else:
set_details += " hour"
set_details += " " + str(minutes_until_set) + " minutes from now"
next_rise_local = str(ephem.localtime(rise_time_ut))
if rise_details <> "":
next_rise_local += " (" + rise_details + ")"
next_set_local = str(ephem.localtime(set_time_ut))
if set_details <> "":
next_set_local += " (" + set_details + ")"
dictionaryData = {}
dictionaryData["Name"] = "Moon"
dictionaryData["Altitude"] = str(moon_altitude)
dictionaryData["IsVisible"] = moon_visible
dictionaryData["Azimuth"] = str(moon_azimuth)
dictionaryData["Compass"] = str(moon_compass)
dictionaryData["InConstellation"] = moon_constellation
dictionaryData["NextRiseUT"] = str(rise_time_ut)
dictionaryData["NextRiseLocal"] = str(rise_time_local)
dictionaryData["NextRiseUntil"] = str(rise_details)
dictionaryData["NextSetUT"] = str(set_time_ut)
dictionaryData["NextSetLocal"] = str(set_time_local)
dictionaryData["NextSetUntil"] = str(set_details)
dictionaryData["Phase"] = str(moon.phase)
dictionaryData["NextFirstQuarter"] = str(ephem.next_first_quarter_moon(now))
dictionaryData["NextFull"] = str(ephem.next_full_moon(now))
dictionaryData["NextLastQuarter"] = str(ephem.next_last_quarter_moon(now))
dictionaryData["NextNew"] = str(ephem.next_new_moon(now))
if self.prettyprint == True:
json_string = json.dumps(dictionaryData, sort_keys=True, indent=4, separators=(",", ": "))
else:
json_string = json.dumps(dictionaryData, sort_keys=True, separators=(",", ": "))
return json_string
except Exception as ex:
print str(ex)
return ""
def do_thread_loop(self):
while (self.running):
if (self.mqtt_connected):
nowtime = datetime.datetime.now()
if (nowtime.year != self.year):
self.year = nowtime.year
self.mqttc.publish("/raw/clock/year",
self.year,
retain=True)
if (nowtime.month != self.month):
self.month = nowtime.month
self.mqttc.publish("/raw/clock/month",
self.month,
retain=True)
if (nowtime.day != self.day):
self.day = nowtime.day
self.mqttc.publish("/raw/clock/day", self.day, retain=True)
self.weekday = nowtime.weekday()
self.mqttc.publish("/raw/clock/weekday",
self.weekday,
retain=True)
self.utc_sunrise = self.observer.next_rising(self.sun)
# self.mqttc.publish("/raw/clock/utc_sunrise", str(self.utc_sunrise), retain=True)
self.sunrise = ephem.localtime(
self.observer.next_rising(self.sun))
self.mqttc.publish("/raw/clock/sunrise",
str(self.sunrise),
retain=True)
self.utc_sunset = self.observer.next_setting(self.sun)
# self.mqttc.publish("/raw/clock/utc_sunset", str(self.utc_sunset), retain=True)
self.sunset = ephem.localtime(
self.observer.next_setting(self.sun))
self.mqttc.publish("/raw/clock/sunset",
str(self.sunset),
retain=True)
self.utc_moonrise = self.observer.next_rising(self.moon)
# self.mqttc.publish("/raw/clock/utc_moonrise", str(self.utc_moonrise), retain=True)
self.moonrise = ephem.localtime(
self.observer.next_rising(self.moon))
self.mqttc.publish("/raw/clock/moonrise",
str(self.moonrise),
retain=True)
self.utc_moonset = self.observer.next_setting(self.moon)
# self.mqttc.publish("/raw/clock/utc_moonset", str(self.utc_moonset), retain=True)
self.moonset = ephem.localtime(
self.observer.next_setting(self.moon))
self.mqttc.publish("/raw/clock/moonset",
str(self.moonset),
retain=True)
self.nextnewmoon = ephem.next_new_moon(nowtime)
self.mqttc.publish("/raw/clock/nextnewmoon",
str(self.nextnewmoon),
retain=True)
self.nextfirstquartermoon = ephem.next_first_quarter_moon(
nowtime)
self.mqttc.publish("/raw/clock/nextfirstquartermoon",
str(self.nextfirstquartermoon),
retain=True)
self.nextlastquartermoon = ephem.next_last_quarter_moon(
nowtime)
self.mqttc.publish("/raw/clock/nextlastquartermoon",
str(self.nextlastquartermoon),
retain=True)
self.nextfullmoon = ephem.next_full_moon(nowtime)
self.mqttc.publish("/raw/clock/nextfullmoon",
str(self.nextfullmoon),
retain=True)
if (nowtime.hour != self.mil_hour):
self.mil_hour = nowtime.hour
self.hour = self.mil_hour % 12
if (self.hour == 0):
self.hour = 12
self.mqttc.publish("/raw/clock/hour",
self.hour,
retain=True)
self.mqttc.publish("/raw/clock/militaryhour",
self.mil_hour,
retain=True)
if (self.mil_hour > 11):
self.ampm = "PM"
else:
self.ampm = "AM"
if ((self.mil_hour == 12) or (self.mil_hour == 0)):
self.mqttc.publish("/raw/clock/ampm",
self.ampm,
retain=True)
if (nowtime.minute != self.minute):
self.minute = nowtime.minute
self.mqttc.publish("/raw/clock/minute",
self.minute,
retain=True)
if (nowtime < self.sunrise): # is this right???
temp = "set"
elif (nowtime > self.sunset):
temp = "set"
else:
temp = "rise"
if (temp != self.sunstate):
self.sunstate = temp
self.mqttc.publish("/raw/clock/sunstate",
self.sunstate,
retain=True)
if (self.interval):
print "Waiting ", self.interval, " seconds for next update."
time.sleep(self.interval)
# 観測地設定
osaka = ephem.Observer()
osaka.lat = '34.6914'
osaka.lon = '135.4917'
osaka.date = datetime.datetime.utcnow()
# 月
moon = ephem.Moon()
# 次回 月の出・月の入り等を表示
print("次の月の出 : ", ephem.localtime(osaka.next_rising(moon)))
print("次の月の入り : ", ephem.localtime(osaka.next_setting(moon)))
print("次の新月 : ", ephem.localtime(ephem.next_new_moon(osaka.date)))
print("次の上弦 : ", ephem.localtime(ephem.next_first_quarter_moon(osaka.date)))
print("次の満月 : ", ephem.localtime(ephem.next_full_moon(osaka.date)))
print("次の下弦 : ", ephem.localtime(ephem.next_last_quarter_moon(osaka.date)))
print("現在の月齢 : ", osaka.date - ephem.previous_new_moon(osaka.date))
# 月と太陽の離角を計算
moon.compute(osaka)
moon_elong = np.rad2deg(moon.elong)
# 描画領域を準備
fig = plt.figure(figsize=(5, 5))
ax = fig.gca(projection='3d')
# x, y, z軸の範囲設定
ax.set_xlim([-1., 1.])
ax.set_ylim([-1., 1.])
sunset = observer.next_setting (ephem.Sun()) #Sunset
data['sunrise'] = str(ephem.localtime(sunrise))
data['noon'] = str(ephem.localtime(noon))
data['sunset'] = str(ephem.localtime(sunset))
# observer.horizon = '-6' # civil twilight
# civilian_twilight_start = observer.previous_rising(ephem.Sun())
# civilian_twilight_end = observer.next_setting(ephem.Sun())
# observer.horizon = '-12' # nautical twilight
# nautical_twilight_start = observer.previous_rising(ephem.Sun())
# nautical_twilight_end = observer.next_setting(ephem.Sun())
# observer.horizon = '-18' # astronomical twilight
# astronomical_twilight_start = observer.previous_rising(ephem.Sun())
# astronomical_twilight_end = observer.next_setting(ephem.Sun())
data['moon'] = {}
data['moon']['radius'] = ephem.moon_radius
data['moon']['previous_new_moon'] = str(ephem.localtime(ephem.previous_new_moon(time)))
data['moon']['next_new_moon'] = str(ephem.localtime(ephem.next_new_moon(time)))
data['moon']['previous_first_quarter_moon'] = str(ephem.localtime(ephem.previous_first_quarter_moon(time)))
data['moon']['next_first_quarter_moon'] = str(ephem.localtime(ephem.next_first_quarter_moon(time)))
data['moon']['previous_full_moon'] = str(ephem.localtime(ephem.previous_full_moon(time)))
data['moon']['next_full_moon'] = str(ephem.localtime(ephem.next_full_moon(time)))
data['moon']['previous_last_quarter_moon'] = str(ephem.localtime(ephem.previous_last_quarter_moon(time)))
data['moon']['next_last_quarter_moon'] = str(ephem.localtime(ephem.next_last_quarter_moon(time)))
print json.dumps(data)