Nebula.hpp

/*
 * Stellarium
 * Copyright (C) 2002 Fabien Chereau
 * Copyright (C) 2011 Alexander Wolf
 * Copyright (C) 2015 Georg Zotti
 *
 * 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 _NEBULA_HPP_
#define _NEBULA_HPP_

#include "StelObject.hpp"
#include "StelTranslator.hpp"
#include "StelTextureTypes.hpp"

#include <QString>

class StelPainter;
class QDataStream;

// This only draws nebula icons. For the DSO images, see StelSkylayerMgr and StelSkyImageTile.
class Nebula : public StelObject
{
friend class NebulaMgr;

    //Required for the correct working of the Q_FLAGS macro (which requires a MOC pass)
    Q_GADGET
    Q_FLAGS(CatalogGroup)
    Q_FLAGS(TypeGroup)
    Q_ENUMS(NebulaType)
public:
    enum CatalogGroupFlags
    {
        CatNGC      = 0x00000001, 
        CatIC       = 0x00000002, 
        CatM        = 0x00000004, 
        CatC        = 0x00000008, 
        CatB        = 0x00000010, 
        CatSh2      = 0x00000020, 
        CatLBN      = 0x00000040, 
        CatLDN      = 0x00000080, 
        CatRCW      = 0x00000100, 
        CatVdB      = 0x00000200, 
        CatCr       = 0x00000400, 
        CatMel      = 0x00000800, 
        CatPGC      = 0x00001000, 
        CatUGC      = 0x00002000, 
        CatCed      = 0x00004000  
    };
    Q_DECLARE_FLAGS(CatalogGroup, CatalogGroupFlags)

    enum TypeGroupFlags
    {
        TypeGalaxies        = 0x00000001, 
        TypeActiveGalaxies  = 0x00000002, 
        TypeInteractingGalaxies = 0x00000004, 
        TypeStarClusters    = 0x00000008, 
        TypeHydrogenRegions = 0x00000010, 
        TypeBrightNebulae   = 0x00000020, 
        TypeDarkNebulae     = 0x00000040, 
        TypePlanetaryNebulae    = 0x00000080, 
        TypeSupernovaRemnants   = 0x00000100, 
        TypeOther       = 0x00000200  
    };
    Q_DECLARE_FLAGS(TypeGroup, TypeGroupFlags)

    
    static const CatalogGroupFlags AllCatalogs = (CatalogGroupFlags)(CatNGC|CatIC|CatM|CatC|CatB|CatSh2|CatLBN|CatLDN|CatRCW|CatVdB|CatCr|CatMel|CatPGC|CatUGC|CatCed);
    static const TypeGroupFlags AllTypes = (TypeGroupFlags)(TypeGalaxies|TypeActiveGalaxies|TypeInteractingGalaxies|TypeStarClusters|TypeHydrogenRegions|TypeBrightNebulae|TypeDarkNebulae|TypePlanetaryNebulae|TypeSupernovaRemnants|TypeOther);

    enum NebulaType
    {
        NebGx       = 0,    
        NebAGx      = 1,    
        NebRGx      = 2,    
        NebIGx      = 3,    
        NebQSO      = 4,    
        NebCl       = 5,    
        NebOc       = 6,    
        NebGc       = 7,    
        NebSA       = 8,    
        NebSC       = 9,    
        NebN        = 10,   
        NebPn       = 11,   
        NebDn       = 12,   
        NebRn       = 13,   
        NebBn       = 14,   
        NebEn       = 15,   
        NebCn       = 16,   
        NebHII      = 17,   
        NebSNR      = 18,   
        NebISM      = 19,   
        NebEMO      = 20,   
        NebBLL      = 21,   
        NebBLA      = 22,   
        NebMolCld   = 23,   
        NebYSO      = 24,   
        NebPossQSO  = 25,   
        NebPossPN   = 26,   
        NebPPN      = 27,   
        NebStar     = 28,   
        NebUnknown  = 29    
    };

    Nebula();
    ~Nebula();

    virtual QString getInfoString(const StelCore *core, const InfoStringGroup& flags) const;
    virtual QVariantMap getInfoMap(const StelCore *core) const;
    virtual QString getType() const {return "Nebula";}
    virtual Vec3d getJ2000EquatorialPos(const StelCore*) const {return XYZ;}
    virtual double getCloseViewFov(const StelCore* core = NULL) const;
    virtual float getVMagnitude(const StelCore* core) const;
    virtual float getSelectPriority(const StelCore* core) const;
    virtual Vec3f getInfoColor() const;
    virtual QString getNameI18n() const {return nameI18;}
    virtual QString getEnglishName() const {return englishName;}
    QString getEnglishAliases() const;
    QString getI18nAliases() const;
    virtual double getAngularSize(const StelCore*) const;
    virtual SphericalRegionP getRegion() const {return pointRegion;}

    // Methods specific to Nebula
    void setLabelColor(const Vec3f& v) {labelColor = v;}
    void setCircleColor(const Vec3f& v) {circleColor = v;}

    QString getTypeString() const;

    NebulaType getDSOType() const {return nType;}

    QString getMorphologicalTypeString() const;

    float getSurfaceBrightness(const StelCore* core) const;
    float getSurfaceBrightnessWithExtinction(const StelCore* core) const;

    float getSurfaceArea(void) const;

    void setProperName(QString name) { englishName = name; }
    void addNameAlias(QString name) { englishAliases.append(name); }
    void removeAllNames() { englishName=""; englishAliases.clear(); }

    QString getDSODesignation();

private:
    friend struct DrawNebulaFuncObject;

    void translateName(const StelTranslator& trans)
    {
        nameI18 = trans.qtranslate(englishName);
        nameI18Aliases.clear();
        foreach(QString alias, englishAliases)
            nameI18Aliases.append(trans.qtranslate(alias));
    }

    void readDSO(QDataStream& in);

    void drawLabel(StelPainter& sPainter, float maxMagLabel);
    void drawHints(StelPainter& sPainter, float maxMagHints);

    bool objectInDisplayedType() const;

    QString getMorphologicalTypeDescription() const;

    unsigned int DSO_nb;
    unsigned int M_nb;              // Messier Catalog number
    unsigned int NGC_nb;            // New General Catalog number
    unsigned int IC_nb;             // Index Catalog number
    unsigned int C_nb;              // Caldwell Catalog number
    unsigned int B_nb;              // Barnard Catalog number (Dark Nebulae)
    unsigned int Sh2_nb;            // Sharpless Catalog number (Catalogue of HII Regions (Sharpless, 1959))
    unsigned int VdB_nb;            // Van den Bergh Catalog number (Catalogue of Reflection Nebulae (Van den Bergh, 1966))
    unsigned int RCW_nb;            // RCW Catalog number (H-α emission regions in Southern Milky Way (Rodgers+, 1960))
    unsigned int LDN_nb;            // LDN Catalog number (Lynds' Catalogue of Dark Nebulae (Lynds, 1962))
    unsigned int LBN_nb;            // LBN Catalog number (Lynds' Catalogue of Bright Nebulae (Lynds, 1965))
    unsigned int Cr_nb;             // Collinder Catalog number
    unsigned int Mel_nb;            // Melotte Catalog number
    unsigned int PGC_nb;            // PGC number (Catalog of galaxies)
    unsigned int UGC_nb;            // UGC number (The Uppsala General Catalogue of Galaxies)
    QString Ced_nb;         // Ced number (Cederblad Catalog of bright diffuse Galactic nebulae)    
    QString englishName;            // English name
    QStringList englishAliases; // English aliases
    QString nameI18;                // Nebula name
    QStringList nameI18Aliases;     // Nebula aliases
    QString mTypeString;        // Morphological type of object (as string) 
    float bMag;                     // B magnitude
    float vMag;                     // V magnitude. For Dark Nebulae, opacity is stored here.   
    float majorAxisSize;        // Major axis size in degrees
    float minorAxisSize;        // Minor axis size in degrees
    int orientationAngle;       // Orientation angle in degrees 
    float oDistance;        // distance (Mpc for galaxies, kpc for other objects)
    float oDistanceErr;     // Error of distance (Mpc for galaxies, kpc for other objects)
    float redshift;
    float redshiftErr;
    float parallax;
    float parallaxErr;
    Vec3d XYZ;                      // Cartesian equatorial position (J2000.0)
    Vec3d XY;                       // Store temporary 2D position
    NebulaType nType;

    SphericalRegionP pointRegion;

    static StelTextureSP texCircle;                    // The symbolic circle texture
    static StelTextureSP texGalaxy;                    // Type 0
    static StelTextureSP texOpenCluster;               // Type 1
    static StelTextureSP texGlobularCluster;           // Type 2
    static StelTextureSP texPlanetaryNebula;           // Type 3
    static StelTextureSP texDiffuseNebula;             // Type 4
    static StelTextureSP texDarkNebula;                // Type 5
    static StelTextureSP texOpenClusterWithNebulosity; // Type 7
    static float hintsBrightness;

    static Vec3f labelColor;            // The color of labels
    static Vec3f circleColor;           // The color of the symbolic circle texture (default marker; NebUnknown)
    static Vec3f galaxyColor;           // The color of galaxy marker texture (NebGx)
    static Vec3f radioGalaxyColor;          // The color of radio galaxy marker texture (NebRGx)
    static Vec3f activeGalaxyColor;         // The color of active galaxy marker texture (NebAGx)
    static Vec3f interactingGalaxyColor;        // The color of interacting galaxy marker texture (NebIGx)
    static Vec3f quasarColor;           // The color of quasar marker texture (NebQSO)
    static Vec3f nebulaColor;           // The color of nebula marker texture (NebN)
    static Vec3f planetaryNebulaColor;      // The color of planetary nebula marker texture (NebPn)
    static Vec3f reflectionNebulaColor;     // The color of reflection nebula marker texture (NebRn)
    static Vec3f bipolarNebulaColor;        // The color of bipolar nebula marker texture (NebBn)
    static Vec3f emissionNebulaColor;       // The color of emission nebula marker texture (NebEn)
    static Vec3f darkNebulaColor;           // The color of dark nebula marker texture (NebDn)
    static Vec3f hydrogenRegionColor;       // The color of hydrogen region marker texture (NebHII)
    static Vec3f supernovaRemnantColor;     // The color of supernova remnant marker texture (NebSNR)
    static Vec3f interstellarMatterColor;       // The color of interstellar matter marker texture (NebISM)
    static Vec3f clusterWithNebulosityColor;    // The color of cluster associated with nebulosity marker texture (NebCn)
    static Vec3f clusterColor;          // The color of star cluster marker texture (NebCl)
    static Vec3f openClusterColor;          // The color of open star cluster marker texture (NebOc)
    static Vec3f globularClusterColor;      // The color of globular star cluster marker texture (NebGc)
    static Vec3f stellarAssociationColor;       // The color of stellar association marker texture (NebSA)
    static Vec3f starCloudColor;            // The color of star cloud marker texture (NebSC)
    static Vec3f emissionObjectColor;       // The color of emission object marker texture (NebEMO)
    static Vec3f blLacObjectColor;          // The color of BL Lac object marker texture (NebBLL)
    static Vec3f blazarColor;           // The color of blazar marker texture (NebBLA)
    static Vec3f molecularCloudColor;       // The color of molecular cloud marker texture (NebMolCld)
    static Vec3f youngStellarObjectColor;       // The color of Young Stellar Object marker texture (NebYSO)
    static Vec3f possibleQuasarColor;       // The color of possible quasar marker texture (NebPossQSO)
    static Vec3f possiblePlanetaryNebulaColor;  // The color of possible planetary nebula marker texture (NebPossPN)
    static Vec3f protoplanetaryNebulaColor;     // The color of protoplanetary nebula marker texture (NebPPN)
    static Vec3f starColor;             // The color of star marker texture (NebStar)

    static bool drawHintProportional;     // scale hint with nebula size?
    static bool surfaceBrightnessUsage;
    static bool designationUsage;

    static bool flagUseTypeFilters;
    static CatalogGroup catalogFilters;
    static TypeGroup typeFilters;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(Nebula::CatalogGroup)
Q_DECLARE_OPERATORS_FOR_FLAGS(Nebula::TypeGroup)

#endif // _NEBULA_HPP_