예제 #1
0
def natal_chart_calc(t_zone, b_offset, b_date, t_birth_hour, t_birth_min, b_latitude, b_longitude, is_time, h_type):
    date_year_birth = int(b_date.strftime("%Y"))
    date_month_birth = int(b_date.strftime("%m"))
    date_day_birth = int(b_date.strftime("%d"))
    # print 'naren', date_year_birth, date_month_birth, date_day_birth, t_birth_hour, t_birth_min, t_zone, b_offset,\
    # (t_birth_hour + (t_birth_min / 60.)) - (t_zone + b_offset)
    now_julian = swe.julday(date_year_birth, date_month_birth, date_day_birth,
                            (t_birth_hour + (t_birth_min / 60.)) - (t_zone + b_offset))
    # print now_julian
    l_birthchart = len(constants.BIRTH_PLANETS)
    bchart_pos = np.zeros(l_birthchart + 2)
    bchart_speed = np.zeros(l_birthchart)
    for i in range(l_birthchart):
        pos_p = swe.calc_ut(now_julian, constants.BIRTH_PLANETS[i])
        bchart_pos[i] = pos_p[0]
        bchart_speed[i] = pos_p[3]

    if is_time:
        house_array = (swe.houses(now_julian, b_latitude, b_longitude, h_type))
        bchart_pos[i + 1] = house_array[1][0]
        bchart_pos[i + 2] = house_array[1][1]
    else:
        bchart_pos[i + 1] = 0
        bchart_pos[i + 2] = 0
    return bchart_pos, bchart_speed
예제 #2
0
def natal_chart_calc(t_zone, b_offset, b_date, t_birth_hour, t_birth_min,
                     b_latitude, b_longitude, is_time, h_type):
    date_year_birth = int(b_date.strftime("%Y"))
    date_month_birth = int(b_date.strftime("%m"))
    date_day_birth = int(b_date.strftime("%d"))
    # print 'naren', date_year_birth, date_month_birth, date_day_birth, t_birth_hour, t_birth_min, t_zone, b_offset,\
    # (t_birth_hour + (t_birth_min / 60.)) - (t_zone + b_offset)
    now_julian = swe.julday(date_year_birth, date_month_birth, date_day_birth,
                            (t_birth_hour +
                             (t_birth_min / 60.)) - (t_zone + b_offset))
    # print now_julian
    l_birthchart = len(constants.BIRTH_PLANETS)
    bchart_pos = np.zeros(l_birthchart + 2)
    bchart_speed = np.zeros(l_birthchart)
    for i in range(l_birthchart):
        pos_p = swe.calc_ut(now_julian, constants.BIRTH_PLANETS[i])
        bchart_pos[i] = pos_p[0]
        bchart_speed[i] = pos_p[3]

    if is_time:
        house_array = (swe.houses(now_julian, b_latitude, b_longitude, h_type))
        bchart_pos[i + 1] = house_array[1][0]
        bchart_pos[i + 2] = house_array[1][1]
    else:
        bchart_pos[i + 1] = 0
        bchart_pos[i + 2] = 0
    return bchart_pos, bchart_speed
예제 #3
0
파일: swe.py 프로젝트: xAlstrat/flatlib
def sweHouses(jd, lat, lon, hsys):
    """ Returns lists of houses and angles. """
    hsys = SWE_HOUSESYS[hsys]
    hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
    # Add first house to the end of 'hlist' so that we
    # can compute house sizes with an iterator
    hlist += (hlist[0], )
    houses = [{
        'id': const.LIST_HOUSES[i],
        'lon': hlist[i],
        'size': angle.distance(hlist[i], hlist[i + 1])
    } for i in range(12)]
    angles = [{
        'id': const.ASC,
        'lon': ascmc[0]
    }, {
        'id': const.MC,
        'lon': ascmc[1]
    }, {
        'id': const.DESC,
        'lon': angle.norm(ascmc[0] + 180)
    }, {
        'id': const.IC,
        'lon': angle.norm(ascmc[1] + 180)
    }, {
        'id': const.VERTEX,
        'lon': ascmc[3]
    }]
    return (houses, angles)
예제 #4
0
 def calc_houses(self):
     houses = swe.houses(self.datetime_julday, self.latitude,
                         self.longitude)[0]
     planets_in_houses = []
     for planet_code, planet in self.planets.items():
         planet['house'] = self.calc_house(houses, planet['x'])
     self.asc = houses[0]
     self.asc_sign = SIGN_NAMES[int(houses[0] / 30)]
     return houses  #, planets_in_houses
