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

 /*  Ekos Polar Alignment Assistant Tool
     SPDX-FileCopyrightText: 2018-2021 Jasem Mutlaq
     SPDX-FileCopyrightText: 2020-2021 Hy Murveit
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #pragma once
 
 #include "ui_polaralignmentassistant.h"
 #include "ekos/ekos.h"
 #include "ekos/guide/internalguide/starcorrespondence.h"
 #include "polaralign.h"
 #include "align.h"
 #include "indi/indimount.h"
 
 class AlignView;
 class QProgressIndicator;
 class SolverUtils;
 
 namespace Ekos
 {
 
 class PolarAlignWidget;
 
 /**
  * @brief The PolarAlignmentAssistant class
  *
  * Captures three images rotated by a set number of degrees decided by the user (default 30).
  * Each image is plate solver to find the center RA,DE coordinates. The three points are then
  * used to generate a unique circle with its center as the RA axis. As the mount rotated around
  * these point, we can identify the RA rotational axis. From there, we compare the distance from RA axis
  * to the celestial pole axis. For a perfectly aligned mount, the two points would overlap exactly.
  * In reality, there is also some differences due to the mount mechanical limitations and measurements
  * errors.
  *
  * The user is then presented with a triangle that couples the corrections required in Altitude and Azimuth
  * knobs to move the RA axis to the celestial pole. An optional feature is available the calculates the error
  * in real time as the user move the mount around during refresh, but this feature is computationally intensive
  * as we need to extract stars from each frame.
  *
  * @author Jasem Mutlaq
  * @author Hy Murveit
  */
 class PolarAlignmentAssistant : public QWidget, public Ui::PolarAlignmentAssistant
 {
         Q_OBJECT
 
     public:
         explicit PolarAlignmentAssistant(Align *parent, const QSharedPointer<AlignView> &view);
         ~PolarAlignmentAssistant();
 
         typedef enum
         {
             PAH_IDLE,
             PAH_FIRST_CAPTURE,
             PAH_FIRST_SOLVE,
             PAH_FIND_CP,
             PAH_FIRST_ROTATE,
             PAH_FIRST_SETTLE,
             PAH_SECOND_CAPTURE,
             PAH_SECOND_SOLVE,
             PAH_SECOND_ROTATE,
             PAH_SECOND_SETTLE,
             PAH_THIRD_CAPTURE,
             PAH_THIRD_SOLVE,
             PAH_STAR_SELECT,
             PAH_REFRESH,
             PAH_POST_REFRESH
         } Stage;
 
         // Algorithm choice in UI
         typedef enum
         {
             PLATE_SOLVE_ALGORITHM,
             MOVE_STAR_ALGORITHM,
             MOVE_STAR_UPDATE_ERR_ALGORITHM
         } RefreshAlgorithm;
 
         enum CircleSolution
         {
             NO_CIRCLE_SOLUTION,
             ONE_CIRCLE_SOLUTION,
             TWO_CIRCLE_SOLUTION,
             INFINITE_CIRCLE_SOLUTION
         };
         typedef enum { NORTH_HEMISPHERE, SOUTH_HEMISPHERE } HemisphereType;
 
         // Set the mount used in Align class.
         void setCurrentTelescope(ISD::Mount *scope)
         {
             m_CurrentTelescope = scope;
         }
         // Sync mount slew speed and available rates from the telescope object
         void syncMountSpeed(const QString &speed);
         // Enable PAA if the FOV is sufficient
         void setEnabled(bool enabled);
         // Return the exposure used in the refresh phase.
         double getPAHExposureDuration() const
         {
             return pAHExposure->value();
         }
         // Handle updates during the refresh phase such as error estimation.
         void processPAHRefresh();
         // Handle solver failure and retry to capture until a preset number of retries is met.
         bool processSolverFailure();
         // Handle both automated and manual mount rotations.
         void processMountRotation(const dms &ra, double settleDuration);
         // After solver is complete, handle PAH Stage processing
         void processPAHStage(double orientation, double ra, double dec, double pixscale, bool eastToTheRight, short healpix,
                              short index);
         // Return current PAH stage
         Stage getPAHStage() const
         {
             return m_PAHStage;
         }
         // Set active stage.
         void setPAHStage(Stage stage);
         // Start the polar alignment process.
         void startPAHProcess();
         // Stops the polar alignment process.
         void stopPAHProcess();
         // Process the results of WCS from the solving process. If the results are good, we continue to the next phase.
         // Otherwise, we abort the operation.
         void setWCSToggled(bool result);
         // Update GUI to reflect mount status.
         void setMountStatus(ISD::Mount::Status newState);
         // Update the correction offset by this percentage in order to move the triangle around when clicking on
         // for example.
         void setPAHCorrectionOffsetPercentage(double dx, double dy);
         // Update the PAH refresh duration
         void setPAHRefreshDuration(double value)
         {
             pAHExposure->setValue(value);
         }
         // Start the refresh process.
         void startPAHRefreshProcess();
         // This should be called when manual slewing is complete.
         void setPAHSlewDone();
         // Return current active stage label
         QString getPAHStageString(bool translated = true) const
         {
             return translated ? i18n(PAHStages[m_PAHStage]) : PAHStages[m_PAHStage];
         }
         // Return last message
         QString getPAHMessage() const;
         // Set image data from align class
         void setImageData(const QSharedPointer<FITSData> &image);
 
         void setPAHRefreshAlgorithm(RefreshAlgorithm value);
 
     protected:
         // Polar Alignment Helper slots
         void rotatePAH();
         void setPAHCorrectionOffset(int x, int y);
 
     private:
         /**
             * @brief Warns the user if the polar alignment might cross the meridian.
             */
         bool checkPAHForMeridianCrossing();
 
         /**
              * @brief calculatePAHError Calculate polar alignment error in the Polar Alignment Helper (PAH) method
              * @return True if calculation is successsful, false otherwise.
              */
         bool calculatePAHError();
 
         /**
          * @brief syncCorrectionVector Flip correction vector based on user settings.
          */
         void syncCorrectionVector();
 
         /**
          * @brief setupCorrectionGraphics Update align view correction graphics.
          * @param pixel
          */
         void setupCorrectionGraphics(const QPointF &pixel);
 
         /**
          * @brief supdateRefreshDisplay Updates the UI's refresh error stats.
          * @param azError the azimuth error in degrees
          * @param altError the altitude error in degrees
          */
         void updateRefreshDisplay(double azError, double altError);
 
     signals:
         // Report new log
         void newLog(const QString &);
         // Request new capture and solve
         void captureAndSolve();
         // Report correction vector and original errors
         void polarResultUpdated(QLineF correctionVector, double polarError, double azError, double altError);
         // Report updated errors
         void updatedErrorsChanged(double total, double az, double alt);
         // Report new correction vector
         void newCorrectionVector(QLineF correctionVector);
         // Report new PAH stage
         void newPAHStage(Stage stage);
         // Report new PAH message
         void newPAHMessage(const QString &message);
         // Report whether the tool is enabled or not
         void PAHEnabled(bool);
         // Request to set alignment table result
         void newAlignTableResult(Align::AlignResult result);
         // Report that the align view was updated.
         void newFrame(const QSharedPointer<FITSView> &view);
 
     private:
         void updateDisplay(Stage stage, const QString &message);
         void drawArrows(double altError, double azError);
         void showUpdatedError(bool show);
         // These are only used in the plate-solve refresh scheme.
         void solverDone(bool timedOut, bool success, const FITSImage::Solution &solution, double elapsedSeconds);
         void startSolver();
         void updatePlateSolveTriangle(const QSharedPointer<FITSData> &image);
 
         // Polar Alignment Helper
         Stage m_PAHStage { PAH_IDLE };
 
         SkyPoint targetPAH;
 
         // Which hemisphere are we located on?
         HemisphereType hemisphere;
 
         // Polar alignment will retry capture & solve a few times if solve fails.
         int m_PAHRetrySolveCounter { 0 };
 
         // Points on the image to correct mount's ra axis.
         // correctionFrom is the star the user selected (or center of the image at start).
         // correctionTo is where theuser should move that star.
         // correctionAltTo is where the use should move that star to only fix altitude.
         QPointF correctionFrom, correctionTo, correctionAltTo;
 
         // RA/DEC coordinates where the image center needs to be move to to correct the RA axis.
         SkyPoint refreshSolution, altOnlyRefreshSolution;
 
 
         bool detectStarsPAHRefresh(QList<Edge> *stars, int num, int x, int y, int *xyIndex);
 
         // Incremented every time sufficient # of stars are detected (for move-star refresh) or
         // when solver is successful (for plate-solve refresh).
         int refreshIteration { 0 };
         // Incremented on every image received.
         int imageNumber { 0 };
         StarCorrespondence starCorrespondencePAH;
 
         // Class used to estimate alignment error.
         PolarAlign polarAlign;
 
         // Pointer to image data
         QSharedPointer<FITSData> m_ImageData;
 
         // Reference to parent
         Align *m_AlignInstance {nullptr};
 
         // Reference to current active telescope
         ISD::Mount *m_CurrentTelescope { nullptr };
 
         // Reference to align view
         QSharedPointer<AlignView> m_AlignView;
 
         // PAH Stage Map
         static const QMap<Stage, const char *> PAHStages;
 
         // Threshold to stop PAH rotation in degrees
         static constexpr uint8_t PAH_ROTATION_THRESHOLD { 5 };
 
         PolarAlignWidget *polarAlignWidget {nullptr};
 
         // Used in the refresh part of polar alignment.
         QSharedPointer<SolverUtils> m_Solver;
         double m_LastRa {0};
         double m_LastDec {0};
         double m_LastOrientation {0};
         double m_LastPixscale {0};
 
         // Restricts (the internal solver) to using the index and healpix
         // from the previous solve, if that solve was successful.
         int m_IndexToUse { -1 };
         int m_HealpixToUse { -1 };
         int m_NumHealpixFailures { 0 };
 };
 }