Kstars

starcomponent.h
1 /*
2  SPDX-FileCopyrightText: 2005 Thomas Kabelmann <[email protected]>
3 
4  SPDX-License-Identifier: GPL-2.0-or-later
5 */
6 
7 #pragma once
8 
9 #include "ksnumbers.h"
10 #include "listcomponent.h"
11 #include "skylabel.h"
12 #include "stardata.h"
13 #include "skyobjects/starobject.h"
14 
15 #include <memory>
16 
17 #ifdef KSTARS_LITE
18 class StarItem;
19 #endif
20 
21 class KStarsSplash;
22 class BinFileHelper;
23 class DeepStarComponent;
24 class HighPMStarList;
25 class MeshIterator;
26 class SkyLabeler;
27 class SkyMesh;
28 class StarObject;
29 class StarBlockFactory;
30 
31 #define MAX_LINENUMBER_MAG 90
32 
33 /**
34  * @class StarComponent
35  *
36  * @short Represents the stars on the sky map. For optimization reasons the stars are not
37  * separate objects and are stored in a list.
38  *
39  * The StarComponent class manages all stars drawn in KStars. While it handles all stars
40  * having names using its own member methods, it shunts the responsibility of unnamed stars
41  * to the class 'DeepStarComponent', objects of which it maintains.
42  *
43  * @author Thomas Kabelmann
44  * @author Akarsh Simha
45  * @version 1.0
46  */
48 {
49 #ifdef KSTARS_LITE
50  friend class StarItem; //Needs access to faintMagnitude() and reindex()
51 #endif
52 
53  protected:
55 
56  public:
57  ~StarComponent() override;
58 
59  // TODO: Desingletonize StarComponent
60  /** @short Create an instance of StarComponent */
62 
63  /** @return the instance of StarComponent if already created, nullptr otherwise */
64  static StarComponent *Instance() { return pinstance; }
65 
66  //This function is empty; we need that so that the JiT update
67  //is the only one being used.
68  void update(KSNumbers *num) override;
69 
70  bool selected() override;
71 
72  void draw(SkyPainter *skyp) override;
73 
74  /**
75  * @short draw all the labels in the prioritized LabelLists and then clear the LabelLists.
76  */
77  void drawLabels();
78 
79  static float zoomMagnitudeLimit();
80 
81  SkyObject *objectNearest(SkyPoint *p, double &maxrad) override;
82 
83  virtual SkyObject *findStarByGenetiveName(const QString name);
84 
85  /**
86  * @short Searches the region(s) and appends the SkyObjects found to the list of sky objects
87  *
88  * Look for a SkyObject that is in one of the regions
89  * If found, then append to the list of sky objects
90  * @p list list of SkyObject to which matching list has to be appended to
91  * @p region defines the regions in which the search for SkyObject should be done within
92  */
93  void objectsInArea(QList<SkyObject *> &list, const SkyRegion &region) override;
94 
95  /**
96  * @short Find stars by HD catalog index
97  * @param HDnum HD Catalog Number of the star to find
98  * @return If the star is a static star, a pointer to the star will be returned
99  * If it is a dynamic star, a fake copy will be created that survives till
100  * the next findByHDIndex() call. If no match was found, returns nullptr.
101  */
102  StarObject *findByHDIndex(int HDnum);
103 
104 
105  /**
106  * @short Append a star to the Object List. (including genetive name)
107  *
108  * Overrides ListComponent::appendListObject() to include genetive names of stars as well.
109  */
110  void appendListObject(SkyObject * object);
111 
112  /**
113  * @short Add to the given list, the stars from this component, that lie within the
114  * specified circular aperture, and that are brighter than the limiting magnitude specified.
115  * @p center The center point of the aperture
116  * @p radius The radius around the center point that defines the aperture
117  * @p maglim Optional parameter indicating the limiting magnitude.
118  * If magnitude limit is numerically < -28, the limiting magnitude
119  * is assumed to be the limiting magnitude of the catalog (i.e. no magnitude limit)
120  * @p list The list to operate on
121  */
122  void starsInAperture(QList<StarObject *> &list, const SkyPoint &center, float radius, float maglim = -29);
123 
124  // TODO: Make byteSwap a template method and put it in byteorder.h
125  // It should ideally handle 32-bit, 16-bit fields and StarData and
126  // DeepStarData fields
127  static void byteSwap(StarData *stardata);
128 
129  private:
130  /**
131  * @short Read data for stars which will remain static in the memory
132  *
133  * This method reads data for named stars (stars having names, which are stored by
134  * default in "namedstars.dat") into memory. These stars are always kept in memory,
135  * as against 'deep' stars which are mostly loaded dynamically (KStars treats all
136  * unnamed stars as 'deep' stars) into memory when required, depending on region
137  * and magnitude limit. Once loading is successful, this method sets the starsLoaded flag to true
138  */
139  bool loadStaticData();
140 
141  /** @return the magnitude of the faintest star */
142  float faintMagnitude() const;
143 
144  /** true if all stars(not only high PM ones) were reindexed else false**/
145  bool reindex(KSNumbers *num);
146 
147  /** Adds a label to the lists of labels to be drawn prioritized by magnitude. */
148  void addLabel(const QPointF &p, StarObject *star);
149 
150  void reindexAll(KSNumbers *num);
151 
152  /** Load available deep star catalogs */
153  int loadDeepStarCatalogs();
154 
155  bool addDeepStarCatalogIfExists(const QString &fileName, float trigMag, bool staticstars = false);
156 
157  SkyMesh *m_skyMesh { nullptr };
158  std::unique_ptr<StarIndex> m_starIndex;
159 
160  KSNumbers m_reindexNum;
161  double m_reindexInterval { 0 };
162 
163  LabelList *m_labelList[MAX_LINENUMBER_MAG + 1];
164  bool m_hideLabels { false };
165 
166  float m_zoomMagLimit { 0 };
167 
168  /// Limiting magnitude of the catalog currently loaded
169  float m_FaintMagnitude { -5 };
170  bool starsLoaded { false };
171  /// Current limiting magnitude for visible stars
172  float magLim { 0 };
173 
174  StarObject m_starObject;
175  StarObject *focusStar { nullptr }; // This object is always drawn
176 
177  KStarsSplash *m_reindexSplash { nullptr };
178 
179  StarBlockFactory *m_StarBlockFactory { nullptr };
180 
181  QVector<HighPMStarList *> m_highPMStars;
182  QHash<QString, SkyObject *> m_genName;
183  QHash<int, StarObject *> m_HDHash;
184  QVector<DeepStarComponent *> m_DeepStarComponents;
185 
186  /**
187  * @struct starName
188  * @brief Structure that holds star name information, to be read as-is from the
189  * corresponding binary data file
190  */
191  typedef struct starName
192  {
193  char bayerName[8];
194  char longName[32];
195  } starName;
196 
197  StarData stardata;
198  starName starname;
199 
200  static StarComponent *pinstance;
201 };
Represents the stars on the sky map. For optimization reasons the stars are not separate objects and ...
Definition: starcomponent.h:47
SkyObject * objectNearest(SkyPoint *p, double &maxrad) override
Find the SkyObject nearest the given SkyPoint.
A 32-byte Structure that holds star data.
Definition: stardata.h:17
Stores dms coordinates for a point in the sky. for converting between coordinate systems.
Definition: skypoint.h:44
static StarComponent * Instance()
Definition: starcomponent.h:64
void objectsInArea(QList< SkyObject * > &list, const SkyRegion &region) override
Searches the region(s) and appends the SkyObjects found to the list of sky objects.
static StarComponent * Create(SkyComposite *)
Create an instance of StarComponent.
Store several time-dependent astronomical quantities.
Definition: ksnumbers.h:42
Class that handles Stars.
Definition: staritem.h:22
the KStars Splash Screen.
Definition: kstarssplash.h:20
subclass of SkyObject specialized for stars.
Definition: starobject.h:32
Implements an interface to handle binary data files used by KStars.
Definition: binfilehelper.h:38
Draws things on the sky, without regard to backend.
Definition: skypainter.h:37
bool selected() override
void update(KSNumbers *num) override
Update the sky positions of this component.
void drawLabels()
draw all the labels in the prioritized LabelLists and then clear the LabelLists.
A factory that creates StarBlocks and recycles them in an LRU Cache.
void starsInAperture(QList< StarObject * > &list, const SkyPoint &center, float radius, float maglim=-29)
Add to the given list, the stars from this component, that lie within the specified circular aperture...
StarObject * findByHDIndex(int HDnum)
Find stars by HD catalog index.
Information about an object in the sky.
Definition: skyobject.h:41
void draw(SkyPainter *skyp) override
Draw the object on the SkyMap skyp a pointer to the SkyPainter to use.
void appendListObject(SkyObject *object)
Append a star to the Object List.
This file is part of the KDE documentation.
Documentation copyright © 1996-2022 The KDE developers.
Generated on Mon Aug 15 2022 04:04:06 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.