AstroCommon.h

Go to the documentation of this file.

#ifndef GlobeEngine_AstroCommon_h
#define GlobeEngine_AstroCommon_h

#include "OpenGL_Includes.h"
#include <vmmlib/vector.hpp>


namespace geAstro {

    enum UniverseSelectionType { NONE = 0, SYSTEMS, SUNS, PLANETS, MOONS, SMALLBODIES, ORBITS };

    static UniverseSelectionType getUniversSelectionTypeFromInt(int _id) {
        switch (_id) {
            case 0: {return UniverseSelectionType::NONE; break; }
            case 1: {return UniverseSelectionType::SYSTEMS; break; }
            case 2: {return UniverseSelectionType::SUNS; break; }
            case 3: {return UniverseSelectionType::PLANETS; break; }
            case 4: {return UniverseSelectionType::MOONS; break; }
            case 5: {return UniverseSelectionType::SMALLBODIES; break; }
            case 6: {return UniverseSelectionType::ORBITS; break; }
            default: {return UniverseSelectionType::NONE; break; }
        }
    }

    struct SystemSelection
    {
        UniverseSelectionType selectionType;
        int selectionIndex;

        SystemSelection() {
            selectionType = NONE;
            selectionIndex = -1;
        }

        SystemSelection(UniverseSelectionType _selectionType, int _selectionIndex) :
            selectionType(_selectionType), selectionIndex(_selectionIndex)
        {}
    };

    struct UniverseSelection
    {
        int systemInFocus;
        UniverseSelectionType selectionType;
        int selectionIndex;

        UniverseSelection() {
            systemInFocus = -1;
            selectionType = NONE;
            selectionIndex = -1;
        }

        UniverseSelection(int _systemInFocus, UniverseSelectionType _selectionType, int _selectionIndex) :
            systemInFocus(_systemInFocus), selectionType(_selectionType), selectionIndex(_selectionIndex)
        {}
    };

    static vmml::Vector3i getGregorianDate(double _currentJulianDate){

        //convert julian day number to gregorian date
        int a = _currentJulianDate + 32044;
        int b = (4 * a + 3) / 146097;
        int c = a - (b * 146097) / 4;

        int d = (4 * c + 3) / 1461;
        int e = c - (1461 * d) / 4;
        int m = (5 * e + 2) / 153;

        int day = e - (153 * m + 2) / 5 + 1;
        int month = m + 3 - 12 * (m / 10);
        int year = b * 100 + d - 4800 + m / 10;

        return vmml::Vector3i(day, month, year);
    }

    //source: https://en.wikipedia.org/wiki/Astronomical_unit
    const double KMperAU = 149597870.7;
    const double AUperKm = 0.00000000668459; //source: google
    const double solarRadiusInAU = 0.0046491; //source: https://en.wikipedia.org/wiki/Solar_radius
    const double jupiterRadiusInAU = 0.0004673; //source: https://en.wikipedia.org/wiki/Jupiter
    const double solarMass = 1.989e30; //in kg (source google) 
    const double jupiterMass = 1.898e27; //in kg. source: google

    const double hoursToDegreesFactor = 15.0;
    const double minutesToDegreesFactor = 1.0 / 4.0;
    const double secondsToDegreesFactor = 1.0 / 240.0;

    const double arcMinutesToDegreesFactor = 1.0 / 60.0;
    const double arcSecondsToDegreesFactor = 1.0 / 3600.0;



    static double getAUfromParsec(double distanceInParsec){
        return distanceInParsec * 206264.806247; //exactly 648000/pi source: https://en.wikipedia.org/wiki/Parsec
    }

    static double getKmFromAU(double rad){
        return rad * KMperAU;
    }

    static double getAUFromKm(double rad){
        return rad * AUperKm;
    }

    static double getAUFromSolarRadii(double rad){
        return rad * solarRadiusInAU;
    }
    
    static double getAUFromJupiterRadii(double rad){
        return rad * jupiterRadiusInAU;
    }

    static double getKgFromSolarMasses(double _mass){
        return _mass * solarMass;
    }

    static double getKgFromJupiterMasses(double _mass){
        return _mass * jupiterMass;
    }

    static double getTonnesFromKg(double _mass){
        return _mass * 0.001;
    }

    static double getDegreesFromHours(double _hours){
        return _hours * hoursToDegreesFactor;
    }

    static double getDegreesFromMinutes(double _minutes){
        return _minutes * minutesToDegreesFactor;
    }
    
    static double getDegreesFromSeconds(double _seconds){
        return _seconds * secondsToDegreesFactor;
    }

    static double getDegreesFromArcminutes(double _arcminutes){
        return _arcminutes * arcMinutesToDegreesFactor;
    }

    static double getDegreesFromArcseconds(double _arcseconds){
        return _arcseconds * arcSecondsToDegreesFactor;
    }

    static double getRightAscensionFromString(std::string rightAscensionAsString){
        double rightAscensionHours = atof(rightAscensionAsString.substr(0, 2).c_str());
        double rightAscensionMinutes = atof(rightAscensionAsString.substr(3, 2).c_str());
        double rightAscensionSeconds = atof(rightAscensionAsString.substr(6, 2).c_str());
        double rightAscension = geAstro::getDegreesFromHours(rightAscensionHours) + geAstro::getDegreesFromMinutes(rightAscensionMinutes)
            + geAstro::getDegreesFromSeconds(rightAscensionSeconds);

        return rightAscension;
    }

    static double getDeclinationFromString(std::string declinationAsString){
        double declinationSignFactor = declinationAsString.substr(0, 1) == "-" ? -1.0 : 1.0;
        double declinationDegrees = atof(declinationAsString.substr(1, 2).c_str());
        double declinationArcMinutes = atof(declinationAsString.substr(4, 2).c_str());
        double declinationArcSeconds = atof(declinationAsString.substr(7, 2).c_str());
        double declination = declinationSignFactor * (declinationDegrees + geAstro::getDegreesFromArcminutes(declinationArcMinutes) +
            geAstro::getDegreesFromArcseconds(declinationArcSeconds));
        return declination;
    }//*/

    static int getTemperatureFromSpectralType(std::string st) {
        if (st.length() == 0){
            return 5800; //default value: roughly temperature of the sun.
        }

        char letter = st.at(0);
        int dig = 5;
        if (st.length() > 1){
            if (isdigit(st.at(1))){
                dig = st.at(1) - '0'; // necessary not to read the ascii code but the the real digit.
            }
        }

        //temperatures[K] from wikipedia https://en.wikipedia.org/wiki/Stellar_classification
        //0 hottest - 9 coldest
        if (letter == 'O'){ return 30000; }
        else if (letter == 'B'){ return 10000 + (9 - dig) * (30000 - 10000) / 9; }
        else if (letter == 'A'){ return 7500 + (9 - dig) * (10000 - 7500) / 9; }
        else if (letter == 'F'){ return 6000 + (9 - dig) * (7500 - 6000) / 9; }
        else if (letter == 'G'){ return 5200 + (9 - dig) * (6000 - 5200) / 9; }
        else if (letter == 'K'){ return 3700 + (9 - dig) * (5200 - 3700) / 9; }
        else if (letter == 'M'){ return 2400 + (9 - dig) * (3700 - 2400) / 9; }
        else if (letter == 'T'){ return 700 + (9 - dig) * (1300 - 700) / 9; }
        else if (letter == 'Y'){ return 350; }
        return 5800; //roughly temperature of the sun.
    }
}
#endif