Exemplo n.º 1
0
    def calcBirthSolarArcRev(self, ti):
        y = self.chart.time.year
        m = self.chart.time.month
        d = self.chart.time.day

        yn, mn, dn = util.incrDay(y, m, d)

        ti1 = chart.Time(y, m, d, 0, 0, 0, False, self.chart.time.cal,
                         chart.Time.LOCALMEAN, True, 0, 0, False,
                         self.chart.place, False)
        ti2 = chart.Time(yn, mn, dn, 0, 0, 0, False, self.chart.time.cal,
                         chart.Time.LOCALMEAN, True, 0, 0, False,
                         self.chart.place, False)

        sun1 = planets.Planet(ti1.jd, astrology.SE_SUN, astrology.SEFLG_SWIEPH)
        sun2 = planets.Planet(ti2.jd, astrology.SE_SUN, astrology.SEFLG_SWIEPH)

        diff = 0.0
        if self.options.pdkeyd == primdirs.PrimDirs.BIRTHDAYSOLAREQUATORIALARC:
            diff = sun2.dataEqu[planets.Planet.RAEQU] - sun1.dataEqu[
                planets.Planet.RAEQU]
        elif self.options.pdkeyd == primdirs.PrimDirs.BIRTHDAYSOLARECLIPTICALARC:
            diff = sun2.data[planets.Planet.LONG] - sun1.data[
                planets.Planet.LONG]

        coeff = 1.0
        if diff != 0.0:
            coeff = 1.0 / diff

        return ti / coeff
