5926409083

Committed 21 Aug 2023 12:45PM UTC coverage: 11.905% (+0.01%) from 11.891%

Build # 5926409083

Build Type

Pull #3373

github

Committed by

gzotti

Commit Message

Reduce verbosity a bit.

Pull Request Pull Request #3373: Fix: unambiguous comet names

Run Details

264 of 264 new or added lines in 9 files covered. (100.0%)

14845 of 124700 relevant lines covered (11.9%)

23289.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/core/modules/SolarSystem.cpp

/*
 * Stellarium
 * Copyright (C) 2002 Fabien Chereau
 * Copyright (C) 2010 Bogdan Marinov
 * Copyright (C) 2011 Alexander Wolf
 *
 * 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.
 */

#include "SolarSystem.hpp"
#include "StelTexture.hpp"
#include "EphemWrapper.hpp"
#include "Orbit.hpp"

#include "StelProjector.hpp"
#include "StelApp.hpp"
#include "StelCore.hpp"
#include "StelTextureMgr.hpp"
#include "StelObjectMgr.hpp"
#include "StelLocaleMgr.hpp"
#include "StelSkyCultureMgr.hpp"
#include "StelFileMgr.hpp"
#include "StelModuleMgr.hpp"
#include "StelIniParser.hpp"
#include "Planet.hpp"
#include "MinorPlanet.hpp"
#include "Comet.hpp"
#include "StelMainView.hpp"

#include "StelSkyDrawer.hpp"
#include "StelUtils.hpp"
#include "StelPainter.hpp"
#include "TrailGroup.hpp"

#include "AstroCalcDialog.hpp"
#include "StelObserver.hpp"

#include <algorithm>

#include <QTextStream>
#include <QSettings>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QMap>
#include <QMultiMap>
#include <QMapIterator>
#include <QDebug>
#include <QDir>
#include <QHash>

SolarSystem::SolarSystem() : StelObjectModule()
        , shadowPlanetCount(0)
        , earthShadowEnlargementDanjon(false)
        , flagMoonScale(false)
        , moonScale(1.0)
        , flagMinorBodyScale(false)
        , minorBodyScale(1.0)
        , flagPlanetScale(false)
        , planetScale(1.0)
        , flagSunScale(false)
        , sunScale(1.0)
        , labelsAmount(false)
        , flagPermanentSolarCorona(true)
        , flagOrbits(false)
        , flagLightTravelTime(true)
        , flagUseObjModels(false)
        , flagShowObjSelfShadows(true)
        , flagShow(false)
        , flagPointer(false)
        , flagNativePlanetNames(false)
        , flagIsolatedTrails(true)
        , numberIsolatedTrails(0)
        , maxTrailPoints(5000)
        , maxTrailTimeExtent(1)
        , trailsThickness(1)
        , flagIsolatedOrbits(true)
        , flagPlanetsOrbitsOnly(false)
        , flagOrbitsWithMoons(false)
        , ephemerisMarkersDisplayed(true)
        , ephemerisDatesDisplayed(false)
        , ephemerisMagnitudesDisplayed(false)
        , ephemerisHorizontalCoordinates(false)
        , ephemerisLineDisplayed(false)
        , ephemerisAlwaysOn(false)
        , ephemerisNow(false)
        , ephemerisLineThickness(1)
        , ephemerisSkipDataDisplayed(false)
        , ephemerisSkipMarkersDisplayed(false)
        , ephemerisDataStep(1)
        , ephemerisDataLimit(1)
        , ephemerisSmartDatesDisplayed(true)
        , ephemerisScaleMarkersDisplayed(false)
        , ephemerisGenericMarkerColor(Vec3f(1.0f, 1.0f, 0.0f))
        , ephemerisSecondaryMarkerColor(Vec3f(0.7f, 0.7f, 1.0f))
        , ephemerisSelectedMarkerColor(Vec3f(1.0f, 0.7f, 0.0f))
        , ephemerisMercuryMarkerColor(Vec3f(1.0f, 1.0f, 0.0f))
        , ephemerisVenusMarkerColor(Vec3f(1.0f, 1.0f, 1.0f))
        , ephemerisMarsMarkerColor(Vec3f(1.0f, 0.0f, 0.0f))
        , ephemerisJupiterMarkerColor(Vec3f(0.3f, 1.0f, 1.0f))
        , ephemerisSaturnMarkerColor(Vec3f(0.0f, 1.0f, 0.0f))
        , allTrails(Q_NULLPTR)
        , conf(StelApp::getInstance().getSettings())
{
        planetNameFont.setPixelSize(StelApp::getInstance().getScreenFontSize());
        connect(&StelApp::getInstance(), SIGNAL(screenFontSizeChanged(int)), this, SLOT(setFontSize(int)));
        setObjectName("SolarSystem");
        connect(this, SIGNAL(flagOrbitsChanged(bool)),            this, SLOT(reconfigureOrbits()));
        connect(this, SIGNAL(flagPlanetsOrbitsOnlyChanged(bool)), this, SLOT(reconfigureOrbits()));
        connect(this, SIGNAL(flagIsolatedOrbitsChanged(bool)),    this, SLOT(reconfigureOrbits()));
        connect(this, SIGNAL(flagOrbitsWithMoonsChanged(bool)),   this, SLOT(reconfigureOrbits()));
}

void SolarSystem::setFontSize(int newFontSize)
{
        planetNameFont.setPixelSize(newFontSize);
}

SolarSystem::~SolarSystem()
{
        // release selected:
        selected.clear();
        selectedSSO.clear();
        for (auto* orb : qAsConst(orbits))
        {
                delete orb;
                orb = Q_NULLPTR;
        }
        sun.clear();
        moon.clear();
        earth.clear();
        Planet::hintCircleTex.clear();
        Planet::texEarthShadow.clear();

        texEphemerisMarker.clear();
        texEphemerisCometMarker.clear();
        texEphemerisNowMarker.clear();
        texPointer.clear();

        delete allTrails;
        allTrails = Q_NULLPTR;

        // Get rid of circular reference between the shared pointers which prevent proper destruction of the Planet objects.
        for (const auto& p : qAsConst(systemPlanets))
        {
                p->satellites.clear();
        }

        //delete comet textures created in loadPlanets
        Comet::comaTexture.clear();
        Comet::tailTexture.clear();

        //deinit of SolarSystem is NOT called at app end automatically
        SolarSystem::deinit();
}

/*************************************************************************
 Re-implementation of the getCallOrder method
*************************************************************************/
double SolarSystem::getCallOrder(StelModuleActionName actionName) const
{
        if (actionName==StelModule::ActionDraw)
                return StelApp::getInstance().getModuleMgr().getModule("StarMgr")->getCallOrder(actionName)+10;
        return 0;
}

// Init and load the solar system data
void SolarSystem::init()
{
        Q_ASSERT(conf);

        Planet::init();
        loadPlanets();        // Load planets data

        // Compute position and matrix of sun and all the satellites (ie planets)
        // for the first initialization Q_ASSERT that center is sun center (only impacts on light speed correction)        
        computePositions(StelApp::getInstance().getCore()->getJDE(), getSun());

        setSelected("");        // Fix a bug on macosX! Thanks Fumio!
        setFlagDrawMoonHalo(conf->value("viewing/flag_draw_moon_halo", true).toBool());
        setFlagDrawSunHalo(conf->value("viewing/flag_draw_sun_halo", true).toBool());
        setFlagMoonScale(conf->value("viewing/flag_moon_scaled", conf->value("viewing/flag_init_moon_scaled", false).toBool()).toBool());  // name change
        setMoonScale(conf->value("viewing/moon_scale", 4.0).toDouble());
        setMinorBodyScale(conf->value("viewing/minorbodies_scale", 10.0).toDouble());
        setFlagMinorBodyScale(conf->value("viewing/flag_minorbodies_scaled", false).toBool());
        setFlagPlanetScale(conf->value("viewing/flag_planets_scaled", false).toBool());
        setPlanetScale(conf->value("viewing/planets_scale", 150.0).toDouble());
        setFlagSunScale(conf->value("viewing/flag_sun_scaled", false).toBool());
        setSunScale(conf->value("viewing/sun_scale", 4.0).toDouble());
        setFlagPlanets(conf->value("astro/flag_planets").toBool());
        setFlagHints(conf->value("astro/flag_planets_hints").toBool());
        setFlagLabels(conf->value("astro/flag_planets_labels", true).toBool());
        setLabelsAmount(conf->value("astro/labels_amount", 3.).toDouble());
        setFlagOrbits(conf->value("astro/flag_planets_orbits").toBool());
        setFlagLightTravelTime(conf->value("astro/flag_light_travel_time", true).toBool());
        setFlagUseObjModels(conf->value("astro/flag_use_obj_models", false).toBool());
        setFlagShowObjSelfShadows(conf->value("astro/flag_show_obj_self_shadows", true).toBool());
        setFlagPointer(conf->value("astro/flag_planets_pointers", true).toBool());
        // Set the algorithm from Astronomical Almanac for computation of apparent magnitudes for
        // planets in case  observer on the Earth by default
        setApparentMagnitudeAlgorithmOnEarth(conf->value("astro/apparent_magnitude_algorithm", "Mallama2018").toString());
        setFlagNativePlanetNames(conf->value("viewing/flag_planets_native_names", true).toBool());
        // Is enabled the showing of isolated trails for selected objects only?
        setFlagIsolatedTrails(conf->value("viewing/flag_isolated_trails", true).toBool());
        setNumberIsolatedTrails(conf->value("viewing/number_isolated_trails", 1).toInt());
        setMaxTrailPoints(conf->value("viewing/max_trail_points", 5000).toInt());
        setMaxTrailTimeExtent(conf->value("viewing/max_trail_time_extent", 1).toInt());
        setFlagIsolatedOrbits(conf->value("viewing/flag_isolated_orbits", true).toBool());
        setFlagPlanetsOrbitsOnly(conf->value("viewing/flag_planets_orbits_only", false).toBool());
        setFlagOrbitsWithMoons(conf->value("viewing/flag_orbits_with_moons", false).toBool());
        setFlagPermanentOrbits(conf->value("astro/flag_permanent_orbits", false).toBool());
        setOrbitColorStyle(conf->value("astro/planets_orbits_color_style", "one_color").toString());

        // Settings for calculation of position of Great Red Spot on Jupiter
        setGrsLongitude(conf->value("astro/grs_longitude", 216).toInt());
        setGrsDrift(conf->value("astro/grs_drift", 15.).toDouble());
        setGrsJD(conf->value("astro/grs_jd", 2456901.5).toDouble());

        setFlagEarthShadowEnlargementDanjon(conf->value("astro/shadow_enlargement_danjon", false).toBool());
        setFlagPermanentSolarCorona(conf->value("viewing/flag_draw_sun_corona", true).toBool());

        // Load colors from config file
        QString defaultColor = conf->value("color/default_color").toString();
        setLabelsColor(                    Vec3f(conf->value("color/planet_names_color", defaultColor).toString()));
        setOrbitsColor(                    Vec3f(conf->value("color/sso_orbits_color", defaultColor).toString()));
        setMajorPlanetsOrbitsColor(        Vec3f(conf->value("color/major_planet_orbits_color", "0.7,0.2,0.2").toString()));
        setMoonsOrbitsColor(               Vec3f(conf->value("color/moon_orbits_color", "0.7,0.2,0.2").toString()));
        setMinorPlanetsOrbitsColor(        Vec3f(conf->value("color/minor_planet_orbits_color", "0.7,0.5,0.5").toString()));
        setDwarfPlanetsOrbitsColor(        Vec3f(conf->value("color/dwarf_planet_orbits_color", "0.7,0.5,0.5").toString()));
        setCubewanosOrbitsColor(           Vec3f(conf->value("color/cubewano_orbits_color", "0.7,0.5,0.5").toString()));
        setPlutinosOrbitsColor(            Vec3f(conf->value("color/plutino_orbits_color", "0.7,0.5,0.5").toString()));
        setScatteredDiskObjectsOrbitsColor(Vec3f(conf->value("color/sdo_orbits_color", "0.7,0.5,0.5").toString()));
        setOortCloudObjectsOrbitsColor(    Vec3f(conf->value("color/oco_orbits_color", "0.7,0.5,0.5").toString()));
        setCometsOrbitsColor(              Vec3f(conf->value("color/comet_orbits_color", "0.7,0.8,0.8").toString()));
        setSednoidsOrbitsColor(            Vec3f(conf->value("color/sednoid_orbits_color", "0.7,0.5,0.5").toString()));
        setInterstellarOrbitsColor(        Vec3f(conf->value("color/interstellar_orbits_color", "1.0,0.6,1.0").toString()));
        setMercuryOrbitColor(              Vec3f(conf->value("color/mercury_orbit_color", "0.5,0.5,0.5").toString()));
        setVenusOrbitColor(                Vec3f(conf->value("color/venus_orbit_color", "0.9,0.9,0.7").toString()));
        setEarthOrbitColor(                Vec3f(conf->value("color/earth_orbit_color", "0.0,0.0,1.0").toString()));
        setMarsOrbitColor(                 Vec3f(conf->value("color/mars_orbit_color", "0.8,0.4,0.1").toString()));
        setJupiterOrbitColor(              Vec3f(conf->value("color/jupiter_orbit_color", "1.0,0.6,0.0").toString()));
        setSaturnOrbitColor(               Vec3f(conf->value("color/saturn_orbit_color", "1.0,0.8,0.0").toString()));
        setUranusOrbitColor(               Vec3f(conf->value("color/uranus_orbit_color", "0.0,0.7,1.0").toString()));
        setNeptuneOrbitColor(              Vec3f(conf->value("color/neptune_orbit_color", "0.0,0.3,1.0").toString()));
        setTrailsColor(                    Vec3f(conf->value("color/object_trails_color", defaultColor).toString()));
        setPointerColor(                   Vec3f(conf->value("color/planet_pointers_color", "1.0,0.3,0.3").toString()));

        // Ephemeris stuff
        setFlagEphemerisMarkers(conf->value("astrocalc/flag_ephemeris_markers", true).toBool());
        setFlagEphemerisAlwaysOn(conf->value("astrocalc/flag_ephemeris_alwayson", true).toBool());
        setFlagEphemerisNow(conf->value("astrocalc/flag_ephemeris_now", false).toBool());
        setFlagEphemerisDates(conf->value("astrocalc/flag_ephemeris_dates", false).toBool());
        setFlagEphemerisMagnitudes(conf->value("astrocalc/flag_ephemeris_magnitudes", false).toBool());
        setFlagEphemerisHorizontalCoordinates(conf->value("astrocalc/flag_ephemeris_horizontal", false).toBool());
        setFlagEphemerisLine(conf->value("astrocalc/flag_ephemeris_line", false).toBool());
        setEphemerisLineThickness(conf->value("astrocalc/ephemeris_line_thickness", 1).toInt());
        setFlagEphemerisSkipData(conf->value("astrocalc/flag_ephemeris_skip_data", false).toBool());
        setFlagEphemerisSkipMarkers(conf->value("astrocalc/flag_ephemeris_skip_markers", false).toBool());
        setEphemerisDataStep(conf->value("astrocalc/ephemeris_data_step", 1).toInt());        
        setFlagEphemerisSmartDates(conf->value("astrocalc/flag_ephemeris_smart_dates", true).toBool());
        setFlagEphemerisScaleMarkers(conf->value("astrocalc/flag_ephemeris_scale_markers", false).toBool());
        setEphemerisGenericMarkerColor( Vec3f(conf->value("color/ephemeris_generic_marker_color", "1.0,1.0,0.0").toString()));
        setEphemerisSecondaryMarkerColor( Vec3f(conf->value("color/ephemeris_secondary_marker_color", "0.7,0.7,1.0").toString()));
        setEphemerisSelectedMarkerColor(Vec3f(conf->value("color/ephemeris_selected_marker_color", "1.0,0.7,0.0").toString()));
        setEphemerisMercuryMarkerColor( Vec3f(conf->value("color/ephemeris_mercury_marker_color", "1.0,1.0,0.0").toString()));
        setEphemerisVenusMarkerColor(   Vec3f(conf->value("color/ephemeris_venus_marker_color", "1.0,1.0,1.0").toString()));
        setEphemerisMarsMarkerColor(    Vec3f(conf->value("color/ephemeris_mars_marker_color", "1.0,0.0,0.0").toString()));
        setEphemerisJupiterMarkerColor( Vec3f(conf->value("color/ephemeris_jupiter_marker_color", "0.3,1.0,1.0").toString()));
        setEphemerisSaturnMarkerColor(  Vec3f(conf->value("color/ephemeris_saturn_marker_color", "0.0,1.0,0.0").toString()));

        setOrbitsThickness(conf->value("astro/object_orbits_thickness", 1).toInt());
        setTrailsThickness(conf->value("astro/object_trails_thickness", 1).toInt());
        recreateTrails();
        setFlagTrails(conf->value("astro/flag_object_trails", false).toBool());

        StelObjectMgr *objectManager = GETSTELMODULE(StelObjectMgr);
        objectManager->registerStelObjectMgr(this);
        connect(objectManager, SIGNAL(selectedObjectChanged(StelModule::StelModuleSelectAction)),
                this, SLOT(selectedObjectChange(StelModule::StelModuleSelectAction)));

        texPointer = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/pointeur4.png");
        texEphemerisMarker = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/disk.png");
        texEphemerisNowMarker = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/gear.png");
        texEphemerisCometMarker = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/cometIcon.png");
        Planet::hintCircleTex = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/planet-indicator.png");
        
        StelApp *app = &StelApp::getInstance();
        connect(app, SIGNAL(languageChanged()), this, SLOT(updateI18n()));
        connect(&app->getSkyCultureMgr(), SIGNAL(currentSkyCultureChanged(QString)), this, SLOT(updateSkyCulture(QString)));
        connect(&StelMainView::getInstance(), SIGNAL(reloadShadersRequested()), this, SLOT(reloadShaders()));
        StelCore *core = app->getCore();
        connect(core, SIGNAL(locationChanged(StelLocation)), this, SLOT(recreateTrails()));
        connect(core, SIGNAL(dateChangedForTrails()), this, SLOT(recreateTrails()));

        QString displayGroup = N_("Display Options");
        addAction("actionShow_Planets", displayGroup, N_("Planets"), "planetsDisplayed", "P");
        addAction("actionShow_Planets_Labels", displayGroup, N_("Planet labels"), "labelsDisplayed", "Alt+P");
        addAction("actionShow_Planets_Orbits", displayGroup, N_("Planet orbits"), "flagOrbits", "O");
        addAction("actionShow_Planets_Trails", displayGroup, N_("Planet trails"), "trailsDisplayed", "Shift+T");
        addAction("actionShow_Planets_Trails_Reset", displayGroup, N_("Planet trails reset"), "recreateTrails()"); // No hotkey predefined.
        //there is a small discrepancy in the GUI: "Show planet markers" actually means show planet hints
        addAction("actionShow_Planets_Hints", displayGroup, N_("Planet markers"), "flagHints", "Ctrl+P");
        addAction("actionShow_Planets_Pointers", displayGroup, N_("Planet selection marker"), "flagPointer", "Ctrl+Shift+P");
        addAction("actionShow_Planets_EnlargeMoon", displayGroup, N_("Enlarge Moon"), "flagMoonScale");
        addAction("actionShow_Planets_EnlargeMinor", displayGroup, N_("Enlarge minor bodies"), "flagMinorBodyScale");
        addAction("actionShow_Planets_EnlargePlanets", displayGroup, N_("Enlarge Planets"), "flagPlanetScale");
        addAction("actionShow_Planets_EnlargeSun", displayGroup, N_("Enlarge Sun"), "flagSunScale");
        addAction("actionShow_Skyculture_NativePlanetNames", displayGroup, N_("Native planet names (from starlore)"), "flagNativePlanetNames", "Ctrl+Shift+N");

        connect(StelApp::getInstance().getModule("HipsMgr"), SIGNAL(gotNewSurvey(HipsSurveyP)),
                        this, SLOT(onNewSurvey(HipsSurveyP)));

        // Fill ephemeris dates
        connect(this, SIGNAL(requestEphemerisVisualization()), this, SLOT(fillEphemerisDates()));
        connect(this, SIGNAL(ephemerisDataStepChanged(int)), this, SLOT(fillEphemerisDates()));
        connect(this, SIGNAL(ephemerisSkipDataChanged(bool)), this, SLOT(fillEphemerisDates()));
        connect(this, SIGNAL(ephemerisSkipMarkersChanged(bool)), this, SLOT(fillEphemerisDates()));
        connect(this, SIGNAL(ephemerisSmartDatesChanged(bool)), this, SLOT(fillEphemerisDates()));
}

