StelCore.hpp

/*
 * Copyright (C) 2003 Fabien Chereau
 * Copyright (C) 2012 Matthew Gates
 * Copyright (C) 2015 Georg Zotti (Precession fixes)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.
 */

#ifndef _STELCORE_HPP_
#define _STELCORE_HPP_

#include "StelProjector.hpp"
#include "StelProjectorType.hpp"
#include "StelLocation.hpp"
#include "StelSkyDrawer.hpp"
#include <QString>
#include <QStringList>
#include <QTime>
#include <QPair>

class StelToneReproducer;
class StelSkyDrawer;
class StelGeodesicGrid;
class StelMovementMgr;
class StelObserver;

class StelCore : public QObject
{
    Q_OBJECT
    Q_ENUMS(ProjectionType)
    Q_ENUMS(DeltaTAlgorithm)
    Q_PROPERTY(bool flipHorz READ getFlipHorz WRITE setFlipHorz)
    Q_PROPERTY(bool flipVert READ getFlipVert WRITE setFlipVert)
    Q_PROPERTY(bool flagUseNutation READ getUseNutation WRITE setUseNutation)
    Q_PROPERTY(bool flagUseTopocentricCoordinates READ getUseTopocentricCoordinates WRITE setUseTopocentricCoordinates)

public:
    enum FrameType
    {
        FrameUninitialized,         
        FrameAltAz,             
        FrameHeliocentricEclipticJ2000,     
        FrameObservercentricEclipticJ2000,  
        FrameObservercentricEclipticOfDate, 
        FrameEquinoxEqu,            
        FrameJ2000,             
        FrameGalactic               
    };

    enum ProjectionType
    {
        ProjectionPerspective,      
        ProjectionEqualArea,        
        ProjectionStereographic,    
        ProjectionFisheye,      
        ProjectionHammer,       
        ProjectionCylinder,     
        ProjectionMercator,     
        ProjectionOrthographic,     
        ProjectionSinusoidal        
    };

    enum RefractionMode
    {
        RefractionAuto,         
        RefractionOn,           
        RefractionOff           
    };

    enum DeltaTAlgorithm
    {
        WithoutCorrection,              
        Schoch,                         
        Clemence,                       
        IAU,                            
        AstronomicalEphemeris,          
        TuckermanGoldstine,             
        MullerStephenson,               
        Stephenson1978,                 
        SchmadelZech1979,               
        MorrisonStephenson1982,         
        StephensonMorrison1984,         
        StephensonHoulden,              
        Espenak,                        
        Borkowski,                      
        SchmadelZech1988,               
        ChaprontTouze,                  
        StephensonMorrison1995,         
        Stephenson1997,                 
        ChaprontMeeus,                  
        JPLHorizons,                    
        MeeusSimons,                    
        MontenbruckPfleger,             
        ReingoldDershowitz,             
        MorrisonStephenson2004,         
        Reijs,                          
        EspenakMeeus,                   
        EspenakMeeusZeroMoonAccel,      //   Espenak & Meeus (2006) algorithm for DeltaT (but without additional Lunar acceleration. FOR TESTING ONLY, NONPUBLIC)
        Banjevic,           
        IslamSadiqQureshi,      
        KhalidSultanaZaidi,     
        Custom                          
    };

    StelCore();
    virtual ~StelCore();

    void init();

    void update(double deltaTime);

    void windowHasBeenResized(float x, float y, float width, float height);

    void preDraw();

    void postDraw();

    StelProjectorP getProjection2d() const;

    StelProjectorP getProjection(FrameType frameType, RefractionMode refractionMode=RefractionAuto) const;

    StelProjectorP getProjection(StelProjector::ModelViewTranformP modelViewTransform, ProjectionType projType=(ProjectionType)1000) const;

    StelToneReproducer* getToneReproducer();
    const StelToneReproducer* getToneReproducer() const;

    StelSkyDrawer* getSkyDrawer();
    const StelSkyDrawer* getSkyDrawer() const;

    const StelGeodesicGrid* getGeodesicGrid(int maxLevel) const;

    StelMovementMgr* getMovementMgr();
    const StelMovementMgr* getMovementMgr() const;

    void setClippingPlanes(double znear, double zfar);
    void getClippingPlanes(double* zn, double* zf) const;

    QString projectionTypeKeyToNameI18n(const QString& key) const;

    QString projectionNameI18nToTypeKey(const QString& nameI18n) const;

    StelProjector::StelProjectorParams getCurrentStelProjectorParams() const;
    void setCurrentStelProjectorParams(const StelProjector::StelProjectorParams& newParams);

    void lookAtJ2000(const Vec3d& pos, const Vec3d& up);

