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 */
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 */
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 */
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 */
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 /** 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 */
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 */
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 // Aborts the current exposure, if one is ongoing.
320 void abortExposure();
321
322 // This Function will allow PHD2 to update the exposure values to the recommended ones.
323 QString setRecommendedExposureValues(QList<double> values);
324
325 // Append Log entry
326 void appendLogText(const QString &);
327
328 // Update Guide module status
329 void setStatus(Ekos::GuideState newState);
330
331 // Update Capture Module status
332 void setCaptureStatus(Ekos::CaptureState newState);
333 // Update Mount module status
334 void setMountStatus(ISD::Mount::Status newState);
335 void setMountCoords(const SkyPoint &position, ISD::Mount::PierSide pierSide, const dms &ha);
336
337 // Update Pier Side
338 void setPierSide(ISD::Mount::PierSide newSide);
339
340 // Star Position
341 void setStarPosition(const QVector3D &newCenter, bool updateNow);
342
343 // Capture
344 void setCaptureComplete();
345
346 // Pulse both RA and DEC axes
347 bool sendMultiPulse(GuideDirection ra_dir, int ra_msecs, GuideDirection dec_dir, int dec_msecs, CaptureAfterPulses followWithCapture);
348 // Pulse for one of the mount axes
349 bool sendSinglePulse(GuideDirection dir, int msecs, CaptureAfterPulses followWithCapture);
350
351 /**
352 * @brief setDECSwap Change ST4 declination pulse direction. +DEC pulses increase DEC if swap is OFF. When on +DEC pulses result in decreasing DEC.
353 * @param enable True to enable DEC swap. Off to disable it.
354 */
355 void setDECSwap(bool enable);
356
357
358 /**
359 * @brief updateSetting Update per-train and global setting
360 * @param key Name of setting
361 * @param value Value
362 * @note per-train and global settings are updated. Changes are saved to database
363 * and to disk immediately.
364 */
365 void updateSetting(const QString &key, const QVariant &value);
366
367 //plot slots
368 void handleVerticalPlotSizeChange();
369 void handleHorizontalPlotSizeChange();
370 void clearGuideGraphs();
371 void clearCalibrationGraphs();
372 void slotAutoScaleGraphs();
373 void buildTarget();
374 void guideHistory();
375 void setLatestGuidePoint(bool isChecked);
376
377 void updateDirectionsFromPHD2(const QString &mode);
378
379 void guideAfterMeridianFlip();
380
381 // Trains
382 QString opticalTrain() const
383 {
384 return opticalTrainCombo->currentText();
385 }
386 void setOpticalTrain(const QString &value)
387 {
388 opticalTrainCombo->setCurrentText(value);
389 }
390
391 protected slots:
392 void updateCCDBin(int index);
393
394 /**
395 * @brief processCCDNumber Process number properties arriving from CCD. Currently, binning changes are processed.
396 * @param nvp pointer to number property.
397 */
398 void updateProperty(INDI::Property prop);
399
400 /**
401 * @brief setTrackingStar Gets called when the user select a star in the guide frame
402 * @param x X coordinate of star
403 * @param y Y coordinate of star
404 */
405 void setTrackingStar(int x, int y);
406
407 void saveDefaultGuideExposure();
408
409 void updateTrackingBoxSize(int currentIndex);
410
411 //void onXscaleChanged( int i );
412 //void onYscaleChanged( int i );
413 void onThresholdChanged(int i);
414 void onEnableDirRA();
415 void onEnableDirDEC();
416
417 void setAxisDelta(double ra, double de);
418 void setAxisSigma(double ra, double de);
419 void setAxisPulse(double ra, double de);
420 void setSNR(double snr);
421 void calibrationUpdate(GuideInterface::CalibrationUpdateType type, const QString &message = QString(""), double dx = 0,
422 double dy = 0);
423
424 void guideInfo(const QString &info);
425
426 void processGuideOptions();
427 void configSEPMultistarOptions();
428
429 void onControlDirectionChanged();
430
431 void showFITSViewer();
432
433 void processCaptureTimeout();
434
435 void nonGuidedDither();
436
437 signals:
438 void newLog(const QString &text);
439 void newStatus(Ekos::GuideState status);
440
441 void newImage(const QSharedPointer<FITSView> &view);
442 void newStarPixmap(QPixmap &);
443
444 void trainChanged();
445
446 // Immediate deviations in arcsecs
447 void newAxisDelta(double ra, double de);
448 // Sigma deviations in arcsecs RMS
449 void newAxisSigma(double ra, double de);
450
451 void guideStats(double raError, double decError, int raPulse, int decPulse,
452 double snr, double skyBg, int numStars);
453
454 void guideChipUpdated(ISD::CameraChip *);
455 void settingsUpdated(const QVariantMap &settings);
456 void driverTimedout(const QString &deviceName);
457
458 private:
459
460 void resizeEvent(QResizeEvent *event) override;
461
462 /**
463 * @brief updateGuideParams Update the guider and frame parameters due to any changes in the mount and/or ccd frame
464 */
465 void updateGuideParams();
466
467 /**
468 * @brief check if the guiding chip of the camera should be used (if present)
469 */
470 void checkUseGuideHead();
471
472 /**
473 * @brief syncTrackingBoxPosition Sync the tracking box to the current selected star center
474 */
475 void syncTrackingBoxPosition();
476
477 /**
478 * @brief setBusy Indicate busy status within the module visually
479 * @param enable True if module is busy, false otherwise
480 */
481 void setBusy(bool enable);
482
483 /**
484 * @brief setBLOBEnabled Enable or disable BLOB reception from current CCD if using external guider
485 * @param enable True to enable BLOB reception, false to disable BLOB reception
486 * @param name CCD to enable to disable. If empty (default), then action is applied to all CCDs.
487 */
488 void setExternalGuiderBLOBEnabled(bool enable);
489
490 /**
491 * @brief prepareCapture Set common settings for capture for guide module
492 * @param targetChip target Chip
493 */
494 void prepareCapture(ISD::CameraChip *targetChip);
495
496
497 void handleManualDither();
498
499 ////////////////////////////////////////////////////////////////////
500 /// Settings
501 ////////////////////////////////////////////////////////////////////
502
503 /**
504 * @brief Connect GUI elements to sync settings once updated.
505 */
506 void connectSettings();
507 /**
508 * @brief Stop updating settings when GUI elements are updated.
509 */
510 void disconnectSettings();
511 /**
512 * @brief loadSettings Load setting from Options and set them accordingly.
513 */
514 void loadGlobalSettings();
515
516 /**
517 * @brief syncSettings When checkboxes, comboboxes, or spin boxes are updated, save their values in the
518 * global and per-train settings.
519 */
520 void syncSettings();
521
522 /**
523 * @brief syncControl Sync setting to widget. The value depends on the widget type.
524 * @param settings Map of all settings
525 * @param key name of widget to sync
526 * @param widget pointer of widget to set
527 * @return True if sync successful, false otherwise
528 */
529 bool syncControl(const QVariantMap &settings, const QString &key, QWidget * widget);
530
531 /**
532 * @brief settleSettings Run this function after timeout from debounce timer to update database
533 * and emit settingsChanged signal. This is required so we don't overload output.
534 */
535 void settleSettings();
536
537 // Operation stack
538 void buildOperationStack(GuideState operation);
539 bool executeOperationStack();
540 bool executeOneOperation(GuideState operation);
541
542 // Init Functions
543 void initPlots();
544 void initDriftGraph();
545 void initCalibrationPlot();
546 void initView();
547 void initConnections();
548
549 bool captureOneFrame();
550
551 void setupOpticalTrainManager();
552 void refreshOpticalTrain();
553
554 // Driver
555 void reconnectDriver(const QString &camera, QVariantMap settings);
556
557 // Operation Stack
558 QStack<GuideState> operationStack;
559
560 // Devices
561 ISD::Camera *m_Camera { nullptr };
562 ISD::Mount *m_Mount { nullptr };
563 ISD::Guider *m_Guider { nullptr };
564 ISD::AdaptiveOptics *m_AO { nullptr };
565
566 // Guider process
567 GuideInterface *m_GuiderInstance { nullptr };
568
569 //This is for the configure PHD2 camera method.
570 QString m_LastPHD2CameraName, m_LastPHD2MountName;
571 GuiderType guiderType { GUIDE_INTERNAL };
572
573 // Star
574 QVector3D starCenter;
575
576 // Guide Params
577 int guideBinIndex { 0 }; // Selected or saved binning for guiding
578 double ccdPixelSizeX { -1 };
579 double ccdPixelSizeY { -1 };
580
581 // Scope info
582 double m_Aperture { -1 };
583 double m_FocalLength { -1 };
584 double m_FocalRatio { -1 };
585 double m_Reducer {-1};
586
587 double guideDeviationRA { 0 };
588 double guideDeviationDEC { 0 };
589 double pixScaleX { -1 };
590 double pixScaleY { -1 };
591
592 // State
593 GuideState m_State { GUIDE_IDLE };
594 GuideStateWidget *guideStateWidget { nullptr };
595
596 // Guide timer
597 QElapsedTimer guideTimer;
598
599 // Debounce Timer
600 QTimer m_DebounceTimer;
601
602 // Capture timeout timer
603 QTimer captureTimeout;
604 uint8_t m_CaptureTimeoutCounter { 0 };
605 uint8_t m_DeviceRestartCounter { 0 };
606
607 // Pulse Timer
608 QTimer m_PulseTimer;
609
610 // Log
611 QStringList m_LogText;
612
613 // Misc
614 bool useGuideHead { false };
615
616 // Progress Activity Indicator
617 QProgressIndicator *pi { nullptr };
618
619 // Options
620 OpsCalibration *opsCalibration { nullptr };
621 OpsGuide *opsGuide { nullptr };
622 OpsDither *opsDither { nullptr };
623 OpsGPG *opsGPG { nullptr };
624
625 // Guide Frame
626 QSharedPointer<GuideView> m_GuideView;
627
628 // Calibration done already?
629 bool calibrationComplete { false };
630
631 // Was the modified frame subFramed?
632 bool subFramed { false };
633
634 // Controls
635 double guideGainSpecialValue {INVALID_VALUE};
636 double TargetCustomGainValue {-1};
637
638 // CCD Chip frame settings
640
641 // Profile Pixmap
642 QPixmap profilePixmap;
643 // drift plot
644 QPixmap driftPlotPixmap;
645
646 // Flag to start auto calibration followed immediately by guiding
647 //bool autoCalibrateGuide { false };
648
649 // Pointers of guider processes
650 QPointer<InternalGuider> internalGuider;
651 QPointer<PHD2> phd2Guider;
652 QPointer<LinGuider> linGuider;
654 QSharedPointer<FITSData> m_ImageData;
655
656 // Dark Processor
657 QPointer<DarkProcessor> m_DarkProcessor;
658
659 // Manual Pulse Dialog
660 QPointer<ManualPulse> m_ManaulPulse;
661
662 double primaryFL = -1, primaryAperture = -1, guideFL = -1, guideAperture = -1;
663 ISD::Mount::Status m_MountStatus { ISD::Mount::MOUNT_IDLE };
664
665 bool graphOnLatestPt = true;
666
667 //This is for enforcing the PHD2 Star lock when Guide is pressed,
668 //autostar is not selected, and the user has chosen a star.
669 //This connection storage is so that the connection can be disconnected after enforcement
670 QMetaObject::Connection guideConnect;
671
672 QCPItemText *calLabel { nullptr };
673
674 // The scales of these zoom levels are defined in Guide::zoomX().
675 static constexpr int defaultXZoomLevel = 3;
676 int driftGraphZoomLevel {defaultXZoomLevel};
677
678
679 // The accumulated non-guided dither offsets (in milliseconds) in the RA and DEC directions.
680 int nonGuidedDitherRaOffsetMsec = 0, nonGuidedDitherDecOffsetMsec = 0;
681
682 // Random generator for non guided dithering
683 std::mt19937 nonGuidedPulseGenerator;
684
685 // Flag to check if random generator for non guided dithering is initialized.
686 bool isNonGuidedDitherInitialized = false;
687
688 // Reset non guided dithering properties and initialize the random generator seed if not already done.
689 // Should be called in Guide::Guide() for initial seed initialization, and then in setCaptureStatus to reset accumulated drift
690 // every time a capture task is completed or aborted.
691 void resetNonGuidedDither();
692
693 QVariantMap m_Settings;
694 QVariantMap m_GlobalSettings;
695};
696}
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
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:50
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:44
device handle controlling Mounts.
Definition indimount.h:27
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:79
CaptureState
Capture states.
Definition ekos.h:92
Int toInt() const const
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 Fri Jun 14 2024 11:55:02 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.