void SolarSystem::deinit()
{
        Planet::deinitShader();
        Planet::deinitFBO();
}

void SolarSystem::resetTextures(const QString &planetName)
{
        if (planetName.isEmpty())
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        p->resetTextures();
                }
        }
        else
        {
                PlanetP planet = searchByEnglishName(planetName);
                if (!planet.isNull())
                        planet->resetTextures();
        }
}

void SolarSystem::setTextureForPlanet(const QString& planetName, const QString& texName)
{
        PlanetP planet = searchByEnglishName(planetName);
        if (!planet.isNull())
                planet->replaceTexture(texName);
        else
                qWarning() << "The planet" << planetName << "was not found. Please check the name.";
}

void SolarSystem::recreateTrails()
{
        // Create a trail group containing all the planets orbiting the sun (not including satellites)
        if (allTrails!=Q_NULLPTR)
                delete allTrails;
        allTrails = new TrailGroup(maxTrailTimeExtent * 365.f, maxTrailPoints);

        unsigned long cnt = static_cast<unsigned long>(selectedSSO.size());
        if (cnt>0 && getFlagIsolatedTrails())
        {
                unsigned long limit = static_cast<unsigned long>(getNumberIsolatedTrails());
                if (cnt<limit)
                        limit = cnt;
                for (unsigned long i=0; i<limit; i++)
                {
                        if (selectedSSO[cnt - i - 1]->getPlanetType() != Planet::isObserver)
                                allTrails->addObject(static_cast<QSharedPointer<StelObject>>(selectedSSO[cnt - i - 1]), &trailsColor);
                }
        }
        else
        {
                for (const auto& p : qAsConst(getSun()->satellites))
                {
                        if (p->getPlanetType() != Planet::isObserver)
                                allTrails->addObject(static_cast<QSharedPointer<StelObject>>(p), &trailsColor);
                }
                // Add moons of current planet
                StelCore *core=StelApp::getInstance().getCore();
                const StelObserver *obs=core->getCurrentObserver();
                if (obs)
                {
                        const QSharedPointer<Planet> planet=obs->getHomePlanet();
                        for (const auto& m : qAsConst(planet->satellites))
                                if (m->getPlanetType() != Planet::isObserver)
                                        allTrails->addObject(static_cast<QSharedPointer<StelObject>>(m), &trailsColor);
                }
        }
}


void SolarSystem::updateSkyCulture(const QString& skyCultureDir)
{
        planetNativeNamesMap.clear();
        planetNativeNamesMeaningMap.clear();

        QString namesFile = StelFileMgr::findFile("skycultures/" + skyCultureDir + "/planet_names.fab");

        if (namesFile.isEmpty())
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        if (p->getPlanetType()==Planet::isPlanet || p->getPlanetType()==Planet::isMoon || p->getPlanetType()==Planet::isStar)
                        {
                                p->setNativeName("");
                                p->setNativeNameMeaning("");
                        }
                }
                updateI18n();
                return;
        }

        // Open file
        QFile planetNamesFile(namesFile);
        if (!planetNamesFile.open(QIODevice::ReadOnly | QIODevice::Text))
        {
                qDebug() << " Cannot open file" << QDir::toNativeSeparators(namesFile);
                return;
        }

        // Now parse the file
        // lines to ignore which start with a # or are empty
        static const QRegularExpression commentRx("^(\\s*#.*|\\s*)$");

        // lines which look like records - we use the RE to extract the fields
        // which will be available in recRx.capturedTexts()
        static const QRegularExpression recRx("^\\s*(\\w+)\\s+\"(.+)\"\\s+_[(]\"(.+)\"[)]\\n");

        QString record, planetId, nativeName, nativeNameMeaning;

        // keep track of how many records we processed.
        int totalRecords=0;
        int readOk=0;
        int lineNumber=0;
        while (!planetNamesFile.atEnd())
        {
                record = QString::fromUtf8(planetNamesFile.readLine());
                lineNumber++;

                // Skip comments
                if (commentRx.match(record).hasMatch())
                        continue;

                totalRecords++;

                QRegularExpressionMatch match=recRx.match(record);
                if (!match.hasMatch())
                {
                        qWarning() << "ERROR - cannot parse record at line" << lineNumber << "in planet names file" << QDir::toNativeSeparators(namesFile);
                }
                else
                {
                        planetId          = match.captured(1).trimmed();
                        nativeName        = match.captured(2).trimmed();
                        nativeNameMeaning = match.captured(3).trimmed();
                        planetNativeNamesMap[planetId] = nativeName;
                        planetNativeNamesMeaningMap[planetId] = nativeNameMeaning;
                        readOk++;
                }
        }
        planetNamesFile.close();
        qDebug() << "Loaded" << readOk << "/" << totalRecords << "native names of planets";

        for (const auto& p : qAsConst(systemPlanets))
        {
                if (p->getPlanetType()==Planet::isPlanet || p->getPlanetType()==Planet::isMoon || p->getPlanetType()==Planet::isStar)
                {
                        p->setNativeName(planetNativeNamesMap[p->getEnglishName()]);
                        p->setNativeNameMeaning(planetNativeNamesMeaningMap[p->getEnglishName()]);
                }
        }

        updateI18n();
}

void SolarSystem::reloadShaders()
{
        Planet::deinitShader();
        Planet::initShader();
}

void SolarSystem::drawPointer(const StelCore* core)
{
        const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);

        const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Planet");
        if (!newSelected.empty())
        {
                const StelObjectP obj = newSelected[0];
                Vec3d pos=obj->getJ2000EquatorialPos(core);

                Vec3f screenpos;
                // Compute 2D pos and return if outside screen
                if (!prj->project(pos, screenpos))
                        return;

                StelPainter sPainter(prj);
                sPainter.setColor(getPointerColor());

                float screenSize = static_cast<float>(obj->getAngularRadius(core))*prj->getPixelPerRadAtCenter()*M_PI_180f*2.f;
                
                const float scale = static_cast<float>(prj->getDevicePixelsPerPixel())*StelApp::getInstance().getGlobalScalingRatio();
                screenSize+= scale * (45.f + 10.f*std::sin(2.f * static_cast<float>(StelApp::getInstance().getAnimationTime())));

                texPointer->bind();

                sPainter.setBlending(true);

                screenSize*=0.5f;
                const float angleBase = static_cast<float>(StelApp::getInstance().getAnimationTime()) * 10;
                // We draw 4 instances of the sprite at the corners of the pointer
                for (int i = 0; i < 4; ++i)
                {
                        const float angle = angleBase + i * 90;
                        const float x = screenpos[0] + screenSize * cos(angle * M_PI_180f);
                        const float y = screenpos[1] + screenSize * sin(angle * M_PI_180f);
                        sPainter.drawSprite2dMode(x, y, 10, angle);
                }
        }
}

void keplerOrbitPosFunc(double jd,double xyz[3], double xyzdot[3], void* orbitPtr)
{
        static_cast<KeplerOrbit*>(orbitPtr)->positionAtTimevInVSOP87Coordinates(jd, xyz);
        static_cast<KeplerOrbit*>(orbitPtr)->getVelocity(xyzdot);
}

void gimbalOrbitPosFunc(double jd,double xyz[3], double xyzdot[3], void* orbitPtr)
{
        static_cast<GimbalOrbit*>(orbitPtr)->positionAtTimevInVSOP87Coordinates(jd, xyz);
        static_cast<GimbalOrbit*>(orbitPtr)->getVelocity(xyzdot);
}

// Init and load the solar system data (2 files)
void SolarSystem::loadPlanets()
{
        minorBodies.clear();
        systemMinorBodies.clear();
        qDebug() << "Loading Solar System data (1: planets and moons) ...";
        QString solarSystemFile = StelFileMgr::findFile("data/ssystem_major.ini");
        if (solarSystemFile.isEmpty())
        {
                qWarning() << "ERROR while loading ssystem_major.ini (unable to find data/ssystem_major.ini):" << StelUtils::getEndLineChar();
                return;
        }

        if (!loadPlanets(solarSystemFile))
        {
                qWarning() << "ERROR while loading ssystem_major.ini:" << StelUtils::getEndLineChar();
                return;
        }

        qDebug() << "Loading Solar System data (2: minor bodies) ...";
        QStringList solarSystemFiles = StelFileMgr::findFileInAllPaths("data/ssystem_minor.ini");
        if (solarSystemFiles.isEmpty())
        {
                qWarning() << "ERROR while loading ssystem_minor.ini (unable to find data/ssystem_minor.ini):" << StelUtils::getEndLineChar();
                return;
        }

        for (const auto& solarSystemFile : qAsConst(solarSystemFiles))
        {
                if (loadPlanets(solarSystemFile))
                {
                        qDebug() << "File ssystem_minor.ini is loaded successfully...";
                        break;
                }
                else
                {
//                        sun.clear();
//                        moon.clear();
//                        earth.clear();
                        //qCritical() << "We should not be here!";

                        qDebug() << "Removing minor bodies";
                        for (const auto& p : qAsConst(systemPlanets))
                        {
                                // We can only delete minor objects now!
                                if (p->pType >= Planet::isAsteroid)
                                {
                                        p->satellites.clear();
                                }
                        }                        
                        systemPlanets.clear();                        
                        //Memory leak? What's the proper way of cleaning shared pointers?

                        // TODO: 0.16pre what about the orbits list?

                        //If the file is in the user data directory, rename it:
                        if (solarSystemFile.contains(StelFileMgr::getUserDir()))
                        {
                                QString newName = QString("%1/data/ssystem_minor-%2.ini").arg(StelFileMgr::getUserDir(), QDateTime::currentDateTime().toString("yyyyMMddThhmmss"));
                                if (QFile::rename(solarSystemFile, newName))
                                        qWarning() << "Invalid Solar System file" << QDir::toNativeSeparators(solarSystemFile) << "has been renamed to" << QDir::toNativeSeparators(newName);
                                else
                                {
                                        qWarning() << "Invalid Solar System file" << QDir::toNativeSeparators(solarSystemFile) << "cannot be removed!";
                                        qWarning() << "Please either delete it, rename it or move it elsewhere.";
                                }
                        }
                }
        }

        shadowPlanetCount = 0;

        for (const auto& planet : qAsConst(systemPlanets))
                if(planet->parent != sun || !planet->satellites.isEmpty())
                        shadowPlanetCount++;
}

unsigned char SolarSystem::BvToColorIndex(double bV)
{
        const double dBV = qBound(-500., static_cast<double>(bV)*1000.0, 3499.);
        return static_cast<unsigned char>(floor(0.5+127.0*((500.0+dBV)/4000.0)));
}

