Kstars

guide.h
1/*
2 SPDX-FileCopyrightText: 2012 Jasem Mutlaq <mutlaqja@ikarustech.com>
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 "ekos/ekos.h"
12#include "indi/indicamera.h"
13#include "indi/indimount.h"
14
15#include <QTime>
16#include <QTimer>
17
18#include <random>
19
21class QTabWidget;
22
23class FITSView;
24class FITSViewer;
25class ScrollGraph;
26class GuideView;
27
28namespace Ekos
29{
30class OpsCalibration;
31class OpsGuide;
32class OpsDither;
33class OpsGPG;
34class InternalGuider;
35class PHD2;
36class LinGuider;
37class GuideStateWidget;
38class ManualPulse;
39class DarkProcessor;
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 */
50class Guide : public QWidget, public Ui::Guide
51{
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 Q_SCRIPTABLE 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 /**
247 * @brief Reset non guided dithering properties and initialize the random generator seed if not already done.
248 * Should be called in Guide::Guide() for initial seed initialization, and then every time to reset accumulated drift
249 * every time a capture task is completed or aborted.
250 */
252
253 /** DBUS interface function.
254 * @brief suspend Suspend autoguiding
255 * @return True if successful, false otherwise.
256 */
257 Q_SCRIPTABLE bool suspend();
258
259 /** DBUS interface function.
260 * @brief resume Resume autoguiding
261 * @return True if successful, false otherwise.
262 */
263 Q_SCRIPTABLE bool resume();
264
265 /** DBUS interface function.
266 * Capture a guide frame
267 * @return Returns true if capture command is sent successfully to INDI server.
268 */
269 Q_SCRIPTABLE bool capture();
270
271 /** DBUS interface function.
272 * Loop frames specified by the exposure control continuously until stopped.
273 */
274 Q_SCRIPTABLE Q_NOREPLY void loop();
275
276 /** DBUS interface function.
277 * 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.
278 * @param enable if true, it will select a subframe around the guide star depending on the boxSize size.
279 */
280 Q_SCRIPTABLE Q_NOREPLY void setSubFrameEnabled(bool enable);
281
282 /** DBUS interface function.
283 * 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.
284 * @param enable if true, it will select a subframe around the guide star depending on the boxSize size.
285 */
286 Q_SCRIPTABLE Q_NOREPLY void setAutoStarEnabled(bool enable);
287
288 /** DBUS interface function.
289 * Selects which guiding process to utilize for calibration & guiding.
290 * @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.
291 * @return True if guiding is switched to the new requested type. False otherwise.
292 */
293 Q_SCRIPTABLE bool setGuiderType(int type);
294
295 /** DBUS interface function.
296 * @brief axisDelta returns the last immediate axis delta deviation in arcseconds. This is the deviation of locked star position when guiding started.
297 * @return List of doubles. First member is RA deviation. Second member is DE deviation.
298 */
299 Q_SCRIPTABLE QList<double> axisDelta();
300
301 /** DBUS interface function.
302 * @brief axisSigma return axis sigma deviation in arcseconds RMS. This is the RMS deviation of locked star position when guiding started.
303 * @return List of doubles. First member is RA deviation. Second member is DE deviation.
304 */
305 Q_SCRIPTABLE QList<double> axisSigma();
306
307 /**
308 * @brief checkCamera Check all CCD parameters and ensure all variables are updated to reflect the selected CCD
309 * @param ccdNum CCD index number in the CCD selection combo box
310 */
311 void checkCamera();
312
313 /**
314 * @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
315 * @param targetChip Chip for which the exposure is undergoing
316 * @param exposure numbers of seconds left in the exposure
317 * @param expState State of the exposure property
318 */
319 void checkExposureValue(ISD::CameraChip *targetChip, double exposure, IPState expState);
320
321 /**
322 * @brief newFITS is called by the INDI framework whenever there is a new BLOB arriving
323 */
324 void processData(const QSharedPointer<FITSData> &data);
325
326 // Aborts the current exposure, if one is ongoing.
327 void abortExposure();
328
329 // This Function will allow PHD2 to update the exposure values to the recommended ones.
330 QString setRecommendedExposureValues(QList<double> values);
331
332 // Append Log entry
333 void appendLogText(const QString &);
334
335 // Update Guide module status
336 void setStatus(Ekos::GuideState newState);
337
338 // Update Capture Module status
339 void setCaptureStatus(Ekos::CaptureState newState);
340 // Update Mount module status
341 void setMountStatus(ISD::Mount::Status newState);
342 void setMountCoords(const SkyPoint &position, ISD::Mount::PierSide pierSide, const dms &ha);
343
344 // Update Pier Side
345 void setPierSide(ISD::Mount::PierSide newSide);
346
347 // Star Position
348 void setStarPosition(const QVector3D &newCenter, bool updateNow);
349
350 // Capture
351 void setCaptureComplete();
352
353 // Pulse both RA and DEC axes
354 bool sendMultiPulse(GuideDirection ra_dir, int ra_msecs, GuideDirection dec_dir, int dec_msecs, CaptureAfterPulses followWithCapture);
355 // Pulse for one of the mount axes
356 bool sendSinglePulse(GuideDirection dir, int msecs, CaptureAfterPulses followWithCapture);
357
358 /**
359 * @brief setDECSwap Change ST4 declination pulse direction. +DEC pulses increase DEC if swap is OFF. When on +DEC pulses result in decreasing DEC.
360 * @param enable True to enable DEC swap. Off to disable it.
361 */
362 void setDECSwap(bool enable);
363
364
365 /**
366 * @brief updateSetting Update per-train and global setting
367 * @param key Name of setting
368 * @param value Value
369 * @note per-train and global settings are updated. Changes are saved to database
370 * and to disk immediately.
371 */
372 void updateSetting(const QString &key, const QVariant &value);
373
374 //plot slots
375 void handleVerticalPlotSizeChange();
376 void handleHorizontalPlotSizeChange();
377 void clearGuideGraphs();
378 void clearCalibrationGraphs();
379 void slotAutoScaleGraphs();
380 void buildTarget();
381 void guideHistory();
382 void setLatestGuidePoint(bool isChecked);
383
384 void updateDirectionsFromPHD2(const QString &mode);
385
386 void guideAfterMeridianFlip();
387
388 // Trains
389 QString opticalTrain() const
390 {
391 return opticalTrainCombo->currentText();
392 }
393 void setOpticalTrain(const QString &value)
394 {
395 opticalTrainCombo->setCurrentText(value);
396 }
397
398 protected slots:
399 void updateCCDBin(int index);
400
401 /**
402 * @brief processCCDNumber Process number properties arriving from CCD. Currently, binning changes are processed.
403 * @param nvp pointer to number property.
404 */
405 void updateProperty(INDI::Property prop);
406
407 /**
408 * @brief setTrackingStar Gets called when the user select a star in the guide frame
409 * @param x X coordinate of star
410 * @param y Y coordinate of star
411 */
412 void setTrackingStar(int x, int y);
413
414 void saveDefaultGuideExposure();
415
416 void updateTrackingBoxSize(int currentIndex);
417
418 //void onXscaleChanged( int i );
419 //void onYscaleChanged( int i );
420 void onSettingsUpdated(int starDetectionIndex);
421 void onEnableDirRA();
422 void onEnableDirDEC();
423
424 void setAxisDelta(double ra, double de);
425 void setAxisSigma(double ra, double de);
426 void setAxisPulse(double ra, double de);
427 void setSNR(double snr);
428 void calibrationUpdate(GuideInterface::CalibrationUpdateType type, const QString &message = QString(""), double dx = 0,
429 double dy = 0);
430
431 void guideInfo(const QString &info);
432
433 void processGuideOptions();
434 void configSEPMultistarOptions();
435
436 void onControlDirectionChanged();
437
438 void showFITSViewer();
439
440 void displayGuideView(bool enabled);
441
442 void processCaptureTimeout();
443
444 void nonGuidedDither();
445
446 signals:
447 void newLog(const QString &text);
448 void newStatus(Ekos::GuideState status);
449
450 void newImage(const QSharedPointer<FITSView> &view);
451 void newStarPixmap(QPixmap &);
452
453 void trainChanged();
454
455 // Immediate deviations in arcsecs
456 void newAxisDelta(double ra, double de);
457 // Sigma deviations in arcsecs RMS
458 void newAxisSigma(double ra, double de);
459
460 void guideStats(double raError, double decError, int raPulse, int decPulse,
461 double snr, double skyBg, int numStars);
462
463 void guideChipUpdated(ISD::CameraChip *);
464 void settingsUpdated(const QVariantMap &settings);
465 void driverTimedout(const QString &deviceName);
466
467 private:
468
469 void resizeEvent(QResizeEvent *event) override;
470
471 /**
472 * @brief updateGuideParams Update the guider and frame parameters due to any changes in the mount and/or ccd frame
473 */
474 void updateGuideParams();
475
476 /**
477 * @brief check if the guiding chip of the camera should be used (if present)
478 */
479 void checkUseGuideHead();
480
481 /**
482 * @brief syncTrackingBoxPosition Sync the tracking box to the current selected star center
483 */
484 void syncTrackingBoxPosition();
485
486 /**
487 * @brief setBusy Indicate whether guiding id running or not to disable buttons which should not be
488 * accessible while guiding is running.
489 * @param enable True if guiding is running, false otherwise
490 */
491 void setBusy(bool enable);
492
493 /**
494 * @brief isGuiderActive Indicate if the guider is active (i.e. calibrating, guiding, dithering, ...)
495 */
496 static bool isGuiderActive(const GuideState state) {
497 return state == GUIDE_CAPTURE ||
498 state == GUIDE_LOOPING ||
499 state == GUIDE_DARK ||
500 state == GUIDE_SUBFRAME ||
501 state == GUIDE_STAR_SELECT ||
502 state == GUIDE_CALIBRATING ||
503 state == GUIDE_GUIDING ||
504 state == GUIDE_SUSPENDED ||
505 state == GUIDE_REACQUIRE ||
506 state == GUIDE_DITHERING ||
507 state == GUIDE_MANUAL_DITHERING ||
508 state == GUIDE_DITHERING_SETTLE;
509 }
510
511 /**
512 * @brief setBLOBEnabled Enable or disable BLOB reception from current CCD if using external guider
513 * @param enable True to enable BLOB reception, false to disable BLOB reception
514 * @param name CCD to enable to disable. If empty (default), then action is applied to all CCDs.
515 */
516 void setExternalGuiderBLOBEnabled(bool enable);
517
518 /**
519 * @brief prepareCapture Set common settings for capture for guide module
520 * @param targetChip target Chip
521 */
522 void prepareCapture(ISD::CameraChip *targetChip);
523
524
525 void handleManualDither();
526
527 ////////////////////////////////////////////////////////////////////
528 /// Settings
529 ////////////////////////////////////////////////////////////////////
530
531 /**
532 * @brief Connect GUI elements to sync settings once updated.
533 */
534 void connectSettings();
535 /**
536 * @brief Stop updating settings when GUI elements are updated.
537 */
538 void disconnectSettings();
539 /**
540 * @brief loadSettings Load setting from Options and set them accordingly.
541 */
542 void loadGlobalSettings();
543
544 /**
545 * @brief syncSettings When checkboxes, comboboxes, or spin boxes are updated, save their values in the
546 * global and per-train settings.
547 */
548 void syncSettings();
549
550 /**
551 * @brief syncControl Sync setting to widget. The value depends on the widget type.
552 * @param settings Map of all settings
553 * @param key name of widget to sync
554 * @param widget pointer of widget to set
555 * @return True if sync successful, false otherwise
556 */
557 bool syncControl(const QVariantMap &settings, const QString &key, QWidget * widget);
558
559 /**
560 * @brief settleSettings Run this function after timeout from debounce timer to update database
561 * and emit settingsChanged signal. This is required so we don't overload output.
562 */
563 void settleSettings();
564
565 // Operation stack
566 void buildOperationStack(GuideState operation);
567 bool executeOperationStack();
568 bool executeOneOperation(GuideState operation);
569
570 // Init Functions
571 void initPlots();
572 void initDriftGraph();
573 void initCalibrationPlot();
574 void initView();
575 void initConnections();
576
577 bool captureOneFrame();
578
579 void setupOpticalTrainManager();
580 void refreshOpticalTrain();
581
582 // Driver
583 void reconnectDriver(const QString &camera, QVariantMap settings);
584
585 // Calibration plot of RA- and DEC-axis
586 void drawRADECAxis(QCPItemText *Label, QCPItemLine *Arrow, const double dx, const double dy);
587
588
589 // Operation Stack
590 QStack<GuideState> operationStack;
591
592 // Devices
593 ISD::Camera *m_Camera { nullptr };
594 ISD::Mount *m_Mount { nullptr };
595 ISD::Guider *m_Guider { nullptr };
596 ISD::AdaptiveOptics *m_AO { nullptr };
597
598 // Guider process
599 GuideInterface *m_GuiderInstance { nullptr };
600
601 //This is for the configure PHD2 camera method.
602 QString m_LastPHD2CameraName, m_LastPHD2MountName;
603 GuiderType guiderType { GUIDE_INTERNAL };
604
605 // Star
606 QVector3D starCenter;
607
608 // Guide Params
609 int guideBinIndex { 0 }; // Selected or saved binning for guiding
610 double ccdPixelSizeX { -1 };
611 double ccdPixelSizeY { -1 };
612
613 // Scope info
614 double m_Aperture { -1 };
615 double m_FocalLength { -1 };
616 double m_FocalRatio { -1 };
617 double m_Reducer {-1};
618
619 double guideDeviationRA { 0 };
620 double guideDeviationDEC { 0 };
621 double pixScaleX { -1 };
622 double pixScaleY { -1 };
623
624 // State
625 GuideState m_State { GUIDE_IDLE };
626 GuideStateWidget *guideStateWidget { nullptr };
627
628 // Guide timer
629 QElapsedTimer guideTimer;
630
631 // Debounce Timer
632 QTimer m_DebounceTimer;
633
634 // Capture timeout timer
635 QTimer captureTimeout;
636 uint8_t m_CaptureTimeoutCounter { 0 };
637 uint8_t m_DeviceRestartCounter { 0 };
638
639 // Pulse Timer
640 QTimer m_PulseTimer;
641
642 // Log
643 QStringList m_LogText;
644
645 // Misc
646 bool useGuideHead { false };
647
648 // Progress Activity Indicator
649 QProgressIndicator *m_ProgressIndicator { nullptr };
650
651 // Options
652 OpsCalibration *opsCalibration { nullptr };
653 OpsGuide *opsGuide { nullptr };
654 OpsDither *opsDither { nullptr };
655 OpsGPG *opsGPG { nullptr };
656
657 // Guide Frame
658 QSharedPointer<GuideView> m_GuideView;
659
660 // Calibration done already?
661 bool calibrationComplete { false };
662
663 // Was the modified frame subFramed?
664 bool subFramed { false };
665
666 // Controls
667 double guideGainSpecialValue {INVALID_VALUE};
668 double TargetCustomGainValue {-1};
669
670 // CCD Chip frame settings
671 QMap<ISD::CameraChip *, QVariantMap> frameSettings;
672
673 // Profile Pixmap
674 QPixmap profilePixmap;
675 // drift plot
676 QPixmap driftPlotPixmap;
677
678 // Flag to start auto calibration followed immediately by guiding
679 //bool autoCalibrateGuide { false };
680
681 // Pointers of guider processes
682 QPointer<InternalGuider> internalGuider;
683 QPointer<PHD2> phd2Guider;
684 QPointer<LinGuider> linGuider;
685 QSharedPointer<FITSViewer> fv;
686 QSharedPointer<FITSData> m_ImageData;
687
688 // Dark Processor
689 QPointer<DarkProcessor> m_DarkProcessor;
690
691 // Manual Pulse Dialog
692 QPointer<ManualPulse> m_ManaulPulse;
693
694 double primaryFL = -1, primaryAperture = -1, guideFL = -1, guideAperture = -1;
695 ISD::Mount::Status m_MountStatus { ISD::Mount::MOUNT_IDLE };
696
697 bool graphOnLatestPt = true;
698
699 //This is for enforcing the PHD2 Star lock when Guide is pressed,
700 //autostar is not selected, and the user has chosen a star.
701 //This connection storage is so that the connection can be disconnected after enforcement
702 QMetaObject::Connection guideConnect;
703
704 // Some layer items
705 QCPItemText *calLabel { nullptr }; // Title
706 QCPItemText *calRALabel { nullptr }; // RA axis ...
707 QCPItemLine *calRAArrow { nullptr }; // ... with direction
708 QCPItemText *calDECLabel { nullptr }; // DEC axis ...
709 QCPItemLine *calDECArrow { nullptr }; // ... with direction
710 double calDecArrowStartX { 0 };
711 double calDecArrowStartY { 0 };
712
713
714 // The scales of these zoom levels are defined in Guide::zoomX().
715 static constexpr int defaultXZoomLevel = 3;
716 int driftGraphZoomLevel {defaultXZoomLevel};
717
718
719 // The accumulated non-guided dither offsets (in milliseconds) in the RA and DEC directions.
720 int nonGuidedDitherRaOffsetMsec = 0, nonGuidedDitherDecOffsetMsec = 0;
721
722 // Random generator for non guided dithering
723 std::mt19937 nonGuidedPulseGenerator;
724
725 // Flag to check if random generator for non guided dithering is initialized.
726 bool isNonGuidedDitherInitialized = false;
727
728 QVariantMap m_Settings;
729 QVariantMap m_GlobalSettings;
730};
731}
The DarkProcessor class.
Q_SCRIPTABLE bool connectGuider()
DBUS interface function.
Definition guide.cpp:2788
bool setMount(ISD::Mount *device)
Add new Mount.
Definition guide.cpp:443
Q_SCRIPTABLE bool calibrate()
DBUS interface function.
Definition guide.cpp:1303
void updateProperty(INDI::Property prop)
processCCDNumber Process number properties arriving from CCD.
Definition guide.cpp:1778
Q_SCRIPTABLE Q_NOREPLY void setAutoStarEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1588
Q_SCRIPTABLE QString camera()
DBUS interface function.
Q_SCRIPTABLE Q_NOREPLY void setDarkFrameEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1843
void processData(const QSharedPointer< FITSData > &data)
newFITS is called by the INDI framework whenever there is a new BLOB arriving
Definition guide.cpp:1091
Q_SCRIPTABLE QList< double > axisDelta()
DBUS interface function.
Q_SCRIPTABLE bool resume()
DBUS interface function.
Definition guide.cpp:1455
QVector3D getStarPosition()
getStarPosition Return star center as selected by the user or auto-detected by KStars
Definition guide.h:195
void setTrackingStar(int x, int y)
setTrackingStar Gets called when the user select a star in the guide frame
Definition guide.cpp:2200
Q_SCRIPTABLE bool setGuiderType(int type)
DBUS interface function.
Definition guide.cpp:1928
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:1801
Q_SCRIPTABLE Ekos::GuideState status()
getStatus Return guide module status
Definition guide.h:115
void updateSetting(const QString &key, const QVariant &value)
updateSetting Update per-train and global setting
Definition guide.cpp:3528
bool setGuider(ISD::Guider *device)
Add new Guider.
Definition guide.cpp:728
Q_SCRIPTABLE bool suspend()
DBUS interface function.
Definition guide.cpp:1445
Q_SCRIPTABLE bool dither()
DBUS interface function.
Definition guide.cpp:1409
void resetNonGuidedDither()
Reset non guided dithering properties and initialize the random generator seed if not already done.
Definition guide.cpp:2683
Q_SCRIPTABLE QString guider()
DBUS interface function.
Q_SCRIPTABLE QList< double > axisSigma()
DBUS interface function.
Q_SCRIPTABLE Q_NOREPLY void setExposure(double value)
DBUS interface function.
Definition guide.cpp:1575
Q_SCRIPTABLE Q_NOREPLY void setSubFrameEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1580
void checkCamera()
checkCamera Check all CCD parameters and ensure all variables are updated to reflect the selected CCD
Definition guide.cpp:467
Q_SCRIPTABLE bool capture()
DBUS interface function.
Definition guide.cpp:775
QString getLogText()
Definition guide.h:186
Q_SCRIPTABLE Q_NOREPLY void clearCalibration()
DBUS interface function.
Definition guide.cpp:1594
Q_SCRIPTABLE bool abort()
DBUS interface function.
Definition guide.cpp:894
Q_SCRIPTABLE bool disconnectGuider()
DBUS interface function.
Definition guide.cpp:2794
bool setAdaptiveOptics(ISD::AdaptiveOptics *device)
Add new Adaptive Optics.
Definition guide.cpp:754
void setDECSwap(bool enable)
setDECSwap Change ST4 declination pulse direction.
Definition guide.cpp:1255
Q_SCRIPTABLE void clearLog()
clearLog As the name suggests
Definition guide.cpp:1249
Q_SCRIPTABLE Q_NOREPLY void loop()
DBUS interface function.
Definition guide.cpp:3126
Q_SCRIPTABLE bool guide()
DBUS interface function.
Definition guide.cpp:1355
bool setCamera(ISD::Camera *device)
Add new Camera.
Definition guide.cpp:325
Uses external LinGuider for guiding.
Definition linguider.h:26
The ManualPulse class generates manual pulses for testing purposes to see how much the mount react to...
Definition manualpulse.h:22
Enables the user to set guide calibration options.
Enables the user to set guide options.
Definition opsdither.h:23
Enables the user to set Gaussian Process Guider options.
Definition opsgpg.h:25
Enables the user to set guide options.
Definition opsguide.h:30
Uses external PHD2 for guiding.
Definition phd2.h:30
Primary window to view monochrome and color FITS images.
Definition fitsviewer.h:54
The main change relative to fitsview is to add the capability of displaying the 'neighbor guide stars...
Definition guideview.h:22
AdaptiveOptics class handles control of INDI AdaptiveOptics devices.
CameraChip class controls a particular chip in camera.
Camera class controls an INDI Camera device.
Definition indicamera.h:45
device handle controlling Mounts.
Definition indimount.h:29
The QProgressIndicator class lets an application display a progress indicator to show that a long tas...
The sky coordinates of a point in the sky.
Definition skypoint.h:45
An angle, stored as degrees, but expressible in many ways.
Definition dms.h:38
Ekos is an advanced Astrophotography tool for Linux.
Definition align.cpp:83
CaptureState
Capture states.
Definition ekos.h:92
Q_CLASSINFO(Name, Value)
Q_OBJECTQ_OBJECT
Q_PROPERTY(...)
QWidget(QWidget *parent, Qt::WindowFlags f)
virtual bool event(QEvent *event) override
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:58:35 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.