예제 #1
0
        public static float ephem_positionOfPlanet(planet_positions rec, int planet)
        {
            float pos = 0;

            switch (planet)
            {
            case SUN: pos = rec.sun; break;

            case MOON: pos = rec.moon; break;

            case MERCURY: pos = rec.mercury; break;

            case VENUS: pos = rec.venus; break;

            case MARS: pos = rec.mars; break;

            case JUPITER: pos = rec.jupiter; break;

            case SATURN: pos = rec.saturn; break;

            case URANUS: pos = rec.uranus; break;

            case NEPTUNE: pos = rec.neptune; break;

            case PLUTO: pos = rec.pluto; break;

            case NODE: pos = rec.node; break;

            case ASCENDANT: pos = rec.ascendant; break;

            case MEDIUM_COELI: pos = rec.mediumCoeli; break;
            }
            return(pos);
        }
예제 #2
0
        public static void ephem_setPosition(ref planet_positions rec, int planet, float pos)
        {
            switch (planet)
            {
            case SUN: rec.sun = pos; break;

            case MOON: rec.moon = pos; break;

            case MERCURY: rec.mercury = pos; break;

            case VENUS: rec.venus = pos; break;

            case MARS: rec.mars = pos; break;

            case JUPITER: rec.jupiter = pos; break;

            case SATURN: rec.saturn = pos; break;

            case URANUS: rec.uranus = pos; break;

            case NEPTUNE: rec.neptune = pos; break;

            case PLUTO: rec.pluto = pos; break;

            case NODE: rec.node = pos; break;

            case ASCENDANT: rec.ascendant = pos; break;

            case MEDIUM_COELI: rec.mediumCoeli = pos; break;
            }
        }
예제 #3
0
        public static planet_positions calculateMean(planet_positions rec1, planet_positions rec2, float percentAfterRec1)
        {
            planet_positions res = new planet_positions();

            res.ascendant       = 0.0f; // NullHouses - Houses corresponds to signs
            res.mediumCoeli     = 270.0f;
            res.gmt0sideralTime = rec1.gmt0sideralTime;

            res.weekday = rec1.weekday;

            if (rec1.sideralTime > rec2.sideralTime)
            {
                float sidTime = calculateMeanFloat(rec1.sideralTime, rec2.sideralTime + 24.0f, percentAfterRec1);
                if (sidTime >= 24.0)
                {
                    res.sideralTime = sidTime - 24;
                }
                else
                {
                    res.sideralTime = sidTime;
                }
            }
            else
            {
                res.sideralTime = calculateMeanFloat(rec1.sideralTime, rec2.sideralTime, percentAfterRec1);
            }

            /*if ((rec1.Gmt != 0) || (rec2.Gmt != 0))
             * {
             *      throw new AstroException("Cannot calculate from records not based on GMT 0:00");
             * }*/
            /*res.Day = rec1.Day;
             * res.Month = rec1.Month;
             * res.Year = rec1.Year;*/


            res.sun     = calculateMeanFloat(rec1.sun, rec2.sun, percentAfterRec1);
            res.moon    = calculateMeanFloat(rec1.moon, rec2.moon, percentAfterRec1);
            res.mercury = calculateMeanFloat(rec1.mercury, rec2.mercury, percentAfterRec1);
            res.venus   = calculateMeanFloat(rec1.venus, rec2.venus, percentAfterRec1);
            res.mars    = calculateMeanFloat(rec1.mars, rec2.mars, percentAfterRec1);
            res.jupiter = calculateMeanFloat(rec1.jupiter, rec2.jupiter, percentAfterRec1);
            res.saturn  = calculateMeanFloat(rec1.saturn, rec2.saturn, percentAfterRec1);
            res.uranus  = calculateMeanFloat(rec1.uranus, rec2.uranus, percentAfterRec1);
            res.neptune = calculateMeanFloat(rec1.neptune, rec2.neptune, percentAfterRec1);
            res.pluto   = calculateMeanFloat(rec1.pluto, rec2.pluto, percentAfterRec1);
            res.node    = calculateMeanFloat(rec1.node, rec2.node, percentAfterRec1);

            return(res);
        }
예제 #4
0
        public static planet_positions ephem_calculateRecForGmt(int year, int dayNo, float gmtHour, ref EPHEM_YEAR preLoadedYear,
                                                                int verifyMonth = 0, int verifyDay = 0)
        {
            EPHEM_YEAR y1;
            EPHEM_REC  rec1;
            EPHEM_REC  rec2;

            if (preLoadedYear != null && preLoadedYear.days[0].year == year)
            {
                y1 = preLoadedYear;
            }
            else
            {
                y1            = ephem_readYear(year);
                preLoadedYear = y1;
            }
            if (dayNo == 365)
            {
                EPHEM_YEAR y2;
                y2   = ephem_readYear(year + 1);
                rec1 = y1.days[365];
                rec2 = y2.days[0];
            }
            else
            {
                rec1 = y1.days[dayNo];
                rec2 = y1.days[dayNo + 1];
            }
            if (verifyMonth != 0 && rec1.month != verifyMonth)
            {
                return(NULLpositions());
            }
            if (verifyDay != 0 && rec1.day != verifyDay)
            {
                return(NULLpositions());
            }
            planet_positions ret = calculateMean(positionsForEphemRec(rec1), positionsForEphemRec(rec2), (gmtHour * 100) / 24);

            ret.gmtTime = gmtHour;
            return(ret);
        }
예제 #5
0
        public static planet_positions NULLpositions()
        {
            planet_positions pos = new planet_positions();

            pos.sideralTime = 0;
            pos.gmtTime     = 0.0f;
            pos.weekday     = 0;
            pos.sun         = 0;
            pos.moon        = 0;
            pos.mercury     = 0;
            pos.venus       = 0;
            pos.mars        = 0;
            pos.jupiter     = 0;
            pos.saturn      = 0;
            pos.uranus      = 0;
            pos.neptune     = 0;
            pos.pluto       = 0;
            pos.node        = 0;
            pos.ascendant   = 0.0f;
            pos.mediumCoeli = 0.0f;
            return(pos);
        }
예제 #6
0
        public static planet_positions Duplicate(planet_positions pp)
        {
            planet_positions ret = new planet_positions();

            ret.weekday         = pp.weekday;
            ret.sideralTime     = pp.sideralTime;
            ret.gmt0sideralTime = pp.gmt0sideralTime;
            ret.gmtTime         = pp.gmtTime;
            ret.sun             = pp.sun;
            ret.moon            = pp.moon;
            ret.mercury         = pp.mercury;
            ret.venus           = pp.venus;
            ret.mars            = pp.mars;
            ret.jupiter         = pp.jupiter;
            ret.saturn          = pp.saturn;
            ret.uranus          = pp.uranus;
            ret.neptune         = pp.neptune;
            ret.pluto           = pp.pluto;
            ret.node            = pp.node;
            ret.ascendant       = pp.ascendant;
            ret.mediumCoeli     = pp.mediumCoeli;
            return(ret);
        }
예제 #7
0
        public static planet_positions positionsForEphemRec(EPHEM_REC rec)
        {
            planet_positions pos = new planet_positions();

            pos.sideralTime     = hmsToHours(rec.sid_h, rec.sid_m, rec.sid_s);
            pos.gmt0sideralTime = pos.sideralTime;
            pos.gmtTime         = 0.0f;
            pos.weekday         = rec.weekday;
            pos.sun             = rec.sun / 100.0f;
            pos.moon            = rec.moon / 100.0f;
            pos.mercury         = rec.mercury / 100.0f;
            pos.venus           = rec.venus / 100.0f;
            pos.mars            = rec.mars / 100.0f;
            pos.jupiter         = rec.jupiter / 100.0f;
            pos.saturn          = rec.saturn / 100.0f;
            pos.uranus          = rec.uranus / 100.0f;
            pos.neptune         = rec.neptune / 100.0f;
            pos.pluto           = rec.pluto / 100.0f;
            pos.node            = rec.node / 100.0f;
            pos.ascendant       = 0.0f;
            pos.mediumCoeli     = 270.0f;
            return(pos);
        }