Exemplo n.º 2
0
	def calc(self, opts):
		ayanamsha = 0.0
		if opts.ayanamsha != 0:
			astrology.swe_set_sid_mode(opts.ayanamsha-1, 0, 0)
			tim = chart.Time(self.year, 1, 1, 0, 0, 0, False, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
			ayanamsha = astrology.swe_get_ayanamsa_ut(tim.jd)

		plsnum = 7
		if opts.transcendental[chart.Chart.TRANSURANUS]:
			plsnum += 1
		if opts.transcendental[chart.Chart.TRANSNEPTUNE]:
			plsnum += 1
		if opts.transcendental[chart.Chart.TRANSPLUTO]:
			plsnum += 1

		#calculating one per day (per hour would be too slow)
		for i in range(plsnum):
			if i != 1:#moon excepted
				y = self.year; m = 1; d = 1
				ar = []
				for num in range(365):
					time = chart.Time(y, m, d, 0, 0, 0, False, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					pl = planets.Planet(time.jd, i, self.flags)
					pos = pl.data[planets.Planet.LONG]
					if opts.ayanamsha != 0:
						pos = util.normalize(pos-ayanamsha)

					ar.append(pos)

					y, m, d = util.incrDay(y, m, d)

				self.posArr.append(ar)
Exemplo n.º 3
0
    def getDateHour(self, tim, place, newmoonorig):
        while True:
            h, m, s = util.decToDeg(tim.time)
            y, mo, d = tim.year, tim.month, tim.day
            h -= 1
            if h < 0:
                h = 23
                y, mo, d = util.decrDay(y, mo, d)
                if y == 0:
                    y = 1
                    tim = chart.Time(y, mo, d, h, m, s, False, tim.cal,
                                     chart.Time.GREENWICH, True, 0, 0, False,
                                     place, False)
                    return True, tim, True

            tim = chart.Time(y, mo, d, h, m, s, False, tim.cal,
                             chart.Time.GREENWICH, True, 0, 0, False, place,
                             False)

            sun = planets.Planet(tim.jd, astrology.SE_SUN, self.flags)
            moon = planets.Planet(tim.jd, astrology.SE_MOON, self.flags)
            lonsun = sun.data[planets.Planet.LONG]
            lonmoon = moon.data[planets.Planet.LONG]

            d, m, s = util.decToDeg(lonsun)
            lonsun = d + m / 60.0 + s / 3600.0
            d, m, s = util.decToDeg(lonmoon)
            lonmoon = d + m / 60.0 + s / 3600.0

            diff = lonmoon - lonsun
            newmoon, ready = self.isNewMoon(diff)
            if newmoon != newmoonorig or ready:
                return True, tim, ready

        return False, tim
Exemplo n.º 4
0
	def onCalc(self, evt):
		#create chart with currdatetime
		time = chart.Time(int(self.year.GetValue()), int(self.month.GetValue()), int(self.day.GetValue()), int(self.hour.GetValue()), int(self.minute.GetValue()), int(self.sec.GetValue()), self.chart.time.bc, self.chart.time.cal, self.chart.time.zt, self.chart.time.plus, self.chart.time.zh, self.chart.time.zm, self.chart.time.daylightsaving, self.chart.place)

		self.horoscope = chart.Chart(self.chart.name, self.chart.male, time, self.chart.place, self.chart.htype, self.chart.notes, self.chart.options)

		#calcpds
		keytxt = ''
		if self.chart.options.pdkeydyn:
			keytxt = mtexts.typeListDyn[self.chart.options.pdkeyd]
		else:
			keytxt = mtexts.typeListStat[self.chart.options.pdkeys]

		txt = mtexts.typeListDirs[self.chart.options.primarydir]+'; '+keytxt+'\n'+mtexts.txts['BusyInfo']

		self.progbar = wx.ProgressDialog(mtexts.txts['Calculating'], txt, parent=self, style=wx.PD_CAN_ABORT|wx.PD_APP_MODAL)
		self.progbar.Fit()

		self.pds = None
		self.pdready = False
		self.abort = primdirs.AbortPD()
		thId = thread.start_new_thread(self.calcPDs, (self.pdrange, self.direction, self))

		self.timer = wx.Timer(self)
		self.Bind(wx.EVT_TIMER, self.OnTimer)
		self.timer.Start(500)
Exemplo n.º 5
0
    def onOK(self, event):
        if (self.Validate() and self.sdate.Validate()):
            if util.checkDate(int(self.year.GetValue()),
                              int(self.month.GetValue()),
                              int(self.day.GetValue())):
                y = int(self.year.GetValue())
                m = int(self.month.GetValue())
                d = int(self.day.GetValue())
                h = int(self.hour.GetValue())
                mi = int(self.minute.GetValue())
                s = int(self.second.GetValue())
                tim = chart.Time(y, m, d, h, mi, s, False,
                                 chart.Time.GREGORIAN, chart.Time.GREENWICH,
                                 True, 0, 0, False, self.radixplace, False)

                if self.radixjd >= tim.jd:
                    dlgm = wx.MessageDialog(
                        None, mtexts.txts['TimeSmallerThanBirthTime'],
                        mtexts.txts['Error'], wx.OK | wx.ICON_EXCLAMATION)
                    dlgm.ShowModal()
                    dlgm.Destroy()
                    return False

                self.Close()
                self.SetReturnCode(wx.ID_OK)
            else:
                dlgm = wx.MessageDialog(
                    None, mtexts.txts['InvalidDate'] + ' (' +
                    self.year.GetValue() + '.' + self.month.GetValue() + '.' +
                    self.day.GetValue() + '.)', mtexts.txts['Error'],
                    wx.OK | wx.ICON_EXCLAMATION)
                dlgm.ShowModal()
                dlgm.Destroy()
	def onDecrDay(self, event):
		h, mi, s = util.decToDeg(self.t)
		yt, mt, dt = util.decrDay(self.y+self.cnt, self.m, self.d)
		tim = chart.Time(yt, mt, dt, h, mi, s, self.chart.time.bc, self.chart.time.cal, self.chart.time.zt, self.chart.time.plus, self.chart.time.zh, self.chart.time.zm, self.chart.time.daylightsaving, self.chart.place, False)
		if tim.jd > self.chart.time.jd:
			y, self.m, self.d = util.decrDay(self.y+self.cnt, self.m, self.d)
			if y != self.y+self.cnt:
				self.cnt -=1
			self.show(self.y, self.m, self.d, self.t, self.cnt)
Exemplo n.º 7
0
 def onDecrYear(self, event):
     h, mi, s = util.decToDeg(self.t)
     tim = chart.Time(self.y + self.cnt - 1, self.m, self.d, h, mi, s,
                      self.chart.time.bc, self.chart.time.cal,
                      self.chart.time.zt, self.chart.time.plus,
                      self.chart.time.zh, self.chart.time.zm,
                      self.chart.time.daylightsaving, self.chart.place,
                      False)
     if tim.jd > self.chart.time.jd:
         self.cnt -= 1
         self.show(self.y, self.m, self.d, self.t, self.cnt)
Exemplo n.º 8
0
 def show(self, y, m, d, h, mi, s):
     time = chart.Time(y, m, d, h, mi, s, self.chart.time.bc,
                       self.chart.time.cal, self.chart.time.zt,
                       self.chart.time.plus, self.chart.time.zh,
                       self.chart.time.zm, self.chart.time.daylightsaving,
                       self.chart.place, False)
     chrt = chart.Chart(self.chart.name, self.chart.male, time,
                        self.chart.place, chart.Chart.TRANSIT, '',
                        self.options, False)
     self.parent.change(chrt, self.caption)
     del self.chart
     self.chart = chrt
Exemplo n.º 9
0
	def onDecr(self, event):
		self.age -= 1
		self.daytxt.SetValue(str(self.age))
		direct = True
		age = self.age
		if self.age < 0:
			age *= -1
			direct = False
		sdir = secdir.SecDir(self.chart, age, direct, self.soltime)
		y, m, d, hour, minute, second = sdir.compute()

		time = chart.Time(y, m, d, hour, minute, second, False, self.chart.time.cal, self.zt, self.chart.time.plus, self.zh, self.zm, False, self.chart.place, False)
		chrt = chart.Chart(self.chart.name, self.chart.male, time, self.chart.place, chart.Chart.TRANSIT, '', self.options, False)
		self.parent.change(chrt, self.caption)
Exemplo n.º 10
0
    def change(self, chrt, y, m, d, ho, mi, se, pdtypetxt, pdkeytxt, txtdir,
               da):
        self.chartPDs = chrt
        self.w.chartPDs = chrt

        tim = chart.Time(y, m, d, ho, mi, se, self.chartRadix.time.bc,
                         chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0,
                         0, False, self.chartRadix.place, False)
        chrtIng = chart.Chart(self.chartRadix.name, self.chartRadix.male, tim,
                              self.chartRadix.place, chart.Chart.PDINCHART, '',
                              self.options, False)
        self.chartIngress = chrtIng
        self.w.chartIngress = chrtIng
        self.w.drawBkg()
        self.w.Refresh()

        #Update Caption
        txt = pdtypetxt + ' ' + pdkeytxt + ' ' + txtdir + ' ' + str(
            y) + '.' + str(m).zfill(2) + '.' + str(d).zfill(2) + ' ' + str(
                ho).zfill(2) + ':' + str(mi).zfill(2) + ':' + str(se).zfill(
                    2) + '  ' + str(da)
        self.SetTitle(txt)
Exemplo n.º 11
0
    def calcTrueSolarArcRegressive(self, arc):
        LIM = 120.0  #arbitrary value
        y = self.chart.time.year
        m = self.chart.time.month
        d = self.chart.time.day

        h, mi, s = util.decToDeg(self.chart.time.time)
        tt = 0.0

        #Subtract arc from Suns's pos (long or ra)
        prSunPos = self.chart.planets.planets[astrology.SE_SUN].dataEqu[
            planets.Planet.RAEQU]
        if self.options.pdkeyd == primdirs.PrimDirs.TRUESOLARECLIPTICALARC:
            prSunPos = self.chart.planets.planets[astrology.SE_SUN].data[
                planets.Planet.LONG]

        prSunPosEnd = prSunPos - arc
        transition = False  #Pisces-Aries
        if prSunPosEnd < 0.0:
            prSunPos += 360.0
            prSunPosEnd += 360.0
            transition = True

#		Find day in ephemeris
        while (prSunPos >= prSunPosEnd):
            y, m, d = util.decrDay(y, m, d)
            ti = chart.Time(y, m, d, 0, 0, 0, False, self.chart.time.cal,
                            chart.Time.GREENWICH, True, 0, 0, False,
                            self.chart.place, False)
            sun = planets.Planet(ti.jd, astrology.SE_SUN,
                                 astrology.SEFLG_SWIEPH)

            pos = sun.dataEqu[planets.Planet.RAEQU]
            if self.options.pdkeyd == primdirs.PrimDirs.TRUESOLARECLIPTICALARC:
                pos = sun.data[planets.Planet.LONG]
            if transition and pos < LIM:
                pos += 360.0
            prSunPos = pos

        if (prSunPos != prSunPosEnd):
            if transition:
                prSunPosEnd -= 360.0

            trlon = 0.0
            if self.options.pdkeyd == primdirs.PrimDirs.TRUESOLARECLIPTICALARC:
                trlon = prSunPosEnd
            else:
                #to Longitude...
                trlon = util.ra2ecl(prSunPosEnd, self.chart.obl[0])

            trans = transits.Transits()
            trans.day(y, m, d, self.chart, astrology.SE_SUN, trlon)

            if len(trans.transits) > 0:
                tt = trans.transits[0].time
        else:
            #the time is midnight
            tt = 0.0

        #difference
        th, tm, ts = util.decToDeg(tt)
        d1 = datetime.datetime(y, m, d, th, tm, ts)  #in GMT
        d2 = datetime.datetime(self.chart.time.year, self.chart.time.month,
                               self.chart.time.day, h, mi, s)  #in GMT
        diff = d2 - d1
        ddays = diff.days
        dtime = diff.seconds / 3600.0
        #dtime to days
        dtimeindays = dtime / 24.0

        tt = ddays + dtimeindays

        return tt
Exemplo n.º 12
0
    def onShowBtn(self, event):
        if (self.Validate() and self.sdate.Validate()):
            if util.checkDate(int(self.year.GetValue()),
                              int(self.month.GetValue()),
                              int(self.day.GetValue())):
                arc = 0.0
                date = 2000.5

                direct = self.positiverb.GetValue()
                if (self.arcrb.GetValue()):
                    arc = float(self.da.GetValue())
                    jd, age = self.calcTime(arc, direct)
                    y, m, d, h = astrology.swe_revjul(jd, 1)
                    ho, mi, se = util.decToDeg(h)
                    self.year.SetValue(str(y))
                    self.month.SetValue(str(m))
                    self.day.SetValue(str(d))

                    self.hour.SetValue(str(ho))
                    self.minute.SetValue(str(mi))
                    self.second.SetValue(str(se))
                else:
                    y = int(self.year.GetValue())
                    m = int(self.month.GetValue())
                    d = int(self.day.GetValue())
                    ho = int(self.hour.GetValue())
                    mi = int(self.minute.GetValue())
                    se = int(self.second.GetValue())
                    t = float(ho) + float(mi) / 60.0 + float(se) / 3600.0
                    calflag = astrology.SE_GREG_CAL
                    if self.chart.time.cal == chart.Time.JULIAN:
                        calflag = astrology.SE_JUL_CAL
                    jd = astrology.swe_julday(y, m, d, t, calflag)
                    if self.chart.time.jd >= jd:
                        dlgm = wx.MessageDialog(
                            None, mtexts.txts['TimeSmallerThanBirthTime'],
                            mtexts.txts['Error'], wx.OK | wx.ICON_EXCLAMATION)
                        dlgm.ShowModal()
                        dlgm.Destroy()
                        return False

                    arc = self.calcArc(jd, direct)
                    self.da.SetValue(str(arc))

                da = arc
                if not direct:
                    da *= -1

                pdinch = pdsinchart.PDsInChart(
                    self.chart, da)  #self.yz, mz, dz, tz ==> chart
                pdh, pdm, pds = util.decToDeg(pdinch.tz)
                cal = chart.Time.GREGORIAN
                if self.chart.time.cal == chart.Time.JULIAN:
                    cal = chart.Time.JULIAN
                tim = chart.Time(pdinch.yz, pdinch.mz, pdinch.dz, pdh, pdm,
                                 pds, self.chart.time.bc, cal,
                                 chart.Time.GREENWICH, True, 0, 0, False,
                                 self.chart.place, False)

                if not self.terrestrial:
                    if self.options.pdincharttyp == pdsinchartdlgopts.PDsInChartsDlgOpts.FROMMUNDANEPOS:
                        pdchart = chart.Chart(self.chart.name, self.chart.male,
                                              tim, self.chart.place,
                                              chart.Chart.PDINCHART, '',
                                              self.options,
                                              False)  #, proftype, nolat)
                        pdchartpls = chart.Chart(self.chart.name,
                                                 self.chart.male,
                                                 self.chart.time,
                                                 self.chart.place,
                                                 chart.Chart.PDINCHART, '',
                                                 self.options, False)

                        #modify planets ...
                        if self.options.primarydir == primdirs.PrimDirs.PLACIDIANSEMIARC or self.options.primarydir == primdirs.PrimDirs.PLACIDIANUNDERTHEPOLE:
                            pdchart.planets.calcMundaneProfPos(
                                pdchart.houses.ascmc2,
                                pdchartpls.planets.planets,
                                self.chart.place.lat, self.chart.obl[0])
                        else:
                            pdchart.houses = houses.Houses(
                                tim.jd, 0, pdchart.place.lat,
                                pdchart.place.lon, 'R', pdchart.obl[0],
                                self.options.ayanamsha, pdchart.ayanamsha)
                            pdchart.planets.calcRegioPDsInChartsPos(
                                pdchart.houses.ascmc2,
                                pdchartpls.planets.planets,
                                self.chart.place.lat, self.chart.obl[0])

                        #modify lof
                        if self.options.primarydir == primdirs.PrimDirs.PLACIDIANSEMIARC or self.options.primarydir == primdirs.PrimDirs.PLACIDIANUNDERTHEPOLE:
                            pdchart.fortune.calcMundaneProfPos(
                                pdchart.houses.ascmc2, pdchartpls.fortune,
                                self.chart.place.lat, self.chart.obl[0])
                        else:
                            pdchart.fortune.calcRegioPDsInChartsPos(
                                pdchart.houses.ascmc2, pdchartpls.fortune,
                                self.chart.place.lat, self.chart.obl[0])

                    elif self.options.pdincharttyp == pdsinchartdlgopts.PDsInChartsDlgOpts.FROMZODIACALPOS:
                        pdchart = chart.Chart(self.chart.name, self.chart.male,
                                              tim, self.chart.place,
                                              chart.Chart.PDINCHART, '',
                                              self.options, False,
                                              chart.Chart.YEAR, True)

                        pdchartpls = chart.Chart(
                            self.chart.name, self.chart.male, self.chart.time,
                            self.chart.place, chart.Chart.PDINCHART, '',
                            self.options, False, chart.Chart.YEAR, True)
                        #modify planets ...
                        if self.options.primarydir == primdirs.PrimDirs.PLACIDIANSEMIARC or self.options.primarydir == primdirs.PrimDirs.PLACIDIANUNDERTHEPOLE:
                            pdchart.planets.calcMundaneProfPos(
                                pdchart.houses.ascmc2,
                                pdchartpls.planets.planets,
                                self.chart.place.lat, self.chart.obl[0])
                        else:
                            pdchart.houses = houses.Houses(
                                tim.jd, 0, pdchart.place.lat,
                                pdchart.place.lon, 'R', pdchart.obl[0],
                                self.options.ayanamsha, pdchart.ayanamsha)
                            pdchart.planets.calcRegioPDsInChartsPos(
                                pdchart.houses.ascmc2,
                                pdchartpls.planets.planets,
                                self.chart.place.lat, self.chart.obl[0])

                        #modify lof
                        if self.options.primarydir == primdirs.PrimDirs.PLACIDIANSEMIARC or self.options.primarydir == primdirs.PrimDirs.PLACIDIANUNDERTHEPOLE:
                            pdchart.fortune.calcMundaneProfPos(
                                pdchart.houses.ascmc2, pdchartpls.fortune,
                                self.chart.place.lat, self.chart.obl[0])
                        else:
                            pdchart.fortune.calcRegioPDsInChartsPos(
                                pdchart.houses.ascmc2, pdchartpls.fortune,
                                self.chart.place.lat, self.chart.obl[0])

                    else:  #Full Astronomical Procedure
                        pdchart = chart.Chart(self.chart.name, self.chart.male,
                                              tim, self.chart.place,
                                              chart.Chart.PDINCHART, '',
                                              self.options,
                                              False)  #, proftype, nolat)

                        pdchartpls = chart.Chart(self.chart.name,
                                                 self.chart.male,
                                                 self.chart.time,
                                                 self.chart.place,
                                                 chart.Chart.PDINCHART, '',
                                                 self.options, False)

                        pdpls = pdchartpls.planets.planets
                        if self.options.pdinchartsecmotion:
                            pdpls = pdchart.planets.planets

                        raequasc, declequasc, dist = astrology.swe_cotrans(
                            pdchart.houses.ascmc[houses.Houses.EQUASC], 0.0,
                            1.0, -self.chart.obl[0])
                        pdchart.planets.calcFullAstronomicalProc(
                            da, self.chart.obl[0], pdpls, pdchart.place.lat,
                            pdchart.houses.ascmc2, raequasc)  #planets
                        pdchart.fortune.calcFullAstronomicalProc(
                            pdchartpls.fortune, da, self.chart.obl[0])
                else:
                    if self.options.pdinchartterrsecmotion:
                        pdchart = chart.Chart(self.chart.name, self.chart.male,
                                              tim, self.chart.place,
                                              chart.Chart.PDINCHART, '',
                                              self.options,
                                              False)  #, proftype, nolat)
                    else:
                        pdchart = chart.Chart(self.chart.name, self.chart.male,
                                              self.chart.time,
                                              self.chart.place,
                                              chart.Chart.PDINCHART, '',
                                              self.options,
                                              False)  #, proftype, nolat)
                        raequasc, declequasc, dist = astrology.swe_cotrans(
                            pdchart.houses.ascmc[houses.Houses.EQUASC], 0.0,
                            1.0, -self.chart.obl[0])
                        pdchart.planets.calcMundaneWithoutSM(
                            da, self.chart.obl[0], pdchart.place.lat,
                            pdchart.houses.ascmc2, raequasc)

                    pdchart.fortune.recalcForMundaneChart(
                        self.chart.fortune.fortune[fortune.Fortune.LON],
                        self.chart.fortune.fortune[fortune.Fortune.LAT],
                        self.chart.fortune.fortune[fortune.Fortune.RA],
                        self.chart.fortune.fortune[fortune.Fortune.DECL],
                        pdchart.houses.ascmc2, pdchart.raequasc,
                        pdchart.obl[0], pdchart.place.lat)

                keytxt = mtexts.typeListDyn[self.options.pdkeyd]
                if not self.options.pdkeydyn:
                    keytxt = mtexts.typeListStat[self.options.pdkeys]
                txtdir = mtexts.txts['D']
                if not direct:
                    txtdir = mtexts.txts['C']

                self.parent.change(
                    pdchart, y, m, d, ho, mi, se,
                    mtexts.typeListDirs[self.options.primarydir], keytxt,
                    txtdir, math.fabs(da))
            else:
                dlgm = wx.MessageDialog(
                    None, mtexts.txts['InvalidDate'] + ' (' +
                    self.year.GetValue() + '.' + self.month.GetValue() + '.' +
                    self.day.GetValue() + '.)', mtexts.txts['Error'],
                    wx.OK | wx.ICON_EXCLAMATION)
                dlgm.ShowModal()
                dlgm.Destroy()
Exemplo n.º 13
0
	def find(self):
		rnge = 3000
		checker = rangechecker.RangeChecker()
		if checker.isExtended():
			rnge = 5000

		y = 1973 #year doesn't matter
		m = 3
		d = 21
		for i in range(int(self.ftdata[astrology.SE_SUN][findtimedlg.FindTimeDlg.LON])):
			y, m ,d = util.incrDay(y, m ,d)

		#Because the Sun's velocity is not exactly one degree per day. It is variable. The targetdate (from Sun's long) won't exactly be in the middle of the range
		tim = chart.Time(y, m, d, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
		tmpSun = planets.Planet(tim.jd, astrology.SE_SUN, self.flags)
		lonSun = tmpSun.data[planets.Planet.LONG]
		lontofind = self.ftdata[astrology.SE_SUN][findtimedlg.FindTimeDlg.LON]

		if lonSun > FindTime.CIRCLE-FindTime.OFFSET and lontofind < FindTime.OFFSET:
			lontofind += FindTime.CIRCLE
		if lontofind > FindTime.CIRCLE-FindTime.OFFSET and lonSun < FindTime.OFFSET:
			lonSun += FindTime.CIRCLE

		diff = int(math.fabs(int(lonSun)-int(lontofind)))
		if int(self.ftdata[astrology.SE_SUN][findtimedlg.FindTimeDlg.LON]) < int(lonSun):
			for i in range(diff):
				y, m, d = util.decrDay(y, m, d)
		else:
			for i in range(diff):
				y, m, d = util.incrDay(y, m, d)

		ybeg, mbeg, dbeg = y, m, d
		yend, mend, dend = y, m, d
		DATEOFFS = 7
		#adjust range
		for i in range(DATEOFFS):
			ybeg, mbeg, dbeg = util.decrDay(ybeg, mbeg ,dbeg)
			yend, mend, dend = util.incrDay(yend, mend ,dend)

		tfnd = (1, 1, 1, 1.0, 1.0)
		y = 1; m = mbeg; d = dbeg
		while (y < rnge):
			if self.abort.abort:
				return

			fnd = self.day(y, m, d, astrology.SE_SUN, self.ftdata[astrology.SE_SUN][findtimedlg.FindTimeDlg.LON])
			if fnd != None:
				found = True
				#The order of the search is chaldean (i.e. acc. to speed)
				for i in range(FindTime.TRADPL_NUM):
					j = self.mapChaldeanToModern(i)
					if j != 3: #SUN
						tfnd = self.day(y, m, d, j, self.ftdata[j][findtimedlg.FindTimeDlg.LON])
						if tfnd == None:
							found = False
							break

				if found:
					#update wnd
					evt = findtimedlg.FTDataReadyEvent(attr1=tfnd)
					wx.PostEvent(self.win, evt)

			yt = y
			if m == mend and d == dend:
				y += 1
				m = mbeg
				d = dbeg
			else:
				y, m, d = util.incrDay(y, m, d)

			if yt != y and yt%50 == 0:
				evt = findtimedlg.FTYearEvent(attr1=yt)
				wx.PostEvent(self.win, evt)
Exemplo n.º 14
0
	def get(self, planet1, planet2, time1, lon, pl, unit):
		if self.check(planet1, planet2, lon):
			fr = 0
			to = 60
			if unit == FindTime.HOUR:
				fr = 0
				to = 24

			for val in range(fr, to):
				time = None
				if unit == FindTime.HOUR:
					time1 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, val, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					time2 = None
					if val+1 < to:
						time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, val+1, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					else:
						y, m, d = util.incrDay(int(math.fabs(time1.year)), time1.month, time1.day)
						time2 = chart.Time(y, m, d, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
				elif unit == FindTime.MINUTE:
					time1 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour, val, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					time2 = None
					if val+1 < to:
						time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour, val+1, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					else:
						if time1.hour+1 < 24:
							time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour+1, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
						else:
							y, m, d = util.incrDay(int(math.fabs(time1.year)), time1.month, time1.day)
							time2 = chart.Time(y, m, d, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
				elif unit == FindTime.SECOND:
					time1 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour, time1.minute, val, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					time2 = None
					if val+1 < to:
						time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour, time1.minute, val+1, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
					else:
						if time1.minute+1 < 60:
							time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour, time1.minute+1, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
						else:
							if time1.hour+1 < 24:
								time2 = chart.Time(int(math.fabs(time1.year)), time1.month, time1.day, time1.hour+1, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
							else:
								y, m, d = util.incrDay(int(math.fabs(time1.year)), time1.month, time1.day)
								time2 = chart.Time(y, m, d, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
				else:
#					print 'unit > SECOND'
					return None	

				planet1 = planets.Planet(time1.jd, pl, self.flags)
				planet2 = planets.Planet(time2.jd, pl, self.flags)
	
				if self.check(planet1, planet2, lon):
					un = FindTime.OVER
					if unit == FindTime.HOUR:
						un = FindTime.MINUTE
					if unit == FindTime.MINUTE:
						un = FindTime.SECOND
				
					if un != FindTime.OVER:
						return self.get(planet1, planet2, time1, lon, pl, un)
					else:
						if self.ftdatause[findtimedlg.FindTimeDlg.RET]:
							#check retrograde
							if ((planet1.data[planets.Planet.SPLON] <= 0.0 and self.ftdata[pl][findtimedlg.FindTimeDlg.RETR]) or (planet1.data[planets.Planet.SPLON] > 0.0 and not self.ftdata[pl][findtimedlg.FindTimeDlg.RETR])):
								return (int(math.fabs(time1.year)), time1.month, time1.day, time1.time, time1.jd)

							return None

						return (int(math.fabs(time1.year)), time1.month, time1.day, time1.time, time1.jd)
				
		return None
Exemplo n.º 15
0
	def day(self, year, month, day, planet, pos):
		y, m, d = util.incrDay(year, month, day)
		time1 = chart.Time(year, month, day, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
		time2 = chart.Time(y, m, d, 0, 0, 0, self.bc, chart.Time.GREGORIAN, chart.Time.GREENWICH, True, 0, 0, False, None, False)
				
		return self.cycleplanet(time1, time2, planet, pos)