9#include "internalguider.h"
11#include "ekos_guide_debug.h"
14#include "auxiliary/kspaths.h"
15#include "fitsviewer/fitsdata.h"
16#include "fitsviewer/fitsview.h"
17#include "guidealgorithms.h"
18#include "ksnotification.h"
19#include "ekos/auxiliary/stellarsolverprofileeditor.h"
20#include "fitsviewer/fitsdata.h"
21#include "../guideview.h"
30#define MAX_GUIDE_STARS 10
32using namespace std::chrono_literals;
36InternalGuider::InternalGuider()
39 pmath.reset(
new cgmath());
40 connect(pmath.get(), &cgmath::newStarPosition,
this, &InternalGuider::newStarPosition);
41 connect(pmath.get(), &cgmath::guideStats,
this, &InternalGuider::guideStats);
45 pmath->getMutableCalibration()->restore(
46 pierSide, Options::reverseDecOnPierSideChange(), subBinX, subBinY,
nullptr);
53 m_darkGuideTimer = std::make_unique<QTimer>(
this);
54 m_captureTimer = std::make_unique<QTimer>(
this);
56 setDarkGuideTimerInterval();
60 connect(
this, &Ekos::GuideInterface::frameCaptureRequested,
this, [ = ]()
62 this->m_captureTimer->start();
66void InternalGuider::setExposureTime()
68 Seconds seconds(Options::guideExposure());
69 setTimer(m_captureTimer, seconds);
72void InternalGuider::setTimer(std::unique_ptr<QTimer> &timer, Seconds seconds)
74 const std::chrono::duration<double, std::milli>
inMilliseconds(seconds);
78void InternalGuider::setDarkGuideTimerInterval()
81 const Seconds seconds(std::max(
kMinInterval, Options::gPGDarkGuidingInterval()));
82 setTimer(m_darkGuideTimer, seconds);
85void InternalGuider::resetDarkGuiding()
87 m_darkGuideTimer->stop();
88 m_captureTimer->stop();
91bool InternalGuider::isInferencePeriodFinished()
93 auto const contribution = pmath->getGPG().predictionContribution();
96bool InternalGuider::guide()
98 if (state >= GUIDE_GUIDING)
100 return processGuiding();
103 if (state == GUIDE_SUSPENDED)
107 m_GuideFrame->disconnect(
this);
112 m_starLostCounter = 0;
113 m_highRMSCounter = 0;
116 m_isFirstFrame =
true;
118 if (state == GUIDE_IDLE)
120 if (Options::saveGuideLog())
122 GuideLog::GuideInfo info;
123 fillGuideInfo(&info);
124 guideLog.startGuiding(info);
126 state = GUIDE_GUIDING;
128 emit newStatus(state);
130 emit frameCaptureRequested();
144bool InternalGuider::abort()
149 guideLog.endGuiding();
152 if (state == GUIDE_CALIBRATING ||
153 state == GUIDE_GUIDING ||
154 state == GUIDE_DITHERING ||
155 state == GUIDE_MANUAL_DITHERING ||
156 state == GUIDE_REACQUIRE)
158 if (state == GUIDE_DITHERING || state == GUIDE_MANUAL_DITHERING)
159 emit newStatus(GUIDE_DITHERING_ERROR);
160 emit newStatus(GUIDE_ABORTED);
166 emit newStatus(GUIDE_IDLE);
171 disconnect(m_darkGuideTimer.get(),
nullptr,
nullptr,
nullptr);
177 m_ProgressiveDither.clear();
178 m_starLostCounter = 0;
179 m_highRMSCounter = 0;
183 pmath->suspend(
false);
190bool InternalGuider::suspend()
192 guideLog.pauseInfo();
193 state = GUIDE_SUSPENDED;
196 emit newStatus(state);
198 pmath->suspend(
true);
204void InternalGuider::startDarkGuiding()
206 if (Options::gPGDarkGuiding())
211 m_darkGuideTimer->start();
217bool InternalGuider::resume()
221 guideLog.resumeInfo();
222 state = GUIDE_GUIDING;
223 emit newStatus(state);
225 pmath->suspend(
false);
231 emit frameCaptureRequested();
236bool InternalGuider::ditherXY(
double x,
double y)
238 m_ProgressiveDither.clear();
246 double oneJump = (guideBoxSize / 4.0);
263 m_ProgressiveDither.
enqueue(GuiderUtils::Vector(targetX, targetY, -1));
266 while (targetX != x || targetY != y);
268 m_DitherTargetPosition = m_ProgressiveDither.
dequeue();
269 pmath->setTargetPosition(m_DitherTargetPosition.x, m_DitherTargetPosition.y);
270 guideLog.ditherInfo(x, y, m_DitherTargetPosition.x, m_DitherTargetPosition.y);
272 state = GUIDE_MANUAL_DITHERING;
273 emit newStatus(state);
280bool InternalGuider::dither(
double pixels)
282 if (Options::ditherWithOnePulse() )
283 return onePulseDither(
pixels);
293 GuiderUtils::Vector
star_position = pmath->findLocalStarPosition(m_ImageData, m_GuideFrame,
false);
298 if (++m_starLostCounter > MAX_LOST_STAR_THRESHOLD)
300 qCDebug(
KSTARS_EKOS_GUIDE) <<
"Too many consecutive lost stars." << m_starLostCounter <<
"Aborting dither.";
301 return abortDither();
304 emit frameCaptureRequested();
308 m_starLostCounter = 0;
310 if (state != GUIDE_DITHERING)
314 auto seed = std::chrono::system_clock::now().time_since_epoch().count();
315 std::default_random_engine generator(seed);
322 if (pmath->getCalibration().declinationSwapEnabled())
325 if (m_DitherOrigin.
x() == 0 && m_DitherOrigin.
y() == 0)
339 <<
QString(
"Dithering target off by too much in X (abs(%1 + %2) > %3), adjust diff_x from %4 to %5")
347 <<
QString(
"Dithering target off by too much in Y (abs(%1 + %2) > %3), adjust diff_y from %4 to %5")
355 <<
QString(
"Dithering by %1 pixels. Target: %2,%3 Current: %4,%5 Move: %6,%7 Wander: %8,%9")
357 .
arg(m_DitherTargetPosition.x, 5,
'f', 1).
arg(m_DitherTargetPosition.y, 5,
'f', 1)
361 guideLog.ditherInfo(
diff_x,
diff_y, m_DitherTargetPosition.x, m_DitherTargetPosition.y);
363 pmath->setTargetPosition(m_DitherTargetPosition.x, m_DitherTargetPosition.y);
365 if (Options::gPGEnabled())
367 pmath->getGPG().startDithering(
diff_x,
diff_y, pmath->getCalibration());
369 state = GUIDE_DITHERING;
370 emit newStatus(state);
379 pmath->getCalibration().computeDrift(
381 GuiderUtils::Vector(m_DitherTargetPosition.x, m_DitherTargetPosition.y, 0),
388 <<
QString(
"Dithering in progress. Current: %1,%2 Target: %3,%4 Diff: %5,%6 Wander: %8,%9")
390 .
arg(m_DitherTargetPosition.x, 5,
'f', 1).
arg(m_DitherTargetPosition.y, 5,
'f', 1)
402 if (Options::ditherWithOnePulse())
403 m_isFirstFrame =
true;
407 if (Options::ditherSettle() > 0)
409 state = GUIDE_DITHERING_SETTLE;
410 guideLog.settleStartedInfo();
411 emit newStatus(state);
414 if (Options::gPGEnabled())
415 pmath->getGPG().ditheringSettled(
true);
421 if (++m_DitherRetries > Options::ditherMaxIterations())
422 return abortDither();
429bool InternalGuider::onePulseDither(
double pixels)
434 emit abortExposure();
439 auto seed = std::chrono::system_clock::now().time_since_epoch().count();
440 std::default_random_engine generator(seed);
447 if (pmath->getCalibration().declinationSwapEnabled())
450 if (m_DitherOrigin.
x() == 0 && m_DitherOrigin.
y() == 0)
464 <<
QString(
"OPD: Dithering target off by too much in X (abs(%1 + %2) > %3), adjust diff_x from %4 to %5")
472 <<
QString(
"OPD: Dithering target off by too much in Y (abs(%1 + %2) > %3), adjust diff_y from %4 to %5")
480 <<
QString(
"OPD: Dithering by %1 pixels. Target: %2,%3 Current: %4,%5 Move: %6,%7 Wander: %8,%9")
482 .
arg(m_DitherTargetPosition.x, 5,
'f', 1).
arg(m_DitherTargetPosition.y, 5,
'f', 1)
486 guideLog.ditherInfo(
diff_x,
diff_y, m_DitherTargetPosition.x, m_DitherTargetPosition.y);
488 pmath->setTargetPosition(m_DitherTargetPosition.x, m_DitherTargetPosition.y);
490 if (Options::gPGEnabled())
492 pmath->getGPG().startDithering(
diff_x,
diff_y, pmath->getCalibration());
494 state = GUIDE_DITHERING;
495 emit newStatus(state);
498 const GuiderUtils::Vector
raDecMove = pmath->getCalibration().rotateToRaDec(
xyMove);
504 m_isFirstFrame =
true;
516 state = GUIDE_DITHERING_SETTLE;
517 guideLog.settleStartedInfo();
518 emit newStatus(state);
520 if (Options::gPGEnabled())
521 pmath->getGPG().ditheringSettled(
true);
527bool InternalGuider::abortDither()
529 if (Options::ditherFailAbortsAutoGuide())
531 emit newStatus(Ekos::GUIDE_DITHERING_ERROR);
537 emit newLog(
i18n(
"Warning: Dithering failed. Autoguiding shall continue as set in the options in case "
538 "of dither failure."));
540 if (Options::ditherSettle() > 0)
542 state = GUIDE_DITHERING_SETTLE;
543 guideLog.settleStartedInfo();
544 emit newStatus(state);
547 if (Options::gPGEnabled())
548 pmath->getGPG().ditheringSettled(
false);
555bool InternalGuider::processManualDithering()
563 pmath->getCalibration().computeDrift(
565 GuiderUtils::Vector(m_DitherTargetPosition.x, m_DitherTargetPosition.y, 0),
572 if (m_ProgressiveDither.empty() ==
false)
574 m_DitherTargetPosition = m_ProgressiveDither.
dequeue();
575 pmath->setTargetPosition(m_DitherTargetPosition.x, m_DitherTargetPosition.y);
576 qCDebug(
KSTARS_EKOS_GUIDE) <<
"Next Dither Jump X:" << m_DitherTargetPosition.x <<
"Jump Y:" << m_DitherTargetPosition.y;
589 if (Options::ditherSettle() > 0)
591 state = GUIDE_DITHERING_SETTLE;
592 guideLog.settleStartedInfo();
593 emit newStatus(state);
605 if (++m_DitherRetries > Options::ditherMaxIterations())
607 emit newLog(
i18n(
"Warning: Manual Dithering failed."));
609 if (Options::ditherSettle() > 0)
611 state = GUIDE_DITHERING_SETTLE;
612 guideLog.settleStartedInfo();
613 emit newStatus(state);
626void InternalGuider::setDitherSettled()
628 guideLog.settleCompletedInfo();
629 emit newStatus(Ekos::GUIDE_DITHERING_SUCCESS);
632 state = GUIDE_GUIDING;
635bool InternalGuider::calibrate()
640 if (subW == 0 || subH == 0)
646 if (mountAperture == 0.0 || mountFocalLength == 0.0)
657 KSNotification::error(
i18n(
"%1 info are missing. Please set the values in INDI Control Panel.",
errMsg),
658 i18n(
"Missing Information"));
662 if (state != GUIDE_CALIBRATING)
664 pmath->getTargetPosition(&calibrationStartX, &calibrationStartY);
665 calibrationProcess.reset(
666 new CalibrationProcess(calibrationStartX, calibrationStartY,
667 !Options::twoAxisEnabled()));
668 state = GUIDE_CALIBRATING;
669 emit newStatus(GUIDE_CALIBRATING);
672 if (calibrationProcess->inProgress())
674 iterateCalibration();
678 if (restoreCalibration())
680 calibrationProcess.reset();
681 emit newStatus(Ekos::GUIDE_CALIBRATION_SUCCESS);
683 i18n(
"Guiding calibration restored"), KSNotification::Guide);
690 pmath->getMutableCalibration()->setParameters(
691 ccdPixelSizeX / 1000.0, ccdPixelSizeY / 1000.0, mountFocalLength,
692 subBinX, subBinY, pierSide, mountRA, mountDEC);
694 calibrationProcess->useCalibration(pmath->getMutableCalibration());
696 m_GuideFrame->disconnect(
this);
699 emit DESwapChanged(
false);
700 pmath->setLostStar(
false);
702 if (Options::saveGuideLog())
704 GuideLog::GuideInfo info;
705 fillGuideInfo(&info);
706 guideLog.startCalibration(info);
708 calibrationProcess->startup();
709 calibrationProcess->setGuideLog(&guideLog);
710 iterateCalibration();
715void InternalGuider::iterateCalibration()
717 if (calibrationProcess->inProgress())
719 auto const timeStep = calculateGPGTimeStep();
720 pmath->performProcessing(GUIDE_CALIBRATING, m_ImageData, m_GuideFrame,
timeStep);
723 if (pmath->usingSEPMultiStar())
725 auto gs = pmath->getGuideStars();
726 info =
QString(
"%1 stars, %2/%3 refs")
727 .
arg(
gs.getNumStarsDetected())
728 .
arg(
gs.getNumReferencesFound())
729 .
arg(
gs.getNumReferences());
731 emit guideInfo(info);
733 if (pmath->isStarLost())
735 emit newLog(
i18n(
"Lost track of the guide star. Try increasing the square size or reducing pulse duration."));
736 emit newStatus(Ekos::GUIDE_CALIBRATION_ERROR);
737 emit calibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY,
738 i18n(
"Guide Star lost."));
747 auto status = calibrationProcess->getStatus();
748 if (status != GUIDE_CALIBRATING)
749 emit newStatus(status);
757 GuideInterface::CalibrationUpdateType
type;
758 calibrationProcess->getCalibrationUpdate(&type, &
updateMessage, &x, &y);
762 GuideDirection pulseDirection;
764 calibrationProcess->getPulse(&pulseDirection, &pulseMsecs);
765 if (pulseDirection != NO_DIR)
766 emit newSinglePulse(pulseDirection, pulseMsecs, StartCaptureAfterPulses);
768 if (status == GUIDE_CALIBRATION_ERROR)
770 KSNotification::event(
QLatin1String(
"CalibrationFailed"),
i18n(
"Guiding calibration failed"),
771 KSNotification::Guide, KSNotification::Alert);
774 else if (status == GUIDE_CALIBRATION_SUCCESS)
776 KSNotification::event(
QLatin1String(
"CalibrationSuccessful"),
777 i18n(
"Guiding calibration completed successfully"), KSNotification::Guide);
778 emit DESwapChanged(pmath->getCalibration().declinationSwapEnabled());
779 pmath->setTargetPosition(calibrationStartX, calibrationStartY);
792 if (Options::saveGuideImages())
796 now.toString(
"yyyy-MM-dd"));
801 QString name =
"guide_frame_" +
now.toString(
"HH-mm-ss") +
".fits";
803 m_ImageData->saveImage(filename);
807void InternalGuider::reset()
814 connect(m_GuideFrame.
get(), &FITSView::trackingStarSelected,
this, &InternalGuider::trackingStarSelected,
816 calibrationProcess.reset();
819bool InternalGuider::clearCalibration()
821 Options::setSerializedCalibration(
"");
822 pmath->getMutableCalibration()->reset();
826bool InternalGuider::restoreCalibration()
828 bool success = Options::reuseGuideCalibration() &&
829 pmath->getMutableCalibration()->restore(
830 pierSide, Options::reverseDecOnPierSideChange(),
831 subBinX, subBinY, &mountDEC);
833 emit DESwapChanged(pmath->getCalibration().declinationSwapEnabled());
837void InternalGuider::setStarPosition(
QVector3D &starCenter)
839 pmath->setTargetPosition(starCenter.
x(), starCenter.
y());
842void InternalGuider::trackingStarSelected(
int x,
int y)
860void InternalGuider::setDECSwap(
bool enable)
862 pmath->getMutableCalibration()->setDeclinationSwapEnabled(enable);
865void InternalGuider::setSquareAlgorithm(
int index)
867 if (index == SEP_MULTISTAR && !pmath->usingSEPMultiStar())
868 m_isFirstFrame =
true;
869 pmath->setAlgorithmIndex(index);
872bool InternalGuider::getReticleParameters(
double * x,
double * y)
874 return pmath->getTargetPosition(x, y);
877bool InternalGuider::setGuiderParams(
double ccdPixelSizeX,
double ccdPixelSizeY,
double mountAperture,
878 double mountFocalLength)
880 this->ccdPixelSizeX = ccdPixelSizeX;
881 this->ccdPixelSizeY = ccdPixelSizeY;
882 this->mountAperture = mountAperture;
883 this->mountFocalLength = mountFocalLength;
884 return pmath->setGuiderParameters(ccdPixelSizeX, ccdPixelSizeY, mountAperture, mountFocalLength);
887bool InternalGuider::setFrameParams(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t
binX, uint16_t
binY)
889 if (w <= 0 || h <= 0)
900 pmath->setVideoParameters(w, h, subBinX, subBinY);
905void InternalGuider::emitAxisPulse(
const cproc_out_params *
out)
908 double dePulse =
out->pulse_length[GUIDE_DEC];
911 if(
out->pulse_dir[GUIDE_RA] == NO_DIR)
914 if(
out->pulse_dir[GUIDE_DEC] == NO_DIR)
917 if(
out->pulse_dir[GUIDE_RA] == RA_INC_DIR)
920 if(
out->pulse_dir[GUIDE_DEC] == DEC_INC_DIR)
926bool InternalGuider::processGuiding()
928 const cproc_out_params *
out;
936 m_isFirstFrame =
false;
937 if (state == GUIDE_GUIDING)
939 GuiderUtils::Vector
star_pos = pmath->findLocalStarPosition(m_ImageData, m_GuideFrame,
true);
946 m_isFirstFrame =
true;
953 auto const timeStep = calculateGPGTimeStep();
954 pmath->performProcessing(state, m_ImageData, m_GuideFrame,
timeStep, &guideLog);
955 if (pmath->usingSEPMultiStar())
958 auto gs = pmath->getGuideStars();
959 info =
QString(
"%1 stars, %2/%3 refs")
960 .
arg(
gs.getNumStarsDetected())
961 .
arg(
gs.getNumReferencesFound())
962 .
arg(
gs.getNumReferences());
964 emit guideInfo(info);
968 if (this->m_darkGuideTimer->isActive())
969 this->m_darkGuideTimer->start();
972 if (state == GUIDE_SUSPENDED)
974 if (Options::gPGEnabled())
975 emit frameCaptureRequested();
980 if (pmath->isStarLost())
983 m_starLostCounter = 0;
987 out = pmath->getOutputParameters();
989 if (isPoorGuiding(
out))
996 if (
sendPulses && (
out->pulse_dir[GUIDE_RA] != NO_DIR ||
out->pulse_dir[GUIDE_DEC] != NO_DIR))
998 emit newMultiPulse(
out->pulse_dir[GUIDE_RA],
out->pulse_length[GUIDE_RA],
999 out->pulse_dir[GUIDE_DEC],
out->pulse_length[GUIDE_DEC], StartCaptureAfterPulses);
1002 emit frameCaptureRequested();
1004 if (state == GUIDE_DITHERING || state == GUIDE_MANUAL_DITHERING)
1012 if (state < GUIDE_DITHERING)
1013 emit newAxisDelta(
out->delta[GUIDE_RA],
out->delta[GUIDE_DEC]);
1016 emit newAxisSigma(
out->sigma[GUIDE_RA],
out->sigma[GUIDE_DEC]);
1017 if (SEPMultiStarEnabled())
1018 emit newSNR(pmath->getGuideStarSNR());
1025std::pair<Seconds, Seconds> InternalGuider::calculateGPGTimeStep()
1029 const Seconds
guideDelay{(Options::guideDelay())};
1034 if (!Options::gPGDarkGuiding() || !isInferencePeriodFinished())
1063void InternalGuider::darkGuide()
1066 if (state != GUIDE_GUIDING)
1069 if(Options::gPGDarkGuiding() && isInferencePeriodFinished())
1071 const cproc_out_params *
out;
1072 auto const timeStep = calculateGPGTimeStep();
1073 pmath->performDarkGuiding(state,
timeStep);
1075 out = pmath->getOutputParameters();
1076 emit newSinglePulse(
out->pulse_dir[GUIDE_RA],
out->pulse_length[GUIDE_RA], DontCaptureAfterPulses);
1082bool InternalGuider::isPoorGuiding(
const cproc_out_params *
out)
1084 double delta_rms = std::hypot(
out->delta[GUIDE_RA],
out->delta[GUIDE_DEC]);
1085 if (
delta_rms > Options::guideMaxDeltaRMS())
1088 m_highRMSCounter = 0;
1091 || state == GUIDE_MANUAL_DITHERING) ? MAX_LOST_STAR_THRESHOLD * 3 : MAX_LOST_STAR_THRESHOLD;
1093 || state == GUIDE_MANUAL_DITHERING) ? MAX_RMS_THRESHOLD * 3 : MAX_RMS_THRESHOLD;
1097 <<
"m_highRMSCounter" << m_highRMSCounter
1101 emit newLog(
i18n(
"Lost track of the guide star. Searching for guide stars..."));
1103 emit newLog(
i18n(
"Delta RMS threshold value exceeded. Searching for guide stars..."));
1105 reacquireTimer.
start();
1106 rememberState = state;
1107 state = GUIDE_REACQUIRE;
1108 emit newStatus(state);
1113bool InternalGuider::selectAutoStarSEPMultistar()
1115 m_GuideFrame->updateFrame();
1126bool InternalGuider::SEPMultiStarEnabled()
1128 return Options::guideAlgorithm() == SEP_MULTISTAR;
1131bool InternalGuider::selectAutoStar()
1134 if (Options::guideAlgorithm() == SEP_MULTISTAR)
1135 return selectAutoStarSEPMultistar();
1141 if (Options::guideAlgorithm() != SEP_THRESHOLD)
1142 starCenters = GuideAlgorithms::detectStars(m_ImageData, m_GuideFrame->getTrackingBox());
1144 if (starCenters.empty())
1146 QVariantMap settings;
1147 settings[
"maxStarsCount"] = 50;
1148 settings[
"optionsProfileIndex"] = Options::guideOptionsProfile();
1149 settings[
"optionsProfileGroup"] =
static_cast<int>(Ekos::GuideProfiles);
1150 m_ImageData->setSourceExtractorSettings(settings);
1152 if (Options::guideAlgorithm() == SEP_THRESHOLD)
1153 m_ImageData->findStars(ALGORITHM_SEP).waitForFinished();
1155 m_ImageData->findStars().waitForFinished();
1157 starCenters = m_ImageData->getStarCenters();
1158 if (starCenters.empty())
1163 if (Options::guideAlgorithm() == SEP_THRESHOLD)
1164 std::sort(starCenters.begin(), starCenters.end(), [](
const Edge * a,
const Edge * b)
1166 return a->val > b->val;
1169 std::sort(starCenters.begin(), starCenters.end(), [](
const Edge * a,
const Edge * b)
1171 return a->width > b->width;
1174 m_GuideFrame->setStarsEnabled(
true);
1175 m_GuideFrame->updateFrame();
1178 int maxX = m_ImageData->width();
1179 int maxY = m_ImageData->height();
1181 int scores[MAX_GUIDE_STARS];
1183 int maxIndex = MAX_GUIDE_STARS < starCenters.count() ? MAX_GUIDE_STARS : starCenters.count();
1189 Edge *
center = starCenters.at(i);
1199 if (
center->width >
float(guideBoxSize) / subBinX)
1203 if (Options::guideAlgorithm() == SEP_THRESHOLD)
1211 foreach (Edge *edge, starCenters)
1258bool InternalGuider::reacquire()
1260 bool rc = selectAutoStar();
1263 m_highRMSCounter = m_starLostCounter = 0;
1264 m_isFirstFrame =
true;
1267 if (rememberState == GUIDE_DITHERING || state == GUIDE_MANUAL_DITHERING)
1269 if (Options::ditherSettle() > 0)
1271 state = GUIDE_DITHERING_SETTLE;
1272 guideLog.settleStartedInfo();
1273 emit newStatus(state);
1280 state = GUIDE_GUIDING;
1281 emit newStatus(state);
1285 else if (reacquireTimer.
elapsed() >
static_cast<int>(Options::guideLostStarTimeout() * 1000))
1287 emit newLog(
i18n(
"Failed to find any suitable guide stars. Aborting..."));
1292 emit frameCaptureRequested();
1296void InternalGuider::fillGuideInfo(GuideLog::GuideInfo * info)
1301 info->pixelScale = (206.26481 * this->ccdPixelSizeX * this->subBinX) / this->mountFocalLength;
1302 info->binning = this->subBinX;
1303 info->focalLength = this->mountFocalLength;
1304 info->ra = this->mountRA.
Degrees();
1305 info->dec = this->mountDEC.
Degrees();
1306 info->azimuth = this->mountAzimuth.
Degrees();
1307 info->altitude = this->mountAltitude.
Degrees();
1308 info->pierSide = this->pierSide;
1309 info->xangle = pmath->getCalibration().getRAAngle();
1310 info->yangle = pmath->getCalibration().getDECAngle();
1312 info->xrate = 1000.0 / pmath->getCalibration().raPulseMillisecondsPerArcsecond();
1313 info->yrate = 1000.0 / pmath->getCalibration().decPulseMillisecondsPerArcsecond();
1316void InternalGuider::updateGPGParameters()
1318 setDarkGuideTimerInterval();
1319 pmath->getGPG().updateParameters();
1322void InternalGuider::resetGPG()
1324 pmath->getGPG().reset();
1328const Calibration &InternalGuider::getCalibration()
const
1330 return pmath->getCalibration();
const double & Degrees() const
static constexpr double DegToRad
DegToRad is a const static member equal to the number of radians in one degree (dms::PI/180....
QString i18n(const char *text, const TYPE &arg...)
Type type(const QSqlDatabase &db)
Ekos is an advanced Astrophotography tool for Linux.
QString path(const QString &relativePath)
KIOCORE_EXPORT QString dir(const QString &fileClass)
QString name(StandardShortcut id)
NETWORKMANAGERQT_EXPORT NetworkManager::Status status()
QDateTime currentDateTime()
QString filePath(const QString &fileName) const const
qint64 elapsed() const const
virtual void close() override
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
bool disconnect(const QMetaObject::Connection &connection)
QString arg(Args &&... args) const const
QTextStream & center(QTextStream &stream)