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(FrameType)
    Q_ENUMS(ProjectionType)
    Q_ENUMS(RefractionMode)
    Q_ENUMS(DeltaTAlgorithm)
    Q_PROPERTY(bool flipHorz READ getFlipHorz WRITE setFlipHorz NOTIFY flipHorzChanged)
    Q_PROPERTY(bool flipVert READ getFlipVert WRITE setFlipVert NOTIFY flipVertChanged)
    Q_PROPERTY(bool flagUseNutation READ getUseNutation WRITE setUseNutation NOTIFY flagUseNutationChanged)
    Q_PROPERTY(bool flagUseTopocentricCoordinates READ getUseTopocentricCoordinates WRITE setUseTopocentricCoordinates NOTIFY flagUseTopocentricCoordinatesChanged)
    Q_PROPERTY(ProjectionType currentProjectionType READ getCurrentProjectionType WRITE setCurrentProjectionType NOTIFY currentProjectionTypeChanged)
    Q_PROPERTY(QString currentProjectionTypeKey READ getCurrentProjectionTypeKey WRITE setCurrentProjectionTypeKey NOTIFY currentProjectionTypeKeyChanged STORED false)
    Q_PROPERTY(QString currentProjectionNameI18n READ getCurrentProjectionNameI18n NOTIFY currentProjectionNameI18nChanged STORED false)

public:

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

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

    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,          
        Banjevic,                           
        IslamSadiqQureshi,                  
        KhalidSultanaZaidi,                 
        StephensonMorrisonHohenkerk2016,    
        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 supergalacticToJ2000(const Vec3d& v) const;
    Vec3d equinoxEquToJ2000(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d j2000ToJ1875(const Vec3d& v) const;
    Vec3d j2000ToEquinoxEqu(const Vec3d& v, RefractionMode refMode=RefractionAuto) const;
    Vec3d j2000ToGalactic(const Vec3d& v) const;
    Vec3d j2000ToSupergalactic(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;

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

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

    Vec3d getObserverHeliocentricEclipticPos() const;

    const StelLocation& getCurrentLocation() const;
    float getUTCOffset(const double JD) const;

    QString getCurrentTimeZone() const;
    void setCurrentTimeZone(const QString& tz);

    const QSharedPointer<class Planet> getCurrentPlanet() const;

    const StelObserver* getCurrentObserver() const;

    void setObserver(StelObserver* obs);

    SphericalCap getVisibleSkyArea() const;

    // 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;
    static const double TZ_ERA_BEGINNING;

    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 moveObserverTo(const StelLocation& target, double duration=1., double durationIfPlanetChange=1.);

    void setCurrentProjectionType(ProjectionType type);
    ProjectionType getCurrentProjectionType() const;

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

    QString getCurrentProjectionNameI18n() const;

    QStringList getAllProjectionTypeKeys() const;

    void setCurrentDeltaTAlgorithm(DeltaTAlgorithm 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;

    //New for 0.15: Vertical offset should even be available for animation, so at last with property mechanism.
    double getViewportHorizontalOffset(void);
    void setViewportHorizontalOffset(double newOffsetPct);
    double getViewportVerticalOffset(void);
    void setViewportVerticalOffset(double newOffsetPct);
    // Set both viewport offsets. Arguments will be clamped to be inside [-50...50]. I (GZ) hope this will avoid some of the shaking.
    void setViewportOffset(double newHorizontalOffsetPct, double newVerticalOffsetPct);

    void setViewportStretch(float stretch);

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

    double getJDOfLastJDUpdate() const;
    void setMilliSecondsOfLastJDUpdate(qint64 millis);
    qint64 getMilliSecondsOfLastJDUpdate() const;

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

    double getSolutionEquationOfTime(const double JDE) const;

    bool getUseDST() const;
    void setUseDST(const bool b);

    bool getUseCustomTimeZone(void) const;
    void setUseCustomTimeZone(const bool b);

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


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

    bool getUseNutation() const {return flagUseNutation;}
    void setUseNutation(bool use) { if (flagUseNutation != use) { flagUseNutation=use; emit flagUseNutationChanged(use); }}

    bool getUseTopocentricCoordinates() const {return flagUseTopocentricCoordinates;}
    void setUseTopocentricCoordinates(bool use) { if (flagUseTopocentricCoordinates!= use) { flagUseTopocentricCoordinates=use; emit flagUseTopocentricCoordinatesChanged(use); }}

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

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

    void revertTimeDirection(void);

    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 addMinute();
    void addHour();
    void addDay();
    void addWeek();

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

    void subtractMinute();
    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; }
    float getDeltaTnDot() const { return deltaTnDot; }
    Vec3f getDeltaTCustomEquationCoefficients() const { return deltaTCustomEquationCoeff; }

    void initEphemeridesFunctions();

    bool de430IsAvailable();            
    bool de431IsAvailable();            
    bool de430IsActive();               
    bool de431IsActive();               
    void setDe430Active(bool status);   
    void setDe431Active(bool status);   

    QString getIAUConstellation(const Vec3d positionJ2000) const;


signals:
    void locationChanged(StelLocation);
    void timeRateChanged(double rate);
    void timeSyncOccurred(double jDay);
    void dateChanged();
    void flipHorzChanged(bool b);
    void flipVertChanged(bool b);
    void flagUseNutationChanged(bool b);
    void flagUseTopocentricCoordinatesChanged(bool b);
    void currentProjectionTypeChanged(StelCore::ProjectionType newType);
    void currentProjectionTypeKeyChanged(const QString& newValue);
    void currentProjectionNameI18nChanged(const QString& newValue);

private:
    StelToneReproducer* toneReproducer;     // 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 updateMaximumFov();
    void resetSync();

    void registerMathMetaTypes();


    // 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
    static Mat4d matJ2000ToJ1875;              // Precession matrix for IAU constellation lookup.

    Mat4d matJ2000ToAltAz;
    Mat4d matAltAzToJ2000;

    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 milliSecondsOfLastJDUpdate;    // Time in seconds when the time rate or time last changed
    double jdOfLastJDUpdate;         // JD when the time rate or time last changed

    QString currentTimeZone;    
    bool flagUseDST;
    bool flagUseCTZ; // custom time zone

    // Variables for equations of DeltaT
    Vec3f deltaTCustomEquationCoeff;
    float deltaTCustomNDot;
    float deltaTCustomYear;
    float deltaTnDot; // The currently applied nDot correction. (different per algorithm, and displayed in status line.)
    bool  deltaTdontUseMoon; // true if the currenctly selected algorithm does not do a lunar correction (?????)
    double (*deltaTfunc)(const double JD); // This is a function pointer which must be set to a function which computes DeltaT(JD).
    int deltaTstart;   // begin year of validity range for the selected DeltaT algorithm. (SET INT_MIN to mark infinite)
    int deltaTfinish;  // end   year of validity range for the selected DeltaT algorithm. (Set INT_MAX to mark infinite)

    // Variables for DE430/431 ephem calculation
    bool de430Available; // ephem file found
    bool de431Available; // ephem file found
    bool de430Active;    // available and user-activated.
    bool de431Active;    // available and user-activated.
};

#endif // _STELCORE_HPP_