File indexing completed on 2024-04-21 14:44:04

 /*
     SPDX-FileCopyrightText: 2002 Mark Hollomon <mhh@mindspring.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 /** @class KSUtils
     *@short KStars utility functions
     *@author Mark Hollomon
     *@version 1.0
     *Static functions for various purposes.
     *The openDataFile() function searches the standard KDE directories
     *for the data filename given as an argument.
     *(it is impossible to instantiate a KSUtils object; just use the static functions).
     */
 
 #pragma once
 
 #include "dms.h"
 
 #include <QPointF>
 #include <QSharedPointer>
 #include <QJsonDocument>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <unordered_map>
 
 #include "config-kstars.h"
 // N.B. DO not remove, it is required for compilation.
 #include "polyfills/qstring_hash.h"
 
 #if __GNUC__ > 5
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif
 #if __GNUC__ > 6
 #pragma GCC diagnostic ignored "-Wint-in-bool-context"
 #endif
 #include <Eigen/Core>
 #if __GNUC__ > 5
 #pragma GCC diagnostic pop
 #endif
 
 #include <cstddef>
 
 class QFile;
 class QString;
 class QTextStream;
 class SkyPoint;
 class SkyObject;
 class StarObject;
 
 namespace KSUtils
 {
 // Quick checks whether hardware is limited or not
 // right now the only check is architecture. arm processors are limited while x86 are sufficient
 bool isHardwareLimited();
 
 /** Attempt to open the data file named filename, using the QFile object "file".
  *First look in the standard KDE directories, then look in a local "data"
  *subdirectory.  If the data file cannot be found or opened, display a warning
  *messagebox.
  *@short Open a data file.
  *@param file The QFile object to be opened
  *@param s The name of the data file.
  *@returns bool Returns true if data file was opened successfully.
  *@returns a reference to the opened file.
  */
 bool openDataFile(QFile &file, const QString &s);
 
 /** Clamp value into range.
  *  @p x  value to clamp.
  *  @p min  minimal allowed value.
  *  @p max  maximum allowed value.
  */
 template <typename T>
 inline T clamp(T x, T min, T max)
 {
     if (x < min)
         return min;
     if (x > max)
         return max;
     return x;
 }
 
 /** Put angle into range. Period is equal to max-min.
  *
  *  @p x angle value
  *  @p min minimal angle
  *  @p max maximal angle
  */
 template <typename T>
 inline T reduceAngle(T x, T min, T max)
 {
     T delta = max - min;
     return x - delta * floor((x - min) / delta);
 }
 
 /** Convert from spherical to cartesian coordinate system.
  *  Resulting vector have unit length
  */
 inline Eigen::Vector3d fromSperical(const dms &longitude, const dms &latitude)
 {
     double sinL, sinB;
     double cosL, cosB;
 
     longitude.SinCos(sinL, cosL);
     latitude.SinCos(sinB, cosB);
     return Eigen::Vector3d(cosB * cosL, cosB * sinL, sinB);
 }
 
 /** Convert a vector to a point */
 inline QPointF vecToPoint(const Eigen::Vector2f &vec)
 {
     return QPointF(vec[0], vec[1]);
 }
 
 /** Convert a point to a vector */
 inline Eigen::Vector2f pointToVec(const QPointF &p)
 {
     return Eigen::Vector2f(p.x(), p.y());
 }
 
 /**
  *@short Create a URL to obtain a DSS image for a given SkyPoint
  *@note If SkyPoint is a DeepSkyObject, this method automatically
  *decides the image size required to fit the object.
  */
 QString getDSSURL(const SkyPoint *const p);
 
 /**
  *@short Create a URL to obtain a DSS image for a given RA, Dec
  *@param ra The J2000.0 Right Ascension of the point
  *@param dec The J2000.0 Declination of the point
  *@param width The width of the image in arcminutes
  *@param height The height of the image in arcminutes
  *@param type The image type, either gif or fits.
  *@note This method resets height and width to fall within the range accepted by DSS
  */
 QString getDSSURL(const dms &ra, const dms &dec, float width = 0, float height = 0,
                   const QString &type = "gif");
 
 /**
  *@short Return a string corresponding to an angle specifying direction
  *
  * The angle must measure direction from North, towards East. Both
  * the azimuth and position angle follow this convention, so this
  * method can be used to return a string corresponding to the
  * general heading of a given azimuth / position angle.
  *
  *@param angle angle as dms (measured from North, towards East)
  *@return A localized string corresponding to the approximate direction (eg: NNW)
  */
 QString toDirectionString(dms angle);
 /**
  *@short Converts StarObject list into SkyObject list
  *@param starObjList QList of StarObject pointers
  *@return Returns a pointer to QList of SkyObject pointers
  *@note Used for Star-Hopper
  */
 QList<SkyObject *> *castStarObjListToSkyObjList(QList<StarObject *> *starObjList);
 
 /**
  *@note Avoid using this method for the same reasons as QSharedPointer::data()
  */
 template <typename T>
 QList<T *> makeVanillaPointerList(const QList<QSharedPointer<T>> &spList)
 {
     QList<T *> vpList;
     foreach (QSharedPointer<T> sp, spList)
         vpList.append(sp.data());
     return vpList;
 }
 
 /**
  *@short Return the genetive form of constellation name, given the abbreviation
  *@param code Three-letter IAU abbreviation of the constellation
  *@return the genetive form of the constellation name
  */
 QString constGenetiveFromAbbrev(const QString &code);
 
 /**
  *@short Return the name of the constellation, given the abbreviation
  *@param code Three-letter IAU abbreviation of the constellation
  *@return the nominative form of the constellation name
  */
 QString constNameFromAbbrev(const QString &code);
 
 /**
  *@short Return the abbreviation of the constellation, given the full name
  *@param fullName_ Full name of the constellation
  *@return the three-letter IAU standard abbreviation of the constellation
  */
 QString constNameToAbbrev(const QString &fullName_);
 
 /**
  *@short Return the abbreviation of the constellation, given the genetive form
  *@param genetive_ the genetive form of the constellation's name
  *@return the three-letter IAU standard abbreviation of the constellation
  */
 QString constGenetiveToAbbrev(const QString &genetive_);
 
 /**
 * Interface into Qt's logging system
 * @author: Yale Dedis 2011
 * Adapted from DeDiS project.
 */
 class Logging
 {
     public:
         /**
                  * Store all logs into the specified file
                  */
         static void UseFile();
 
         /**
                  * Output logs to stdout
                  */
         static void UseStdout();
 
         /**
                  * Output logs to stderr
                  */
         static void UseStderr();
 
         /**
                  * Use the default logging mechanism
                  */
         static void UseDefault();
 
         /**
                  * Disable logging
                  */
         static void Disable();
 
         /**
              * @brief SyncFilterRules Sync QtLogging filter rules from Options
              */
         static void SyncFilterRules();
 
     private:
         static QString _filename;
 
         static void Disabled(QtMsgType type, const QMessageLogContext &context,
                              const QString &msg);
         static void File(QtMsgType type, const QMessageLogContext &context,
                          const QString &msg);
         static void Stdout(QtMsgType type, const QMessageLogContext &context,
                            const QString &msg);
         static void Stderr(QtMsgType type, const QMessageLogContext &context,
                            const QString &msg);
         static void Write(QTextStream &stream, QtMsgType type,
                           const QMessageLogContext &context, const QString &msg);
 };
 
 QString getDefaultPath(const QString &option);
 
 #ifdef Q_OS_OSX
 void copyResourcesFolderFromAppBundle(QString folder);
 bool setupMacKStarsIfNeeded(); //The boolean returns true if the data folders are good to go.
 bool configureAstrometry();
 bool replaceIndexFileNotYetSet();
 bool copyRecursively(QString sourceFolder, QString destFolder);
 #endif
 
 // Astrometry Related functions
 QStringList getAstrometryDefaultIndexFolderPaths();
 QString getAstrometryConfFilePath();
 QStringList getAstrometryDataDirs();
 bool addAstrometryDataDir(const QString &dataDir);
 bool removeAstrometryDataDir(const QString &dataDir);
 
 struct JPLFilter
 {
     QByteArray item;
     QByteArray op;
     QByteArray value;
 };
 
 class JPLParser
 {
     public:
         JPLParser(const QString &path);
 
         const QJsonArray &data() const
         {
             return m_data;
         }
         const std::unordered_map<QString, int> &fieldMap() const
         {
             return m_field_map;
         }
 
         template <typename Lambda>
         void for_each(const Lambda &fct)
         {
             for (const auto &item : m_data)
             {
                 fct([ &, this](const QString & key)
                 {
                     return item.toArray().at(m_field_map.at(key));
                 });
             }
         };
 
     private:
         QJsonDocument m_doc;
         QJsonArray m_data;
         std::unordered_map<QString, int> m_field_map;
 };
 // TODO: Implement Datatypes//Maps for kind, datafields, filters...
 
 class MPCParser
 {
     public:
         MPCParser(const QString &path);
 
         template <typename Lambda>
         void for_each(const Lambda &fct)
         {
             for (const auto &item : m_data)
             {
                 fct([ &, this](const QString & key)
                 {
                     return item.toObject().value(key);
                 });
             }
         };
 
     private:
         QJsonDocument m_doc;
         QJsonArray m_data;
 };
 
 /**
  *@short Generate a query string for downloading comet/asteroid data from JPL.
  *@param kind The kind of object we want: ast, com.
  *@param dataFields The columns we want to download.
  *@param filters Filters for the Data.
  *@return The query string.
  */
 QByteArray getJPLQueryString(const QByteArray &kind, const QByteArray &dataFields,
                              const QVector<JPLFilter> &filters);
 
 /**
  * @brief RAWToJPEG Convert raw image (e.g. CR2) using libraw to a JPEG image
  * @param rawImage full path to raw image
  * @param output full path to jpeg image to write to
  * @return True if conversion is successful, false otherwise.
  */
 bool RAWToJPEG(const QString &rawImage, const QString &output, QString &errorMessage);
 
 /**
  * @brief getAvailableRAM Try to get available and total RAM on system
  * @return availableRAM Available (free and unclaimed) system RAM in bytes. 0 if failed to determine RAM
  */
 double getAvailableRAM();
 
 void setGlobalSettings(const QVariantMap &settings);
 
 /**
  * @brief sanitize Remove all illegal characters and spaces that can be problematic in file paths across all OSes.
  * @param text String to sanitize
  * @return Sanitized text
  */
 QString sanitize(const QString &text);
 
 /**
  * @brief rangePA Limit position angle to -180 to +180 range
  * @param pa Position angle
  * @return limited position angle
  */
 double rangePA(double pa);
 
 /**
  * @brief range360 Limit angle to be in 0 to 360 range
  * @param r angle in degrees
  * @return Limited angle in degrees
  */
 double range360(double r);
 
 /**
          * @brief rotationToPositionAngle Convert from astrometry.net rotation to PA
          * @param value rotation in degrees (-180 to +180)
          * @return Position angle in degrees (-180 to +180)
          */
 double rotationToPositionAngle(double value);
 
 /** @brief rotationToPositionAngle Convert from position angle to astrometry.net rotation
          * @param value Position angle in degrees (-180 to +180)
          * @return rotation in degrees (-180 to +180)
          */
 double positionAngleToRotation(double value);
 
 } // namespace KSUtils