bool SolarSystem::loadPlanets(const QString& filePath)
{
        StelSkyDrawer* skyDrawer = StelApp::getInstance().getCore()->getSkyDrawer();
        qDebug().noquote() << "Loading from:"  << filePath;
        QSettings pd(filePath, StelIniFormat);
        if (pd.status() != QSettings::NoError)
        {
                qWarning().noquote() << "ERROR while parsing" << QDir::toNativeSeparators(filePath);
                return false;
        }

        // QSettings does not allow us to say that the sections of the file
        // will be listed in the same order  as in the file like the old
        // InitParser used to so we can no longer assume that.
        //
        // This means we must first decide what order to read the sections
        // of the file in (each section contains one planet/moon/asteroid/comet/...) to avoid setting
        // the parent Planet* to one which has not yet been created.
        //
        // Stage 1: Make a map of body names back to the section names
        // which they come from. Also make a map of body name to parent body
        // name. These two maps can be made in a single pass through the
        // sections of the file.
        //
        // Stage 2: Make an ordered list of section names such that each
        // item is only ever dependent on items which appear earlier in the
        // list.
        // 2a: Make a QMultiMap relating the number of levels of dependency
        //     to the body name, i.e.
        //     0 -> Sun
        //     1 -> Mercury
        //     1 -> Venus
        //     1 -> Earth
        //     2 -> Moon
        //     etc.
        // 2b: Populate an ordered list of section names by iterating over
        //     the QMultiMap.  This type of container is always sorted on the
        //     key in ascending order, so it's easy.
        //     i.e. [sun, earth, moon] is fine, but not [sun, moon, earth]
        //
        // Stage 3: iterate over the ordered sections decided in stage 2,
        // creating the planet objects from the QSettings data.

        // Stage 1 (as described above).
        QMap<QString, QString> secNameMap;
        QMap<QString, QString> parentMap;
        QStringList sections = pd.childGroups();
        // qDebug() << "Stage 1: load ini file with" << sections.size() << "entries: "<< sections;
        for (int i=0; i<sections.size(); ++i)
        {
                const QString secname = sections.at(i);
                const QString englishName = pd.value(secname+"/name", pd.value(secname+"/iau_designation")).toString();
                if (englishName.isEmpty())
                        qWarning() << "SSO without proper name found in" << filePath << "section" << secname;
                const QString strParent = pd.value(secname+"/parent", "Sun").toString();
                // Only for sorting here we must find our own temporary object name. This is similar but not equal to IAU practice, and must be exactly repeated in the next loop in Stage 2a.
                QString obName=englishName;
                const bool isMinor=QStringList({"asteroid", "plutino", "comet", "dwarf planet", "cubewano", "scattered disc object", "oco", "sednoid", "interstellar object"}).contains(pd.value(secname+"/type").toString());
                if (isMinor && englishName!="Pluto")
                {
                        const QString designation = pd.value(secname+"/iau_designation", pd.value(secname+"/minor_planet_number")).toString();
                        if (designation.isEmpty() && (pd.value(secname+"/type") != "comet"))
                                qWarning() << "Minor body " << englishName << "has incomplete data (missing iau_designation or minor_planet_number) in" << filePath << "section" << secname;
                        obName=(QString("%1 (%2)").arg(designation, englishName));
                }
                if (secNameMap.contains(obName))
                        qWarning() << "secNameMap already contains " << obName << ". Overwriting data.";
                secNameMap[obName] = secname;
                if (strParent!="none" && !strParent.isEmpty() && !englishName.isEmpty())
                {
                        parentMap[obName] = strParent;
                        // qDebug() << "parentmap[" << obName << "] = " << strParent;
                }
        }

        // Stage 2a (as described above).
        QMultiMap<int, QString> depLevelMap;
        for (int i=0; i<sections.size(); ++i)
        {
                const QString secname = sections.at(i);
                const QString englishName = pd.value(secname+"/name", pd.value(secname+"/iau_designation")).toString();
                QString obName=englishName;
                const bool isMinor=QStringList({"asteroid", "plutino", "comet", "dwarf planet", "cubewano", "scattered disc object", "oco", "sednoid", "interstellar object"}).contains(pd.value(secname+"/type").toString());
                if (isMinor && englishName!="Pluto")
                {
                        const QString designation = pd.value(secname+"/iau_designation", pd.value(secname+"/minor_planet_number")).toString();
                        obName=(QString("%1 (%2)").arg(designation, englishName));
                }
                // follow dependencies, incrementing level when we have one till we run out.
                QString p=obName;
                int level = 0;
                while(parentMap.contains(p) && parentMap[p]!="none")
                {
                        level++;
                        p = parentMap[p];
                }

                depLevelMap.insert(level, secNameMap[obName]);
                // qDebug() << "2a: Level" << level << "secNameMap[" << obName << "]="<< secNameMap[obName];
        }

        // Stage 2b (as described above).
        // qDebug() << "Stage 2b:";
        QStringList orderedSections;
#if (QT_VERSION>=QT_VERSION_CHECK(6,0,0))
        QMultiMapIterator<int, QString> levelMapIt(depLevelMap);
#else
        QMapIterator<int, QString> levelMapIt(depLevelMap);
#endif
        while(levelMapIt.hasNext())
        {
                levelMapIt.next();
                orderedSections << levelMapIt.value();
        }
        // qDebug() << orderedSections;

        // Stage 3 (as described above).
        int readOk=0;
        //int totalPlanets=0;

        // qDebug() << "Adding " << orderedSections.size() << "objects...";
        for (int i = 0;i<orderedSections.size();++i)
        {
                // qDebug() << "Processing entry" << orderedSections.at(i);

                //totalPlanets++;
                const QString secname = orderedSections.at(i);
                const QString type = pd.value(secname+"/type").toString();
                QString englishName = pd.value(secname+"/name").toString().simplified();
                // englishName alone may be a combination of several elements...
                if (type=="comet" || type == "interstellar object")
                {
                        static const QRegularExpression periodicRe("^([1-9][0-9]*[PD](-\\w+)?)"); // No "/" at end, there are nameless numbered comets! (e.g. 362P, 396P)
                        QRegularExpressionMatch periodMatch=periodicRe.match(englishName);

                        static const QRegularExpression iauDesignationRe("^([1-9][0-9]*[PD](-\\w+)?)|([CA]/[-0-9]+\\s[A-Y])");
                        QRegularExpressionMatch iauDesignationMatch=iauDesignationRe.match(englishName);

                        // Our name rules for the final englishName, which must contain one element in brackets.
                        // Numbered periodic comets: "1P/Halley (1986)"
                        // All others: C-AX/2023 A2 (discoverer)". (with optional fragment code -AX)
                        const QString iauDesignation = pd.value(secname+"/iau_designation").toString();
                        const QString dateCode =      pd.value(secname+"/date_code").toString();
                        const QString perihelCode =   pd.value(secname+"/perihelion_code").toString();
                        const QString discoveryCode = pd.value(secname+"/discovery_code").toString();
                        if (iauDesignation.isEmpty() && perihelCode.isEmpty() && discoveryCode.isEmpty() && !periodMatch.hasMatch() && !iauDesignationMatch.hasMatch())
                                qWarning() << "Comet " << englishName << "has no IAU designation, no perihelion code, no discovery code and seems not a numbered comet in section " << secname;
                        // order of codes: date_code [P/1982 U1] - perihelion_code [1986 III] - discovery_code [1982i]

                        // The test here can be improved, e.g. with a regexp. In case the name is already reasonably complete, we do not re-build it from the available elements for now. However, the ini file should provide the elements separated!
                        if (iauDesignation.isEmpty() && !englishName.contains("("))
                                englishName.append(QString(" (%1)").arg(discoveryCode));
                        else if (!iauDesignation.isEmpty() && !englishName.contains("(") && !englishName.contains("/"))
                                englishName=QString("%1 (%2)").arg(iauDesignation, englishName); // recombine name and iau_designation if name is only the discoverer name.

                        if (!englishName.contains("("))
                        {
                                QString name;
                                if (!iauDesignation.isEmpty())
                                {
                                        name=iauDesignation;
                                        if (!englishName.isEmpty())
                                                name.append(QString(" (%1)").arg(englishName));
                                }
                                else if (!dateCode.isEmpty())
                                {
                                        name=dateCode;
                                        if (!englishName.isEmpty())
                                                name.append(QString(" (%1)").arg(englishName));
                                }
                                else if (!discoveryCode.isEmpty())
                                {
                                        name=discoveryCode;
                                        if (!englishName.isEmpty())
                                                name.append(QString(" (%1)").arg(englishName));
                                }
                                else if (!perihelCode.isEmpty())
                                {
                                        name.append(QString("C/%1").arg(perihelCode)); // This is not classic, but a final fallback before warning
                                        if (!englishName.isEmpty())
                                                name.append(QString(" (%1)").arg(englishName));
                                }

                                if (name.contains("("))
                                        englishName=name;
                                else
                                        qWarning() << "Comet " << englishName << "has no proper name elements in section " << secname;
                        }
                }
                else if (QStringList({"asteroid", "dwarf planet", "cubewano", "sednoid", "plutino", "scattered disc object", "Oort cloud object"}).contains(type) && !englishName.contains("Pluto"))
                {
                        const int minorPlanetNumber= pd.value(secname+"/minor_planet_number").toInt();
                        const QString iauDesignation = pd.value(secname+"/iau_designation", "").toString();
                        if (iauDesignation.isEmpty() && minorPlanetNumber==0)
                                qWarning() << "minor body " << englishName << "has no IAU code in section " << secname;
                        const QString discoveryCode = pd.value(secname+"/discovery_code").toString();

                        // The test here can be improved, e.g. with a regexp. In case the name is already reasonably complete, we do not re-build it from the available elements
                        if (englishName.isEmpty())
                        {
                                //if (minorPlanetNumber>0)
                                //        englishName=QString("(%1) ").arg(minorPlanetNumber);
                                if (!iauDesignation.isEmpty())
                                {
                                        englishName.append(iauDesignation);
                                }
                                else if (!discoveryCode.isEmpty())
                                {
                                        englishName.append(discoveryCode);
                                }
                                else
                                        qWarning() << "Minor body in section" << secname << "has no proper name elements";
                        }
                }

                const double bV = pd.value(secname+"/color_index_bv", 99.).toDouble();
                const QString strParent = pd.value(secname+"/parent", "Sun").toString(); // Obvious default, keep file entries simple.
                PlanetP parent;
                if (strParent!="none")
                {
                        // Look in the other planets the one named with strParent
                        for (const auto& p : qAsConst(systemPlanets))
                        {
                                if (p->getCommonEnglishName()==strParent)
                                {
                                        parent = p;
                                        break;
                                }
                        }
                        if (parent.isNull())
                        {
                                qWarning().noquote().nospace() << "ERROR: can't find parent solar system body for " << englishName << ". Skipping.";
                                //abort();
                                continue;
                        }
                }
                Q_ASSERT(parent || englishName=="Sun");

                const QString coordFuncName = pd.value(secname+"/coord_func", "kepler_orbit").toString(); // 0.20: new default for all non *_special.
                // qDebug() << "englishName:" << englishName << ", parent:" << strParent <<  ", coord_func:" << coordFuncName;
                posFuncType posfunc=Q_NULLPTR;
                Orbit* orbitPtr=Q_NULLPTR;
                OsculatingFunctType *osculatingFunc = Q_NULLPTR;
                bool closeOrbit = true;
                double semi_major_axis=0; // used again below.


#ifdef USE_GIMBAL_ORBIT
                // undefine the flag in Orbit.h to disable and use the old, static observer solution (on an infinitely slow KeplerOrbit)
                // Note that for now we ignore any orbit-related config values except orbit_SemiMajorAxis from the ini file.
                if (type=="observer")
                {
                        double unit = 1; // AU
                        double defaultSemiMajorAxis = 1;
                        if (strParent!="Sun")
                        {
                                unit /= AU;  // Planet moons have distances given in km in the .ini file! But all further computation done in AU.
                                defaultSemiMajorAxis *= AU;
                        }
                        semi_major_axis = pd.value(secname+"/orbit_SemiMajorAxis", defaultSemiMajorAxis).toDouble() * unit;
                        // Create a pseudo orbit that allows interaction with keyboard
                        GimbalOrbit *orb = new GimbalOrbit(semi_major_axis, 0.*M_PI_180, 45.*M_PI_180); // [Over mid-north latitude]
                        orb->setMinDistance(parent->getEquatorialRadius()*1.5);
                        orbits.push_back(orb);

                        orbitPtr = orb;
                        posfunc = &gimbalOrbitPosFunc;
                }
                else
#endif
                if ((coordFuncName=="kepler_orbit") || (coordFuncName=="comet_orbit") || (coordFuncName=="ell_orbit")) // ell_orbit used for planet moons. TBD in V1.0: remove non-kepler_orbit!
                {
                        if (coordFuncName!="kepler_orbit")
                                qDebug() << "Old-fashioned entry" << coordFuncName << "found. Please delete line from " << filePath << "section" << secname;
                        // ell_orbit was used for planet moons, comet_orbit for minor bodies. The only difference is that pericenter distance for moons is given in km, not AU.
                        // Read the orbital elements                        
                        const double eccentricity = pd.value(secname+"/orbit_Eccentricity", 0.0).toDouble();
                        if (eccentricity >= 1.0) closeOrbit = false;
                        double pericenterDistance = pd.value(secname+"/orbit_PericenterDistance",-1e100).toDouble(); // AU, or km for Moons (those where parent!=sun)!
                        if (pericenterDistance <= 0.0) {
                                semi_major_axis = pd.value(secname+"/orbit_SemiMajorAxis",-1e100).toDouble();
                                if (semi_major_axis <= -1e100) {
                                        qDebug() << "ERROR loading " << englishName << "from section" << secname
                                                 << ": you must provide orbit_PericenterDistance or orbit_SemiMajorAxis. Skipping " << englishName;
                                        continue;
                                } else {
                                        Q_ASSERT(eccentricity != 1.0); // parabolic orbits have no semi_major_axis
                                        pericenterDistance = semi_major_axis * (1.0-eccentricity);
                                }
                        } else {
                                semi_major_axis = (eccentricity == 1.0)
                                                                ? 0.0 // parabolic orbits have no semi_major_axis
                                                                : pericenterDistance / (1.0-eccentricity);
                        }
                        if (strParent!="Sun")
                                pericenterDistance /= AU;  // Planet moons have distances given in km in the .ini file! But all further computation done in AU.

                        double meanMotion = pd.value(secname+"/orbit_MeanMotion",-1e100).toDouble(); // degrees/day
                        if (meanMotion <= -1e100) {
                                const double period = pd.value(secname+"/orbit_Period",-1e100).toDouble();
                                if (period <= -1e100) {
                                        if (parent->getParent()) {
                                                qWarning().noquote() << "ERROR: " << englishName
                                                           << ": when the parent body is not the sun, you must provide "
                                                           << "either orbit_MeanMotion or orbit_Period";
                                        } else {
                                                // in case of parent=sun: use Gaussian gravitational constant for calculating meanMotion:
                                                meanMotion = (eccentricity == 1.0)
                                                                        ? 0.01720209895 * (1.5/pericenterDistance) * std::sqrt(0.5/pericenterDistance)  // Heafner: Fund.Eph.Comp. W / dt
                                                                        : 0.01720209895 / (fabs(semi_major_axis)*std::sqrt(fabs(semi_major_axis)));
                                        }
                                } else {
                                        meanMotion = 2.0*M_PI/period;
                                }
                        } else {
                                meanMotion *= (M_PI/180.0);
                        }

                        const double ascending_node = pd.value(secname+"/orbit_AscendingNode", 0.0).toDouble()*(M_PI/180.0);
                        double arg_of_pericenter = pd.value(secname+"/orbit_ArgOfPericenter",-1e100).toDouble();
                        double long_of_pericenter;
                        if (arg_of_pericenter <= -1e100) {
                                long_of_pericenter = pd.value(secname+"/orbit_LongOfPericenter", 0.0).toDouble()*(M_PI/180.0);
                                arg_of_pericenter = long_of_pericenter - ascending_node;
                        } else {
                                arg_of_pericenter *= (M_PI/180.0);
                                long_of_pericenter = arg_of_pericenter + ascending_node;
                        }

                        double time_at_pericenter = pd.value(secname+"/orbit_TimeAtPericenter",-1e100).toDouble();
                        // In earlier times (up to 0.21.2) we did not care much to store orbital epoch for comets but silently assumed T for it in various places.
                        // However, the distinction is relevant to discern element sets for various valid ranges.
                        // Comet orbits epoch should default to T while planets or moons default to J2000.
                        const double epoch = pd.value(secname+"/orbit_Epoch", type=="comet" ? time_at_pericenter : J2000).toDouble();
                        if (time_at_pericenter <= -1e100) {
                                double mean_anomaly = pd.value(secname+"/orbit_MeanAnomaly",-1e100).toDouble()*(M_PI/180.0);
                                if (mean_anomaly <= -1e10) {
                                        double mean_longitude = pd.value(secname+"/orbit_MeanLongitude",-1e100).toDouble()*(M_PI/180.0);
                                        if (mean_longitude <= -1e10) {
                                                qWarning().noquote() << "ERROR: " << englishName
                                                           << ": when you do not provide orbit_TimeAtPericenter, you must provide orbit_Epoch"
                                                           << "and either one of orbit_MeanAnomaly or orbit_MeanLongitude. Skipping this object.";
                                                //abort();
                                                continue;
                                        } else {
                                                mean_anomaly = mean_longitude - long_of_pericenter;
                                        }
                                }
                                time_at_pericenter = epoch - mean_anomaly / meanMotion;
                        }

                        static const QMap<QString, double>massMap={ // masses from DE430/431
                                { "Sun",            1.0},
                                { "Mercury",  6023682.155592},
                                { "Venus",     408523.718658},
                                { "Earth",     332946.048834},
                                { "Mars",     3098703.590291},
                                { "Jupiter",     1047.348625},
                                { "Saturn",      3497.901768},
                                { "Uranus",     22902.981613},
                                { "Neptune",    19412.259776},
                                { "Pluto",  135836683.768617}};

                        // Construct orbital elements relative to the parent body. This will construct orbits for J2000 only.
                        // Some planet axes move very slowly, this effect could be modelled by replicating these lines
                        // after recomputing obliquity and node (below) in Planet::computeTransMatrix().
                        // The effect is negligible for several millennia, though.
                        // When the parent is the sun use ecliptic rather than sun equator:
                        const double parentRotObliquity  = parent->getParent() ? parent->getRotObliquity(J2000) : 0.0;
                        const double parent_rot_asc_node = parent->getParent() ? parent->getRotAscendingNode()  : 0.0;
                        double parent_rot_j2000_longitude = 0.0;
                        if (parent->getParent()) {
                                const double c_obl = cos(parentRotObliquity);
                                const double s_obl = sin(parentRotObliquity);
                                const double c_nod = cos(parent_rot_asc_node);
                                const double s_nod = sin(parent_rot_asc_node);
                                const Vec3d OrbitAxis0( c_nod,       s_nod,        0.0);
                                const Vec3d OrbitAxis1(-s_nod*c_obl, c_nod*c_obl,s_obl);
                                const Vec3d OrbitPole(  s_nod*s_obl,-c_nod*s_obl,c_obl);
                                const Vec3d J2000Pole(StelCore::matJ2000ToVsop87.multiplyWithoutTranslation(Vec3d(0,0,1)));
                                Vec3d J2000NodeOrigin(J2000Pole^OrbitPole);
                                J2000NodeOrigin.normalize();
                                parent_rot_j2000_longitude = atan2(J2000NodeOrigin*OrbitAxis1,J2000NodeOrigin*OrbitAxis0);
                        }

                        const double orbitGoodDays=pd.value(secname+"/orbit_good", parent->englishName!="Sun" ? 0. : -1.).toDouble(); // "Moons" have permanently good orbits.
                        const double inclination = pd.value(secname+"/orbit_Inclination", 0.0).toDouble()*(M_PI/180.0);

                        // Create a Keplerian orbit. This has been called CometOrbit before 0.20.
                        //qDebug() << "Creating KeplerOrbit for" << parent->englishName << "---" << englishName;
                        KeplerOrbit *orb = new KeplerOrbit(epoch,                  // JDE
                                                           pericenterDistance,     // [AU]
                                                           eccentricity,           // 0..>1 (>>1 for Interstellar objects)
                                                           inclination,            // [radians]
                                                           ascending_node,         // [radians]
                                                           arg_of_pericenter,      // [radians]
                                                           time_at_pericenter,     // JDE
                                                           orbitGoodDays,          // orbitGoodDays. 0=always good, -1=compute_half_orbit_duration
                                                           meanMotion,             // [radians/day]
                                                           parentRotObliquity,     // [radians]
                                                           parent_rot_asc_node,    // [radians]
                                                           parent_rot_j2000_longitude, // [radians]
                                                           1./massMap.value(parent->englishName, 1.)); // central mass [solar masses]
                        orbits.push_back(orb);

                        orbitPtr = orb;
                        posfunc = &keplerOrbitPosFunc;
                }
                else
                {
                        static const QMap<QString, posFuncType>posfuncMap={
                                { "sun_special",       &get_sun_helio_coordsv},
                                { "mercury_special",   &get_mercury_helio_coordsv},
                                { "venus_special",     &get_venus_helio_coordsv},
                                { "earth_special",     &get_earth_helio_coordsv},
                                { "lunar_special",     &get_lunar_parent_coordsv},
                                { "mars_special",      &get_mars_helio_coordsv},
                                { "phobos_special",    &get_phobos_parent_coordsv},
                                { "deimos_special",    &get_deimos_parent_coordsv},
                                { "jupiter_special",   &get_jupiter_helio_coordsv},
                                { "io_special",        &get_io_parent_coordsv},
                                { "europa_special",    &get_europa_parent_coordsv},
                                { "ganymede_special",  &get_ganymede_parent_coordsv},
                                { "calisto_special",   &get_callisto_parent_coordsv},
                                { "callisto_special",  &get_callisto_parent_coordsv},
                                { "saturn_special",    &get_saturn_helio_coordsv},
                                { "mimas_special",     &get_mimas_parent_coordsv},
                                { "enceladus_special", &get_enceladus_parent_coordsv},
                                { "tethys_special",    &get_tethys_parent_coordsv},
                                { "dione_special",     &get_dione_parent_coordsv},
                                { "rhea_special",      &get_rhea_parent_coordsv},
                                { "titan_special",     &get_titan_parent_coordsv},
                                { "hyperion_special",  &get_hyperion_parent_coordsv},
                                { "iapetus_special",   &get_iapetus_parent_coordsv},
                                { "helene_special",    &get_helene_parent_coordsv},
                                { "telesto_special",   &get_telesto_parent_coordsv},
                                { "calypso_special",   &get_calypso_parent_coordsv},
                                { "uranus_special",    &get_uranus_helio_coordsv},
                                { "miranda_special",   &get_miranda_parent_coordsv},
                                { "ariel_special",     &get_ariel_parent_coordsv},
                                { "umbriel_special",   &get_umbriel_parent_coordsv},
                                { "titania_special",   &get_titania_parent_coordsv},
                                { "oberon_special",    &get_oberon_parent_coordsv},
                                { "neptune_special",   &get_neptune_helio_coordsv},
                                { "pluto_special",     &get_pluto_helio_coordsv}};
                        static const QMap<QString, OsculatingFunctType*>osculatingMap={
                                { "mercury_special",   &get_mercury_helio_osculating_coords},
                                { "venus_special",     &get_venus_helio_osculating_coords},
                                { "earth_special",     &get_earth_helio_osculating_coords},
                                { "mars_special",      &get_mars_helio_osculating_coords},
                                { "jupiter_special",   &get_jupiter_helio_osculating_coords},
                                { "saturn_special",    &get_saturn_helio_osculating_coords},
                                { "uranus_special",    &get_uranus_helio_osculating_coords},
                                { "neptune_special",   &get_neptune_helio_osculating_coords}};
                        posfunc=posfuncMap.value(coordFuncName, Q_NULLPTR);
                        osculatingFunc=osculatingMap.value(coordFuncName, Q_NULLPTR);
                }
                if (posfunc==Q_NULLPTR)
                {
                        qCritical() << "ERROR in section " << secname << ": can't find posfunc " << coordFuncName << " for " << englishName;
                        exit(-1);
                }

                // Create the Solar System body and add it to the list
                //TODO: Refactor the subclass selection to reduce duplicate code mess here,
                // by at least using this base class pointer and using setXXX functions instead of mega-constructors
                // that have to pass most of it on to the Planet class
                PlanetP newP;

                // New class objects, named "plutino", "cubewano", "dwarf planet", "SDO", "OCO", has properties
                // similar to asteroids and we should calculate their positions like for asteroids. Dwarf planets
                // have one exception: Pluto - as long as we use a special function for calculation of Pluto's orbit.
                if ((type == "asteroid" || type == "dwarf planet" || type == "cubewano" || type=="sednoid" || type == "plutino" || type == "scattered disc object" || type == "Oort cloud object" || type == "interstellar object") && !englishName.contains("Pluto"))
                {
                        minorBodies << englishName;

                        Vec3f color = Vec3f(1.f, 1.f, 1.f);
                        if (bV<99.)
                                color = skyDrawer->indexToColor(BvToColorIndex(bV))*0.75f; // see ZoneArray.cpp:L490
                        else
                                color = Vec3f(pd.value(secname+"/color", "1.0,1.0,1.0").toString());

                        const bool hidden = pd.value(secname+"/hidden", false).toBool();
                        const QString normalMapName = ( hidden ? "" : englishName.toLower().append("_normals.png")); // no normal maps for invisible objects!
                        const QString horizonMapName = ( hidden ? "" : englishName.toLower().append("_normals.png")); // no normal maps for invisible objects!

                        newP = PlanetP(new MinorPlanet(englishName,
                                                    pd.value(secname+"/radius", 1.0).toDouble()/AU,
                                                    pd.value(secname+"/oblateness", 0.0).toDouble(),
                                                    color, // halo color
                                                    pd.value(secname+"/albedo", 0.25f).toFloat(),
                                                    pd.value(secname+"/roughness",0.9f).toFloat(),
                                                    pd.value(secname+"/tex_map", "nomap.png").toString(),
                                                    pd.value(secname+"/normals_map", normalMapName).toString(),
                                                    pd.value(secname+"/horizon_map", horizonMapName).toString(),
                                                    pd.value(secname+"/model").toString(),
                                                    posfunc,
                                                    static_cast<KeplerOrbit*>(orbitPtr), // the KeplerOrbit object created previously
                                                    osculatingFunc, // should be Q_NULLPTR
                                                    closeOrbit,
                                                    hidden,
                                                    type));
                        QSharedPointer<MinorPlanet> mp =  newP.dynamicCast<MinorPlanet>();
                        //Number, IAU provisional designation
                        mp->setMinorPlanetNumber(pd.value(secname+"/minor_planet_number", 0).toInt());
                        mp->setIAUDesignation(pd.value(secname+"/iau_designation", "").toString());

                        //H-G magnitude system
                        const float magnitude = pd.value(secname+"/absolute_magnitude", -99.f).toFloat();
                        const float slope = pd.value(secname+"/slope_parameter", 0.15f).toFloat();
                        if (magnitude > -99.f)
                        {
                                mp->setAbsoluteMagnitudeAndSlope(magnitude, qBound(0.0f, slope, 1.0f));
                        }

                        mp->setColorIndexBV(static_cast<float>(bV));
                        mp->setSpectralType(pd.value(secname+"/spec_t", "").toString(), pd.value(secname+"/spec_b", "").toString());

                        // Discovery circumstances
                        QString discovererName = pd.value(secname+"/discoverer", "").toString();
                        QString discoveryDate = pd.value(secname+"/discovery", "").toString();
                        if (!discoveryDate.isEmpty())
                                mp->setDiscoveryData(discoveryDate, discovererName);

                        // order of codes: date_code [P/1982 U1] - perihelion_code [1986 III] - discovery_code [1982i]
                        QStringList codes = { pd.value(secname+"/date_code", "").toString(),
                                              pd.value(secname+"/perihelion_code", "").toString(),
                                              pd.value(secname+"/discovery_code", "").toString() };
                        codes.removeAll("");
                        if (codes.count()>0)
                                mp->setExtraDesignations(codes);

                        if (semi_major_axis>0)
                                mp->deltaJDE = 2.0*semi_major_axis*StelCore::JD_SECOND;
                         else if ((semi_major_axis<=0.0) && (type!="interstellar object"))
                                qWarning().noquote() << "WARNING: Minor body" << englishName << "has no semimajor axis!";

                        systemMinorBodies.push_back(newP);
                }
                else if (type == "comet")
                {
                        minorBodies << englishName;
                        newP = PlanetP(new Comet(englishName,
                                              pd.value(secname+"/radius", 5.0).toDouble()/AU,
                                              pd.value(secname+"/oblateness", 0.0).toDouble(),
                                              Vec3f(pd.value(secname+"/color", "1.0,1.0,1.0").toString()), // halo color
                                              pd.value(secname+"/albedo", 0.075f).toFloat(), // assume very dark surface
                                              pd.value(secname+"/roughness",0.9f).toFloat(),
                                              pd.value(secname+"/outgas_intensity",0.1f).toFloat(),
                                              pd.value(secname+"/outgas_falloff", 0.1f).toFloat(),
                                              pd.value(secname+"/tex_map", "nomap.png").toString(),
                                              pd.value(secname+"/model").toString(),
                                              posfunc,
                                              static_cast<KeplerOrbit*>(orbitPtr), // the KeplerOrbit object
                                              osculatingFunc, // ALWAYS NULL for comets.
                                              closeOrbit,
                                              pd.value(secname+"/hidden", false).toBool(),
                                              type,
                                              pd.value(secname+"/dust_widthfactor", 1.5f).toFloat(),
                                              pd.value(secname+"/dust_lengthfactor", 0.4f).toFloat(),
                                              pd.value(secname+"/dust_brightnessfactor", 1.5f).toFloat()
                                              ));
                        QSharedPointer<Comet> mp = newP.dynamicCast<Comet>();

                        //g,k magnitude system
                        const float magnitude = pd.value(secname+"/absolute_magnitude", -99.f).toFloat();
                        const float slope = qBound(-5.0f, pd.value(secname+"/slope_parameter", 4.0f).toFloat(), 30.0f);
                        if (magnitude > -99.f)
                                        mp->setAbsoluteMagnitudeAndSlope(magnitude, slope);

                        QString iauDesignation = pd.value(secname+"/iau_designation", "").toString();
                        if (!iauDesignation.isEmpty())
                                mp->setIAUDesignation(iauDesignation);
                        // order of codes: date_code [P/1982 U1] - perihelion_code [1986 III] - discovery_code [1982i]
                        QStringList codes = { pd.value(secname+"/date_code", "").toString(),
                                              pd.value(secname+"/perihelion_code", "").toString(),
                                              pd.value(secname+"/discovery_code", "").toString() };
                        codes.removeAll("");
                        if (codes.count()>0)
                                mp->setExtraDesignations(codes);

                        // Discovery circumstances
                        QString discovererName = pd.value(secname+"/discoverer", "").toString();
                        QString discoveryDate = pd.value(secname+"/discovery", "").toString();
                        if (!discoveryDate.isEmpty())
                                mp->setDiscoveryData(discoveryDate, discovererName);

                        systemMinorBodies.push_back(newP);
                }
                else // type==star|planet|moon|dwarf planet|observer|artificial
                {
                        //qDebug() << type;
                        Q_ASSERT(type=="star" || type=="planet" || type=="moon" || type=="artificial" || type=="observer" || type=="dwarf planet"); // TBD: remove Pluto...
                        // Set possible default name of the normal map for avoiding yin-yang shaped moon
                        // phase when normal map key not exists. Example: moon_normals.png
                        // Details: https://bugs.launchpad.net/stellarium/+bug/1335609                        
                        newP = PlanetP(new Planet(englishName,
                                               pd.value(secname+"/radius", 1.0).toDouble()/AU,
                                               pd.value(secname+"/oblateness", 0.0).toDouble(),
                                               Vec3f(pd.value(secname+"/color", "1.0,1.0,1.0").toString()), // halo color
                                               pd.value(secname+"/albedo", 0.25f).toFloat(),
                                               pd.value(secname+"/roughness",0.9f).toFloat(),
                                               pd.value(secname+"/tex_map", "nomap.png").toString(),
                                               pd.value(secname+"/normals_map", englishName.toLower().append("_normals.png")).toString(),
                                               pd.value(secname+"/horizon_map", englishName.toLower().append("_horizon.png")).toString(),
                                               pd.value(secname+"/model").toString(),
                                               posfunc,
                                               static_cast<KeplerOrbit*>(orbitPtr), // This remains Q_NULLPTR for the major planets, or has a KeplerOrbit for planet moons.
                                               osculatingFunc,
                                               closeOrbit,
                                               pd.value(secname+"/hidden", false).toBool(),
                                               pd.value(secname+"/atmosphere", false).toBool(),
                                               pd.value(secname+"/halo", true).toBool(),
                                               type));
                        newP->absoluteMagnitude = pd.value(secname+"/absolute_magnitude", -99.f).toFloat();
                        newP->massKg = pd.value(secname+"/mass_kg", 0.).toDouble();

                        // Moon designation (planet index + IAU moon number)
                        QString moonDesignation = pd.value(secname+"/iau_moon_number", "").toString();
                        if (!moonDesignation.isEmpty())
                                newP->setIAUMoonNumber(moonDesignation);
                        newP->setColorIndexBV(static_cast<float>(bV));
                        // Discovery circumstances
                        QString discovererName = pd.value(secname+"/discoverer", "").toString();
                        QString discoveryDate = pd.value(secname+"/discovery", "").toString();
                        if (!discoveryDate.isEmpty())
                                newP->setDiscoveryData(discoveryDate, discovererName);
                }

                if (!parent.isNull())
                {
                        parent->satellites.append(newP);
                        newP->parent = parent;
                }
                if (secname=="earth") earth = newP;
                if (secname=="sun") sun = newP;
                if (secname=="moon") moon = newP;

                // At this point the orbit and object type (class Planet and subclasses) have been fixed.
                // For many objects we have oriented spheroids with rotational parameters.

                // There are two ways of defining the axis orientation:
                // obliquity and ascending node, which was used by Stellarium already before 2010 (based on Celestia?).
                double rotObliquity = pd.value(secname+"/rot_obliquity",0.).toDouble()*(M_PI_180);
                double rotAscNode = pd.value(secname+"/rot_equator_ascending_node",0.).toDouble()*(M_PI_180);
                // rot_periode given in hours (from which rotPeriod in days),
                // The default is useful for many moons in bound rotation
                double rotPeriod=pd.value(secname+"/rot_periode", pd.value(secname+"/orbit_Period", 1.).toDouble()*24.).toDouble()/24.;
                double rotOffset=pd.value(secname+"/rot_rotation_offset",0.).toDouble();

                // 0.21+: Use WGCCRE planet North pole data if available
                // NB: N pole for J2000 epoch as defined by IAU (NOT right hand rotation rule)
                // Define only basic motion. Use special functions for more complicated axes.
                const double J2000NPoleRA  = pd.value(secname+"/rot_pole_ra",  0.).toDouble()*M_PI_180;
                const double J2000NPoleRA1 = pd.value(secname+"/rot_pole_ra1", 0.).toDouble()*M_PI_180;
                const double J2000NPoleDE  = pd.value(secname+"/rot_pole_de",  0.).toDouble()*M_PI_180;
                const double J2000NPoleDE1 = pd.value(secname+"/rot_pole_de1", 0.).toDouble()*M_PI_180;
                const double J2000NPoleW0  = pd.value(secname+"/rot_pole_w0",  0.).toDouble(); // [degrees]   Basically the same idea as rot_rotation_offset, but W!=rotAngle
                const double J2000NPoleW1  = pd.value(secname+"/rot_pole_w1",  0.).toDouble(); // [degrees/d] Basically the same idea as 360/rot_periode
                if (fabs(J2000NPoleW1) > 0.0) // Patch possibly old period value with a more modern value.
                {
                        // this is just another expression for rotational speed.
                        rotPeriod=360.0/J2000NPoleW1;
                }

                // IMPORTANT: For the planet moons with orbits relative to planets' equator plane,
                // re-compute the important bits from the updated axis elements.
                // Reactivated to re-establish Pluto/Charon lock #153
                if((J2000NPoleRA!=0.) || (J2000NPoleDE!=0.))
                {
                        // If available, recompute obliquity and AscNode from the new data.
                        // Solution since 0.16: Make this once for J2000.
                        // Optional (future?): Repeat this block in Planet::computeTransMatrix() for planets with moving axes and update all Moons' KeplerOrbit if required.
                        Vec3d J2000NPole;
                        StelUtils::spheToRect(J2000NPoleRA,J2000NPoleDE,J2000NPole);

                        Vec3d vsop87Pole(StelCore::matJ2000ToVsop87.multiplyWithoutTranslation(J2000NPole));

                        double lon, lat;
                        StelUtils::rectToSphe(&lon, &lat, vsop87Pole);

                        rotObliquity = (M_PI_2 - lat);
                        rotAscNode = (lon + M_PI_2);

                        //qDebug() << englishName << ": Compare these values to the older data in ssystem_major";
                        //qDebug() << "\tCalculated rotational obliquity: " << rotObliquity*180./M_PI;
                        //qDebug() << "\tCalculated rotational ascending node: " << rotAscNode*180./M_PI;

                        if (J2000NPoleW0 >0)
                        {
                                // W0 is counted from the ascending node with ICRF, but rotOffset from orbital plane.
                                // Try this assumption by just counting Offset=W0+90+RA0.
                                rotOffset=J2000NPoleW0 + lon*M_180_PI;
                                //qDebug() << "\tCalculated rotational period (days // hours): " << rotPeriod << "//" << rotPeriod*24.;
                                //qDebug() << "\tRotational offset (degrees): " << rotOffset;
                        }
                }
                newP->setRotationElements(
                        englishName,
                        rotPeriod,
                        rotOffset,
                        pd.value(secname+"/rot_epoch", J2000).toDouble(),
                        rotObliquity,
                        rotAscNode,
                        J2000NPoleRA,
                        J2000NPoleRA1,
                        J2000NPoleDE,
                        J2000NPoleDE1,
                        J2000NPoleW0,
                        J2000NPoleW1);
                // orbit_Period given in days.
                // Elliptical Kepler orbits (ecc<0.9) will replace whatever is given by a value computed on the fly. Parabolic objects show 0.
                newP->setSiderealPeriod(fabs(pd.value(secname+"/orbit_Period", 0.).toDouble()));

                if (pd.contains(secname+"/tex_ring")) {
                        const float rMin = pd.value(secname+"/ring_inner_size").toFloat()/AUf;
                        const float rMax = pd.value(secname+"/ring_outer_size").toFloat()/AUf;
                        Ring *r = new Ring(rMin,rMax,pd.value(secname+"/tex_ring").toString());
                        newP->setRings(r);
                }

                systemPlanets.push_back(newP);
                readOk++;
        }

        if (systemPlanets.isEmpty())
        {
                qWarning().noquote() << "No Solar System objects loaded from" << QDir::toNativeSeparators(filePath);
                return false;
        }
        else
                qDebug() << "Solar System has" << systemPlanets.count() << "entries.";

        // special case: load earth shadow texture
        if (!Planet::texEarthShadow)
                Planet::texEarthShadow = StelApp::getInstance().getTextureManager().createTexture(StelFileMgr::getInstallationDir()+"/textures/earth-shadow.png");

        // Also comets just have static textures.
        if (!Comet::comaTexture)
                Comet::comaTexture = StelApp::getInstance().getTextureManager().createTextureThread(StelFileMgr::getInstallationDir()+"/textures/cometComa.png", StelTexture::StelTextureParams(true, GL_LINEAR, GL_CLAMP_TO_EDGE));
        //tail textures. We use paraboloid tail bodies, textured like a fisheye sphere, i.e. center=head. The texture should be something like a mottled star to give some structure.
        if (!Comet::tailTexture)
                Comet::tailTexture = StelApp::getInstance().getTextureManager().createTextureThread(StelFileMgr::getInstallationDir()+"/textures/cometTail.png", StelTexture::StelTextureParams(true, GL_LINEAR, GL_CLAMP_TO_EDGE));

        if (readOk>0)
                qDebug() << "Loaded" << readOk << "Solar System bodies";

        return true;
}

