Kstars

cameraprocess.h
1/*
2 SPDX-FileCopyrightText: 2023 Wolfgang Reissenberger <sterne-jaeger@openfuture.de>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#pragma once
8
9#include "camerastate.h"
10#include "sequencejob.h"
11
12#include "indiapi.h"
13
14#include <QObject>
15
16class FITSViewer;
17
18namespace Ekos
19{
20
21class CaptureDeviceAdaptor;
22class DarkProcessor;
23
24/**
25 * @class CameraProcess
26 * @brief The CameraProcess class holds the entire business logic to control capturing execution.
27 *
28 * Capture Execution
29 * =================
30 * Executing the sequence jobs is a complex process (explained here for light frames) and works roughly
31 * as follows and starts by calling {@see Capture#start()} either from the scheduler, by DBUS or by
32 * pressing the start button:
33 * 1. Select the next sequence job to be executed ({@see startNextPendingJob()}. If the list of jobs is
34 * empty, an {@see #addJob()} event is sent. The corresponding callback function
35 * {@see #jobAdded(SequenceJob*)} is triggered. Now we know that at least one sequence job is
36 * to be executed.
37 * 2. Prepare the selected job
38 * - update the counters of captured frames ({@see #prepareJob(SequenceJob *)})
39 * - execute the pre job script, if existing ({@see #prepareActiveJobStage1()})
40 * - set temperature, rotator angle and wait (if required) for the initial guiding
41 * deviation being below the configured threshold ({@see #prepareJobExecution()})
42 * and wait until these parameters are OK.
43 * 3. Prepare capturing a single frame
44 * We still need to do some preparation steps before capturing starts.
45 * - {@see #executeJob()} is the starting point, which simply sets the capture state
46 * to "busy" and sets the FITS attributes to the camera
47 * - Check all tasks that need to be completed before capturing may start (post meridian
48 * flip actions, guiding deviation, dithering, re-focusing, ..., see {@see #checkLightFramePendingTasks()}
49 * 4. Capture a single frame
50 * - Initiate capturing (set diverse settings of {@see #activeCamera()} (see {@see #captureImage})
51 * - hand over the control of capturing to the sequence job ({@see SequenceJob#startCapturing()})
52 * - Select the correct filter (@see SequenceJobState#prepareTargetFilter()}
53 * - As soon as the correct filter is set, the sequence job state will send the event
54 * {@see SequenceJobState::initCaptureComplete()}, which will finally call trigger
55 * {@see SequenceJob::capture()}
56 * 5. Listen upon capturing progress
57 * - listen to the event {@see ISD::Camera::newExposureValue}, update the remaining
58 * time and wait until the INDI state changes from busy to OK
59 * - start the download timer to measure download times
60 * - listen to the event {@see ISD::Camera::newImage} and start processing the FITS image
61 * as soon as it has been recieved
62 * 6. Process received image
63 * - update the FITS image meta data {@see #updateImageMetadataAction()}
64 * - update time calculation and counters and execute post capture script ({@see imageCapturingCompleted()})
65 * 7. Check how to continue the sequence execution ({@see resumeSequence()})
66 * - if the current sequence job isn't completed,
67 * - execute the post capture script
68 * - start next exposure (similar to 3.) ({@see startNextExposure()})
69 * TODO: check why we need this separate method and cannot use {@see updatePreCaptureCalibrationStatus()}
70 * - if the current sequence is complete,
71 * - execute the post sequence script ({@see processJobCompletion1()})
72 * - stop the current sequence job ({@see processJobCompletion2()})
73 * - recall {@see resumeSequence()}, which calls {@see startNextJob()}
74 * - if there is another job to be executed, jump to 2., otherwise Capture is completed
75 * by sending a stopCapture(CAPTURE_COMPLETE) event
76 *
77 * ADU based flats calibration
78 * ===========================
79 * Capturing ADU based flats begins like capturing other frame types. The difference begins as soon as an
80 * image has been received (step 6 above) in {@see imageCapturingCompleted()}. Here {@see checkFlatCalibration()}
81 * is called to check the frame's ADU. If the ADU isn't in the expected range, a new frame is captured with
82 * modified exposure time ({@see startNextExposure()}.
83 *
84 * Autofocus
85 * =========
86 * Capture has three ways that trigger autofocus during a capturing sequence: HFR based, temperature drift based,
87 * timer based and post meridian flip based. Each time the capture execution reaches the preparation of caturing
88 * a single frame (3. above) (see {@see CameraState#startFocusIfRequired()} and
89 * {@see RefocusState#checkFocusRequired()}).
90 *
91 * Meridian Flip
92 * =============
93 * The meridian flip itself is executed by the Mount module and is controlled by
94 * (see {@see MeridianFlipState}). Nevertheless, the Capture module plays an
95 * important rule in the meridian flip:
96 * 1. Accept a flip to be executed
97 * As soon as a meridian flip has been planned (informed through
98 * {@see #updateMFMountState(MeridianFlipState::MeridianFlipMountState)}, the meridian flip state is set
99 * to MF_REQUESTED.
100 * - If capturing is running the state remains in this state until the frame has been captured. As soon as
101 * the capturing state changes to id, suspended or aborted (see {@see CameraState::setCaptureState(CaptureState)}),
102 * the meridian flip state is set to MF_ACCEPTED (see {@see MeridianFlipState::updateMeridianFlipStage(const MFStage)}).
103 * This is triggered from {@see #checkLightFramePendingTasks()}, i.e. this function is looping once per second until
104 * the meridian flip has been completed.
105 * - If capturing is not running, the latter happens immediately.
106 * Now the meridian flip is started.
107 * 2. Post MF actions
108 * As soon as the meridian flip has been completed (and the Capture module is waiting for it), the Capture module
109 * takes over the control and executes all necessary tasks: aligning, re-focusing, guiding, etc. This happens all through
110 * {@see #checkLightFramePendingTasks()}. As soon as all has recovered, capturing continues.
111 */
112class CameraProcess : public QObject
113{
114 Q_OBJECT
115
116public:
117 typedef enum
118 {
119 ADU_LEAST_SQUARES,
120 ADU_POLYNOMIAL
121 } ADUAlgorithm;
122
123 typedef struct FitsvViewerTabIDs
124 {
125 int normalTabID { -1 };
126 int calibrationTabID { -1 };
127 int focusTabID { -1 };
128 int guideTabID { -1 };
129 int alignTabID { -1 };
130
131 } FitsvViewerTabIDs;
132
133
134 CameraProcess(QSharedPointer<CameraState> newModuleState, QSharedPointer<CaptureDeviceAdaptor> newDeviceAdaptor);
135
136 // ////////////////////////////////////////////////////////////////////
137 // handle connectivity to modules and devices
138 // ////////////////////////////////////////////////////////////////////
139 /**
140 * @brief setMount Connect to the given mount device (and deconnect the old one
141 * if existing)
142 * @param device pointer to Mount device.
143 * @return True if added successfully, false if duplicate or failed to add.
144 */
145 bool setMount(ISD::Mount *device);
146
147 /**
148 * @brief setRotator Connect to the given rotator device (and deconnect
149 * the old one if existing)
150 * @param device pointer to rotator INDI device
151 * @return True if added successfully, false if duplicate or failed to add.
152 */
153 bool setRotator(ISD::Rotator * device);
154
155 /**
156 * @brief setDustCap Connect to the given dust cap device (and deconnect
157 * the old one if existing)
158 * @param device pointer to dust cap INDI device
159 * @return True if added successfully, false if duplicate or failed to add.
160 */
161 bool setDustCap(ISD::DustCap *device);
162
163 /**
164 * @brief setLightBox Connect to the given dust cap device (and deconnect
165 * the old one if existing)
166 * @param device pointer to light box INDI device.
167 * @return True if added successfully, false if duplicate or failed to add.
168 */
169 bool setLightBox(ISD::LightBox *device);
170
171 /**
172 * @brief setDome Connect to the given dome device
173 * @param device point to dome INDI device
174 * @return True if added successfully, false if duplicate or failed to add.
175 */
176 bool setDome(ISD::Dome *device);
177
178 /**
179 * @brief setCamera Connect to the given camera device (and deconnect
180 * the old one if existing)
181 * @param device pointer to camera INDI device.
182 * @return True if added successfully, false if duplicate or failed to add.
183 */
184 bool setCamera(ISD::Camera *device);
185
186 /**
187 * @brief setScope Set active train telescope name
188 * @param name Name of scope
189 */
190 void setScope(const QString &name)
191 {
192 m_Scope = name;
193 }
194
195 /**
196 * @brief Connect or disconnect the camera device
197 * @param connection flag if connect (=true) or disconnect (=false)
198 */
199 void setCamera(bool connection);
200
201 /**
202 * @brief setFilterWheel Connect to the given filter wheel device (and deconnect
203 * the old one if existing)
204 * @param device pointer to filter wheel INDI device.
205 * @return True if added successfully, false if duplicate or failed to add.
206 */
207 bool setFilterWheel(ISD::FilterWheel *device);
208
209 /**
210 * Toggle video streaming if supported by the device.
211 * @param enabled Set to true to start video streaming, false to stop it if active.
212 */
213 void toggleVideo(bool enabled);
214
215 // ////////////////////////////////////////////////////////////////////
216 // capturing process steps
217 // ////////////////////////////////////////////////////////////////////
218
219 /**
220 * @brief toggleSequence Toggle sequence state depending on its current state.
221 * 1. If paused, then resume sequence.
222 * 2. If idle or completed, then start sequence.
223 * 3. Otherwise, abort current sequence.
224 */
225 Q_SCRIPTABLE void toggleSequence();
226
227 /**
228 * @brief startNextPendingJob Start the next pending job.
229 *
230 * Find the next job to be executed:
231 * 1. If there are already some jobs defined, {@see #findNextPendingJob()} is
232 * used to find the next job to be executed.
233 * 2. If the list is empty, the current settings are used to create a job instantly,
234 * which subsequently will be executed.
235 */
236 void startNextPendingJob();
237
238 /**
239 * @brief Counterpart to the event {@see#createJob(SequenceJob::SequenceJobType)}
240 * where the event receiver reports whether one has been added successfully
241 * and of which type it was.
242 */
243 void jobCreated(SequenceJob *newJob);
244
245 /**
246 * @brief capturePreview Capture a preview (single or looping ones)
247 */
248 void capturePreview(bool loop = false);
249
250 /**
251 * @brief stopCapturing Stopping the entire capturing state
252 * (envelope for aborting, suspending, pausing, ...)
253 * @param targetState state capturing should be having afterwards
254 */
255 void stopCapturing(CaptureState targetState);
256
257 /**
258 * @brief pauseCapturing Pauses capturing as soon as the current
259 * capture is complete.
260 */
261 Q_SCRIPTABLE void pauseCapturing();
262
263 /**
264 * @brief startJob Start the execution of a selected sequence job:
265 * - Initialize the state for capture preparation ({@see CameraState#initCapturePreparation()}
266 * - Prepare the selected job ({@see #prepareJob(SequenceJob *)})
267 * @param job selected sequence job
268 */
269 void startJob(SequenceJob *job);
270
271 /**
272 * @brief prepareJob Update the counters of existing frames and continue with prepareActiveJob(), if there exist less
273 * images than targeted. If enough images exist, continue with processJobCompletion().
274 */
275 void prepareJob(SequenceJob *job);
276
277 /**
278 * @brief prepareActiveJobStage1 Check for pre job script to execute. If none, move to stage 2
279 */
280 void prepareActiveJobStage1();
281 /**
282 * @brief prepareActiveJobStage2 Reset #calibrationStage and continue with preparePreCaptureActions().
283 */
284 void prepareActiveJobStage2();
285
286 /**
287 * @brief preparePreCaptureActions Trigger setting the filter, temperature, (if existing) the rotator angle and
288 * let the #activeJob execute the preparation actions before a capture may
289 * take place (@see SequenceJob::prepareCapture()).
290 *
291 * After triggering the settings, this method returns. This mechanism is slightly tricky, since it
292 * asynchronous and event based and works as collaboration between Capture and SequenceJob. Capture has
293 * the connection to devices and SequenceJob knows the target values.
294 *
295 * Each time Capture receives an updated value - e.g. the current CCD temperature
296 * (@see updateCCDTemperature()) - it informs the #activeJob about the current CCD temperature.
297 * SequenceJob checks, if it has reached the target value and if yes, sets this action as as completed.
298 *
299 * As soon as all actions are completed, SequenceJob emits a prepareComplete() event, which triggers
300 * executeJob() from the CameraProcess.
301 */
302 void prepareJobExecution();
303
304 /**
305 * @brief executeJob Start the execution of #activeJob by initiating updatePreCaptureCalibrationStatus().
306 */
307 Q_SCRIPTABLE void executeJob();
308
309 /**
310 * @brief refreshOpticalTrain Refresh the devices from the optical train configuration
311 * @param name name of the optical train configuration
312 */
313 void refreshOpticalTrain(QString name);
314
315 /**
316 * @brief Check all tasks that might be pending before capturing may start.
317 *
318 * The following checks are executed:
319 * 1. Are there any pending jobs that failed? If yes, return with IPS_ALERT.
320 * 2. Has pausing been initiated (@see checkPausing()).
321 * 3. Is a meridian flip already running (@see m_MeridianFlipState->checkMeridianFlipRunning()) or ready
322 * for execution (@see CameraState#checkMeridianFlipReady()).
323 * 4. check guide deviation for non meridian flip stages if the initial guide limit is set.
324 * Wait until the guide deviation is reported to be below the limit
325 * (@see Capture::setGuideDeviation(double, double)).
326 * 5. Check if dithering is required or running.
327 * 6. Check if re-focusing is required
328 * Needs to be checked after dithering checks to avoid dithering in parallel
329 * to focusing, since @startFocusIfRequired() might change its value over time
330 * 7. Resume guiding if it was suspended (@see Capture::resumeGuiding())
331 *
332 * @return IPS_OK iff no task is pending, IPS_BUSY otherwise (or IPS_ALERT if a problem occured)
333 */
334 IPState checkLightFramePendingTasks();
335
336
337 /**
338 * @brief updatePreCaptureCalibrationStatus This is a wrapping loop for processPreCaptureCalibrationStage(),
339 * which contains all checks before captureImage() may be called.
340 *
341 * If processPreCaptureCalibrationStage() returns IPS_OK (i.e. everything is ready so that
342 * capturing may be started), captureImage() is called. Otherwise, it waits for a second and
343 * calls itself again.
344 */
345 void updatePreCaptureCalibrationStatus();
346
347 /**
348 * @brief processPreCaptureCalibrationStage Execute the tasks that need to be completed before capturing may start.
349 *
350 * For light frames, checkLightFramePendingTasks() is called.
351 *
352 * @return IPS_OK if all necessary tasks have been completed
353 */
354 IPState processPreCaptureCalibrationStage();
355
356 /**
357 * @brief captureStarted Manage the result when capturing has been started
358 */
359 void captureStarted(CaptureResult rc);
360
361 /**
362 * @brief checkNextExposure Try to start capturing the next exposure (@see startNextExposure()).
363 * If startNextExposure() returns, that there are still some jobs pending,
364 * we wait for 1 second and retry to start it again.
365 * If one of the pending preparation jobs has problems, the looping stops.
366 */
367 void checkNextExposure();
368
369 /**
370 * @brief startNextExposure Ensure that all pending preparation tasks are be completed (focusing, dithering, etc.)
371 * and start the next exposure.
372 *
373 * Checks of pending preparations depends upon the frame type:
374 *
375 * - For light frames, pending preparations like focusing, dithering etc. needs
376 * to be checked before each single frame capture. efore starting to capture the next light frame,
377 * checkLightFramePendingTasks() is called to check if all pending preparation tasks have
378 * been completed successfully. As soon as this is the case, the sequence timer
379 * #seqTimer is started to wait the configured delay and starts capturing the next image.
380 *
381 * - For bias, dark and flat frames, preparation jobs are only executed when starting a sequence.
382 * Hence, for these frames we directly start the sequence timer #seqTimer.
383 *
384 * @return IPS_OK, iff all pending preparation jobs are completed (@see checkLightFramePendingTasks()).
385 * In that case, the #seqTimer is started to wait for the configured settling delay and then
386 * capture the next image (@see Capture::captureImage). In case that a pending task aborted,
387 * IPS_IDLE is returned.
388 */
389
390 IPState startNextExposure();
391
392 /**
393 * @brief resumeSequence Try to continue capturing.
394 *
395 * Take the active job, if there is one, or search for the next one that is either
396 * idle or aborted. If a new job is selected, call startNextJob() to prepare it.
397 * If the current job is still active, initiate checkNextExposure().
398 *
399 * @return IPS_OK if there is a job that may be continued, IPS_BUSY otherwise.
400 */
401 IPState resumeSequence();
402
403 /**
404 * @brief newFITS process new FITS data received from camera. Update status of active job and overall sequence.
405 *
406 * Manage the capture process after a captured image has been successfully downloaded
407 * from the camera:
408 * - stop timers for timeout and download progress
409 * - update the download time calculation
410 * - update captured frames counters ({@see updateCompletedCaptureCountersAction()})
411 * - check flat calibration (for flats only)
412 * - execute the post capture script (if existing)
413 * - resume the sequence ({@see resumeSequence()})
414 *
415 * @param data pointer to blob containing FITS data
416 * @param extension defining the file type
417 */
418 void processFITSData(const QSharedPointer<FITSData> &data, const QString &extension);
419
420 /**
421 * @brief showFITSPreview Directly show the FITS data as preview
422 * @param data pointer to blob containing FITS data
423 */
424 void showFITSPreview(const QSharedPointer<FITSData> &data);
425
426 /**
427 * @brief setNewRemoteFile A new image has been stored as remote file
428 * @param file local file path
429 */
430 void processNewRemoteFile(QString file);
431
432 /**
433 * @brief processJobCompletionStage1 Process job completion. In stage 1 when simply check if the is a post-job script to be running
434 * if yes, we run it and wait until it is done before we move to stage2
435 */
436 void processJobCompletion1();
437
438 /**
439 * @brief processJobCompletionStage2 Stop execution of the current sequence and check whether there exists a next sequence
440 * and start it, if there is a next one to be started (@see resumeSequence()).
441 */
442 void processJobCompletion2();
443
444 /**
445 * @brief startNextJob Select the next job that is either idle or aborted and
446 * call prepareJob(*SequenceJob) to prepare its execution and
447 * resume guiding if it was suspended (and no meridian flip is running).
448 * @return IPS_OK if a job to be executed exists, IPS_IDLE otherwise.
449 */
450 IPState startNextJob();
451
452 /**
453 * @brief captureImage Initiates image capture in the active job.
454 */
455 void captureImage();
456
457 /**
458 * @brief resetFrame Reset frame settings of the camera
459 */
460 Q_SCRIPTABLE void resetFrame();
461
462 // ////////////////////////////////////////////////////////////////////
463 // capturing actions
464 // ////////////////////////////////////////////////////////////////////
465
466 /**
467 * @brief setExposureProgress Manage exposure progress reported by
468 * the camera device.
469 */
470 void setExposureProgress(ISD::CameraChip *tChip, double value, IPState state);
471
472 /**
473 * @brief setDownloadProgress update the Capture Module and Summary
474 * Screen's estimate of how much time is left in the download
475 */
476 void setDownloadProgress();
477
478 /**
479 * @brief continueFramingAction If framing is running, start the next capture sequence
480 * @return IPS_OK in all cases
481 */
482 IPState continueFramingAction(const QSharedPointer<FITSData> &imageData);
483
484 /**
485 * @brief updateDownloadTimesAction Add the current download time to the list of already measured ones
486 */
487 IPState updateDownloadTimesAction();
488
489 /**
490 * @brief previewImageCompletedAction Activities required when a preview image has been captured.
491 * @return IPS_OK if a preview has been completed, IPS_IDLE otherwise
492 */
493 IPState previewImageCompletedAction();
494
495 /**
496 * @brief updateCompletedCaptureCounters Update counters if an image has been captured
497 */
498 void updateCompletedCaptureCountersAction();
499
500 /**
501 * @brief updateImageMetadataAction Update meta data of a captured image
502 */
503 IPState updateImageMetadataAction(QSharedPointer<FITSData> imageData);
504
505 /**
506 * @brief runCaptureScript Run the pre-/post capture/job script
507 * @param scriptType script type (pre-/post capture/job)
508 * @param precond additional pre condition for starting the script
509 * @return IPS_BUSY, of script exists, IPS_OK otherwise
510 */
511 IPState runCaptureScript(ScriptTypes scriptType, bool precond = true);
512
513 /**
514 * @brief scriptFinished Slot managing the return status of
515 * pre/post capture/job scripts
516 */
517 void scriptFinished(int exitCode, QProcess::ExitStatus status);
518
519 /**
520 * @brief setCamera select camera device
521 * @param name Name of the camera device
522 */
523 void selectCamera(QString name);
524
525 /**
526 * @brief configureCamera Refreshes the CCD information in the capture module.
527 */
528 void checkCamera();
529
530 /**
531 * @brief syncDSLRToTargetChip Syncs INDI driver CCD_INFO property to the DSLR values.
532 * This include Max width, height, and pixel sizes.
533 * @param model Name of camera driver in the DSLR database.
534 */
535 void syncDSLRToTargetChip(const QString &model);
536
537 /**
538 * @brief reconnectDriver Reconnect the camera driver
539 */
540 void reconnectCameraDriver(const QString &camera, const QString &filterWheel);
541
542 /**
543 * @brief Generic method for removing any connected device.
544 */
545 void removeDevice(const QSharedPointer<ISD::GenericDevice> &device);
546
547 /**
548 * @brief processCaptureTimeout If exposure timed out, let's handle it.
549 */
550 void processCaptureTimeout();
551
552 /**
553 * @brief processCaptureError Handle when image capture fails
554 * @param type error type
555 */
556 void processCaptureError(ISD::Camera::ErrorType type);
557
558 /**
559 * @brief checkFlatCalibration check the flat calibration
560 * @param imageData current image data to be analysed
561 * @param exp_min minimal possible exposure time
562 * @param exp_max maximal possible exposure time
563 * @return false iff calibration has not been reached yet
564 */
565 bool checkFlatCalibration(QSharedPointer<FITSData> imageData, double exp_min, double exp_max);
566
567 /**
568 * @brief calculateFlatExpTime calculate the next flat exposure time from the measured ADU value
569 * @param currentADU ADU of the last captured frame
570 * @return next exposure time to be tried for the flat capturing
571 */
572 double calculateFlatExpTime(double currentADU);
573
574 /**
575 * @brief clearFlatCache Clear the measured values for flat calibrations
576 */
577 void clearFlatCache();
578
579 /**
580 * @brief updateTelescopeInfo Update the scope information in the camera's
581 * INDI driver.
582 */
583 void updateTelescopeInfo();
584
585 /**
586 * @brief updateFilterInfo Update the filter information in the INDI
587 * drivers of the current camera and dust cap
588 */
589 void updateFilterInfo();
590
591 /**
592 * @brief updateFITSViewer display new image in the configured FITSViewer tab.
593 */
594 void updateFITSViewer(const QSharedPointer<FITSData> data, const FITSMode &captureMode, const FITSScale &captureFilter, const QString &filename, const QString &deviceName);
595 void updateFITSViewer(const QSharedPointer<FITSData> data, ISD::CameraChip *tChip, const QString &filename);
596
597 // ////////////////////////////////////////////////////////////////////
598 // XML capture sequence file handling
599 // ////////////////////////////////////////////////////////////////////
600 /**
601 * Loads the Ekos Sequence Queue file in the Sequence Queue. Jobs are appended to existing jobs.
602 * @param fileURL full URL of the filename
603 * @param targetName override the target defined in the sequence queue file (necessary for using the target of the scheduler)
604 */
605 bool loadSequenceQueue(const QString &fileURL, const QString &targetName = "", bool setOptions = true);
606
607 /**
608 * Saves the Sequence Queue to the Ekos Sequence Queue file.
609 * @param fileURL full URL of the filename
610 */
611 bool saveSequenceQueue(const QString &path, bool loadOptions = true);
612
613 // ////////////////////////////////////////////////////////////////////
614 // helper functions
615 // ////////////////////////////////////////////////////////////////////
616
617 /**
618 * @brief checkPausing check if a pause has been planned and pause subsequently
619 * @param continueAction action to be executed when resume after pausing
620 * @return true iff capturing has been paused
621 */
622 bool checkPausing(CaptureContinueAction continueAction);
623
624 /**
625 * @brief findExecutableJob find next job to be executed
626 */
627 SequenceJob *findNextPendingJob();
628
629 // Based on John Burkardt LLSQ (LGPL)
630 void llsq(QVector<double> x, QVector<double> y, double &a, double &b);
631
632 /**
633 * @brief generateScriptArguments Generate argument list to pass to capture script
634 * @return generates argument list consisting of one argument -metadata followed by JSON-formatted key:value pair:
635 * -ts UNIX timestamp
636 * -image full path to captured image (if any)
637 * -size size of file in bytes (if any)
638 * -job {name, index}
639 * -capture {name, index}
640 * -filter
641 * TODO depending on user feedback.
642 */
643 QStringList generateScriptArguments() const;
644
645 /**
646 * @brief Does the CCD has a cooler control (On/Off) ?
647 */
648 bool hasCoolerControl();
649
650 /**
651 * @brief Set the CCD cooler ON/OFF
652 *
653 */
654 bool setCoolerControl(bool enable);
655
656 /**
657 * @brief restartCamera Restarts the INDI driver associated with a camera. Remote and Local drivers are supported.
658 * @param name Name of camera to restart. If a driver defined multiple cameras, they would be removed and added again
659 * after driver restart.
660 * @note Restarting camera should only be used as a last resort when it comes completely unresponsive. Due the complex
661 * nature of driver interactions with Ekos, restarting cameras can lead to unexpected behavior.
662 */
663 void restartCamera(const QString &name);
664
665 /**
666 * @brief frameTypes Retrieve the frame types from the active camera's primary chip.
667 */
668 QStringList frameTypes();
669 /**
670 * @brief filterLabels list of currently available filter labels
671 */
672 QStringList filterLabels();
673
674 /**
675 * @brief getGain Update the gain value from the custom property value. Depending
676 * on the camera, it is either stored as GAIN property value of CCD_GAIN or as
677 * Gain property value from CCD_CONTROLS.
678 */
679 void updateGain(double value, QMap<QString, QMap<QString, QVariant> > &propertyMap);
680
681 /**
682 * @brief getOffset Update the offset value from the custom property value. Depending
683 * on the camera, it is either stored as OFFSET property value of CCD_OFFSET or as
684 * Offset property value from CCD_CONTROLS.
685 */
686 void updateOffset(double value, QMap<QString, QMap<QString, QVariant> > &propertyMap);
687
688
689 // ////////////////////////////////////////////////////////////////////
690 // attributes access
691 // ////////////////////////////////////////////////////////////////////
692 QProcess &captureScript()
693 {
694 return m_CaptureScript;
695 }
696
697signals:
698 // controls for capture execution
699 void addJob (SequenceJob *job);
700 void createJob(SequenceJob::SequenceJobType jobtype = SequenceJob::JOBTYPE_BATCH);
701 void jobStarting();
702 void stopCapture(CaptureState targetState = CAPTURE_IDLE);
703 void captureAborted(double exposureSeconds);
704 void captureStopped();
705 void requestAction(CaptureWorkflowActionType action);
706 void syncGUIToJob(SequenceJob *job);
707 void updateFrameProperties(int reset);
708 void updateJobTable(SequenceJob *job, bool full = false);
709 void jobExecutionPreparationStarted();
710 void jobPrepared(SequenceJob *job);
711 void captureImageStarted();
712 void captureTarget(QString targetName);
713 void captureRunning();
714 void newExposureProgress(SequenceJob *job);
715 void newDownloadProgress(double downloadTimeLeft);
716 void downloadingFrame();
717 void updateCaptureCountDown(int deltaMS);
718 void darkFrameCompleted();
719 void updateMeridianFlipStage(MeridianFlipState::MFStage stage);
720 void cameraReady();
721 void refreshCamera(bool isValid);
722 void refreshCameraSettings();
723 void refreshFilterSettings();
724 void processingFITSfinished(bool success);
725 void rotatorReverseToggled(bool enabled);
726 // communication with other modules
727 void newImage(SequenceJob *job, const QSharedPointer<FITSData> &data);
728 void newView(const QSharedPointer<FITSView> &view);
729 void suspendGuiding();
730 void resumeGuiding();
731 void abortFocus();
732 void captureComplete(const QVariantMap &metadata);
733 void sequenceChanged(const QJsonArray &sequence);
734 void driverTimedout(const QString &deviceName);
735 // new log text for the module log window
736 void newLog(const QString &text);
737
738
739private:
740 QSharedPointer<CameraState> m_State;
741 QSharedPointer<CaptureDeviceAdaptor> m_DeviceAdaptor;
742 QPointer<DarkProcessor> m_DarkProcessor;
743 QSharedPointer<FITSViewer> m_FITSViewerWindow;
744 FitsvViewerTabIDs m_fitsvViewerTabIDs = {-1, -1, -1, -1, -1};
745
746 // Pre-/post capture script process
747 QProcess m_CaptureScript;
748 QString m_Scope;
749 // Flat field automation
750 QVector<double> ExpRaw, ADURaw;
751 ADUAlgorithm targetADUAlgorithm { ADU_LEAST_SQUARES };
752
753
754 /**
755 * @brief activeJob Shortcut for the module state
756 */
757 QSharedPointer<CameraState> state() const
758 {
759 return m_State;
760 }
761
762 /**
763 * @brief activeJob Shortcut to device adapter
764 */
765 QSharedPointer<CaptureDeviceAdaptor> devices()
766 {
767 return m_DeviceAdaptor;
768 }
769
770 /**
771 * @brief Get or Create FITSViewer if we are using FITSViewer
772 * or if capture mode is calibrate since for now we are forced to open the file in the viewer
773 * this should be fixed in the future and should only use FITSData.
774 */
775 QSharedPointer<FITSViewer> getFITSViewer();
776
777 /**
778 * @brief activeJob Shortcut to the active job held in the state machine
779 */
780 SequenceJob *activeJob()
781 {
782 return state()->getActiveJob();
783 }
784
785 /**
786 * @brief activeCamera Shortcut to the active camera held in the device adaptor
787 */
788 ISD::Camera *activeCamera();
789
790 /**
791 * @brief resetAllJobs Iterate over all jobs and reset them.
792 */
793 void resetAllJobs();
794 /**
795 * @brief resetJobStatus Reset a single job to the given status
796 */
797 void resetJobStatus(JOBStatus newStatus);
798 /**
799 * @brief updatedCaptureCompleted Update the completed captures count to the given
800 * number.
801 */
802 void updatedCaptureCompleted(int count);
803 /**
804 * @brief captureImageWithDelay Helper function that starts the sequence delay timer
805 * for starting to capture after the configured delay.
806 */
807 IPState captureImageWithDelay();
808 /**
809 * @brief saveReceivedImage Save the received image if the state allows it
810 * @return true iff everything worked as expected
811 */
812 bool checkSavingReceivedImage(const QSharedPointer<FITSData> &data, const QString &extension, QString &filename);
813
814 /**
815 * @brief createTabText Create the tab to be displayed in the FITSViewer tab
816 */
817 QString createTabTitle(const FITSMode &captureMode, const QString &deviceName);
818};
819} // Ekos namespace
Ekos::CameraProcess
The CameraProcess class holds the entire business logic to control capturing execution.
Definition cameraprocess.h:113
Ekos::CameraProcess::runCaptureScript
IPState runCaptureScript(ScriptTypes scriptType, bool precond=true)
runCaptureScript Run the pre-/post capture/job script
Definition cameraprocess.cpp:1820
Ekos::CameraProcess::updateTelescopeInfo
void updateTelescopeInfo()
updateTelescopeInfo Update the scope information in the camera's INDI driver.
Definition cameraprocess.cpp:2404
Ekos::CameraProcess::processCaptureTimeout
void processCaptureTimeout()
processCaptureTimeout If exposure timed out, let's handle it.
Definition cameraprocess.cpp:2064
Ekos::CameraProcess::setMount
bool setMount(ISD::Mount *device)
setMount Connect to the given mount device (and deconnect the old one if existing)
Definition cameraprocess.cpp:83
Ekos::CameraProcess::setExposureProgress
void setExposureProgress(ISD::CameraChip *tChip, double value, IPState state)
setExposureProgress Manage exposure progress reported by the camera device.
Definition cameraprocess.cpp:1555
Ekos::CameraProcess::startNextExposure
IPState startNextExposure()
startNextExposure Ensure that all pending preparation tasks are be completed (focusing,...
Definition cameraprocess.cpp:896
Ekos::CameraProcess::updatePreCaptureCalibrationStatus
void updatePreCaptureCalibrationStatus()
updatePreCaptureCalibrationStatus This is a wrapping loop for processPreCaptureCalibrationStage(),...
Definition cameraprocess.cpp:1302
Ekos::CameraProcess::reconnectCameraDriver
void reconnectCameraDriver(const QString &camera, const QString &filterWheel)
reconnectDriver Reconnect the camera driver
Definition cameraprocess.cpp:1961
Ekos::CameraProcess::checkLightFramePendingTasks
IPState checkLightFramePendingTasks()
Check all tasks that might be pending before capturing may start.
Definition cameraprocess.cpp:772
Ekos::CameraProcess::checkNextExposure
void checkNextExposure()
checkNextExposure Try to start capturing the next exposure (
Definition cameraprocess.cpp:870
Ekos::CameraProcess::clearFlatCache
void clearFlatCache()
clearFlatCache Clear the measured values for flat calibrations
Definition cameraprocess.cpp:2398
Ekos::CameraProcess::loadSequenceQueue
bool loadSequenceQueue(const QString &fileURL, const QString &targetName="", bool setOptions=true)
Loads the Ekos Sequence Queue file in the Sequence Queue.
Definition cameraprocess.cpp:2563
Ekos::CameraProcess::setFilterWheel
bool setFilterWheel(ISD::FilterWheel *device)
setFilterWheel Connect to the given filter wheel device (and deconnect the old one if existing)
Definition cameraprocess.cpp:2621
Ekos::CameraProcess::startNextPendingJob
void startNextPendingJob()
startNextPendingJob Start the next pending job.
Definition cameraprocess.cpp:253
Ekos::CameraProcess::resetFrame
Q_SCRIPTABLE void resetFrame()
resetFrame Reset frame settings of the camera
Definition cameraprocess.cpp:1545
Ekos::CameraProcess::saveSequenceQueue
bool saveSequenceQueue(const QString &path, bool loadOptions=true)
Saves the Sequence Queue to the Ekos Sequence Queue file.
Definition cameraprocess.cpp:2588
Ekos::CameraProcess::generateScriptArguments
QStringList generateScriptArguments() const
generateScriptArguments Generate argument list to pass to capture script
Definition cameraprocess.cpp:2782
Ekos::CameraProcess::previewImageCompletedAction
IPState previewImageCompletedAction()
previewImageCompletedAction Activities required when a preview image has been captured.
Definition cameraprocess.cpp:1688
Ekos::CameraProcess::setDome
bool setDome(ISD::Dome *device)
setDome Connect to the given dome device
Definition cameraprocess.cpp:157
Ekos::CameraProcess::setCoolerControl
bool setCoolerControl(bool enable)
Set the CCD cooler ON/OFF.
Definition cameraprocess.cpp:2796
Ekos::CameraProcess::setScope
void setScope(const QString &name)
setScope Set active train telescope name
Definition cameraprocess.h:190
Ekos::CameraProcess::prepareActiveJobStage1
void prepareActiveJobStage1()
prepareActiveJobStage1 Check for pre job script to execute.
Definition cameraprocess.cpp:627
Ekos::CameraProcess::updateCompletedCaptureCountersAction
void updateCompletedCaptureCountersAction()
updateCompletedCaptureCounters Update counters if an image has been captured
Definition cameraprocess.cpp:1706
Ekos::CameraProcess::scriptFinished
void scriptFinished(int exitCode, QProcess::ExitStatus status)
scriptFinished Slot managing the return status of pre/post capture/job scripts
Definition cameraprocess.cpp:1838
Ekos::CameraProcess::setRotator
bool setRotator(ISD::Rotator *device)
setRotator Connect to the given rotator device (and deconnect the old one if existing)
Definition cameraprocess.cpp:106
Ekos::CameraProcess::selectCamera
void selectCamera(QString name)
setCamera select camera device
Definition cameraprocess.cpp:1891
Ekos::CameraProcess::executeJob
Q_SCRIPTABLE void executeJob()
executeJob Start the execution of activeJob by initiating updatePreCaptureCalibrationStatus().
Definition cameraprocess.cpp:670
Ekos::CameraProcess::findNextPendingJob
SequenceJob * findNextPendingJob()
findExecutableJob find next job to be executed
Definition cameraprocess.cpp:2651
Ekos::CameraProcess::stopCapturing
void stopCapturing(CaptureState targetState)
stopCapturing Stopping the entire capturing state (envelope for aborting, suspending,...
Definition cameraprocess.cpp:320
Ekos::CameraProcess::updateFilterInfo
void updateFilterInfo()
updateFilterInfo Update the filter information in the INDI drivers of the current camera and dust cap
Definition cameraprocess.cpp:2423
Ekos::CameraProcess::processPreCaptureCalibrationStage
IPState processPreCaptureCalibrationStage()
processPreCaptureCalibrationStage Execute the tasks that need to be completed before capturing may st...
Definition cameraprocess.cpp:1262
Ekos::CameraProcess::setCamera
bool setCamera(ISD::Camera *device)
setCamera Connect to the given camera device (and deconnect the old one if existing)
Definition cameraprocess.cpp:167
Ekos::CameraProcess::checkCamera
void checkCamera()
configureCamera Refreshes the CCD information in the capture module.
Definition cameraprocess.cpp:1910
Ekos::CameraProcess::updateGain
void updateGain(double value, QMap< QString, QMap< QString, QVariant > > &propertyMap)
getGain Update the gain value from the custom property value.
Definition cameraprocess.cpp:2839
Ekos::CameraProcess::filterLabels
QStringList filterLabels()
filterLabels list of currently available filter labels
Definition cameraprocess.cpp:2831
Ekos::CameraProcess::setLightBox
bool setLightBox(ISD::LightBox *device)
setLightBox Connect to the given dust cap device (and deconnect the old one if existing)
Definition cameraprocess.cpp:146
Ekos::CameraProcess::toggleSequence
Q_SCRIPTABLE void toggleSequence()
toggleSequence Toggle sequence state depending on its current state.
Definition cameraprocess.cpp:219
Ekos::CameraProcess::startNextJob
IPState startNextJob()
startNextJob Select the next job that is either idle or aborted and call prepareJob(*SequenceJob) to ...
Definition cameraprocess.cpp:1386
Ekos::CameraProcess::checkPausing
bool checkPausing(CaptureContinueAction continueAction)
checkPausing check if a pause has been planned and pause subsequently
Definition cameraprocess.cpp:2634
Ekos::CameraProcess::prepareActiveJobStage2
void prepareActiveJobStage2()
prepareActiveJobStage2 Reset #calibrationStage and continue with preparePreCaptureActions().
Definition cameraprocess.cpp:643
Ekos::CameraProcess::showFITSPreview
void showFITSPreview(const QSharedPointer< FITSData > &data)
showFITSPreview Directly show the FITS data as preview
Definition cameraprocess.cpp:1243
Ekos::CameraProcess::removeDevice
void removeDevice(const QSharedPointer< ISD::GenericDevice > &device)
Generic method for removing any connected device.
Definition cameraprocess.cpp:1988
Ekos::CameraProcess::resumeSequence
IPState resumeSequence()
resumeSequence Try to continue capturing.
Definition cameraprocess.cpp:920
Ekos::CameraProcess::startJob
void startJob(SequenceJob *job)
startJob Start the execution of a selected sequence job:
Definition cameraprocess.cpp:443
Ekos::CameraProcess::refreshOpticalTrain
void refreshOpticalTrain(QString name)
refreshOpticalTrain Refresh the devices from the optical train configuration
Definition cameraprocess.cpp:746
Ekos::CameraProcess::frameTypes
QStringList frameTypes()
frameTypes Retrieve the frame types from the active camera's primary chip.
Definition cameraprocess.cpp:2821
Ekos::CameraProcess::updateOffset
void updateOffset(double value, QMap< QString, QMap< QString, QVariant > > &propertyMap)
getOffset Update the offset value from the custom property value.
Definition cameraprocess.cpp:2873
Ekos::CameraProcess::capturePreview
void capturePreview(bool loop=false)
capturePreview Capture a preview (single or looping ones)
Definition cameraprocess.cpp:297
Ekos::CameraProcess::processJobCompletion2
void processJobCompletion2()
processJobCompletionStage2 Stop execution of the current sequence and check whether there exists a ne...
Definition cameraprocess.cpp:1340
Ekos::CameraProcess::checkFlatCalibration
bool checkFlatCalibration(QSharedPointer< FITSData > imageData, double exp_min, double exp_max)
checkFlatCalibration check the flat calibration
Definition cameraprocess.cpp:2163
Ekos::CameraProcess::updateImageMetadataAction
IPState updateImageMetadataAction(QSharedPointer< FITSData > imageData)
updateImageMetadataAction Update meta data of a captured image
Definition cameraprocess.cpp:1753
Ekos::CameraProcess::captureStarted
void captureStarted(CaptureResult rc)
captureStarted Manage the result when capturing has been started
Definition cameraprocess.cpp:822
Ekos::CameraProcess::processFITSData
void processFITSData(const QSharedPointer< FITSData > &data, const QString &extension)
newFITS process new FITS data received from camera.
Definition cameraprocess.cpp:1036
Ekos::CameraProcess::jobCreated
void jobCreated(SequenceJob *newJob)
Counterpart to the event {.
Definition cameraprocess.cpp:274
Ekos::CameraProcess::prepareJob
void prepareJob(SequenceJob *job)
prepareJob Update the counters of existing frames and continue with prepareActiveJob(),...
Definition cameraprocess.cpp:449
Ekos::CameraProcess::processNewRemoteFile
void processNewRemoteFile(QString file)
setNewRemoteFile A new image has been stored as remote file
Definition cameraprocess.cpp:1250
Ekos::CameraProcess::pauseCapturing
Q_SCRIPTABLE void pauseCapturing()
pauseCapturing Pauses capturing as soon as the current capture is complete.
Definition cameraprocess.cpp:426
Ekos::CameraProcess::updateDownloadTimesAction
IPState updateDownloadTimesAction()
updateDownloadTimesAction Add the current download time to the list of already measured ones
Definition cameraprocess.cpp:1668
Ekos::CameraProcess::calculateFlatExpTime
double calculateFlatExpTime(double currentADU)
calculateFlatExpTime calculate the next flat exposure time from the measured ADU value
Definition cameraprocess.cpp:2287
Ekos::CameraProcess::processCaptureError
void processCaptureError(ISD::Camera::ErrorType type)
processCaptureError Handle when image capture fails
Definition cameraprocess.cpp:2131
Ekos::CameraProcess::continueFramingAction
IPState continueFramingAction(const QSharedPointer< FITSData > &imageData)
continueFramingAction If framing is running, start the next capture sequence
Definition cameraprocess.cpp:1645
Ekos::CameraProcess::syncDSLRToTargetChip
void syncDSLRToTargetChip(const QString &model)
syncDSLRToTargetChip Syncs INDI driver CCD_INFO property to the DSLR values.
Definition cameraprocess.cpp:1941
Ekos::CameraProcess::setDownloadProgress
void setDownloadProgress()
setDownloadProgress update the Capture Module and Summary Screen's estimate of how much time is left ...
Definition cameraprocess.cpp:1629
Ekos::CameraProcess::prepareJobExecution
void prepareJobExecution()
preparePreCaptureActions Trigger setting the filter, temperature, (if existing) the rotator angle and...
Definition cameraprocess.cpp:724
Ekos::CameraProcess::updateFITSViewer
void updateFITSViewer(const QSharedPointer< FITSData > data, const FITSMode &captureMode, const FITSScale &captureFilter, const QString &filename, const QString &deviceName)
updateFITSViewer display new image in the configured FITSViewer tab.
Definition cameraprocess.cpp:2490
Ekos::CameraProcess::processJobCompletion1
void processJobCompletion1()
processJobCompletionStage1 Process job completion.
Definition cameraprocess.cpp:1324
Ekos::CameraProcess::captureImage
void captureImage()
captureImage Initiates image capture in the active job.
Definition cameraprocess.cpp:1422
Ekos::CameraProcess::setDustCap
bool setDustCap(ISD::DustCap *device)
setDustCap Connect to the given dust cap device (and deconnect the old one if existing)
Definition cameraprocess.cpp:133
Ekos::CameraProcess::restartCamera
void restartCamera(const QString &name)
restartCamera Restarts the INDI driver associated with a camera.
Definition cameraprocess.cpp:2804
Ekos::CameraProcess::hasCoolerControl
bool hasCoolerControl()
Does the CCD has a cooler control (On/Off) ?
Definition cameraprocess.cpp:2788
Ekos::CameraProcess::toggleVideo
void toggleVideo(bool enabled)
Toggle video streaming if supported by the device.
Definition cameraprocess.cpp:190
FITSViewer
Primary window to view monochrome and color FITS images.
Definition fitsviewer.h:54
ISD::CameraChip
CameraChip class controls a particular chip in camera.
Definition indicamerachip.h:23
ISD::Camera
Camera class controls an INDI Camera device.
Definition indicamera.h:45
ISD::Dome
Class handles control of INDI dome devices.
Definition indidome.h:25
ISD::DustCap
Handles operation of a remotely controlled dust cover cap.
Definition indidustcap.h:25
ISD::LightBox
Handles operation of a remotely controlled light box.
Definition indilightbox.h:21
ISD::Mount
device handle controlling Mounts.
Definition indimount.h:29
ISD::Rotator
Rotator class handles control of INDI Rotator devices.
Definition indirotator.h:20
SequenceJob
Sequence Job is a container for the details required to capture a series of images.
Ekos
Ekos is an advanced Astrophotography tool for Linux.
Definition align.cpp:83
Ekos::CaptureState
CaptureState
Capture states.
Definition ekos.h:92
Ekos::CAPTURE_IDLE
@ CAPTURE_IDLE
Definition ekos.h:93
Ekos::ScriptTypes
ScriptTypes
Definition ekos.h:173
QObject::Q_OBJECT
Q_OBJECTQ_OBJECT
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri Dec 13 2024 11:47:11 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.