def years_diff(y1, m1, d1, h1, y2, m2, d2, h2):
swe.set_ephe_path(ephe_path)
jd1 = swe.julday(y1, m1, d1, h1)
jd2 = swe.julday(y2, m2, d2, h2)
jd = jd1 + swe._years_diff(jd1, jd2)
#jd = jd1 + ( (jd2-jd1) / 365.248193724 )
y, mth, d, h, m, s = swe._revjul(jd, swe.GREG_CAL)
return datetime.datetime(y, mth, d, h, m, s)
def years_diff(y1, m1, d1, h1 , y2, m2, d2, h2): swe.set_ephe_path(ephe_path) jd1 = swe.julday(y1,m1,d1,h1) jd2 = swe.julday(y2,m2,d2,h2) jd = jd1 + swe._years_diff(jd1, jd2) #jd = jd1 + ( (jd2-jd1) / 365.248193724 ) y, mth, d, h, m, s = swe._revjul(jd, swe.GREG_CAL) return datetime.datetime(y,mth,d,h,m,s)
def get_star_longitude(star, jd):
""" Calculate star longitude based on sefstars.txt.
:param star: Example: Spica.
:param jd:
:return:
"""
from jyotisha.panchaanga.temporal import data
import os
swe.set_ephe_path(os.path.dirname(data.__file__))
(long, lat, _, _, _, _) = swe.fixstar_ut(star, jd)[0]
return long
def _setup_swisseph(self):
"""Prepare swisseph for calculations."""
f = self._filter
# ephemeris type
if f._ephe_type == 'swiss':
swe.set_ephe_path(f._ephe_path)
elif f._ephe_type == 'jpl':
swe.set_jpl_file(f._ephe_path)
# sidereal mode
if f._sid_mode > -1:
swe.set_sid_mode(f._sid_mode, f._sid_t0, f._sid_ayan_t0)
# situation
if f._xcentric == 'topo':
swe.set_topo(float(self._longitude), float(self._latitude),
self._altitude)
def check_input(input_json):
try:
if 'SWISSEPH_PATH' in os.environ:
ephe_path = os.environ['SWISSEPH_PATH']
else:
raise ValueError("SWISSEPH_PATH must be set....")
if os.path.isdir(ephe_path):
swe.set_ephe_path(ephe_path)
else:
raise ValueError("Error, swiss ephemeris was not found")
check_json(input_json)
return input_json
except Exception as e:
raise ValueError(str(e))
def setPath(path):
""" Sets the path for the swe files. """
swisseph.set_ephe_path(path)
def __init__(self,
year,
month,
day,
hour,
geolon,
geolat,
altitude,
planets,
zodiac,
openastrocfg,
houses_override=None):
#ephemeris path (default "/usr/share/swisseph:/usr/local/share/swisseph")
swe.set_ephe_path(ephe_path)
#basic location
self.jul_day_UT = swe.julday(year, month, day, hour)
self.geo_loc = swe.set_topo(geolon, geolat, altitude)
#output variables
self.planets_sign = list(range(len(planets)))
self.planets_degree = list(range(len(planets)))
self.planets_degree_ut = list(range(len(planets)))
self.planets_info_string = list(range(len(planets)))
self.planets_retrograde = list(range(len(planets)))
#iflag
"""
#define SEFLG_JPLEPH 1L // use JPL ephemeris
#define SEFLG_SWIEPH 2L // use SWISSEPH ephemeris, default
#define SEFLG_MOSEPH 4L // use Moshier ephemeris
#define SEFLG_HELCTR 8L // return heliocentric position
#define SEFLG_TRUEPOS 16L // return true positions, not apparent
#define SEFLG_J2000 32L // no precession, i.e. give J2000 equinox
#define SEFLG_NONUT 64L // no nutation, i.e. mean equinox of date
#define SEFLG_SPEED3 128L // speed from 3 positions (do not use it, SEFLG_SPEED is // faster and preciser.)
#define SEFLG_SPEED 256L // high precision speed (analyt. comp.)
#define SEFLG_NOGDEFL 512L // turn off gravitational deflection
#define SEFLG_NOABERR 1024L // turn off 'annual' aberration of light
#define SEFLG_EQUATORIAL 2048L // equatorial positions are wanted
#define SEFLG_XYZ 4096L // cartesian, not polar, coordinates
#define SEFLG_RADIANS 8192L // coordinates in radians, not degrees
#define SEFLG_BARYCTR 16384L // barycentric positions
#define SEFLG_TOPOCTR (32*1024L) // topocentric positions
#define SEFLG_SIDEREAL (64*1024L) // sidereal positions
"""
#check for apparent geocentric (default), true geocentric, topocentric or heliocentric
iflag = swe.FLG_SWIEPH + swe.FLG_SPEED
if (openastrocfg['postype'] == "truegeo"):
iflag += swe.FLG_TRUEPOS
elif (openastrocfg['postype'] == "topo"):
iflag += swe.FLG_TOPOCTR
elif (openastrocfg['postype'] == "helio"):
iflag += swe.FLG_HELCTR
#sidereal
if (openastrocfg['zodiactype'] == "sidereal"):
iflag += swe.FLG_SIDEREAL
mode = "SIDM_" + openastrocfg['siderealmode']
swe.set_sid_mode(getattr(swe, mode))
#compute a planet (longitude,latitude,distance,long.speed,lat.speed,speed)
for i in range(23):
ret_flag = swe.calc_ut(self.jul_day_UT, i, iflag)
for x in range(len(zodiac)):
deg_low = float(x * 30)
deg_high = float((x + 1) * 30)
if ret_flag[0] >= deg_low:
if ret_flag[0] <= deg_high:
self.planets_sign[i] = x
self.planets_degree[i] = ret_flag[0] - deg_low
self.planets_degree_ut[i] = ret_flag[0]
#if latitude speed is negative, there is retrograde
if ret_flag[3] < 0:
self.planets_retrograde[i] = True
else:
self.planets_retrograde[i] = False
#available house systems:
"""
hsys= ‘P’ Placidus
‘K’ Koch
‘O’ Porphyrius
‘R’ Regiomontanus
‘C’ Campanus
‘A’ or ‘E’ Equal (cusp 1 is Ascendant)
‘V’ Vehlow equal (Asc. in middle of house 1)
‘X’ axial rotation system
‘H’ azimuthal or horizontal system
‘T’ Polich/Page (“topocentric” system)
‘B’ Alcabitus
‘G’ Gauquelin sectors
‘M’ Morinus
"""
#houses calculation (hsys=P for Placidus)
#check for polar circle latitude < -66 > 66
if houses_override:
self.jul_day_UT = swe.julday(houses_override[0],
houses_override[1],
houses_override[2],
houses_override[3])
if geolat > 66.0:
geolat = 66.0
print("polar circle override for houses, using 66 degrees")
elif geolat < -66.0:
geolat = -66.0
print("polar circle override for houses, using -66 degrees")
#sidereal houses
if (openastrocfg['zodiactype'] == "sidereal"):
sh = swe.houses_ex(self.jul_day_UT, geolat, geolon,
openastrocfg['houses_system'].encode("ascii"),
swe.FLG_SIDEREAL)
else:
sh = swe.houses(self.jul_day_UT, geolat, geolon,
openastrocfg['houses_system'].encode("ascii"))
self.houses_degree_ut = list(sh[0])
#arabic parts
sun, moon, asc = self.planets_degree_ut[0], self.planets_degree_ut[
1], self.houses_degree_ut[0]
dsc, venus = self.houses_degree_ut[6], self.planets_degree_ut[3]
#offset
offset = moon - sun
#if planet degrees is greater than 360 substract 360 or below 0 add 360
for i in range(len(self.houses_degree_ut)):
#add offset
#self.houses_degree_ut[i] += offset
if self.houses_degree_ut[i] > 360.0:
self.houses_degree_ut[i] = self.houses_degree_ut[i] - 360.0
elif self.houses_degree_ut[i] < 0.0:
self.houses_degree_ut[i] = self.houses_degree_ut[i] + 360.0
self.houses_degree = list(range(len(self.houses_degree_ut)))
self.houses_sign = list(range(len(self.houses_degree_ut)))
for i in range(12):
for x in range(len(zodiac)):
deg_low = float(x * 30)
deg_high = float((x + 1) * 30)
if self.houses_degree_ut[i] >= deg_low:
if self.houses_degree_ut[i] <= deg_high:
self.houses_sign[i] = x
self.houses_degree[
i] = self.houses_degree_ut[i] - deg_low
#mean apogee
bm = self.planets_degree_ut[12]
#mean north node
mn = self.planets_degree_ut[10]
#perigee lunaire moyen
pl = self.planets_degree_ut[22]
#perigee solaire moyen
#define SE_NODBIT_MEAN 1
#define SE_NODBIT_OSCU 2
#define SE_NODBIT_OSCU_BAR 4
#define SE_NODBIT_FOPOINT 256
#Return: 4 tuples of 6 float (asc, des, per, aph)
ps = swe.nod_aps_ut(self.jul_day_UT, 0, swe.NODBIT_MEAN, iflag)
pl = swe.nod_aps_ut(self.jul_day_UT, 1, swe.NODBIT_MEAN, iflag)
ps = ps[2][0]
pl = pl[2][0]
#print mn
#print sun
#print ps
#print moon
#print pl
c = 1.517 * math.sin(2 * math.radians(sun - mn))
c += -0.163 * math.sin(math.radians(sun - ps))
c += -0.128 * math.sin(2 * math.radians(moon - sun))
c += 0.120 * math.sin(2 * math.radians(moon - mn))
c += 0.107 * math.sin(2 * math.radians(pl - mn))
c += 0.063 * math.sin(math.radians(3 * sun - ps - 2 * mn))
c += 0.040 * math.sin(math.radians(moon + pl - 2 * sun))
c += -0.040 * math.sin(math.radians(moon + pl - 2 * mn))
c += 0.027 * math.sin(math.radians(moon - pl))
c += -0.027 * math.sin(math.radians(sun + ps - 2 * mn))
c += 0.015 * math.sin(2 * math.radians(sun - pl))
c += -0.013 * math.sin(math.radians(moon + 2 * mn - pl - 2 * sun))
c += -0.013 * math.sin(math.radians(moon - 2 * mn - pl + 2 * sun))
c += -0.007 * math.sin(math.radians(2 * moon + pl - 3 * sun))
c += 0.005 * math.sin(math.radians(3 * moon - pl - 2 * mn))
c += -0.005 * math.sin(math.radians(3 * moon - pl - 2 * sun))
#print c
sbm = sun - bm
if sbm < 0: sbm += 360
if sbm > 180.0: sbm -= 180
print("sun %s black moon %s sun-bm %s=%s" % (sun, bm, sun - bm, sbm))
q = 12.333
if sbm < 60.0:
print('sbm<60')
c = q * math.sin(1.5 * math.radians(sbm))
elif sbm > 120.0:
print('sbm>120')
c = q * math.cos(1.5 * math.radians(sbm))
else:
print('sbm 60-120')
c = -q * math.cos(3.0 * math.radians(sbm))
true_lilith = c
def true_lilith_calc(sun, lilith):
deg = sun - lilith
q = 12.333
if deg < 0.0: deg += 360.0
if deg > 180.0: deg -= 180.0
if deg < 60.0:
return q * math.sin(1.5 * math.radians(deg)
) - 1.892 * math.sin(3 * math.radians(deg))
elif deg > 120.0:
return q * math.cos(1.5 * math.radians(deg)
) + 1.892 * math.sin(3 * math.radians(deg))
elif deg < 100.0:
return -q * math.cos(
3.0 * math.radians(deg)) + 0.821 * math.cos(
4.5 * math.radians(deg))
else:
return -q * math.cos(3.0 * math.radians(deg))
def true_lilith_calc2(sun, lilith):
deg = sun - lilith
q = 12.333
if deg < 0.0: deg += 360.0
if deg > 180.0: deg -= 180.0
if deg < 60.0: return q * math.sin(1.5 * math.radians(deg))
elif deg > 120.0: return q * math.cos(1.5 * math.radians(deg))
else: return -q * math.cos(3.0 * math.radians(deg))
true_lilith = true_lilith_calc2(sun, bm)
#print c
"""
if sbm < 60.0:
print 'sbm 0-60'
c= q * math.sin(1.5*math.radians(sbm)) - 0.0917
elif sbm >= 60.0 and sbm < 120.0:
print 'sbm 60-120'
c= -q * math.cos(3*math.radians(sbm)) - 0.0917
elif sbm >= 120.0 and sbm < 240.0:
print 'sbm 120-240'
c= q * math.cos(1.5*math.radians(sbm)) - 0.0917
elif sbm >= 240.0 and sbm < 300.0:
print 'sbm 240-300'
c= q * math.cos(3*math.radians(sbm)) - 0.0917
else:
print 'sbm 300-360'
c= -q * math.sin(1.5*math.radians(sbm)) - 0.0917
"""
c += -0.117 * math.sin(math.radians(sun - ps))
#print c
#c+= x * -0.163 * math.sin(math.radians(sun-ps))
#c+= x * -0.128 * math.sin(2*math.radians(moon-sun))
#c+= x * 0.120 * math.sin(2*math.radians(moon-bm))
#c+= x * 0.107 * math.sin(2*math.radians(pl-bm))
#c+= x * 0.063 * math.sin(math.radians(3*sun-ps-2*bm))
#c+= x * 0.040 * math.sin(math.radians(moon+pl-2*sun))
#c+= x * -0.040 * math.sin(math.radians(moon+pl-2*bm))
#c+= x * 0.027 * math.sin(math.radians(moon-pl))
#c+= x * -0.027 * math.sin(math.radians(sun+ps-2*bm))
#c+= x * 0.015 * math.sin(2*math.radians(sun-pl))
#c+= x * -0.013 * math.sin(math.radians(moon+2*bm-pl-2*sun))
#c+= x * -0.013 * math.sin(math.radians(moon-2*bm-pl+2*sun))
#c+= x * -0.007 * math.sin(math.radians(2*moon+pl-3*sun))
#c+= x * 0.005 * math.sin(math.radians(3*moon-pl-2*bm))
#c+= x * -0.005 * math.sin(math.radians(3*moon-pl-2*sun))
#compute additional points and angles
#list index 23 is asc, 24 is Mc, 25 is Dsc, 26 is Ic
self.planets_degree_ut[23] = self.houses_degree_ut[0]
self.planets_degree_ut[24] = self.houses_degree_ut[9]
self.planets_degree_ut[25] = self.houses_degree_ut[6]
self.planets_degree_ut[26] = self.houses_degree_ut[3]
#list index 27 is day pars
self.planets_degree_ut[27] = asc + (moon - sun)
#list index 28 is night pars
self.planets_degree_ut[28] = asc + (sun - moon)
#list index 29 is South Node
self.planets_degree_ut[29] = self.planets_degree_ut[10] - 180.0
#list index 30 is marriage pars
self.planets_degree_ut[30] = (asc + dsc) - venus
#list index 31 is black sun
self.planets_degree_ut[31] = swe.nod_aps_ut(self.jul_day_UT, 0,
swe.NODBIT_MEAN,
swe.FLG_SWIEPH)[3][0]
#list index 32 is vulcanus
self.planets_degree_ut[32] = 31.1 + (self.jul_day_UT -
2425246.5) * 0.00150579
#list index 33 is persephone
self.planets_degree_ut[33] = 240.0 + (self.jul_day_UT -
2425246.5) * 0.002737829
#list index 34 is true lilith (own calculation)
self.planets_degree_ut[34] = self.planets_degree_ut[12] + true_lilith
#swiss ephemeris version of true lilith
#self.planets_degree_ut[34] = swe.nod_aps_ut(self.jul_day_UT,1,swe.NODBIT_OSCU,swe.FLG_SWIEPH)[3][0]
#adjust list index 32 and 33
for i in range(23, 35):
while (self.planets_degree_ut[i] < 0):
self.planets_degree_ut[i] += 360.0
while (self.planets_degree_ut[i] > 360.0):
self.planets_degree_ut[i] -= 360.0
#get zodiac sign
for x in range(12):
deg_low = float(x * 30.0)
deg_high = float((x + 1.0) * 30.0)
if self.planets_degree_ut[i] >= deg_low:
if self.planets_degree_ut[i] <= deg_high:
self.planets_sign[i] = x
self.planets_degree[
i] = self.planets_degree_ut[i] - deg_low
self.planets_retrograde[i] = False
#lunar phase, anti-clockwise degrees between sun and moon
ddeg = moon - sun
if ddeg < 0: ddeg += 360.0
step = 360.0 / 28.0
print(moon, sun, ddeg)
for x in range(28):
low = x * step
high = (x + 1) * step
if ddeg >= low and ddeg < high: mphase = x + 1
sunstep = [
0, 30, 40, 50, 60, 70, 80, 90, 120, 130, 140, 150, 160, 170, 180,
210, 220, 230, 240, 250, 260, 270, 300, 310, 320, 330, 340, 350
]
for x in range(len(sunstep)):
low = sunstep[x]
if x is 27: high = 360
else: high = sunstep[x + 1]
if ddeg >= low and ddeg < high: sphase = x + 1
self.lunar_phase = {
"degrees": ddeg,
"moon_phase": mphase,
"sun_phase": sphase
}
#close swiss ephemeris
swe.close()
import swisseph as swe
import collections
from Swiss_eph_constants import *
swe.set_ephe_path('/usr/share/ephe') #set path to ephemeris files
class Chart(object):
def __init__(self):
self.data = []
def Setup_eph(self, lat, long, side=1):
swe.set_topo(lat, long)
swe.set_sid_mode(side)
def decdeg2dms(self, dd):
is_positive = dd >= 0
dd = abs(dd)
minutes, seconds = divmod(dd * 3600, 60)
degrees, minutes = divmod(minutes, 60)
degrees = degrees if is_positive else -degrees
return (degrees, minutes, seconds)
def prnt(self, var):
return (str(var[0]) + 'º ' + str(var[1]) + "' " +
str(round(var[2], 2)) + '"')
def getHouse(self, PlanetLocDict, HouseDict, planet):
import swisseph as swe
import time
from datetime import datetime, timedelta
from my_ephe_path import EPHE_PATH
swe.set_ephe_path(EPHE_PATH) #set the filepath to your Swiss Ephemeris download
swe.set_sid_mode(swe.SIDM_LAHIRI) #uses Hindu-Lahiri ayanamsa for sidereal zodiac
SIGNKEY=('Aries', #0
'Taurus', #1
'Gemini', #2
'Cancer', #3
'Leo', #4
'Virgo', #5
'Libra', #6
'Scorpio', #7
'Sagittarius', #8
'Capricorn', #9
'Aquarius', #10
'Pisces') #11
SIGNCUSPS=tuple(30*x for x in range(12)) #degree value of all sign cusps from 0 = 0 deg Aries to 330 = 0 deg Pisces
PLANETKEY=('Sun', #0
'Moon', #1
'Mercury', #2
'Venus', #3
'Mars', #4
'Jupiter', #5
'Saturn') #6
name = str(get['name'].value)
city = str(get['city'].value)
newcity = str(get['newcity'].value)
lat = float(get['lat'].value)
lon = float(get['lon'].value)
newlat = float(get['newlat'].value)
newlon = float(get['newlon'].value)
year = int(get['year'].value)
newyear = int(get['newyear'].value)
month = int(get['month'].value)
day = int(get['day'].value)
time = float(get['time'].value)
hsys = str(get['hsys'].value)
display = str(get['display'].value)
swe.set_ephe_path('ephe')
# Thanks to openastro.org for this algorythm
solaryearsecs = 31556925.51 # 365 days, 5 hours, 48 minutes, 45.51 seconds
#print("localToSolar: from %s to %s" %(year,newyear))
h, m, s = decHour(time)
dt_original = datetime.datetime(year, month, day, h, m, s)
dt_new = datetime.datetime(newyear, month, day, h, m, s)
result1 = swe.calc_ut(swe.julday(year, month, day, time), 0)
#print("localToSolar: first sun %s" % (result1[0]) )
result2 = swe.calc_ut(swe.julday(newyear, month, day, time), 0)
#print("localToSolar: second sun %s" % (result2[0]) )
sundiff = result1[0] - result2[0]
#print("localToSolar: sundiff %s" %(sundiff))
sundelta = (sundiff / 360.0) * solaryearsecs
# Rarely used, pprint is imported only upon such request for output.
# It also substitutes swe.get_planet_name - can be handy on occasion.
if "out" in re and re["out"] == "pprint":
from pprint import pprint
if __name__ == "__main__":
# This is a minimal e[phemeris].
e = {"0": {}, "1": {}, "2": {}, "3": [], "4": []}
# The data files, which may not be in the
# [sin repo](https://github.com/astrolet/sin) /
# [gravity pakage](http://search.npmjs.org/#/gravity).
swe.set_ephe_path(re["data"])
# Is using the Gregorian calendar flag correct?
# If calendar type is conditional, is it easier to determine here (with the help of swe)?
t = swe.utc_to_jd(re["ut"][0],
re["ut"][1],
re["ut"][2],
re["ut"][3],
re["ut"][4],
re["ut"][5],
re["ut"][6])
# <!---
# e["jd-ut1"] = swe.jdut1_to_utc(t[1], 1)
# --->
#
# Ask for what is precious:
import os
import swisseph as sweph
### FILES AND DIRECTORIES
_ROOT = os.path.abspath(os.path.dirname(__file__))
sweph_dir = os.path.join(_ROOT, '../sweph')
dbfile = os.path.join(_ROOT, 'events.db')
sweph.set_ephe_path(sweph_dir)
### APPROXIMATOR TWEAKS
debug_event_approximation = False
maximum_error = 2e-6 # our guaranteed maximum error
max_data_points = 100000
### ASPECTS
# TODO there are quite a few minor aspects that aren't included yet.
dexter_aspects = [
(30, 'semi-sextile'),
(45, 'semi-square'),
(60, 'sextile'),
(72, 'quintile'),
(120, 'trine'),
(144, 'bi-quintile'),
(150, 'quincunx')
]
from datetime import datetime, timedelta
from collections import OrderedDict
from math import ceil
import networkx as nx
import swisseph
swisseph.set_ephe_path('/usr/share/libswe/ephe/')
DELTA = 0.0004
from IPython import embed
def diff(a1, a2):
angle_diff = ((a1 - a2 + 180 + 360) % 360) - 180
return angle_diff
def binary_search(function, target, lo=0, hi=None, delta=DELTA):
val = None
i = 0
while lo < hi:
mid = lo + (hi - lo) / 2
dif = diff(function(mid), target)
i += 1
#print(i,lo,hi,dif,delta)
if dif < 0:
lo = mid
else:
#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
import os
import swisseph as swe
import tkinter as tk
from math import cos, sin, radians
swe.set_ephe_path(os.path.join(os.getcwd(), "Eph"))
root = tk.Tk()
root.title("")
root.configure(bg="white")
root.resizable(width=False, height=False)
def source_path(relative_path):
import sys
base_path = getattr(sys, '_MEIPASS',
os.path.dirname(os.path.abspath(__file__)))
return os.path.join(base_path, relative_path)
if os.name == "nt":
root.iconbitmap(source_path("TkSwissEph.ico"))
canvas = None
toplevel = None
def create_toplevel():
#!/usr/bin/env python
__author__ = 'naren'
import swisseph as swe
import datetime
import math
import birthchart
from astro import constants
swe.set_ephe_path('astro/data/ephemeris/')
def date_convert(jul_number):
temp = swe.revjul(jul_number)
year = temp[0]
month = temp[1]
day = temp[2]
min_temp, hour = math.modf(temp[3])
sec_temp, min = math.modf(min_temp * 60)
sub_sec, sec = math.modf(sec_temp * 60)
return datetime.datetime(year, month, day, int(hour), int(min), int(sec))
def solar(time_zone, year, month, day, location_latitude, location_longitude):
solaar = {}
now = swe.julday(year, month, day)
for i in range(1):
res_global = swe.sol_eclipse_when_glob(now)
#print 'global', res_global
t_start = res_global[1][0]
lat_long = swe.sol_eclipse_where(t_start)
#print 'where', lat_long
#!/usr/bin/env python
__author__ = 'naren'
import swisseph as swe
import datetime
import math
import birthchart
from astro import constants
swe.set_ephe_path('../ephemeris/')
def date_convert(jul_number):
temp = swe.revjul(jul_number)
year = temp[0]
month = temp[1]
day = temp[2]
min_temp, hour = math.modf(temp[3])
sec_temp, min = math.modf(min_temp * 60)
sub_sec, sec = math.modf(sec_temp * 60)
return datetime.datetime(year, month, day, int(hour), int(min), int(sec))
# ###lunar eclipses
print 'When next Lunar Eclipse'
print '------------------------'
now = swe.julday(2016, 3, 23)
time_zone = 0 # we have to look up time zone from lat/long
res = swe.lun_eclipse_when(now)
res_how = swe.lun_eclipse_how(res[1][0], 139.7, 35.68)
print res
print res_how
import swisseph as sweph
from cerridwen import jd_now
sweph.set_ephe_path("/home/sky/cerridwen/sweph/")
signs = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo',
'Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces'];
ranges = [['28 Gem', '10 Can'], ['22 Leo', '28 Leo']]
def sign_abbrev_to_idx(sa):
abbrevs = [s[0:3] for s in signs]
for i, abbrev in enumerate(abbrevs):
if abbrev == sa:
return i
assert(sign_abbrev_to_idx('Gem')==2)
def absrange(relrange):
start, end = relrange
deg, sign = start.split(' ')
start_abs = int(deg) + sign_abbrev_to_idx(sign)*30
deg, sign = end.split(' ')
end_abs = int(deg) + sign_abbrev_to_idx(sign)*30
return [start_abs, end_abs]
ranges = list(map(absrange, ranges))
def getinfo(lat=0.0,
lon=0.0,
year=1970,
month=1,
day=1,
time=0.0,
hsys='E',
display=range(23)):
swe.set_ephe_path('ephe')
julday = swe.julday(year, month, day, time)
geo = swe.set_topo(lon, lat, 0)
houses, ascmc = swe.houses(julday, lat, lon, hsys)
for body in range(25):
if str(body) in display:
if body == 23:
result = swe.calc_ut(julday, 10)
degree_ut = sanitize(result[0] + 180)
retrograde = bool(result[3] > 0)
elif body == 24:
result = swe.calc_ut(julday, 11)
degree_ut = sanitize(result[0] + 180)
retrograde = bool(result[3] > 0)
else:
result = swe.calc_ut(julday, body)
degree_ut = result[0]
retrograde = bool(result[3] < 0)
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
cibody = {
"id": body,
"name": bnames[body],
"sign": sign,
"sign_name": snames[sign],
"degree": degree_ut - deg_low,
"degree_ut": degree_ut,
"retrograde": retrograde
}
cibodies.append(cibody)
for index, degree_ut in enumerate(houses):
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
cihouse = {
"id": index + 1,
"number": hnames[index],
"name": "House",
"sign": sign,
"sign_name": snames[sign],
"degree": degree_ut - deg_low,
"degree_ut": degree_ut
}
cihouses.append(cihouse)
for index, degree_ut in enumerate(ascmc):
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
ciascmc = {
"id": index + 1,
"name": anames[index],
"sign": sign,
"sign_name": snames[sign],
"degree": degree_ut - deg_low,
"degree_ut": degree_ut
}
ciascmcs.append(ciascmc)
for body1 in cibodies:
deg1 = body1["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
for body2 in cibodies:
deg2 = body2["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
test_aspect(body1, body2, deg1, deg2, 180, 10, "Opposition")
test_aspect(body1, body2, deg1, deg2, 150, 2, "Quincunx")
test_aspect(body1, body2, deg1, deg2, 120, 8, "Trine")
test_aspect(body1, body2, deg1, deg2, 90, 6, "Square")
test_aspect(body1, body2, deg1, deg2, 60, 4, "Sextile")
test_aspect(body1, body2, deg1, deg2, 30, 1, "Semi-sextile")
test_aspect(body1, body2, deg1, deg2, 0, 10, "Conjunction")
swe.close()
cibodies.sort(cmp_bodies)
old_deg = -1000.
dist = 0
for body in cibodies:
deg = body["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
dist = dist + 1 if math.fabs(old_deg - deg) < 5 else 0
body["dist"] = dist
old_deg = deg
ciresults = {
"bodies": cibodies,
"houses": cihouses,
"ascmcs": ciascmcs,
"aspects": ciaspects,
}
return ciresults
#!/usr/bin/env python
__author__ = 'naren'
import numpy as np
import birthchart
import datetime
import pandas as pd
import swisseph as swe
from astro import constants
import numpy as np
import time
swe.set_ephe_path('astro/data/ephemeris/') # path to ephemeris files
start_time = datetime.datetime.utcnow()
print 'date is: ', start_time
#print start_time.tzinfo
birth_date = start_time
time_birth_hour = start_time.hour # 24 hour format
time_birth_min = start_time.minute # 24 hour format
bt_zone = float(0) # Positive for East of London
city_latitude = float(28.66666667) # Positive for north of Equator
city_longitude = float(77.21666667) # positive for East of London
is_birth_time = False
x, y = np.array(birthchart.ephemeris_calc(0.,birth_date, time_birth_hour, time_birth_min))
# x, y = np.array(birthchart.natal_chart_calc(bt_zone, birth_offset, birth_date, time_birth_hour, time_birth_min,
# birth_latitude, birth_longitude, is_birth_time, house_type))
signs = birthchart.natal_planet_signs(x)
#print signs
for i in range(len(x)):
planet_deg = int(x[i])
p_min = x[i] - planet_deg
def setPath(path):
""" Sets the path for the swe files. """
swisseph.set_ephe_path(path)
#!/usr/bin/env python
__author__ = 'naren'
import swisseph as swe
import datetime
import math
import birthchart
from astro import constants
swe.set_ephe_path('astro/data/ephemeris/')
def date_convert(jul_number):
temp = swe.revjul(jul_number)
year = temp[0]
month = temp[1]
day = temp[2]
min_temp, hour = math.modf(temp[3])
sec_temp, min = math.modf(min_temp * 60)
sub_sec, sec = math.modf(sec_temp * 60)
return datetime.datetime(year, month, day, int(hour), int(min), int(sec))
print 'Next Solar Eclipse global'
print '------------------------'
now = swe.julday(2017, 8, 1)
time_zone = -0 # we have to look up time zone from lat/long
for i in range(1):
res_global = swe.sol_eclipse_when_glob(now)
print 'global', res_global
t_start = res_global[1][0]
# -*- coding: utf-8 -*-
import os
import sys
import math
from datetime import datetime
from utils import dechourjoin
import swisseph as swe
from settings import SWE_DATAFILE_PATH
swe.set_ephe_path(SWE_DATAFILE_PATH)
bnames = ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn",\
"uranus", "neptune", "pluto", "mean node"]
#swisseph 中 星体代码
bnames_se = {"sun":0, "moon":1, "mercury":2, "venus":3, "mars":4, "jupiter":5, \
"saturn":6, "uranus":7, "neptune":8, "pluto":9, "mean node":10}
anames = ["Asc", "Mc"]
#十二星座
snames = ["aries", "taurus", "gemini", "cancer", "leo", "virgo", "libra",
"scorpio", "sagittarius", "capricorn", "aquarius", "pisces"]
DEFAULT_DATE = datetime(1990, 3, 30, 18, 15, 0)
class swissephData:
def __init__(self):
self.cibodies = []
self.cihouses = []
self.ciascmcs = []
self.ciresults = {}
def getinfo(lat=0.0, lon=0.0, year=1970, month=1, day=1, time=0.0, hsys='E', display=range(23)):
swe.set_ephe_path('ephe')
julday = swe.julday(year, month, day, time)
geo = swe.set_topo(lon, lat, 0)
houses, ascmc = swe.houses(julday, lat, lon, hsys)
for body in range(25):
if str(body) in display:
if body == 23:
result = swe.calc_ut(julday, 10)
degree_ut = sanitize(result[0] + 180);
retrograde = bool(result[3] > 0)
elif body == 24:
result = swe.calc_ut(julday, 11)
degree_ut = sanitize(result[0] + 180);
retrograde = bool(result[3] > 0)
else:
result = swe.calc_ut(julday, body)
degree_ut = result[0];
retrograde = bool(result[3] < 0)
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
cibody = { "id" : body,
"name" : bnames[body],
"sign" : sign,
"sign_name" : snames[sign],
"degree" : degree_ut - deg_low,
"degree_ut" : degree_ut,
"retrograde" : retrograde }
cibodies.append(cibody)
for index, degree_ut in enumerate(houses):
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
cihouse = { "id" : index + 1,
"number" : hnames[index],
"name" : "House",
"sign" : sign,
"sign_name" : snames[sign],
"degree" : degree_ut - deg_low,
"degree_ut" : degree_ut }
cihouses.append(cihouse)
for index, degree_ut in enumerate(ascmc):
for sign in range(12):
deg_low = float(sign * 30)
deg_high = float((sign + 1) * 30)
if (degree_ut >= deg_low and degree_ut <= deg_high):
ciascmc = { "id" : index + 1,
"name" : anames[index],
"sign" : sign,
"sign_name" : snames[sign],
"degree" : degree_ut - deg_low,
"degree_ut" : degree_ut }
ciascmcs.append(ciascmc)
for body1 in cibodies:
deg1 = body1["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
for body2 in cibodies:
deg2 = body2["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
test_aspect(body1, body2, deg1, deg2, 180, 10, "Opposition")
test_aspect(body1, body2, deg1, deg2, 150, 2, "Quincunx")
test_aspect(body1, body2, deg1, deg2, 120, 8, "Trine")
test_aspect(body1, body2, deg1, deg2, 90, 6, "Square")
test_aspect(body1, body2, deg1, deg2, 60, 4, "Sextile")
test_aspect(body1, body2, deg1, deg2, 30, 1, "Semi-sextile")
test_aspect(body1, body2, deg1, deg2, 0, 10, "Conjunction")
swe.close()
cibodies.sort(cmp_bodies)
old_deg = -1000.
dist = 0
for body in cibodies:
deg = body["degree_ut"] - ciascmcs[0]["degree_ut"] + 180
dist = dist + 1 if math.fabs(old_deg - deg) < 5 else 0
body["dist"] = dist
old_deg = deg
ciresults = {
"bodies" : cibodies,
"houses" : cihouses,
"ascmcs" : ciascmcs,
"aspects" : ciaspects,
}
return ciresults
# Rarely used, pprint is imported only upon such request for output.
# It also substitutes swe.get_planet_name - can be handy on occasion.
if "out" in re and re["out"] == "pprint":
from pprint import pprint
if __name__ == "__main__":
# This is a minimal e[phemeris].
e = {"0": {}, "1": {}, "2": {}, "3": [], "4": []}
# The data files, which may not be in the
# [sin repo](https://github.com/astrolet/sin) /
# [gravity pakage](http://search.npmjs.org/#/gravity).
swe.set_ephe_path(re["data"])
# Is using the Gregorian calendar flag correct?
# If calendar type is conditional, is it easier to determine here (with the help of swe)?
t = swe.utc_to_jd(re["ut"][0], re["ut"][1], re["ut"][2], re["ut"][3], re["ut"][4], re["ut"][5], re["ut"][6])
# <!---
# e["jd-ut1"] = swe.jdut1_to_utc(t[1], 1)
# --->
#
# Ask for what is precious:
#
# 1. majors (the main things / points for astrology)
# 2. minors (other objects - e.g. some "minor planets")
# 3. angles (ascmc) = 8 of 10 doubles (unused 8 & 9)
# 4. houses (cusps) = 12 of 13 doubles (unused zero)
#
import csv
import math
import sys
from pathlib import Path
from random import random, shuffle
from typing import Tuple, List, Dict, Optional
import numpy as np
import swisseph as swe
import roc_sd
from roc_estimates import ROC_SD
DAYS_IN_YEAR = (swe.julday(2300, 1, 1) - swe.julday(1900, 1, 1)) / 400
swe.set_ephe_path("/home/dmc/astrolog/astephem")
SUN = 0
MERCURY = 2
VENUS = 3
"""
For each "planet" we're going to consider, we record its index in SwissEph, its full name, a unique two-letter
identifier, and its orbital period in years. (Astrologers use the term "planet" to include not only true astronomical
planets but all bodies of interest in the solar system, including the Sun, Moon, asteroids and other things too small
to be planets).
"""
PLANET_DATA = [
(0, "Sun", "Su", 1.0),
(1, "Moon", "Mo", 0.074),
(2, "Mercury", "Me", 0.241),
(3, "Venus", "Ve", 0.699),
#!/usr/bin/env python
__author__ = 'naren'
import swisseph as swe
import datetime
import math
import birthchart
from astro import constants
swe.set_ephe_path('../ephemeris/')
def date_convert(jul_number):
temp = swe.revjul(jul_number)
year = temp[0]
month = temp[1]
day = temp[2]
min_temp, hour = math.modf(temp[3])
sec_temp, min = math.modf(min_temp * 60)
sub_sec, sec = math.modf(sec_temp * 60)
return datetime.datetime(year, month, day, int(hour), int(min), int(sec))
def lunar(time_zone, year, month, day, location_latitude, location_longitude):
# ###lunar eclipses
lunar_eclipse = {}
now = swe.julday(year, month, day)
res = swe.lun_eclipse_when(now)
res_how = swe.lun_eclipse_how(res[1][0], 139.7, 35.68)
#print res
#print res_how
eclip_time = swe.revjul(res[1][0]) # utc
from dateutil.parser import parse
import pytz
import geocoder
import swisseph as swe
swe.set_ephe_path('/usr/share/libswe/ephe/')
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import pgettext_lazy
from django.db import models
from timezone_field import TimeZoneField
from tzwhere.tzwhere import tzwhere
from users.models import UserProfile
tzwhere = tzwhere()
class Event(models.Model):
user = models.ForeignKey(UserProfile, related_name='events', null=True, verbose_name=_('User'))
name = models.CharField(max_length=256, verbose_name=_('Name'))
date = models.DateTimeField(verbose_name=_('Date'))
city = models.CharField(max_length=256, verbose_name=_('City'))
location = models.ForeignKey('Location', related_name='events', null=True, verbose_name=_('Location'))
ephemeris = models.OneToOneField('Ephemeris', related_name='event', verbose_name=_('Events'))
houses = models.OneToOneField('Houses', related_name='event', verbose_name=_('Houses'))
class Meta:
verbose_name = _('event')
verbose_name_plural = _('events')
def __unicode__(self):
return self.name
import swisseph as sweph
from cerridwen import jd_now
sweph.set_ephe_path("/home/sky/cerridwen/sweph/")
signs = [
'Aries', 'Taurus', 'Gemini', 'Cancer', 'Leo', 'Virgo', 'Libra', 'Scorpio',
'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces'
]
ranges = [['28 Gem', '10 Can'], ['22 Leo', '28 Leo']]
def sign_abbrev_to_idx(sa):
abbrevs = [s[0:3] for s in signs]
for i, abbrev in enumerate(abbrevs):
if abbrev == sa:
return i
assert (sign_abbrev_to_idx('Gem') == 2)
def absrange(relrange):
start, end = relrange
deg, sign = start.split(' ')
start_abs = int(deg) + sign_abbrev_to_idx(sign) * 30
deg, sign = end.split(' ')
end_abs = int(deg) + sign_abbrev_to_idx(sign) * 30
return [start_abs, end_abs]
name = str (get['name'].value)
city = str (get['city'].value)
newcity = str (get['newcity'].value)
lat = float(get['lat'].value)
lon = float(get['lon'].value)
newlat = float(get['newlat'].value)
newlon = float(get['newlon'].value)
year = int (get['year'].value)
newyear = int (get['newyear'].value)
month = int (get['month'].value)
day = int (get['day'].value)
time = float(get['time'].value)
hsys = str (get['hsys'].value)
display = str (get['display'].value)
swe.set_ephe_path('ephe')
# Thanks to openastro.org for this algorythm
solaryearsecs = 31556925.51 # 365 days, 5 hours, 48 minutes, 45.51 seconds
#print("localToSolar: from %s to %s" %(year,newyear))
h,m,s = decHour(time)
dt_original = datetime.datetime(year,month,day,h,m,s)
dt_new = datetime.datetime(newyear,month,day,h,m,s)
result1 = swe.calc_ut(swe.julday(year,month,day,time), 0)
#print("localToSolar: first sun %s" % (result1[0]) )
result2 = swe.calc_ut(swe.julday(newyear,month,day,time), 0)
#print("localToSolar: second sun %s" % (result2[0]) )
sundiff = result1[0] - result2[0]
#print("localToSolar: sundiff %s" %(sundiff))
sundelta = ( sundiff / 360.0 ) * solaryearsecs
import planet_rise_times
import ip2location_lookup
import ephemeris_today
import moon_phases
import eclipse_solar
import eclipses_lunar
#############################################################################################################################
############################################### Common ######################################################################
con = sqlite3.connect('city', check_same_thread=False)
curr = con.cursor()
application = Flask(__name__, static_url_path='/astro/static')
api = Api(application)
swe.set_ephe_path('astro/data/ephemeris/') # path to ephemeris files
f = urllib2.urlopen('http://jsonip.com/')
json_string = f.read()
f.close()
ip_add = json.loads(json_string)
ip_addrs = ip_add['ip']#'2607:f1c0:83c:7000:0:0:43:963d'
tt = ''
if (re.match('^[0-9]{0,3}.[0-9]{0,3}.[0-9]{0,3}.[0-9]{0,3}$', ip_addrs)):
tt = 1
location_latitude, location_longitude, TimezoneID, region, city, country, timezone = ip2location_lookup.ipv42loc(ip_addrs)
else:
tt = 0
location_latitude, location_longitude, TimezoneID, region, city, country, timezone = ip2location_lookup.ipv62loc(ip_addrs)
#print 'latitude is', location_latitude
#print 'Longitude is', location_longitude
hora) + ':' + str(min) + '"'
horaLocal = horaLocal - datetime.timedelta(hours=int(gmt))
#horaLocal = horaLocal - datetime.timedelta(minutes=int(30))
#print(horaLocal)
#Luego de aplicar el GMT
dia = horaLocal.strftime('%d')
mes = int(horaLocal.strftime('%m'))
anio = horaLocal.strftime('%Y')
hora = horaLocal.strftime('%H')
min = horaLocal.strftime('%M')
#print('Tiempo: ' + dia + '/' + mes + '/' + anio + ' ' + hora + ':' + min)
swe.set_ephe_path('/usr/share/libswe/ephe')
d = datetime.datetime(int(anio), int(mes), int(dia), int(hora), int(min))
jd1 = jdutil.datetime_to_jd(d)
np = [('Sol', 0), ('Luna', 1), ('Mercurio', 2), ('Venus', 3), ('Marte', 4),
('Júpiter', 5), ('Saturno', 6), ('Urano', 7), ('Neptuno', 8),
('Plutón', 9), ('Nodo Norte', 11), ('Nodo Sur', 10), ('Quirón', 15),
('Selena', 57), ('Lilith', 12)]
#La oblicuidad de calcula con ipl = SE_ECL_NUT = -1 en SWE pero en swisseph ECL_NUT = -1
posObli = swe.calc(jd1, -1, flag=swe.FLG_SWIEPH + swe.FLG_SPEED)
oblicuidad = posObli[0][0]
#pos=swe.calc_ut(jd1, np[4][1], flag=swe.FLG_SWIEPH+swe.FLG_SPEED)
#pos=swe.calc_ut(jd1, np[4][1], flag=swe.FLG_SWIEPH)
pos = swe.calc_ut(jd1, np[2][1], flag=swe.FLG_SPEED)
data_book = {'Sheet1': []}
##pyexcel.save_as(array=data, dest_file_name=output_file)
#sheet = pyexcel.Sheet(data)
other_book = pyexcel.Book(data_book)
other_book.save_as(output_file)
input_file = u"xls_wordlist.xls"
empty_row = ["NA", "NA", "NA", "NA", "NA", "NA", "NA", "NA", "NA"]
i = -1
row_to_add = []
for value in empty_row:
i += 1
row_to_add.append(empty_row[i])
ephe_path = '/usr/share/libswe/:/usr/local/share/libswe/'
swe.set_ephe_path(ephe_path)
gregflag = 1
geolon = 0.34 #bordeaux
geolat = 44.50 #bordeaux
#Ce serait bien de faire une liste du top 10 des occurences contenant le moins de lettres
# implement limit to psalms
def Read_cell(
x=1,
y=1
): #this procedure uses an xls file and pyexcel the other should be harmonized
print "reading cell", x, y, "from", input_file
global input_file
#name = chrt.planets.planets[j].name
#riseset = chrt.riseset.planetRiseSet(j)
out.append("%.2f\t%.2f\t%.3f\t%.2f\t" % (lon, lat, decl, speed))
for asteroid in chrt.asteroids.asteroids:
lon = asteroid.data[planets.Planet.LONG]
lat = asteroid.data[planets.Planet.LAT]
speed = asteroid.data[planets.Planet.SPLON]
decl = asteroid.dataEqu[planets.Planet.DECLEQU]
out.append("%.2f\t%.2f\t%.3f\t%.2f\t" % (lon, lat, decl, speed))
sys.stdout.write(''.join(out))
opts = options.Options()
swisseph.set_ephe_path('../SWEP/Ephem')
# instance of place, time and chart generation
# Based on Greenwich place and UTC time.
place = chart.Place(None, 51, 29, 24, True, 0, 0, 0, True, 0)
time = chart.event.DateTime(2020, 8, 20, 0, 0, 0, False, 0, 0, True, 0, 0,
False, place)
chrt = chart.Chart("Daily Chart", False, time, place, 0, "", opts)
print("Date\tHour\t" \
"SULON\tSULAT\tSUDEC\tSUSP\t" \
"MOLON\tMOLAT\tMODEC\tMOSP\t" \
"MELON\tMELAT\tMEDEC\tMESP\t" \
"VELON\tVELAT\tVEDEC\tVESP\t" \
"MALON\tMALAT\tMADEC\tMASP\t" \
"JULON\tJULAT\tJUDEC\tJUSP\t" \
"SALON\tSALAT\tSADEC\tSASP\t" \
def __init__(self,year,month,day,hour,geolon,geolat,altitude,planets,zodiac,openastrocfg,houses_override=None):
#ephemeris path (default "/usr/share/swisseph:/usr/local/share/swisseph")
swe.set_ephe_path(ephe_path)
#basic location
self.jul_day_UT=swe.julday(year,month,day,hour)
self.geo_loc = swe.set_topo(geolon,geolat,altitude)
#output variables
self.planets_sign = range(len(planets))
self.planets_degree = range(len(planets))
self.planets_degree_ut = range(len(planets))
self.planets_info_string = range(len(planets))
self.planets_retrograde = range(len(planets))
#iflag
"""
#define SEFLG_JPLEPH 1L // use JPL ephemeris
#define SEFLG_SWIEPH 2L // use SWISSEPH ephemeris, default
#define SEFLG_MOSEPH 4L // use Moshier ephemeris
#define SEFLG_HELCTR 8L // return heliocentric position
#define SEFLG_TRUEPOS 16L // return true positions, not apparent
#define SEFLG_J2000 32L // no precession, i.e. give J2000 equinox
#define SEFLG_NONUT 64L // no nutation, i.e. mean equinox of date
#define SEFLG_SPEED3 128L // speed from 3 positions (do not use it, SEFLG_SPEED is // faster and preciser.)
#define SEFLG_SPEED 256L // high precision speed (analyt. comp.)
#define SEFLG_NOGDEFL 512L // turn off gravitational deflection
#define SEFLG_NOABERR 1024L // turn off 'annual' aberration of light
#define SEFLG_EQUATORIAL 2048L // equatorial positions are wanted
#define SEFLG_XYZ 4096L // cartesian, not polar, coordinates
#define SEFLG_RADIANS 8192L // coordinates in radians, not degrees
#define SEFLG_BARYCTR 16384L // barycentric positions
#define SEFLG_TOPOCTR (32*1024L) // topocentric positions
#define SEFLG_SIDEREAL (64*1024L) // sidereal positions
"""
#check for apparent geocentric (default), true geocentric, topocentric or heliocentric
iflag=swe.FLG_SWIEPH+swe.FLG_SPEED
if(openastrocfg['postype']=="truegeo"):
iflag += swe.FLG_TRUEPOS
elif(openastrocfg['postype']=="topo"):
iflag += swe.FLG_TOPOCTR
elif(openastrocfg['postype']=="helio"):
iflag += swe.FLG_HELCTR
#sidereal
if(openastrocfg['zodiactype']=="sidereal"):
iflag += swe.FLG_SIDEREAL
mode="SIDM_"+openastrocfg['siderealmode']
swe.set_sid_mode(getattr(swe,mode.encode("ascii")))
#compute a planet (longitude,latitude,distance,long.speed,lat.speed,speed)
for i in range(23):
ret_flag = swe.calc_ut(self.jul_day_UT,i,iflag)
for x in range(len(zodiac)):
deg_low=float(x*30)
deg_high=float((x+1)*30)
if ret_flag[0] >= deg_low:
if ret_flag[0] <= deg_high:
self.planets_sign[i]=x
self.planets_degree[i] = ret_flag[0] - deg_low
self.planets_degree_ut[i] = ret_flag[0]
#if latitude speed is negative, there is retrograde
if ret_flag[3] < 0:
self.planets_retrograde[i] = True
else:
self.planets_retrograde[i] = False
#available house systems:
"""
hsys= ‘P’ Placidus
‘K’ Koch
‘O’ Porphyrius
‘R’ Regiomontanus
‘C’ Campanus
‘A’ or ‘E’ Equal (cusp 1 is Ascendant)
‘V’ Vehlow equal (Asc. in middle of house 1)
‘X’ axial rotation system
‘H’ azimuthal or horizontal system
‘T’ Polich/Page (“topocentric” system)
‘B’ Alcabitus
‘G’ Gauquelin sectors
‘M’ Morinus
"""
#houses calculation (hsys=P for Placidus)
#check for polar circle latitude < -66 > 66
if houses_override:
self.jul_day_UT = swe.julday(houses_override[0],houses_override[1],houses_override[2],houses_override[3])
if geolat > 66.0:
geolat = 66.0
print "polar circle override for houses, using 66 degrees"
elif geolat < -66.0:
geolat = -66.0
print "polar circle override for houses, using -66 degrees"
#sidereal houses
if(openastrocfg['zodiactype']=="sidereal"):
sh = swe.houses_ex(self.jul_day_UT,geolat,geolon,openastrocfg['houses_system'].encode("ascii"),swe.FLG_SIDEREAL)
else:
sh = swe.houses(self.jul_day_UT,geolat,geolon,openastrocfg['houses_system'].encode("ascii"))
self.houses_degree_ut = list(sh[0])
self.houses_degree = range(len(self.houses_degree_ut))
self.houses_sign = range(len(self.houses_degree_ut))
for i in range(12):
for x in range(len(zodiac)):
deg_low=float(x*30)
deg_high=float((x+1)*30)
if self.houses_degree_ut[i] >= deg_low:
if self.houses_degree_ut[i] <= deg_high:
self.houses_sign[i]=x
self.houses_degree[i] = self.houses_degree_ut[i] - deg_low
#compute additional points and angles
#list index 23 is asc, 24 is Mc, 25 is Dsc, 26 is Ic
self.planets_degree_ut[23] = self.houses_degree_ut[0]
self.planets_degree_ut[24] = self.houses_degree_ut[9]
self.planets_degree_ut[25] = self.houses_degree_ut[6]
self.planets_degree_ut[26] = self.houses_degree_ut[3]
#arabic parts
sun,moon,asc = self.planets_degree_ut[0],self.planets_degree_ut[1],self.planets_degree_ut[23]
dsc,venus = self.planets_degree_ut[25],self.planets_degree_ut[3]
#list index 27 is day pars
self.planets_degree_ut[27] = asc + (moon - sun)
#list index 28 is night pars
self.planets_degree_ut[28] = asc + (sun - moon)
#list index 29 is South Node
self.planets_degree_ut[29] = self.planets_degree_ut[10] - 180.0
#list index 30 is marriage pars
self.planets_degree_ut[30] = (asc+dsc)-venus
#if planet degrees is greater than 360 substract 360 or below 0 add 360
for i in range(23,31):
if self.planets_degree_ut[i] > 360.0:
self.planets_degree_ut[i] = self.planets_degree_ut[i] - 360.0
elif self.planets_degree_ut[i] < 0.0:
self.planets_degree_ut[i] = self.planets_degree_ut[i] + 360.0
#get zodiac sign
for x in range(12):
deg_low=float(x*30.0)
deg_high=float((x+1.0)*30.0)
if self.planets_degree_ut[i] >= deg_low:
if self.planets_degree_ut[i] <= deg_high:
self.planets_sign[i]=x
self.planets_degree[i] = self.planets_degree_ut[i] - deg_low
self.planets_retrograde[i] = False
#close swiss ephemeris
swe.close()
