Kstars

guide.h
1 /*
2  SPDX-FileCopyrightText: 2012 Jasem Mutlaq <[email protected]>
3 
4  SPDX-License-Identifier: GPL-2.0-or-later
5 */
6 
7 #pragma once
8 
9 #include "ui_guide.h"
10 #include "guideinterface.h"
11 #include "guidestatewidget.h"
12 #include "ekos/ekos.h"
13 #include "indi/indicamera.h"
14 #include "indi/indimount.h"
15 #include "ekos/auxiliary/darkprocessor.h"
16 
17 #include <QTime>
18 #include <QTimer>
19 #include <QtDBus>
20 
21 #include <random>
22 
23 class QProgressIndicator;
24 class QTabWidget;
25 
26 class FITSView;
27 class FITSViewer;
28 class ScrollGraph;
29 class GuideView;
30 
31 namespace Ekos
32 {
33 class OpsCalibration;
34 class OpsGuide;
35 class OpsDither;
36 class OpsGPG;
37 class InternalGuider;
38 class PHD2;
39 class LinGuider;
40 
41 /**
42  * @class Guide
43  * @short Performs calibration and autoguiding using an ST4 port or directly via the INDI driver. Can be used with the following external guiding applications:
44  * PHD2
45  * LinGuider
46  *
47  * @author Jasem Mutlaq
48  * @version 1.4
49  */
50 class Guide : public QWidget, public Ui::Guide
51 {
52  Q_OBJECT
53  Q_CLASSINFO("D-Bus Interface", "org.kde.kstars.Ekos.Guide")
54  Q_PROPERTY(Ekos::GuideState status READ status NOTIFY newStatus)
55  Q_PROPERTY(QStringList logText READ logText NOTIFY newLog)
56  Q_PROPERTY(QString opticalTrain READ opticalTrain WRITE setOpticalTrain)
57  Q_PROPERTY(QString camera READ camera)
58  Q_PROPERTY(QString guider READ guider)
59  Q_PROPERTY(double exposure READ exposure WRITE setExposure)
60  Q_PROPERTY(QList<double> axisDelta READ axisDelta NOTIFY newAxisDelta)
61  Q_PROPERTY(QList<double> axisSigma READ axisSigma NOTIFY newAxisSigma)
62 
63  public:
64  Guide();
65  ~Guide();
66 
67  enum GuiderStage
68  {
69  CALIBRATION_STAGE,
70  GUIDE_STAGE
71  };
72  enum GuiderType
73  {
74  GUIDE_INTERNAL,
75  GUIDE_PHD2,
76  GUIDE_LINGUIDER
77  };
78 
79  /** @defgroup GuideDBusInterface Ekos DBus Interface - Capture Module
80  * Ekos::Guide interface provides advanced scripting capabilities to calibrate and guide a mount via a CCD camera.
81  */
82 
83  /*@{*/
84 
85  /** DBUS interface function.
86  * select the CCD device from the available CCD drivers.
87  * @param device The CCD device name
88  * @return Returns true if CCD device is found and set, false otherwise.
89  */
90  Q_SCRIPTABLE QString camera();
91 
92  /** DBUS interface function.
93  * select the ST4 device from the available ST4 drivers.
94  * @param device The ST4 device name
95  * @return Returns true if ST4 device is found and set, false otherwise.
96  */
97  Q_SCRIPTABLE QString guider();
98 
99  /** DBUS interface function.
100  * @brief connectGuider Establish connection to guider application. For internal guider, this always returns true.
101  * @return True if successfully connected, false otherwise.
102  */
103  Q_SCRIPTABLE bool connectGuider();
104 
105  /** DBUS interface function.
106  * @brief disconnectGuider Disconnect from guider application. For internal guider, this always returns true.
107  * @return True if successfully disconnected, false otherwise.
108  */
109  Q_SCRIPTABLE bool disconnectGuider();
110 
111  /**
112  * @brief getStatus Return guide module status
113  * @return state of guide module from Ekos::GuideState
114  */
115  Q_SCRIPTABLE Ekos::GuideState status()
116  {
117  return m_State;
118  }
119 
120  /** DBUS interface function.
121  * Set CCD exposure value
122  * @param value exposure value in seconds.
123  */
124  Q_SCRIPTABLE Q_NOREPLY void setExposure(double value);
125  double exposure()
126  {
127  return guideExposure->value();
128  }
129 
130  /** DBUS interface function.
131  * Set calibration dark frame option. The options must be set before starting the calibration operation. If no options are set, the options loaded from the user configuration are used.
132  * @param enable if true, a dark frame will be captured to subtract from the light frame.
133  */
134  Q_SCRIPTABLE Q_NOREPLY void setDarkFrameEnabled(bool enable);
135 
136  /** @}*/
137 
138  /**
139  * @brief Add new Camera
140  * @param device pointer to camera device.
141  * @return True if added successfully, false if duplicate or failed to add.
142  */
143  bool setCamera(ISD::Camera *device);
144 
145 
146  /**
147  * @brief Add new Mount
148  * @param device pointer to Mount device.
149  * @return True if added successfully, false if duplicate or failed to add.
150  */
151  bool setMount(ISD::Mount *device);
152 
153  /**
154  * @brief Add new Guider
155  * @param device pointer to Guider device.
156  * @return True if added successfully, false if duplicate or failed to add.
157  */
158  bool setGuider(ISD::Guider *device);
159 
160  /**
161  * @brief Add new Adaptive Optics
162  * @param device pointer to AO device.
163  * @return True if added successfully, false if duplicate or failed to add.
164  */
166 
167  void removeDevice(const QSharedPointer<ISD::GenericDevice> &device);
168  void configurePHD2Camera();
169 
170  bool isDithering();
171  void syncTelescopeInfo();
172  void syncCameraInfo();
173 
174  /**
175  * @brief clearLog As the name suggests
176  */
177  void clearLog();
178  QStringList logText()
179  {
180  return m_LogText;
181  }
182 
183  /**
184  * @return Return current log text of guide module
185  */
187  {
188  return m_LogText.join("\n");
189  }
190 
191  /**
192  * @brief getStarPosition Return star center as selected by the user or auto-detected by KStars
193  * @return QVector3D of starCenter. The 3rd parameter is used to store current bin settings and in unrelated to the star position.
194  */
196  {
197  return starCenter;
198  }
199 
200  // Tracking Box
201  int getTrackingBoxSize()
202  {
203  return guideSquareSize->currentText().toInt();
204  }
205 
206  GuideInterface *getGuiderInstance()
207  {
208  return m_GuiderInstance;
209  }
210 
211  // Settings
212  QVariantMap getAllSettings() const;
213  void setAllSettings(const QVariantMap &settings);
214 
215  public slots:
216 
217  /** DBUS interface function.
218  * Start the autoguiding operation.
219  * @return Returns true if guiding started successfully, false otherwise.
220  */
221  Q_SCRIPTABLE bool guide();
222 
223  /** DBUS interface function.
224  * Stop any active calibration, guiding, or dithering operation
225  * @return Returns true if operation is stopped successfully, false otherwise.
226  */
227  Q_SCRIPTABLE bool abort();
228 
229  /** DBUS interface function.
230  * Start the calibration operation. Note that this will not start guiding automatically.
231  * @return Returns true if calibration started successfully, false otherwise.
232  */
233  Q_SCRIPTABLE bool calibrate();
234 
235  /** DBUS interface function.
236  * Clear calibration data. Next time any guide operation is performed, a calibration is first started.
237  */
238  Q_SCRIPTABLE Q_NOREPLY void clearCalibration();
239 
240  /** DBUS interface function.
241  * @brief dither Starts dithering process in a random direction restricted by the number of pixels specified in dither options
242  * @return True if dither started successfully, false otherwise.
243  */
244  Q_SCRIPTABLE bool dither();
245 
246  /** DBUS interface function.
247  * @brief suspend Suspend autoguiding
248  * @return True if successful, false otherwise.
249  */
250  Q_SCRIPTABLE bool suspend();
251 
252  /** DBUS interface function.
253  * @brief resume Resume autoguiding
254  * @return True if successful, false otherwise.
255  */
256  Q_SCRIPTABLE bool resume();
257 
258  /** DBUS interface function.
259  * Capture a guide frame
260  * @return Returns true if capture command is sent successfully to INDI server.
261  */
262  Q_SCRIPTABLE bool capture();
263 
264  /** DBUS interface function.
265  * Loop frames specified by the exposure control continuously until stopped.
266  */
267  Q_SCRIPTABLE Q_NOREPLY void loop();
268 
269  /** DBUS interface function.
270  * Set guiding options. The options must be set before starting the guiding operation. If no options are set, the options loaded from the user configuration are used.
271  * @param enable if true, it will select a subframe around the guide star depending on the boxSize size.
272  */
273  Q_SCRIPTABLE Q_NOREPLY void setSubFrameEnabled(bool enable);
274 
275  /** DBUS interface function.
276  * Set guiding options. The options must be set before starting the guiding operation. If no options are set, the options loaded from the user configuration are used.
277  * @param enable if true, it will select a subframe around the guide star depending on the boxSize size.
278  */
279  Q_SCRIPTABLE Q_NOREPLY void setAutoStarEnabled(bool enable);
280 
281  /** DBUS interface function.
282  * Selects which guiding process to utilize for calibration & guiding.
283  * @param type Type of guider process to use. 0 for internal guider, 1 for external PHD2, 2 for external lin_guider. Pass -1 to select default guider in options.
284  * @return True if guiding is switched to the new requested type. False otherwise.
285  */
286  Q_SCRIPTABLE bool setGuiderType(int type);
287 
288  /** DBUS interface function.
289  * @brief axisDelta returns the last immediate axis delta deviation in arcseconds. This is the deviation of locked star position when guiding started.
290  * @return List of doubles. First member is RA deviation. Second member is DE deviation.
291  */
292  Q_SCRIPTABLE QList<double> axisDelta();
293 
294  /** DBUS interface function.
295  * @brief axisSigma return axis sigma deviation in arcseconds RMS. This is the RMS deviation of locked star position when guiding started.
296  * @return List of doubles. First member is RA deviation. Second member is DE deviation.
297  */
298  Q_SCRIPTABLE QList<double> axisSigma();
299 
300  /**
301  * @brief checkCamera Check all CCD parameters and ensure all variables are updated to reflect the selected CCD
302  * @param ccdNum CCD index number in the CCD selection combo box
303  */
304  void checkCamera();
305 
306  /**
307  * @brief checkExposureValue This function is called by the INDI framework whenever there is a new exposure value. We use it to know if there is a problem with the exposure
308  * @param targetChip Chip for which the exposure is undergoing
309  * @param exposure numbers of seconds left in the exposure
310  * @param expState State of the exposure property
311  */
312  void checkExposureValue(ISD::CameraChip *targetChip, double exposure, IPState expState);
313 
314  /**
315  * @brief newFITS is called by the INDI framework whenever there is a new BLOB arriving
316  */
317  void processData(const QSharedPointer<FITSData> &data);
318 
319  // This Function will allow PHD2 to update the exposure values to the recommended ones.
320  QString setRecommendedExposureValues(QList<double> values);
321 
322  // Append Log entry
323  void appendLogText(const QString &);
324 
325  // Update Guide module status
326  void setStatus(Ekos::GuideState newState);
327 
328  // Update Capture Module status
329  void setCaptureStatus(Ekos::CaptureState newState);
330  // Update Mount module status
331  void setMountStatus(ISD::Mount::Status newState);
332  void setMountCoords(const SkyPoint &position, ISD::Mount::PierSide pierSide, const dms &ha);
333 
334  // Update Pier Side
335  void setPierSide(ISD::Mount::PierSide newSide);
336 
337  // Star Position
338  void setStarPosition(const QVector3D &newCenter, bool updateNow);
339 
340  // Capture
341  void setCaptureComplete();
342 
343  // Pulse both RA and DEC axes
344  bool sendMultiPulse(GuideDirection ra_dir, int ra_msecs, GuideDirection dec_dir, int dec_msecs, CaptureAfterPulses followWithCapture);
345  // Pulse for one of the mount axes
346  bool sendSinglePulse(GuideDirection dir, int msecs, CaptureAfterPulses followWithCapture);
347 
348  /**
349  * @brief setDECSwap Change ST4 declination pulse direction. +DEC pulses increase DEC if swap is OFF. When on +DEC pulses result in decreasing DEC.
350  * @param enable True to enable DEC swap. Off to disable it.
351  */
352  void setDECSwap(bool enable);
353 
354 
355  /**
356  * @brief updateSetting Update per-train and global setting
357  * @param key Name of setting
358  * @param value Value
359  * @note per-train and global settings are updated. Changes are saved to database
360  * and to disk immediately.
361  */
362  void updateSetting(const QString &key, const QVariant &value);
363 
364  //plot slots
365  void handleVerticalPlotSizeChange();
366  void handleHorizontalPlotSizeChange();
367  void clearGuideGraphs();
368  void clearCalibrationGraphs();
369  void slotAutoScaleGraphs();
370  void buildTarget();
371  void guideHistory();
372  void setLatestGuidePoint(bool isChecked);
373 
374  void updateDirectionsFromPHD2(const QString &mode);
375 
376  void guideAfterMeridianFlip();
377 
378  // Trains
379  QString opticalTrain() const
380  {
381  return opticalTrainCombo->currentText();
382  }
383  void setOpticalTrain(const QString &value)
384  {
385  opticalTrainCombo->setCurrentText(value);
386  }
387 
388  protected slots:
389  void updateCCDBin(int index);
390 
391  /**
392  * @brief processCCDNumber Process number properties arriving from CCD. Currently, binning changes are processed.
393  * @param nvp pointer to number property.
394  */
395  void updateProperty(INDI::Property prop);
396 
397  /**
398  * @brief setTrackingStar Gets called when the user select a star in the guide frame
399  * @param x X coordinate of star
400  * @param y Y coordinate of star
401  */
402  void setTrackingStar(int x, int y);
403 
404  void saveDefaultGuideExposure();
405 
406  void updateTrackingBoxSize(int currentIndex);
407 
408  //void onXscaleChanged( int i );
409  //void onYscaleChanged( int i );
410  void onThresholdChanged(int i);
411  void onEnableDirRA();
412  void onEnableDirDEC();
413 
414  void setAxisDelta(double ra, double de);
415  void setAxisSigma(double ra, double de);
416  void setAxisPulse(double ra, double de);
417  void setSNR(double snr);
418  void calibrationUpdate(GuideInterface::CalibrationUpdateType type, const QString &message = QString(""), double dx = 0,
419  double dy = 0);
420 
421  void guideInfo(const QString &info);
422 
423  void processGuideOptions();
424  void configSEPMultistarOptions();
425 
426  void onControlDirectionChanged();
427 
428  void showFITSViewer();
429 
430  void processCaptureTimeout();
431 
432  void nonGuidedDither();
433 
434  signals:
435  void newLog(const QString &text);
436  void newStatus(Ekos::GuideState status);
437 
438  void newImage(const QSharedPointer<FITSView> &view);
439  void newStarPixmap(QPixmap &);
440 
441  void trainChanged();
442 
443  // Immediate deviations in arcsecs
444  void newAxisDelta(double ra, double de);
445  // Sigma deviations in arcsecs RMS
446  void newAxisSigma(double ra, double de);
447 
448  void guideStats(double raError, double decError, int raPulse, int decPulse,
449  double snr, double skyBg, int numStars);
450 
451  void guideChipUpdated(ISD::CameraChip *);
452  void settingsUpdated(const QVariantMap &settings);
453  void driverTimedout(const QString &deviceName);
454 
455  private:
456 
457  void resizeEvent(QResizeEvent *event) override;
458 
459  /**
460  * @brief updateGuideParams Update the guider and frame parameters due to any changes in the mount and/or ccd frame
461  */
462  void updateGuideParams();
463 
464  /**
465  * @brief check if the guiding chip of the camera should be used (if present)
466  */
467  void checkUseGuideHead();
468 
469  /**
470  * @brief syncTrackingBoxPosition Sync the tracking box to the current selected star center
471  */
472  void syncTrackingBoxPosition();
473 
474  /**
475  * @brief setBusy Indicate busy status within the module visually
476  * @param enable True if module is busy, false otherwise
477  */
478  void setBusy(bool enable);
479 
480  /**
481  * @brief setBLOBEnabled Enable or disable BLOB reception from current CCD if using external guider
482  * @param enable True to enable BLOB reception, false to disable BLOB reception
483  * @param name CCD to enable to disable. If empty (default), then action is applied to all CCDs.
484  */
485  void setExternalGuiderBLOBEnabled(bool enable);
486 
487  /**
488  * @brief prepareCapture Set common settings for capture for guide module
489  * @param targetChip target Chip
490  */
491  void prepareCapture(ISD::CameraChip *targetChip);
492 
493 
494  void handleManualDither();
495 
496  ////////////////////////////////////////////////////////////////////
497  /// Settings
498  ////////////////////////////////////////////////////////////////////
499 
500  /**
501  * @brief Connect GUI elements to sync settings once updated.
502  */
503  void connectSettings();
504  /**
505  * @brief Stop updating settings when GUI elements are updated.
506  */
507  void disconnectSettings();
508  /**
509  * @brief loadSettings Load setting from Options and set them accordingly.
510  */
511  void loadGlobalSettings();
512 
513  /**
514  * @brief syncSettings When checkboxes, comboboxes, or spin boxes are updated, save their values in the
515  * global and per-train settings.
516  */
517  void syncSettings();
518 
519  /**
520  * @brief syncControl Sync setting to widget. The value depends on the widget type.
521  * @param settings Map of all settings
522  * @param key name of widget to sync
523  * @param widget pointer of widget to set
524  * @return True if sync successful, false otherwise
525  */
526  bool syncControl(const QVariantMap &settings, const QString &key, QWidget * widget);
527 
528  // Operation stack
529  void buildOperationStack(GuideState operation);
530  bool executeOperationStack();
531  bool executeOneOperation(GuideState operation);
532 
533  // Init Functions
534  void initPlots();
535  void initDriftGraph();
536  void initCalibrationPlot();
537  void initView();
538  void initConnections();
539 
540  bool captureOneFrame();
541 
542  void setupOpticalTrainManager();
543  void refreshOpticalTrain();
544 
545  // Driver
546  void reconnectDriver(const QString &camera, QVariantMap settings);
547 
548  // Operation Stack
549  QStack<GuideState> operationStack;
550 
551  // Devices
552  ISD::Camera *m_Camera { nullptr };
553  ISD::Mount *m_Mount { nullptr };
554  ISD::Guider *m_Guider { nullptr };
555  ISD::AdaptiveOptics *m_AO { nullptr };
556 
557  // Guider process
558  GuideInterface *m_GuiderInstance { nullptr };
559 
560  //This is for the configure PHD2 camera method.
561  QString lastPHD2CameraName;
562  GuiderType guiderType { GUIDE_INTERNAL };
563 
564  // Star
565  QVector3D starCenter;
566 
567  // Guide Params
568  int guideBinIndex { 0 }; // Selected or saved binning for guiding
569  double ccdPixelSizeX { -1 };
570  double ccdPixelSizeY { -1 };
571 
572  // Scope info
573  double m_Aperture { -1 };
574  double m_FocalLength { -1 };
575  double m_FocalRatio { -1 };
576  double m_Reducer {-1};
577 
578  double guideDeviationRA { 0 };
579  double guideDeviationDEC { 0 };
580  double pixScaleX { -1 };
581  double pixScaleY { -1 };
582 
583  // State
584  GuideState m_State { GUIDE_IDLE };
585  GuideStateWidget *guideStateWidget { nullptr };
586 
587  // Guide timer
588  QElapsedTimer guideTimer;
589 
590  // Capture timeout timer
591  QTimer captureTimeout;
592  uint8_t m_CaptureTimeoutCounter { 0 };
593  uint8_t m_DeviceRestartCounter { 0 };
594 
595  // Pulse Timer
596  QTimer m_PulseTimer;
597 
598  // Log
599  QStringList m_LogText;
600 
601  // Misc
602  bool useGuideHead { false };
603 
604  // Progress Activity Indicator
605  QProgressIndicator *pi { nullptr };
606 
607  // Options
608  OpsCalibration *opsCalibration { nullptr };
609  OpsGuide *opsGuide { nullptr };
610  OpsDither *opsDither { nullptr };
611  OpsGPG *opsGPG { nullptr };
612 
613  // Guide Frame
614  QSharedPointer<GuideView> m_GuideView;
615 
616  // Calibration done already?
617  bool calibrationComplete { false };
618 
619  // Was the modified frame subFramed?
620  bool subFramed { false };
621 
622  // CCD Chip frame settings
624 
625  // Profile Pixmap
626  QPixmap profilePixmap;
627  // drift plot
628  QPixmap driftPlotPixmap;
629 
630  // Flag to start auto calibration followed immediately by guiding
631  //bool autoCalibrateGuide { false };
632 
633  // Pointers of guider processes
634  QPointer<InternalGuider> internalGuider;
635  QPointer<PHD2> phd2Guider;
636  QPointer<LinGuider> linGuider;
638  QSharedPointer<FITSData> m_ImageData;
639 
640  // Dark Processor
641  QPointer<DarkProcessor> m_DarkProcessor;
642 
643  double primaryFL = -1, primaryAperture = -1, guideFL = -1, guideAperture = -1;
644  ISD::Mount::Status m_MountStatus { ISD::Mount::MOUNT_IDLE };
645 
646  bool graphOnLatestPt = true;
647 
648  //This is for enforcing the PHD2 Star lock when Guide is pressed,
649  //autostar is not selected, and the user has chosen a star.
650  //This connection storage is so that the connection can be disconnected after enforcement
651  QMetaObject::Connection guideConnect;
652 
653  QCPItemText *calLabel { nullptr };
654 
655  // The scales of these zoom levels are defined in Guide::zoomX().
656  static constexpr int defaultXZoomLevel = 3;
657  int driftGraphZoomLevel {defaultXZoomLevel};
658 
659 
660  // The accumulated non-guided dither offsets (in milliseconds) in the RA and DEC directions.
661  int nonGuidedDitherRaOffsetMsec = 0, nonGuidedDitherDecOffsetMsec = 0;
662 
663  // Random generator for non guided dithering
664  std::mt19937 nonGuidedPulseGenerator;
665 
666  // Flag to check if random generator for non guided dithering is initialized.
667  bool isNonGuidedDitherInitialized = false;
668 
669  // Reset non guided dithering properties and initialize the random generator seed if not already done.
670  // Should be called in Guide::Guide() for initial seed initialization, and then in setCaptureStatus to reset accumulated drift
671  // every time a capture task is completed or aborted.
672  void resetNonGuidedDither();
673 
674  QVariantMap m_Settings;
675  QVariantMap m_GlobalSettings;
676 };
677 }
Q_OBJECTQ_OBJECT
void checkCamera()
checkCamera Check all CCD parameters and ensure all variables are updated to reflect the selected CCD
Definition: guide.cpp:443
Q_SCRIPTABLE bool suspend()
DBUS interface function.
Definition: guide.cpp:1306
Q_PROPERTY(...)
Q_SCRIPTABLE bool connectGuider()
DBUS interface function.
Definition: guide.cpp:2589
void processData(const QSharedPointer< FITSData > &data)
newFITS is called by the INDI framework whenever there is a new BLOB arriving
Definition: guide.cpp:961
Q_SCRIPTABLE Q_NOREPLY void setAutoStarEnabled(bool enable)
DBUS interface function.
Definition: guide.cpp:1445
Q_SCRIPTABLE bool setGuiderType(int type)
DBUS interface function.
Definition: guide.cpp:1773
Q_SCRIPTABLE Q_NOREPLY void setDarkFrameEnabled(bool enable)
DBUS interface function.
Definition: guide.cpp:1688
Ekos is an advanced Astrophotography tool for Linux. It is based on a modular extensible framework to...
Definition: align.cpp:69
Stores dms coordinates for a point in the sky. for converting between coordinate systems.
Definition: skypoint.h:44
Q_CLASSINFO(Name, Value)
virtual bool event(QEvent *event) override
void setTrackingStar(int x, int y)
setTrackingStar Gets called when the user select a star in the guide frame
Definition: guide.cpp:2039
Q_SCRIPTABLE bool resume()
DBUS interface function.
Definition: guide.cpp:1316
bool setAdaptiveOptics(ISD::AdaptiveOptics *device)
Add new Adaptive Optics.
Definition: guide.cpp:696
Q_SCRIPTABLE bool dither()
DBUS interface function.
Definition: guide.cpp:1270
void updateSetting(const QString &key, const QVariant &value)
updateSetting Update per-train and global setting
Definition: guide.cpp:3238
Q_SCRIPTABLE Ekos::GuideState status()
getStatus Return guide module status
Definition: guide.h:115
The QProgressIndicator class lets an application display a progress indicator to show that a long tas...
Q_SCRIPTABLE bool disconnectGuider()
DBUS interface function.
Definition: guide.cpp:2595
Q_SCRIPTABLE Q_NOREPLY void loop()
DBUS interface function.
Definition: guide.cpp:2895
void checkExposureValue(ISD::CameraChip *targetChip, double exposure, IPState expState)
checkExposureValue This function is called by the INDI framework whenever there is a new exposure val...
Definition: guide.cpp:1646
Q_SCRIPTABLE bool capture()
DBUS interface function.
Definition: guide.cpp:717
Performs calibration and autoguiding using an ST4 port or directly via the INDI driver....
Definition: guide.h:50
void updateProperty(INDI::Property prop)
processCCDNumber Process number properties arriving from CCD.
Definition: guide.cpp:1623
Primary window to view monochrome and color FITS images. The FITSviewer can open multiple images each...
Definition: fitsviewer.h:48
CaptureState
Capture states.
Definition: ekos.h:91
A text label.
Definition: qcustomplot.h:6567
Q_SCRIPTABLE bool calibrate()
DBUS interface function.
Definition: guide.cpp:1170
QString join(const QString &separator) const const
Q_SCRIPTABLE Q_NOREPLY void clearCalibration()
DBUS interface function.
Definition: guide.cpp:1451
An angle, stored as degrees, but expressible in many ways.
Definition: dms.h:37
void clearLog()
clearLog As the name suggests
Definition: guide.cpp:1116
bool setCamera(ISD::Camera *device)
Add new Camera.
Definition: guide.cpp:308
QString getLogText()
Definition: guide.h:186
void setDECSwap(bool enable)
setDECSwap Change ST4 declination pulse direction.
Definition: guide.cpp:1122
Q_SCRIPTABLE Q_NOREPLY void setExposure(double value)
DBUS interface function.
Definition: guide.cpp:1432
bool setGuider(ISD::Guider *device)
Add new Guider.
Definition: guide.cpp:670
bool setMount(ISD::Mount *device)
Add new Mount.
Definition: guide.cpp:419
The main change relative to fitsview is to add the capability of displaying the 'neighbor guide stars...
Definition: guideview.h:21
Q_SCRIPTABLE bool guide()
DBUS interface function.
Definition: guide.cpp:1216
QString message
QVector3D getStarPosition()
getStarPosition Return star center as selected by the user or auto-detected by KStars
Definition: guide.h:195
Q_SCRIPTABLE bool abort()
DBUS interface function.
Definition: guide.cpp:786
Q_SCRIPTABLE Q_NOREPLY void setSubFrameEnabled(bool enable)
DBUS interface function.
Definition: guide.cpp:1437
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Wed Mar 22 2023 04:02:02 by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.