def calculate_julian(year, month, day, hours=None, minutes=None, seconds=None):
"""
Calculate the julian date value.
:param year: the year
:param month: the month
:param day: the day
:param hours: the hours
:param minutes: the minutes
:param seconds: the seconds
:return: the julian date
"""
yr = mathutils.to_int(year)
mth = mathutils.to_int(month)
day = mathutils.to_int(day)
hrs = mathutils.to_int(hours)
mns = mathutils.to_int(minutes)
scs = mathutils.to_float(seconds)
if mth <= 2:
yr -= 1
mth += 12
if yr >= 1582:
A = yr / 100
B = 2 - A + (A / 4)
else:
B = 0
if yr < 0:
C = int((365.25 * yr) - 0.75)
else:
C = int(365.25 * yr)
D = int(30.6001 * (mth + 1))
return 1720994.5 + B + C + D + day + (((
(mathutils.fix(scs, TIME_SECONDS_PRECISION) / 60.0) + float(mns)) /
60.0) + float(hrs)) / 24.0
def validate_date(year,
month,
day,
hours=None,
minutes=None,
seconds=None,
mode=None,
require_time=True):
"""
Validate a date or date time.
:return: (year, month, day[, hours, minutes, seconds[, mode]]) or None
"""
yr = mathutils.to_int(year, None)
mth = mathutils.to_int(month, None)
dy = mathutils.to_int(day, None)
if yr is not None:
if (mth is not None) and (mth >= 1) and (mth <= 12):
if is_leap_year(yr) and (mth == 2):
if dy > 29:
return None
elif dy > LENGTH_OF_MONTH[mth]:
return None
elif dy < 1:
return None
if hours is not None:
tm = validate_time(hours, minutes, seconds, mode)
if tm is None:
return None
if len(tm) == 4:
return yr, mth, dy, tm[0], tm[1], tm[2], tm[3]
return yr, mth, dy, tm[0], tm[1], tm[2]
elif require_time:
return None
return yr, mth, dy
return None
def dd_from_dms(d, m, s):
d = mathutils.to_int(d, None)
m = mathutils.to_int(m, None)
s = mathutils.to_float(s, None)
if (d is not None) and (m is not None) and (s is not None):
if d < 0:
sgn = -1
else:
sgn = 1
dd = sgn * ((((s / 60.0) + float(m)) / 60.0) + float(abs(d)))
return dd
return None
def to_day_of_week_from_julian(jd):
"""
Converts a julian to day of the week.
:param jd: julian
:return: day of week
"""
jul = mathutils.to_float(jd, None)
if jul is not None:
a = (jul + 1.5) / 7.0
day = mathutils.to_int(round((a - mathutils.to_int(a)) * 7.0))
return day
return None
def add_years(self, dy):
"""
Add a year delta to the date.
:param dy: year delta
"""
if self.year is not None:
self.year += mathutils.to_int(dy, 0)
def get_date_of_easter(year):
"""
Calculate the date of Easter.
:param year: year for which to calculate the date of Easter
:return: date tuple for Easter (None if not a valid year)(year, month, day)
"""
y = mathutils.to_int(year)
if y is not None:
if y >= 1583:
a = int(y % 19)
b = int(y / 100)
c = int(y % 100)
d = int(b / 4)
e = int(b % 4)
f = int((b + 8) / 25)
g = int((b - f + 1) / 3)
h = int(((19 * a) + b - d - g + 15) % 30)
i = int(c / 4)
k = int(c % 4)
l = int((32 + (2 * e) + (2 * i) - h - k) % 7)
m = int((a + (11 * h) + (22 * l)) / 451)
t = int((h + l - (7 * m) + 114))
n = int(t / 31)
p = int((t % 31) + 1)
return y, n, p
return None
def get_days_in_month(month, year=None):
"""
Determine the number of days in the month.
:param month: month to analyze (1..12)
:param year: year to use with month (None for basic analysis)
:return: number of days in the month
"""
d = 0
m = mathutils.to_int(month, None)
if m is not None:
d = LENGTH_OF_MONTH[m]
y = mathutils.to_int(year, None)
if (y is not None) and (m == 2):
if is_leap_year(y):
d += 1
return d
def set_with_epochTD(self, epochTD):
self.set_year(mathutils.to_int(epochTD))
self.set_month(1)
self.set_day(1)
self.set_hours(0)
self.set_minutes(0)
self.set_seconds(0.0)
self.set_mode(TIME_MODE_TDT)
def dh_from_hms(hours, minutes, seconds):
"""
Converts a time to decimal hours.
:param hours: hours
:param minutes: minutes
:param seconds: seconds
:return: dh
"""
h = mathutils.to_int(hours, None)
m = mathutils.to_int(minutes, None)
s = mathutils.to_float(seconds, None)
if (h is not None) and (m is not None) and (s is not None):
if h < 0:
sgn = -1
else:
sgn = 1
return sgn * ((((s / 60.0) + m) / 60.0) + abs(h))
return None
def set_zone_correction(self, zc):
"""
Set the time zone correction to be used in date calculations.
:param zc: the time zone correction to set (- for west, + for east)(-24..24)
"""
zc = mathutils.to_int(zc, 0)
if zc is not None:
zc = mathutils.normalize_hours(zc, -24.0, 24.0)
self.zone_correction = zc
def validate_time(hours, minutes, seconds, mode=None):
"""
Validate the time.
:return: (hours, minutes, seconds[, mode]) or None
"""
hrs = mathutils.to_int(hours, None)
mns = mathutils.to_int(minutes, None)
scs = mathutils.to_float(seconds, None)
if (hrs is not None) and (mns is not None) and (scs is not None):
if (hrs >= 0) and (hrs < 24):
if (mns >= 0) and (mns < 60):
if (scs >= 0) and (scs < 60):
if mode is not None:
if mode in TIME_MODES:
return hrs, mns, scs, mode
else:
return hrs, mns, scs
return None
def set_year(self, year):
"""
Set the year.
:param year: the year to set
"""
y = mathutils.to_int(year, None)
if y is not None:
self.year = y
if self.day is not None:
if self.day > self.get_days_in_month():
self.day = self.get_days_in_month()
def set_hours(self, h=0):
"""
Set the hours.
:param h: the hours to set (0..23)
"""
h = mathutils.to_int(h, 0)
if h is not None:
if h < 0:
h = 0
if h > 23:
h = 23
self.hours = h
def is_leap_year(year):
"""
Determine if the year is a leap year.
:param year: year
:return: True or False
"""
y = mathutils.to_int(year, None)
if y is not None:
if (y % 100) == 0:
return (y % 400) == 0
return (y % 4) == 0
return None
def set_minutes(self, minutes=0):
"""
Set the minutes.
:param minutes: the minutes to set (0..59)
"""
m = mathutils.to_int(minutes, 0)
if m is not None:
if m < 0:
m = 0
if m > 59:
m = 59
self.minutes = m
def set_day(self, day=1):
"""
Set the day.
:param day: the day to set (1..31)
"""
d = 1
if day is not None:
d = mathutils.to_int(day, 1)
if d < 1:
d = 1
if d > self.get_days_in_month():
d = self.get_days_in_month()
self.day = d
def add_days(self, dd):
"""
Add a day delta to the date.
:param dd: day delta
"""
if self.day is not None:
self.day += mathutils.to_int(dd, 0)
dm = 0
while self.day < 1:
self.day += get_days_in_month(self.month, self.year)
dm -= 1
while self.day > get_days_in_month(self.month, self.year):
self.day -= get_days_in_month(self.month, self.year)
dm += 1
self.add_months(dm)
def add_hours(self, dh):
"""
Add an hour delta to the date.
:param dh: hour delta
"""
if self.hours is not None:
self.hours += mathutils.to_int(dh, 0)
dd = 0
while self.hours < 1:
self.hours += 24
dd -= 1
while self.hours >= 24:
self.hours -= 24
dd += 1
self.add_days(dd)
def add_minutes(self, dm):
"""
Add a minute delta to the date.
:param dm: minute delta
"""
if self.minutes is not None:
self.minutes += mathutils.to_int(dm, 0)
dh = 0
while self.minutes < 1:
self.minutes += 24
dh -= 1
while self.minutes >= 24:
self.minutes -= 24
dh += 1
self.add_hours(dh)
def add_months(self, dm):
"""
Add a month delta to the date.
:param dm: month delta
"""
if self.month is not None:
self.month += mathutils.to_int(dm, 0)
dy = 0
while self.month < 1:
self.month += 12
dy -= 1
while self.month > 12:
self.month -= 12
dy += 1
self.add_years(dy)
def set_month(self, month=1):
"""
Set the month.
:param month: the month to set (1..12)
"""
m = mathutils.to_int(month, 1)
if m is not None:
if m < 1:
m = 1
if m > 12:
m = 12
self.month = m
if self.day is not None:
if self.day > self.get_days_in_month():
self.day = self.get_days_in_month()
def __convert_date_time(res):
"""
Convert the response array (usually from keyboard input) into a date time tuple.
:param res: the response to convert
:return: an unvalidated date time tuple
"""
dat = []
i = 0
while (i < len(res)) and (i < 7):
if i < 5:
dat.append(mathutils.to_int(res[i]))
elif i == 5:
dat.append(mathutils.fix(res[i], astrodate.TIME_SECONDS_PRECISION))
else:
dat.append(res[i])
i += 1
return dat
def set_with_julian(self, jul, mode=TIME_MODE_UTC):
"""
Set date from a julian day.
:param jul: julian
:param mode: the time mode (default: 'utc')
"""
jul = mathutils.to_float(jul, None)
if jul is not None:
jd = 0.5 + jul
I = mathutils.to_int(jd)
F = jd - I
if I > 2229160:
A = mathutils.to_int((I - 1867216.25) / 36524.25)
B = I + 1 + A - mathutils.to_int(A / 4.0)
else:
B = I
C = B + 1524
D = mathutils.to_int((C - 122.1) / 365.25)
E = mathutils.to_int(365.25 * D)
G = mathutils.to_int((C - E) / 30.6001)
d = C - E + F - mathutils.to_int(30.6001 * G)
if G < 13.5:
mth = G - 1
else:
mth = G - 13
if mth > 2.5:
yr = D - 4716
else:
yr = D - 4715
day = mathutils.to_int(d)
h = (d - day) * 24
hrs, mns, scs = hms_from_dh(h)
self.set_year(yr)
self.set_month(mth)
self.set_day(day)
self.set_hours(hrs)
self.set_minutes(mns)
self.set_seconds(scs)
self.set_mode(mode)
def set_min2(self, min2):
m = 0
if min2 is not None:
m = mathutils.to_int(min2, 0)
self.min2 = m
def set_min1(self, min1):
m = 0
if min1 is not None:
m = mathutils.to_int(min1, 0)
self.min1 = m
def set_deg2(self, deg2):
d = 0
if deg2 is not None:
d = mathutils.to_int(deg2, 0)
self.deg2 = d
def set_deg1(self, deg1):
d = 0
if deg1 is not None:
d = mathutils.to_int(deg1, 0)
self.deg1 = d
def validate_hours(h, m, s):
if (h is not None) and (h == mathutils.to_int(h)) and (h > -24.0) and (h <= 24.0):
if (m is not None) and (m == mathutils.to_int(m)) and (m >= 0.0) and (m <= 59.0):
if (s is not None) and (s == mathutils.to_float(s)) and (s >= 0.0) and (s < 60.0):
return True
return False
def validate_degrees(d, m, s):
if (d is not None) and (d == mathutils.to_int(d)) and (d >= -360.0) and (d <= 360.0):
if (m is not None) and (m == mathutils.to_int(m)) and (m >= 0.0) and (m <= 59.0):
if (s is not None) and (s == mathutils.to_float(s)) and (s >= 0.0) and (s < 60.0):
return True
return False
