File indexing completed on 2024-04-28 15:09:13

 /*
     SPDX-FileCopyrightText: 2022 Hy Murveit <hy@murveit.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <stellarsolver.h>
 
 #include <QObject>
 #include <QString>
 #include <QTimer>
 #include <QFutureWatcher>
 #include <mutex>
 #include <memory>
 #include <QSharedPointer>
 
 #ifdef _WIN32
 #undef Unused
 #endif
 
 class FITSData;
 
 // This is a wrapper to make calling the StellarSolver solver a bit simpler.
 // Must supply the imagedata and stellar solver parameters
 // and connect to the signals. Remote solving not supported.
 class SolverUtils : public QObject
 {
         Q_OBJECT
 
     public:
         SolverUtils(const SSolver::Parameters &parameters, double timeoutSeconds = 15,
                     SSolver::ProcessType type = SSolver::SOLVE);
         ~SolverUtils();
 
         void runSolver(const QSharedPointer<FITSData> &data);
         void runSolver(const QString &filename);
         SolverUtils &useScale(bool useIt, double scaleLowArcsecPerPixel, double scaleHighArcsecPerPixel);
         SolverUtils &usePosition(bool useIt, double raDegrees, double decDegrees);
         bool isRunning() const;
         void abort();
 
         void setHealpix(int indexToUse = -1, int healpixToUse = -1);
         void getSolutionHealpix(int *indexUsed, int *healpixUsed) const;        
 
         const FITSImage::Background &getBackground() const
         {
             // Better leak than crash. Warn?
             if (!m_StellarSolver) return *new FITSImage::Background();
             return m_StellarSolver->getBackground();
         }
         const QList<FITSImage::Star> &getStarList() const
         {
             // Better leak than crash. Warn?
             if (!m_StellarSolver) return *new QList<FITSImage::Star>();
             return m_StellarSolver->getStarList();
         }
         int getNumStarsFound() const
         {
             if (!m_StellarSolver) return 0;
             return m_StellarSolver->getNumStarsFound();
         };
 
         // We don't trust StellarSolver's mutli-processing algorithm MULTI_DEPTHS which is used
         // with multiAlgorithm==MULTI_AUTO && use_scale && !use_position. This disables that.
         static void patchMultiAlgorithm(StellarSolver *solver);
 
     signals:
         void done(bool timedOut, bool success, const FITSImage::Solution &solution, double elapsedSeconds);
         void newLog(const QString &logText);
 
     private:
         void solverDone();
         void solverTimeout();
         void executeSolver();
         void prepareSolver();
 
         std::unique_ptr<StellarSolver> m_StellarSolver;
 
         qint64 m_StartTime;
         QTimer m_SolverTimer;
         // Copy of parameters
         SSolver::Parameters m_Parameters;
         // Solver timeout in milliseconds.
         const uint32_t m_TimeoutMilliseconds {0};
         // Temporary file name in case of external solver.
         QString m_TemporaryFilename;
         QFutureWatcher<bool> m_Watcher;
         double m_ScaleLowArcsecPerPixel {0}, m_ScaleHighArcsecPerPixel {0};
 
         QSharedPointer<FITSData> m_ImageData;
 
         int m_IndexToUse { -1 };
         int m_HealpixToUse { -1 };
 
         bool m_UseScale { false };
         bool m_UsePosition { false };
         double m_raDegrees { 0.0 };
         double m_decDegrees { 0.0 };
 
         SSolver::ProcessType m_Type = SSolver::SOLVE;
         std::mutex deleteSolverMutex;
 };