// Compute the position for every elements of the solar system.
// The order is not important since the position is computed relatively to the mother body
void SolarSystem::computePositions(double dateJDE, PlanetP observerPlanet)
{
        StelCore *core=StelApp::getInstance().getCore();
        const bool withAberration=core->getUseAberration();
        if (flagLightTravelTime) // switching off light time correction implies no aberration for the planets.
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        p->computePosition(dateJDE, Vec3d(0.));
                }
                const Vec3d obsPosJDE=observerPlanet->getHeliocentricEclipticPos();

                // For higher accuracy, we now make two iterations of light time and aberration correction. In the final
                // round, we also compute rotation data.  May fix sub-arcsecond inaccuracies, and optionally apply
                // aberration in the way described in Explanatory Supplement (2013), 7.55.  For reasons unknown (See
                // discussion in GH:#1626) we do not add anything for the Moon when observed from Earth!  Presumably the
                // used ephemerides already provide aberration-corrected positions for the Moon?
                const Vec3d aberrationPushSpeed=observerPlanet->getHeliocentricEclipticVelocity() * core->getAberrationFactor();
                for (const auto& p : qAsConst(systemPlanets))
                {
                        //p->setExtraInfoString(StelObject::DebugAid, "");
                        const auto planetPos = p->getHeliocentricEclipticPos();
                        const double lightTimeDays = (planetPos-obsPosJDE).norm() * (AU / (SPEED_OF_LIGHT * 86400.));
                        Vec3d aberrationPush(0.);
                        if (withAberration && (observerPlanet->englishName!="Earth" || p->englishName!="Moon"))
                                aberrationPush=lightTimeDays*aberrationPushSpeed;
                        p->computePosition(dateJDE-lightTimeDays, aberrationPush);
                }
                // Extra accuracy with another round. Not sure if useful. Maybe hide behind a new property flag?
                for (const auto& p : qAsConst(systemPlanets))
                {
                        //p->setExtraInfoString(StelObject::DebugAid, "");
                        const auto planetPos = p->getHeliocentricEclipticPos();
                        const double lightTimeDays = (planetPos-obsPosJDE).norm() * (AU / (SPEED_OF_LIGHT * 86400.));
                        Vec3d aberrationPush(0.);
                        if (withAberration && (observerPlanet->englishName!="Earth" || p->englishName!="Moon"))
                                aberrationPush=lightTimeDays*aberrationPushSpeed;
                        // The next call may already do nothing if the time difference to the previous round is not large enough.
                        p->computePosition(dateJDE-lightTimeDays, aberrationPush);
//                        p->setExtraInfoString(StelObject::DebugAid, QString("LightTime %1d; obsSpeed %2/%3/%4 AU/d")
//                                              .arg(QString::number(lightTimeDays, 'f', 3))
//                                              .arg(QString::number(aberrationPushSpeed[0], 'f', 3))
//                                              .arg(QString::number(aberrationPushSpeed[0], 'f', 3))
//                                              .arg(QString::number(aberrationPushSpeed[0], 'f', 3)));

                        const auto update = &RotationElements::updatePlanetCorrections;
                        if      (p->englishName=="Moon")    update(dateJDE-lightTimeDays, RotationElements::EarthMoon);
                        else if (p->englishName=="Mars")    update(dateJDE-lightTimeDays, RotationElements::Mars);
                        else if (p->englishName=="Jupiter") update(dateJDE-lightTimeDays, RotationElements::Jupiter);
                        else if (p->englishName=="Saturn")  update(dateJDE-lightTimeDays, RotationElements::Saturn);
                        else if (p->englishName=="Uranus")  update(dateJDE-lightTimeDays, RotationElements::Uranus);
                        else if (p->englishName=="Neptune") update(dateJDE-lightTimeDays, RotationElements::Neptune);
                }
        }
        else
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        p->setExtraInfoString(StelObject::DebugAid, "");
                        p->computePosition(dateJDE, Vec3d(0.));
                        const auto update = &RotationElements::updatePlanetCorrections;
                        if      (p->englishName=="Moon")    update(dateJDE, RotationElements::EarthMoon);
                        else if (p->englishName=="Mars")    update(dateJDE, RotationElements::Mars);
                        else if (p->englishName=="Jupiter") update(dateJDE, RotationElements::Jupiter);
                        else if (p->englishName=="Saturn")  update(dateJDE, RotationElements::Saturn);
                        else if (p->englishName=="Uranus")  update(dateJDE, RotationElements::Uranus);
                        else if (p->englishName=="Neptune") update(dateJDE, RotationElements::Neptune);
                }
        }
        computeTransMatrices(dateJDE, observerPlanet->getHeliocentricEclipticPos());
}

