Stellarium / stellarium / 13260145531

/*

 * 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 "StelPropertyMgr.hpp"

#include "SolarSystem.hpp"

#include "Dithering.hpp"

#include <QString>

#include <QStringList>

#include <QTime>

#include <QPair>

class StelToneReproducer;

class StelSkyDrawer;

class StelGeodesicGrid;

class StelMovementMgr;

class StelObserver;

//! @class StelCore

//! Main class for Stellarium core processing.

//! This class provides services like management of sky projections,

//! tone conversion, or reference frame conversion. It is used by the

//! various StelModules to update and display themselves.

//! There is currently only one StelCore instance in Stellarium, but

//! in the future they may be more, allowing for example to display

//! several independent views of the sky at the same time.

//! @author Fabien Chereau, Matthew Gates, Georg Zotti

class StelCore : public QObject

{

        Q_OBJECT

        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 flagUseAberration READ getUseAberration WRITE setUseAberration NOTIFY flagUseAberrationChanged)

        Q_PROPERTY(double aberrationFactor READ getAberrationFactor WRITE setAberrationFactor NOTIFY aberrationFactorChanged)

        Q_PROPERTY(bool flagUseParallax READ getUseParallax WRITE setUseParallax NOTIFY flagUseParallaxChanged)

        Q_PROPERTY(double parallaxFactor READ getParallaxFactor WRITE setParallaxFactor NOTIFY parallaxFactorChanged)

        Q_PROPERTY(bool flagUseTopocentricCoordinates READ getUseTopocentricCoordinates WRITE setUseTopocentricCoordinates NOTIFY flagUseTopocentricCoordinatesChanged)

        Q_PROPERTY(ProjectionType currentProjectionType READ getCurrentProjectionType WRITE setCurrentProjectionType NOTIFY currentProjectionTypeChanged)

        //! This is just another way to access the projection type, by string instead of enum

        Q_PROPERTY(QString currentProjectionTypeKey READ getCurrentProjectionTypeKey WRITE setCurrentProjectionTypeKey NOTIFY currentProjectionTypeKeyChanged STORED false)

        //! Read-only property returning the localized projection name

        Q_PROPERTY(QString currentProjectionNameI18n READ getCurrentProjectionNameI18n NOTIFY currentProjectionNameI18nChanged STORED false)

        Q_PROPERTY(bool flagGravityLabels READ getFlagGravityLabels WRITE setFlagGravityLabels NOTIFY flagGravityLabelsChanged)

        Q_PROPERTY(QString currentTimeZone READ getCurrentTimeZone WRITE setCurrentTimeZone NOTIFY currentTimeZoneChanged)

        Q_PROPERTY(bool flagUseCTZ READ getUseCustomTimeZone WRITE setUseCustomTimeZone NOTIFY useCustomTimeZoneChanged)

        Q_PROPERTY(bool flagUseDST READ getUseDST WRITE setUseDST NOTIFY flagUseDSTChanged)

        Q_PROPERTY(bool startupTimeStop READ getStartupTimeStop WRITE setStartupTimeStop NOTIFY startupTimeStopChanged)

        Q_PROPERTY(DitheringMode ditheringMode READ getDitheringMode WRITE setDitheringMode NOTIFY ditheringModeChanged)

public:

        //! @enum FrameType

        //! Supported reference frame types

        enum FrameType

        {

                FrameUninitialized,                        //!< Reference frame is not set (FMajerech: Added to avoid condition on uninitialized value in StelSkyLayerMgr::draw())

                FrameAltAz,                                //!< Altazimuthal reference frame centered on observer: +x=south, +y=east, +z=zenith.

                FrameHeliocentricEclipticJ2000,                //!< Fixed-ecliptic reference frame centered on the Sun. This is J2000 ecliptical / almost VSOP87.

                FrameObservercentricEclipticJ2000,        //!< Fixed-ecliptic reference frame centered on the Observer. Was ObservercentricEcliptic, but renamed because it is Ecliptic of J2000!

                FrameObservercentricEclipticOfDate,        //!< Moving ecliptic reference frame centered on the Observer. Ecliptic of date, i.e. includes the precession of the ecliptic.

                FrameEquinoxEqu,                        //!< Equatorial reference frame at the current equinox centered on the observer.

                                                        //!< The north pole follows the precession of the planet on which the observer is located.

                                                        //!< On Earth, this may include nutation if so configured. Models ecliptical motion and precession (Vondrak 2011 model) and nutation.

                FrameJ2000,                                //!< Equatorial reference frame at the J2000 equinox centered on the observer. This is also the ICRS reference frame.

                FrameFixedEquatorial,                        //!< Fixed equatorial frame (hour angle/declination). Note that hour angle is counted backwards here and must be treated specially for user I/O.

                FrameGalactic,                                //!< Galactic reference frame centered on observer.

                FrameSupergalactic                        //!< Supergalactic reference frame centered on observer.

        };

        //! @enum ProjectionType

        //! Available projection types. A value of 1000 indicates the default projection

        enum ProjectionType

        {

                ProjectionPerspective,                //!< Perspective projection

                ProjectionStereographic,        //!< Stereographic projection

                ProjectionFisheye,                //!< Fisheye projection

                ProjectionOrthographic,                //!< Orthographic projection

                ProjectionEqualArea,                //!< Equal Area projection

                ProjectionHammer,                //!< Hammer-Aitoff projection

                ProjectionSinusoidal,                //!< Sinusoidal projection

                ProjectionMercator,                //!< Mercator projection

                ProjectionMiller,                //!< Miller cylindrical projection

                ProjectionCylinder,                //!< Cylinder projection

                ProjectionCylinderFill                //!< Cylinder projection, no zoom or movement allowed

        };

        //! @enum RefractionMode

        //! Available refraction mode.

        enum RefractionMode

        {

                RefractionAuto,                //!< Automatically decide to add refraction if atmosphere is activated

                RefractionOn,                //!< Always add refraction (i.e. apparent coordinates)

                RefractionOff                //!< Never add refraction (i.e. geometric coordinates)

        };

        Q_ENUM(RefractionMode)

        //! @enum DeltaTAlgorithm

        //! Available DeltaT algorithms

        enum DeltaTAlgorithm

        {

                WithoutCorrection,               //!< Without correction, DeltaT is Zero. Like Stellarium versions before 0.12.

                Schoch,                          //!< Schoch (1931) algorithm for DeltaT

                Clemence,                        //!< Clemence (1948) algorithm for DeltaT

                IAU,                             //!< IAU (1952) algorithm for DeltaT (based on observations by Spencer Jones (1939))

                AstronomicalEphemeris,           //!< Astronomical Ephemeris (1960) algorithm for DeltaT

                TuckermanGoldstine,              //!< Tuckerman (1962, 1964) & Goldstine (1973) algorithm for DeltaT

                MullerStephenson,                //!< Muller & Stephenson (1975) algorithm for DeltaT

                Stephenson1978,                  //!< Stephenson (1978) algorithm for DeltaT

                SchmadelZech1979,                //!< Schmadel & Zech (1979) algorithm for DeltaT

                MorrisonStephenson1982,          //!< Morrison & Stephenson (1982) algorithm for DeltaT (used by RedShift)

                StephensonMorrison1984,          //!< Stephenson & Morrison (1984) algorithm for DeltaT

                StephensonHoulden,               //!< Stephenson & Houlden (1986) algorithm for DeltaT

                Espenak,                         //!< Espenak (1987, 1989) algorithm for DeltaT

                Borkowski,                       //!< Borkowski (1988) algorithm for DeltaT

                SchmadelZech1988,                //!< Schmadel & Zech (1988) algorithm for DeltaT

                ChaprontTouze,                   //!< Chapront-Touzé & Chapront (1991) algorithm for DeltaT

                StephensonMorrison1995,          //!< Stephenson & Morrison (1995) algorithm for DeltaT

                Stephenson1997,                  //!< Stephenson (1997) algorithm for DeltaT

                ChaprontMeeus,                   //!< Chapront, Chapront-Touze & Francou (1997) & Meeus (1998) algorithm for DeltaT

                JPLHorizons,                     //!< JPL Horizons algorithm for DeltaT

                MeeusSimons,                     //!< Meeus & Simons (2000) algorithm for DeltaT

                MontenbruckPfleger,              //!< Montenbruck & Pfleger (2000) algorithm for DeltaT

                ReingoldDershowitz,              //!< Reingold & Dershowitz (2002, 2007) algorithm for DeltaT

                MorrisonStephenson2004,          //!< Morrison & Stephenson (2004, 2005) algorithm for DeltaT

                Reijs,                           //!< Reijs (2006) algorithm for DeltaT

                EspenakMeeus,                    //!< Espenak & Meeus (2006) algorithm for DeltaT

                EspenakMeeusModified,            //!< Espenak & Meeus (2006) algorithm with modified formulae for DeltaT (Recommended, default)

                EspenakMeeusZeroMoonAccel,       //!< Espenak & Meeus (2006) algorithm for DeltaT (but without additional Lunar acceleration. FOR TESTING ONLY, NONPUBLIC)

                Banjevic,                        //!< Banjevic (2006) algorithm for DeltaT

                IslamSadiqQureshi,               //!< Islam, Sadiq & Qureshi (2008 + revisited 2013) algorithm for DeltaT (6 polynomials)

                KhalidSultanaZaidi,              //!< M. Khalid, Mariam Sultana and Faheem Zaidi polynomial approximation of time period 1620-2013 (2014)

                StephensonMorrisonHohenkerk2016, //!< Stephenson, Morrison, Hohenkerk (2016) RSPA paper provides spline fit to observations for -720..2019 and else parabolic fit.

                Henriksson2017,                  //!< Henriksson (2017) algorithm for DeltaT (The solution for Schoch formula for DeltaT (1931), but with ndot=-30.128"/cy^2)

                Custom                           //!< User defined coefficients for quadratic equation for DeltaT

        };

        StelCore();

        ~StelCore() override;

        //! Init and load all main core components.

        void init();

        //! Update all the objects with respect to the time.

        //! @param deltaTime the time increment in sec.

        void update(double deltaTime);

        //! Handle the resizing of the window

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

        //! Update core state before drawing modules.

        void preDraw();

        //! Update core state after drawing modules.

        void postDraw();

        //! Get a new instance of a simple 2d projection. This projection cannot be used to project or unproject but

        //! only for 2d painting

        StelProjectorP getProjection2d() const;

        //! Get a new instance of projector using a modelview transformation corresponding to the given frame.

        //! If not specified the refraction effect is included if atmosphere is on.

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

        //! Get a new instance of projector using the given modelview transformation.

        //! If not specified the projection used is the one currently used as default.

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

        //! Get the current tone reproducer used in the core.

        //! Get the current tone reproducer used in the core.

        const StelToneReproducer* getToneReproducer() const{return toneReproducer;}

        //! Get the current StelSkyDrawer used in the core.

        //! Get the current StelSkyDrawer used in the core.

        //! Get an instance of StelGeodesicGrid which is guaranteed to allow for at least maxLevel levels

        const StelGeodesicGrid* getGeodesicGrid(int maxLevel) const;

        //! Get the instance of movement manager.

        //! Get the const instance of movement manager.

        //! Set the near and far clipping planes.

        //! Get the near and far clipping planes.

        //! Get the translated projection name from its TypeKey for the current locale.

        QString projectionTypeKeyToNameI18n(const QString& key) const;

        //! Get the projection TypeKey from its translated name for the current locale.

        QString projectionNameI18nToTypeKey(const QString& nameI18n) const;

        //! Get the current set of parameters.

        StelProjector::StelProjectorParams getCurrentStelProjectorParams() const;

        //! Set the set of parameters to use when creating a new StelProjector.

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

        //! Set vision direction

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

        // Unused as of 24.1

        //void setMatAltAzModelView(const Mat4d& mat);

        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;

        Vec3d galacticToJ2000(const Vec3d& v) const;

        Vec3d supergalacticToJ2000(const Vec3d& v) const;

        //! Transform position vector v from equatorial coordinates of date (which may also include atmospheric refraction) to those of J2000.

        //! Use refMode=StelCore::RefractionOff if you don't want any atmosphere correction.

        //! Use refMode=StelCore::RefractionOn to create observed (apparent) coordinates (which are subject to refraction).

        //! Use refMode=StelCore::RefractionAuto to correct coordinates for refraction only when atmosphere is active.

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

        //! Use fixed matrix to allow fast transformation of positions related to the IAU constellation borders.

        Vec3d j2000ToJ1875(const Vec3d& v) const;

        //! Use fixed matrix to allow fast transformation of positions related to the IAU constellation borders.

        Vec3d j1875ToJ2000(const Vec3d& v) const;

        //! Transform position vector v from equatorial coordinates J2000 to those of date (optionally corrected by refraction).

        //! Use refMode=StelCore::RefractionOff if you don't want any atmosphere correction.

        //! Use refMode=StelCore::RefractionOn to correct observed (apparent) coordinates (which are subject to refraction).

        //! Use refMode=StelCore::RefractionAuto to correct coordinates for refraction only when atmosphere is active.

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

        Vec3d j2000ToGalactic(const Vec3d& v) const;

        Vec3d j2000ToSupergalactic(const Vec3d& v) const;

        //! Transform vector from heliocentric ecliptic coordinate to altazimuthal

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

        //! Transform from heliocentric coordinate to equatorial at current equinox (for the planet where the observer stands)

        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;

        //! Get the modelview matrix for heliocentric ecliptic (Vsop87) drawing.

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

        //! Get the modelview matrix for observer-centric ecliptic (Vsop87) drawing.

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

        //! Get the modelview matrix for observer-centric ecliptic of Date drawing.

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

        //! Get the modelview matrix for observer-centric equatorial at equinox drawing.

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

        //! Get the modelview matrix for observer-centric fixed equatorial drawing.

        StelProjector::ModelViewTranformP getFixedEquatorialModelViewTransform(RefractionMode refMode) const;

        //! Get the modelview matrix for observer-centric altazimuthal drawing.

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

        //! Get the modelview matrix for observer-centric J2000 equatorial drawing.

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

        //! Get the modelview matrix for observer-centric Galactic equatorial drawing.

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

        //! Get the modelview matrix for observer-centric Supergalactic equatorial drawing.

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

        //! Rotation matrix from equatorial J2000 to ecliptic (VSOP87A).

        static const Mat4d matJ2000ToVsop87;

        //! Rotation matrix from ecliptic (VSOP87A) to equatorial J2000.

        static const Mat4d matVsop87ToJ2000;

        //! Rotation matrix from J2000 to Galactic reference frame, using FITS convention.

        static const Mat4d matJ2000ToGalactic;

        //! Rotation matrix from Galactic to J2000 reference frame, using FITS convention.

        static const Mat4d matGalacticToJ2000;

        //! Rotation matrix from J2000 to Supergalactic reference frame.

        static const Mat4d matJ2000ToSupergalactic;

        //! Rotation matrix from Supergalactic to J2000 reference frame.

        static const Mat4d matSupergalacticToJ2000;

        //! Return the observer heliocentric ecliptic position (GZ: presumably J2000)

        Vec3d getObserverHeliocentricEclipticPos() const;

        //! Return the observer heliocentric ecliptic velocity. This includes orbital and diurnal motion;

        // diurnal motion is omitted if planetocentric coordinates are in use.

        Vec3d getObserverHeliocentricEclipticVelocity() const;

        //! Get the information on the current location

        const StelLocation& getCurrentLocation() const;

        //! Get the UTC offset on the current location (in hours)

        //! N.B. This is a rather costly operation. Re-use where possible!

        double getUTCOffset(const double JD) const;

        QString getCurrentTimeZone() const;

        void setCurrentTimeZone(const QString& tz);

        const QSharedPointer<class Planet> getCurrentPlanet() const;

        //! Unfortunately we also need this.

        //! Returns the current observer.

        //! Note that the observer object may be deleted at any time when control returns to StelCore.

        const StelObserver* getCurrentObserver() const;

        //! Replaces the current observer. StelCore assumes ownership of the observer.

        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;

        //! Get the sidereal time shifted by the observer longitude

        //! @return the local sidereal time in radian

        double getLocalSiderealTime() const;

        //! Get the duration of a sidereal day for the current observer in day.

        double getLocalSiderealDayLength() const;

        //! Get the duration of a sidereal year for the current observer in days.

        double getLocalSiderealYearLength() const;

        //! Return the startup mode, can be "actual" (i.e. take current time from system),

        //! "today" (take some time e.g. on the evening of today) or "preset" (completely preconfigured).

        QString getStartupTimeMode() const;

        void setStartupTimeMode(const QString& s);

        //! Get info about valid range for current algorithm for calculation of Delta-T

        //! @param JD the Julian Day number to test.

        //! @param marker receives a string: "*" if jDay is outside valid range, or "?" if range unknown, else an empty string.

        //! @return valid range as explanatory string.

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

        //! Checks for altitude of the Sun - is it night or day?

        //! @return true if sun higher than about -6 degrees, i.e. "day" includes civil twilight.

        //! @note Useful mostly for brightness-controlled GUI decisions like font colors.

        bool isBrightDaylight() const;

        //! Get value of the current Julian epoch (i.e. current year with decimal fraction, e.g. 2012.34567)

        double getCurrentEpoch() const;

        //! Get the default Mapping used by the Projection

        QString getDefaultProjectionTypeKey(void) const;

        Vec3d getMouseJ2000Pos(void) const;

        //! get vector used to compute parallax effect

        Vec3d getParallaxDiff(double JD) const;

        //! get vector used to compute aberration effect

        Vec3d getAberrationVec(double JD) const;

public slots:

        //! Smoothly move the observer to the given location

        //! @param target the target location

        //! @param duration direction of view move duration in s

        //! @param durationIfPlanetChange direction of view + planet travel move duration in s.

        //! This is used only if the destination planet is different from the starting one.

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

        //! Set the current ProjectionType to use

        void setCurrentProjectionType(StelCore::ProjectionType type);

        StelCore::ProjectionType getCurrentProjectionType() const;

        //! Get the current Mapping used by the Projection

        QString getCurrentProjectionTypeKey(void) const;

        //! Set the current ProjectionType to use from its key

        void setCurrentProjectionTypeKey(QString type);

        QString getCurrentProjectionNameI18n() const;

        //! Get the list of all the available projections

        QStringList getAllProjectionTypeKeys() const;

        //! Set the current algorithm and nDot used therein for time correction (DeltaT)

        void setCurrentDeltaTAlgorithm(StelCore::DeltaTAlgorithm algorithm);

        //! Get the current algorithm for time correction (DeltaT)

        //! Get description of the current algorithm for time correction

        QString getCurrentDeltaTAlgorithmDescription(void) const;

        //! Get the current algorithm used by the DeltaT

        QString getCurrentDeltaTAlgorithmKey(void) const;

        //! Set the current algorithm to use from its key

        void setCurrentDeltaTAlgorithmKey(QString type);

        //! Set the mask type.

        void setMaskType(StelProjector::StelProjectorMaskType m);

        //! Set the flag with decides whether to arrange labels so that

        //! they are aligned with the bottom of a 2d screen, or a 3d dome.

        void setFlagGravityLabels(bool gravity);

        //! return whether dome-aligned labels are in use

        bool getFlagGravityLabels() const;

        //! Set the offset rotation angle in degree to apply to gravity text (only if gravityLabels is set to false).

        void setDefaultAngleForGravityText(float a);

        //! Set the horizontal flip status.

        //! @param flip The new value (true = flipped, false = unflipped).

        void setFlipHorz(bool flip);

        //! Set the vertical flip status.

        //! @param flip The new value (true = flipped, false = unflipped).

        void setFlipVert(bool flip);

        //! Get the state of the horizontal flip.

        //! @return True if flipped horizontally, else false.

        bool getFlipHorz(void) const;

        //! Get the state of the vertical flip.

        //! @return True if flipped vertically, else false.

        bool getFlipVert(void) const;

        // Vertical offset should even be available for animation, so at last with property mechanism.

        //! Get current value for horizontal viewport offset [-50...50]

        //! An offset of 50 percent means projective image center is on the right screen border

        double getViewportHorizontalOffset(void) const;

        //! Set horizontal viewport offset. Argument will be clamped to be inside [-50...50]

        //! An offset of 50 percent means projective image center is on the right screen border

        //! Animation is available via StelMovementMgr::moveViewport()

        void setViewportHorizontalOffset(double newOffsetPct);

        //! Get current value for vertical viewport offset [-50...50]

        //! An offset of 50 percent means projective image center is on the upper screen border

        double getViewportVerticalOffset(void) const;

        //! Set vertical viewport offset. Argument will be clamped to be inside [-50...50]

        //! An offset of 50 percent means projective image center is on the upper screen border

        //! Setting to a negative value will move the visible horizon down, this may be desired esp. in cylindrical projection.

        //! Animation is available via StelMovementMgr::moveViewport()

        void setViewportVerticalOffset(double newOffsetPct);

        // Set both viewport offsets. Arguments will be clamped to be inside [-50...50].

        void setViewportOffset(double newHorizontalOffsetPct, double newVerticalOffsetPct);

        //! Can be used in specialized setups, intended e.g. for multi-projector installations with edge blending.

        //! @param stretch [default 1] enlarge to stretch image to non-square pixels. A minimum value of 0.001 is enforced.

        //! @note This only influences the projected content. Things like ScreenImages keep square pixels.

        void setViewportStretch(float stretch);

        //! Get the location used by default at startup

        QString getDefaultLocationID() const;

        //! Set the location to use by default at startup

        void setDefaultLocationID(const QString& id);

        //! Return to the default location.

        void returnToDefaultLocation();

        //! Return to the default location and set default landscape with atmosphere and fog effects

        void returnToHome();

        //! Returns the JD of the last time resetSync() was called

        double getJDOfLastJDUpdate() const;

        //! Sets the system date which corresponds to the jdOfLastJDUpdate.

        //! Usually, you do NOT want to call this method.

        //! This method is used by the RemoteSync plugin.

        void setMilliSecondsOfLastJDUpdate(qint64 millis);

        //! Returns the system date of the last time resetSync() was called

        qint64 getMilliSecondsOfLastJDUpdate() const;

        //! Set the current date in Julian Day (UT)

        void setJD(double newJD);

        //! Set the current date in Julian Day (TT).

        //! The name is derived from the classical name "Ephemeris Time", of which TT is the successor.

        //! It is still frequently used in the literature.

        void setJDE(double newJDE);

        //! Get the current date in Julian Day (UT).

        double getJD() const;

        //! Get the current date in Julian Day (TT).

        //! The name is derived from the classical name "Ephemeris Time", of which TT is the successor.

        //! It is still frequently used in the literature.

        double getJDE() const;

        //! Get solution of equation of time [minutes].

        //! Source: J. Meeus "Astronomical Algorithms" (2nd ed., 1998) 28.3.

        //! @param JDE JD in Dynamical Time (previously called Ephemeris Time)

        //! @return time in minutes

        double getSolutionEquationOfTime(const double JDE) const;

        //! Get solution of equation of time [minutes] for the current time.

        //! Source: J. Meeus "Astronomical Algorithms" (2nd ed., with corrections as of August 10, 2009) p.183-187.

        //! @return time in minutes

        double getSolutionEquationOfTime() const;

        bool getUseDST() const;

        void setUseDST(const bool b);

        bool getStartupTimeStop() const;

        void setStartupTimeStop(const bool b);

        void setDitheringMode(DitheringMode mode);

        void setDitheringMode(const QString& modeName);

        bool getUseCustomTimeZone(void) const;

        void setUseCustomTimeZone(const bool b);

        //! Set the current date in Modified Julian Day (UT).

        //! MJD is simply JD-2400000.5, getting rid of large numbers and starting days at midnight.

        //! It is mostly used in satellite contexts.

        void setMJDay(double MJD);

        //! Get the current date in Modified Julian Day (UT)

        double getMJDay() const;

        //! Compute DeltaT estimation for a given date [seconds].

        //! DeltaT is the accumulated effect of earth's rotation slowly getting slower, mostly caused by tidal braking by the Moon.

        //! For accurate positioning of objects in the sky, we must compute earth-based clock-dependent things like earth rotation, hour angles etc.

        //! using plain UT, but all orbital motions or rotation of the other planets must be computed in TT, which is a regular time frame.

        //! Also satellites are computed in the UT frame because (1) they are short-lived and (2) must follow paths over earth ground.

        //! (Note that we make no further difference between TT and DT, those might differ by milliseconds at best but are regarded equivalent for our purpose.)

        //! @param JD the date and time expressed as a Julian Day

        //! @return DeltaT in seconds

        //! @note Thanks to Rob van Gent who created a collection from many formulas for calculation of DeltaT: http://www.staff.science.uu.nl/~gent0113/deltat/deltat.htm

        //! @note Use this only if needed, prefer calling getDeltaT() for access to the current value.

        //! @note Up to V0.15.1, if the requested year was outside validity range, we returned zero or some useless value.

        //!       Starting with V0.15.2 the value from the edge of the defined range is returned instead if not explicitly zero is given in the source.

        //!       Limits can be queried with getCurrentDeltaTAlgorithmValidRangeDescription()

        double computeDeltaT(const double JD);

        //! Get current DeltaT in seconds.

        double getDeltaT() const;

        //! @return whether nutation is currently used.

        //! Set whether you want computation and simulation of nutation (a slight wobble of Earth's axis, just a few arcseconds).

        //! @return whether aberration is currently used.

        //! Set whether you want computation and simulation of aberration (a slight wobble of stellar positions due to finite speed of light, about 20 arcseconds when observing from earth).

        //! @return aberration factor. 1 is realistic simulation, but higher values may be useful for didactic purposes.

        //! Set aberration factor. Values are clamped to 0...5. (Values above 5 cause graphical problems.)

        QByteArray getAberrationShader() const;

        void setAberrationUniforms(QOpenGLShaderProgram& program) const;

        //! @return whether parallax effect is currently used.

        //! Set whether you want computation and simulation of parallax effect.

        //! @return parallax factor. 1 is realistic simulation, but higher values may be useful for didactic purposes.

        //! Set aberration factor. Values are clamped to 0...5. (Values above 5 cause graphical problems.)

        //! @return whether topocentric coordinates are currently used.

        //! Set whether you want topocentric or planetocentric data

        //! Return the preset sky time in JD

        double getPresetSkyTime() const;

        //! Set the preset sky time from a JD

        void setPresetSkyTime(double d);

        //! Set time speed in JDay/sec

        void setTimeRate(double ts);

        //! Get time speed in JDay/sec

        double getTimeRate() const;

        void revertTimeDirection(void);

        //! Increase the time speed

        void increaseTimeSpeed();

        //! Decrease the time speed

        void decreaseTimeSpeed();

        //! Increase the time speed, but not as much as with increaseTimeSpeed()

        void increaseTimeSpeedLess();

        //! Decrease the time speed but not as much as with decreaseTimeSpeed()

        void decreaseTimeSpeedLess();

        //! Set time speed to 0, i.e. freeze the passage of simulation time

        void setZeroTimeSpeed();

        //! Set real time speed, i.e. 1 sec/sec

        void setRealTimeSpeed();

        //! Set real time speed or pause simulation if we are already in realtime speed.

        void toggleRealTimeSpeed();

        //! Get whether it is real time speed, i.e. 1 sec/sec

        bool getRealTimeSpeed() const;

        //! Set stellarium time to current real world time

        void setTimeNow();

        //! Set the time to some value, leaving the day the same.

        void setTodayTime(const QTime& target);

        //! Get whether the current stellarium time is the real world time

        bool getIsTimeNow() const;

        //! get the initial "today time" from the config file

        QTime getInitTodayTime(void) const;

        //! set the initial "today time" from the config file

        void setInitTodayTime(const QTime& time);

        //! Set the preset sky time from a QDateTime

        void setPresetSkyTime(QDateTime dateTime);

        //! Add one [Earth, solar] minute to the current simulation time.

        void addMinute();

        //! Add one [Earth, solar] hour to the current simulation time.

        void addHour();

        //! Add one [Earth, solar] day to the current simulation time.

        void addDay();

        //! Add one [Earth, solar] week to the current simulation time.

        void addWeek();

        //! Add one sidereal day to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located.

        void addSiderealDay();

        //! Add seven sidereal days to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located.

        void addSiderealWeek();

        //! Add one sidereal year to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located. Sidereal year

        //! connected to orbital period of planets.

        void addSiderealYear();

        //! Add n sidereal years to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located. Sidereal year

        //! connected to orbital period of planets.

        void addSiderealYears(double n=100.);

        //! Subtract one [Earth, solar] minute to the current simulation time.

        void subtractMinute();

        //! Subtract one [Earth, solar] hour to the current simulation time.

        void subtractHour();

        //! Subtract one [Earth, solar] day to the current simulation time.

        void subtractDay();

        //! Subtract one [Earth, solar] week to the current simulation time.

        void subtractWeek();

        //! Subtract one sidereal day to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located.

        void subtractSiderealDay();

        //! Subtract seven sidereal days to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located.

        void subtractSiderealWeek();

        //! Subtract one sidereal year to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located. Sidereal year

        //! connected to orbital period of planets.

        void subtractSiderealYear();

        //! Subtract n sidereal years to the simulation time. The length of time depends

        //! on the current planetary body on which the observer is located. Sidereal year

        //! connected to orbital period of planets.

        void subtractSiderealYears(double n=100.);

        //! Add one synodic month to the simulation time.

        void addSynodicMonth();

        //! Add one saros (223 synodic months) to the simulation time.

        void addSaros();

        //! Add one draconic year to the simulation time.

        void addDraconicYear();

        //! Add one draconic month to the simulation time.

        void addDraconicMonth();

        //! Add one anomalistic month to the simulation time.

        void addAnomalisticMonth();

        //! Add one anomalistic year to the simulation time.

        void addAnomalisticYear();

        //! Add n anomalistic years to the simulation time.

        void addAnomalisticYears(double n=100.);

        //! Add one mean tropical month to the simulation time.

        void addMeanTropicalMonth();

        //! Add one mean tropical year to the simulation time.

        void addMeanTropicalYear();

        //! Add n mean tropical years to the simulation time.

        void addMeanTropicalYears(double n=100.);

        //! Add one tropical year to the simulation time.

        void addTropicalYear();

        //! Add one great year

        //! Great Year [NASA SP-7, 1965] - the period of one complete cycle of the equinoxes around the ecliptic, about 25,800 years.

        //! https://web.archive.org/web/20050421192849/http://www.hq.nasa.gov/office/hqlibrary/aerospacedictionary/aerodictall/g.html

        void addGreatYear();

        //! Add one calendar month to the simulation time.

        void addCalendarMonth();

        //! Add one calendar year to the simulation time.

        void addCalendarYear();

        //! Add one calendar decade to the simulation time.

        void addCalendarDecade();

        //! Add one calendar century to the simulation time.

        void addCalendarCentury();

        //! Add one Julian year to the simulation time.

        void addJulianYear();

        //! Add n Julian years to the simulation time.

        void addJulianYears(double n=100.);

        //! Add one Gaussian year to the simulation time. The Gaussian Year is 365.2568983 days, and is C.F.Gauss's value for the Sidereal Year.

        //! Note that 1 GaussY=2 π/k where k is the Gaussian gravitational constant. A massless body orbits one solar mass in 1AU distance in a Gaussian Year.

        void addGaussianYear();

        //! Subtract one synodic month from the simulation time.

        void subtractSynodicMonth();

        //! Subtract one saros (223 synodic months) from the simulation time.

        void subtractSaros();

        //! Subtract one draconic year from the simulation time.

        void subtractDraconicYear();

        //! Subtract one draconic month from the simulation time.

        void subtractDraconicMonth();

        //! Subtract one anomalistic month from the simulation time.

        void subtractAnomalisticMonth();

        //! Subtract one anomalistic year from the simulation time.

        void subtractAnomalisticYear();

        //! Subtract n anomalistic years from the simulation time.

        void subtractAnomalisticYears(double n=100.);

        //! Subtract one mean tropical month from the simulation time.

        void subtractMeanTropicalMonth();

        //! Subtract one mean tropical year from the simulation time.

        void subtractMeanTropicalYear();

        //! Subtract n mean tropical years from the simulation time.

        void subtractMeanTropicalYears(double n=100.);

        //! Subtract one tropical year from the simulation time.

        void subtractTropicalYear();

        //! Subtract one great year

        //! Great Year [NASA SP-7, 1965] - the period of one complete cycle of the equinoxes around the ecliptic, about 25,800 years.

        //! https://web.archive.org/web/20050421192849/http://www.hq.nasa.gov/office/hqlibrary/aerospacedictionary/aerodictall/g.html

        void subtractGreatYear();

        //! Subtract one calendar month from the simulation time.

        void subtractCalendarMonth();

        //! Subtract one calendar year from the simulation time.

        void subtractCalendarYear();

        //! Subtract one calendar decade from the simulation time.

        void subtractCalendarDecade();

        //! Subtract one calendar century from the simulation time.

        void subtractCalendarCentury();

        //! Subtract one Julian year from the simulation time.

        void subtractJulianYear();

        //! Subtract n Julian years from the simulation time.

        void subtractJulianYears(double n=100.);

        //! Subtract one Gaussian year from the simulation time.

        void subtractGaussianYear();

        //! Add a number of Earth Solar days to the current simulation time

        //! @param d the decimal number of days to add (use negative values to subtract)

        void addSolarDays(double d);

        //! Add a number of sidereal days to the current simulation time,

        //! based on the observer body's rotational period.

        //! @param d the decimal number of sidereal days to add (use negative values to subtract)

        void addSiderealDays(double d);

        //! Move the observer to the selected object. This will only do something if

        //! the selected object is of the correct type - i.e. a planet.

        void moveObserverToSelected();

        //! Set central year for custom equation for calculation of DeltaT

        //! @param y the year, e.g. 1820

        //! Set n-dot for custom equation for calculation of DeltaT

        //! @param v the n-dot value, e.g. -26.0

        //! Set coefficients for custom equation for calculation of DeltaT

        //! @param c the coefficients, e.g. -20,0,32

        //! Get central year for custom equation for calculation of DeltaT

        //! Get n-dot for custom equation for calculation of DeltaT

        //! Get n-dot for current DeltaT algorithm

        //! Get coefficients for custom equation for calculation of DeltaT

        //! initialize ephemerides calculation functions

        void initEphemeridesFunctions();

        bool de430IsAvailable();            //!< true if DE430 ephemeris file has been found

        bool de431IsAvailable();            //!< true if DE431 ephemeris file has been found

        bool de430IsActive();               //!< true if DE430 ephemeris is in use

        bool de431IsActive();               //!< true if DE431 ephemeris is in use

        void setDe430Active(bool status);   //!< switch DE430 use to @param status (if de430IsAvailable()). DE430 is only used if date is within range of DE430.

        void setDe431Active(bool status);   //!< switch DE431 use to @param status (if de431IsAvailable()). DE431 is only used if DE430 is not used and the date is within range of DE431.

        bool de440IsAvailable();            //!< true if DE440 ephemeris file has been found

        bool de441IsAvailable();            //!< true if DE441 ephemeris file has been found

        bool de440IsActive();               //!< true if DE440 ephemeris is in use

        bool de441IsActive();               //!< true if DE441 ephemeris is in use

        void setDe440Active(bool status);   //!< switch DE440 use to @param status (if de440IsAvailable()). DE440 is only used if date is within range of DE440.

        void setDe441Active(bool status);   //!< switch DE441 use to @param status (if de441IsAvailable()). DE441 is only used if DE440 is not used and the date is within range of DE441.

        //! Set min and max range of dates for ephemeris

        //! Get min and max range of dates for ephemeris

        //! Return 3-letter abbreviation of IAU constellation name for position in equatorial coordinates on the current epoch.

        //! Follows 1987PASP...99..695R: Nancy Roman: Identification of a Constellation from a Position

        //! Data file from ADC catalog VI/42 with its amendment from 1999-12-30.

        //! @param positionEqJnow position vector in rectangular equatorial coordinates of current epoch&equinox.

        QString getIAUConstellation(const Vec3d &positionEqJnow) const;

        //! Returns naked-eye limiting magnitude corresponding to the given sky luminance in cd/m².

        static float luminanceToNELM(float luminance);

        //! Returns sky luminance in cd/m² corresponding to the given naked-eye limiting magnitude.

        static float nelmToLuminance(float nelm);

        //! Returns some representative naked-eye limiting magnitude for the given Bortle scale index.

        static float bortleScaleIndexToNELM(int index);

        //! Returns some representative value of zenith luminance in cd/m² for the given Bortle scale index.

        //! Classifies the sky using the Bortle scale using zenith naked-eye limiting magnitude as input.

        static int nelmToBortleScaleIndex(float nelm);

        //! Classifies the sky using the Bortle scale using zenith luminance in cd/m² as input.

        //! Converts luminance in cd/m² to magnitude/arcsec².

        //! Converts magnitude/arcsec² to luminance in cd/m².

signals:

        //! This signal is emitted when the observer location has changed.

        void locationChanged(const StelLocation&);

        //! This signal is emitted whenever the targeted location changes, i.e., at the onset of location transitions.

        //! The second parameter can transmit a landscapeID or should be QString().

        void targetLocationChanged(const StelLocation& loc, const QString& id);

        //! This signal is emitted when the current timezone name is changed.

        void currentTimeZoneChanged(const QString& tz);

        //! This signal is emitted when custom timezone use is activated (true) or deactivated (false).

        void useCustomTimeZoneChanged(const bool b);

        //! This signal is emitted when daylight saving time is enabled or disabled.

        void flagUseDSTChanged(const bool b);

        //! This signal is emitted when stop clock at startup is enabled or disabled.

        void startupTimeStopChanged(const bool b);

        //! This signal is emitted when the time rate has changed

        void timeRateChanged(double rate);

        //! This signal is emitted whenever the time is re-synced.

        //! This happens whenever the internal jDay is changed through setJDay/setMJDay and similar,

        //! and whenever the time rate changes.

        void timeSyncOccurred(double jDay);

        //! This signal is emitted when the date has changed.

        void dateChanged();

        //! This signal can be emitted when e.g. the date has changed in a way that planet trails or similar things should better be reset.

        //! TODO: Currently the signal is not used. Think of the proper way to apply it.

        void dateChangedForTrails();

        //! This signal is emitted when the date has changed for a month.

        void dateChangedForMonth();

        //! This signal is emitted when the date has changed by one year.

        void dateChangedByYear(const int year);

        //! This signal indicates a horizontal display flip

        void flipHorzChanged(bool b);

        //! This signal indicates a vertical display flip

        void flipVertChanged(bool b);

        //! This signal indicates a switch in use of nutation

        void flagUseNutationChanged(bool b);

        //! This signal indicates a switch in use of aberration

        void flagUseAberrationChanged(bool b);

        //! This signal indicates a change in aberration exaggeration factor

        void aberrationFactorChanged(double val);

        //! This signal indicates a switch in use of parallax

        void flagUseParallaxChanged(bool b);

        //! This signal indicates a change in parallax exaggeration factor

        void parallaxFactorChanged(double val);

        //! This signal indicates a switch in use of topocentric coordinates

        void flagUseTopocentricCoordinatesChanged(bool b);

        //! Emitted whenever the projection type changes

        void currentProjectionTypeChanged(StelCore::ProjectionType newType);

        //! Emitted whenever the projection type changes

        void currentProjectionTypeKeyChanged(const QString& newValue);

        //! Emitted whenever the projection type changes

        void currentProjectionNameI18nChanged(const QString& newValue);

        //! Emitted when gravity label use is changed

        void flagGravityLabelsChanged(bool gravity);

        //! Emitted when button "Save settings" is pushed

        void configurationDataSaved();

        void updateSearchLists();

        void ditheringModeChanged(DitheringMode mode);

        //! Called just after algorithm/theory for ephemeris is changed in the GUI

        void ephemAlgorithmChanged();

private slots:

        //! Call this whenever latitude changes. I.e., just connect it to the locationChanged() signal.

        void updateFixedEquatorialTransformMatrices();

private:

        DitheringMode parseDitheringMode(const QString& s);

        static const QMap<QString, DitheringMode>ditheringMap;

private:

        StelToneReproducer* toneReproducer;                // Tones conversion between stellarium world and display device

        StelSkyDrawer* skyDrawer;

        StelMovementMgr* movementMgr;                // Manage vision movements

        StelPropertyMgr* propMgr;

        // 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;

        //! This is called in every frame to set rotation matrices for the various movable projection frames.

        //! The rarely updated frame transform between AltAz and Fixed Equatorial is set in updateFixedEquatorialTransformMatrices() instead.

        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 matAltAzToFixedEquatorial;           // Transform from topocentric altazimuthal coordinate to Fixed Equatorial system (hour angle/decl)

        Mat4d matFixedEquatorialToAltAz;           // Transform from Fixed Equatorial (hour angle/decl) to topocentric (StelObserver) altazimuthal coordinate

        Mat4d matHeliocentricEclipticToEquinoxEqu; // Transform from heliocentric ecliptic Cartesian (VSOP87A) to earth equatorial coordinate

        Mat4d matEquinoxEquDateToJ2000;            // 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 we want to use aberration (a small-scale wobble of stellar positions (~20 arceconds on earth) due to finite speed of light and observer in motion on a planet.)

        bool flagUseAberration;

        // value to allow exaggerating aberration effects. 1 is natural value, stretching to e.g. 1000 may be useful for explanations.

        double aberrationFactor;