Kstars

filtermanager.cpp
1/*
2 SPDX-FileCopyrightText: 2017 Jasem Mutlaq <mutlaqja@ikarustech.com>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include "buildfilteroffsets.h"
8#include <kstars_debug.h>
9
10#include "indi_debug.h"
11#include "kstarsdata.h"
12#include "kstars.h"
13#include "ekos/focus/focus.h"
14#include "ekos/manager.h"
15#include "Options.h"
16#include "auxiliary/kspaths.h"
17#include "auxiliary/ksmessagebox.h"
18#include "ekos/auxiliary/tabledelegate.h"
19
20#include <QTimer>
21#include <QSqlTableModel>
22#include <QSqlDatabase>
23#include <QSqlRecord>
24
25#include <basedevice.h>
26
27#include <algorithm>
28
29namespace Ekos
30{
31
32FilterManager::FilterManager(QWidget *parent) : QDialog(parent)
33{
34#ifdef Q_OS_MACOS
35 setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
36#endif
37
38 setupUi(this);
39
40 connect(buttonBox, SIGNAL(accepted()), this, SLOT(close()));
41 connect(buttonBox, SIGNAL(rejected()), this, SLOT(close()));
42
43 connect(buildOffsetsButton, &QPushButton::clicked, this, &FilterManager::buildFilterOffsets);
44
45 kcfg_FlatSyncFocus->setChecked(Options::flatSyncFocus());
46 connect(kcfg_FlatSyncFocus, &QCheckBox::toggled, this, [this]()
47 {
48 Options::setFlatSyncFocus(kcfg_FlatSyncFocus->isChecked());
49 });
50
51 // 30 second timeout for filter change
52 m_FilterChangeTimeout.setSingleShot(true);
53 m_FilterChangeTimeout.setInterval(30000);
54 connect(&m_FilterChangeTimeout, &QTimer::timeout, this, &FilterManager::checkFilterChangeTimeout);
55
56 createFilterModel();
57
58 // No Edit delegate
59 noEditDelegate = new NotEditableDelegate(m_FilterView);
60 m_FilterView->setItemDelegateForColumn(FM_LABEL, noEditDelegate);
61
62 // Exposure delegate
63 exposureDelegate = new DoubleDelegate(m_FilterView, 0.001, 3600, 1);
64 m_FilterView->setItemDelegateForColumn(FM_EXPOSURE, exposureDelegate);
65
66 // Offset delegate
67 offsetDelegate = new IntegerDelegate(m_FilterView, -10000, 10000, 1);
68 m_FilterView->setItemDelegateForColumn(FM_OFFSET, offsetDelegate);
69
70 // Auto Focus delegate
71 useAutoFocusDelegate = new ToggleDelegate(m_FilterView);
72 m_FilterView->setItemDelegateForColumn(FM_AUTO_FOCUS, useAutoFocusDelegate);
73
74 // Set Delegates
75 lockDelegate = new ComboDelegate(m_FilterView);
76 m_FilterView->setItemDelegateForColumn(FM_LOCK_FILTER, lockDelegate);
77 lockDelegate->setValues(getLockDelegates());
78
79 // Last AF solution delegate. Set by Autofocus but make editable in case bad data
80 // corrections need to be made
81 lastAFSolutionDelegate = new IntegerDelegate(m_FilterView, 0, 1000000, 1);
82 m_FilterView->setItemDelegateForColumn(FM_LAST_AF_SOLUTION, lastAFSolutionDelegate);
83
84 // Last AF solution temperature delegate
85 lastAFTempDelegate = new DoubleDelegate(m_FilterView, -60.0, 60.0, 1.0);
86 m_FilterView->setItemDelegateForColumn(FM_LAST_AF_TEMP, lastAFTempDelegate);
87
88 // Last AF solution altitude delegate
89 lastAFAltDelegate = new DoubleDelegate(m_FilterView, 0.0, 90.0, 1.0);
90 m_FilterView->setItemDelegateForColumn(FM_LAST_AF_ALT, lastAFAltDelegate);
91
92 // Last AF solution datetime delegate
93 lastAFDTDelegate = new DatetimeDelegate(m_FilterView, DATETIME_FORMAT, "2025-01-01", "2100-01-01", false);
94 m_FilterView->setItemDelegateForColumn(FM_LAST_AF_DATETIME, lastAFDTDelegate);
95
96 // Ticks / °C delegate
97 ticksPerTempDelegate = new DoubleDelegate(m_FilterView, -10000.0, 10000.0, 1.0);
98 m_FilterView->setItemDelegateForColumn(FM_TICKS_PER_TEMP, ticksPerTempDelegate);
99
100 // Ticks / °Altitude delegate
101 ticksPerAltDelegate = new DoubleDelegate(m_FilterView, -10000.0, 10000.0, 1.0);
102 m_FilterView->setItemDelegateForColumn(FM_TICKS_PER_ALT, ticksPerAltDelegate);
103
104 // Wavelength delegate
105 wavelengthDelegate = new IntegerDelegate(m_FilterView, 200, 1000, 50);
106 m_FilterView->setItemDelegateForColumn(FM_WAVELENGTH, wavelengthDelegate);
107}
108
109void FilterManager::createFilterModel()
110{
111 QSqlDatabase userdb = QSqlDatabase::database(KStarsData::Instance()->userdb()->connectionName());
112
113 m_FilterModel = new QSqlTableModel(this, userdb);
114 m_FilterView->setModel(m_FilterModel);
115 m_FilterModel->setTable("filter");
116 m_FilterModel->setEditStrategy(QSqlTableModel::OnFieldChange);
117
118 m_FilterModel->setHeaderData(FM_LABEL, Qt::Horizontal, i18n("Filter"));
119
120 m_FilterModel->setHeaderData(FM_EXPOSURE, Qt::Horizontal, i18n("Filter exposure time during focus"), Qt::ToolTipRole);
121 m_FilterModel->setHeaderData(FM_EXPOSURE, Qt::Horizontal, i18n("Exposure"));
122
123 m_FilterModel->setHeaderData(FM_OFFSET, Qt::Horizontal, i18n("Relative offset in steps"), Qt::ToolTipRole);
124 m_FilterModel->setHeaderData(FM_OFFSET, Qt::Horizontal, i18n("Offset"));
125
126 m_FilterModel->setHeaderData(FM_AUTO_FOCUS, Qt::Horizontal, i18n("Start Auto Focus when filter is activated"),
127 Qt::ToolTipRole);
128 m_FilterModel->setHeaderData(FM_AUTO_FOCUS, Qt::Horizontal, i18n("Auto Focus"));
129
130 m_FilterModel->setHeaderData(FM_LOCK_FILTER, Qt::Horizontal, i18n("Lock specific filter when running Auto Focus"),
131 Qt::ToolTipRole);
132 m_FilterModel->setHeaderData(FM_LOCK_FILTER, Qt::Horizontal, i18n("Lock Filter"));
133
134 m_FilterModel->setHeaderData(FM_LAST_AF_SOLUTION, Qt::Horizontal,
135 i18n("Last AF solution. Updated automatically by the autofocus process."), Qt::ToolTipRole);
136 m_FilterModel->setHeaderData(FM_LAST_AF_SOLUTION, Qt::Horizontal, i18n("Last AF Solution"));
137
138 m_FilterModel->setHeaderData(FM_LAST_AF_TEMP, Qt::Horizontal,
139 i18n("The temperature of the last AF solution. Updated automatically by the autofocus process."), Qt::ToolTipRole);
140 m_FilterModel->setHeaderData(FM_LAST_AF_TEMP, Qt::Horizontal, i18n("Last AF Temp (°C)"));
141
142 m_FilterModel->setHeaderData(FM_LAST_AF_ALT, Qt::Horizontal,
143 i18n("The altitude of the last AF solution. Updated automatically by the autofocus process."), Qt::ToolTipRole);
144 m_FilterModel->setHeaderData(FM_LAST_AF_ALT, Qt::Horizontal, i18n("Last AF Alt (°Alt)"));
145
146 m_FilterModel->setHeaderData(FM_LAST_AF_DATETIME, Qt::Horizontal,
147 i18n("The datetime of the last AF solution. Updated automatically by the autofocus process."), Qt::ToolTipRole);
148 m_FilterModel->setHeaderData(FM_LAST_AF_DATETIME, Qt::Horizontal, i18n("Last AF Datetime"));
149
150 m_FilterModel->setHeaderData(FM_TICKS_PER_TEMP, Qt::Horizontal,
151 i18n("The number of ticks per °C increase in temperature. +ve for outward focuser movement"), Qt::ToolTipRole);
152 m_FilterModel->setHeaderData(FM_TICKS_PER_TEMP, Qt::Horizontal, i18n("Ticks / °C"));
153
154 m_FilterModel->setHeaderData(FM_TICKS_PER_ALT, Qt::Horizontal,
155 i18n("The number of ticks per degree increase in altitude. +ve for outward focuser movement"), Qt::ToolTipRole);
156 m_FilterModel->setHeaderData(FM_TICKS_PER_ALT, Qt::Horizontal, i18n("Ticks / °Alt"));
157
158 m_FilterModel->setHeaderData(FM_WAVELENGTH, Qt::Horizontal, i18n("Mid-point wavelength of filter in nm"), Qt::ToolTipRole);
159 m_FilterModel->setHeaderData(FM_WAVELENGTH, Qt::Horizontal, i18n("Wavelength"));
160
161 connect(m_FilterModel, &QSqlTableModel::dataChanged, this, &FilterManager::updated);
162
163 connect(m_FilterModel, &QSqlTableModel::dataChanged, this, [this](const QModelIndex & topLeft, const QModelIndex &,
164 const QVector<int> &)
165 {
166 reloadFilters();
167 if (topLeft.column() == FM_EXPOSURE)
168 emit exposureChanged(m_FilterModel->data(topLeft).toDouble());
169 else if (topLeft.column() == FM_LOCK_FILTER)
170 {
171 // Don't allow the lock filter to be set to the current filter - circular dependancy
172 // Don't allow the lock to be set if this filter is a lock for another filter - nested dependancy
173 QString lock = m_FilterModel->data(m_FilterModel->index(topLeft.row(), topLeft.column())).toString();
174 QString filter = m_FilterModel->data(m_FilterModel->index(topLeft.row(), FM_LABEL)).toString();
175 bool alreadyALock = false;
176 for (int i = 0; i < m_ActiveFilters.count(); i++)
177 {
178 if (m_ActiveFilters[i]->lockedFilter() == filter)
179 {
180 alreadyALock = true;
181 break;
182 }
183 }
184 if (alreadyALock || (lock == filter))
185 {
186 m_FilterModel->setData(m_FilterModel->index(topLeft.row(), topLeft.column()), NULL_FILTER);
187 }
188 // Update the acceptable values in the lockDelegate
189 lockDelegate->setValues(getLockDelegates());
190 }
191 else if (topLeft.column() == FM_TICKS_PER_TEMP)
192 emit ticksPerTempChanged();
193 else if (topLeft.column() == FM_TICKS_PER_ALT)
194 emit ticksPerAltChanged();
195 else if (topLeft.column() == FM_WAVELENGTH)
196 emit wavelengthChanged();
197 });
198}
199
200void FilterManager::refreshFilterModel()
201{
202 if (m_FilterWheel == nullptr || m_currentFilterLabels.empty())
203 return;
204
205 // In case filter model was cleared due to a device disconnect
206 if (m_FilterModel == nullptr)
207 createFilterModel();
208
209 QString vendor(m_FilterWheel->getDeviceName());
210 m_FilterModel->setFilter(QString("vendor='%1'").arg(vendor));
211 m_FilterModel->select();
212
213 m_FilterView->hideColumn(0);
214 m_FilterView->hideColumn(1);
215 m_FilterView->hideColumn(2);
216 m_FilterView->hideColumn(3);
217
218 // If we have an existing table but it doesn't match the number of current filters
219 // then we remove it.
220 if (m_FilterModel->rowCount() > 0 && m_FilterModel->rowCount() != m_currentFilterLabels.count())
221 {
222 for (int i = 0; i < m_FilterModel->rowCount(); i++)
223 m_FilterModel->removeRow(i);
224
225 m_FilterModel->select();
226 }
227
228 // If it is first time, let's populate data
229 if (m_FilterModel->rowCount() == 0)
230 {
231 filterProperties *fp = new filterProperties(vendor, "", "", "");
232 for (QString &filter : m_currentFilterLabels)
233 {
234 fp->color = filter;
235 KStarsData::Instance()->userdb()->AddFilter(fp);
236 }
237
238 m_FilterModel->select();
239 }
240 // Make sure all the filter colors match DB. If not update model to sync with INDI filter values
241 else
242 {
243 for (int i = 0; i < m_FilterModel->rowCount(); ++i)
244 {
245 QModelIndex index = m_FilterModel->index(i, FM_LABEL);
246 if (m_FilterModel->data(index).toString() != m_currentFilterLabels[i])
247 {
248 m_FilterModel->setData(index, m_currentFilterLabels[i]);
249 }
250 }
251 }
252
253 lockDelegate->setValues(getLockDelegates());
254
255 reloadFilters();
256 resizeDialog();
257}
258
259void FilterManager::resizeDialog()
260{
261 // Resize the columns to the data and then the dialog to the rows and columns
262 m_FilterView->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
263 int width = m_FilterView->horizontalHeader()->length() + 50;
264 int height = label->height() + m_FilterView->verticalHeader()->length() + label_2->height() + buttonBox->height() + 100;
265 this->resize(width, height);
266}
267// This function processes the list of active filters and returns a list of filters that could be lock filters
268// i.e. that don't themselves have locks.
269QStringList FilterManager::getLockDelegates()
270{
271 QStringList lockDelegates;
272
273 for (int i = 0; i < m_ActiveFilters.count(); i++)
274 {
275 if (m_ActiveFilters[i]->lockedFilter() == NULL_FILTER)
276 lockDelegates.append(m_ActiveFilters[i]->color());
277 }
278 return lockDelegates;
279}
280
281void FilterManager::reloadFilters()
282{
283 qDeleteAll(m_ActiveFilters);
284 currentFilter = nullptr;
285 targetFilter = nullptr;
286 m_ActiveFilters.clear();
287 operationQueue.clear();
288
289 filterProperties *fp = new filterProperties("", "", "", "");
290
291 for (int i = 0; i < m_FilterModel->rowCount(); ++i)
292 {
293 QSqlRecord record = m_FilterModel->record(i);
294 QString id = record.value("id").toString();
295
296 fp->vendor = record.value("Vendor").toString();
297 fp->model = record.value("Model").toString();
298 fp->type = record.value("Type").toString();
299 fp->color = record.value("Color").toString();
300 fp->exposure = record.value("Exposure").toDouble();
301 fp->offset = record.value("Offset").toInt();
302 fp->lockedFilter = record.value("LockedFilter").toString();
303 fp->useAutoFocus = record.value("UseAutoFocus").toInt() == 1;
304 fp->absFocusPos = record.value("AbsoluteFocusPosition").toInt();
305 fp->focusTemperature = record.value("FocusTemperature").toDouble();
306 fp->focusAltitude = record.value("FocusAltitude").toDouble();
307 fp->focusDatetime = record.value("FocusDatetime").toString();
308 fp->focusTicksPerTemp = record.value("FocusTicksPerTemp").toDouble();
309 fp->focusTicksPerAlt = record.value("FocusTicksPerAlt").toDouble();
310 fp->wavelength = record.value("Wavelength").toInt();
311 OAL::Filter *o = new OAL::Filter(id, fp);
312 m_ActiveFilters.append(o);
313 }
314}
315
316void FilterManager::setFilterWheel(ISD::FilterWheel *filter)
317{
318 // Return if same device and we already initialized the properties.
319 if (m_FilterWheel == filter && m_FilterNameProperty && m_FilterPositionProperty)
320 return;
321 else if (m_FilterWheel)
322 m_FilterWheel->disconnect(this);
323
324 m_FilterWheel = filter;
325
326 m_FilterNameProperty = nullptr;
327 m_FilterPositionProperty = nullptr;
328 m_FilterConfirmSet = nullptr;
329
330 if (!m_FilterWheel)
331 return;
332
333 connect(m_FilterWheel, &ISD::ConcreteDevice::propertyUpdated, this, &FilterManager::updateProperty);
334 connect(m_FilterWheel, &ISD::ConcreteDevice::Disconnected, this, &FilterManager::processDisconnect);
335
336 refreshFilterProperties();
337}
338
339void FilterManager::refreshFilterProperties()
340{
341 if (m_FilterNameProperty && m_FilterPositionProperty)
342 {
343 if (m_FilterConfirmSet == nullptr)
344 m_FilterConfirmSet = m_FilterWheel->getSwitch("CONFIRM_FILTER_SET");
345
346 // All filters are synced up?
347 if (m_currentFilterLabels.count() == m_FilterNameProperty->ntp)
348 return;
349 }
350
351 filterNameLabel->setText(m_FilterWheel->getDeviceName());
352
353 m_currentFilterLabels.clear();
354
355 m_FilterNameProperty = m_FilterWheel->getText("FILTER_NAME");
356 m_FilterPositionProperty = m_FilterWheel->getNumber("FILTER_SLOT");
357 m_FilterConfirmSet = m_FilterWheel->getSwitch("CONFIRM_FILTER_SET");
358
359 refreshFilterLabels();
360 refreshFilterPosition();
361
362 if (m_currentFilterPosition >= 1 && m_currentFilterPosition <= m_ActiveFilters.count())
363 lastFilterOffset = m_ActiveFilters[m_currentFilterPosition - 1]->offset();
364}
365
366QStringList FilterManager::getFilterLabels(bool forceRefresh)
367{
368 if ((!m_currentFilterLabels.empty() && forceRefresh == false) || !m_FilterNameProperty || !m_FilterPositionProperty)
369 return m_currentFilterLabels;
370
371 QStringList filterList;
372
373 for (int i = 0; i < m_FilterPositionProperty->np[0].max; i++)
374 {
375 if (m_FilterNameProperty != nullptr && (i < m_FilterNameProperty->ntp))
376 filterList.append(m_FilterNameProperty->tp[i].text);
377 }
378
379 return filterList;
380}
381
382int FilterManager::getFilterPosition(bool forceRefresh)
383{
384 if (forceRefresh == false || m_FilterPositionProperty == nullptr)
385 return m_currentFilterPosition;
386
387 return static_cast<int>(m_FilterPositionProperty->np[0].value);
388}
389
390void FilterManager::refreshFilterLabels()
391{
392 QList filters = getFilterLabels(true);
393
394 if (filters != m_currentFilterLabels)
395 {
396 m_currentFilterLabels = filters;
397 refreshFilterModel();
398
399 emit labelsChanged(filters);
400
401 // refresh position after filter changes
402 refreshFilterPosition();
403 }
404}
405
406void FilterManager::refreshFilterPosition()
407{
408
409 int pos = getFilterPosition(true);
410 if (pos != m_currentFilterPosition)
411 {
412 m_currentFilterPosition = pos;
413 emit positionChanged(pos);
414 }
415}
416
417bool FilterManager::setFilterPosition(uint8_t position, FilterPolicy policy)
418{
419 // Position 1 to Max
420 if (position > m_ActiveFilters.count() || m_currentFilterPosition < 1 || position < 1)
421 return false;
422
423 m_Policy = policy;
424 currentFilter = m_ActiveFilters[m_currentFilterPosition - 1];
425 targetFilter = m_ActiveFilters[position - 1];
426
427 buildOperationQueue(FILTER_CHANGE);
428
429 executeOperationQueue();
430
431 return true;
432}
433
434
435void FilterManager::updateProperty(INDI::Property prop)
436{
437 if (m_FilterWheel == nullptr || m_FilterWheel->getDeviceName() != prop.getDeviceName())
438 return;
439
440 if (prop.isNameMatch("FILTER_NAME"))
441 {
442 auto tvp = prop.getText();
443 m_FilterNameProperty = tvp;
444
445 refreshFilterLabels();
446 }
447 else if (prop.isNameMatch("FILTER_SLOT"))
448 {
449 m_FilterChangeTimeout.stop();
450
451 auto nvp = prop.getNumber();
452 // If filter fails to change position while we request that
453 // fail immediately.
454 if (state == FILTER_CHANGE && nvp->s == IPS_ALERT)
455 {
456 emit failed();
457 return;
458 }
459
460 if (nvp->s != IPS_OK)
461 return;
462
463 m_FilterPositionProperty = nvp;
464 refreshFilterPosition();
465
466 if (state == FILTER_CHANGE)
467 executeOperationQueue();
468 // If filter is changed externally, record its current offset as the starting offset.
469 else if (state == FILTER_IDLE && m_ActiveFilters.count() >= m_currentFilterPosition)
470 lastFilterOffset = m_ActiveFilters[m_currentFilterPosition - 1]->offset();
471 }
472}
473
474
475void FilterManager::processDisconnect()
476{
477 m_currentFilterLabels.clear();
478 m_currentFilterPosition = -1;
479 m_FilterNameProperty = nullptr;
480 m_FilterPositionProperty = nullptr;
481}
482
483void FilterManager::buildOperationQueue(FilterState operation)
484{
485 operationQueue.clear();
486 m_useTargetFilter = false;
487
488 switch (operation)
489 {
490 case FILTER_CHANGE:
491 {
492 // Setup whether we'll run an Autofocus after the Filter Change. The normal reason is that a Filter
493 // Change has been requested but there is also a condition whereby a previous filter change worked but
494 // the associated Autofocus failed. In the latter case, the currentFilter == targetFilter so no need to
495 // change the filter but we'll still need to retry Autofocus.
496 bool runAF = false;
497 if (m_FocusReady && (m_Policy & AUTOFOCUS_POLICY) && targetFilter->useAutoFocus())
498 if ((targetFilter != currentFilter) || (m_LastAFFailed.value(targetFilter->color(), FALSE)))
499 runAF = true;
500
501 if ( (m_Policy & CHANGE_POLICY) && targetFilter != currentFilter)
502 m_useTargetFilter = true;
503
504 if (m_useTargetFilter)
505 {
506 operationQueue.enqueue(FILTER_CHANGE);
507 if (m_FocusReady && (m_Policy & OFFSET_POLICY))
508 operationQueue.enqueue(FILTER_OFFSET);
509 else
510 {
511 // Keep track of filter and offset either here or after the offset has been processed
512 lastFilterOffset = targetFilter->offset();
513 currentFilter = targetFilter;
514 }
515
516 }
517
518 if (runAF)
519 operationQueue.enqueue(FILTER_AUTOFOCUS);
520 }
521 break;
522
523 default:
524 break;
525 }
526}
527
528bool FilterManager::executeOperationQueue()
529{
530 if (operationQueue.isEmpty())
531 {
532 state = FILTER_IDLE;
533 emit newStatus(state);
534 emit ready();
535 return false;
536 }
537
538 FilterState nextOperation = operationQueue.dequeue();
539
540 bool actionRequired = true;
541
542 switch (nextOperation)
543 {
544 case FILTER_CHANGE:
545 {
546 m_FilterChangeTimeout.stop();
547
548 if (m_ConfirmationPending)
549 return true;
550
551 state = FILTER_CHANGE;
552 if (m_useTargetFilter)
553 targetFilterPosition = m_ActiveFilters.indexOf(targetFilter) + 1;
554 m_FilterWheel->setPosition(targetFilterPosition);
555
556 emit newStatus(state);
557
558 if (m_FilterConfirmSet)
559 {
560 connect(KSMessageBox::Instance(), &KSMessageBox::accepted, this, [this]()
561 {
562 KSMessageBox::Instance()->disconnect(this);
563 m_ConfirmationPending = false;
564 m_FilterWheel->confirmFilter();
565 });
566 connect(KSMessageBox::Instance(), &KSMessageBox::rejected, this, [this]()
567 {
568 KSMessageBox::Instance()->disconnect(this);
569 m_ConfirmationPending = false;
570 });
571
572 m_ConfirmationPending = true;
573
574 KSMessageBox::Instance()->questionYesNo(i18n("Set filter to %1. Is filter set?", targetFilter->color()),
575 i18n("Confirm Filter"));
576 }
577 // If automatic filter change with filter wheel, we start operation timeout
578 else m_FilterChangeTimeout.start();
579 }
580 break;
581
582 case FILTER_OFFSET:
583 {
584 state = FILTER_OFFSET;
585 if (m_useTargetFilter)
586 {
587 targetFilterOffset = targetFilter->offset() - lastFilterOffset;
588 lastFilterOffset = targetFilter->offset();
589 currentFilter = targetFilter;
590 m_useTargetFilter = false;
591 }
592 if (targetFilterOffset == 0)
593 actionRequired = false;
594 else
595 {
596 emit newFocusOffset(targetFilterOffset, false);
597 emit newStatus(state);
598 }
599 }
600 break;
601
602 case FILTER_AUTOFOCUS:
603 state = FILTER_AUTOFOCUS;
604 qCDebug(KSTARS) << "FilterManager.cpp is triggering autofocus.";
605 emit newStatus(state);
606 emit runAutoFocus(AutofocusReason::FOCUS_FILTER, "");
607 break;
608
609 default:
610 break;
611 }
612
613 // If an additional action is required, return return and continue later
614 if (actionRequired)
615 return true;
616 // Otherwise, continue processing the queue
617 else
618 return executeOperationQueue();
619}
620
621bool FilterManager::executeOneOperation(FilterState operation)
622{
623 bool actionRequired = false;
624
625 switch (operation)
626 {
627 default:
628 break;
629 }
630
631 return actionRequired;
632}
633
634void FilterManager::setFocusOffsetComplete()
635{
636 if (state == FILTER_OFFSET)
637 executeOperationQueue();
638}
639
640double FilterManager::getFilterExposure(const QString &name) const
641{
642 auto filterDetails = getFilterByName(name);
643 if (filterDetails)
644 return filterDetails->exposure();
645
646 // Default value
647 return 1;
648}
649
650bool FilterManager::setFilterExposure(int index, double exposure)
651{
652 if (m_currentFilterLabels.empty())
653 return false;
654
655 QString color = m_currentFilterLabels[index];
656 for (int i = 0; i < m_ActiveFilters.count(); i++)
657 {
658 if (color == m_ActiveFilters[i]->color())
659 {
660 m_FilterModel->setData(m_FilterModel->index(i, FM_EXPOSURE), exposure);
661 m_FilterModel->submitAll();
662 refreshFilterModel();
663 return true;
664 }
665 }
666
667 return false;
668}
669
670int FilterManager::getFilterOffset(const QString &name) const
671{
672 int offset = INVALID_VALUE;
673 auto filterDetails = getFilterByName(name);
674 if (filterDetails)
675 offset = filterDetails->offset();
676
677 return offset;
678}
679
680bool FilterManager::setFilterOffset(QString color, int offset)
681{
682 if (m_currentFilterLabels.empty())
683 return false;
684
685 for (int i = 0; i < m_ActiveFilters.count(); i++)
686 {
687 if (color == m_ActiveFilters[i]->color())
688 {
689 m_FilterModel->setData(m_FilterModel->index(i, FM_OFFSET), offset);
690 m_FilterModel->submitAll();
691 refreshFilterModel();
692 return true;
693 }
694 }
695
696 return false;
697}
698
699bool FilterManager::getFilterAbsoluteFocusDetails(const QString &name, int &focusPos, double &focusTemp,
700 double &focusAlt) const
701{
702 auto filterDetails = getFilterByName(name);
703 if (filterDetails)
704 {
705 focusPos = filterDetails->absoluteFocusPosition();
706 focusTemp = filterDetails->focusTemperature();
707 focusAlt = filterDetails->focusAltitude();
708 return true;
709 }
710
711 return false;
712}
713
714bool FilterManager::setFilterAbsoluteFocusDetails(int index, int focusPos, double focusTemp, double focusAlt)
715{
716 if (index < 0 || index >= m_currentFilterLabels.count())
717 return false;
718
719 QString color = m_currentFilterLabels[index];
720 for (int i = 0; i < m_ActiveFilters.count(); i++)
721 {
722 if (color == m_ActiveFilters[i]->color())
723 {
724 m_FilterModel->setData(m_FilterModel->index(i, FM_LAST_AF_SOLUTION), focusPos);
725 m_FilterModel->setData(m_FilterModel->index(i, FM_LAST_AF_TEMP), focusTemp);
726 m_FilterModel->setData(m_FilterModel->index(i, FM_LAST_AF_ALT), focusAlt);
727 m_FilterModel->setData(m_FilterModel->index(i, FM_LAST_AF_DATETIME),
728 KStarsData::Instance()->lt().toString(DATETIME_FORMAT));
729 m_FilterModel->submitAll();
730 refreshFilterModel();
731 return true;
732 }
733 }
734
735 return false;
736}
737
738bool FilterManager::getAFDatetime(const QString &name, QDateTime &datetime) const
739{
740 auto filterDetails = getFilterByName(name);
741 if (filterDetails)
742 {
743 datetime = filterDetails->focusDatetime();
744 return true;
745 }
746 return false;
747}
748
749QString FilterManager::getFilterLock(const QString &name) const
750{
751 auto filterDetails = getFilterByName(name);
752 if (filterDetails)
753 return filterDetails->lockedFilter();
754
755 // Default value
756 return NULL_FILTER;
757}
758
759bool FilterManager::setFilterLock(int index, QString name)
760{
761 if (m_currentFilterLabels.empty())
762 return false;
763
764 QString color = m_currentFilterLabels[index];
765 for (int i = 0; i < m_ActiveFilters.count(); i++)
766 {
767 if (color == m_ActiveFilters[i]->color())
768 {
769 m_FilterModel->setData(m_FilterModel->index(i, FM_LOCK_FILTER), name);
770 m_FilterModel->submitAll();
771 refreshFilterModel();
772 return true;
773 }
774 }
775
776 return false;
777}
778
779int FilterManager::getFilterWavelength(const QString &name) const
780{
781 auto filterDetails = getFilterByName(name);
782 if (filterDetails)
783 return filterDetails->wavelength();
784
785 // Default value
786 return 500;
787}
788
789double FilterManager::getFilterTicksPerTemp(const QString &name) const
790{
791 auto filterDetails = getFilterByName(name);
792 if (filterDetails)
793 return filterDetails->focusTicksPerTemp();
794
795 // Something's wrong so return 0
796 return 0.0;
797}
798
799double FilterManager::getFilterTicksPerAlt(const QString &name) const
800{
801 auto filterDetails = getFilterByName(name);
802 if (filterDetails)
803 return filterDetails->focusTicksPerAlt();
804
805 // Something's wrong so return 0
806 return 0.0;
807}
808
809OAL::Filter * FilterManager::getFilterByName(const QString &name) const
810{
811 if (m_currentFilterLabels.empty() ||
812 m_currentFilterPosition < 1 ||
813 m_currentFilterPosition > m_currentFilterLabels.count())
814 return nullptr;
815
816 QString color = name;
817 if (color.isEmpty())
818 color = m_currentFilterLabels[m_currentFilterPosition - 1];
819
820 auto pos = std::find_if(m_ActiveFilters.begin(), m_ActiveFilters.end(), [color](OAL::Filter * oneFilter)
821 {
822 return (oneFilter->color() == color);
823 });
824
825 if (pos != m_ActiveFilters.end())
826 return (*pos);
827 else
828 return nullptr;
829}
830
831void FilterManager::removeDevice(const QSharedPointer<ISD::GenericDevice> &device)
832{
833 if (m_FilterWheel && (m_FilterWheel->getDeviceName() == device->getDeviceName()))
834 {
835 m_FilterNameProperty = nullptr;
836 m_FilterPositionProperty = nullptr;
837 m_FilterWheel = nullptr;
838 m_currentFilterLabels.clear();
839 m_currentFilterPosition = 0;
840 qDeleteAll(m_ActiveFilters);
841 m_ActiveFilters.clear();
842 delete(m_FilterModel);
843 m_FilterModel = nullptr;
844 }
845}
846
847void FilterManager::setFocusStatus(Ekos::FocusState focusState)
848{
849 setAutofocusStatus(focusState);
850
851 if (state == FILTER_AUTOFOCUS)
852 {
853 switch (focusState)
854 {
855 case FOCUS_COMPLETE:
856 executeOperationQueue();
857 break;
858
859 case FOCUS_FAILED:
860 if (++retries == 3)
861 {
862 retries = 0;
863 emit failed();
864 return;
865 }
866 // Restart again
867 emit runAutoFocus(AutofocusReason::FOCUS_FILTER, "");
868 break;
869
870 default:
871 break;
872 }
873 }
874}
875
876void FilterManager::setAutofocusStatus(Ekos::FocusState focusState)
877{
878 if (targetFilter)
879 {
880 if (focusState == FOCUS_COMPLETE)
881 m_LastAFFailed.insert(targetFilter->color(), FALSE);
882 else if (focusState == FOCUS_ABORTED || focusState == FOCUS_FAILED)
883 m_LastAFFailed.insert(targetFilter->color(), TRUE);
884 }
885}
886
887bool FilterManager::syncAbsoluteFocusPosition(int index)
888{
889 if (m_FocusReady == false)
890 {
891 qCWarning(KSTARS_INDI) << __FUNCTION__ << "No Focuser detected.";
892 return true;
893 }
894 else if (index < 0 || index > m_ActiveFilters.count())
895 {
896 // We've been asked to set the focus position but something's wrong because
897 // the passed in filter index is bad. Give up and return true - returning false
898 // just results in an infinite retry loop.
899 qCWarning(KSTARS_INDI) << __FUNCTION__ << "index" << index << "is out of bounds.";
900 return true;
901 }
902
903 // By default filter absolute focus offset is zero
904 // JM 2023.07.03: So if it is zero, we return immediately.
905 auto absFocusPos = m_ActiveFilters[index]->absoluteFocusPosition();
906
907 if (m_FocusAbsPosition == absFocusPos || absFocusPos <= 0)
908 {
909 m_FocusAbsPositionPending = false;
910 return true;
911 }
912 else if (m_FocusAbsPositionPending == false)
913 {
914 m_FocusAbsPositionPending = true;
915 emit newFocusOffset(absFocusPos, true);
916 }
917
918 return false;
919}
920
921bool FilterManager::setFilterNames(const QStringList &newLabels)
922{
923 if (m_FilterWheel == nullptr || m_currentFilterLabels.empty())
924 return false;
925
926 m_FilterWheel->setLabels(newLabels);
927 return true;
928}
929
930QJsonObject FilterManager::toJSON()
931{
932 if (!m_FilterWheel)
933 return QJsonObject();
934
935 QJsonArray filters;
936
937 for (int i = 0; i < m_FilterModel->rowCount(); ++i)
938 {
939 QJsonObject oneFilter =
940 {
941 {"index", i},
942 {"label", m_FilterModel->data(m_FilterModel->index(i, FM_LABEL)).toString()},
943 {"exposure", m_FilterModel->data(m_FilterModel->index(i, FM_EXPOSURE)).toDouble()},
944 {"offset", m_FilterModel->data(m_FilterModel->index(i, FM_OFFSET)).toInt()},
945 {"autofocus", m_FilterModel->data(m_FilterModel->index(i, FM_AUTO_FOCUS)).toBool()},
946 {"lock", m_FilterModel->data(m_FilterModel->index(i, FM_LOCK_FILTER)).toString()},
947 {"lastafsolution", m_FilterModel->data(m_FilterModel->index(i, FM_LAST_AF_SOLUTION)).toInt()},
948 {"lastaftemp", m_FilterModel->data(m_FilterModel->index(i, FM_LAST_AF_TEMP)).toDouble()},
949 {"lastafalt", m_FilterModel->data(m_FilterModel->index(i, FM_LAST_AF_ALT)).toDouble()},
950 {"lastafdt", m_FilterModel->data(m_FilterModel->index(i, FM_LAST_AF_DATETIME)).toString()},
951 {"tickspertemp", m_FilterModel->data(m_FilterModel->index(i, FM_TICKS_PER_TEMP)).toDouble()},
952 {"ticksperalt", m_FilterModel->data(m_FilterModel->index(i, FM_TICKS_PER_ALT)).toDouble()},
953 {"wavelength", m_FilterModel->data(m_FilterModel->index(i, FM_WAVELENGTH)).toInt()},
954 };
955
956 filters.append(oneFilter);
957 }
958
959 QJsonObject data =
960 {
961 {"device", m_FilterWheel->getDeviceName()},
962 {"filters", filters}
963 };
964
965 return data;
966
967}
968
969void FilterManager::setFilterData(const QJsonObject &settings)
970{
971 if (!m_FilterWheel)
972 return;
973
974 if (settings["device"].toString() != m_FilterWheel->getDeviceName())
975 return;
976
977 QJsonArray filters = settings["filters"].toArray();
978 QStringList labels = getFilterLabels();
979
980 for (auto oneFilterRef : filters)
981 {
982 QJsonObject oneFilter = oneFilterRef.toObject();
983 int row = oneFilter["index"].toInt();
984
985 labels[row] = oneFilter["label"].toString();
986 m_FilterModel->setData(m_FilterModel->index(row, FM_LABEL), oneFilter["label"].toString());
987 m_FilterModel->setData(m_FilterModel->index(row, FM_EXPOSURE), oneFilter["exposure"].toDouble());
988 m_FilterModel->setData(m_FilterModel->index(row, FM_OFFSET), oneFilter["offset"].toInt());
989 m_FilterModel->setData(m_FilterModel->index(row, FM_AUTO_FOCUS), oneFilter["autofocus"].toBool());
990 m_FilterModel->setData(m_FilterModel->index(row, FM_LOCK_FILTER), oneFilter["lock"].toString());
991 m_FilterModel->setData(m_FilterModel->index(row, FM_LAST_AF_SOLUTION), oneFilter["lastafsolution"].toInt());
992 m_FilterModel->setData(m_FilterModel->index(row, FM_LAST_AF_TEMP), oneFilter["lastaftemp"].toDouble());
993 m_FilterModel->setData(m_FilterModel->index(row, FM_LAST_AF_ALT), oneFilter["lastafalt"].toDouble());
994 m_FilterModel->setData(m_FilterModel->index(row, FM_LAST_AF_DATETIME), oneFilter["lastafdt"].toString(DATETIME_FORMAT));
995 m_FilterModel->setData(m_FilterModel->index(row, FM_TICKS_PER_TEMP), oneFilter["tickspertemp"].toDouble());
996 m_FilterModel->setData(m_FilterModel->index(row, FM_TICKS_PER_ALT), oneFilter["ticksperalt"].toDouble());
997 m_FilterModel->setData(m_FilterModel->index(row, FM_WAVELENGTH), oneFilter["wavelength"].toInt());
998 }
999
1000 m_FilterModel->submitAll();
1001 setFilterNames(labels);
1002
1003 refreshFilterModel();
1004}
1005
1006void FilterManager::buildFilterOffsets()
1007{
1008 // Launch the Build Filter Offsets utility. The utility uses a sync call to launch the dialog
1009 QSharedPointer<FilterManager> filterManager;
1010 Ekos::Manager::Instance()->getFilterManager(m_FilterWheel->getDeviceName(), filterManager);
1011 BuildFilterOffsets bfo(filterManager);
1012}
1013
1014void FilterManager::signalRunAutoFocus(AutofocusReason autofocusReason, const QString &reasonInfo)
1015{
1016 // BuildFilterOffsets signalled runAutoFocus so pass signal to Focus
1017 emit runAutoFocus(autofocusReason, reasonInfo);
1018}
1019
1020void FilterManager::autoFocusComplete(FocusState completionState, int currentPosition, double currentTemperature,
1021 double currentAlt)
1022{
1023 // Focus signalled Autofocus completed so pass signal to BuildFilterOffsets
1024 emit autoFocusDone(completionState, currentPosition, currentTemperature, currentAlt);
1025}
1026
1027void FilterManager::signalAbortAutoFocus()
1028{
1029 // BuildFilterOffsets signalled abortAutoFocus so pass signal to Focus
1030 emit abortAutoFocus();
1031}
1032
1033void FilterManager::checkFilterChangeTimeout()
1034{
1035 if (state == FILTER_CHANGE)
1036 {
1037 qCWarning(KSTARS) << "FilterManager.cpp filter change timed out.";
1038 emit failed();
1039 }
1040}
1041}
OAL::Filter
Information of user filters.
Definition filter.h:51
i18n
QString i18n(const char *text, const TYPE &arg...)
Baloo::toString
char * toString(const EngineQuery &query)
Ekos
Ekos is an advanced Astrophotography tool for Linux.
Definition align.cpp:83
KItinerary::LocationUtil::name
QString name(const QVariant &location)
KStandardGuiItem::close
KGuiItem close()
KStandardShortcut::label
QString label(StandardShortcut id)
QAbstractButton::clicked
void clicked(bool checked)
QAbstractButton::toggled
void toggled(bool checked)
QAbstractItemModel::dataChanged
void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList< int > &roles)
QDialog::accepted
void accepted()
QDialog::rejected
void rejected()
QJsonArray::append
void append(const QJsonValue &value)
QList::append
void append(QList< T > &&value)
QModelIndex::column
int column() const const
QModelIndex::row
int row() const const
QSqlDatabase::database
QSqlDatabase database(const QString &connectionName, bool open)
QSqlRecord::value
QVariant value(const QString &name) const const
QString::data
QChar * data()
QString::isEmpty
bool isEmpty() const const
QString::length
qsizetype length() const const
Qt::ToolTipRole
ToolTipRole
Qt::Horizontal
Horizontal
QtConcurrent::filter
QFuture< void > filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
QtFuture::connect
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)
QTimer::timeout
void timeout()
QVariant::toDouble
double toDouble(bool *ok) const const
QVariant::toInt
int toInt(bool *ok) const const
QVariant::toString
QString toString() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Mar 28 2025 11:57:24 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.