Working solver

2024-09-20 14:34:21 +02:00
parent c8898387fe
commit dccb2e88da
9 changed files with 506 additions and 50 deletions
@@ -1,5 +1,8 @@
 #include "solver.h"
+#include <QJsonObject>
+#include <QJsonDocument>
 #include <fitsio.h>
+#include <QStandardPaths>
 #include <wcslib/wcshdr.h>
 #include <wcslib/wcsutil.h>
 #include "rawimage.h"
@@ -8,65 +11,121 @@

 Solver::Solver(QObject *parent) : QObject(parent)
 {
-    _solver = std::make_unique<StellarSolver>();
+    _solver = new StellarSolver(this);

-    QStringList indexFolder = StellarSolver::getDefaultIndexFolderPaths();
+    QStringList indexFolder = getIndexPaths();

    _solver->setProperty("ProcessType", SSolver::SOLVE);
    _solver->setIndexFolderPaths(indexFolder);
    _solver->setParameterProfile(SSolver::Parameters::ALL_STARS);
+
+    connect(_solver, &StellarSolver::finished, this, &Solver::finished);
 }

 Solver::~Solver()
 {
 }

-bool Solver::solveImage(const QString &path)
+void Solver::setIndexFolders(const QStringList &indexPaths)
 {
-    ImageInfoData info;
-    std::shared_ptr<RawImage> rawImage;
-    if(loadImage(path, info, rawImage, true))
-    {
-        _path = path;
-        switch(rawImage->type())
-        {
-        case RawImage::UINT8:
-            _stats.dataType = TBYTE;
-            break;
-        case RawImage::UINT16:
-            _stats.dataType = TUSHORT;
-            break;
-        case RawImage::UINT32:
-            _stats.dataType = TUINT;
-            break;
-        case RawImage::FLOAT32:
-            _stats.dataType = TFLOAT;
-            break;
-        case RawImage::FLOAT64:
-            _stats.dataType = TDOUBLE;
-            break;
-        default:
-            _error = tr("Unsupported image data type");
-            return false;
-            break;
-        }
-        _stats.bytesPerPixel = rawImage->typeSize(rawImage->type());
-        _stats.channels = rawImage->channels();
-        _stats.width = rawImage->width();
-        _stats.height = rawImage->height();
-        _stats.samples_per_channel = _stats.width * _stats.height;
+    _solver->setIndexFolderPaths(indexPaths);
+}

-        _solver->loadNewImageBuffer(_stats, (const uint8_t*)rawImage->data());
-        return _solver->solve();
+bool Solver::loadImage(const QString &path)
+{
+    _loaded = false;
+    std::shared_ptr<RawImage> image;
+    ImageInfoData info;
+    if(::loadImage(path, info, image, true))
+    {
+        loadImage(image, path);
    }
    return false;
 }

-FITSImage::Solution Solver::getSolution() const
+bool Solver::loadImage(std::shared_ptr<RawImage> &image, const QString &path)
+{
+    _rawImage = image;
+    switch(_rawImage->type())
+    {
+    case RawImage::UINT8:
+        _stats.dataType = TBYTE;
+        break;
+    case RawImage::UINT16:
+        _stats.dataType = TUSHORT;
+        break;
+    case RawImage::UINT32:
+        _stats.dataType = TUINT;
+        break;
+    case RawImage::FLOAT32:
+        _stats.dataType = TFLOAT;
+        break;
+    case RawImage::FLOAT64:
+        _stats.dataType = TDOUBLE;
+        break;
+    default:
+        _error = tr("Unsupported image data type");
+        return false;
+        break;
+    }
+    _stats.bytesPerPixel = _rawImage->typeSize(_rawImage->type());
+    _stats.channels = _rawImage->channels();
+    _stats.width = _rawImage->width();
+    _stats.height = _rawImage->height();
+    _stats.samples_per_channel = _stats.width * _stats.height;
+
+    _loaded = _solver->loadNewImageBuffer(_stats, (const uint8_t*)_rawImage->data());
+    _path = path;
+    return _loaded;
+}
+
+bool Solver::solveImage()
+{
+    if(_loaded && !_solver->isRunning())
+    {
+        _process = SSolver::ProcessType::SOLVE;
+        _solver->setProperty("ProcessType", _process);
+        _solver->start();
+        return true;
+    }
+    return false;
+}
+
+bool Solver::extractSources(bool hfr)
+{
+    if(_loaded && !_solver->isRunning())
+    {
+        _process = hfr ? SSolver::ProcessType::EXTRACT_WITH_HFR : SSolver::ProcessType::EXTRACT;
+        _solver->setProperty("ProcessType", _process);
+        _solver->start();
+        return true;
+    }
+    return false;
+}
+
+const FITSImage::Solution& Solver::getSolution() const
 {
    return _solver->getSolution();
 }

+const QList<FITSImage::Star>& Solver::getStars() const
+{
+    return _solver->getStarList();
+}
+
+double Solver::getHFR() const
+{
+    double hfr = 0.0;
+    auto stars = getStars();
+    if(stars.empty())return -1.0;
+
+    for(auto &star : stars)
+    {
+        hfr += star.HFR;
+    }
+    return hfr / stars.size();
+}
+
 QString Solver::errorMessage() const
 {
    return _error;
@@ -74,6 +133,8 @@ QString Solver::errorMessage() const

 void Solver::updateHeader()
 {
+    if(!_solver->solvingDone())return;
+
    FITSImage::Solution solution = getSolution();
    qDebug() << "RA" << solution.ra << "DEC" << solution.dec << "Orient" << solution.orientation << "field wxh" << solution.fieldWidth << solution.fieldHeight << solution.pixscale;
    qDebug() << "error" << solution.raError << solution.decError;
@@ -105,3 +166,40 @@ void Solver::updateHeader()
    modify.updateKeyword("EQUINOX", 2000, QByteArray("Equinox of coordinates"));
    file.modifyFITSRecords(&modify);
 }
+
+void Solver::setParameters(Parameters::ParametersProfile profile)
+{
+    _solver->setParameterProfile(profile);
+}
+
+void Solver::setParameters(const Parameters &parameters)
+{
+    _solver->setParameters(parameters);
+}
+
+QStringList Solver::getIndexPaths()
+{
+    QStringList paths;// = StellarSolver::getDefaultIndexFolderPaths();
+    paths.prepend(getTenmonIndexPath());
+    return paths;
+}
+
+QString Solver::getTenmonIndexPath()
+{
+    return QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/astrometry";
+}
+
+void Solver::finished()
+{
+    switch(_process)
+    {
+    case SSolver::ProcessType::SOLVE:
+        emit solvingDone();
+        break;
+    case SSolver::ProcessType::EXTRACT_WITH_HFR:
+    case SSolver::ProcessType::EXTRACT:
+        emit extractionDone();
+        break;
+    }
+
+}