// Compute the transformation matrix for every elements of the solar system.
// The elements have to be ordered hierarchically, eg. it's important to compute earth before moon.
void SolarSystem::computeTransMatrices(double dateJDE, const Vec3d& observerPos)
{
        const double dateJD=dateJDE - (StelApp::getInstance().getCore()->computeDeltaT(dateJDE))/86400.0;

        if (flagLightTravelTime)
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        const double light_speed_correction = (p->getHeliocentricEclipticPos()-observerPos).norm() * (AU / (SPEED_OF_LIGHT * 86400));
                        p->computeTransMatrix(dateJD-light_speed_correction, dateJDE-light_speed_correction);
                }
        }
        else
        {
                for (const auto& p : qAsConst(systemPlanets))
                {
                        p->computeTransMatrix(dateJD, dateJDE);
                }
        }
}

// And sort them from the furthest to the closest to the observer
// NOTE: std::binary_function is deprecated in C++11 and removed in C++17
struct biggerDistance : public StelUtils::binary_function<PlanetP, PlanetP, bool>
{
        bool operator()(PlanetP p1, PlanetP p2)
        {
                return p1->getDistance() > p2->getDistance();
        }
};

// Draw all the elements of the solar system
// We are supposed to be in heliocentric coordinate
void SolarSystem::draw(StelCore* core)
{
        // AstroCalcDialog
        drawEphemerisItems(core);

        if (!flagShow)
                return;

        // Compute each Planet distance to the observer
        const Vec3d obsHelioPos = core->getObserverHeliocentricEclipticPos();

        for (const auto& p : qAsConst(systemPlanets))
        {
                p->computeDistance(obsHelioPos);
        }

        // And sort them from the furthest to the closest
        std::sort(systemPlanets.begin(),systemPlanets.end(),biggerDistance());

        if (trailFader.getInterstate()>0.0000001f)
        {
                StelPainter sPainter(core->getProjection2d());
                const float ppx = static_cast<float>(sPainter.getProjector()->getDevicePixelsPerPixel());
                allTrails->setOpacity(trailFader.getInterstate());
                if (trailsThickness>1 || ppx>1.f)
                        sPainter.setLineWidth(trailsThickness*ppx);
                allTrails->draw(core, &sPainter);
                if (trailsThickness>1 || ppx>1.f)
                        sPainter.setLineWidth(1);
        }

        // Make some voodoo to determine when labels should be displayed
        const float sdLimitMag=static_cast<float>(core->getSkyDrawer()->getLimitMagnitude());
        const float maxMagLabel = (sdLimitMag<5.f ? sdLimitMag :
                        5.f+(sdLimitMag-5.f)*1.2f) +(static_cast<float>(labelsAmount)-3.f)*1.2f;

        // Draw the elements
        for (const auto& p : qAsConst(systemPlanets))
        {
                if ( (p->getEnglishName() != "Sun") ||
                                ((p->getEnglishName() == "Sun") && !(core->getSkyDrawer()->getFlagDrawSunAfterAtmosphere())))
                        p->draw(core, maxMagLabel, planetNameFont);
        }

        if (GETSTELMODULE(StelObjectMgr)->getFlagSelectedObjectPointer() && getFlagPointer())
                drawPointer(core);
}

void SolarSystem::drawEphemerisItems(const StelCore* core)
{
        if (flagShow || (!flagShow && getFlagEphemerisAlwaysOn()))
        {
                if (getFlagEphemerisMarkers())
                        drawEphemerisMarkers(core);
                if (getFlagEphemerisLine())
                        drawEphemerisLine(core);
        }
}

Vec3f SolarSystem::getEphemerisMarkerColor(int index) const
{
        // Sync index with AstroCalcDialog::generateEphemeris(). If required, switch to using a QMap.
        const QVector<Vec3f> colors={
                ephemerisGenericMarkerColor,
                ephemerisSecondaryMarkerColor,
                ephemerisMercuryMarkerColor,
                ephemerisVenusMarkerColor,
                ephemerisMarsMarkerColor,
                ephemerisJupiterMarkerColor,
                ephemerisSaturnMarkerColor};
        return colors.value(index, ephemerisGenericMarkerColor);
}

void SolarSystem::drawEphemerisMarkers(const StelCore *core)
{
        const int fsize = AstroCalcDialog::EphemerisList.count();
        if (fsize==0) return;

        StelProjectorP prj;
        if (getFlagEphemerisHorizontalCoordinates())
                prj = core->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff);
        else
                prj = core->getProjection(StelCore::FrameJ2000);
        StelPainter sPainter(prj);

        float size, shift, baseSize = 4.f;
        const bool showDates = getFlagEphemerisDates();
        const bool showMagnitudes = getFlagEphemerisMagnitudes();
        const bool showSkippedData = getFlagEphemerisSkipData();
        const bool skipMarkers = getFlagEphemerisSkipMarkers();
        const bool isNowVisible = getFlagEphemerisNow();
        const int dataStep = getEphemerisDataStep();
        const int sizeCoeff = getEphemerisLineThickness() - 1;
        QString info = "";
        Vec3d win;
        Vec3f markerColor;
        bool skipFlag = false;

        if (getFlagEphemerisLine() && getFlagEphemerisScaleMarkers())
                baseSize = 3.f; // The line lies through center of marker

        if (isNowVisible)
        {
                const int limit = getEphemerisDataLimit();
                const int nsize = static_cast<int>(fsize/limit);
                sPainter.setBlending(true, GL_ONE, GL_ONE);
                texEphemerisNowMarker->bind();
                Vec3d pos;
                Vec3f win;
                for (int i =0; i < limit; i++)
                {
                        sPainter.setColor(getEphemerisMarkerColor(AstroCalcDialog::EphemerisList[i*nsize].colorIndex));
                        if (getFlagEphemerisHorizontalCoordinates())
                                pos = AstroCalcDialog::EphemerisList[i*nsize].sso->getAltAzPosAuto(core);
                        else
                                pos = AstroCalcDialog::EphemerisList[i*nsize].sso->getJ2000EquatorialPos(core);
                        if (prj->project(pos, win))
                                sPainter.drawSprite2dMode(static_cast<float>(win[0]), static_cast<float>(win[1]), 6.f, 0.f);
                }
        }

        for (int i =0; i < fsize; i++)
        {
                skipFlag = (((i + 1)%dataStep)!=1 && dataStep!=1);

                // Check visibility of pointer
                if (!(sPainter.getProjector()->projectCheck(AstroCalcDialog::EphemerisList[i].coord, win)))
                        continue;

                QString debugStr; // Used temporarily for development
                const bool isComet=AstroCalcDialog::EphemerisList[i].isComet;
                if (i == AstroCalcDialog::DisplayedPositionIndex)
                {
                        markerColor = getEphemerisSelectedMarkerColor();
                        size = 6.f;
                }
                else
                {
                        markerColor = getEphemerisMarkerColor(AstroCalcDialog::EphemerisList[i].colorIndex);
                        size = baseSize;
                }
                if (isComet) size += 16.f;
                size += sizeCoeff;
                sPainter.setColor(markerColor);
                sPainter.setBlending(true, GL_ONE, GL_ONE);
                if (isComet)
                        texEphemerisCometMarker->bind();
                else
                        texEphemerisMarker->bind();

                if (skipMarkers && skipFlag)
                        continue;

                Vec3f win;
                float solarAngle=0.f; // Angle to possibly rotate the texture. Degrees.
                if (prj->project(AstroCalcDialog::EphemerisList[i].coord, win))
                {
                        if (isComet)
                        {
                                // compute solarAngle in screen space.
                                Vec3f sunWin;
                                prj->project(AstroCalcDialog::EphemerisList[i].sunCoord, sunWin);
                                // TODO: In some projections, we may need to test result and flip/mirror the angle, or deal with wrap-around effects.
                                // E.g., in cylindrical mode, the comet icon will flip as soon as the corresponding sun position wraps around the screen edge.
                                solarAngle=M_180_PIf*(atan2(-(win[1]-sunWin[1]), win[0]-sunWin[0]));
                                // This will show projected positions and angles usable in labels.
                                debugStr = QString("Sun: %1/%2 Obj: %3/%4 -->%5").arg(QString::number(sunWin[0]), QString::number(sunWin[1]), QString::number(win[0]), QString::number(win[1]), QString::number(solarAngle));
                        }
                        //sPainter.drawSprite2dMode(static_cast<float>(win[0]), static_cast<float>(win[1]), size, 180.f+AstroCalcDialog::EphemerisList[i].solarAngle*M_180_PIf);
                        sPainter.drawSprite2dMode(static_cast<float>(win[0]), static_cast<float>(win[1]), size, 270.f-solarAngle);
                }

                if (showDates || showMagnitudes)
                {
                        if (showSkippedData && skipFlag)
                                continue;

                        shift = 3.f + size/1.6f;
                        if (showDates && showMagnitudes)
                                info = QString("%1 (%2)").arg(AstroCalcDialog::EphemerisList[i].objDateStr, QString::number(AstroCalcDialog::EphemerisList[i].magnitude, 'f', 2));
                        if (showDates && !showMagnitudes)
                                info = AstroCalcDialog::EphemerisList[i].objDateStr;
                        if (!showDates && showMagnitudes)
                                info = QString::number(AstroCalcDialog::EphemerisList[i].magnitude, 'f', 2);

                        // Activate for debug labels.
                        //info=debugStr;
                        sPainter.drawText(AstroCalcDialog::EphemerisList[i].coord, info, 0, shift, shift, false);
                }
        }
}

void SolarSystem::drawEphemerisLine(const StelCore *core)
{
        const int size = AstroCalcDialog::EphemerisList.count();
        if (size==0) return;

        // The array of data is not empty - good news!
        StelProjectorP prj;
        if (getFlagEphemerisHorizontalCoordinates())
                prj = core->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff);
        else
                prj = core->getProjection(StelCore::FrameJ2000);
        StelPainter sPainter(prj);
        const float ppx = static_cast<float>(sPainter.getProjector()->getDevicePixelsPerPixel());

        const float oldLineThickness=sPainter.getLineWidth();
        const float lineThickness = getEphemerisLineThickness()*ppx;
        if (!fuzzyEquals(lineThickness, oldLineThickness))
                sPainter.setLineWidth(lineThickness);

        Vec3f color;
        QVector<Vec3d> vertexArray;
        QVector<Vec4f> colorArray;
        const int limit = getEphemerisDataLimit();
        const int nsize = static_cast<int>(size/limit);
        vertexArray.resize(nsize);
        colorArray.resize(nsize);
        for (int j=0; j<limit; j++)
        {
                for (int i =0; i < nsize; i++)
                {
                        color = getEphemerisMarkerColor(AstroCalcDialog::EphemerisList[i + j*nsize].colorIndex);
                        colorArray[i]=Vec4f(color, 1.0f);
                        vertexArray[i]=AstroCalcDialog::EphemerisList[i + j*nsize].coord;
                }
                sPainter.drawPath(vertexArray, colorArray);
        }

        if (!fuzzyEquals(lineThickness, oldLineThickness))
                sPainter.setLineWidth(oldLineThickness); // restore line thickness
}

