File indexing completed on 2024-04-28 15:09:08

 /*
     SPDX-FileCopyrightText: 2023 John Evans <john.e.evans.email@googlemail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "buildfilteroffsets.h"
 #include <kstars_debug.h>
 #include "kstars.h"
 #include "ekos/auxiliary/tabledelegate.h"
 #include "Options.h"
 
 namespace Ekos
 {
 
 // buildFilterOffsets (BFO) sets up a dialog to manage automatic calculation of filter offsets
 // by performing autofocus runs on user selected filters and working out the relative offsets.
 // The idea is to use the utility once in a while to setup the offsets which them enables the user to avoid having
 // to do an autofocus run when swapping filters. The benefit of this might be to avoid focusing on a difficult-to-
 // focus filter but focusing on a lock filter and then using the offset; or just to avoid an Autofocus run when
 // changing filter.
 //
 // The utility follows the standard Ekos cpp/h/ui file setup. The basic dialog is contained in the .ui file but
 // because the table is constructed from data at runtime some of the GUI is constructed in code in the .cpp.
 // BFO uses the MVC design pattern. The BuildFilterOffset object is a friend of FilterManager because BFO is closely
 // related to FilterManager. This allows several FilterManager methods to be accessed by BFO. In addition, signals
 // with Focus are passed via FilterManager.
 //
 // On launch, BFO displays a grid containing all the filters in the Filter Settings. Relevant information is copied across
 // to BFO and the filters appear in the same order. The 1st filter is suffiixed with a "*", marking it as the reference
 // filter which is the one against which all other relevant offsets are measured.
 //
 // To change the reference filter, the user double clicks another filter.
 //
 // The user needs to set the number of Autofocus (AF) runs to perform on each filter. The default is 5, the maximum is 10.
 // Setting this field to 0, removes the associated filter from further processing.
 //
 // The user presses Run and the utility moves to the processing stage. Extra columns are displayed, one for each AF run,
 // as well as average, new offset and save columns. For each filter the number of requested AF runs is performed. The
 // table cell associated with the in-flight AF run is highlighted. As an AF run completes the results are displayed in
 // the table. When all AF runs for a filter are complete, processing moves to the next filter.
 //
 // Normally, if a lock filter is configured for a particular filter, then when focusing, the lock filter is swapped in
 // AF runs, and then the original filter is swapped back into position. For BFO this model is inappropriate. When an
 // AF run is requested on a filter then AF is always run on that filter so the lock filter policy is not honoured when
 // running AF from BFO.
 //
 // The user can interrupt processing by pressing stop. A confirm dialog then allows the user to stop BFO or resume.
 //
 // BFO can take a while to complete. For example if 5 AF runs are requested on 8 filters and AF takes, say 2 mins per
 // run, then BFO will take over an hour. During this time environmental conditions such as temperature and altitude
 // could change the focus point. For this reaons, it it possible Adapt each focus run back to the temp and alt applicable
 // during the first AF run for more accurate calculation of the offsets. If Adapt Focus is checked, then the adapted
 // vales are used in calculations; if not checked then the raw (unadapted) values are used. The toggle can be used at
 // any time. The tooltip on each AF run provides a tabular explanation of the adaptations and how the raw value is
 // changed to the adapted value. In order to use Adapt Focus, the ticks per temperature and ticks per altitude fields
 // in the Fillter Settings popup need to be filled in appropriately for each filter being processed.
 //
 // If AF fails then the user is prompted to retry or abort the processing.
 //
 // When processing completes the user can review the results. Each processed filter's new offset has an associated save
 // checkbox allowing all or some values to be saved. Saving persists the new offset values in the Filter Settings popup
 // for future use during imaging.
 //
 // The average AF value for a filter is a simple mean. There are typically not enough sample points taken for robust
 // statistical processing to add any value. So the user needs to review the AF values and decide if they want to remove
 // any outliers (set the AF value to 0 to exclude from processing, or adjust the number). In addition, it is possible
 // to override the offset with a manually entered value.
 //
 BuildFilterOffsets::BuildFilterOffsets(QSharedPointer<FilterManager> filterManager)
 {
 #ifdef Q_OS_OSX
     setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
 #endif
 
     if (filterManager.isNull())
         return;
 
     m_filterManager = filterManager;
 
     setupUi(this);
     setupConnections();
     initBuildFilterOffsets();
     setupBuildFilterOffsetsTable();
     setupGUI();
 
     // Launch the dialog - synchronous call
     this->exec();
 }
 
 BuildFilterOffsets::~BuildFilterOffsets()
 {
 }
 
 void BuildFilterOffsets::setupConnections()
 {
     // Connections to FilterManager
     connect(this, &BuildFilterOffsets::runAutoFocus, m_filterManager.get(), &FilterManager::signalRunAutoFocus);
     connect(this, &BuildFilterOffsets::abortAutoFocus, m_filterManager.get(), &FilterManager::signalAbortAutoFocus);
 
     // Connections from FilterManager
     connect(m_filterManager.get(), &FilterManager::autoFocusDone, this, &BuildFilterOffsets::autoFocusComplete);
     connect(m_filterManager.get(), &FilterManager::ready, this, &BuildFilterOffsets::buildTheOffsetsTaskComplete);
 
     // Connections internal to BuildFilterOffsets
     connect(this, &BuildFilterOffsets::ready, this, &BuildFilterOffsets::buildTheOffsetsTaskComplete);
 }
 
 void BuildFilterOffsets::setupGUI()
 {
     // Add action buttons to the button box
     m_runButton = buildOffsetsButtonBox->addButton("Run", QDialogButtonBox::ActionRole);
     m_stopButton = buildOffsetsButtonBox->addButton("Stop", QDialogButtonBox::ActionRole);
 
     // Set tooltips for the buttons
     m_runButton->setToolTip("Run Build Filter Offsets utility");
     m_stopButton->setToolTip("Interrupt processing when utility is running");
     buildOffsetsButtonBox->button(QDialogButtonBox::Save)->setToolTip("Save New Offsets");
 
     // Set the buttons' state
     setBuildFilterOffsetsButtons(BFO_INIT);
 
     // Connect up button callbacks
     connect(m_runButton, &QPushButton::clicked, this, &BuildFilterOffsets::buildTheOffsets);
     connect(m_stopButton, &QPushButton::clicked, this, &BuildFilterOffsets::stopProcessing);
     connect(buildOffsetsButtonBox->button(QDialogButtonBox::Save), &QPushButton::clicked, this,
             &BuildFilterOffsets::saveTheOffsets);
     connect(buildOffsetsButtonBox->button(QDialogButtonBox::Close), &QPushButton::clicked, this, [this]()
     {
         // Close the dialog down unless lots of processing has been done. In that case put up an "are you sure" popup
         if (!m_tableInEditMode)
             this->done(QDialog::Rejected);
         else if (KMessageBox::questionYesNo(KStars::Instance(),
                                             i18n("Are you sure you want to quit?")) == KMessageBox::Yes)
             this->done(QDialog::Rejected);
     });
 
     // Setup the Adapt Focus checkbox
     buildOffsetsAdaptFocus->setChecked(Options::adaptFocusBFO());
     connect(buildOffsetsAdaptFocus, &QCheckBox::toggled, this, [&](bool checked)
     {
         Options::setAdaptFocusBFO(checked);
         reloadPositions(checked);
     });
 
     // Connect cell changed callback
     connect(&m_BFOModel, &QStandardItemModel::itemChanged, this, &BuildFilterOffsets::itemChanged);
 
     // Connect double click callback
     connect(buildOffsetsTableView, &QAbstractItemView::doubleClicked, this, &BuildFilterOffsets::refChanged);
 
     // Display an initial message in the status bar
     buildOffsetsStatusBar->showMessage(i18n("Idle"));
 
     // Resize the dialog based on the data
     buildOffsetsDialogResize();
 }
 
 void BuildFilterOffsets::initBuildFilterOffsets()
 {
     m_inBuildOffsets = false;
     m_stopFlag = m_problemFlag = m_abortAFPending = m_tableInEditMode = false;
     m_filters.clear();
     m_refFilter = -1;
     m_rowIdx = m_colIdx = 0;
 
     // Drain any old queue items
     m_buildOffsetsQ.clear();
 }
 
 void BuildFilterOffsets::setupBuildFilterOffsetsTable()
 {
     // Setup MVC
     buildOffsetsTableView->setModel(&m_BFOModel);
 
     // Setup the table view
     QStringList Headers { i18n("Filter"), i18n("Offset"), i18n("Lock Filter"), i18n("# Focus Runs") };
     m_BFOModel.setColumnCount(Headers.count());
     m_BFOModel.setHorizontalHeaderLabels(Headers);
 
     // Setup tooltips on column headers
     m_BFOModel.setHeaderData(getColumn(BFO_FILTER), Qt::Horizontal,
                              i18n("Filter. * indicates reference filter. Double click to change"),
                              Qt::ToolTipRole);
     m_BFOModel.setHeaderData(getColumn(BFO_NUM_FOCUS_RUNS), Qt::Horizontal, i18n("# Focus Runs. Set per filter. 0 to ignore"),
                              Qt::ToolTipRole);
 
     // Setup edit delegates for each column
     // No Edit delegates for Filter, Offset and Lock Filter
     NotEditableDelegate *noEditDel = new NotEditableDelegate(buildOffsetsTableView);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_FILTER), noEditDel);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_OFFSET), noEditDel);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_LOCK), noEditDel);
 
     // # Focus Runs delegate
     IntegerDelegate *numRunsDel = new IntegerDelegate(buildOffsetsTableView, 0, 10, 1);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_NUM_FOCUS_RUNS), numRunsDel);
 
     // Setup the table
     m_BFOModel.setRowCount(m_filterManager->m_ActiveFilters.count());
 
     // Load the data for each filter
     for (int row = 0 ; row < m_filterManager->m_ActiveFilters.count(); row++)
     {
         // Filter name
         m_filters.push_back(m_filterManager->m_ActiveFilters[row]->color());
         QString str;
         if (row == 0)
         {
             str = QString("%1 *").arg(m_filters[row]);
             m_refFilter = 0;
         }
         else
             str = m_filters[row];
 
         QStandardItem* item0 = new QStandardItem(str);
         m_BFOModel.setItem(row, getColumn(BFO_FILTER), item0);
 
         // Offset
         QStandardItem* item1 = new QStandardItem(QString::number(m_filterManager->m_ActiveFilters[row]->offset()));
         m_BFOModel.setItem(row, getColumn(BFO_OFFSET), item1);
 
         // Lock filter
         QStandardItem* item2 = new QStandardItem(m_filterManager->m_ActiveFilters[row]->lockedFilter());
         m_BFOModel.setItem(row, getColumn(BFO_LOCK), item2);
 
         // Number of AF runs to perform
         QStandardItem* item3 = new QStandardItem(QString::number(5));
         m_BFOModel.setItem(row, getColumn(BFO_NUM_FOCUS_RUNS), item3);
     }
 }
 
 void BuildFilterOffsets::setBuildFilterOffsetsButtons(const BFOButtonState state)
 {
     switch (state)
     {
         case BFO_INIT:
             m_runButton->setEnabled(true);
             m_stopButton->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Save)->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Close)->setEnabled(true);
             break;
 
         case BFO_RUN:
             m_runButton->setEnabled(false);
             m_stopButton->setEnabled(true);
             buildOffsetsButtonBox->button(QDialogButtonBox::Save)->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Close)->setEnabled(false);
             break;
 
         case BFO_SAVE:
             m_runButton->setEnabled(false);
             m_stopButton->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Save)->setEnabled(true);
             buildOffsetsButtonBox->button(QDialogButtonBox::Close)->setEnabled(true);
             break;
 
         case BFO_STOP:
             m_runButton->setEnabled(false);
             m_stopButton->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Save)->setEnabled(false);
             buildOffsetsButtonBox->button(QDialogButtonBox::Close)->setEnabled(false);
             break;
 
         default:
             break;
     }
 }
 
 // Loop through all the filters to process, and for each...
 // - set Autofocus to use the filter
 // - Loop for the number of runs chosen by the user for that filter
 //   - Run AF
 //   - Get the focus solution
 //   - Load the focus solution into table widget in the appropriate cell
 // - Calculate the average AF solution for that filter and display it
 void BuildFilterOffsets::buildTheOffsets()
 {
     buildOffsetsQItem qItem;
 
     // Set the buttons
     setBuildFilterOffsetsButtons(BFO_RUN);
 
     // Make the Number of runs column not editable
     // No Edit delegates for Filter, Offset and Lock Filter
     QPointer<NotEditableDelegate> noEditDel = new NotEditableDelegate(buildOffsetsTableView);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_NUM_FOCUS_RUNS), noEditDel);
 
     // Loop through the work to do and load up Queue and extend tableWidget to record AF answers
     int maxAFRuns = 0;
     int startRow = -1;
     for (int row = 0; row < m_filters.count(); row++ )
     {
         const int numRuns = m_BFOModel.item(row, getColumn(BFO_NUM_FOCUS_RUNS))->text().toInt();
         if (numRuns > 0)
         {
             if (startRow < 0)
                 startRow = row;
 
             // Set the filter change
             qItem.color = m_filters[row];
             qItem.changeFilter = true;
             m_buildOffsetsQ.enqueue(qItem);
 
             // Load up the AF runs based on how many the user requested
             qItem.changeFilter = false;
             maxAFRuns = std::max(maxAFRuns, numRuns);
             for (int runNum = 1; runNum <= numRuns; runNum++)
             {
                 qItem.numAFRun = runNum;
                 m_buildOffsetsQ.enqueue(qItem);
             }
         }
     }
 
     // Add columns to the Model for AF runs and set the headers. Each AF run result is editable
     // but the calculated average is not.
     int origCols = m_BFOModel.columnCount();
     m_BFOModel.setColumnCount(origCols + maxAFRuns + 3);
     for (int col = 0; col < maxAFRuns; col++)
     {
         QStandardItem *newItem = new QStandardItem(i18n("AF Run %1", col + 1));
         m_BFOModel.setHorizontalHeaderItem(origCols + col, newItem);
         m_BFOModel.setHeaderData(origCols + col, Qt::Horizontal,
                                  i18n("AF Run %1. Calculated automatically but can be edited. Set to 0 to exclude from average.", col + 1),
                                  Qt::ToolTipRole);
         buildOffsetsTableView->setItemDelegateForColumn(origCols + col, noEditDel);
     }
 
     // Add 3 more columns for the average of the AF runs, the offset and whether to save the offset
     QStandardItem *averageItem = new QStandardItem(i18n("Average"));
     m_BFOModel.setHorizontalHeaderItem(origCols + maxAFRuns, averageItem);
     m_BFOModel.setHeaderData(origCols + maxAFRuns, Qt::Horizontal, i18n("AF Average (mean)."), Qt::ToolTipRole);
     buildOffsetsTableView->setItemDelegateForColumn(origCols + maxAFRuns, noEditDel);
 
     QStandardItem *offsetItem = new QStandardItem(i18n("New Offset"));
     m_BFOModel.setHorizontalHeaderItem(origCols + maxAFRuns + 1, offsetItem);
     m_BFOModel.setHeaderData(origCols + maxAFRuns + 1, Qt::Horizontal,
                              i18n("New Offset. Calculated relative to Filter with *. Can be edited."), Qt::ToolTipRole);
     buildOffsetsTableView->setItemDelegateForColumn(origCols + maxAFRuns + 1, noEditDel);
 
     QPointer<ToggleDelegate> saveDelegate = new ToggleDelegate(&m_BFOModel);
     QStandardItem *saveItem = new QStandardItem(i18n("Save"));
     m_BFOModel.setHorizontalHeaderItem(origCols + maxAFRuns + 2, saveItem);
     m_BFOModel.setHeaderData(origCols + maxAFRuns + 2, Qt::Horizontal,
                              i18n("Save. Check to save the New Offset for the associated Filter."), Qt::ToolTipRole);
     buildOffsetsTableView->setItemDelegateForColumn(origCols + maxAFRuns + 2, saveDelegate);
 
     // Resize the dialog
     buildOffsetsDialogResize();
 
     // Set the selected cell to the first AF run of the ref filter
     m_rowIdx = startRow;
     m_colIdx = getColumn(BFO_AF_RUN_1);
     QModelIndex index = buildOffsetsTableView->model()->index(m_rowIdx, m_colIdx);
     buildOffsetsTableView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
 
     // Initialise the progress bar
     buildOffsetsProgressBar->reset();
     buildOffsetsProgressBar->setRange(0, m_buildOffsetsQ.count());
     buildOffsetsProgressBar->setValue(0);
 
     // The Q has been loaded with all required actions so lets start processing
     m_inBuildOffsets = true;
     runBuildOffsets();
 }
 
 // This is signalled when an asynchronous task has been completed, either
 // a filter change or an autofocus run
 void BuildFilterOffsets::buildTheOffsetsTaskComplete()
 {
     if (m_stopFlag)
     {
         // User hit the stop button, so see what they want to do
         if (KMessageBox::warningContinueCancel(KStars::Instance(),
                                                i18n("Are you sure you want to stop Build Filter Offsets?"), i18n("Stop Build Filter Offsets"),
                                                KStandardGuiItem::stop(), KStandardGuiItem::cancel(), "") == KMessageBox::Cancel)
         {
             // User wants to retry processing
             m_stopFlag = false;
             setBuildFilterOffsetsButtons(BFO_RUN);
 
             if (m_abortAFPending)
             {
                 // If the in-flight task was aborted then retry - don't take the next task off the Q
                 m_abortAFPending = false;
                 processQItem(m_qItemInProgress);
             }
             else
             {
                 // No tasks were aborted so we can just start the next task in the queue
                 buildOffsetsProgressBar->setValue(buildOffsetsProgressBar->value() + 1);
                 runBuildOffsets();
             }
         }
         else
         {
             // User wants to abort
             m_stopFlag = m_abortAFPending = false;
             this->done(QDialog::Rejected);
         }
     }
     else if (m_problemFlag)
     {
         // The in flight task had a problem so see what the user wants to do
         if (KMessageBox::warningContinueCancel(KStars::Instance(),
                                                i18n("An unexpected problem occurred.\nStop Build Filter Offsets, or Cancel to retry?"),
                                                i18n("Build Filter Offsets Unexpected Problem"),
                                                KStandardGuiItem::stop(), KStandardGuiItem::cancel(), "") == KMessageBox::Cancel)
         {
             // User wants to retry
             m_problemFlag = false;
             processQItem(m_qItemInProgress);
         }
         else
         {
             // User wants to abort
             m_problemFlag = false;
             this->done(QDialog::Rejected);
         }
     }
     else
     {
         // All good so update the progress bar and process the next task
         buildOffsetsProgressBar->setValue(buildOffsetsProgressBar->value() + 1);
         runBuildOffsets();
     }
 }
 
 // Resize the dialog to the data
 void BuildFilterOffsets::buildOffsetsDialogResize()
 {
     // Resize the columns to the data
     buildOffsetsTableView->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 
     // Resize the dialog to the width and height of the table widget
     const int width = buildOffsetsTableView->horizontalHeader()->length() + 40;
     const int height = buildOffsetsTableView->verticalHeader()->length() + buildOffsetsButtonBox->height() +
                        buildOffsetsProgressBar->height() + buildOffsetsStatusBar->height() + 60;
     this->resize(width, height);
 }
 
 void BuildFilterOffsets::runBuildOffsets()
 {
     if (m_buildOffsetsQ.isEmpty())
     {
         // All tasks have been actioned so allow the user to edit the results, save them or quit.
         setCellsEditable();
         setBuildFilterOffsetsButtons(BFO_SAVE);
         m_tableInEditMode = true;
         buildOffsetsStatusBar->showMessage(i18n("Processing complete."));
     }
     else
     {
         // Take the next item off the queue
         m_qItemInProgress = m_buildOffsetsQ.dequeue();
         processQItem(m_qItemInProgress);
     }
 }
 
 void BuildFilterOffsets::processQItem(const buildOffsetsQItem currentItem)
 {
     if (currentItem.changeFilter)
     {
         // Need to change filter
         buildOffsetsStatusBar->showMessage(i18n("Changing filter to %1...", currentItem.color));
 
         auto pos = m_filterManager->m_currentFilterLabels.indexOf(currentItem.color) + 1;
         if (!m_filterManager->setFilterPosition(pos, m_filterManager->CHANGE_POLICY))
         {
             // Filter wheel position change failed.
             buildOffsetsStatusBar->showMessage(i18n("Problem changing filter to %1...", currentItem.color));
             m_problemFlag = true;
         }
     }
     else
     {
         // Signal an AF run with an arg of "build offsets"
         const int run = m_colIdx - getColumn(BFO_AF_RUN_1) + 1;
         const int numRuns = m_BFOModel.item(m_rowIdx, getColumn(BFO_NUM_FOCUS_RUNS))->text().toInt();
         buildOffsetsStatusBar->showMessage(i18n("Running Autofocus on %1 (%2/%3)...", currentItem.color, run, numRuns));
         emit runAutoFocus(m_inBuildOffsets);
     }
 }
 
 // This is called at the end of an AF run
 void BuildFilterOffsets::autoFocusComplete(FocusState completionState, int position, double temperature, double altitude)
 {
     if (!m_inBuildOffsets)
         return;
 
     if (completionState != FOCUS_COMPLETE)
     {
         // The AF run has failed. If the user aborted the run then this is an expected signal
         if (!m_abortAFPending)
             // In this case the failure is a genuine problem so set a problem flag
             m_problemFlag = true;
     }
     else
     {
         // AF run was successful so load the solution results
         processAFcomplete(position, temperature, altitude);
 
         // Load the result into the table. The Model update will trigger further updates
         loadPosition(buildOffsetsAdaptFocus->isChecked(), m_rowIdx, m_colIdx);
 
         // Now see what's next, another AF run on this filter or are we moving to the next filter
         if (m_colIdx - getColumn(BFO_NUM_FOCUS_RUNS) < getNumRuns(m_rowIdx))
             m_colIdx++;
         else
         {
             // Move the active cell to the next AF run in the table
             // Usually this will be the next row, but if this row has zero AF runs skip to the next
             for (int nextRow = m_rowIdx + 1; nextRow < m_filters.count(); nextRow++)
             {
                 if (getNumRuns(nextRow) > 0)
                 {
                     // Found the next filter to process
                     m_rowIdx = nextRow;
                     m_colIdx = getColumn(BFO_AF_RUN_1);
                     break;
                 }
             }
         }
         // Highlight the next cell...
         const QModelIndex index = buildOffsetsTableView->model()->index(m_rowIdx, m_colIdx);
         buildOffsetsTableView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
     }
     // Signal the next processing step
     emit ready();
 }
 
 // Called to store the AF position details. The raw AF position is passed in (from Focus)
 // The Adapted position (based on temperature and altitude) is calculated
 // The sense of the adaptation is to take the current position and adapt it to the
 // conditions (temp and alt) of the reference.
 void BuildFilterOffsets::processAFcomplete(const int position, const double temperature, const double altitude)
 {
     AFSolutionDetail solution;
 
     solution.position = position;
     solution.temperature = temperature;
     solution.altitude = altitude;
     solution.ticksPerTemp = m_filterManager->getFilterTicksPerTemp(m_filters[m_rowIdx]);
     solution.ticksPerAlt = m_filterManager->getFilterTicksPerAlt(m_filters[m_rowIdx]);
 
     if (m_rowIdx == 0 && m_colIdx == getColumn(BFO_AF_RUN_1))
     {
         // Set the reference temp and alt to be the first AF run
         m_refTemperature = temperature;
         m_refAltitude = altitude;
     }
 
     // Calculate the temperature adaptation
     if (temperature == INVALID_VALUE || m_refTemperature == INVALID_VALUE)
     {
         solution.deltaTemp = 0.0;
         solution.deltaTicksTemperature = 0.0;
     }
     else
     {
         solution.deltaTemp = m_refTemperature - temperature;
         solution.deltaTicksTemperature = solution.ticksPerTemp * solution.deltaTemp;
     }
 
     // Calculate the altitude adaptation
     if (altitude == INVALID_VALUE || m_refAltitude == INVALID_VALUE)
     {
         solution.deltaAlt = 0.0;
         solution.deltaTicksAltitude = 0.0;
     }
     else
     {
         solution.deltaAlt = m_refAltitude - altitude;
         solution.deltaTicksAltitude = solution.ticksPerAlt * solution.deltaAlt;
     }
 
     // Calculate the total adaptation
     solution.deltaTicksTotal = static_cast<int>(round(solution.deltaTicksTemperature + solution.deltaTicksAltitude));
 
     // Calculate the Adapted position
     solution.adaptedPosition = position + solution.deltaTicksTotal;
 
     m_AFSolutions.push_back(solution);
 }
 
 // Load the focus position depending on the setting of the adaptPos checkbox. The Model update will trigger further updates
 void BuildFilterOffsets::loadPosition(const bool checked, const int row, const int col)
 {
     int idx = 0;
     // Work out the array index for m_AFSolutions
     for (int i = 0; i < row; i++)
         idx += getNumRuns(i);
 
     idx += col - getColumn(BFO_AF_RUN_1);
 
     // Check that the passed in row, col has been processed. If not, nothing to do
     if (idx < m_AFSolutions.count())
     {
         // Get the AF position to use based on the setting of 'checked'
         int pos = (checked) ? m_AFSolutions[idx].adaptedPosition : m_AFSolutions[idx].position;
 
         // Present a tooltip explanation of how the original position is changed by adaptation, e.g.
         //                    Adapt Focus Explainer
         //               Position  Temperature (°C)   Altitude (°Alt)
         // Measured Pos: 36704     T: 0.9°C (ΔT=0.7)  Alt: 40.1° (ΔAlt=-4.2)
         // Adaptations:      4     T: 7.10 ticks      Alt: -3.20 ticks
         // Adapted Pos:  36708
         //
         const QString temp = QString("%1").arg(m_AFSolutions[idx].temperature, 0, 'f', 1);
         const QString deltaTemp = i18n("(ΔT=%1)", QString("%1").arg(m_AFSolutions[idx].deltaTemp, 0, 'f', 1));
         const QString ticksTemp = i18n("(%1 ticks)", QString("%1").arg(m_AFSolutions[idx].deltaTicksTemperature, 0, 'f', 1));
         const QString alt = QString("%1").arg(m_AFSolutions[idx].altitude, 0, 'f', 1);
         const QString deltaAlt = i18n("(ΔAlt=%1)", QString("%1").arg(m_AFSolutions[idx].deltaAlt, 0, 'f', 1));
         const QString ticksAlt = i18n("(%1 ticks)", QString("%1").arg(m_AFSolutions[idx].deltaTicksAltitude, 0, 'f', 1));
 
         QStandardItem *posItem = new QStandardItem(QString::number(pos));
         const QString toolTip =
             i18nc("Graphics tooltip; colume 1 is a header, column 2 is focus position, column 3 is temperature in °C, colunm 4 is altitude in °Alt"
                   "Row 1 is the headers, row 2 is the measured position, row 3 are the adaptations for temperature and altitude, row 4 is adapted position",
                   "<head><style>"
                   "  th, td, caption {white-space: nowrap; padding-left: 5px; padding-right: 5px;}"
                   "  th { text-align: left;}"
                   "  td { text-align: right;}"
                   "  caption { text-align: center; vertical-align: top; font-weight: bold; margin: 0px; padding-bottom: 5px;}"
                   "</head></style>"
                   "<body><table>"
                   "<caption align=top>Adapt Focus Explainer</caption>"
                   "<tr><th></th><th>Position</th><th>Temperature (°C)</th><th>Altitude (°Alt)</th></tr>"
                   "<tr><th>Measured Pos</th><td>%1</td><td>%2 %3</td><td>%4 %5</td></tr>"
                   "<tr><th>Adaptations</th><td>%6</td><td>%7</td><td>%8</td></tr>"
                   "<tr><th>Adapted Pos</th><td>%9</td></tr>"
                   "</table></body>",
                   m_AFSolutions[idx].position, temp, deltaTemp, alt, deltaAlt,
                   m_AFSolutions[idx].deltaTicksTotal, ticksTemp, ticksAlt,
                   m_AFSolutions[idx].adaptedPosition);
 
         posItem->setToolTip(toolTip);
         m_BFOModel.setItem(row, col, posItem);
     }
 }
 
 // Reload the focus position grid depending on the setting of the adaptPos checkbox.
 void BuildFilterOffsets::reloadPositions(const bool checked)
 {
     for (int row = 0; row <= m_rowIdx; row++)
     {
         const int numRuns = getNumRuns(row);
         const int maxCol = (row < m_rowIdx) ? numRuns : m_colIdx - getColumn(BFO_AF_RUN_1) + 1;
         for (int col = 0; col < maxCol; col++)
             loadPosition(checked, row, col + getColumn(BFO_AF_RUN_1));
     }
 }
 
 // Called when the user wants to persist the calculated offsets
 void BuildFilterOffsets::saveTheOffsets()
 {
     for (int row = 0; row < m_filters.count(); row++)
     {
         // Check there's an item set for the current row before accessing
         if (m_BFOModel.item(row, getColumn(BFO_SAVE_CHECK))->text().toInt())
         {
             // Save item is set so persist the offset
             const int offset = m_BFOModel.item(row, getColumn(BFO_NEW_OFFSET))->text().toInt();
             if (!m_filterManager->setFilterOffset(m_filters[row], offset))
                 qCDebug(KSTARS) << "Unable to save calculated offset for filter " << m_filters[row];
         }
     }
     // All done so close the dialog
     this->done(QDialog::Accepted);
 }
 
 // Processing done so make certain cells editable for the user
 void BuildFilterOffsets::setCellsEditable()
 {
     // Enable an edit delegate on the AF run result columns so the user can adjust as necessary
     // The delegates operate at the row or column level so some cells need to be manually disabled
     for (int col = getColumn(BFO_AF_RUN_1); col < getColumn(BFO_AF_RUN_1) + getMaxRuns(); col++)
     {
         IntegerDelegate *AFDel = new IntegerDelegate(buildOffsetsTableView, 0, 1000000, 1);
         buildOffsetsTableView->setItemDelegateForColumn(col, AFDel);
 
         // Disable any cells where for that filter less AF runs were requested
         for (int row = 0; row < m_BFOModel.rowCount(); row++)
         {
             const int numRuns = getNumRuns(row);
             if ((numRuns > 0) && (col > numRuns + getColumn(BFO_AF_RUN_1) - 1))
             {
                 QStandardItem *currentItem = new QStandardItem();
                 currentItem->setEditable(false);
                 m_BFOModel.setItem(row, col, currentItem);
             }
         }
     }
 
     // Offset column
     IntegerDelegate *offsetDel = new IntegerDelegate(buildOffsetsTableView, -10000, 10000, 1);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_NEW_OFFSET), offsetDel);
 
     // Save column
     ToggleDelegate *saveDel = new ToggleDelegate(buildOffsetsTableView);
     buildOffsetsTableView->setItemDelegateForColumn(getColumn(BFO_SAVE_CHECK), saveDel);
 
     // Check filters where user requested zero AF runs
     for (int row = 0; row < m_filters.count(); row++)
     {
         if (getNumRuns(row) <= 0)
         {
             // Uncheck save just in case user activated it
             QStandardItem *saveItem = new QStandardItem("");
             m_BFOModel.setItem(row, getColumn(BFO_SAVE_CHECK), saveItem);
             NotEditableDelegate *newDelegate = new NotEditableDelegate(buildOffsetsTableView);
             buildOffsetsTableView->setItemDelegateForRow(row, newDelegate);
         }
     }
 }
 
 void BuildFilterOffsets::stopProcessing()
 {
     m_stopFlag = true;
     setBuildFilterOffsetsButtons(BFO_STOP);
 
     if (m_qItemInProgress.changeFilter)
     {
         // Change filter in progress. Let it run to completion
         m_abortAFPending = false;
     }
     else
     {
         // AF run is currently in progress so signal an abort
         buildOffsetsStatusBar->showMessage(i18n("Aborting Autofocus..."));
         m_abortAFPending = true;
         emit abortAutoFocus();
     }
 }
 
 // Callback when an item in the Model is changed
 void BuildFilterOffsets::itemChanged(QStandardItem *item)
 {
     if (item->column() == getColumn(BFO_NUM_FOCUS_RUNS))
     {
         if (item->row() == m_refFilter && m_BFOModel.item(item->row(), item->column())->text().toInt() == 0)
             // If user is trying to set the num AF runs of the ref filter to 0, set to 1
             m_BFOModel.setItem(item->row(), item->column(), new QStandardItem(QString::number(1)));
     }
     else if ((item->column() >= getColumn(BFO_AF_RUN_1)) && (item->column() < getColumn(BFO_AVERAGE)))
     {
         // One of the AF runs has changed so recalc the Average and Offset
         calculateAFAverage(item->row(), item->column());
         calculateOffset(item->row());
     }
 }
 
 // Callback when a row in the Model is changed
 void BuildFilterOffsets::refChanged(QModelIndex index)
 {
     if (m_inBuildOffsets)
         return;
 
     const int row = index.row();
     const int col = index.column();
     if (col == 0 && row >= 0 && row < m_filters.count() && row != m_refFilter)
     {
         // User double clicked the filter column in a different cell to the current ref filter
         QStandardItem* itemSelect = new QStandardItem(QString("%1 *").arg(m_filters[row]));
         m_BFOModel.setItem(row, getColumn(BFO_FILTER), itemSelect);
 
         // The ref filter needs to have at least 1 AF run so that there is an average
         // solution to base the offsets of other filters against... so force this condition
         if (getNumRuns(row) == 0)
             m_BFOModel.setItem(row, getColumn(BFO_NUM_FOCUS_RUNS), new QStandardItem(QString::number(1)));
 
         // Reset the previous selection
         QStandardItem* itemDeselect = new QStandardItem(m_filters[m_refFilter]);
         m_BFOModel.setItem(m_refFilter, getColumn(BFO_FILTER), itemDeselect);
 
         m_refFilter = row;
         // Resize the cols and dialog
         buildOffsetsDialogResize();
     }
 }
 
 // This routine calculates the average of the AF runs. Given that the number of runs is likely to be low
 // a simple average is used. The user may manually adjust the values.
 void BuildFilterOffsets::calculateAFAverage(const int row, const int col)
 {
     int numRuns;
     if (m_tableInEditMode)
         numRuns = getNumRuns(row);
     else
         numRuns = col - getColumn(BFO_AF_RUN_1) + 1;
 
     // Firstly, the average of the AF runs
     double total = 0;
     int useableRuns = numRuns;
     for(int i = 0; i < numRuns; i++)
     {
         int j = m_BFOModel.item(row, getColumn(BFO_AF_RUN_1) + i)->text().toInt();
         if (j > 0)
             total += j;
         else
             useableRuns--;
     }
 
     const int average = (useableRuns > 0) ? static_cast<int>(round(total / useableRuns)) : 0;
 
     // Update the Model with the newly calculated average
     QStandardItem *averageItem = new QStandardItem(QString::number(average));
     m_BFOModel.setItem(row, getColumn(BFO_AVERAGE), averageItem);
 }
 
 // calculateOffset updates new offsets when AF averages have been calculated. There are 2 posibilities:
 // 1. The updated row is the reference filter in the list so update the offset of other filters
 // 2. The updated row is another filter in which case just update its offset
 void BuildFilterOffsets::calculateOffset(const int row)
 {
     if (row == m_refFilter)
     {
         // The first filter has been changed so loop through the other filters and adjust the offsets
         if (m_tableInEditMode)
         {
             for (int i = 0; i < m_filters.count(); i++)
             {
                 if (i != m_refFilter && getNumRuns(i) > 0)
                     calculateOffset(i);
             }
         }
         else
         {
             // If there are some filters higher in the table than ref filter then these can only be
             // proessed now that the ref filter has been processed.
             for (int i = 0; i < m_refFilter; i++)
             {
                 if (getNumRuns(i) > 0)
                     calculateOffset(i);
             }
         }
     }
 
     // If we haven't processed the ref filter yet then skip over
     if (m_rowIdx >= m_refFilter)
     {
         // The ref filter has been processed so we can calculate the offset from it
         const int average = m_BFOModel.item(row, getColumn(BFO_AVERAGE))->text().toInt();
         const int refFilterAverage = m_BFOModel.item(m_refFilter, getColumn(BFO_AVERAGE))->text().toInt();
 
         // Calculate the offset and set it in the model
         const int offset = average - refFilterAverage;
         QStandardItem *offsetItem = new QStandardItem(QString::number(offset));
         m_BFOModel.setItem(row, getColumn(BFO_NEW_OFFSET), offsetItem);
 
         // Set the save checkbox
         QStandardItem *saveItem = new QStandardItem(QString::number(1));
         m_BFOModel.setItem(row, getColumn(BFO_SAVE_CHECK), saveItem);
     }
 }
 
 // Returns the column in the table for the passed in id. The structure is:
 // Col 0 -- BFO_FILTER         -- Filter name
 // Col 1 -- BFO_OFFSET         -- Current offset value
 // Col 2 -- BFO_LOCK           -- Lock filter name
 // Col 3 -- BFO_NUM_FOCUS_RUNS -- Number of AF runs
 // Col 4 -- BFO_AF_RUN_1       -- 1st AF run
 // Col x -- BFO_AVERAGE        -- Average AF run. User selects the number of AF runs at run time
 // Col y -- BFO_NEW_OFFSET     -- New offset.
 // Col z -- BFO_SAVE_CHECK     -- Save checkbox
 int BuildFilterOffsets::getColumn(const BFOColID id)
 {
     switch (id)
     {
         case BFO_FILTER:
         case BFO_OFFSET:
         case BFO_LOCK:
         case BFO_NUM_FOCUS_RUNS:
         case BFO_AF_RUN_1:
             break;
 
         case BFO_AVERAGE:
             return m_BFOModel.columnCount() - 3;
             break;
 
         case BFO_NEW_OFFSET:
             return m_BFOModel.columnCount() - 2;
             break;
 
         case BFO_SAVE_CHECK:
             return m_BFOModel.columnCount() - 1;
             break;
 
         default:
             break;
     }
     return id;
 }
 
 // Get the number of AF runs for the passed in row
 int BuildFilterOffsets::getNumRuns(const int row)
 {
     return m_BFOModel.item(row, getColumn(BFO_NUM_FOCUS_RUNS))->text().toInt();
 }
 
 // Get the maximum number of AF runs
 int BuildFilterOffsets::getMaxRuns()
 {
     return getColumn(BFO_AVERAGE) - getColumn(BFO_AF_RUN_1);
 }
 
 }