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 onThresholdChanged(int i);
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 processCaptureTimeout();
441
442 void nonGuidedDither();
443
444 signals:
445 void newLog(const QString &text);
446 void newStatus(Ekos::GuideState status);
447
448 void newImage(const QSharedPointer<FITSView> &view);
449 void newStarPixmap(QPixmap &);
450
451 void trainChanged();
452
453 // Immediate deviations in arcsecs
454 void newAxisDelta(double ra, double de);
455 // Sigma deviations in arcsecs RMS
456 void newAxisSigma(double ra, double de);
457
458 void guideStats(double raError, double decError, int raPulse, int decPulse,
459 double snr, double skyBg, int numStars);
460
461 void guideChipUpdated(ISD::CameraChip *);
462 void settingsUpdated(const QVariantMap &settings);
463 void driverTimedout(const QString &deviceName);
464
465 private:
466
467 void resizeEvent(QResizeEvent *event) override;
468
469 /**
470 * @brief updateGuideParams Update the guider and frame parameters due to any changes in the mount and/or ccd frame
471 */
472 void updateGuideParams();
473
474 /**
475 * @brief check if the guiding chip of the camera should be used (if present)
476 */
477 void checkUseGuideHead();
478
479 /**
480 * @brief syncTrackingBoxPosition Sync the tracking box to the current selected star center
481 */
482 void syncTrackingBoxPosition();
483
484 /**
485 * @brief setBusy Indicate busy status within the module visually
486 * @param enable True if module is busy, false otherwise
487 */
488 void setBusy(bool enable);
489
490 /**
491 * @brief setBLOBEnabled Enable or disable BLOB reception from current CCD if using external guider
492 * @param enable True to enable BLOB reception, false to disable BLOB reception
493 * @param name CCD to enable to disable. If empty (default), then action is applied to all CCDs.
494 */
495 void setExternalGuiderBLOBEnabled(bool enable);
496
497 /**
498 * @brief prepareCapture Set common settings for capture for guide module
499 * @param targetChip target Chip
500 */
501 void prepareCapture(ISD::CameraChip *targetChip);
502
503
504 void handleManualDither();
505
506 ////////////////////////////////////////////////////////////////////
507 /// Settings
508 ////////////////////////////////////////////////////////////////////
509
510 /**
511 * @brief Connect GUI elements to sync settings once updated.
512 */
513 void connectSettings();
514 /**
515 * @brief Stop updating settings when GUI elements are updated.
516 */
517 void disconnectSettings();
518 /**
519 * @brief loadSettings Load setting from Options and set them accordingly.
520 */
521 void loadGlobalSettings();
522
523 /**
524 * @brief syncSettings When checkboxes, comboboxes, or spin boxes are updated, save their values in the
525 * global and per-train settings.
526 */
527 void syncSettings();
528
529 /**
530 * @brief syncControl Sync setting to widget. The value depends on the widget type.
531 * @param settings Map of all settings
532 * @param key name of widget to sync
533 * @param widget pointer of widget to set
534 * @return True if sync successful, false otherwise
535 */
536 bool syncControl(const QVariantMap &settings, const QString &key, QWidget * widget);
537
538 /**
539 * @brief settleSettings Run this function after timeout from debounce timer to update database
540 * and emit settingsChanged signal. This is required so we don't overload output.
541 */
542 void settleSettings();
543
544 // Operation stack
545 void buildOperationStack(GuideState operation);
546 bool executeOperationStack();
547 bool executeOneOperation(GuideState operation);
548
549 // Init Functions
550 void initPlots();
551 void initDriftGraph();
552 void initCalibrationPlot();
553 void initView();
554 void initConnections();
555
556 bool captureOneFrame();
557
558 void setupOpticalTrainManager();
559 void refreshOpticalTrain();
560
561 // Driver
562 void reconnectDriver(const QString &camera, QVariantMap settings);
563
564 // Operation Stack
565 QStack<GuideState> operationStack;
566
567 // Devices
568 ISD::Camera *m_Camera { nullptr };
569 ISD::Mount *m_Mount { nullptr };
570 ISD::Guider *m_Guider { nullptr };
571 ISD::AdaptiveOptics *m_AO { nullptr };
572
573 // Guider process
574 GuideInterface *m_GuiderInstance { nullptr };
575
576 //This is for the configure PHD2 camera method.
577 QString m_LastPHD2CameraName, m_LastPHD2MountName;
578 GuiderType guiderType { GUIDE_INTERNAL };
579
580 // Star
581 QVector3D starCenter;
582
583 // Guide Params
584 int guideBinIndex { 0 }; // Selected or saved binning for guiding
585 double ccdPixelSizeX { -1 };
586 double ccdPixelSizeY { -1 };
587
588 // Scope info
589 double m_Aperture { -1 };
590 double m_FocalLength { -1 };
591 double m_FocalRatio { -1 };
592 double m_Reducer {-1};
593
594 double guideDeviationRA { 0 };
595 double guideDeviationDEC { 0 };
596 double pixScaleX { -1 };
597 double pixScaleY { -1 };
598
599 // State
600 GuideState m_State { GUIDE_IDLE };
601 GuideStateWidget *guideStateWidget { nullptr };
602
603 // Guide timer
604 QElapsedTimer guideTimer;
605
606 // Debounce Timer
607 QTimer m_DebounceTimer;
608
609 // Capture timeout timer
610 QTimer captureTimeout;
611 uint8_t m_CaptureTimeoutCounter { 0 };
612 uint8_t m_DeviceRestartCounter { 0 };
613
614 // Pulse Timer
615 QTimer m_PulseTimer;
616
617 // Log
618 QStringList m_LogText;
619
620 // Misc
621 bool useGuideHead { false };
622
623 // Progress Activity Indicator
624 QProgressIndicator *pi { nullptr };
625
626 // Options
627 OpsCalibration *opsCalibration { nullptr };
628 OpsGuide *opsGuide { nullptr };
629 OpsDither *opsDither { nullptr };
630 OpsGPG *opsGPG { nullptr };
631
632 // Guide Frame
633 QSharedPointer<GuideView> m_GuideView;
634
635 // Calibration done already?
636 bool calibrationComplete { false };
637
638 // Was the modified frame subFramed?
639 bool subFramed { false };
640
641 // Controls
642 double guideGainSpecialValue {INVALID_VALUE};
643 double TargetCustomGainValue {-1};
644
645 // CCD Chip frame settings
647
648 // Profile Pixmap
649 QPixmap profilePixmap;
650 // drift plot
651 QPixmap driftPlotPixmap;
652
653 // Flag to start auto calibration followed immediately by guiding
654 //bool autoCalibrateGuide { false };
655
656 // Pointers of guider processes
657 QPointer<InternalGuider> internalGuider;
658 QPointer<PHD2> phd2Guider;
659 QPointer<LinGuider> linGuider;
661 QSharedPointer<FITSData> m_ImageData;
662
663 // Dark Processor
664 QPointer<DarkProcessor> m_DarkProcessor;
665
666 // Manual Pulse Dialog
667 QPointer<ManualPulse> m_ManaulPulse;
668
669 double primaryFL = -1, primaryAperture = -1, guideFL = -1, guideAperture = -1;
670 ISD::Mount::Status m_MountStatus { ISD::Mount::MOUNT_IDLE };
671
672 bool graphOnLatestPt = true;
673
674 //This is for enforcing the PHD2 Star lock when Guide is pressed,
675 //autostar is not selected, and the user has chosen a star.
676 //This connection storage is so that the connection can be disconnected after enforcement
677 QMetaObject::Connection guideConnect;
678
679 QCPItemText *calLabel { nullptr };
680
681 // The scales of these zoom levels are defined in Guide::zoomX().
682 static constexpr int defaultXZoomLevel = 3;
683 int driftGraphZoomLevel {defaultXZoomLevel};
684
685
686 // The accumulated non-guided dither offsets (in milliseconds) in the RA and DEC directions.
687 int nonGuidedDitherRaOffsetMsec = 0, nonGuidedDitherDecOffsetMsec = 0;
688
689 // Random generator for non guided dithering
690 std::mt19937 nonGuidedPulseGenerator;
691
692 // Flag to check if random generator for non guided dithering is initialized.
693 bool isNonGuidedDitherInitialized = false;
694
695 QVariantMap m_Settings;
696 QVariantMap m_GlobalSettings;
697};
698}
Performs calibration and autoguiding using an ST4 port or directly via the INDI driver.
Definition guide.h:51
Q_SCRIPTABLE bool connectGuider()
DBUS interface function.
Definition guide.cpp:2712
bool setMount(ISD::Mount *device)
Add new Mount.
Definition guide.cpp:437
Q_SCRIPTABLE bool calibrate()
DBUS interface function.
Definition guide.cpp:1283
void updateProperty(INDI::Property prop)
processCCDNumber Process number properties arriving from CCD.
Definition guide.cpp:1741
Q_SCRIPTABLE Q_NOREPLY void setAutoStarEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1561
Q_SCRIPTABLE QString camera()
DBUS interface function.
Q_SCRIPTABLE Q_NOREPLY void setDarkFrameEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1806
void processData(const QSharedPointer< FITSData > &data)
newFITS is called by the INDI framework whenever there is a new BLOB arriving
Definition guide.cpp:1074
Q_SCRIPTABLE QList< double > axisDelta()
DBUS interface function.
Q_SCRIPTABLE bool resume()
DBUS interface function.
Definition guide.cpp:1429
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:2158
Q_SCRIPTABLE bool setGuiderType(int type)
DBUS interface function.
Definition guide.cpp:1891
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:1764
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:3400
bool setGuider(ISD::Guider *device)
Add new Guider.
Definition guide.cpp:722
Q_SCRIPTABLE bool suspend()
DBUS interface function.
Definition guide.cpp:1419
Q_SCRIPTABLE bool dither()
DBUS interface function.
Definition guide.cpp:1383
void resetNonGuidedDither()
Reset non guided dithering properties and initialize the random generator seed if not already done.
Definition guide.cpp:2607
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:1548
Q_SCRIPTABLE Q_NOREPLY void setSubFrameEnabled(bool enable)
DBUS interface function.
Definition guide.cpp:1553
void checkCamera()
checkCamera Check all CCD parameters and ensure all variables are updated to reflect the selected CCD
Definition guide.cpp:461
Q_SCRIPTABLE bool capture()
DBUS interface function.
Definition guide.cpp:769
QString getLogText()
Definition guide.h:186
Q_SCRIPTABLE Q_NOREPLY void clearCalibration()
DBUS interface function.
Definition guide.cpp:1567
Q_SCRIPTABLE bool abort()
DBUS interface function.
Definition guide.cpp:889
Q_SCRIPTABLE bool disconnectGuider()
DBUS interface function.
Definition guide.cpp:2718
bool setAdaptiveOptics(ISD::AdaptiveOptics *device)
Add new Adaptive Optics.
Definition guide.cpp:748
void setDECSwap(bool enable)
setDECSwap Change ST4 declination pulse direction.
Definition guide.cpp:1235
Q_SCRIPTABLE void clearLog()
clearLog As the name suggests
Definition guide.cpp:1229
Q_SCRIPTABLE Q_NOREPLY void loop()
DBUS interface function.
Definition guide.cpp:3023
Q_SCRIPTABLE bool guide()
DBUS interface function.
Definition guide.cpp:1329
bool setCamera(ISD::Camera *device)
Add new Camera.
Definition guide.cpp:319
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
A text label.
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(...)
QString join(QChar separator) const const
virtual bool event(QEvent *event) override
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Sat Dec 21 2024 17:04:46 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.