void SolarSystem::fillEphemerisDates()
{
        const int fsize = AstroCalcDialog::EphemerisList.count();
        if (fsize==0) return;

        StelLocaleMgr* localeMgr = &StelApp::getInstance().getLocaleMgr();
        const bool showSmartDates = getFlagEphemerisSmartDates();
        double JD = AstroCalcDialog::EphemerisList.first().objDate;
        bool withTime = (fsize>1 && (AstroCalcDialog::EphemerisList[1].objDate-JD<1.0));

        int fYear, fMonth, fDay, sYear, sMonth, sDay, h, m, s;
        QString info;
        const double shift = StelApp::getInstance().getCore()->getUTCOffset(JD)*StelCore::JD_HOUR;
        StelUtils::getDateFromJulianDay(JD+shift, &fYear, &fMonth, &fDay);
        bool sFlag = true;
        sYear = fYear;
        sMonth = fMonth;
        sDay = fDay;
        const bool showSkippedData = getFlagEphemerisSkipData();
        const int dataStep = getEphemerisDataStep();

        for (int i = 0; i < fsize; i++)
        {
                JD = AstroCalcDialog::EphemerisList[i].objDate;
                StelUtils::getDateFromJulianDay(JD+shift, &fYear, &fMonth, &fDay);

                if (showSkippedData && ((i + 1)%dataStep)!=1 && dataStep!=1)
                        continue;

                if (showSmartDates)
                {
                        if (sFlag)
                                info = QString("%1").arg(fYear);

                        if (info.isEmpty() && !sFlag && fYear!=sYear)
                                info = QString("%1").arg(fYear);

                        if (!info.isEmpty())
                                info.append(QString("/%1").arg(localeMgr->romanMonthName(fMonth)));
                        else if (fMonth!=sMonth)
                                info = QString("%1").arg(localeMgr->romanMonthName(fMonth));

                        if (!info.isEmpty())
                                info.append(QString("/%1").arg(fDay));
                        else
                                info = QString("%1").arg(fDay);

                        if (withTime) // very short step
                        {
                                if (fDay==sDay && !sFlag)
                                        info.clear();

                                StelUtils::getTimeFromJulianDay(JD+shift, &h, &m, &s);
                                QString hours = QString::number(h).rightJustified(2, '0');
                                QString minutes = QString::number(m).rightJustified(2, '0');
                                if (!info.isEmpty())
                                        info.append(QString(" %1:%2").arg(hours, minutes));
                                else
                                        info = QString("%1:%2").arg(hours, minutes);
                        }

                        AstroCalcDialog::EphemerisList[i].objDateStr = info;
                        info.clear();
                        sYear = fYear;
                        sMonth = fMonth;
                        sDay = fDay;
                        sFlag = false;
                }
                else
                {
                        // OK, let's use standard formats for date and time (as defined for whole planetarium)
                        if (withTime)
                                AstroCalcDialog::EphemerisList[i].objDateStr = QString("%1 %2").arg(localeMgr->getPrintableDateLocal(JD), localeMgr->getPrintableTimeLocal(JD));
                        else
                                AstroCalcDialog::EphemerisList[i].objDateStr = localeMgr->getPrintableDateLocal(JD);
                }
        }
}

PlanetP SolarSystem::searchByEnglishName(QString planetEnglishName) const
{
        for (const auto& p : systemPlanets)
        {
                if (p->getEnglishName().toUpper() == planetEnglishName.toUpper() || p->getCommonEnglishName().toUpper() == planetEnglishName.toUpper())
                        return p;

                // IAU designation?
                QString iau = p->getIAUDesignation();
                if (!iau.isEmpty() && iau.toUpper()==planetEnglishName.toUpper())
                        return p;
        }
        for (const auto& p : systemMinorBodies)
        {
                QStringList c;
                // other comet designations?
                if (p->getPlanetType()==Planet::isComet)
                {
                        QSharedPointer<Comet> mp = p.dynamicCast<Comet>();
                        c = mp->getExtraDesignations();
                } else {
                        QSharedPointer<MinorPlanet> mp = p.dynamicCast<MinorPlanet>();
                        c = mp->getExtraDesignations();
                }
                for (const auto& d : c)
                {
                        if (d.toUpper()==planetEnglishName.toUpper())
                                return p;
                }
        }
        return PlanetP();
}

PlanetP SolarSystem::searchMinorPlanetByEnglishName(QString planetEnglishName) const
{
        for (const auto& p : systemMinorBodies)
        {
                if (p->getCommonEnglishName().toUpper() == planetEnglishName.toUpper() || p->getEnglishName().toUpper() == planetEnglishName.toUpper())
                        return p;

                // IAU designation?
                QString iau = p->getIAUDesignation();
                if (!iau.isEmpty() && iau.toUpper()==planetEnglishName.toUpper())
                        return p;

                QStringList c;
                // other comet designations?
                if (p->getPlanetType()==Planet::isComet)
                {
                        QSharedPointer<Comet> mp = p.dynamicCast<Comet>();
                        c = mp->getExtraDesignations();
                }
                else
                {
                        QSharedPointer<MinorPlanet> mp = p.dynamicCast<MinorPlanet>();
                        c = mp->getExtraDesignations();
                }
                for (const auto& d : c)
                {
                        if (d.toUpper()==planetEnglishName.toUpper())
                                return p;
                }
        }
        return PlanetP();
}


StelObjectP SolarSystem::searchByNameI18n(const QString& planetNameI18) const
{
        for (const auto& p : systemPlanets)
        {
                QString nativeName = p->getNativeNameI18n().toUpper();
                if (p->getNameI18n().toUpper() == planetNameI18.toUpper() || (!nativeName.isEmpty() && nativeName == planetNameI18.toUpper()))
                        return qSharedPointerCast<StelObject>(p);
        }
        return StelObjectP();
}


StelObjectP SolarSystem::searchByName(const QString& name) const
{
        for (const auto& p : systemPlanets)
        {
                QString nativeName = p->getNativeName().toUpper();
                if (p->getEnglishName().toUpper() == name.toUpper() || (!nativeName.isEmpty() && nativeName == name.toUpper()))
                        return qSharedPointerCast<StelObject>(p);

                // IAU designation?
                QString iau = p->getIAUDesignation();
                if (!iau.isEmpty() && iau.toUpper()==name.toUpper())
                        return qSharedPointerCast<StelObject>(p);
        }
        for (const auto& p : systemMinorBodies)
        {
                QStringList c;
                // other comet designations?
                if (p->getPlanetType()==Planet::isComet)
                {
                        QSharedPointer<Comet> mp = p.dynamicCast<Comet>();
                        c = mp->getExtraDesignations();
                }
                else
                {
                        QSharedPointer<MinorPlanet> mp = p.dynamicCast<MinorPlanet>();
                        c = mp->getExtraDesignations();
                }
                for (const auto& d : c)
                {
                        if (d.toUpper()==name.toUpper())
                                return qSharedPointerCast<StelObject>(p);
                }
        }

        return StelObjectP();
}

float SolarSystem::getPlanetVMagnitude(QString planetName, bool withExtinction) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        float r = 0.f;
        if (withExtinction)
                r = p->getVMagnitudeWithExtinction(StelApp::getInstance().getCore());
        else
                r = p->getVMagnitude(StelApp::getInstance().getCore());
        return r;
}

QString SolarSystem::getPlanetType(QString planetName) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        if (p.isNull())
                return QString("UNDEFINED");
        return p->getObjectType();
}

double SolarSystem::getDistanceToPlanet(QString planetName) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        return p->getDistance();
}

double SolarSystem::getElongationForPlanet(QString planetName) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        return p->getElongation(StelApp::getInstance().getCore()->getObserverHeliocentricEclipticPos());
}

double SolarSystem::getPhaseAngleForPlanet(QString planetName) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        return p->getPhaseAngle(StelApp::getInstance().getCore()->getObserverHeliocentricEclipticPos());
}

float SolarSystem::getPhaseForPlanet(QString planetName) const
{
        PlanetP p = searchByEnglishName(planetName);
        if (p.isNull()) // Possible was asked the common name of minor planet?
                p = searchMinorPlanetByEnglishName(planetName);
        return p->getPhase(StelApp::getInstance().getCore()->getObserverHeliocentricEclipticPos());
}

QStringList SolarSystem::getObjectsList(QString objType) const
{
        QStringList r;
        if (objType.toLower()=="all")
        {
                r = listAllObjects(true);
                // Remove the Sun
                r.removeOne("Sun");
                // Remove special objects
                r.removeOne("Solar System Observer");
                r.removeOne("Earth Observer");
                r.removeOne("Mars Observer");
                r.removeOne("Jupiter Observer");
                r.removeOne("Saturn Observer");
                r.removeOne("Uranus Observer");
                r.removeOne("Neptune Observer");
        }
        else
                r = listAllObjectsByType(objType, true);

        return r;
}

// Search if any Planet is close to position given in earth equatorial position and return the distance
StelObjectP SolarSystem::search(Vec3d pos, const StelCore* core) const
{
        pos.normalize();
        PlanetP closest;
        double cos_angle_closest = 0.;
        Vec3d equPos;

        for (const auto& p : systemPlanets)
        {
                equPos = p->getEquinoxEquatorialPos(core);
                equPos.normalize();
                double cos_ang_dist = equPos*pos;
                if (cos_ang_dist>cos_angle_closest)
                {
                        closest = p;
                        cos_angle_closest = cos_ang_dist;
                }
        }

        if (cos_angle_closest>0.999)
        {
                return qSharedPointerCast<StelObject>(closest);
        }
        else return StelObjectP();
}

// Return a QList containing the planets located inside the limFov circle around position vv
QList<StelObjectP> SolarSystem::searchAround(const Vec3d& vv, double limitFov, const StelCore* core) const
{
        QList<StelObjectP> result;
        if (!getFlagPlanets())
                return result;

        const bool withAberration=core->getUseAberration();
        Vec3d v(vv);
        v.normalize(); // TODO: start with vv already normalized?
        if (withAberration)
        {
                Vec3d vel=core->getCurrentPlanet()->getHeliocentricEclipticVelocity();
                StelCore::matVsop87ToJ2000.transfo(vel);
                vel*=core->getAberrationFactor()*(AU/(86400.0*SPEED_OF_LIGHT));
                v+=vel;
                v.normalize();
        }

        double cosLimFov = std::cos(limitFov * M_PI/180.);
        Vec3d equPos;
        double cosAngularSize;

        const QString weAreHere = core->getCurrentPlanet()->getEnglishName();
        for (const auto& p : systemPlanets)
        {
                equPos = p->getJ2000EquatorialPos(core);
                equPos.normalize();

                cosAngularSize = std::cos(p->getSpheroidAngularRadius(core) * M_PI/180.);

                if (equPos*v>=std::min(cosLimFov, cosAngularSize) && p->getEnglishName()!=weAreHere)
                {
                        result.append(qSharedPointerCast<StelObject>(p));
                }
        }
        return result;
}

// Update i18 names from english names according to current sky culture translator
void SolarSystem::updateI18n()
{
        const StelTranslator& trans = StelApp::getInstance().getLocaleMgr().getSkyTranslator();
        for (const auto& p : qAsConst(systemPlanets))
                p->translateName(trans);
}

QStringList SolarSystem::listMatchingObjects(const QString& objPrefix, int maxNbItem, bool useStartOfWords) const
{
        QStringList result;
        if (getFlagPlanets())
                result = StelObjectModule::listMatchingObjects(objPrefix, maxNbItem, useStartOfWords);
        return result;
}

void SolarSystem::setFlagTrails(bool b)
{
        if (getFlagTrails() != b)
        {
                trailFader = b;
                if (b)
                {
                        allTrails->reset(maxTrailPoints);
                        recreateTrails();
                }
                emit trailsDisplayedChanged(b);
        }
}

bool SolarSystem::getFlagTrails() const
{
        return static_cast<bool>(trailFader);
}

void SolarSystem::setMaxTrailPoints(int max)
{
        if (maxTrailPoints != max)
        {
                maxTrailPoints = max;
                allTrails->reset(max);
                recreateTrails();
                emit maxTrailPointsChanged(max);
        }
}

void SolarSystem::setMaxTrailTimeExtent(int max)
{
        if (maxTrailTimeExtent != max && maxTrailTimeExtent > 0)
        {
                maxTrailTimeExtent = max;
                recreateTrails();
                emit maxTrailTimeExtentChanged(max);
        }
}

void SolarSystem::setTrailsThickness(int v)
{
        if (trailsThickness != v)
        {
                trailsThickness = v;
                emit trailsThicknessChanged(v);
        }
}

void SolarSystem::setFlagHints(bool b)
{
        if (getFlagHints() != b)
        {
                for (const auto& p : qAsConst(systemPlanets))
                        p->setFlagHints(b);
                emit flagHintsChanged(b);
        }
}

bool SolarSystem::getFlagHints(void) const
{
        for (const auto& p : systemPlanets)
        {
                if (p->getFlagHints())
                        return true;
        }
        return false;
}

void SolarSystem::setFlagLabels(bool b)
{
        if (getFlagLabels() != b)
        {
                for (const auto& p : qAsConst(systemPlanets))
                        p->setFlagLabels(b);
                emit labelsDisplayedChanged(b);
        }
}

bool SolarSystem::getFlagLabels() const
{
        for (const auto& p : systemPlanets)
        {
                if (p->getFlagLabels())
                        return true;
        }
        return false;
}

void SolarSystem::setFlagLightTravelTime(bool b)
{
        if(b!=flagLightTravelTime)
        {
                flagLightTravelTime = b;
                emit flagLightTravelTimeChanged(b);
        }
}

void SolarSystem::setFlagShowObjSelfShadows(bool b)
{
        if(b!=flagShowObjSelfShadows)
        {
                flagShowObjSelfShadows = b;
                if(!b)
                        Planet::deinitFBO();
                emit flagShowObjSelfShadowsChanged(b);
        }
}

void SolarSystem::setSelected(PlanetP obj)
{
        if (obj && obj->getType() == "Planet")
        {
                selected = obj;
                selectedSSO.push_back(obj);
        }
        else
                selected.clear();
        // Undraw other objects hints, orbit, trails etc..
        setFlagHints(getFlagHints());
        reconfigureOrbits();
}


void SolarSystem::update(double deltaTime)
{
        trailFader.update(static_cast<int>(deltaTime*1000));
        if (trailFader.getInterstate()>0.f)
        {
                allTrails->update();
        }

        for (const auto& p : qAsConst(systemPlanets))
        {
                p->update(static_cast<int>(deltaTime*1000));
        }
}

// is a lunar eclipse close at hand?
bool SolarSystem::nearLunarEclipse() const
{
        // TODO: could replace with simpler test
        // TODO Source?

        const Vec3d sun = getSun()->getAberrationPush();
        const Vec3d e = getEarth()->getEclipticPos();
        const Vec3d m = getMoon()->getEclipticPos();  // relative to earth
        const Vec3d mh = getMoon()->getHeliocentricEclipticPos();  // relative to sun

        // shadow location at earth + moon distance along earth vector from (aberrated) sun
        Vec3d en = e-sun;
        en.normalize();
        Vec3d shadow = en * (e.norm() + m.norm());

        // find shadow radii in AU
        double r_penumbra = shadow.norm()*702378.1/AU/e.norm() - SUN_RADIUS/AU;

        // modify shadow location for scaled moon
        Vec3d mdist = shadow - mh;
        if(mdist.norm() > r_penumbra + 2000./AU) return false;   // not visible so don't bother drawing

        return true;
}

QStringList SolarSystem::listAllObjects(bool inEnglish) const
{
        QStringList result;
        if (inEnglish)
        {
                for (const auto& p : systemPlanets)
                {
                        result << p->getEnglishName();
                        if (!p->getIAUDesignation().isEmpty())
                                result << p->getIAUDesignation();
                }
        }
        else
        {
                for (const auto& p : systemPlanets)
                {
                        result << p->getNameI18n();
                        if (!p->getNativeNameI18n().isEmpty())
                                result << p->getNativeNameI18n() << p->getNativeName();
                        if (!p->getIAUDesignation().isEmpty())
                                result << p->getIAUDesignation();
                }
        }
        for (const auto& p : systemMinorBodies)
        {
                QStringList c;
                // other comet designations?
                if (p->getPlanetType()==Planet::isComet)
                {
                        QSharedPointer<Comet> mp = p.dynamicCast<Comet>();
                        c = mp->getExtraDesignations();
                } else {
                        QSharedPointer<MinorPlanet> mp = p.dynamicCast<MinorPlanet>();
                        c = mp->getExtraDesignations();
                }
                if (c.count()>0)
                        result << c;
        }
        return result;
}

QStringList SolarSystem::listAllObjectsByType(const QString &objType, bool inEnglish) const
{
        QStringList result;
        if (inEnglish)
        {
                for (const auto& p : systemPlanets)
                {
                        if (p->getObjectType()==objType)
                        {
                                result << p->getEnglishName();
                                if (!p->getIAUDesignation().isEmpty())
                                        result << p->getIAUDesignation();
                        }
                }
        }
        else
        {
                for (const auto& p : systemPlanets)
                {
                        if (p->getObjectType()==objType)
                        {
                                result << p->getNameI18n();
                                if (!p->getIAUDesignation().isEmpty())
                                        result << p->getIAUDesignation();
                        }
                }
        }
        for (const auto& p : systemMinorBodies)
        {
                if (p->getObjectType()==objType)
                {
                        QStringList c;
                        // other comet designations?
                        if (p->getPlanetType()==Planet::isComet)
                        {
                                QSharedPointer<Comet> mp = p.dynamicCast<Comet>();
                                c = mp->getExtraDesignations();
                        } else {
                                QSharedPointer<MinorPlanet> mp = p.dynamicCast<MinorPlanet>();
                                c = mp->getExtraDesignations();
                        }
                        if (c.count()>0)
                                result << c;
                }
        }
        return result;
}

void SolarSystem::selectedObjectChange(StelModule::StelModuleSelectAction)
{
        const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Planet");
        if (!newSelected.empty())
        {
                setSelected(qSharedPointerCast<Planet>(newSelected[0]));
                if (getFlagIsolatedTrails())
                        recreateTrails();
        }
        else
                setSelected("");
}

// Activate/Deactivate planets display
void SolarSystem::setFlagPlanets(bool b)
{
        if (b!=flagShow)
        {
                flagShow=b;
                emit flagPlanetsDisplayedChanged(b);
        }
}

bool SolarSystem::getFlagPlanets(void) const
{
        return flagShow;
}

