7#include "focusadvisor.h"
9#include "focusalgorithms.h"
11#include "ekos/auxiliary/opticaltrainmanager.h"
12#include "ekos/auxiliary/opticaltrainsettings.h"
13#include "ekos/auxiliary/stellarsolverprofile.h"
18const char * FOCUSER_SIMULATOR =
"Focuser Simulator";
19const int MAXIMUM_FOCUS_ADVISOR_ITERATIONS = 1001;
20const int NUM_JUMPS_PER_SECTOR = 10;
21const int FIND_STARS_MIN_STARS = 2;
22const double TARGET_MAXMIN_HFR_RATIO = 3.0;
23const double INITIAL_MAXMIN_HFR_RATIO = 2.0;
24const int NUM_STEPS_PRE_AF = 11;
33 m_focus =
static_cast<Focus *
>(parent);
39FocusAdvisor::~FocusAdvisor()
43void FocusAdvisor::processUI()
46 m_helpDialog =
new QDialog(
this);
47 m_helpUI.reset(
new Ui::focusAdvisorHelpDialog());
48 m_helpUI->setupUi(m_helpDialog);
58 m_runButton->setToolTip(
"Run Focus Advisor");
59 m_stopButton->setToolTip(
"Stop Focus Advisor");
60 m_helpButton->setToolTip(
"List parameter settings");
74void FocusAdvisor::setupResultsTable()
76 focusAdvTable->setColumnCount(RESULTS_MAX_COLS);
77 focusAdvTable->setRowCount(0);
81 focusAdvTable->setHorizontalHeaderItem(RESULTS_SECTION, itemSection);
85 focusAdvTable->setHorizontalHeaderItem(RESULTS_RUN_NUMBER, itemRunNumber);
89 focusAdvTable->setHorizontalHeaderItem(RESULTS_START_POSITION, itemStartPosition);
93 focusAdvTable->setHorizontalHeaderItem(RESULTS_STEP_SIZE, itemStepSize);
97 focusAdvTable->setHorizontalHeaderItem(RESULTS_AFOVERSCAN, itemAFOverscan);
101 focusAdvTable->setHorizontalHeaderItem(RESULTS_TEXT, itemText);
104 focusAdvTable->hide();
109void FocusAdvisor::setupHelpTable()
113 m_helpUI->table->setHorizontalHeaderItem(HELP_PARAMETER, itemParameter);
116 itemCurrentValue->
setToolTip(
i18n(
"Current value of the parameter"));
117 m_helpUI->table->setHorizontalHeaderItem(HELP_CURRENT_VALUE, itemCurrentValue);
120 itemProposedValue->
setToolTip(
i18n(
"Focus Advisor proposed value for the parameter"));
121 m_helpUI->table->setHorizontalHeaderItem(HELP_NEW_VALUE, itemProposedValue);
129void FocusAdvisor::setButtons(
const bool running)
131 bool canRun = m_focus->m_Focuser && m_focus->m_Focuser->isConnected() && m_focus->m_Focuser->canAbsMove();
132 m_runButton->setEnabled(!running && canRun);
133 m_stopButton->setEnabled(running);
134 m_helpButton->setEnabled(!running);
138bool FocusAdvisor::canFocusAdvisorRun()
141 return m_focus->m_Focuser && m_focus->m_Focuser->isConnected() && m_focus->m_Focuser->canAbsMove() &&
142 m_focus->m_FocusAlgorithm == Focus::FOCUS_LINEAR1PASS &&
143 (m_focus->m_StarMeasure == Focus::FOCUS_STAR_HFR || m_focus->m_StarMeasure == Focus::FOCUS_STAR_HFR_ADJ
144 || m_focus->m_StarMeasure == Focus::FOCUS_STAR_FWHM) &&
145 (m_focus->m_CurveFit == CurveFitting::FOCUS_HYPERBOLA || m_focus->m_CurveFit == CurveFitting::FOCUS_PARABOLA);
148bool FocusAdvisor::start()
151 focusAdvTable->setRowCount(0);
152 focusAdvTable->sizePolicy();
157 if (m_focus->inFocusLoop || m_focus->inAdjustFocus || m_focus->inAutoFocus || m_focus->inBuildOffsets
158 || m_focus->inScanStartPos || inFocusAdvisor())
160 m_focus->appendLogText(
i18n(
"Focus Advisor: another focus action in progress. Please try again."));
164 if (focusAdvUpdateParams->isChecked())
167 focusAdvUpdateParamsLabel->setText(
i18n(
"Done"));
168 emit newStage(UpdatingParameters);
171 m_inFindStars = focusAdvFindStars->isChecked();
172 m_inPreAFAdj = focusAdvCoarseAdj->isChecked();
173 m_inAFAdj = focusAdvFineAdj->isChecked();
174 if (m_inFindStars || m_inPreAFAdj || m_inAFAdj)
176 if (canFocusAdvisorRun())
179 m_initialScanStartPos = m_focus->m_OpsFocusProcess->focusScanStartPos->isChecked();
180 m_focus->m_OpsFocusProcess->focusScanStartPos->setChecked(
false);
181 m_focus->runAutoFocus(FOCUS_FOCUS_ADVISOR,
"");
185 m_focus->appendLogText(
i18n(
"Focus Advisor cannot run with current params."));
193void FocusAdvisor::stop()
195 abort(
i18n(
"Focus Advisor stopped"));
200void FocusAdvisor::help()
203 m_helpDialog->show();
204 m_helpDialog->raise();
207void FocusAdvisor::addSectionToHelpTable(
int &row,
const QString §ion)
209 if (++row >= m_helpUI->table->rowCount())
210 m_helpUI->table->setRowCount(row + 1);
217 m_helpUI->table->setItem(row, HELP_PARAMETER, item);
220void FocusAdvisor::addParamToHelpTable(
int &row,
const QString ¶meter,
const QString ¤tValue,
223 if (m_helpUI->focusAdvHelpOnlyChanges->isChecked() && newValue == currentValue)
226 if (++row >= m_helpUI->table->rowCount())
227 m_helpUI->table->setRowCount(row + 1);
229 m_helpUI->table->setItem(row, HELP_PARAMETER, itemParameter);
231 m_helpUI->table->setItem(row, HELP_CURRENT_VALUE, itemCurrentValue);
233 if (newValue != currentValue)
240 m_helpUI->table->setItem(row, HELP_NEW_VALUE, itemNewValue);
244void FocusAdvisor::resizeHelpDialog()
251 m_helpUI->verticalLayout->layout()->getContentsMargins(&left, &top, &right, &bottom);
253 const int width = m_helpUI->table->horizontalHeader()->length() +
254 m_helpUI->table->verticalHeader()->width() +
255 m_helpUI->table->verticalScrollBar()->width() +
256 m_helpUI->table->frameWidth() * 2 +
258 m_helpDialog->contentsMargins().left() + m_helpDialog->contentsMargins().right() + 8;
260 m_helpDialog->resize(width, m_helpDialog->height());
264void FocusAdvisor::updateParams()
266 m_focus->setAllSettings(m_map);
267 addResultsTable(
i18n(
"Update Parameters"), -1, -1, -1, -1,
"Done");
271void FocusAdvisor::setupParams(
const QString &OTName)
274 m_map = getOTDefaults(OTName);
275 bool noDefaults = m_map.isEmpty();
277 if (!m_map.isEmpty())
281 bool longFL = m_focus->m_FocalLength > 1500;
282 double imageScale = m_focus->getStarUnits(Focus::FOCUS_STAR_HFR, Focus::FOCUS_UNITS_ARCSEC);
283 bool centralObstruction = scopeHasObstruction(m_focus->m_ScopeType);
286 m_helpUI->helpLabel->setText(
QString(
"Recommendations: %1 FL=%2 ImageScale=%3")
287 .arg(m_focus->m_ScopeType).
arg(m_focus->m_FocalLength).
arg(imageScale, 0,
'f', 2));
291 m_helpUI->table->setRowCount(0);
295 addSectionToHelpTable(row,
i18n(
"Camera & Filter Wheel Parameters"));
298 double exposure = longFL ? 4.0 : 2.0;
299 processParam(exposure, row, m_map, m_focus->focusExposure,
"Exposure");
303 if (m_focus->focusBinning->isEnabled())
306 QString binTarget = (imageScale < 1.0) ?
"2x2" :
"1x1";
308 for (
int i = 0; i < m_focus->focusBinning->count(); i++)
310 if (m_focus->focusBinning->itemText(i) == binTarget)
317 processParam(binning, row, m_map, m_focus->focusBinning,
"Binning");
320 processParam(m_focus->focusGain->value(), row, m_map, m_focus->focusGain,
"Gain");
323 processParam(m_focus->focusISO->currentText(), row, m_map, m_focus->focusISO,
"ISO");
326 processParam(m_focus->focusFilter->currentText(), row, m_map, m_focus->focusFilter,
"Filter");
329 addSectionToHelpTable(row,
i18n(
"Settings Parameters"));
332 processParam(
false, row, m_map, m_focus->m_OpsFocusSettings->focusAutoStarEnabled,
"Auto Select Star");
335 processParam(m_focus->m_OpsFocusSettings->focusSuspendGuiding->isChecked(), row, m_map,
336 m_focus->m_OpsFocusSettings->focusSuspendGuiding,
"Auto Select Star");
339 processParam(
false, row, m_map, m_focus->m_OpsFocusSettings->useFocusDarkFrame,
"Dark Frame");
342 processParam(
true, row, m_map, m_focus->m_OpsFocusSettings->focusUseFullField,
"Full Field");
343 processParam(
false, row, m_map, m_focus->m_OpsFocusSettings->focusSubFrame,
"Sub Frame");
346 processParam(32, row, m_map, m_focus->m_OpsFocusSettings->focusBoxSize,
"Box");
349 processParam(m_focus->m_OpsFocusSettings->focusUnits->currentText(), row, m_map, m_focus->m_OpsFocusSettings->focusUnits,
353 processParam(m_focus->m_OpsFocusSettings->focusGuideSettleTime->value(), row, m_map,
354 m_focus->m_OpsFocusSettings->focusGuideSettleTime,
"Guide Settle");
358 if (m_focus->m_OpsFocusSettings->focusNoMaskRB->isChecked())
359 maskCurrent =
"Use all stars";
360 else if (m_focus->m_OpsFocusSettings->focusRingMaskRB->isChecked())
362 double inner = m_focus->m_OpsFocusSettings->focusFullFieldInnerRadius->value();
363 double outer = m_focus->m_OpsFocusSettings->focusFullFieldOuterRadius->value();
364 maskCurrent =
QString(
"Ring Mask %1%-%2%").
arg(inner, 0,
'f', 1).
arg(outer, 0,
'f', 1);
368 int width = m_focus->m_OpsFocusSettings->focusMosaicTileWidth->value();
369 int spacer = m_focus->m_OpsFocusSettings->focusMosaicSpace->value();
370 maskCurrent =
QString(
"Mosaic Mask %1% (%2 px)").
arg(width).
arg(spacer);
376 m_map.insert(
"focusNoMaskRB",
false);
377 m_map.insert(
"focusRingMaskRB",
true);
378 m_map.insert(
"focusMosaicMaskRB",
false);
379 m_map.insert(
"focusFullFieldInnerRadius", 0.0);
380 m_map.insert(
"focusFullFieldOuterRadius", 80.0);
381 maskNew =
QString(
"Ring Mask %1%-%2%").
arg(0.0, 0,
'f', 1).
arg(80.0, 0,
'f', 1);
385 bool noMask = m_map.value(
"focusNoMaskRB",
false).toBool();
386 bool ringMask = m_map.value(
"focusRingMaskRB",
false).toBool();
387 bool mosaicMask = m_map.value(
"focusMosaicMaskRB",
false).toBool();
389 maskNew =
"Use all stars";
392 double inner = m_map.value(
"focusFullFieldInnerRadius", 0.0).toDouble(&ok);
393 if (!ok || inner < 0.0 || inner > 100.0)
395 double outer = m_map.value(
"focusFullFieldOuterRadius", 80.0).toDouble(&ok);
396 if (!ok || outer < 0.0 || outer > 100.0)
398 maskNew =
QString(
"Ring Mask %1%-%2%").
arg(inner, 0,
'f', 1).
arg(outer, 0,
'f', 1);
402 int width = m_map.value(
"focusMosaicTileWidth", 0.0).toInt(&ok);
403 if (!ok || width < 0 || width > 100)
405 int spacer = m_map.value(
"focusMosaicSpace", 0.0).toInt(&ok);
406 if (!ok || spacer < 0 || spacer > 100)
408 maskNew =
QString(
"Mosaic Mask %1% (%2 px)").
arg(width).
arg(spacer);
411 addParamToHelpTable(row,
i18n(
"Mask"), maskCurrent, maskNew);
414 processParam(
false, row, m_map, m_focus->m_OpsFocusSettings->focusAdaptive,
"Adaptive Focus");
417 processParam(m_focus->m_OpsFocusSettings->focusAdaptiveMinMove->value(), row, m_map,
418 m_focus->m_OpsFocusSettings->focusAdaptiveMinMove,
"Min Move");
421 processParam(
false, row, m_map, m_focus->m_OpsFocusSettings->focusAdaptStart,
"Adapt Start Pos");
424 processParam(m_focus->m_OpsFocusSettings->focusAdaptiveMaxMove->value(), row, m_map,
425 m_focus->m_OpsFocusSettings->focusAdaptiveMaxMove,
"Max Total Move");
428 addSectionToHelpTable(row,
i18n(
"Process Parameters"));
431 processParam(
QString(
"SEP"), row, m_map, m_focus->m_OpsFocusProcess->focusDetection,
"Detection");
434 QString profile = centralObstruction ? FOCUS_DEFAULT_DONUT_NAME : FOCUS_DEFAULT_NAME;
435 processParam(profile, row, m_map, m_focus->m_OpsFocusProcess->focusSEPProfile,
"SEP Profile");
438 processParam(
QString(
"Linear 1 Pass"), row, m_map, m_focus->m_OpsFocusProcess->focusAlgorithm,
"Algorithm");
441 processParam(
QString(
"Hyperbola"), row, m_map, m_focus->m_OpsFocusProcess->focusCurveFit,
"Curve Fit");
444 processParam(
QString(
"HFR"), row, m_map, m_focus->m_OpsFocusProcess->focusStarMeasure,
"Measure");
447 processParam(
true, row, m_map, m_focus->m_OpsFocusProcess->focusUseWeights,
"Use Weights");
450 processParam(0.8, row, m_map, m_focus->m_OpsFocusProcess->focusR2Limit,
"R² Limit");
453 processParam(
true, row, m_map, m_focus->m_OpsFocusProcess->focusRefineCurveFit,
"Refine Curve Fit");
456 processParam(1, row, m_map, m_focus->m_OpsFocusProcess->focusFramesCount,
"Average Over");
459 processParam(1, row, m_map, m_focus->m_OpsFocusProcess->focusHFRFramesCount,
"Average HFR Check");
462 processParam(centralObstruction, row, m_map, m_focus->m_OpsFocusProcess->focusDonut,
"Donut Buster");
463 processParam(1.0, row, m_map, m_focus->m_OpsFocusProcess->focusTimeDilation,
"Time Dilation x");
464 processParam(0.2, row, m_map, m_focus->m_OpsFocusProcess->focusOutlierRejection,
"Outlier Rejection");
467 processParam(
true, row, m_map, m_focus->m_OpsFocusProcess->focusScanStartPos,
"Scan for Start Position");
468 processParam(
false, row, m_map, m_focus->m_OpsFocusProcess->focusScanAlwaysOn,
"Always On");
469 processParam(5, row, m_map, m_focus->m_OpsFocusProcess->focusScanDatapoints,
"Num Datapoints");
470 processParam(1.0, row, m_map, m_focus->m_OpsFocusProcess->focusScanStepSizeFactor,
"Initial Step Sixe x");
473 addSectionToHelpTable(row,
i18n(
"Mechanics Parameters"));
476 processParam(
QString(
"Fixed Steps"), row, m_map, m_focus->m_OpsFocusMechanics->focusWalk,
"Walk");
479 processParam(1.0, row, m_map, m_focus->m_OpsFocusMechanics->focusSettleTime,
"Focuser Settle");
482 int stepSize = m_focus->m_Focuser && m_focus->m_Focuser->getDeviceName() == FOCUSER_SIMULATOR ? 5000 : 20;
483 processParam(stepSize, row, m_map, m_focus->m_OpsFocusMechanics->focusTicks,
"Initial Step Size");
486 processParam(11, row, m_map, m_focus->m_OpsFocusMechanics->focusNumSteps,
"Number Steps");
489 processParam(m_focus->m_OpsFocusMechanics->focusMaxTravel->maximum(), row, m_map,
490 m_focus->m_OpsFocusMechanics->focusMaxTravel,
"Max Travel");
493 processParam(m_focus->m_OpsFocusMechanics->focusBacklash->value(), row, m_map, m_focus->m_OpsFocusMechanics->focusBacklash,
497 processParam(m_focus->m_OpsFocusMechanics->focusAFOverscan->value(), row, m_map,
498 m_focus->m_OpsFocusMechanics->focusAFOverscan,
"AF Overscan");
501 processParam(0.0, row, m_map, m_focus->m_OpsFocusMechanics->focusOverscanDelay,
"AF Overscan Delay");
504 processParam(30, row, m_map, m_focus->m_OpsFocusMechanics->focusCaptureTimeout,
"Capture Timeout");
507 processParam(30, row, m_map, m_focus->m_OpsFocusMechanics->focusMotionTimeout,
"Motion Timeout");
513QString FocusAdvisor::boolText(
const bool flag)
515 return flag ?
"On" :
"Off";
519void FocusAdvisor::setInFocusAdvisor(
bool value)
521 m_inFocusAdvisor = value;
525QString FocusAdvisor::getFocusFramePrefix()
528 if (inFocusAdvisor() && m_inFindStars)
529 prefix =
"_fs_" +
QString(
"%1_%2").
arg(m_findStarsRunNum).
arg(m_focus->absIterations + 1);
530 else if (inFocusAdvisor() && m_inPreAFAdj)
531 prefix =
"_ca_" +
QString(
"%1_%2").
arg(m_preAFRunNum).
arg(m_focus->absIterations + 1);
532 else if (inFocusAdvisor() && m_focus->inScanStartPos)
533 prefix =
"_ssp_" +
QString(
"%1_%2").
arg(m_focus->m_AFRun).
arg(m_focus->absIterations + 1);
538QVariantMap FocusAdvisor::getOTDefaults(
const QString &OTName)
546 for (
auto &tName : OpticalTrainManager::Instance()->getTrainNames())
550 auto tFocuser = OpticalTrainManager::Instance()->getFocuser(tName);
551 if (tFocuser != m_focus->m_Focuser)
553 auto tScope = OpticalTrainManager::Instance()->getScope(tName);
554 auto tScopeType = tScope[
"type"].toString();
555 if (tScopeType != m_focus->m_ScopeType)
559 auto tID = OpticalTrainManager::Instance()->id(tName);
560 OpticalTrainSettings::Instance()->setOpticalTrainID(tID);
561 auto settings = OpticalTrainSettings::Instance()->getOneSetting(OpticalTrainSettings::Focus);
562 if (settings.isValid())
565 map = settings.toJsonObject().toVariantMap();
568 auto tAperture = tScope[
"aperture"].toDouble(-1);
569 auto tFocalLength = tScope[
"focal_length"].toDouble(-1);
570 auto tFocalRatio = tScope[
"focal_ratio"].toDouble(-1);
571 auto tReducer = OpticalTrainManager::Instance()->getReducer(tName);
572 if (tFocalLength > 0.0)
573 tFocalLength *= tReducer;
576 if (tFocalRatio <= 0.0)
578 tFocalRatio = (tAperture > 0.001) ? tFocalLength / tAperture : 0.0f;
584 if (m_focus->m_Focuser && m_focus->m_Focuser->getDeviceName() == FOCUSER_SIMULATOR)
588 stepSize =
map.value(
"focusTicks", stepSize).toInt() * pow(m_focus->m_FocalRatio, 2.0) / pow(tFocalRatio, 2.0);
590 map.insert(
"focusTicks", stepSize);
595 auto id = OpticalTrainManager::Instance()->id(OTName);
596 OpticalTrainSettings::Instance()->setOpticalTrainID(
id);
604bool FocusAdvisor::scopeHasObstruction(
const QString &scopeType)
606 return (scopeType !=
"Refractor" && scopeType !=
"Kutter (Schiefspiegler)");
610void FocusAdvisor::initControl()
612 setInFocusAdvisor(
true);
614 m_initialStepSize = m_focus->m_OpsFocusMechanics->focusTicks->value();
615 m_initialBacklash = m_focus->m_OpsFocusMechanics->focusBacklash->value();
616 m_initialAFOverscan = m_focus->m_OpsFocusMechanics->focusAFOverscan->value();
617 m_initialUseWeights = m_focus->m_OpsFocusProcess->focusUseWeights->isChecked();
620 initFindStars(m_focus->currentPosition);
621 else if (m_inPreAFAdj)
622 initPreAFAdj(m_focus->currentPosition);
624 initAFAdj(m_focus->currentPosition,
false);
628void FocusAdvisor::control()
630 if (!inFocusAdvisor())
635 else if (m_inPreAFAdj)
638 abort(
i18n(
"Focus Advisor aborted due to internal error"));
642void FocusAdvisor::initFindStars(
const int startPos)
645 if (!canFocusAdvisorRun())
647 abort(
i18n(
"Focus Advisor cannot run with current params"));
651 focusAdvFindStarsLabel->setText(
i18n(
"In progress..."));
652 emit newStage(FindingStars);
655 m_focus->initialFocuserAbsPosition = startPos;
656 m_focus->linearRequestedPosition = startPos;
659 m_focus->m_OpsFocusProcess->focusUseWeights->setChecked(
false);
661 m_focus->absIterations = 0;
664 m_focus->clearDataPoints();
665 m_jumpsToGo = NUM_JUMPS_PER_SECTOR;
666 m_jumpSize = m_focus->m_OpsFocusMechanics->focusTicks->value() * NUM_JUMPS_PER_SECTOR;
667 m_findStarsIn =
false;
668 m_findStarsMaxBound = m_findStarsMinBound =
false;
669 m_findStarsSector = 0;
670 m_findStarsRange =
false;
671 m_findStarsRangeIn =
false;
672 m_findStarsFindInEdge =
false;
673 m_findStarsInRange = -1;
674 m_findStarsOutRange = -1;
678 m_focus->m_OpsFocusMechanics->focusBacklash->setValue(0);
679 m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(0);
681 addResultsTable(
i18n(
"Find Stars"), m_findStarsRunNum, startPos, m_jumpSize,
682 m_focus->m_OpsFocusMechanics->focusAFOverscan->value(),
"");
683 emit m_focus->setTitle(
QString(
i18n(
"Find Stars: Scanning for stars...")),
true);
684 if (!m_focus->changeFocus(startPos - m_focus->currentPosition))
685 abort(
i18n(
"Find Stars: Failed"));
692void FocusAdvisor::findStars()
695 emit m_focus->newHFRPlotPosition(
static_cast<double>(m_focus->currentPosition), m_focus->currentMeasure,
696 std::pow(m_focus->currentWeight, -0.5),
false, m_jumpSize,
true);
699 bool starsExist = starsFound();
700 if (m_findStarsRange)
702 bool outOfRange =
false;
706 if (m_findStarsRangeIn)
707 outOfRange = (m_focus->currentPosition - m_jumpSize) <
static_cast<int>(m_focus->absMotionMin);
709 outOfRange = (m_focus->currentPosition + m_jumpSize) >
static_cast<int>(m_focus->absMotionMax);
712 if (m_findStarsFindInEdge)
717 m_findStarsFindInEdge =
false;
718 m_findStarsInRange = m_focus->currentPosition - m_jumpSize;
721 else if (!starsExist && m_findStarsInRange < 0 && m_findStarsOutRange < 0)
725 if (m_findStarsRangeIn)
727 m_findStarsInRange = m_focus->currentPosition;
728 auto max = std::max_element(std::begin(m_position), std::end(m_position));
729 offset = *max - m_focus->currentPosition;
733 m_findStarsOutRange = m_focus->currentPosition;
734 auto min = std::min_element(std::begin(m_position), std::end(m_position));
735 offset = *min - m_focus->currentPosition;
737 m_findStarsRangeIn = !m_findStarsRangeIn;
739 else if (!starsExist || outOfRange)
743 m_inFindStars =
false;
744 if (m_findStarsRangeIn)
746 m_findStarsInRange = m_focus->currentPosition;
749 m_findStarsOutRange = m_focus->currentPosition;
750 const int zoneCentre = (m_findStarsInRange + m_findStarsOutRange) / 2;
751 focusAdvFindStarsLabel->setText(
i18n(
"Done"));
755 initPreAFAdj(zoneCentre);
757 initAFAdj(zoneCentre,
true);
760 m_focus->absTicksSpin->setValue(zoneCentre);
761 emit m_focus->setTitle(
QString(
i18n(
"Stars detected, range centre %1", zoneCentre)),
true);
762 complete(
false,
i18n(
"Focus Advisor Find Stars completed"));
769 m_position.push_back(m_focus->currentPosition);
770 m_measure.push_back(m_focus->currentMeasure);
777 if (!m_findStarsRange)
779 m_findStarsRange =
true;
783 if (m_position.size() > 1)
785 if (m_position.last() < m_position[m_position.size() - 2])
789 std::sort(positionsCopy.
begin(), positionsCopy.
end(), std::greater<int>());
790 m_findStarsOutRange = positionsCopy[1];
791 m_findStarsOutRange = m_position[m_position.size() - 2];
792 m_findStarsRangeIn =
true;
798 m_findStarsFindInEdge =
true;
800 std::sort(positionsCopy.
begin(), positionsCopy.
end(), std::greater<int>());
801 offset = positionsCopy[1] - m_focus->currentPosition;
808 if (++m_focus->absIterations > MAXIMUM_FOCUS_ADVISOR_ITERATIONS)
810 abort(
i18n(
"Find Stars: exceeded max iterations %1", MAXIMUM_FOCUS_ADVISOR_ITERATIONS));
815 if (m_findStarsRange)
818 emit m_focus->setTitle(
QString(
i18n(
"Stars detected, centering range")),
true);
819 updateResultsTable(
i18n(
"Stars detected, centering range"));
821 if (m_findStarsRangeIn)
822 nextPos = std::max(m_focus->currentPosition + offset - m_jumpSize,
static_cast<int>(m_focus->absMotionMin));
824 nextPos = std::min(m_focus->currentPosition + offset + m_jumpSize,
static_cast<int>(m_focus->absMotionMax));
825 deltaPos = nextPos - m_focus->currentPosition;
827 else if (m_position.size() == 1)
830 deltaPos = m_jumpSize * m_jumpsToGo;
832 if (m_focus->currentPosition + deltaPos >= m_focus->absMotionMax)
834 deltaPos = m_focus->absMotionMax - m_focus->currentPosition;
835 m_jumpsToGo = deltaPos / m_jumpSize + (deltaPos % m_jumpSize != 0);
836 m_findStarsMaxBound =
true;
838 m_findStarsJumpsInSector = m_jumpsToGo;
839 m_findStarsSector = 1;
840 emit m_focus->setTitle(
QString(
i18n(
"Find Stars Run %1: No stars at start %2, scanning...", m_findStarsRunNum,
841 m_focus->currentPosition)),
true);
843 else if (m_jumpsToGo > 0)
846 emit m_focus->setTitle(
QString(
i18n(
"Find Stars Run %1 Sector %2: Scanning %3/%4", m_findStarsRunNum, m_findStarsSector,
847 m_jumpsToGo, m_findStarsJumpsInSector)),
true);
848 updateResultsTable(
i18n(
"Find Stars Run %1: Scanning Sector %2", m_findStarsRunNum, m_findStarsSector));
849 int nextPos = std::max(m_focus->currentPosition - m_jumpSize,
static_cast<int>(m_focus->absMotionMin));
850 deltaPos = nextPos - m_focus->currentPosition;
855 if(m_findStarsMaxBound && m_findStarsMinBound)
859 updateResultsTable(
i18n(
"No stars detected"));
860 int newStepSize = m_focus->m_OpsFocusMechanics->focusTicks->value() / 2;
863 m_focus->m_OpsFocusMechanics->focusTicks->setValue(newStepSize);
864 initFindStars(m_focus->initialFocuserAbsPosition);
867 abort(
i18n(
"Find Stars Run %1: failed to find any stars", m_findStarsRunNum));
872 m_jumpsToGo = NUM_JUMPS_PER_SECTOR;
876 if (m_findStarsMaxBound)
879 if (m_focus->currentPosition - m_jumpSize <
static_cast<int>(m_focus->absMotionMin))
880 deltaPos =
static_cast<int>(m_focus->absMotionMin) - m_focus->currentPosition;
882 deltaPos = -m_jumpSize;
886 auto max = std::max_element(std::begin(m_position), std::end(m_position));
887 int sweepMax = *max + (m_jumpSize * m_jumpsToGo);
888 if (sweepMax >=
static_cast<int>(m_focus->absMotionMax))
890 sweepMax =
static_cast<int>(m_focus->absMotionMax);
891 m_jumpsToGo = (sweepMax - *max) / m_jumpSize + ((sweepMax - *max) % m_jumpSize != 0);
892 m_findStarsMaxBound =
true;
894 m_findStarsIn =
false;
895 deltaPos = sweepMax - m_focus->currentPosition;
901 if (m_findStarsMinBound)
903 auto max = std::max_element(std::begin(m_position), std::end(m_position));
904 int sweepMax = *max + (m_jumpSize * m_jumpsToGo);
905 if (sweepMax >=
static_cast<int>(m_focus->absMotionMax))
907 sweepMax =
static_cast<int>(m_focus->absMotionMax);
908 m_jumpsToGo = (sweepMax - *max) / m_jumpSize + ((sweepMax - *max) % m_jumpSize != 0);
909 m_findStarsMaxBound =
true;
911 deltaPos = sweepMax - m_focus->currentPosition;
915 auto min = std::min_element(std::begin(m_position), std::end(m_position));
916 int sweepMin = *min - (m_jumpSize * m_jumpsToGo);
917 if (sweepMin <=
static_cast<int>(m_focus->absMotionMin))
920 m_findStarsMinBound =
true;
921 sweepMin =
static_cast<int>(m_focus->absMotionMin);
922 m_jumpsToGo = (*min - sweepMin) / m_jumpSize + ((*min - sweepMin) % m_jumpSize != 0);
925 m_findStarsIn =
true;
926 int nextJumpPos = std::max(*min - m_jumpSize,
static_cast<int>(m_focus->absMotionMin));
927 deltaPos = nextJumpPos - m_focus->currentPosition;
931 m_findStarsJumpsInSector = m_jumpsToGo;
932 emit m_focus->setTitle(
QString(
i18n(
"Find Stars Run %1 Sector %2: scanning %3/%4", m_findStarsRunNum, m_findStarsSector,
933 m_jumpsToGo, m_findStarsJumpsInSector)),
true);
935 if (!m_findStarsRange)
937 m_focus->linearRequestedPosition = m_focus->currentPosition + deltaPos;
938 if (!m_focus->changeFocus(deltaPos))
939 abort(
i18n(
"Focus Advisor Find Stars run %1: failed to move focuser", m_findStarsRunNum));
942bool FocusAdvisor::starsFound()
944 return (m_focus->currentMeasure != INVALID_STAR_MEASURE && m_focus->currentNumStars > FIND_STARS_MIN_STARS);
949void FocusAdvisor::initPreAFAdj(
const int startPos)
952 if (!canFocusAdvisorRun())
954 abort(
i18n(
"Focus Advisor cannot run with current params"));
959 if (m_preAFRunNum > 50)
961 abort(
i18n(
"Focus Advisor Coarse Adjustment aborted after %1 runs", m_preAFRunNum));
965 focusAdvCoarseAdjLabel->setText(
i18n(
"In progress..."));
966 emit newStage(CoarseAdjustments);
968 m_focus->initialFocuserAbsPosition = startPos;
969 m_focus->absIterations = 0;
973 m_preAFNoStarsOut = m_preAFNoStarsIn =
false;
977 m_focus->clearDataPoints();
978 emit m_focus->setTitle(
QString(
i18n(
"Coarse Adjustment Scan...")),
true);
981 m_jumpSize = m_focus->m_OpsFocusMechanics->focusTicks->value() * NUM_STEPS_PRE_AF;
984 if (m_jumpSize > m_focus->absMotionMax - m_focus->absMotionMin)
986 m_jumpSize = m_focus->absMotionMax - m_focus->absMotionMin;
987 m_focus->m_OpsFocusMechanics->focusTicks->setValue(m_jumpSize / NUM_STEPS_PRE_AF);
990 int deltaPos = (startPos - m_focus->currentPosition) + m_jumpSize / 2;
991 if (m_focus->currentPosition + deltaPos > maxStarsLimit())
992 deltaPos = maxStarsLimit() - m_focus->currentPosition;
994 m_preAFInner = startPos - m_jumpSize / 2;
995 if (m_preAFInner < minStarsLimit())
996 m_preAFInner = minStarsLimit();
999 if (m_preAFRunNum == 1)
1001 m_focus->m_OpsFocusMechanics->focusBacklash->setValue(0);
1002 m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(0);
1003 m_focus->m_OpsFocusProcess->focusUseWeights->setChecked(m_initialUseWeights);
1006 addResultsTable(
i18n(
"Coarse Adjustment"), m_preAFRunNum, startPos,
1007 m_focus->m_OpsFocusMechanics->focusTicks->value(),
1008 m_focus->m_OpsFocusMechanics->focusAFOverscan->value(),
"");
1010 m_focus->linearRequestedPosition = m_focus->currentPosition + deltaPos;
1011 if (!m_focus->changeFocus(deltaPos))
1012 abort(
i18n(
"Focus Advisor Coarse Adjustment failed to move focuser"));
1017void FocusAdvisor::preAFAdj()
1020 if (++m_focus->absIterations > MAXIMUM_FOCUS_ADVISOR_ITERATIONS)
1022 abort(
i18n(
"Focus Advisor Coarse Adjustment: exceeded max iterations %1", MAXIMUM_FOCUS_ADVISOR_ITERATIONS));
1027 const int step = m_focus->m_OpsFocusMechanics->focusTicks->value();
1029 bool starsExist = starsFound();
1033 m_position.push_back(m_focus->currentPosition);
1034 m_measure.push_back(m_focus->currentMeasure);
1036 if (m_preAFNoStarsOut && (m_position.size() == 0))
1038 if (m_findStarsOutRange < 0)
1039 m_findStarsOutRange = m_focus->currentPosition;
1041 m_findStarsOutRange = std::max(m_findStarsOutRange, m_focus->currentPosition);
1047 if (m_position.size() < 2)
1048 m_preAFNoStarsOut =
true;
1049 else if (m_focus->currentPosition - (2 * step) <= m_preAFInner)
1051 m_preAFNoStarsIn =
true;
1052 if (m_findStarsInRange < 0)
1053 m_findStarsInRange = m_position.last();
1055 m_findStarsInRange = std::min(m_findStarsInRange, m_position.last());
1059 emit m_focus->newHFRPlotPosition(
static_cast<double>(m_focus->currentPosition), m_focus->currentMeasure,
1060 std::pow(m_focus->currentWeight, -0.5),
false, step,
true);
1063 if (m_focus->currentPosition - step < m_preAFInner && starsExist)
1066 auto it = std::min_element(std::begin(m_measure), std::end(m_measure));
1067 auto min = std::distance(std::begin(m_measure), it);
1068 if (m_position.size() < 5 || (m_position.size() < 2 * NUM_STEPS_PRE_AF && m_position.size() - min < 3))
1071 if (m_preAFInner - step >= minStarsLimit())
1072 m_preAFInner -= step;
1076 if (m_focus->currentPosition - step >= m_preAFInner)
1079 emit m_focus->setTitle(
QString(
i18n(
"Coarse Adjustment Run %1 scan...", m_preAFRunNum)),
true);
1085 if (m_position.size() < 5)
1087 abort(
i18n(
"Focus Advisor Coarse Adjustment Run %1: insufficient data to proceed", m_preAFRunNum));
1092 auto it = std::min_element(std::begin(m_measure), std::end(m_measure));
1093 auto min = std::distance(std::begin(m_measure), it);
1094 const double minMeasure = *it;
1095 int minPos = m_position[min];
1097 auto it2 = std::max_element(std::begin(m_measure), std::end(m_measure));
1098 const double maxMeasure = *it2;
1100 const double scaling =
static_cast<double>(NUM_STEPS_PRE_AF) /
static_cast<double>(m_measure.count());
1101 const double measureRatio = maxMeasure / minMeasure * scaling;
1104 double whereInRange =
static_cast<double>(minPos - m_position.last()) /
static_cast<double>
1105 (m_position.first() - m_position.last());
1106 bool nearCenter = whereInRange > 0.3 && whereInRange < 0.7;
1109 for (
int i = 0; i < m_position.size() - 1; i++)
1111 double gradient = (m_measure[i] - m_measure[i + 1]) / (m_position[i] - m_position[i + 1]);
1112 gradients.
push_back(std::abs(gradient));
1118 std::sort(gradientsCopy.
begin(), gradientsCopy.
end(), std::greater<double>());
1119 std::vector<double> gradientsMax;
1120 for (
int i = 0; i < 3; i++)
1121 gradientsMax.push_back(gradientsCopy[i]);
1123 double gradientsMean = Mathematics::RobustStatistics::ComputeLocation(Mathematics::RobustStatistics::LOCATION_MEAN,
1126 const double threshold = gradientsMean * 0.5;
1127 int overscan = m_focus->m_OpsFocusMechanics->focusAFOverscan->value();
1128 for (
int i = 0; i < gradients.
size(); i++)
1130 if (gradients[i] <= threshold)
1131 overscan += m_position[i] - m_position[i + 1];
1135 overscan = std::max(overscan, step);
1136 m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(overscan);
1138 const bool hitNoStarsRegion = m_preAFNoStarsIn || m_preAFNoStarsOut;
1141 if (nearCenter && maxMinRatioOK(INITIAL_MAXMIN_HFR_RATIO, measureRatio) && !hitNoStarsRegion)
1145 m_inPreAFAdj =
false;
1146 focusAdvCoarseAdjLabel->setText(
i18n(
"Done"));
1147 m_focus->absIterations = 0;
1153 m_focus->clearDataPoints();
1156 initAFAdj(minPos,
true);
1160 m_focus->absTicksSpin->setValue(minPos);
1161 complete(
false,
i18n(
"Focus Advisor Coarse Adjustment completed."));
1169 const double expansion = TARGET_MAXMIN_HFR_RATIO / measureRatio;
1170 int newStepSize = m_focus->m_OpsFocusMechanics->focusTicks->value() * expansion;
1172 if (m_preAFNoStarsIn && m_preAFNoStarsOut)
1175 const int range = m_position.first() - m_position.last();
1176 newStepSize = range / NUM_STEPS_PRE_AF;
1177 startPosition = (m_position.first() + m_position.last()) / 2;
1178 m_preAFMaxRange =
true;
1179 if (newStepSize < 1)
1182 abort(
i18n(
"Focus Advisor Coarse Adjustment: data quality too poor to continue"));
1186 else if (m_preAFNoStarsIn)
1189 int range = NUM_STEPS_PRE_AF * newStepSize;
1190 int jumpPosition = m_position.last() + range;
1191 if (jumpPosition > maxStarsLimit())
1193 range = maxStarsLimit() - m_position.last();
1194 newStepSize = range / NUM_STEPS_PRE_AF;
1195 m_preAFMaxRange =
true;
1197 startPosition = m_position.last() + (range / 2);
1199 else if (m_preAFNoStarsOut)
1202 int range = NUM_STEPS_PRE_AF * newStepSize;
1203 int endPosition = m_position.first() - range;
1204 if (endPosition < minStarsLimit())
1206 range = m_position.first() - minStarsLimit();
1207 newStepSize = range / NUM_STEPS_PRE_AF;
1208 m_preAFMaxRange =
true;
1210 startPosition = m_position.first() - (range / 2);
1214 startPosition = minPos;
1216 updateResultsTable(
i18n(
"Max/Min Ratio: %1, Next Step Size: %2, Next Overscan: %3",
QString::number(measureRatio,
'f', 1),
1218 m_focus->m_OpsFocusMechanics->focusTicks->setValue(newStepSize);
1219 initPreAFAdj(startPosition);
1224 m_focus->linearRequestedPosition = m_focus->currentPosition + deltaPos;
1225 if (!m_focus->changeFocus(deltaPos))
1226 abort(
i18n(
"Focus Advisor Coarse Adjustment failed to move focuser"));
1230bool FocusAdvisor::maxMinRatioOK(
const double limit,
const double maxMinRatio)
1232 if (m_preAFMaxRange)
1235 return maxMinRatio >= limit;
1239int FocusAdvisor::minStarsLimit()
1241 return std::max(
static_cast<int>(m_focus->absMotionMin), m_findStarsInRange);
1245int FocusAdvisor::maxStarsLimit()
1247 if (m_findStarsOutRange < 0)
1248 return m_focus->absMotionMax;
1250 return std::min(
static_cast<int>(m_focus->absMotionMax), m_findStarsOutRange);
1253void FocusAdvisor::initAFAdj(
const int startPos,
const bool retryOverscan)
1256 if (!canFocusAdvisorRun())
1258 abort(
i18n(
"Focus Advisor cannot run with current params"));
1262 focusAdvFineAdjLabel->setText(
i18n(
"In progress..."));
1263 emit newStage(FineAdjustments);
1269 const int newOverscan = m_focus->m_OpsFocusMechanics->focusAFOverscan->value() / 2;
1270 m_focus->m_OpsFocusMechanics->focusBacklash->setValue(0);
1271 m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(newOverscan);
1275 m_focus->m_OpsFocusProcess->focusUseWeights->setChecked(m_initialUseWeights);
1277 addResultsTable(
i18n(
"Fine Adjustment"), ++m_AFRunCount, startPos,
1278 m_focus->m_OpsFocusMechanics->focusTicks->value(),
1279 m_focus->m_OpsFocusMechanics->focusAFOverscan->value(),
"");
1284void FocusAdvisor::startAF(
const int startPos)
1288 setInFocusAdvisor(
false);
1289 m_focus->absIterations = 0;
1290 m_focus->setupLinearFocuser(startPos);
1291 if (!m_focus->changeFocus(m_focus->linearRequestedPosition - m_focus->currentPosition))
1292 m_focus->completeFocusProcedure(Ekos::FOCUS_ABORTED, Ekos::FOCUS_FAIL_FOCUSER_NO_MOVE);
1297 m_focus->initScanStartPos(
true, startPos);
1301bool FocusAdvisor::analyseAF()
1303 if (m_focus->m_FocusAlgorithm != Focus::FOCUS_LINEAR1PASS || !m_focus->linearFocuser || !m_focus->linearFocuser->isDone()
1304 || m_focus->linearFocuser->solution() == -1)
1307 bool runAgainRatio =
false;
1311 m_focus->linearFocuser->getPass1Measurements(&positions, &measures, &weights, &outliers);
1313 int minPosition = m_focus->linearFocuser->solution();
1314 double minMeasure = m_focus->linearFocuser->solutionValue();
1316 int maxPositon = positions[0];
1317 double maxMeasure = m_focus->curveFitting->f(maxPositon);
1319 const int stepSize = m_focus->m_OpsFocusMechanics->focusTicks->value();
1320 int newStepSize = stepSize;
1322 double measureRatio = maxMeasure / minMeasure;
1323 if (measureRatio > 2.5 && measureRatio < 3.5)
1325 runAgainRatio =
false;
1328 runAgainRatio =
true;
1330 int pos = m_focus->curveFitting->fy(minMeasure * TARGET_MAXMIN_HFR_RATIO);
1331 newStepSize = (pos - minPosition) / ((positions.
size() - 1.0) / 2.0);
1335 double ratio =
static_cast<double>(newStepSize) /
static_cast<double>(stepSize);
1336 ratio = std::max(std::min(ratio, 2.0), 0.5);
1337 newStepSize = stepSize * ratio;
1338 m_focus->m_OpsFocusMechanics->focusTicks->setValue(newStepSize);
1343 if (!m_overscanFound)
1345 double backlashPoints = 0.0;
1346 for (
int i = 0; i < positions.
size() / 2; i++)
1348 double deltaAct = measures[i] - measures[i + 1];
1349 double deltaExp = m_focus->curveFitting->f(positions[i]) - m_focus->curveFitting->f(positions[i + 1]);
1350 double delta = std::abs(deltaAct / deltaExp);
1355 backlashPoints += 0.5;
1360 const int overscan = m_focus->m_OpsFocusMechanics->focusAFOverscan->value();
1361 int newOverscan = overscan;
1363 if (backlashPoints > 0.0)
1366 newOverscan = overscan + (stepSize * backlashPoints);
1367 m_overscanFound =
true;
1369 else if (overscan == 0)
1370 m_overscanFound =
true;
1371 else if (!m_overscanFound)
1373 newOverscan = overscan <= 2 * stepSize ? 0 : overscan / 2;
1375 m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(newOverscan);
1380 m_runAgainR2 =
false;
1382 m_runAgainR2 = m_focus->R2 < m_focus->m_OpsFocusProcess->focusR2Limit->value();
1383 bool runAgain = runAgainRatio || m_runAgainR2 || !m_overscanFound;
1385 updateResultsTable(
i18n(
"Max/Min Ratio: %1, R2: %2, Step Size: %3, Overscan: %4",
QString::number(measureRatio,
'f', 1),
1387 QString::number(m_focus->m_OpsFocusMechanics->focusAFOverscan->value())));
1391 focusAdvFineAdjLabel->setText(
i18n(
"Done"));
1392 complete(
true,
i18n(
"Focus Advisor Fine Adjustment completed"));
1393 emit newStage(Idle);
1399void FocusAdvisor::reset()
1401 m_inFocusAdvisor =
false;
1402 m_initialStepSize = -1;
1403 m_initialBacklash = -1;
1404 m_initialAFOverscan = -1;
1405 m_initialUseWeights =
false;
1406 m_initialScanStartPos =
false;
1409 m_inFindStars =
false;
1410 m_inPreAFAdj =
false;
1414 m_findStarsIn =
false;
1415 m_findStarsMaxBound =
false;
1416 m_findStarsMinBound =
false;
1417 m_findStarsSector = 0;
1418 m_findStarsRunNum = 0;
1419 m_findStarsRange =
false;
1420 m_findStarsRangeIn =
false;
1421 m_findStarsFindInEdge =
false;
1422 m_findStarsInRange = -1;
1423 m_findStarsOutRange = -1;
1425 m_preAFNoStarsOut =
false;
1426 m_preAFNoStarsIn =
false;
1427 m_preAFMaxRange =
false;
1429 m_overscanFound =
false;
1430 m_runAgainR2 =
false;
1431 m_nearFocus =
false;
1434 focusAdvUpdateParamsLabel->setText(
"");
1435 focusAdvFindStarsLabel->setText(
"");
1436 focusAdvCoarseAdjLabel->setText(
"");
1437 focusAdvFineAdjLabel->setText(
"");
1441void FocusAdvisor::abort(
const QString &msg)
1443 m_focus->appendLogText(msg);
1446 resetSavedSettings(
false);
1447 m_focus->processAbort();
1452void FocusAdvisor::complete(
const bool autofocus,
const QString &msg)
1454 m_focus->appendLogText(msg);
1456 resetSavedSettings(
true);
1460 if (m_initialBacklash > -1) m_focus->m_OpsFocusMechanics->focusBacklash->setValue(m_initialBacklash);
1461 if (m_initialAFOverscan > -1) m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(m_initialAFOverscan);
1462 m_focus->completeFocusProcedure(Ekos::FOCUS_IDLE, Ekos::FOCUS_FAIL_ADVISOR_COMPLETE);
1466void FocusAdvisor::resetSavedSettings(
const bool success)
1468 m_focus->m_OpsFocusProcess->focusUseWeights->setChecked(m_initialUseWeights);
1469 m_focus->m_OpsFocusProcess->focusScanStartPos->setChecked(m_initialScanStartPos);
1474 if (m_initialStepSize > -1) m_focus->m_OpsFocusMechanics->focusTicks->setValue(m_initialStepSize);
1475 if (m_initialBacklash > -1) m_focus->m_OpsFocusMechanics->focusBacklash->setValue(m_initialBacklash);
1476 if (m_initialAFOverscan > -1) m_focus->m_OpsFocusMechanics->focusAFOverscan->setValue(m_initialAFOverscan);
1481void FocusAdvisor::addResultsTable(
QString section,
int run,
int startPos,
int stepSize,
int overscan,
QString text)
1483 focusAdvTable->insertRow(0);
1485 focusAdvTable->setItem(0, RESULTS_SECTION, itemSection);
1489 focusAdvTable->setItem(0, RESULTS_RUN_NUMBER, itemRunNumber);
1493 focusAdvTable->setItem(0, RESULTS_START_POSITION, itemStartPos);
1497 focusAdvTable->setItem(0, RESULTS_STEP_SIZE, itemStepSize);
1501 focusAdvTable->setItem(0, RESULTS_AFOVERSCAN, itemAFOverscan);
1503 focusAdvTable->setItem(0, RESULTS_TEXT, itemText);
1505 emit newMessage(text);
1507 if (focusAdvTable->rowCount() == 1)
1509 focusAdvTable->show();
1515void FocusAdvisor::updateResultsTable(
QString text)
1518 focusAdvTable->setItem(0, RESULTS_TEXT, itemText);
1522void FocusAdvisor::resizeDialog()
1526 this->verticalLayout->layout()->getContentsMargins(&left, &top, &right, &bottom);
1529 for (
int i = 0; i < focusAdvTable->horizontalHeader()->count(); i++)
1530 width += focusAdvTable->columnWidth(i);
1531 const int height = focusAdvGroupBox->height() + focusAdvTable->height() + focusAdvButtonBox->height();
1532 focusAdvTable->horizontalHeader()->height() + focusAdvTable->rowHeight(0);
1533 this->resize(width, height);
QString i18n(const char *text, const TYPE &arg...)
Ekos is an advanced Astrophotography tool for Linux.
void stateChanged(int state)
int pointSize() const const
void setBold(bool enable)
void setPointSize(int pointSize)
void setUnderline(bool enable)
void push_back(parameter_type value)
qsizetype size() const const
QString arg(Args &&... args) const const
bool isEmpty() const const
QString number(double n, char format, int precision)
QTextStream & left(QTextStream &stream)
QTextStream & right(QTextStream &stream)
void setText(const QString &text)
void setTextAlignment(Qt::Alignment alignment)
QFuture< void > map(Iterator begin, Iterator end, MapFunctor &&function)
QFuture< T > run(Function function,...)
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)