예제 #5
0
파일: swe.py 프로젝트: xAlstrat/flatlib
def sweHousesLon(jd, lat, lon, hsys):
    """ Returns lists with house and angle longitudes. """
    hsys = SWE_HOUSESYS[hsys]
    hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
    angles = [
        ascmc[0], ascmc[1],
        angle.norm(ascmc[0] + 180),
        angle.norm(ascmc[1] + 180), ascmc[3]
    ]
    return (hlist, angles)
예제 #6
0
파일: swe.py 프로젝트: ruthenium/flatlib
def sweHousesLon(jd, lat, lon, hsys):
    """ Returns lists with house and angle longitudes. """
    hsys = SWE_HOUSESYS[hsys]
    hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
    angles = [
        ascmc[0],
        ascmc[1],
        angle.norm(ascmc[0] + 180), 
        angle.norm(ascmc[1] + 180)
    ]
    return (hlist, angles)
예제 #7
0
def olivier_endpoint():
    import math
    import swisseph as sweph

    latlong = None
    jd = cerridwen.jd_now()

    try:
        date = flask.request.args.get('date')
        if date:
            jd = cerridwen.parse_jd_or_iso_date(date)

        lat = flask.request.args.get('latitude')
        if lat:
            lat = float(lat)
        long = flask.request.args.get('longitude')
        if long:
            long = float(long)
        if (long is None and lat is not None) or (lat is None
                                                  and long is not None):
            raise ValueError("Specify both longitude and latitude or none")
        if lat and long:
            latlong = cerridwen.LatLong(lat, long)
    except ValueError as e:
        return make_response(e, 400)

    result = collections.OrderedDict()

    result['jd'] = jd
    result['iso_date'] = cerridwen.jd2iso(jd)

    from cerridwen import Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto
    for planet in [
            Sun(),
            Moon(),
            Mercury(),
            Venus(),
            Mars(),
            Jupiter(),
            Saturn(),
            Uranus(),
            Neptune(),
            Pluto()
    ]:
        result[planet.name().lower()] = math.radians(planet.longitude(jd))

    if latlong:
        result['houses'] = [
            math.radians(cusp)
            for cusp in sweph.houses(jd, latlong.lat, latlong.long)[0]
        ]

    import json
    return make_response(json.dumps(result, indent=8), 200)
예제 #8
0
def updatePandC(date, observer, houses, entries):
	day = datetime_to_julian(date)
	obliquity = swisseph.calc_ut(day, swisseph.ECL_NUT)[0]
	cusps, asmc = swisseph.houses(day, observer.lat, observer.lng)
	fill_houses(date, observer, houses=houses, data=cusps)
	for i in range(10):
		calcs = swisseph.calc_ut(day, i)
		hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
		if i == swisseph.SUN or i == swisseph.MOON:
			retrograde = 'Not Applicable'
		else:
			retrograde = str(calcs[3] < 0)
		entries[i].retrograde = retrograde
		entries[i].m.longitude = calcs[0]
		entries[i].m.latitude = calcs[1]
		entries[i].m.progress = hom % 1.0
		entries[i].m.house_info = houses[int(hom-1)]
	if len(entries) > 10: #add node entries
		calcs = swisseph.calc_ut(day, swisseph.TRUE_NODE)
		hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
		retrograde = "Always"

		entries[10].retrograde = retrograde
		entries[10].m.longitude = calcs[0]
		entries[10].m.latitude = calcs[1]
		entries[10].m.progress = hom%1.0
		entries[10].m.house_info = houses[int(hom-1)]

		#do some trickery to display the South Node
		reverse = swisseph.degnorm(calcs[0]-180.0)
		revhouse = (int(hom)+6)%12
		#revprogress = 1-hom%1.0
		revprogress = hom%1.0
		entries[11].retrograde = retrograde
		entries[11].m.longitude = reverse
		entries[11].m.latitude = calcs[1]
		entries[11].m.progress = revprogress
		entries[11].m.house_info = houses[int(revhouse-1)]
	if len(entries) > 12:
		ascendant = asmc[0]
		descendant = cusps[6]
		mc = asmc[1]
		ic = cusps[3]
		retrograde = 'Not a Planet'

		entries[12].m.longitude = ascendant
		entries[13].m.longitude = descendant
		entries[14].m.longitude = mc
		entries[15].m.longitude = ic

	swisseph.close()