void SolarSystem::setFlagEphemerisMarkers(bool b)
{
        if (b!=ephemerisMarkersDisplayed)
        {
                ephemerisMarkersDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_markers", b); // Immediate saving of state
                emit ephemerisMarkersChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisMarkers() const
{
        return ephemerisMarkersDisplayed;
}

void SolarSystem::setFlagEphemerisLine(bool b)
{
        if (b!=ephemerisLineDisplayed)
        {
                ephemerisLineDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_line", b); // Immediate saving of state
                emit ephemerisLineChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisLine() const
{
        return ephemerisLineDisplayed;
}

bool SolarSystem::getFlagEphemerisAlwaysOn() const
{
        return ephemerisAlwaysOn;
}

void SolarSystem::setFlagEphemerisAlwaysOn(bool b)
{
        if (b != ephemerisAlwaysOn)
        {
                ephemerisAlwaysOn = b;
                conf->setValue("astrocalc/flag_ephemeris_alwayson", b); // Immediate saving of state
                emit ephemerisAlwaysOnChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisNow() const
{
        return ephemerisNow;
}

void SolarSystem::setFlagEphemerisNow(bool b)
{
        if (b != ephemerisNow)
        {
                ephemerisNow = b;
                conf->setValue("astrocalc/flag_ephemeris_now", b); // Immediate saving of state
                emit ephemerisNowChanged(b);
        }
}

void SolarSystem::setFlagEphemerisHorizontalCoordinates(bool b)
{
        if (b!=ephemerisHorizontalCoordinates)
        {
                ephemerisHorizontalCoordinates=b;
                conf->setValue("astrocalc/flag_ephemeris_horizontal", b); // Immediate saving of state
                emit ephemerisHorizontalCoordinatesChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisHorizontalCoordinates() const
{
        return ephemerisHorizontalCoordinates;
}

void SolarSystem::setFlagEphemerisDates(bool b)
{
        if (b!=ephemerisDatesDisplayed)
        {
                ephemerisDatesDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_dates", b); // Immediate saving of state
                emit ephemerisDatesChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisDates() const
{
        return ephemerisDatesDisplayed;
}

void SolarSystem::setFlagEphemerisMagnitudes(bool b)
{
        if (b!=ephemerisMagnitudesDisplayed)
        {
                ephemerisMagnitudesDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_magnitudes", b); // Immediate saving of state
                emit ephemerisMagnitudesChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisMagnitudes() const
{
        return ephemerisMagnitudesDisplayed;
}

void SolarSystem::setFlagEphemerisSkipData(bool b)
{
        if (b!=ephemerisSkipDataDisplayed)
        {
                ephemerisSkipDataDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_skip_data", b); // Immediate saving of state
                emit ephemerisSkipDataChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisSkipData() const
{
        return ephemerisSkipDataDisplayed;
}

void SolarSystem::setFlagEphemerisSkipMarkers(bool b)
{
        if (b!=ephemerisSkipMarkersDisplayed)
        {
                ephemerisSkipMarkersDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_skip_markers", b); // Immediate saving of state
                emit ephemerisSkipMarkersChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisSkipMarkers() const
{
        return ephemerisSkipMarkersDisplayed;
}

void SolarSystem::setFlagEphemerisSmartDates(bool b)
{
        if (b!=ephemerisSmartDatesDisplayed)
        {
                ephemerisSmartDatesDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_smart_dates", b); // Immediate saving of state
                emit ephemerisSmartDatesChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisSmartDates() const
{
        return ephemerisSmartDatesDisplayed;
}

void SolarSystem::setFlagEphemerisScaleMarkers(bool b)
{
        if (b!=ephemerisScaleMarkersDisplayed)
        {
                ephemerisScaleMarkersDisplayed=b;
                conf->setValue("astrocalc/flag_ephemeris_scale_markers", b); // Immediate saving of state
                emit ephemerisScaleMarkersChanged(b);
        }
}

bool SolarSystem::getFlagEphemerisScaleMarkers() const
{
        return ephemerisScaleMarkersDisplayed;
}

void SolarSystem::setEphemerisDataStep(int step)
{
        ephemerisDataStep = step;
        // automatic saving of the setting
        conf->setValue("astrocalc/ephemeris_data_step", step);
        emit ephemerisDataStepChanged(step);
}

int SolarSystem::getEphemerisDataStep() const
{
        return ephemerisDataStep;
}

void SolarSystem::setEphemerisDataLimit(int limit)
{
        ephemerisDataLimit = limit;
        emit ephemerisDataLimitChanged(limit);
}

int SolarSystem::getEphemerisDataLimit() const
{
        return ephemerisDataLimit;
}

void SolarSystem::setEphemerisLineThickness(int v)
{
        ephemerisLineThickness = v;
        // automatic saving of the setting
        conf->setValue("astrocalc/ephemeris_line_thickness", v);
        emit ephemerisLineThicknessChanged(v);
}

int SolarSystem::getEphemerisLineThickness() const
{
        return ephemerisLineThickness;
}

void SolarSystem::setEphemerisGenericMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisGenericMarkerColor)
        {
                ephemerisGenericMarkerColor = color;
                emit ephemerisGenericMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisGenericMarkerColor() const
{
        return ephemerisGenericMarkerColor;
}

void SolarSystem::setEphemerisSecondaryMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisSecondaryMarkerColor)
        {
                ephemerisSecondaryMarkerColor = color;
                emit ephemerisSecondaryMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisSecondaryMarkerColor() const
{
        return ephemerisSecondaryMarkerColor;
}

void SolarSystem::setEphemerisSelectedMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisSelectedMarkerColor)
        {
                ephemerisSelectedMarkerColor = color;
                emit ephemerisSelectedMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisSelectedMarkerColor() const
{
        return ephemerisSelectedMarkerColor;
}

void SolarSystem::setEphemerisMercuryMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisMercuryMarkerColor)
        {
                ephemerisMercuryMarkerColor = color;
                emit ephemerisMercuryMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisMercuryMarkerColor() const
{
        return ephemerisMercuryMarkerColor;
}

void SolarSystem::setEphemerisVenusMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisVenusMarkerColor)
        {
                ephemerisVenusMarkerColor = color;
                emit ephemerisVenusMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisVenusMarkerColor() const
{
        return ephemerisVenusMarkerColor;
}

void SolarSystem::setEphemerisMarsMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisMarsMarkerColor)
        {
                ephemerisMarsMarkerColor = color;
                emit ephemerisMarsMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisMarsMarkerColor() const
{
        return ephemerisMarsMarkerColor;
}

void SolarSystem::setEphemerisJupiterMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisJupiterMarkerColor)
        {
                ephemerisJupiterMarkerColor = color;
                emit ephemerisJupiterMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisJupiterMarkerColor() const
{
        return ephemerisJupiterMarkerColor;
}

void SolarSystem::setEphemerisSaturnMarkerColor(const Vec3f& color)
{
        if (color!=ephemerisSaturnMarkerColor)
        {
                ephemerisSaturnMarkerColor = color;
                emit ephemerisSaturnMarkerColorChanged(color);
        }
}

Vec3f SolarSystem::getEphemerisSaturnMarkerColor() const
{
        return ephemerisSaturnMarkerColor;
}

void SolarSystem::setFlagNativePlanetNames(bool b)
{
        if (b!=flagNativePlanetNames)
        {
                flagNativePlanetNames=b;
                for (const auto& p : qAsConst(systemPlanets))
                {
                        if (p->getPlanetType()==Planet::isPlanet || p->getPlanetType()==Planet::isMoon || p->getPlanetType()==Planet::isStar)
                                p->setFlagNativeName(flagNativePlanetNames);
                }
                updateI18n();
                emit flagNativePlanetNamesChanged(b);
        }
}

bool SolarSystem::getFlagNativePlanetNames() const
{
        return flagNativePlanetNames;
}

void SolarSystem::setFlagIsolatedTrails(bool b)
{
        if(b!=flagIsolatedTrails)
        {
                flagIsolatedTrails = b;
                recreateTrails();
                emit flagIsolatedTrailsChanged(b);
        }
}

bool SolarSystem::getFlagIsolatedTrails() const
{
        return flagIsolatedTrails;
}

int SolarSystem::getNumberIsolatedTrails() const
{
        return numberIsolatedTrails;
}

void SolarSystem::setNumberIsolatedTrails(int n)
{
        // [1..5] - valid range for trails
        numberIsolatedTrails = qBound(1, n, 5);

        if (getFlagIsolatedTrails())
                recreateTrails();

        emit numberIsolatedTrailsChanged(numberIsolatedTrails);
}

void SolarSystem::setFlagOrbits(bool b)
{
        if(b!=getFlagOrbits())
        {
                flagOrbits = b;
                emit flagOrbitsChanged(b);
        }
}

// Connect this to all signals when orbit selection or selected object has changed.
// This method goes through all planets and sets orbit drawing as configured by several flags
void SolarSystem::reconfigureOrbits()
{
        // we have: flagOrbits O, flagIsolatedOrbits I, flagPlanetsOrbitsOnly P, flagOrbitsWithMoons M, flagPermanentOrbits and a possibly selected planet S
        // permanentOrbits only influences local drawing of a single planet and can be ignored here.
        // O S I P M
        // 0 X X X X  NONE
        // 1 0 1 X X  NONE
        // 1 X 0 0 X  ALL
        // 1 X 0 1 0  all planets only
        // 1 X 0 1 1  all planets with their moons only

        // 1 1 1 0 0  only selected SSO
        // 1 1 1 0 1  only selected SSO and orbits of its moon system
        // 1 1 1 1 0  only selected SSO if it is a major planet
        // 1 1 1 1 1  only selected SSO if it is a major planet, plus its system of moons

        if (!flagOrbits || (flagIsolatedOrbits && (!selected || selected==sun)))
        {
                for (const auto& p : qAsConst(systemPlanets))
                        p->setFlagOrbits(false);
                return;
        }
        // from here, flagOrbits is certainly on
        if (!flagIsolatedOrbits)
        {
                for (const auto& p : qAsConst(systemPlanets))
                        p->setFlagOrbits(!flagPlanetsOrbitsOnly || (p->getPlanetType()==Planet::isPlanet || (flagOrbitsWithMoons && p->parent && p->parent->getPlanetType()==Planet::isPlanet) ));
                return;
        }
        else // flagIsolatedOrbits && selected
        {
                // Display only orbit for selected planet and, if requested, its moons.
                for (const auto& p : qAsConst(systemPlanets))
                        p->setFlagOrbits(   (p==selected && (  !flagPlanetsOrbitsOnly ||  p->getPlanetType()==Planet::isPlanet ) )
                                         || (flagOrbitsWithMoons && p->getPlanetType()==Planet::isMoon && p->parent==selected ) );
                return;
        }
}

void SolarSystem::setFlagIsolatedOrbits(bool b)
{
        if(b!=flagIsolatedOrbits)
        {
                flagIsolatedOrbits = b;
                StelApp::immediateSave("viewing/flag_isolated_orbits", b);
                emit flagIsolatedOrbitsChanged(b);
        }
}

bool SolarSystem::getFlagIsolatedOrbits() const
{
        return flagIsolatedOrbits;
}

void SolarSystem::setFlagPlanetsOrbitsOnly(bool b)
{
        if(b!=flagPlanetsOrbitsOnly)
        {
                flagPlanetsOrbitsOnly = b;
                StelApp::immediateSave("viewing/flag_planets_orbits_only", b);
                emit flagPlanetsOrbitsOnlyChanged(b);
        }
}

bool SolarSystem::getFlagPlanetsOrbitsOnly() const
{
        return flagPlanetsOrbitsOnly;
}

void SolarSystem::setFlagOrbitsWithMoons(bool b)
{
        if(b!=flagOrbitsWithMoons)
        {
                flagOrbitsWithMoons = b;
                StelApp::immediateSave("viewing/flag_orbits_with_moons", b);
                emit flagOrbitsWithMoonsChanged(b);
        }
}

bool SolarSystem::getFlagOrbitsWithMoons() const
{
        return flagOrbitsWithMoons;
}

// Set/Get planets names color
void SolarSystem::setLabelsColor(const Vec3f& c)
{
        if (c!=Planet::getLabelColor())
        {
                Planet::setLabelColor(c);
                emit labelsColorChanged(c);
        }
}

Vec3f SolarSystem::getLabelsColor(void) const
{
        return Planet::getLabelColor();
}

// Set/Get orbits lines color
void SolarSystem::setOrbitsColor(const Vec3f& c)
{
        if (c!=Planet::getOrbitColor())
        {
                Planet::setOrbitColor(c);
                emit orbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getOrbitsColor(void) const
{
        return Planet::getOrbitColor();
}

void SolarSystem::setMajorPlanetsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getMajorPlanetOrbitColor())
        {
                Planet::setMajorPlanetOrbitColor(c);
                emit majorPlanetsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getMajorPlanetsOrbitsColor(void) const
{
        return Planet::getMajorPlanetOrbitColor();
}

void SolarSystem::setMinorPlanetsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getMinorPlanetOrbitColor())
        {
                Planet::setMinorPlanetOrbitColor(c);
                emit minorPlanetsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getMinorPlanetsOrbitsColor(void) const
{
        return Planet::getMinorPlanetOrbitColor();
}

void SolarSystem::setDwarfPlanetsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getDwarfPlanetOrbitColor())
        {
                Planet::setDwarfPlanetOrbitColor(c);
                emit dwarfPlanetsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getDwarfPlanetsOrbitsColor(void) const
{
        return Planet::getDwarfPlanetOrbitColor();
}

void SolarSystem::setMoonsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getMoonOrbitColor())
        {
                Planet::setMoonOrbitColor(c);
                emit moonsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getMoonsOrbitsColor(void) const
{
        return Planet::getMoonOrbitColor();
}

void SolarSystem::setCubewanosOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getCubewanoOrbitColor())
        {
                Planet::setCubewanoOrbitColor(c);
                emit cubewanosOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getCubewanosOrbitsColor(void) const
{
        return Planet::getCubewanoOrbitColor();
}

void SolarSystem::setPlutinosOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getPlutinoOrbitColor())
        {
                Planet::setPlutinoOrbitColor(c);
                emit plutinosOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getPlutinosOrbitsColor(void) const
{
        return Planet::getPlutinoOrbitColor();
}

void SolarSystem::setScatteredDiskObjectsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getScatteredDiscObjectOrbitColor())
        {
                Planet::setScatteredDiscObjectOrbitColor(c);
                emit scatteredDiskObjectsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getScatteredDiskObjectsOrbitsColor(void) const
{
        return Planet::getScatteredDiscObjectOrbitColor();
}

void SolarSystem::setOortCloudObjectsOrbitsColor(const Vec3f &c)
{
        if (c!=Planet::getOortCloudObjectOrbitColor())
        {
                Planet::setOortCloudObjectOrbitColor(c);
                emit oortCloudObjectsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getOortCloudObjectsOrbitsColor(void) const
{
        return Planet::getOortCloudObjectOrbitColor();
}

void SolarSystem::setCometsOrbitsColor(const Vec3f& c)
{
        if (c!=Planet::getCometOrbitColor())
        {
                Planet::setCometOrbitColor(c);
                emit cometsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getCometsOrbitsColor(void) const
{
        return Planet::getCometOrbitColor();
}

void SolarSystem::setSednoidsOrbitsColor(const Vec3f& c)
{
        if (c!=Planet::getSednoidOrbitColor())
        {
                Planet::setSednoidOrbitColor(c);
                emit sednoidsOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getSednoidsOrbitsColor(void) const
{
        return Planet::getSednoidOrbitColor();
}

void SolarSystem::setInterstellarOrbitsColor(const Vec3f& c)
{
        if (c!=Planet::getInterstellarOrbitColor())
        {
                Planet::setInterstellarOrbitColor(c);
                emit interstellarOrbitsColorChanged(c);
        }
}

Vec3f SolarSystem::getInterstellarOrbitsColor(void) const
{
        return Planet::getInterstellarOrbitColor();
}

void SolarSystem::setMercuryOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getMercuryOrbitColor())
        {
                Planet::setMercuryOrbitColor(c);
                emit mercuryOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getMercuryOrbitColor(void) const
{
        return Planet::getMercuryOrbitColor();
}

void SolarSystem::setVenusOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getVenusOrbitColor())
        {
                Planet::setVenusOrbitColor(c);
                emit venusOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getVenusOrbitColor(void) const
{
        return Planet::getVenusOrbitColor();
}

void SolarSystem::setEarthOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getEarthOrbitColor())
        {
                Planet::setEarthOrbitColor(c);
                emit earthOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getEarthOrbitColor(void) const
{
        return Planet::getEarthOrbitColor();
}

void SolarSystem::setMarsOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getMarsOrbitColor())
        {
                Planet::setMarsOrbitColor(c);
                emit marsOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getMarsOrbitColor(void) const
{
        return Planet::getMarsOrbitColor();
}

void SolarSystem::setJupiterOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getJupiterOrbitColor())
        {
                Planet::setJupiterOrbitColor(c);
                emit jupiterOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getJupiterOrbitColor(void) const
{
        return Planet::getJupiterOrbitColor();
}

void SolarSystem::setSaturnOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getSaturnOrbitColor())
        {
                Planet::setSaturnOrbitColor(c);
                emit saturnOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getSaturnOrbitColor(void) const
{
        return Planet::getSaturnOrbitColor();
}

void SolarSystem::setUranusOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getUranusOrbitColor())
        {
                Planet::setUranusOrbitColor(c);
                emit uranusOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getUranusOrbitColor(void) const
{
        return Planet::getUranusOrbitColor();
}

void SolarSystem::setNeptuneOrbitColor(const Vec3f &c)
{
        if (c!=Planet::getNeptuneOrbitColor())
        {
                Planet::setNeptuneOrbitColor(c);
                emit neptuneOrbitColorChanged(c);
        }
}

Vec3f SolarSystem::getNeptuneOrbitColor(void) const
{
        return Planet::getNeptuneOrbitColor();
}

// Set/Get if Moon display is scaled
void SolarSystem::setFlagMoonScale(bool b)
{
        if(b!=flagMoonScale)
        {
                if (b) getMoon()->setSphereScale(moonScale);
                else getMoon()->setSphereScale(1);
                flagMoonScale = b;
                emit flagMoonScaleChanged(b);
        }
}

// Set/Get Moon display scaling factor. This goes directly to the Moon object.
void SolarSystem::setMoonScale(double f)
{
        if(!fuzzyEquals(moonScale, f))
        {
                moonScale = f;
                if (flagMoonScale)
                        getMoon()->setSphereScale(moonScale);
                emit moonScaleChanged(f);
        }
}

// Set if minor body display is scaled. This flag will be queried by all Planet objects except for the Moon.
void SolarSystem::setFlagMinorBodyScale(bool b)
{
        if(b!=flagMinorBodyScale)
        {
                flagMinorBodyScale = b;

                double newScale = b ? minorBodyScale : 1.0;
                //update the bodies with the new scale
                for (const auto& p : qAsConst(systemPlanets))
                {
                        if(p == moon) continue;
                        if (p->getPlanetType()!=Planet::isPlanet && p->getPlanetType()!=Planet::isStar)
                                p->setSphereScale(newScale);
                }
                emit flagMinorBodyScaleChanged(b);
        }
}

// Set minor body display scaling factor. This will be queried by all Planet objects except for the Moon.
void SolarSystem::setMinorBodyScale(double f)
{
        if(!fuzzyEquals(minorBodyScale, f))
        {
                minorBodyScale = f;
                if(flagMinorBodyScale) //update the bodies with the new scale
                {
                        for (const auto& p : qAsConst(systemPlanets))
                        {
                                if(p == moon) continue;
                                if (p->getPlanetType()!=Planet::isPlanet && p->getPlanetType()!=Planet::isStar)
                                        p->setSphereScale(minorBodyScale);
                        }
                }
                emit minorBodyScaleChanged(f);
        }
}

// Set if Planet display is scaled
void SolarSystem::setFlagPlanetScale(bool b)
{
        if(b!=flagPlanetScale)
        {
                double scale=(b ? planetScale : 1.);
                for (auto& p : systemPlanets)
                {
                        if (p->pType==Planet::isPlanet)
                                p->setSphereScale(scale);
                }
                flagPlanetScale = b;
                emit flagPlanetScaleChanged(b);
        }
}

// Set Moon display scaling factor.
void SolarSystem::setPlanetScale(double f)
{
        if(!fuzzyEquals(planetScale, f))
        {
                planetScale = f;
                if (flagPlanetScale)
                        for (auto& p : systemPlanets)
                        {
                                if (p->pType==Planet::isPlanet)
                                        p->setSphereScale(planetScale);
                        }
                emit planetScaleChanged(f);
        }
}

// Set if Sun display is scaled
void SolarSystem::setFlagSunScale(bool b)
{
        if(b!=flagSunScale)
        {
                if (b) getSun()->setSphereScale(sunScale);
                else getSun()->setSphereScale(1);
                flagSunScale = b;
                emit flagSunScaleChanged(b);
        }
}

// Set Sun display scaling factor. This goes directly to the Sun object.
void SolarSystem::setSunScale(double f)
{
        if(!fuzzyEquals(sunScale, f))
        {
                sunScale = f;
                if (flagSunScale)
                        getSun()->setSphereScale(sunScale);
                emit sunScaleChanged(f);
        }
}

// Set selected planets by englishName
void SolarSystem::setSelected(const QString& englishName)
{
        setSelected(searchByEnglishName(englishName));
}

// Get the list of all the planet english names
QStringList SolarSystem::getAllPlanetEnglishNames() const
{
        QStringList res;
        for (const auto& p : systemPlanets)
                res.append(p->getEnglishName());
        return res;
}

QStringList SolarSystem::getAllPlanetLocalizedNames() const
{
        QStringList res;
        for (const auto& p : systemPlanets)
                res.append(p->getNameI18n());
        return res;
}

QStringList SolarSystem::getAllMinorPlanetCommonEnglishNames() const
{
        QStringList res;
        for (const auto& p : systemMinorBodies)
                res.append(p->getCommonEnglishName());
        return res;
}


// GZ TODO: This could be modified to only delete&reload the minor objects. For now, we really load both parts again like in the 0.10?-0.15 series.
void SolarSystem::reloadPlanets()
{
        // Save flag states
        const bool flagScaleMoon = getFlagMoonScale();
        const double moonScale = getMoonScale();
        const bool flagScaleMinorBodies=getFlagMinorBodyScale();
        const double minorScale= getMinorBodyScale();
        const bool flagPlanets = getFlagPlanets();
        const bool flagHints = getFlagHints();
        const bool flagLabels = getFlagLabels();
        const bool flagOrbits = getFlagOrbits();
        const bool flagNative = getFlagNativePlanetNames();
        bool hasSelection = false;

        // Save observer location (fix for LP bug # 969211)
        // TODO: This can probably be done better with a better understanding of StelObserver --BM
        StelCore* core = StelApp::getInstance().getCore();
        const StelLocation loc = core->getCurrentLocation();
        StelObjectMgr* objMgr = GETSTELMODULE(StelObjectMgr);

        // Whether any planet are selected? Save the current selection...
        const QList<StelObjectP> selectedObject = objMgr->getSelectedObject("Planet");
        if (!selectedObject.isEmpty())
        {
                // ... unselect current planet.
                hasSelection = true;
                objMgr->unSelect();
        }
        // Unload all Solar System objects
        selected.clear();//Release the selected one

        // GZ TODO in case this methods gets converted to only reload minor bodies: Only delete Orbits which are not referenced by some Planet.
        for (auto* orb : qAsConst(orbits))
        {
                delete orb;
        }
        orbits.clear();

        sun.clear();
        moon.clear();
        earth.clear();
        Planet::texEarthShadow.clear(); //Loaded in loadPlanets()

        delete allTrails;
        allTrails = Q_NULLPTR;

        for (const auto& p : qAsConst(systemPlanets))
        {
                p->satellites.clear();
        }
        systemPlanets.clear();
        systemMinorBodies.clear();
        // Memory leak? What's the proper way of cleaning shared pointers?

        // Also delete Comet textures (loaded in loadPlanets()
        Comet::tailTexture.clear();
        Comet::comaTexture.clear();

        // Re-load the ssystem_major.ini and ssystem_minor.ini file
        loadPlanets();        
        computePositions(core->getJDE(), getSun());
        setSelected("");
        recreateTrails();
        
        // Restore observer location
        core->moveObserverTo(loc, 0., 0.);

        // Restore flag states
        setFlagMoonScale(flagScaleMoon);
        setMoonScale(moonScale);
        setFlagMinorBodyScale(flagScaleMinorBodies);
        setMinorBodyScale(1.0); // force-reset first to really reach the objects in the next call.
        setMinorBodyScale(minorScale);
        setFlagPlanets(flagPlanets);
        setFlagHints(flagHints);
        setFlagLabels(flagLabels);
        setFlagOrbits(flagOrbits);
        setFlagNativePlanetNames(flagNative);

        // Restore translations
        updateI18n();

        if (hasSelection)
        {
                // Restore selection...
                StelObjectP obj = selectedObject[0];
                objMgr->findAndSelect(obj->getEnglishName(), obj->getType());
        }

        emit solarSystemDataReloaded();
}

// Set the algorithm for computation of apparent magnitudes for planets in case  observer on the Earth
void SolarSystem::setApparentMagnitudeAlgorithmOnEarth(QString algorithm)
{
        Planet::setApparentMagnitudeAlgorithm(algorithm);
        emit apparentMagnitudeAlgorithmOnEarthChanged(algorithm);
}

// Get the algorithm used for computation of apparent magnitudes for planets in case  observer on the Earth
QString SolarSystem::getApparentMagnitudeAlgorithmOnEarth() const
{
        return Planet::getApparentMagnitudeAlgorithmString();
}

void SolarSystem::setFlagDrawMoonHalo(bool b)
{
        Planet::drawMoonHalo=b;
        emit flagDrawMoonHaloChanged(b);
}

bool SolarSystem::getFlagDrawMoonHalo() const
{
        return Planet::drawMoonHalo;
}

void SolarSystem::setFlagDrawSunHalo(bool b)
{
        Planet::drawSunHalo=b;
        emit flagDrawSunHaloChanged(b);
}

bool SolarSystem::getFlagDrawSunHalo() const
{
        return Planet::drawSunHalo;
}

void SolarSystem::setFlagPermanentOrbits(bool b)
{
        if (Planet::permanentDrawingOrbits!=b)
        {
                Planet::permanentDrawingOrbits=b;
                StelApp::immediateSave("astro/flag_permanent_orbits", b);
                emit flagPermanentOrbitsChanged(b);
        }
}

bool SolarSystem::getFlagPermanentOrbits() const
{
        return Planet::permanentDrawingOrbits;
}

void SolarSystem::setOrbitsThickness(int v)
{
        if (v!=Planet::orbitsThickness)
        {
                Planet::orbitsThickness=v;
                StelApp::immediateSave("astro/object_orbits_thickness", v);
                emit orbitsThicknessChanged(v);
        }
}

int SolarSystem::getOrbitsThickness() const
{
        return Planet::orbitsThickness;
}

void SolarSystem::setGrsLongitude(int longitude)
{
        RotationElements::grsLongitude = longitude;
        // automatic saving of the setting
        conf->setValue("astro/grs_longitude", longitude);
        emit grsLongitudeChanged(longitude);
}

int SolarSystem::getGrsLongitude() const
{
        return static_cast<int>(RotationElements::grsLongitude);
}

void SolarSystem::setGrsDrift(double drift)
{
        RotationElements::grsDrift = drift;
        // automatic saving of the setting
        conf->setValue("astro/grs_drift", drift);
        emit grsDriftChanged(drift);
}

double SolarSystem::getGrsDrift() const
{
        return RotationElements::grsDrift;
}

void SolarSystem::setGrsJD(double JD)
{
        RotationElements::grsJD = JD;
        // automatic saving of the setting
        conf->setValue("astro/grs_jd", JD);
        emit grsJDChanged(JD);
}

double SolarSystem::getGrsJD()
{
        return RotationElements::grsJD;
}

void SolarSystem::setFlagEarthShadowEnlargementDanjon(bool b)
{
        earthShadowEnlargementDanjon=b;
        emit earthShadowEnlargementDanjonChanged(b);
}

bool SolarSystem::getFlagEarthShadowEnlargementDanjon() const
{
        return earthShadowEnlargementDanjon;
}

void SolarSystem::setOrbitColorStyle(QString style)
{
        if (style.toLower()=="groups")
                Planet::orbitColorStyle = Planet::ocsGroups;
        else if (style.toLower()=="major_planets")
                Planet::orbitColorStyle = Planet::ocsMajorPlanets;
        else
                Planet::orbitColorStyle = Planet::ocsOneColor;
}

QString SolarSystem::getOrbitColorStyle() const
{
        static const QMap<Planet::PlanetOrbitColorStyle, QString>map={
                { Planet::ocsOneColor,     "one_color"},
                { Planet::ocsGroups,       "groups"},
                { Planet::ocsMajorPlanets, "major_planets"}
        };
        return map.value(Planet::orbitColorStyle, "one_color");
}

// TODO: To make the code better understandable, get rid of planet->computeModelMatrix(trans, true) here.
QPair<double, PlanetP> SolarSystem::getSolarEclipseFactor(const StelCore* core) const
{
        PlanetP p;
        const Vec3d Lp = sun->getEclipticPos() + sun->getAberrationPush();
        const Vec3d P3 = core->getObserverHeliocentricEclipticPos();
        const double RS = sun->getEquatorialRadius();

        double final_illumination = 1.0;

        for (const auto& planet : systemPlanets)
        {
                if(planet == sun || planet == core->getCurrentPlanet())
                        continue;

                Mat4d trans;
                planet->computeModelMatrix(trans, true);

                const Vec3d C = trans * Vec3d(0., 0., 0.);
                const double radius = planet->getEquatorialRadius();

                Vec3d v1 = Lp - P3;
                Vec3d v2 = C - P3;
                const double L = v1.norm();
                const double l = v2.norm();
                v1 /= L;
                v2 /= l;

                const double R = RS / L;
                const double r = radius / l;
                const double d = ( v1 - v2 ).norm();
                double illumination;

                if(d >= R + r) // distance too far
                {
                        illumination = 1.0;
                }
                else if(d <= r - R) // umbra
                {
                        illumination = 0.0;
                }
                else if(d <= R - r) // penumbra completely inside
                {
                        illumination = 1.0 - r * r / (R * R);
                }
                else // penumbra partially inside
                {
                        const double x = (R * R + d * d - r * r) / (2.0 * d);

                        const double alpha = std::acos(x / R);
                        const double beta = std::acos((d - x) / r);

                        const double AR = R * R * (alpha - 0.5 * std::sin(2.0 * alpha));
                        const double Ar = r * r * (beta - 0.5 * std::sin(2.0 * beta));
                        const double AS = R * R * 2.0 * std::asin(1.0);

                        illumination = 1.0 - (AR + Ar) / AS;
                }

                if(illumination < final_illumination)
                {
                        final_illumination = illumination;
                        p = planet;
                }
        }

        return QPair<double, PlanetP>(final_illumination, p);
}

// Retrieve Radius of Umbra and Penumbra at the distance of the Moon.
// Returns a pair (umbra, penumbra) in (geocentric_arcseconds, AU, geometric_AU).
// * sizes in arcseconds are the usual result found as Bessel element in eclipse literature.
//   It includes scaling for effects of atmosphere either after Chauvenet (2%) or after Danjon. (see Espenak: 5000 Years Canon of Lunar Eclipses.)
// * sizes in AU are the same, converted back to AU in Lunar distance.
// * sizes in geometric_AU derived from pure geometrical evaluations without scalings applied.
QPair<Vec3d,Vec3d> SolarSystem::getEarthShadowRadiiAtLunarDistance() const
{
        // Note: The application of this shadow enlargement is not according to the books, but looks close enough for now.
        static const double sun2earth=sun->getEquatorialRadius() / earth->getEquatorialRadius();
        PlanetP sun=getSun();
        PlanetP moon=getMoon();
        PlanetP earth=getEarth();
        const double lunarDistance=moon->getEclipticPos().norm(); // Lunar distance [AU]
        const double earthDistance=earth->getHeliocentricEclipticPos().norm(); // Earth distance [AU]
        const double sunHP =asin(earth->getEquatorialRadius()/earthDistance) * M_180_PI*3600.; // arcsec.
        const double moonHP=asin(earth->getEquatorialRadius()/lunarDistance) * M_180_PI*3600.; // arcsec.
        const double sunSD  =atan(sun->getEquatorialRadius()/earthDistance)  * M_180_PI*3600.; // arcsec.

        // Compute umbra radius at lunar distance.
        const double lUmbra=earthDistance/(sun2earth-1.); // length of earth umbra [AU]
        const double rUmbraAU=earth->getEquatorialRadius()*(lUmbra-lunarDistance)/lUmbra; // radius of earth shadow at lunar distance [AU]
        // Penumbra:
        const double lPenumbra=earthDistance/(sun2earth + 1.); // distance between earth and point between sun and earth where penumbral border rays intersect
        const double rPenumbraAU=earth->getEquatorialRadius()*(lPenumbra+lunarDistance)/lPenumbra; // radius of penumbra at Lunar distance [AU]

        //Classical Bessel elements instead
        double f1, f2;
        if (earthShadowEnlargementDanjon)
        {
                static const double danjonScale=1+1./85.-1./594.; // ~1.01, shadow magnification factor (see Espenak 5000 years Canon)
                f1=danjonScale*moonHP + sunHP + sunSD; // penumbra radius, arcsec
                f2=danjonScale*moonHP + sunHP - sunSD; // umbra radius, arcsec
        }
        else
        {
                const double mHP1=0.998340*moonHP;
                f1=1.02*(mHP1 + sunHP + sunSD); // penumbra radius, arcsec
                f2=1.02*(mHP1 + sunHP - sunSD); // umbra radius, arcsec
        }
        const double f1_AU=tan(f1/3600.*M_PI_180)*lunarDistance;
        const double f2_AU=tan(f2/3600.*M_PI_180)*lunarDistance;
        return QPair<Vec3d,Vec3d>(Vec3d(f2, f2_AU, rUmbraAU), Vec3d(f1, f1_AU, rPenumbraAU));
}

bool SolarSystem::removeMinorPlanet(QString name)
{
        PlanetP candidate = searchMinorPlanetByEnglishName(name);
        if (!candidate)
        {
                qWarning() << "Cannot remove planet " << name << ": Not found.";
                return false;
        }
        Orbit* orbPtr=static_cast<Orbit*>(candidate->orbitPtr);
        if (orbPtr)
                orbits.removeOne(orbPtr);
        systemPlanets.removeOne(candidate);
        systemMinorBodies.removeOne(candidate);
        candidate.clear();
        return true;
}

void SolarSystem::onNewSurvey(HipsSurveyP survey)
{
        // For the moment we only consider the survey url to decide if we
        // assign it to a planet.  It would be better to use some property
        // for that.
        QString planetName = QUrl(survey->getUrl()).fileName();
        PlanetP pl = searchByEnglishName(planetName);
        if (!pl || pl->survey)
                return;
        pl->survey = survey;
        survey->setProperty("planet", pl->getCommonEnglishName());
        // Not visible by default for the moment.
        survey->setProperty("visible", false);
}

Stellarium / stellarium / 5926409083

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous