Kstars

imageoverlaycomponent.cpp
1/*
2 SPDX-FileCopyrightText: 2023 Hy Murveit <hy@murveit.com>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include "imageoverlaycomponent.h"
8
9#include "kstars.h"
10#include "Options.h"
11#include "skypainter.h"
12#include "skymap.h"
13#ifdef HAVE_CFITSIO
14#include "fitsviewer/fitsdata.h"
15#endif
16#include "auxiliary/kspaths.h"
17
18
19#include <QTableWidget>
20#include <QImageReader>
21#include <QCheckBox>
22#include <QComboBox>
23#include <QtConcurrent>
24#include <QRegularExpression>
25
26#include "ekos/auxiliary/solverutils.h"
27#include "ekos/auxiliary/stellarsolverprofile.h"
28
29namespace
30{
31
32enum ColumnIndex
33{
34 FILENAME_COL = 0,
35 //ENABLED_COL,
36 //NICKNAME_COL,
37 STATUS_COL,
38 RA_COL,
39 DEC_COL,
40 ARCSEC_PER_PIXEL_COL,
41 ORIENTATION_COL,
42 WIDTH_COL,
43 HEIGHT_COL,
44 EAST_TO_RIGHT_COL,
45 NUM_COLUMNS
46};
47
48// These needs to be syncronized with enum Status and initializeGui::StatusNames().
49constexpr int UNPROCESSED_INDEX = 0;
50constexpr int OK_INDEX = 4;
51
52// Helper to create the image overlay table.
53// Start the table, displaying the heading and timing information, common to all sessions.
54void setupTable(QTableWidget *table)
55{
56 table->clear();
57 table->setRowCount(0);
58 table->setColumnCount(NUM_COLUMNS);
59 table->setShowGrid(false);
60 table->setWordWrap(true);
61
62 QStringList HeaderNames =
63 {
64 i18n("Filename"),
65 // "", "Nickname",
66 i18n("Status"), i18n("RA"), i18n("DEC"), i18n("A-S/px"), i18n("Angle"),
67 i18n("Width"), i18n("Height"), i18n("EastRight")
68 };
69 table->setHorizontalHeaderLabels(HeaderNames);
70}
71
72// This initializes an item in the table widget.
73void setupTableItem(QTableWidget *table, int row, int column, const QString &text, bool editable = true)
74{
75 if (table->rowCount() < row + 1)
76 table->setRowCount(row + 1);
77 if (column >= NUM_COLUMNS)
78 return;
81 item->setText(text);
82 if (!editable)
83 item->setFlags(item->flags() ^ Qt::ItemIsEditable);
84 table->setItem(row, column, item);
85}
86
87// Helper for sorting the overlays alphabetically (case-insensitive).
88bool overlaySorter(const ImageOverlay &o1, const ImageOverlay &o2)
89{
90 return o1.m_Filename.toLower() < o2.m_Filename.toLower();
91}
92
93// The dms method for initializing from text requires knowing if the input is degrees or hours.
94// This is a crude way to detect HMS input, and may not internationalize well.
95bool isHMS(const QString &input)
96{
97 QString trimmedInput = input.trimmed();
98 // Just 14h
99 QRegularExpression re1("^(\\d+)\\s*h$");
100 // 14h 2m
101 QRegularExpression re2("^(\\d+)\\s*h\\s(\\d+)\\s*(?:[m\']?)$");
102 // 14h 2m 3.2s
103 QRegularExpression re3("^(\\d+)\\s*h\\s(\\d+)\\s*[m\'\\s]\\s*(\\d+\\.*\\d*)\\s*([s\"]?)$");
104
105 return re1.match(trimmedInput).hasMatch() ||
106 re2.match(trimmedInput).hasMatch() ||
107 re3.match(trimmedInput).hasMatch();
108}
109
110// Even if an image is already solved, the user may have changed the status in the UI.
111bool shouldSolveAnyway(QTableWidget *table, int row)
112{
113 QComboBox *item = dynamic_cast<QComboBox*>(table->cellWidget(row, STATUS_COL));
114 if (!item) return false;
115 return (item->currentIndex() != OK_INDEX);
116}
117
118QString toDecString(const dms &dec)
119{
120 // Sadly DMS::setFromString doesn't parse dms::toDMSString()
121 // return dec.toDMSString();
122 return QString("%1 %2' %3\"").arg(dec.degree()).arg(dec.arcmin()).arg(dec.arcsec());
123}
124
125QString toDecString(double dec)
126{
127 return toDecString(dms(dec));
128}
129} // namespace
130
131ImageOverlayComponent::ImageOverlayComponent(SkyComposite *parent) : SkyComponent(parent)
132{
133 QDir dir = QDir(KSPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + "/imageOverlays");
134 dir.mkpath(".");
135 m_Directory = dir.absolutePath();
136 connect(&m_TryAgainTimer, &QTimer::timeout, this, &ImageOverlayComponent::tryAgain, Qt::UniqueConnection);
137 connect(this, &ImageOverlayComponent::updateLog, this, &ImageOverlayComponent::updateStatusDisplay, Qt::UniqueConnection);
138
139 // Get the latest from the User DB
140 loadFromUserDB();
141
142 // The rest of the initialization happens when we get the setWidgets() call.
143}
144
145// Validate the user inputs, and if invalid, replace with the previous values.
146void ImageOverlayComponent::cellChanged(int row, int col)
147{
148 if (!m_Initialized || col < 0 || col >= NUM_COLUMNS || row < 0 || row >= m_ImageOverlayTable->rowCount()) return;
149 // Note there are a couple columns with widgets instead of normal text items.
150 // This method shouldn't get called for those, but...
151 if (col == STATUS_COL || col == EAST_TO_RIGHT_COL) return;
152
153 QTableWidgetItem *item = m_ImageOverlayTable->item(row, col);
154 if (!item) return;
155
156 disconnect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged);
157 QString itemString = item->text();
158 auto overlay = m_Overlays[row];
159 if (col == RA_COL)
160 {
161 dms raDMS;
162 const bool useHMS = isHMS(itemString);
163 const bool raOK = raDMS.setFromString(itemString, !useHMS);
164 if (!raOK)
165 {
166 item->setText(dms(overlay.m_RA).toHMSString());
167 QString msg = i18n("Bad RA string entered for %1. Reset to original value.", overlay.m_Filename);
168 emit updateLog(msg);
169 }
170 else
171 // Re-format the user-entered value.
172 item->setText(raDMS.toHMSString());
173 }
174 else if (col == DEC_COL)
175 {
176 dms decDMS;
177 const bool decOK = decDMS.setFromString(itemString);
178 if (!decOK)
179 {
180 item->setText(toDecString(overlay.m_DEC));
181 QString msg = i18n("Bad DEC string entered for %1. Reset to original value.", overlay.m_Filename);
182 emit updateLog(msg);
183 }
184 else
185 item->setText(toDecString(decDMS));
186 }
187 else if (col == ORIENTATION_COL)
188 {
189 bool angleOK = false;
190 double angle = itemString.toDouble(&angleOK);
191 if (!angleOK || angle > 360 || angle < -360)
192 {
193 item->setText(QString("%1").arg(overlay.m_Orientation, 0, 'f', 2));
194 QString msg = i18n("Bad orientation angle string entered for %1. Reset to original value.", overlay.m_Filename);
195 emit updateLog(msg);
196 }
197 }
198 else if (col == ARCSEC_PER_PIXEL_COL)
199 {
200 bool scaleOK = false;
201 double scale = itemString.toDouble(&scaleOK);
202 if (!scaleOK || scale < 0 || scale > 1000)
203 {
204 item->setText(QString("%1").arg(overlay.m_ArcsecPerPixel, 0, 'f', 2));
205 QString msg = i18n("Bad scale angle string entered for %1. Reset to original value.", overlay.m_Filename);
206 emit updateLog(msg);
207 }
208 }
209 connect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged, Qt::UniqueConnection);
210}
211
212// Like cellChanged() but for the status column which contains QComboxBox widgets.
213void ImageOverlayComponent::statusCellChanged(int row)
214{
215 if (row < 0 || row >= m_ImageOverlayTable->rowCount()) return;
216
217 auto overlay = m_Overlays[row];
218 disconnect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged);
219
220 // If the user changed the status of a column to OK,
221 // then we check to make sure the required columns are filled out.
222 // If so, then we also save it to the DB.
223 // If the required columns are not filled out, the QComboBox value is reverted to UNPROCESSED.
224 QComboBox *statusItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(row, STATUS_COL));
225 bool failed = false;
226 if (statusItem->currentIndex() == OK_INDEX)
227 {
228 dms raDMS;
229 QTableWidgetItem *raItem = m_ImageOverlayTable->item(row, RA_COL);
230 if (!raItem) return;
231 const bool useHMS = isHMS(raItem->text());
232 const bool raOK = raDMS.setFromString(raItem->text(), !useHMS);
233 if (!raOK || raDMS.Degrees() == 0)
234 {
235 QString msg = i18n("Cannot set status to OK. Legal non-0 RA value required.");
236 emit updateLog(msg);
237 failed = true;
238 }
239
240 dms decDMS;
241 QTableWidgetItem *decItem = m_ImageOverlayTable->item(row, DEC_COL);
242 if (!decItem) return;
243 const bool decOK = decDMS.setFromString(decItem->text());
244 if (!decOK)
245 {
246 QString msg = i18n("Cannot set status to OK. Legal non-0 DEC value required.");
247 emit updateLog(msg);
248 failed = true;
249 }
250
251 bool angleOK = false;
252 QTableWidgetItem *angleItem = m_ImageOverlayTable->item(row, ORIENTATION_COL);
253 if (!angleItem) return;
254 const double angle = angleItem->text().toDouble(&angleOK);
255 if (!angleOK || angle > 360 || angle < -360)
256 {
257 QString msg = i18n("Cannot set status to OK. Legal orientation value required.");
258 emit updateLog(msg);
259 failed = true;
260 }
261
262 bool scaleOK = false;
263 QTableWidgetItem *scaleItem = m_ImageOverlayTable->item(row, ARCSEC_PER_PIXEL_COL);
264 if (!scaleItem) return;
265 const double scale = scaleItem->text().toDouble(&scaleOK);
266 if (!scaleOK || scale < 0 || scale > 1000)
267 {
268 QString msg = i18n("Cannot set status to OK. Legal non-0 a-s/px value required.");
269 emit updateLog(msg);
270 failed = true;
271 }
272
273 if (failed)
274 {
275 QComboBox *statusItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(row, STATUS_COL));
276 statusItem->setCurrentIndex(UNPROCESSED_INDEX);
277 }
278 else
279 {
280 m_Overlays[row].m_Status = ImageOverlay::AVAILABLE;
281 m_Overlays[row].m_RA = raDMS.Degrees();
282 m_Overlays[row].m_DEC = decDMS.Degrees();
283 m_Overlays[row].m_ArcsecPerPixel = scale;
284 m_Overlays[row].m_Orientation = angle;
285 const QComboBox *ewItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(row, EAST_TO_RIGHT_COL));
286 m_Overlays[row].m_EastToTheRight = ewItem->currentIndex();
287
288 if (m_Overlays[row].m_Img.get() == nullptr)
289 {
290 // Load the image.
291 const QString fullFilename = QString("%1/%2").arg(m_Directory).arg(m_Overlays[row].m_Filename);
292 QImage *img = loadImageFile(fullFilename, !m_Overlays[row].m_EastToTheRight);
293 m_Overlays[row].m_Width = img->width();
294 m_Overlays[row].m_Height = img->height();
295 m_Overlays[row].m_Img.reset(img);
296 }
297 saveToUserDB();
298 QString msg = i18n("Stored OK status for %1.", m_Overlays[row].m_Filename);
299 emit updateLog(msg);
300 }
301 }
302 connect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged, Qt::UniqueConnection);
303}
304
305ImageOverlayComponent::~ImageOverlayComponent()
306{
307 if (m_LoadImagesFuture.isRunning())
308 {
309 m_LoadImagesFuture.cancel();
310 m_LoadImagesFuture.waitForFinished();
311 }
312}
313
314void ImageOverlayComponent::selectionChanged()
315{
316 if (m_Initialized && Options::showSelectedImageOverlay())
317 show();
318}
319
321{
322 return Options::showImageOverlays();
323}
324
326{
327#if !defined(KSTARS_LITE)
328 if (m_Initialized)
329 {
330 skyp->drawImageOverlay(&m_Overlays);
331 skyp->drawImageOverlay(&m_TemporaryOverlays);
332 }
333#else
334 Q_UNUSED(skyp);
335#endif
336}
337
338void ImageOverlayComponent::setWidgets(QTableWidget *table, QPlainTextEdit *statusDisplay,
339 QPushButton *solveButton, QGroupBox *tableGroupBox,
340 QComboBox *solverProfile)
341{
342 m_ImageOverlayTable = table;
343 // Temporarily make the table uneditable.
344 m_EditTriggers = m_ImageOverlayTable->editTriggers();
346
347 m_SolveButton = solveButton;
348 m_TableGroupBox = tableGroupBox;
349 m_SolverProfile = solverProfile;
350 solveButton->setText(i18n("Solve"));
351
352 m_StatusDisplay = statusDisplay;
353 setupTable(table);
354 updateTable();
355 connect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged, Qt::UniqueConnection);
356 connect(m_ImageOverlayTable, &QTableWidget::itemSelectionChanged, this, &ImageOverlayComponent::selectionChanged,
358
359 initSolverProfiles();
360 loadAllImageFiles();
361}
362
363void ImageOverlayComponent::initSolverProfiles()
364{
365 QString savedOptionsProfiles = QDir(KSPaths::writableLocation(
366 QStandardPaths::AppLocalDataLocation)).filePath("SavedAlignProfiles.ini");
367
368 QList<SSolver::Parameters> optionsList;
369 if(QFile(savedOptionsProfiles).exists())
370 optionsList = StellarSolver::loadSavedOptionsProfiles(savedOptionsProfiles);
371 else
372 optionsList = Ekos::getDefaultAlignOptionsProfiles();
373
374 m_SolverProfile->clear();
375 for(auto &param : optionsList)
376 m_SolverProfile->addItem(param.listName);
377 m_SolverProfile->setCurrentIndex(Options::solveOptionsProfile());
378}
379
380void ImageOverlayComponent::updateStatusDisplay(const QString &message)
381{
382 if (!m_StatusDisplay)
383 return;
384 m_LogText.insert(0, message);
385 m_StatusDisplay->setPlainText(m_LogText.join("\n"));
386}
387
388// Find all the files in the directory, see if they are in the m_Overlays.
389// If no, append to the end of m_Overlays, and set status as unprocessed.
390void ImageOverlayComponent::updateTable()
391{
392#ifdef HAVE_CFITSIO
393 // Get the list of files from the image overlay directory.
394 QDir directory(m_Directory);
395 emit updateLog(i18n("Updating from directory: %1", m_Directory));
396 QStringList images = directory.entryList(QStringList() << "*", QDir::Files);
397 QSet<QString> imageFiles;
398 foreach(QString filename, images)
399 {
400 if (!FITSData::readableFilename(filename))
401 continue;
402 imageFiles.insert(filename);
403 }
404
405 // Sort the files alphabetically.
406 QList<QString> sortedImageFiles;
407 for (const auto &fn : imageFiles)
408 sortedImageFiles.push_back(fn);
409 std::sort(sortedImageFiles.begin(), sortedImageFiles.end(), overlaySorter);
410
411 // Remove any overlays that aren't in the directory.
412 QList<ImageOverlay> tempOverlays;
413 QMap<QString, int> tempMap;
414 int numDeleted = 0;
415 for (int i = 0; i < m_Overlays.size(); ++i)
416 {
417 auto &fname = m_Overlays[i].m_Filename;
418 if (sortedImageFiles.indexOf(fname) >= 0)
419 {
420 tempOverlays.append(m_Overlays[i]);
421 tempMap[fname] = tempOverlays.size() - 1;
422 }
423 else
424 numDeleted++;
425 }
426 m_Overlays = tempOverlays;
427 m_Filenames = tempMap;
428
429 // Add the new files into the overlay list.
430 int numNew = 0;
431 for (const auto &filename : sortedImageFiles)
432 {
433 auto item = m_Filenames.find(filename);
434 if (item == m_Filenames.end())
435 {
436 // If it doesn't already exist in our database:
437 ImageOverlay overlay(filename);
438 const int size = m_Filenames.size(); // place before push_back().
439 m_Overlays.push_back(overlay);
440 m_Filenames[filename] = size;
441 numNew++;
442 }
443 }
444 emit updateLog(i18n("%1 overlays (%2 new, %3 deleted) %4 solved", m_Overlays.size(), numNew, numDeleted,
445 numAvailable()));
446 m_TableGroupBox->setTitle(i18n("Image Overlays. %1 images, %2 available.", m_Overlays.size(), numAvailable()));
447
448 initializeGui();
449 saveToUserDB();
450#endif
451}
452
453void ImageOverlayComponent::loadAllImageFiles()
454{
455#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
456 m_LoadImagesFuture = QtConcurrent::run(&ImageOverlayComponent::loadImageFileLoop, this);
457#else
458 m_LoadImagesFuture = QtConcurrent::run(this, &ImageOverlayComponent::loadImageFileLoop);
459#endif
460}
461
462void ImageOverlayComponent::loadImageFileLoop()
463{
464 emit updateLog(i18n("Loading image files..."));
465 while (loadImageFile());
466 int num = 0;
467 for (const auto &o : m_Overlays)
468 if (o.m_Img.get() != nullptr)
469 num++;
470 emit updateLog(i18n("%1 image files loaded.", num));
471 // Restore editing for the table.
472 m_ImageOverlayTable->setEditTriggers(m_EditTriggers);
473 m_Initialized = true;
474}
475
476void ImageOverlayComponent::addTemporaryImageOverlay(const ImageOverlay &overlay)
477{
478 m_TemporaryOverlays.push_back(overlay);
479}
480
481QImage *ImageOverlayComponent::loadImageFile (const QString &fullFilename, bool mirror)
482{
483 QSharedPointer<QImage> tempImage(new QImage(fullFilename));
484 if (tempImage.get() == nullptr) return nullptr;
485 int scaleWidth = std::min(tempImage->width(), Options::imageOverlayMaxDimension());
486 QImage *processedImg = new QImage;
487 if (mirror)
488 *processedImg = tempImage->mirrored(true, false).scaledToWidth(scaleWidth); // It's reflected horizontally.
489 else
490 *processedImg = tempImage->scaledToWidth(scaleWidth);
491
492 return processedImg;
493}
494
495bool ImageOverlayComponent::loadImageFile()
496{
497 bool updatedSomething = false;
498
499 for (auto &o : m_Overlays)
500 {
501 if (o.m_Status == o.ImageOverlay::AVAILABLE && o.m_Img.get() == nullptr)
502 {
503 QString fullFilename = QString("%1%2%3").arg(m_Directory).arg(QDir::separator()).arg(o.m_Filename);
504 QImage *img = loadImageFile(fullFilename, !o.m_EastToTheRight);
505 o.m_Img.reset(img);
506 updatedSomething = true;
507
508 // Note: The original width and height in o.m_Width/m_Height is kept even
509 // though the image was rescaled. This is to get the rendering right
510 // with the original scale.
511 }
512 }
513 return updatedSomething;
514}
515
516
517// Copies the info in m_Overlays into m_ImageOverlayTable UI.
518void ImageOverlayComponent::initializeGui()
519{
520 if (!m_ImageOverlayTable) return;
521
522 // Don't call callback on programmatic changes.
523 disconnect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged);
524
525 // This clears the table.
526 setupTable(m_ImageOverlayTable);
527
528 int row = 0;
529 for (int i = 0; i < m_Overlays.size(); ++i)
530 {
531 const ImageOverlay &overlay = m_Overlays[row];
532 // False: The user can't edit filename.
533 setupTableItem(m_ImageOverlayTable, row, FILENAME_COL, overlay.m_Filename, false);
534
535 QStringList StatusNames =
536 {
537 i18n("Unprocessed"), i18n("Bad File"), i18n("Solve Failed"), i18n("Error"), i18n("OK")
538 };
539 QComboBox *statusBox = new QComboBox();
540 for (int i = 0; i < ImageOverlay::NUM_STATUS; ++i)
541 statusBox->addItem(StatusNames[i]);
542 connect(statusBox, QOverload<int>::of(&QComboBox::activated), this, [row, this](int newIndex)
543 {
544 Q_UNUSED(newIndex);
545 statusCellChanged(row);
546 });
547 statusBox->setCurrentIndex(static_cast<int>(overlay.m_Status));
548 m_ImageOverlayTable->setCellWidget(row, STATUS_COL, statusBox);
549
550 setupTableItem(m_ImageOverlayTable, row, ORIENTATION_COL, QString("%1").arg(overlay.m_Orientation, 0, 'f', 2));
551 setupTableItem(m_ImageOverlayTable, row, RA_COL, dms(overlay.m_RA).toHMSString());
552 setupTableItem(m_ImageOverlayTable, row, DEC_COL, toDecString(overlay.m_DEC));
553 setupTableItem(m_ImageOverlayTable, row, ARCSEC_PER_PIXEL_COL, QString("%1").arg(overlay.m_ArcsecPerPixel, 0, 'f', 2));
554
555 // The user can't edit width & height--taken from image.
556 setupTableItem(m_ImageOverlayTable, row, WIDTH_COL, QString("%1").arg(overlay.m_Width), false);
557 setupTableItem(m_ImageOverlayTable, row, HEIGHT_COL, QString("%1").arg(overlay.m_Height), false);
558
559 QComboBox *mirroredBox = new QComboBox();
560 mirroredBox->addItem(i18n("West-Right"));
561 mirroredBox->addItem(i18n("East-Right"));
562 connect(mirroredBox, QOverload<int>::of(&QComboBox::activated), this, [row](int newIndex)
563 {
564 Q_UNUSED(row);
565 Q_UNUSED(newIndex);
566 // Don't need to do anything. Will get picked up on change of status to OK.
567 });
568 mirroredBox->setCurrentIndex(overlay.m_EastToTheRight ? 1 : 0);
569 m_ImageOverlayTable->setCellWidget(row, EAST_TO_RIGHT_COL, mirroredBox);
570
571 row++;
572 }
573 m_ImageOverlayTable->resizeColumnsToContents();
574 m_TableGroupBox->setTitle(i18n("Image Overlays. %1 images, %2 available.", m_Overlays.size(), numAvailable()));
575 connect(m_ImageOverlayTable, &QTableWidget::cellChanged, this, &ImageOverlayComponent::cellChanged, Qt::UniqueConnection);
576
577}
578
579void ImageOverlayComponent::loadFromUserDB()
580{
581 QList<ImageOverlay *> list;
582 KStarsData::Instance()->userdb()->GetAllImageOverlays(&m_Overlays);
583 // Alphabetize.
584 std::sort(m_Overlays.begin(), m_Overlays.end(), overlaySorter);
585 m_Filenames.clear();
586 int index = 0;
587 for (const auto &o : m_Overlays)
588 {
589 m_Filenames[o.m_Filename] = index;
590 index++;
591 }
592}
593
594void ImageOverlayComponent::saveToUserDB()
595{
596 KStarsData::Instance()->userdb()->DeleteAllImageOverlays();
597 for (const ImageOverlay &metadata : m_Overlays)
598 KStarsData::Instance()->userdb()->AddImageOverlay(metadata);
599}
600
601void ImageOverlayComponent::solveImage(const QString &filename)
602{
603 if (!m_Initialized) return;
604 m_SolveButton->setText(i18n("Abort"));
605 const int solverTimeout = Options::imageOverlayTimeout();
606
607 QString savedOptionsProfiles = QDir(KSPaths::writableLocation(
608 QStandardPaths::AppLocalDataLocation)).filePath("SavedAlignProfiles.ini");
609 auto profiles = (QFile(savedOptionsProfiles).exists()) ?
610 StellarSolver::loadSavedOptionsProfiles(savedOptionsProfiles) :
611 Ekos::getDefaultAlignOptionsProfiles();
612
613 const int index = m_SolverProfile->currentIndex();
614 auto parameters = index < profiles.size() ? profiles.at(index) : profiles.at(0);
615 // Double search radius
616 parameters.search_radius = parameters.search_radius * 2;
617
618 m_Solver.reset(new SolverUtils(parameters, solverTimeout), &QObject::deleteLater);
619 connect(m_Solver.get(), &SolverUtils::done, this, &ImageOverlayComponent::solverDone, Qt::UniqueConnection);
620
621 if (m_RowsToSolve.size() > 1)
622 emit updateLog(i18n("Solving: %1. %2 in queue.", filename, m_RowsToSolve.size()));
623 else
624 emit updateLog(i18n("Solving: %1.", filename));
625
626 // If the user added some RA/DEC/Scale values to the table, they will be used in the solve
627 // (but aren't remembered in the DB unless the solve is successful).
628 int row = m_RowsToSolve[0];
629 QString raString = m_ImageOverlayTable->item(row, RA_COL)->text().toLatin1().data();
630 QString decString = m_ImageOverlayTable->item(row, DEC_COL)->text().toLatin1().data();
631 QString scaleString = m_ImageOverlayTable->item(row, ARCSEC_PER_PIXEL_COL)->text().toLatin1().data();
632
633 dms raDMS, decDMS;
634 const bool useHMS = isHMS(raString);
635 const bool raOK = raDMS.setFromString(raString, !useHMS) && (raDMS.Degrees() != 0.00);
636 const bool decOK = decDMS.setFromString(decString) && (decDMS.Degrees() != 0.00);
637 bool scaleOK = false;
638 double scale = scaleString.toDouble(&scaleOK);
639 scaleOK = scaleOK && scale != 0.00;
640
641 // Use the default scale if it is > 0 and scale was not specified in the UI table.
642 if (!scaleOK && Options::imageOverlayDefaultScale() > 0.0001)
643 {
644 scale = Options::imageOverlayDefaultScale();
645 scaleOK = true;
646 }
647
648 if (scaleOK)
649 {
650 auto lowScale = scale * 0.75;
651 auto highScale = scale * 1.25;
652 m_Solver->useScale(true, lowScale, highScale);
653 }
654 if (raOK && decOK)
655 m_Solver->usePosition(true, raDMS.Degrees(), decDMS.Degrees());
656
657 m_Solver->runSolver(filename);
658}
659
660void ImageOverlayComponent::tryAgain()
661{
662 m_TryAgainTimer.stop();
663 if (!m_Initialized) return;
664 if (m_RowsToSolve.size() > 0)
665 startSolving();
666}
667
668int ImageOverlayComponent::numAvailable()
669{
670 int num = 0;
671 for (const auto &o : m_Overlays)
672 if (o.m_Status == ImageOverlay::AVAILABLE)
673 num++;
674 return num;
675}
676
677void ImageOverlayComponent::show()
678{
679 if (!m_Initialized || !m_ImageOverlayTable) return;
680 auto selections = m_ImageOverlayTable->selectionModel();
681 if (selections->hasSelection())
682 {
683 auto selectedIndexes = selections->selectedIndexes();
684 const int row = selectedIndexes.at(0).row();
685 if (m_Overlays.size() > row && row >= 0)
686 {
687 if (m_Overlays[row].m_Status != ImageOverlay::AVAILABLE)
688 {
689 emit updateLog(i18n("Can't show %1. Not plate solved.", m_Overlays[row].m_Filename));
690 return;
691 }
692 if (m_Overlays[row].m_Img.get() == nullptr)
693 {
694 emit updateLog(i18n("Can't show %1. Image not loaded.", m_Overlays[row].m_Filename));
695 return;
696 }
697 const double ra = m_Overlays[row].m_RA;
698 const double dec = m_Overlays[row].m_DEC;
699
700 // Convert the RA/DEC from j2000 to jNow.
701 auto localTime = KStarsData::Instance()->geo()->UTtoLT(KStarsData::Instance()->clock()->utc());
702 const dms raDms(ra), decDms(dec);
703 SkyPoint coord(raDms, decDms);
704 coord.apparentCoord(static_cast<long double>(J2000), KStars::Instance()->data()->ut().djd());
705
706 // Is this the right way to move to the SkyMap?
707 Options::setIsTracking(false);
708 SkyMap::Instance()->setFocusObject(nullptr);
709 SkyMap::Instance()->setFocusPoint(nullptr);
710 SkyMap::Instance()->setFocus(dms(coord.ra()), dms(coord.dec()));
711
712 // Zoom factor is in pixels per radian.
713 double zoomFactor = (400 * 60.0 * 10800.0) / (m_Overlays[row].m_Width * m_Overlays[row].m_ArcsecPerPixel * dms::PI);
714 SkyMap::Instance()->setZoomFactor(zoomFactor);
715
716 SkyMap::Instance()->forceUpdate(true);
717 }
718 }
719}
720
721void ImageOverlayComponent::abortSolving()
722{
723 if (!m_Initialized) return;
724 m_RowsToSolve.clear();
725 if (m_Solver)
726 m_Solver->abort();
727 emit updateLog(i18n("Solving aborted."));
728 m_SolveButton->setText(i18n("Solve"));
729}
730
731void ImageOverlayComponent::startSolving()
732{
733 if (!m_Initialized) return;
734 if (m_SolveButton->text() == i18n("Abort"))
735 {
736 abortSolving();
737 return;
738 }
739 if (m_Solver && m_Solver->isRunning())
740 {
741 m_Solver->abort();
742 if (m_RowsToSolve.size() > 0)
743 m_TryAgainTimer.start(2000);
744 return;
745 }
746
747 if (m_RowsToSolve.size() == 0)
748 {
749 QSet<int> selectedRows;
750 auto selections = m_ImageOverlayTable->selectionModel();
751 if (selections->hasSelection())
752 {
753 // Need to de-dup, as selecting the whole row will select all the columns.
754 auto selectedIndexes = selections->selectedIndexes();
755 for (int i = 0; i < selectedIndexes.count(); ++i)
756 {
757 // Don't insert a row that's already solved.
758 const int row = selectedIndexes.at(i).row();
759 if ((m_Overlays[row].m_Status == ImageOverlay::AVAILABLE) &&
760 !shouldSolveAnyway(m_ImageOverlayTable, row))
761 {
762 emit updateLog(i18n("Skipping already solved: %1.", m_Overlays[row].m_Filename));
763 continue;
764 }
765 selectedRows.insert(row);
766 }
767 }
768 m_RowsToSolve.clear();
769 for (int row : selectedRows)
770 m_RowsToSolve.push_back(row);
771 }
772
773 if (m_RowsToSolve.size() > 0)
774 {
775 const int row = m_RowsToSolve[0];
776 const QString filename =
777 QString("%1/%2").arg(m_Directory).arg(m_Overlays[row].m_Filename);
778 if ((m_Overlays[row].m_Status == ImageOverlay::AVAILABLE) &&
779 !shouldSolveAnyway(m_ImageOverlayTable, row))
780 {
781 emit updateLog(i18n("%1 already solved. Skipping.", filename));
782 m_RowsToSolve.removeFirst();
783 if (m_RowsToSolve.size() > 0)
784 startSolving();
785 return;
786 }
787
788 auto img = new QImage(filename);
789 m_Overlays[row].m_Width = img->width();
790 m_Overlays[row].m_Height = img->height();
791 solveImage(filename);
792 }
793}
794
795void ImageOverlayComponent::reload()
796{
797 if (!m_Initialized) return;
798 m_Initialized = false;
799 emit updateLog(i18n("Reloading. Image overlays temporarily disabled."));
800 updateTable();
801 loadAllImageFiles();
802}
803
804void ImageOverlayComponent::solverDone(bool timedOut, bool success, const FITSImage::Solution &solution,
805 double elapsedSeconds)
806{
807 disconnect(m_Solver.get(), &SolverUtils::done, this, &ImageOverlayComponent::solverDone);
808 m_SolveButton->setText(i18n("Solve"));
809 if (m_RowsToSolve.size() == 0)
810 return;
811
812 const int solverRow = m_RowsToSolve[0];
813 m_RowsToSolve.removeFirst();
814
815 QComboBox *statusItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(solverRow, STATUS_COL));
816 if (timedOut)
817 {
818 emit updateLog(i18n("Solver timed out in %1s", QString::number(elapsedSeconds, 'f', 1)));
819 m_Overlays[solverRow].m_Status = ImageOverlay::PLATE_SOLVE_FAILURE;
820 statusItem->setCurrentIndex(static_cast<int>(m_Overlays[solverRow].m_Status));
821 }
822 else if (!success)
823 {
824 emit updateLog(i18n("Solver failed in %1s", QString::number(elapsedSeconds, 'f', 1)));
825 m_Overlays[solverRow].m_Status = ImageOverlay::PLATE_SOLVE_FAILURE;
826 statusItem->setCurrentIndex(static_cast<int>(m_Overlays[solverRow].m_Status));
827 }
828 else
829 {
830 m_Overlays[solverRow].m_Orientation = solution.orientation;
831 m_Overlays[solverRow].m_RA = solution.ra;
832 m_Overlays[solverRow].m_DEC = solution.dec;
833 m_Overlays[solverRow].m_ArcsecPerPixel = solution.pixscale;
834 m_Overlays[solverRow].m_EastToTheRight = solution.parity;
835 m_Overlays[solverRow].m_Status = ImageOverlay::AVAILABLE;
836
837 QString msg = i18n("Solver success in %1s: RA %2 DEC %3 Scale %4 Angle %5",
838 QString::number(elapsedSeconds, 'f', 1),
839 QString::number(solution.ra, 'f', 2),
840 QString::number(solution.dec, 'f', 2),
841 QString::number(solution.pixscale, 'f', 2),
842 QString::number(solution.orientation, 'f', 2));
843 emit updateLog(msg);
844
845 // Store the new values in the table.
846 auto overlay = m_Overlays[solverRow];
847 m_ImageOverlayTable->item(solverRow, RA_COL)->setText(dms(overlay.m_RA).toHMSString());
848 m_ImageOverlayTable->item(solverRow, DEC_COL)->setText(toDecString(overlay.m_DEC));
849 m_ImageOverlayTable->item(solverRow, ARCSEC_PER_PIXEL_COL)->setText(
850 QString("%1").arg(overlay.m_ArcsecPerPixel, 0, 'f', 2));
851 m_ImageOverlayTable->item(solverRow, ORIENTATION_COL)->setText(QString("%1").arg(overlay.m_Orientation, 0, 'f', 2));
852 QComboBox *ewItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(solverRow, EAST_TO_RIGHT_COL));
853 ewItem->setCurrentIndex(overlay.m_EastToTheRight ? 1 : 0);
854
855 QComboBox *statusItem = dynamic_cast<QComboBox*>(m_ImageOverlayTable->cellWidget(solverRow, STATUS_COL));
856 statusItem->setCurrentIndex(static_cast<int>(overlay.m_Status));
857
858 // Load the image.
859 QString fullFilename = QString("%1/%2").arg(m_Directory).arg(m_Overlays[solverRow].m_Filename);
860 QImage *img = loadImageFile(fullFilename, !m_Overlays[solverRow].m_EastToTheRight);
861 m_Overlays[solverRow].m_Img.reset(img);
862 }
863 saveToUserDB();
864
865 if (m_RowsToSolve.size() > 0)
866 startSolving();
867 else
868 {
869 emit updateLog(i18n("Done solving. %1 available.", numAvailable()));
870 m_TableGroupBox->setTitle(i18n("Image Overlays. %1 images, %2 available.", m_Overlays.size(), numAvailable()));
871 }
872}
void draw(SkyPainter *skyp) override
Draw the object on the SkyMap skyp a pointer to the SkyPainter to use.
bool GetAllImageOverlays(QList< ImageOverlay > *imageOverlayList)
Gets all the image overlay rows from the database.
bool AddImageOverlay(const ImageOverlay &overlay)
Adds a new image overlay row into the database.
bool DeleteAllImageOverlays()
Deletes all image overlay rows from the database.
KSUserDB * userdb()
Definition kstarsdata.h:223
GeoLocation * geo()
Definition kstarsdata.h:238
static KStars * Instance()
Definition kstars.h:122
SkyComponent represents an object on the sky map.
SkyComposite is a kind of container class for SkyComponent objects.
void setZoomFactor(double factor)
@ Set zoom factor.
Definition skymap.cpp:1207
void forceUpdate(bool now=false)
Recalculates the positions of objects in the sky, and then repaints the sky map.
Definition skymap.cpp:1217
void setFocus(SkyPoint *f)
sets the central focus point of the sky map.
Definition skymap.cpp:998
void setFocusObject(SkyObject *o)
Set the FocusObject pointer to the argument.
Definition skymap.cpp:404
void setFocusPoint(SkyPoint *f)
set the FocusPoint; the position that is to be the next Destination.
Definition skymap.h:204
Draws things on the sky, without regard to backend.
Definition skypainter.h:40
virtual bool drawImageOverlay(const QList< ImageOverlay > *imageOverlays, bool useCache=false)=0
drawImageOverlay Draws a user-supplied image onto the skymap
An angle, stored as degrees, but expressible in many ways.
Definition dms.h:38
virtual bool setFromString(const QString &s, bool isDeg=true)
Attempt to parse the string argument as a dms value, and set the dms object accordingly.
Definition dms.cpp:48
static constexpr double PI
PI is a const static member; it's public so that it can be used anywhere, as long as dms....
Definition dms.h:385
const QString toHMSString(const bool machineReadable=false, const bool highPrecision=false) const
Definition dms.cpp:378
const double & Degrees() const
Definition dms.h:141
QString i18n(const char *text, const TYPE &arg...)
KIOCORE_EXPORT QString dir(const QString &fileClass)
KIOCORE_EXPORT QStringList list(const QString &fileClass)
void setText(const QString &text)
void activated(int index)
void addItem(const QIcon &icon, const QString &text, const QVariant &userData)
QChar separator()
int height() const const
QImage mirrored(bool horizontal, bool vertical) &&
QImage scaledToWidth(int width, Qt::TransformationMode mode) const const
int width() const const
void append(QList< T > &&value)
iterator begin()
iterator end()
qsizetype indexOf(const AT &value, qsizetype from) const const
void push_back(parameter_type value)
qsizetype size() const const
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
void deleteLater()
bool disconnect(const QMetaObject::Connection &connection)
iterator insert(const T &value)
QString arg(Args &&... args) const const
QString number(double n, char format, int precision)
double toDouble(bool *ok) const const
QString toLower() const const
QString trimmed() const const
AlignLeft
UniqueConnection
ItemIsEditable
QTextStream & dec(QTextStream &stream)
void setShowGrid(bool show)
void setWordWrap(bool on)
void cellChanged(int row, int column)
QWidget * cellWidget(int row, int column) const const
void itemSelectionChanged()
void setColumnCount(int columns)
void setHorizontalHeaderLabels(const QStringList &labels)
void setItem(int row, int column, QTableWidgetItem *item)
void setRowCount(int rows)
Qt::ItemFlags flags() const const
void setFlags(Qt::ItemFlags flags)
void setText(const QString &text)
void setTextAlignment(Qt::Alignment alignment)
QString text() const const
QFuture< T > run(Function function,...)
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)
void timeout()
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:58:38 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.