예제 #9
0
def updatePandC(date, observer, houses, entries):
    day = datetime_to_julian(date)
    obliquity = swisseph.calc_ut(day, swisseph.ECL_NUT)[0]
    cusps, asmc = swisseph.houses(day, observer.lat, observer.lng)
    fill_houses(date, observer, houses=houses, data=cusps)
    for i in range(10):
        calcs = swisseph.calc_ut(day, i)
        hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
        if i == swisseph.SUN or i == swisseph.MOON:
            retrograde = "Not Applicable"
        else:
            retrograde = str(calcs[3] < 0)
        entries[i].retrograde = retrograde
        entries[i].m.longitude = calcs[0]
        entries[i].m.latitude = calcs[1]
        entries[i].m.progress = hom % 1.0
        entries[i].m.house_info = houses[int(hom - 1)]
    if len(entries) > 10:  # add node entries
        calcs = swisseph.calc_ut(day, swisseph.TRUE_NODE)
        hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
        retrograde = "Always"

        entries[10].retrograde = retrograde
        entries[10].m.longitude = calcs[0]
        entries[10].m.latitude = calcs[1]
        entries[10].m.progress = hom % 1.0
        entries[10].m.house_info = houses[int(hom - 1)]

        # do some trickery to display the South Node
        reverse = swisseph.degnorm(calcs[0] - 180.0)
        revhouse = (int(hom) + 6) % 12
        # revprogress = 1-hom%1.0
        revprogress = hom % 1.0
        entries[11].retrograde = retrograde
        entries[11].m.longitude = reverse
        entries[11].m.latitude = calcs[1]
        entries[11].m.progress = revprogress
        entries[11].m.house_info = houses[int(revhouse - 1)]
    if len(entries) > 12:
        ascendant = asmc[0]
        descendant = cusps[6]
        mc = asmc[1]
        ic = cusps[3]
        retrograde = "Not a Planet"

        entries[12].m.longitude = ascendant
        entries[13].m.longitude = descendant
        entries[14].m.longitude = mc
        entries[15].m.longitude = ic

    swisseph.close()
예제 #10
0
def fill_houses(date, observer, houses=None, data=None):
	day = datetime_to_julian(date)
	if not data:
		data = swisseph.houses(day, observer.lat, observer.lng)[0]
	if houses == None:
		houses = []
		for i in range(12):
			houses.append(HouseMeasurement(data[i], data[(i+1)%12], num=i+1))
		swisseph.close()
		return houses
	else:
		for i in range(12):
			houses[i].cusp.longitude = data[i]
			houses[i].end.longitude = data[(i+1)%12]
		swisseph.close()
예제 #11
0
def fill_houses(date, observer, houses=None, data=None):
    day = datetime_to_julian(date)
    if not data:
        data = swisseph.houses(day, observer.lat, observer.lng)[0]
    if houses == None:
        houses = []
        for i in range(12):
            houses.append(HouseMeasurement(data[i], data[(i + 1) % 12], num=i + 1))
        swisseph.close()
        return houses
    else:
        for i in range(12):
            houses[i].cusp.longitude = data[i]
            houses[i].end.longitude = data[(i + 1) % 12]
        swisseph.close()
예제 #12
0
def calculate_main_chart(input_data, intermediate, output):
    output['houses'] = {}
    output['houses']['sh'] = {}
    output['houses']['sh'] = swe.houses(
        intermediate['jul_day_UT'], float(input_data['chart']['latitude']),
        float(input_data['chart']['longitude']),
        input_data['config']['house_system'].encode('ascii'))
    output['houses']['houses_degree_ut'] = output['houses']['sh'][0]
    output['houses']['ps'] = swe.nod_aps_ut(intermediate['jul_day_UT'], 0,
                                            swe.NODBIT_MEAN,
                                            intermediate['iflag'])
    output['houses']['pl'] = swe.nod_aps_ut(intermediate['jul_day_UT'], 1,
                                            swe.NODBIT_MEAN,
                                            intermediate['iflag'])

    return output
예제 #13
0
    def houses(self):
        """Calculatetype positions and store them in dictionaries"""

        #creates the list of the house in 360°
        self.houses_degree_ut = swe.houses(self.j_day, self.city_lat,
                                           self.city_long)[0]
        #stores the house in signulare dictionaries.
        self.first_house = self.pos_calc(self.houses_degree_ut[0], "1", "name")
        self.second_house = self.pos_calc(self.houses_degree_ut[1], "2",
                                          "name")
        self.third_house = self.pos_calc(self.houses_degree_ut[2], "3", "name")
        self.fourth_house = self.pos_calc(self.houses_degree_ut[3], "4",
                                          "name")
        self.fifth_house = self.pos_calc(self.houses_degree_ut[4], "5", "name")
        self.sixth_house = self.pos_calc(self.houses_degree_ut[5], "6", "name")
        self.seventh_house = self.pos_calc(self.houses_degree_ut[6], "7",
                                           "name")
        self.eighth_house = self.pos_calc(self.houses_degree_ut[7], "8",
                                          "name")
        self.ninth_house = self.pos_calc(self.houses_degree_ut[8], "9", "name")
        self.tenth_house = self.pos_calc(self.houses_degree_ut[9], "10",
                                         "name")
        self.eleventh_house = self.pos_calc(self.houses_degree_ut[10], "11",
                                            "name")
        self.twelfth_house = self.pos_calc(self.houses_degree_ut[11], "12",
                                           "name")
        #creates a list of all the dictionaries of thetype.
        self.house_list = [
            self.first_house, self.second_house, self.third_house,
            self.fourth_house, self.fifth_house, self.sixth_house,
            self.seventh_house, self.eighth_house, self.ninth_house,
            self.tenth_house, self.eleventh_house, self.twelfth_house
        ]

        self.houses_degree = [
            self.house_list[0]["pos"], self.house_list[1]["pos"],
            self.house_list[2]["pos"], self.house_list[3]["pos"],
            self.house_list[4]["pos"], self.house_list[5]["pos"],
            self.house_list[6]["pos"], self.house_list[7]["pos"],
            self.house_list[8]["pos"], self.house_list[9]["pos"],
            self.house_list[10]["pos"], self.house_list[11]["pos"]
        ]

        return self.house_list
