StarMgr.hpp

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

#ifndef _STARMGR_HPP_
#define _STARMGR_HPP_

#include <QFont>
#include <QVariantMap>
#include <QVector>
#include "StelFader.hpp"
#include "StelObjectModule.hpp"
#include "StelTextureTypes.hpp"
#include "StelProjectorType.hpp"

class StelObject;
class StelToneReproducer;
class StelProjector;
class StelPainter;
class QSettings;

class ZoneArray;
struct HipIndexStruct;

static const int RCMAG_TABLE_SIZE = 4096;

typedef struct
{
    QString designation;    
    QString vtype;      
    float maxmag;       
    int mflag;      
    float min1mag;      
    float min2mag;      
    QString photosys;   
    double epoch;       
    double period;      
    int Mm;         
    QString stype;      
} varstar;

typedef struct
{
    QString designation;    
    int observation;    
    float positionAngle;    
    float separation;   
} wds;

typedef struct
{
    unsigned int sao;
    unsigned int hd;
    unsigned int hr;

} crossid;

typedef QMap<StelObjectP, float> StelACStarData;

class StarMgr : public StelObjectModule
{
    Q_OBJECT
    Q_PROPERTY(bool flagStarsDisplayed
           READ getFlagStars
           WRITE setFlagStars
           NOTIFY starsDisplayedChanged)
    Q_PROPERTY(bool flagLabelsDisplayed
           READ getFlagLabels
           WRITE setFlagLabels
           NOTIFY starLabelsDisplayedChanged)
    Q_PROPERTY(double labelsAmount
           READ getLabelsAmount
           WRITE setLabelsAmount
           NOTIFY labelsAmountChanged)

public:
    StarMgr(void);
    ~StarMgr(void);

    // Methods defined in the StelModule class
    virtual void init();

    virtual void draw(StelCore* core);

    virtual void update(double deltaTime) {labelsFader.update((int)(deltaTime*1000)); starsFader.update((int)(deltaTime*1000));}

    virtual double getCallOrder(StelModuleActionName actionName) const;

    // Methods defined in StelObjectManager class
    virtual QList<StelObjectP > searchAround(const Vec3d& v, double limitFov, const StelCore* core) const;

    virtual StelObjectP searchByNameI18n(const QString& nameI18n) const;

    virtual StelObjectP searchByName(const QString& name) const;

    virtual StelObjectP searchByID(const QString &id) const;

    virtual QStringList listMatchingObjects(const QString& objPrefix, int maxNbItem=5, bool useStartOfWords=false, bool inEnglish=false) const;
    virtual QStringList listAllObjects(bool inEnglish) const;   
    virtual QStringList listAllObjectsByType(const QString& objType, bool inEnglish) const;
    virtual QString getName() const { return "Stars"; }
    virtual QString getStelObjectType() const;

public slots:
    // Methods callable from script and GUI
    void setLabelColor(const Vec3f& c) {labelColor = c;}
    Vec3f getLabelColor(void) const {return labelColor;}

    void setFlagStars(bool b) {starsFader=b; emit starsDisplayedChanged(b);}
    bool getFlagStars(void) const {return starsFader==true;}

    void setFlagLabels(bool b) {labelsFader=b; emit starLabelsDisplayedChanged(b);}
    bool getFlagLabels(void) const {return labelsFader==true;}

    void setLabelsAmount(double a) {if(a!=labelsAmount){ labelsAmount=a; emit labelsAmountChanged(a);}}
    double getLabelsAmount(void) const {return labelsAmount;}

    void setFontSize(float newFontSize);

    static void setFlagSciNames(bool f) {flagSciNames = f;}
    static bool getFlagSciNames(void) {return flagSciNames;}

public:
    // Other methods
    StelObjectP searchHP(int hip) const;

    static QString getCommonName(int hip);

    static QString getSciName(int hip);

    static QString getSciAdditionalName(int hip);

    static QString getGcvsName(int hip);

    static QString getWdsName(int hip);

    static QString getCommonEnglishName(int hip);

    static QString getAdditionalNames(int hip);

    static QString getAdditionalEnglishNames(int hip);

    static QString getCrossIdentificationDesignations(QString hip);

    static QString getGcvsVariabilityType(int hip);

    static float getGcvsMaxMagnitude(int hip);

    static int getGcvsMagnitudeFlag(int hip);

    static float getGcvsMinMagnitude(int hip, bool firstMinimumFlag=true);

    static QString getGcvsPhotometricSystem(int hip);