    Vec3d altAzToEquinoxEqu(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d equinoxEquToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d altAzToJ2000(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d j2000ToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    void j2000ToAltAzInPlaceNoRefraction(Vec3f* v) const {v->transfo4d(matJ2000ToAltAz);}
    Vec3d galacticToJ2000(const Vec3d& v) const;
    Vec3d equinoxEquToJ2000(const Vec3d& v) const;
    Vec3d j2000ToEquinoxEqu(const Vec3d& v) const;
    Vec3d j2000ToGalactic(const Vec3d& v) const;

    Vec3d heliocentricEclipticToAltAz(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;

    Vec3d heliocentricEclipticToEquinoxEqu(const Vec3d& v) const;
//  //! Transform vector from heliocentric coordinate to false equatorial : equatorial
//  //! coordinate but centered on the observer position (useful for objects close to earth)
//  //! Unused as of V0.13
//  Vec3d heliocentricEclipticToEarthPosEquinoxEqu(const Vec3d& v) const;

    StelProjector::ModelViewTranformP getHeliocentricEclipticModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getObservercentricEclipticJ2000ModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getObservercentricEclipticOfDateModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getEquinoxEquModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getAltAzModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getJ2000ModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    StelProjector::ModelViewTranformP getGalacticModelViewTransform(RefractionMode refMode=RefractionAuto) const;

    static const Mat4d matJ2000ToVsop87;
    static const Mat4d matVsop87ToJ2000;
    static const Mat4d matJ2000ToGalactic;
    static const Mat4d matGalacticToJ2000;

    Vec3d getObserverHeliocentricEclipticPos() const;

    const StelLocation& getCurrentLocation() const;

    const QSharedPointer<class Planet> getCurrentPlanet() const;

    const StelObserver* getCurrentObserver() const;


    SphericalCap getVisibleSkyArea() const;
    
    void moveObserverTo(const StelLocation& target, double duration=1., double durationIfPlanetChange=1.);

    // Conversion in standard Julian time format
    static const double JD_SECOND;
    static const double JD_MINUTE;
    static const double JD_HOUR;
    static const double JD_DAY;
    static const double ONE_OVER_JD_SECOND;

    double getLocalSiderealTime() const;

    double getLocalSiderealDayLength() const;

    double getLocalSiderealYearLength() const;

    QString getStartupTimeMode();
    void setStartupTimeMode(const QString& s);

    QString getCurrentDeltaTAlgorithmValidRangeDescription(const double JD, QString* marker) const;

    bool isBrightDaylight() const;

    double getCurrentEpoch() const;

    QString getDefaultProjectionTypeKey(void) const;

public slots:
    void setCurrentProjectionType(ProjectionType type);
    ProjectionType getCurrentProjectionType() const;

    QString getCurrentProjectionTypeKey(void) const;
    void setCurrentProjectionTypeKey(QString type);

    QStringList getAllProjectionTypeKeys() const;

    void setCurrentDeltaTAlgorithm(DeltaTAlgorithm algorithm) { currentDeltaTAlgorithm=algorithm; }
    DeltaTAlgorithm getCurrentDeltaTAlgorithm() const { return currentDeltaTAlgorithm; }
    QString getCurrentDeltaTAlgorithmDescription(void) const;
    QString getCurrentDeltaTAlgorithmKey(void) const;
    void setCurrentDeltaTAlgorithmKey(QString type);

    void setMaskType(StelProjector::StelProjectorMaskType m);

    void setFlagGravityLabels(bool gravity);
    void setDefaultAngleForGravityText(float a);
    void setFlipHorz(bool flip);
    void setFlipVert(bool flip);
    bool getFlipHorz(void) const;
    bool getFlipVert(void) const;

    QString getDefaultLocationID() const;
    void setDefaultLocationID(const QString& id);
    void returnToDefaultLocation();
    void returnToHome();

    void setJD(double newJD);
    void setJDE(double newJDE);
    double getJD() const;
    double getJDE() const;

    void setMJDay(double MJD);
    double getMJDay() const;

    double computeDeltaT(const double JD) const;
    double getDeltaT() const;

    bool getUseNutation() const {return flagUseNutation;}
    void setUseNutation(bool useNutation) { flagUseNutation=useNutation;}

    bool getUseTopocentricCoordinates() const {return flagUseTopocentricCoordinates;}
    void setUseTopocentricCoordinates(bool use) { flagUseTopocentricCoordinates=use;}

    double getPresetSkyTime() const;
    void setPresetSkyTime(double d);

    void setTimeRate(double ts);
    double getTimeRate() const;

    void increaseTimeSpeed();
    void decreaseTimeSpeed();
    void increaseTimeSpeedLess();
    void decreaseTimeSpeedLess();

    void setZeroTimeSpeed();
    void setRealTimeSpeed();
    void toggleRealTimeSpeed();
    bool getRealTimeSpeed() const;

    void setTimeNow();
    void setTodayTime(const QTime& target);
    bool getIsTimeNow() const;

    QTime getInitTodayTime(void);
    void setInitTodayTime(const QTime& time);
    void setPresetSkyTime(QDateTime dateTime);

    void addHour();
    void addDay();
    void addWeek();

    void addSiderealDay();
    void addSiderealYear();
    void addSiderealYears(float n=100.f);

    void subtractHour();
    void subtractDay();
    void subtractWeek();

    void subtractSiderealDay();
    void subtractSiderealYear();
    void subtractSiderealYears(float n=100.f);

    void addSynodicMonth();

    void addDraconicYear();
    void addDraconicMonth();

    void addAnomalisticMonth();
    void addAnomalisticYear();
    void addAnomalisticYears(float n=100.f);

    void addMeanTropicalMonth();
    void addMeanTropicalYear();
    void addMeanTropicalYears(float n=100.f);
    void addTropicalYear();

    void addJulianYear();
    void addJulianYears(float n=100.f);

    void addGaussianYear();

    void subtractSynodicMonth();

    void subtractDraconicYear();
    void subtractDraconicMonth();

    void subtractAnomalisticMonth();
    void subtractAnomalisticYear();
    void subtractAnomalisticYears(float n=100.f);

    void subtractMeanTropicalMonth();
    void subtractMeanTropicalYear();
    void subtractMeanTropicalYears(float n=100.f);
    void subtractTropicalYear();

    void subtractJulianYear();
    void subtractJulianYears(float n=100.f);

    void subtractGaussianYear();

    void addSolarDays(double d);
    void addSiderealDays(double d);

    void moveObserverToSelected();

    void setDeltaTCustomYear(float y) { deltaTCustomYear=y; }
    void setDeltaTCustomNDot(float v) { deltaTCustomNDot=v; }
    void setDeltaTCustomEquationCoefficients(Vec3f c) { deltaTCustomEquationCoeff=c; }

    float getDeltaTCustomYear() const { return deltaTCustomYear; }
    float getDeltaTCustomNDot() const { return deltaTCustomNDot; }
    Vec3f getDeltaTCustomEquationCoefficients() const { return deltaTCustomEquationCoeff; }

signals:
    void locationChanged(StelLocation);
    void timeRateChanged(double rate);

private:
    StelToneReproducer* toneConverter;      // Tones conversion between stellarium world and display device
    StelSkyDrawer* skyDrawer;
    StelMovementMgr* movementMgr;       // Manage vision movements

    // Manage geodesic grid
    mutable StelGeodesicGrid* geodesicGrid;

    // The currently used projection type
    ProjectionType currentProjectionType;

    // The currentrly used time correction (DeltaT)
    DeltaTAlgorithm currentDeltaTAlgorithm;

    // Parameters to use when creating new instances of StelProjector
    StelProjector::StelProjectorParams currentProjectorParams;

    void updateTransformMatrices();
    void updateTime(double deltaTime);
    void resetSync();



    // Matrices used for every coordinate transfo
    Mat4d matHeliocentricEclipticJ2000ToAltAz; // Transform from heliocentric ecliptic Cartesian (VSOP87A) to topocentric (StelObserver) altazimuthal coordinate
    Mat4d matAltAzToHeliocentricEclipticJ2000; // Transform from topocentric (StelObserver) altazimuthal coordinate to heliocentric ecliptic Cartesian (VSOP87A)
    Mat4d matAltAzToEquinoxEqu;                // Transform from topocentric altazimuthal coordinate to Earth Equatorial
    Mat4d matEquinoxEquToAltAz;                // Transform from Earth Equatorial to topocentric (StelObserver) altazimuthal coordinate
    Mat4d matHeliocentricEclipticToEquinoxEqu; // Transform from heliocentric ecliptic Cartesian (VSOP87A) to earth equatorial coordinate
    Mat4d matEquinoxEquToJ2000;                // For Earth, this is almost the inverse precession matrix, =Rz(VSOPbias)Rx(eps0)Rz(-psiA)Rx(-omA)Rz(chiA)
    Mat4d matJ2000ToEquinoxEqu;                // precession matrix

    Mat4d matJ2000ToAltAz;

    Mat4d matAltAzModelView;           // Modelview matrix for observer-centric altazimuthal drawing
    Mat4d invertMatAltAzModelView;     // Inverted modelview matrix for observer-centric altazimuthal drawing

    // Position variables
    StelObserver* position;
    // The ID of the default startup location
    QString defaultLocationID;

    // flag to indicate we want to use nutation (the small-scale wobble of earth's axis)
    bool flagUseNutation;
    // flag to indicate that we show topocentrically corrected coordinates. (Switching to false for planetocentric coordinates is new for 0.14)
    bool flagUseTopocentricCoordinates;

    // Time variables
    double timeSpeed;                  // Positive : forward, Negative : Backward, 1 = 1sec/sec
    //double JDay;                     // Current time in Julian day. IN V0.12 TO V0.14, this was JD in TT, and all places where UT was required had to subtract getDeltaT() explicitly.
    QPair<double,double> JD;           // From 0.14 on: JD.first=JD_UT, JD.second=DeltaT=TT-UT. To gain JD_TT, compute JDE=JD.first+JD.second or better just call getJDE()
                       // Use is best with calls getJD()/setJD() and getJDE()/setJDE() to explicitly state which flavour of JD you need.
    double presetSkyTime;
    QTime initTodayTime;
    QString startupTimeMode;
    double secondsOfLastJDUpdate;    // Time in seconds when the time rate or time last changed
    double jdOfLastJDUpdate;         // JD when the time rate or time last changed

    // Variables for custom equation of Delta-T
    Vec3f deltaTCustomEquationCoeff;
    float deltaTCustomNDot;
    float deltaTCustomYear;

};

#endif // _STELCORE_HPP_