예제 #14
0
 def house_cusps(self):
     houses = []
     asc = 0
     angle = []
     for i, j in enumerate(
             swe.houses(self.julday(), self.latitude, self.longitude)[0]):
         if i == 0:
             asc += j
         angle.append(j)
         if i + 1 == 1:
             self.append_house(houses, i, j, name="Asc")
         elif i + 1 == 4:
             self.append_house(houses, i, j, name="IC")
         elif i + 1 == 7:
             self.append_house(houses, i, j, name="Dsc")
         elif i + 1 == 10:
             self.append_house(houses, i, j, name="MC")
         else:
             self.append_house(houses, i, j)
     return houses, asc, angle
def getHour(uHora, grado):
    for hora in range(24):
        #print('Hora: '+str(hora))
        encontrado = False
        for minuto in range(60):
            #print('Minuto: '+str(minuto))
            uHora += datetime.timedelta(minutes=1)
            #print(str(d))
            jd1 = jdutil.datetime_to_jd(uHora)
            h = swe.houses(jd1, float(lat), float(lon),
                           bytes("P", encoding="utf-8"))
            gasc = float(h[0][0])
            if gasc >= grado - 1.00 and gasc <= grado + 1.00:
                #print(str(gasc))
                uHora = uHora + datetime.timedelta(hours=int(gmt))
                encontrado = True
                break
        if encontrado:
            break

    return uHora
예제 #16
0
파일: swe.py 프로젝트: ruthenium/flatlib
def sweHouses(jd, lat, lon, hsys):
    """ Returns lists of houses and angles. """
    hsys = SWE_HOUSESYS[hsys]
    hlist, ascmc = swisseph.houses(jd, lat, lon, hsys)
    # Add first house to the end of 'hlist' so that we
    # can compute house sizes with an iterator 
    hlist += (hlist[0],)
    houses = [
        {
            'id': const.LIST_HOUSES[i],
            'lon': hlist[i], 
            'size': angle.distance(hlist[i], hlist[i+1])
        } for i in range(12)
    ]
    angles = [
        {'id': const.ASC, 'lon': ascmc[0]}, 
        {'id': const.MC, 'lon': ascmc[1]},
        {'id': const.DESC, 'lon': angle.norm(ascmc[0] + 180)},
        {'id': const.IC, 'lon': angle.norm(ascmc[1] + 180)}
    ]
    return (houses, angles)
예제 #17
0
def olivier_endpoint():
    import math
    import swisseph as sweph

    latlong = None
    jd = cerridwen.jd_now()

    try:
        date = flask.request.args.get('date')
        if date:
            jd = cerridwen.parse_jd_or_iso_date(date)

        lat = flask.request.args.get('latitude')
        if lat:
            lat = float(lat)
        long = flask.request.args.get('longitude')
        if long:
            long = float(long)
        if (long is None and lat is not None) or (lat is None and long is not None):
            raise ValueError("Specify both longitude and latitude or none")
        if lat and long:
            latlong = cerridwen.LatLong(lat, long)
    except ValueError as e:
        return make_response(e, 400)

    result = collections.OrderedDict()

    result['jd'] = jd
    result['iso_date'] = cerridwen.jd2iso(jd)

    from cerridwen import Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto
    for planet in [Sun(), Moon(), Mercury(), Venus(), Mars(), Jupiter(), Saturn(), Uranus(), Neptune(), Pluto()]:
        result[planet.name().lower()] = math.radians(planet.longitude(jd));

    if latlong:
        result['houses'] = [math.radians(cusp) for cusp in sweph.houses(jd, latlong.lat, latlong.long)[0]]

    import json
    return make_response(json.dumps(result, indent=8), 200)