    static double getGcvsEpoch(int hip);

    static double getGcvsPeriod(int hip);

    static int getGcvsMM(int hip);

    static int getWdsLastObservation(int hip);

    static int getWdsLastPositionAngle(int hip);

    static float getWdsLastSeparation(int hip);

    static QString convertToSpectralType(int index);
    static QString convertToComponentIds(int index);

    QVariantList getCatalogsDescription() const {return catalogsDescription;}

    bool checkAndLoadCatalog(const QVariantMap& m);

    const QList<StelObjectP>& getHipparcosStars() const { return hipparcosStars; }  
    const QList<QMap<StelObjectP, float>>& getHipparcosHighPMStars() const { return hipStarsHighPM; }
    const QList<QMap<StelObjectP, float>>& getHipparcosDoubleStars() const { return doubleHipStars; }
    const QList<QMap<StelObjectP, float>>& getHipparcosVariableStars() const { return variableHipStars; }

private slots:
    void updateI18n();

    void updateSkyCulture(const QString& skyCultureDir);

signals:
    void starLabelsDisplayedChanged(const bool displayed);
    void starsDisplayedChanged(const bool displayed);
    void labelsAmountChanged(float a);

private:
    void setCheckFlag(const QString& catalogId, bool b);

    void copyDefaultConfigFile();

    int loadCommonNames(const QString& commonNameFile);

    void loadSciNames(const QString& sciNameFile);

    void loadGcvs(const QString& GcvsFile);

    void loadWds(const QString& WdsFile);

    void loadCrossIdentificationData(const QString& crossIdFile);

    // TODO: add a non-lame description - what is the purpose of the max search level?
    int getMaxSearchLevel() const;

    void loadData(QVariantMap starsConfigFile);

    void drawPointer(StelPainter& sPainter, const StelCore* core);

    void populateHipparcosLists();
    void populateStarsDesignations();

    QList<StelObjectP> hipparcosStars;
    QList<QMap<StelObjectP, float>> doubleHipStars, variableHipStars, hipStarsHighPM;

    LinearFader labelsFader;
    LinearFader starsFader;

    bool flagStarName;
    double labelsAmount;
    bool gravityLabel;

    int maxGeodesicGridLevel;
    int lastMaxSearchLevel;
    
    // A ZoneArray per grid level
    QVector<ZoneArray*> gridLevels;
    static void initTriangleFunc(int lev, int index,
                                 const Vec3f &c0,
                                 const Vec3f &c1,
                                 const Vec3f &c2,
                                 void *context)
    {
        reinterpret_cast<StarMgr*>(context)->initTriangle(lev, index, c0, c1, c2);
    }

    void initTriangle(int lev, int index,
                      const Vec3f &c0,
                      const Vec3f &c1,
                      const Vec3f &c2);

    HipIndexStruct *hipIndex; // array of Hipparcos stars

    static QHash<int, QString> commonNamesMap;     // the original names from skyculture (star_names.fab)
    static QHash<int, QString> commonNamesMapI18n; // translated names
    static QMap<QString, int> commonNamesIndexI18n;
    static QMap<QString, int> commonNamesIndex;

    static QHash<int, QString> additionalNamesMap; // additional names
    static QHash<int, QString> additionalNamesMapI18n;
    static QMap<QString, int> additionalNamesIndex;
    static QMap<QString, int> additionalNamesIndexI18n;

    static QHash<int, QString> sciNamesMapI18n; 
    static QMap<QString, int> sciNamesIndexI18n;

    static QHash<int, QString> sciAdditionalNamesMapI18n;
    static QMap<QString, int> sciAdditionalNamesIndexI18n;

    static QHash<int, varstar> varStarsMapI18n;
    static QMap<QString, int> varStarsIndexI18n;

    static QHash<int, wds> wdsStarsMapI18n;
    static QMap<QString, int> wdsStarsIndexI18n;

    static QMap<QString, crossid> crossIdMap;
    static QMap<int, int> saoStarsIndex;
    static QMap<int, int> hdStarsIndex;
    static QMap<int, int> hrStarsIndex;

    static QHash<int, QString> referenceMap;

    QFont starFont;
    static bool flagSciNames;
    Vec3f labelColor;

    StelTextureSP texPointer;       // The selection pointer texture

    class StelObjectMgr* objectMgr;

    QString starConfigFileFullPath;
    QVariantMap starSettings;
    QVariantList catalogsDescription;
};


#endif // _STARMGR_HPP_