astro.h
上传用户:center1979
上传日期:2022-07-26
资源大小:50633k
文件大小:6k
源码类别:

OpenGL

开发平台:

Visual C++

  1. // astro.h
  2. //
  3. // Copyright (C) 2001-2006 Chris Laurel <claurel@shatters.net>
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  9. #ifndef _CELENGINE_ASTRO_H_
  10. #define _CELENGINE_ASTRO_H_
  11. #include <iostream>
  12. #include <string>
  13. #include <cmath>
  14. #include <celmath/vecmath.h>
  15. #include <celmath/quaternion.h>
  16. #include <celengine/univcoord.h>
  17. #define SOLAR_ABSMAG  4.83f
  18. #define LN_MAG        1.085736
  19. #define LY_PER_PARSEC 3.26167
  20. #define KM_PER_LY     9460730472580.8
  21. // Old incorrect value; will be required for cel:// URL compatibility
  22. // #define OLD_KM_PER_LY     9466411842000.000
  23. #define KM_PER_AU     149597870.7
  24. #define AU_PER_LY     (KM_PER_LY / KM_PER_AU)
  25. namespace astro
  26. {
  27.     class Date
  28.     {
  29.     public:
  30.         Date();
  31.         Date(int Y, int M, int D);
  32.         Date(double);
  33.         enum Format
  34.         {
  35.             Locale          = 0,
  36.             TZName          = 1,
  37.             UTCOffset       = 2,
  38.         };
  39.         const char* toCStr(Format format = Locale) const;
  40.         operator double() const;
  41.         
  42.         static Date systemDate();
  43.     public:
  44.         int year;
  45.         int month;
  46.         int day;
  47.         int hour;
  48.         int minute;
  49.         int wday;           // week day, 0 Sunday to 6 Saturday
  50.         int utc_offset;     // offset from utc in seconds
  51.         std::string tzname; // timezone name
  52.         double seconds;
  53.     };
  54.     bool parseDate(const std::string&, Date&);
  55.     // Time scale conversions
  56.     // UTC - Coordinated Universal Time
  57.     // TAI - International Atomic Time
  58.     // TT  - Terrestrial Time
  59.     // TCB - Barycentric Coordinate Time
  60.     // TDB - Barycentric Dynamical Time
  61.     inline double secsToDays(double s)
  62.     {
  63.         return s * (1.0 / 86400.0);
  64.     }
  65.     inline double daysToSecs(double d)
  66.     {
  67.         return d * 86400.0;
  68.     }
  69.     // Convert to and from UTC dates
  70.     double UTCtoTAI(const astro::Date& utc);
  71.     astro::Date TAItoUTC(double tai);
  72.     double UTCtoTDB(const astro::Date& utc);
  73.     astro::Date TDBtoUTC(double tdb);
  74.     astro::Date TDBtoLocal(double tdb);
  75.     // Convert among uniform time scales
  76.     double TTtoTAI(double tt);
  77.     double TAItoTT(double tai);
  78.     double TTtoTDB(double tt);
  79.     double TDBtoTT(double tdb);
  80.     // Conversions to and from Julian Date UTC--other time systems
  81.     // should be preferred, since UTC Julian Dates aren't defined
  82.     // during leapseconds.
  83.     double JDUTCtoTAI(double utc);
  84.     double TAItoJDUTC(double tai);
  85.     // Magnitude conversions
  86.     float lumToAbsMag(float lum);
  87.     float lumToAppMag(float lum, float lyrs);
  88.     float absMagToLum(float mag);
  89.     float appMagToLum(float mag, float lyrs);
  90.     template<class T> T absToAppMag(T absMag, T lyrs)
  91.     {
  92.         return (T) (absMag - 5 + 5 * log10(lyrs / LY_PER_PARSEC));
  93.     }
  94.     template<class T> T appToAbsMag(T appMag, T lyrs)
  95.     {
  96.         return (T) (appMag + 5 - 5 * log10(lyrs / LY_PER_PARSEC));
  97.     }
  98.     // Distance conversions
  99.     float lightYearsToParsecs(float);
  100.     double lightYearsToParsecs(double);
  101.     float parsecsToLightYears(float);
  102.     double parsecsToLightYears(double);
  103.     float lightYearsToKilometers(float);
  104.     double lightYearsToKilometers(double);
  105.     float kilometersToLightYears(float);
  106.     double kilometersToLightYears(double);
  107.     float lightYearsToAU(float);
  108.     double lightYearsToAU(double);
  109.     // TODO: templatize the rest of the conversion functions
  110.     template<class T> T AUtoLightYears(T au)
  111.     {
  112.         return au / (T) AU_PER_LY;
  113.     }
  114.     float AUtoKilometers(float);
  115.     double AUtoKilometers(double);
  116.     float kilometersToAU(float);
  117.     double kilometersToAU(double);
  118.     float microLightYearsToKilometers(float);
  119.     double microLightYearsToKilometers(double);
  120.     float kilometersToMicroLightYears(float);
  121.     double kilometersToMicroLightYears(double);
  122.     float microLightYearsToAU(float);
  123.     double microLightYearsToAU(double);
  124.     float AUtoMicroLightYears(float);
  125.     double AUtoMicroLightYears(double);
  126.     double secondsToJulianDate(double);
  127.     double julianDateToSeconds(double);
  128.     void decimalToDegMinSec(double angle, int& degrees, int& minutes, double& seconds);
  129.     double degMinSecToDecimal(int degrees, int minutes, double seconds);
  130.     void decimalToHourMinSec(double angle, int& hours, int& minutes, double& seconds);
  131.     float sphereIlluminationFraction(Point3d spherePos,
  132.                                      Point3d viewerPos);
  133.     Point3d heliocentricPosition(const UniversalCoord& universal,
  134.                                  const Point3f& starPosition);
  135.     UniversalCoord universalPosition(const Point3d& heliocentric,
  136.                                      const Point3f& starPosition);
  137.     UniversalCoord universalPosition(const Point3d& heliocentric,
  138.                                      const UniversalCoord& starPosition);
  139.     Point3f equatorialToCelestialCart(float ra, float dec, float distance);
  140.     Point3d equatorialToCelestialCart(double ra, double dec, double distance);
  141.     Quatd eclipticToEquatorial();
  142.     Vec3d eclipticToEquatorial(const Vec3d& v);
  143.     Quatd equatorialToGalactic();
  144.     Vec3d equatorialToGalactic(const Vec3d& v);
  145.     void anomaly(double meanAnomaly, double eccentricity,
  146.                  double& trueAnomaly, double& eccentricAnomaly);
  147.     double meanEclipticObliquity(double jd);
  148.     extern const double J2000;
  149.     extern const double speedOfLight; // km/s
  150.     extern const double G; // gravitational constant
  151.     extern const double SolarMass;
  152.     extern const double EarthMass;
  153.     extern const double LunarMass;
  154.     extern const double J2000Obliquity;
  155.     extern const double SOLAR_IRRADIANCE;
  156.     extern const double SOLAR_POWER;  // in Watts
  157. };
  158. // Convert a date structure to a Julian date
  159. std::ostream& operator<<(std::ostream& s, const astro::Date);
  160. #endif // _CELENGINE_ASTRO_H_