예제 #18
0
def local_asc_mc(sun_rise1, sun_set1, sun_rise_n1, b_latitude, b_longitude,
                 h_type, t_zone, b_offset):
    date_year_birth = sun_rise1.year
    date_month_birth = sun_rise1.month
    date_day_birth = sun_rise1.day
    date_hour_birth = sun_rise1.hour
    date_min_birth = sun_rise1.minute
    day_diff = (sun_set1 - sun_rise1) / 12
    day_diff1 = (sun_rise_n1 - sun_set1) / 12
    day_divided = 24 + 1  # 60 * 24 /20 extra for storing start of next day, 24 planetary hours in a day
    l_asc_mc = np.zeros(day_divided * 2)
    j = -1
    # print sun_rise1,sun_set1, sun_rise_n1
    for i in range(day_divided):
        # print i, date_year_birth, date_month_birth, date_day_birth, date_hour_birth, date_min_birth, day_diff
        now_julian = swe.julday(
            date_year_birth, date_month_birth, date_day_birth,
            (date_hour_birth + date_min_birth / 60.) - (t_zone - b_offset))
        house_array = (swe.houses(now_julian, b_latitude, b_longitude, h_type))
        j += 1
        l_asc_mc[j] = house_array[1][0]
        j += 1
        l_asc_mc[j] = house_array[1][1]
        if i < 12:
            sun_rise1 += day_diff
            date_year_birth = sun_rise1.year
            date_month_birth = sun_rise1.month
            date_day_birth = sun_rise1.day
            date_hour_birth = sun_rise1.hour
            date_min_birth = sun_rise1.minute
        else:
            sun_set1 += day_diff1
            date_year_birth = sun_set1.year
            date_month_birth = sun_set1.month
            date_day_birth = sun_set1.day
            date_hour_birth = sun_set1.hour
            date_min_birth = sun_set1.minute
            day_diff = day_diff1
    return l_asc_mc
예제 #19
0
def local_asc_mc(sun_rise1, sun_set1, sun_rise_n1, b_latitude, b_longitude, h_type, t_zone, b_offset):
    date_year_birth = sun_rise1.year
    date_month_birth = sun_rise1.month
    date_day_birth = sun_rise1.day
    date_hour_birth = sun_rise1.hour
    date_min_birth = sun_rise1.minute
    day_diff = (sun_set1 - sun_rise1) / 12
    day_diff1 = (sun_rise_n1 - sun_set1) / 12
    day_divided = 24 + 1  # 60 * 24 /20 extra for storing start of next day, 24 planetary hours in a day
    l_asc_mc = np.zeros(day_divided * 2)
    j = -1
    # print sun_rise1,sun_set1, sun_rise_n1
    for i in range(day_divided):
        # print i, date_year_birth, date_month_birth, date_day_birth, date_hour_birth, date_min_birth, day_diff
        now_julian = swe.julday(date_year_birth, date_month_birth, date_day_birth,
                                (date_hour_birth + date_min_birth / 60.) - (t_zone - b_offset))
        house_array = (swe.houses(now_julian, b_latitude, b_longitude, h_type))
        j += 1
        l_asc_mc[j] = house_array[1][0]
        j += 1
        l_asc_mc[j] = house_array[1][1]
        if i < 12:
            sun_rise1 += day_diff
            date_year_birth = sun_rise1.year
            date_month_birth = sun_rise1.month
            date_day_birth = sun_rise1.day
            date_hour_birth = sun_rise1.hour
            date_min_birth = sun_rise1.minute
        else:
            sun_set1 += day_diff1
            date_year_birth = sun_set1.year
            date_month_birth = sun_set1.month
            date_day_birth = sun_set1.day
            date_hour_birth = sun_set1.hour
            date_min_birth = sun_set1.minute
            day_diff = day_diff1
    return l_asc_mc
예제 #20
0
 def longitude(self, jd=None):
     if jd is None: jd = self.jd
     return sweph.houses(jd, self.lat, self.long)[1][0]
예제 #21
0
def get_signs(date, observer, nodes, axes, prefix=None):
    entries = []
    houses = fill_houses(date, observer)
    day = datetime_to_julian(date)
    obliquity = swisseph.calc_ut(day, swisseph.ECL_NUT)[0]

    cusps, asmc = swisseph.houses(day, observer.lat, observer.lng)

    for i in range(10):
        calcs = swisseph.calc_ut(day, i)
        hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
        zm = ActiveZodiacalMeasurement(calcs[0], calcs[1], houses[int(hom - 1)], progress=hom % 1.0)
        if i == swisseph.SUN or i == swisseph.MOON:
            retrograde = "Not Applicable"
        else:
            retrograde = str(calcs[3] < 0)
        planet = Planet(swisseph.get_planet_name(i), prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)
    if nodes:  # add node entries
        calcs = swisseph.calc_ut(day, swisseph.TRUE_NODE)
        hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
        zm = ActiveZodiacalMeasurement(calcs[0], calcs[1], houses[int(hom - 1)], progress=hom % 1.0)
        retrograde = "Always"
        planet = Planet("North Node", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)

        # do some trickery to display the South Node
        reverse = swisseph.degnorm(calcs[0] + 180.0)
        revhouse = (int(hom) + 6) % 12
        # revprogress = 1-hom%1.0
        revprogress = hom % 1.0
        zm = ActiveZodiacalMeasurement(reverse, calcs[1], houses[revhouse - 1], progress=revprogress)
        planet = Planet("South Node", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)
    if axes:
        ascendant = asmc[0]
        descendant = cusps[6]
        mc = asmc[1]
        ic = cusps[3]
        retrograde = "Not a Planet"

        zm = ActiveZodiacalMeasurement(ascendant, 0.0, houses[0], progress=0.0)
        planet = Planet("Ascendant", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)

        zm = ActiveZodiacalMeasurement(descendant, 0.0, houses[6], progress=0.0)
        planet = Planet("Descendant", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)

        zm = ActiveZodiacalMeasurement(mc, 0.0, houses[9], progress=0.0)
        planet = Planet("MC", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)

        zm = ActiveZodiacalMeasurement(ic, 0.0, houses[3], progress=0.0)
        planet = Planet("IC", prefix=prefix, m=zm, retrograde=retrograde)
        entries.append(planet)

        # if stars:
        # print "Todo"
    swisseph.close()
    return houses, entries
예제 #22
0
파일: swiss.py 프로젝트: raininja/openastro
    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()
예제 #23
0
def get_signs(date, observer, nodes, axes, prefix=None):
	entries = []
	houses = fill_houses(date, observer)
	day = datetime_to_julian(date)
	obliquity = swisseph.calc_ut(day, swisseph.ECL_NUT)[0]

	cusps, asmc = swisseph.houses(day, observer.lat, observer.lng)

	for i in range(10):
		calcs = swisseph.calc_ut(day, i)
		hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
		zm = ActiveZodiacalMeasurement(calcs[0], calcs[1], houses[int(hom-1)], progress=hom % 1.0)
		if i == swisseph.SUN or i == swisseph.MOON:
			retrograde = 'Not Applicable'
		else:
			retrograde = str(calcs[3] < 0)
		planet = Planet(swisseph.get_planet_name(i), prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)
	if nodes: #add node entries
		calcs = swisseph.calc_ut(day, swisseph.TRUE_NODE)
		hom = swisseph.house_pos(asmc[2], observer.lat, obliquity, calcs[0], objlat=calcs[1])
		zm = ActiveZodiacalMeasurement(calcs[0], calcs[1], houses[int(hom-1)], progress=hom % 1.0)
		retrograde = "Always"
		planet = Planet("North Node", prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)

		#do some trickery to display the South Node
		reverse = swisseph.degnorm(calcs[0]+180.0)
		revhouse = (int(hom)+6) % 12
		#revprogress = 1-hom%1.0
		revprogress = hom % 1.0
		zm = ActiveZodiacalMeasurement(reverse, calcs[1], houses[revhouse-1], progress=revprogress)
		planet = Planet("South Node", prefix=prefix ,m=zm, retrograde=retrograde)
		entries.append(planet)
	if axes:
		ascendant = asmc[0]
		descendant = cusps[6]
		mc = asmc[1]
		ic = cusps[3]
		retrograde = 'Not a Planet'

		zm = ActiveZodiacalMeasurement(ascendant, 0.0, houses[0], progress=0.0)
		planet = Planet("Ascendant", prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)

		zm = ActiveZodiacalMeasurement(descendant, 0.0, houses[6], progress=0.0)
		planet = Planet("Descendant", prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)

		zm = ActiveZodiacalMeasurement(mc, 0.0, houses[9], progress=0.0)
		planet = Planet("MC", prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)

		zm = ActiveZodiacalMeasurement(ic, 0.0, houses[3], progress=0.0)
		planet = Planet("IC", prefix=prefix, m=zm, retrograde=retrograde)
		entries.append(planet)

	#if stars:
		#print "Todo"
	swisseph.close()
	return houses, entries
예제 #24
0
        iterate = re["stuff"][int(o["what"])]
        if iterate:
            for w in iterate:
                result = swe.calc_ut(t[1], (w + o["offset"]))
                output = {}
                for out in re["stuff"][0]:
                    output[out] = result[out]
                e[o["what"]][w] = output
        else:
            del e[o["what"]]

    # The angles & houses are possible only if given geo location.
    # For that, the latitude and longitude must set - to float, or
    # be able to convert to float (e.g. from string or perhaps int).
    if "geo" in re and "lat" in re["geo"] and "lon" in re["geo"] and re["geo"]["lat"] and re["geo"]["lon"]:
        e["4"], e["3"] = swe.houses(t[1], float(re["geo"]["lat"]), float(re["geo"]["lon"]), str(re["houses"] or "W"))
        # The Whole Sign default wasn't asked for.
        # None (null) or false means no houses wanted.
        if re["houses"]:
            e["4"] += (re["houses"],)
        else:
            del e["4"]
    else:
        del e["3"]
        del e["4"]

    # Zero hash for extra data -- useful with post-processing.
    # Preserves the input request if asked for it (with "re").
    # Possibly also debug data, time metrics, etc.
    if "extra" in re and re["extra"]:
        for (add, conf) in re["extra"].iteritems():
예제 #25
0
파일: ci.py 프로젝트: DarkSide666/AstroWS
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
예제 #26
0
 def calc_houses(self):
     houses, ascmc = swe.houses(self.datetime_julday, self.latitude, self.longitude)
     houses = OrderedDict([(i+1, angle) for i, angle in enumerate(houses)])
     ascmc = Ascmc(*ascmc)
     return houses, ascmc
예제 #27
0
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
예제 #28
0
파일: models.py 프로젝트: balzat/astrology
 def _swe_calc(self, datetime_utc, lat, lon):
     j = julday(datetime_utc)
     angles = swe.houses(j, lat, lon)[0]
     return angles
    anio) + ' ' + str(hora) + ':' + str(min) + '",'
jsonParams += '"sdgmt": "' + stringDateSinGmt
jsonParams += '}'

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]
#print('Oblicuidad: ' + str(posObli[0][0]))

#Se calculan casas previamente para calcular en cada cuerpo con swe.house_pos(...)
h = swe.houses(jd1, float(lat), float(lon), bytes(houseType, encoding="utf-8"))

jsonString = '{'

index = 0

#print(jsonAspets)
#print('Cantidad de Aspectos: '+str(indexAsp))
#Comienza JSON Houses
jsonHouses = '"ph":{'
numHouse = 1
#print('ARMC:' + str(h[0][9]))

for i in h[0]:
    td = decdeg2dms(i)
    gdeg = int(td[0])
예제 #30
0
	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.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 = 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
		



		#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()
예제 #31
0
 def longitude(self, jd=None):
     if jd is None: jd = self.jd
     return sweph.houses(jd, self.lat, self.long)[1][0]
예제 #32
0
    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.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 = 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

        #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()
예제 #33
0
          for out in re["stuff"][0]:
            output[out] = result[out]
          e[o["what"]][w] = output
      else:
        del e[o["what"]]

    # The angles & houses are possible only if given geo location.
    # For that, the latitude and longitude must set - to float, or
    # be able to convert to float (e.g. from string or perhaps int).
    if ("geo" in re
         and "lat" in re["geo"]
         and "lon" in re["geo"]
         and re["geo"]["lat"]
         and re["geo"]["lon"]):
      e["4"], e["3"] = swe.houses(t[1],
                                  float(re["geo"]["lat"]),
                                  float(re["geo"]["lon"]),
                                  str(re["houses"] or "W"))
      # The Whole Sign default wasn't asked for.
      # None (null) or false means no houses wanted.
      if re["houses"]:
        e["4"] += (re["houses"],)
      else:
        del e["4"]
    else:
      del e["3"]
      del e["4"]

    # Zero hash for extra data -- useful with post-processing.
    # Preserves the input request if asked for it (with "re").
    # Possibly also debug data, time metrics, etc.
    if "extra" in re and re["extra"]:
예제 #34
0
파일: swe_data.py 프로젝트: ruthenium/Jing
 def calc(self, lat=0.0, lon=0.0, i_date=DEFAULT_DATE, hsys='P'):
     year = i_date.year
     month = i_date.month
     day = i_date.day
     time = dechourjoin(i_date.hour, i_date.minute, i_date.second)
     
     julday = swe.julday(year, month, day, time)
     geo = swe.set_topo(lat, lon, 0)
     houses, ascmc = swe.houses(julday, lat, lon,  hsys)
     #print houses
     
     for i, body in enumerate(bnames): #日月水金火木土天海冥北交
         result = swe.calc_ut(julday, bnames_se[body])
         degree_ut = result[0]; #和春分点的夹角
         retrograde = bool(result[3] < 0) #是否逆行
         
         for sign in range(12): #行星在12星座的什么位置
             deg_low =  float(sign * 30)
             deg_high = float((sign + 1) * 30)
             if (degree_ut >= deg_low and degree_ut <= deg_high):
                 cibody = { "id"         : bnames_se[body],
                            "name"       : body,
                            "sign"       : sign,
                            "sign_name"  : snames[sign],
                            "degree"     : degree_ut - deg_low, #相对星座头部的夹角
                            "degree_ut"  : degree_ut, #和春分点的夹角
                            "retrograde" : retrograde } #是否逆行
                 self.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,
                             "name"       : "House",
                             "sign"       : sign,
                             "sign_name"  : snames[sign],
                             "degree"     : degree_ut - deg_low,
                             "degree_ut"  : degree_ut }
                 self.cihouses.append(cihouse)
                 
     for index in range(2): #上升点和天顶
         degree_ut = ascmc[index]
         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 }
                 self.ciascmcs.append(ciascmc)
                 cibody  = { "id"         : anames[index],
                             "name"       : anames[index],
                             "sign"       : sign,
                             "sign_name"  : snames[sign],
                             "degree"     : degree_ut - deg_low,
                             "degree_ut"  : degree_ut,
                             "retrograde" : None }
                 self.cibodies.append(cibody)
     
     swe.close()
     
     ciresults = {
         "bodies"  : self.cibodies,
         "houses"  : self.cihouses,
         "ascmcs"  : self.ciascmcs
         }
 
     return ciresults
예제 #35
0
파일: qa.py 프로젝트: musalisa/se
for i in range(1, 12):
    case_aoch_gm.append(decdeg2dm(case_aoch[i], "dm"))
print("\nAOCH case dalla 10°")
print(case_aoch)
#print(case_ar_gm)

#  Ascensioni oblique delle  case
(ZZ, AOHOR) = divmod((ARMC + 90), 360)
print("\nAOHOR")
print(AOHOR)

# Poli delle case
case_poli = []

# Cuspidi delle case sullo zodiaco
case_cuspidi = swe.houses(jut, top_lat, top_long, b'P')[0]
HOR = hor(AOHOR, top_lat)
#HOR = case_cuspidi[0]
print("\nHOR")
print(HOR)
print(decdeg2dm(HOR))
print("\ncuspidi case dalla 10° sullo zodiaco")
print(case_cuspidi)
swe_houses = swe.houses(jut, top_lat, top_long, b'P')

### CARTA Z #################################
#print( "\nCuspidi dei segni")
grado_z = 180 - AOHOR
cx = 350
cy = 350
z1 = 200
예제 #36
0
파일: qa.py 프로젝트: musalisa/se
for i in range(1,12):
	case_aoch_gm.append(decdeg2dm(case_aoch[i],"dm"))
print( "\nAOCH case dalla 10°")
print(case_aoch)
#print(case_ar_gm)

#  Ascensioni oblique delle  case
(ZZ, AOHOR) = divmod((ARMC + 90) , 360)
print( "\nAOHOR")
print( AOHOR)

# Poli delle case
case_poli = []

# Cuspidi delle case sullo zodiaco
case_cuspidi = swe.houses(jut, top_lat, top_long, b'P')[0]
HOR = hor( AOHOR, top_lat)
#HOR = case_cuspidi[0]
print( "\nHOR")
print( HOR )
print(decdeg2dm(HOR))
print( "\ncuspidi case dalla 10° sullo zodiaco")
print(case_cuspidi)
swe_houses = swe.houses(jut, top_lat, top_long, b'P')



### CARTA Z #################################
#print( "\nCuspidi dei segni")
grado_z = 180 - AOHOR
cx = 350
예제 #37
0
#print "uthour",uthour

current_jul_day_UT = swe.julday(year, month, day, uthour, gregflag)

ret_flag_sun = swe.calc_ut(current_jul_day_UT, 0, gregflag)
longitude_sun = ret_flag_sun[0]
print "Sun", longitude_sun
zodiaque = int(longitude_sun // 30) + 1
print "zodiaque", zodiaque

ret_flag_moon = swe.calc_ut(current_jul_day_UT, 1, gregflag)
longitude_moon = ret_flag_moon[0]
print "moon", longitude_moon

cusp = range(13)
cusp = swe.houses(current_jul_day_UT, geolat, geolon, "P")
#print cusp[0]
longitude_asc = cusp[0][0]
print "ascendant", longitude_asc

enjournee = daylight(longitude_sun, longitude_asc)
print "daylight", enjournee

print "-------------------------------------------------------------"
charcodelist = []
charcodelistone = []
#choose the letters of the word-------------------------------------------------------
#12 simples: zodiaque
vowel_codes = [
    "05B0", "05B1", "05B2", "05B3", "05B4", "05B5", "05B6", "05B7", "05B8",
    "05B9", "05BB", "05BC", "05BD", "05BF", "05C1", "05C2", "05C4"