Kstars

calibrationprocess.cpp
1#include "calibrationprocess.h"
2
3#include "gmath.h"
4#include "ekos_guide_debug.h"
5#include "gmath.h"
6#include "guidelog.h"
7
8#include "Options.h"
9
10namespace Ekos
11{
12
13QString stageString(Ekos::CalibrationProcess::CalibrationStage stage)
14{
15 switch(stage)
16 {
17 case Ekos::CalibrationProcess::CAL_IDLE:
18 return ("CAL_IDLE");
19 case Ekos::CalibrationProcess::CAL_ERROR:
20 return("CAL_ERROR");
21 case Ekos::CalibrationProcess::CAL_CAPTURE_IMAGE:
22 return("CAL_CAPTURE_IMAGE");
23 case Ekos::CalibrationProcess::CAL_SELECT_STAR:
24 return("CAL_SELECT_STAR");
25 case Ekos::CalibrationProcess::CAL_START:
26 return("CAL_START");
27 case Ekos::CalibrationProcess::CAL_RA_INC:
28 return("CAL_RA_INC");
29 case Ekos::CalibrationProcess::CAL_RA_DEC:
30 return("CAL_RA_DEC");
31 case Ekos::CalibrationProcess::CAL_DEC_INC:
32 return("CAL_DEC_INC");
33 case Ekos::CalibrationProcess::CAL_DEC_DEC:
34 return("CAL_DEC_DEC");
35 case Ekos::CalibrationProcess::CAL_BACKLASH:
36 return("CAL_BACKLASH");
37 default:
38 return("???");
39 };
40}
41
42CalibrationProcess::CalibrationProcess(double startX, double startY, bool raOnlyEnabled)
43{
44 calibrationStage = CAL_START;
45 raOnly = raOnlyEnabled;
46 start_x1 = startX;
47 start_y1 = startY;
48}
49
50void CalibrationProcess::useCalibration(Calibration *calibrationPtr)
51{
52 calibration = calibrationPtr;
53 tempCalibration = *calibration;
54}
55
56void CalibrationProcess::startup()
57{
58 calibrationStage = CAL_START;
59}
60
61void CalibrationProcess::setGuideLog(GuideLog *guideLogPtr)
62{
63 guideLog = guideLogPtr;
64}
65
66bool CalibrationProcess::inProgress() const
67{
68 return calibrationStage > CAL_START;
69}
70
71void CalibrationProcess::addCalibrationUpdate(
72 GuideInterface::CalibrationUpdateType type,
73 QString message, double x, double y)
74{
75 updateType = type;
76 calibrationUpdate = message;
77 updateX = x;
78 updateY = y;
79}
80
81void CalibrationProcess::getCalibrationUpdate(
82 GuideInterface::CalibrationUpdateType *type,
83 QString *message, double *x, double *y) const
84{
85 *type = updateType;
86 *message = calibrationUpdate;
87 *x = updateX;
88 *y = updateY;
89}
90
91QString CalibrationProcess::getLogStatus() const
92{
93 return logString;
94}
95
96void CalibrationProcess::addLogStatus(const QString &message)
97{
98 logString = message;
99}
100
101void CalibrationProcess::addPulse(GuideDirection dir, int msecs)
102{
103 pulseDirection = dir;
104 pulseMsecs = msecs;
105}
106
107void CalibrationProcess::getPulse(GuideDirection *dir, int *msecs) const
108{
109 *dir = pulseDirection;
110 *msecs = pulseMsecs;
111}
112
113void CalibrationProcess::addStatus(Ekos::GuideState s)
114{
115 status = s;
116}
117
118Ekos::GuideState CalibrationProcess::getStatus() const
119{
120 return status;
121}
122
123void CalibrationProcess::initializeIteration()
124{
125 axisCalibrationComplete = false;
126
127 logString.clear();
128
129 calibrationUpdate.clear();
130 updateType = GuideInterface::CALIBRATION_MESSAGE_ONLY;
131 updateX = 0;
132 updateY = 0;
133
134 addStatus(Ekos::GUIDE_CALIBRATING);
135
136 pulseDirection = NO_DIR;
137 pulseMsecs = 0;
138}
139
140void CalibrationProcess::iterate(double x, double y)
141{
142 initializeIteration();
143 switch (calibrationStage)
144 {
145 case CAL_START:
146 startState();
147 break;
148 case CAL_RA_INC:
149 raOutState(x, y);
150 break;
151 case CAL_RA_DEC:
152 raInState(x, y);
153 break;
154 case CAL_BACKLASH:
155 decBacklashState(x, y);
156 break;
157 case CAL_DEC_INC:
158 decOutState(x, y);
159 break;
160 case CAL_DEC_DEC:
161 decInState(x, y);
162 break;
163 default:
164 break;
165 }
166}
167
168void CalibrationProcess::startState()
169{
170 maximumSteps = Options::autoModeIterations();
171 turn_back_time = maximumSteps * 7;
172
173 ra_iterations = 0;
174 dec_iterations = 0;
175 backlash_iterations = 0;
176 ra_total_pulse = de_total_pulse = 0;
177
178 addLogStatus(i18n("RA drifting forward..."));
179
180 last_pulse = Options::calibrationPulseDuration();
181
182 addCalibrationUpdate(GuideInterface::RA_OUT, i18n("Guide Star found."), 0, 0);
183
184 qCDebug(KSTARS_EKOS_GUIDE) << "Auto Iteration #" << maximumSteps << "Default pulse:" << last_pulse;
185 qCDebug(KSTARS_EKOS_GUIDE) << "Start X1 " << start_x1 << " Start Y1 " << start_y1;
186
187 last_x = start_x1;
188 last_y = start_x2;
189
190 addPulse(RA_INC_DIR, last_pulse);
191
192 ra_iterations++;
193
194 calibrationStage = CAL_RA_INC;
195 if (guideLog)
196 guideLog->addCalibrationData(RA_INC_DIR, start_x1, start_y1, start_x1, start_y1);
197}
198
199
200void CalibrationProcess::raOutState(double cur_x, double cur_y)
201{
202 QString Info = QString("RA+ (%1, %2)").arg((cur_x - start_x1), 0, 'f', 1).arg((cur_y - start_y1), 0, 'f', 1);
203 addCalibrationUpdate(GuideInterface::RA_OUT, Info, cur_x - start_x1, cur_y - start_y1);
204
205 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration #" << ra_iterations << ": STAR " << cur_x << "," << cur_y;
206 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration " << ra_iterations << " Direction: RA_INC_DIR" << " Duration: "
207 << last_pulse << " ms.";
208
209 if (guideLog)
210 guideLog->addCalibrationData(RA_INC_DIR, cur_x, cur_y, start_x1, start_y1);
211
212 // Must pass at least 1.5 pixels to move on to the next stage.
213 // If we've moved 15 pixels, we can cut short the requested number of iterations.
214 const double xDrift = cur_x - start_x1;
215 const double yDrift = cur_y - start_y1;
216 if (((ra_iterations >= maximumSteps) ||
217 (std::hypot(xDrift, yDrift) > Options::calibrationMaxMove()))
218 && (fabs(xDrift) > 1.5 || fabs(yDrift) > 1.5))
219 {
220 ra_total_pulse += last_pulse;
221 calibrationStage = CAL_RA_DEC;
222
223 end_x1 = cur_x;
224 end_y1 = cur_y;
225
226 last_x = cur_x;
227 last_y = cur_y;
228
229 qCDebug(KSTARS_EKOS_GUIDE) << "End X1 " << end_x1 << " End Y1 " << end_y1;
230
231 // This temporary calibration is just used to help find our way back to the origin.
232 // total_pulse is not used, but valid.
233 tempCalibration.calculate1D(start_x1, start_y1, end_x1, end_y1, ra_total_pulse);
234
235 ra_distance = 0;
236 backlash = 0;
237
238 addCalibrationUpdate(GuideInterface::RA_OUT_OK, Info, cur_x - start_x1, cur_y - start_y1);
239
240 addPulse(RA_DEC_DIR, last_pulse);
241 ra_iterations++;
242
243 addLogStatus(i18n("RA drifting reverse..."));
244 if (guideLog)
245 guideLog->endCalibrationSection(RA_INC_DIR, tempCalibration.getAngle());
246 }
247 else if (ra_iterations > turn_back_time)
248 {
249 addLogStatus(i18n("Calibration rejected. Star drift is too short. Check for mount, cable, or backlash problems."));
250 calibrationStage = CAL_ERROR;
251 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
252 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: Drift too short."));
253 if (guideLog)
254 guideLog->endCalibration(0, 0);
255 }
256 else
257 {
258 // Aggressive pulse in case we're going slow
259 if (fabs(cur_x - last_x) < 0.5 && fabs(cur_y - last_y) < 0.5)
260 {
261 // 200%
262 last_pulse = Options::calibrationPulseDuration() * 2;
263 }
264 else
265 {
266 ra_total_pulse += last_pulse;
267 last_pulse = Options::calibrationPulseDuration();
268 }
269
270 last_x = cur_x;
271 last_y = cur_y;
272
273 addPulse(RA_INC_DIR, last_pulse);
274
275 ra_iterations++;
276 }
277}
278
279void CalibrationProcess::raInState(double cur_x, double cur_y)
280{
281 QString Info = QString("RA- (%1, %2)").arg((cur_x - start_x1), 0, 'f', 1).arg((cur_y - start_y1), 0, 'f', 1);
282 addCalibrationUpdate(GuideInterface::RA_IN, Info, cur_x - start_x1, cur_y - start_y1);
283
284 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration #" << ra_iterations << ": STAR " << cur_x << "," << cur_y;
285 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration " << ra_iterations << " Direction: RA_DEC_DIR" << " Duration: "
286 << last_pulse << " ms.";
287
288 double driftRA, driftDEC;
289 tempCalibration.computeDrift(GuiderUtils::Vector(cur_x, cur_y, 0), GuiderUtils::Vector(start_x1, start_y1, 0),
290 &driftRA, &driftDEC);
291
292 qCDebug(KSTARS_EKOS_GUIDE) << "Star x pos is " << driftRA << " from original point.";
293
294 if (ra_distance == 0.0)
295 ra_distance = driftRA;
296
297 if (guideLog)
298 guideLog->addCalibrationData(RA_DEC_DIR, cur_x, cur_y, start_x1, start_y1);
299
300 // start point reached... so exit
301 if (driftRA < 1.5)
302 {
303 last_pulse = Options::calibrationPulseDuration();
304 axisCalibrationComplete = true;
305 }
306 // If we'not moving much, try increasing pulse to 200% to clear any backlash
307 // Also increase pulse width if we are going FARTHER and not back to our original position
308 else if ( (fabs(cur_x - last_x) < 0.5 && fabs(cur_y - last_y) < 0.5)
309 || driftRA > ra_distance)
310 {
311 backlash++;
312
313 // Increase pulse to 200% after we tried to fight against backlash 2 times at least
314 if (backlash > 2)
315 last_pulse = Options::calibrationPulseDuration() * 2;
316 else
317 last_pulse = Options::calibrationPulseDuration();
318 }
319 else
320 {
321 //ra_total_pulse += last_pulse;
322 last_pulse = Options::calibrationPulseDuration();
323 backlash = 0;
324 }
325 last_x = cur_x;
326 last_y = cur_y;
327
328 if (axisCalibrationComplete == false)
329 {
330 if (ra_iterations < turn_back_time)
331 {
332 addPulse(RA_DEC_DIR, last_pulse);
333 ra_iterations++;
334 return;
335 }
336
337 calibrationStage = CAL_ERROR;
338 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
339 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: couldn't reach start."));
340 addLogStatus(i18np("Guide RA: Scope cannot reach the start point after %1 iteration. Possible mount or "
341 "backlash problems...",
342 "GUIDE_RA: Scope cannot reach the start point after %1 iterations. Possible mount or "
343 "backlash problems...",
344 ra_iterations));
345 return;
346 }
347
348 if (raOnly == false)
349 {
350 if (Options::guideCalibrationBacklash())
351 {
352 calibrationStage = CAL_BACKLASH;
353 last_x = cur_x;
354 last_y = cur_y;
355 start_backlash_x = cur_x;
356 start_backlash_y = cur_y;
357 addPulse(DEC_INC_DIR, Options::calibrationPulseDuration());
358 backlash_iterations++;
359 addLogStatus(i18n("DEC backlash..."));
360 }
361 else
362 {
363 calibrationStage = CAL_DEC_INC;
364 start_x2 = cur_x;
365 start_y2 = cur_y;
366 last_x = cur_x;
367 last_y = cur_y;
368
369 qCDebug(KSTARS_EKOS_GUIDE) << "Start X2 " << start_x2 << " start Y2 " << start_y2;
370 addPulse(DEC_INC_DIR, Options::calibrationPulseDuration());
371 dec_iterations++;
372 addLogStatus(i18n("DEC drifting forward..."));
373 }
374 return;
375 }
376 // calc orientation
377 if (calibration->calculate1D(start_x1, start_y1, end_x1, end_y1, ra_total_pulse))
378 {
379 calibration->save();
380 calibrationStage = CAL_IDLE;
381 addStatus(Ekos::GUIDE_CALIBRATION_SUCCESS);
382 // Below converts from ms/arcsecond to arcseconds/second.
383 if (guideLog)
384 guideLog->endCalibration(1000.0 / calibration->raPulseMillisecondsPerArcsecond(), 0);
385 }
386 else
387 {
388 addLogStatus(i18n("Calibration rejected. Star drift is too short. Check for mount, cable, or backlash problems."));
389 calibrationStage = CAL_ERROR;
390 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
391 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: drift too short."));
392 if (guideLog)
393 guideLog->endCalibration(0, 0);
394 }
395}
396
397void CalibrationProcess::decBacklashState(double cur_x, double cur_y)
398{
399 double driftRA, driftDEC;
400 tempCalibration.computeDrift(
401 GuiderUtils::Vector(cur_x, cur_y, 0),
402 GuiderUtils::Vector(start_backlash_x, start_backlash_y, 0),
403 &driftRA, &driftDEC);
404
405 // Exit the backlash phase either after 5 pulses, or after we've moved sufficiently in the
406 // DEC direction.
407 constexpr int MIN_DEC_BACKLASH_MOVE_PIXELS = 3;
408 if ((++backlash_iterations >= 5) ||
409 (fabs(driftDEC) > MIN_DEC_BACKLASH_MOVE_PIXELS))
410 {
411 addCalibrationUpdate(GuideInterface::BACKLASH, i18n("Calibrating DEC Backlash"),
412 cur_x - start_x1, cur_y - start_y1);
413 qCDebug(KSTARS_EKOS_GUIDE) << QString("Stopping dec backlash caibration after %1 iterations, offset %2")
414 .arg(backlash_iterations - 1)
415 .arg(driftDEC, 4, 'f', 2);
416 calibrationStage = CAL_DEC_INC;
417 start_x2 = cur_x;
418 start_y2 = cur_y;
419 last_x = cur_x;
420 last_y = cur_y;
421
422 qCDebug(KSTARS_EKOS_GUIDE) << "Start X2 " << start_x2 << " start Y2 " << start_y2;
423 addPulse(DEC_INC_DIR, Options::calibrationPulseDuration());
424 dec_iterations++;
425 addLogStatus(i18n("DEC drifting forward..."));
426 return;
427 }
428 addCalibrationUpdate(GuideInterface::BACKLASH, i18n("Calibrating DEC Backlash"),
429 cur_x - start_x1, cur_y - start_y1);
430 qCDebug(KSTARS_EKOS_GUIDE) << "Backlash iter" << backlash_iterations << "position" << cur_x << cur_y;
431 addPulse(DEC_INC_DIR, Options::calibrationPulseDuration());
432}
433
434
435void CalibrationProcess::decOutState(double cur_x, double cur_y)
436{
437 QString Info = QString("DE+ (%1, %2)").arg((cur_x - start_x1), 0, 'f', 1).arg((cur_y - start_y1), 0, 'f', 1);
438 addCalibrationUpdate(GuideInterface::DEC_OUT, Info, cur_x - start_x1, cur_y - start_y1);
439
440 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration #" << dec_iterations << ": STAR " << cur_x << "," << cur_y;
441 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration " << dec_iterations << " Direction: DEC_INC_DIR" <<
442 " Duration: " << last_pulse << " ms.";
443
444 // Don't yet know how to tell NORTH vs SOUTH
445 if (guideLog)
446 guideLog->addCalibrationData(DEC_INC_DIR, cur_x, cur_y,
447 start_x2, start_y2);
448 const double xDrift = cur_x - start_x2;
449 const double yDrift = cur_y - start_y2;
450 if (((dec_iterations >= maximumSteps) ||
451 (std::hypot(xDrift, yDrift) > Options::calibrationMaxMove()))
452 && (fabs(xDrift) > 1.5 || fabs(yDrift) > 1.5))
453 {
454 calibrationStage = CAL_DEC_DEC;
455
456 de_total_pulse += last_pulse;
457
458 end_x2 = cur_x;
459 end_y2 = cur_y;
460
461 last_x = cur_x;
462 last_y = cur_y;
463
464 axisCalibrationComplete = false;
465
466 qCDebug(KSTARS_EKOS_GUIDE) << "End X2 " << end_x2 << " End Y2 " << end_y2;
467
468 tempCalibration.calculate1D(start_x2, start_y2, end_x2, end_y2, de_total_pulse);
469
470 de_distance = 0;
471
472 addCalibrationUpdate(GuideInterface::DEC_OUT_OK, Info, cur_x - start_x1, cur_y - start_y1);
473
474 addPulse(DEC_DEC_DIR, last_pulse);
475 addLogStatus(i18n("DEC drifting reverse..."));
476 dec_iterations++;
477 if (guideLog)
478 guideLog->endCalibrationSection(DEC_INC_DIR, tempCalibration.getAngle());
479 }
480 else if (dec_iterations > turn_back_time)
481 {
482 calibrationStage = CAL_ERROR;
483
484 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
485 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: couldn't reach start point."));
486 addLogStatus(i18np("Guide DEC: Scope cannot reach the start point after %1 iteration.\nPossible mount "
487 "or backlash problems...",
488 "GUIDE DEC: Scope cannot reach the start point after %1 iterations.\nPossible mount "
489 "or backlash problems...",
490 dec_iterations));
491
492 if (guideLog)
493 guideLog->endCalibration(0, 0);
494 }
495 else
496 {
497 if (fabs(cur_x - last_x) < 0.5 && fabs(cur_y - last_y) < 0.5)
498 {
499 // Increase pulse by 200%
500 last_pulse = Options::calibrationPulseDuration() * 2;
501 }
502 else
503 {
504 de_total_pulse += last_pulse;
505 last_pulse = Options::calibrationPulseDuration();
506 }
507 last_x = cur_x;
508 last_y = cur_y;
509
510 addPulse(DEC_INC_DIR, last_pulse);
511
512 dec_iterations++;
513 }
514}
515
516void CalibrationProcess::decInState(double cur_x, double cur_y)
517{
518 QString Info = QString("DE- (%1, %2)").arg((cur_x - start_x1), 0, 'f', 1).arg((cur_y - start_y1), 0, 'f', 1);
519 addCalibrationUpdate(GuideInterface::DEC_IN, Info, cur_x - start_x1, cur_y - start_y1);
520
521 // Star position resulting from LAST guiding pulse to mount
522 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration #" << dec_iterations << ": STAR " << cur_x << "," << cur_y;
523 qCDebug(KSTARS_EKOS_GUIDE) << "Iteration " << dec_iterations << " Direction: DEC_DEC_DIR" <<
524 " Duration: " << last_pulse << " ms.";
525
526 // Note: the way this temp calibration was set up above, with the DEC drifts, the ra axis is really dec.
527 // This will help the dec find its way home. Could convert to a full RA/DEC calibration.
528 double driftRA, driftDEC;
529 tempCalibration.computeDrift(
530 GuiderUtils::Vector(cur_x, cur_y, 0),
531 GuiderUtils::Vector(start_x1, start_y1, 0),
532 &driftRA, &driftDEC);
533
534 qCDebug(KSTARS_EKOS_GUIDE) << "Currently " << driftRA << driftDEC << " from original point.";
535
536 // Keep track of distance
537 if (de_distance == 0.0)
538 de_distance = driftRA;
539
540 if (guideLog)
541 guideLog->addCalibrationData(DEC_DEC_DIR, cur_x, cur_y, start_x2, start_y2);
542
543 // start point reached... so exit
544 if (driftRA < 1.5)
545 {
546 last_pulse = Options::calibrationPulseDuration();
547 axisCalibrationComplete = true;
548 }
549 // Increase pulse if we're not moving much or if we are moving _away_ from target.
550 else if ( (fabs(cur_x - last_x) < 0.5 && fabs(cur_y - last_y) < 0.5)
551 || driftRA > de_distance)
552 {
553 // Increase pulse by 200%
554 last_pulse = Options::calibrationPulseDuration() * 2;
555 }
556 else
557 {
558 last_pulse = Options::calibrationPulseDuration();
559 }
560
561 if (axisCalibrationComplete == false)
562 {
563 if (dec_iterations < turn_back_time)
564 {
565 addPulse(DEC_DEC_DIR, last_pulse);
566 dec_iterations++;
567 return;
568 }
569
570 calibrationStage = CAL_ERROR;
571
572 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
573 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: couldn't reach start point."));
574
575 addLogStatus(i18np("Guide DEC: Scope cannot reach the start point after %1 iteration.\nPossible mount "
576 "or backlash problems...",
577 "Guide DEC: Scope cannot reach the start point after %1 iterations.\nPossible mount "
578 "or backlash problems...",
579 dec_iterations));
580 return;
581 }
582
583 bool reverse_dec_dir = false;
584 // calc orientation
585 if (calibration->calculate2D(start_x1, start_y1, end_x1, end_y1, start_x2, start_y2, end_x2, end_y2,
586 &reverse_dec_dir, ra_total_pulse, de_total_pulse))
587 {
588 double rotation = calibration->getAngle();
589 QString success = QString("Calibration OK\n Rotation = %1").arg(rotation, 0, 'f', 1);
590 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n(success.toLatin1().data()));
591
592 calibration->save();
593 calibrationStage = CAL_IDLE;
594 if (reverse_dec_dir)
595 addLogStatus(i18n("DEC direction reversed (RA-DEC is now standard CCW-system)."));
596
597 addStatus(Ekos::GUIDE_CALIBRATION_SUCCESS);
598
599 // Below converts from ms/arcsecond to arcseconds/second.
600 if (guideLog)
601 guideLog->endCalibration(
602 1000.0 / calibration->raPulseMillisecondsPerArcsecond(),
603 1000.0 / calibration->decPulseMillisecondsPerArcsecond());
604 return;
605 }
606 else
607 {
608 addLogStatus(i18n("Calibration rejected. Star drift is too short. Check for mount, cable, or backlash problems."));
609 addCalibrationUpdate(GuideInterface::CALIBRATION_MESSAGE_ONLY, i18n("Calibration Failed: drift too short."));
610 addStatus(Ekos::GUIDE_CALIBRATION_ERROR);
611 calibrationStage = CAL_ERROR;
612 if (guideLog)
613 guideLog->endCalibration(0, 0);
614 return;
615 }
616}
617
618} // namespace Ekos
i18np
QString i18np(const char *singular, const char *plural, const TYPE &arg...)
i18n
QString i18n(const char *text, const TYPE &arg...)
Akonadi::Server::DbType::type
Type type(const QSqlDatabase &db)
Ekos
Ekos is an advanced Astrophotography tool for Linux.
Definition align.cpp:83
KRecentDirs::dir
KIOCORE_EXPORT QString dir(const QString &fileClass)
QByteArray::data
char * data()
QString::toLatin1
QByteArray toLatin1() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Jan 31 2025 11:53:47 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.