You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1263 lines
48 KiB
1263 lines
48 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2021-2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2022 Jiří Pinkava <jiri.pinkava@rossum.ai> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <cmath> |
|
|
|
#include <QDebug> |
|
#include <QAbstractSocket> |
|
#include <QTcpServer> |
|
#include <QTcpSocket> |
|
#include <QEventLoop> |
|
#include <QTimer> |
|
#include <QDateTime> |
|
#include <QVector3D> |
|
|
|
#include "SWGTargetAzimuthElevation.h" |
|
#include "SWGMapItem.h" |
|
#include "SWGStarTrackerTarget.h" |
|
#include "SWGSkyMapTarget.h" |
|
|
|
#include "webapi/webapiadapterinterface.h" |
|
#include "channel/channelwebapiutils.h" |
|
|
|
#include "util/units.h" |
|
#include "util/profiler.h" |
|
#include "maincore.h" |
|
|
|
#include "startracker.h" |
|
#include "startrackerworker.h" |
|
#include "startrackerreport.h" |
|
#include "spice.h" |
|
#include "spiceephemerides.h" |
|
|
|
MESSAGE_CLASS_DEFINITION(StarTrackerWorker::MsgConfigureStarTrackerWorker, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportAzAl, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportRADec, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportGalactic, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportAzElVsTime, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportSolarSystemPositions, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportJupiter, Message) |
|
MESSAGE_CLASS_DEFINITION(StarTrackerReport::MsgReportJupiterData, Message) |
|
|
|
static double linearInterpolate(double y1, double y2, double mu) |
|
{ |
|
return y1 + mu * (y2 - y1); |
|
} |
|
|
|
static double cubicInterpolate(double y0, double y1, double y2, double y3, double mu) |
|
{ |
|
double a0, a1, a2, a3, mu2; |
|
|
|
mu2 = mu * mu; |
|
a0 = y3 - y2 - y0 + y1; |
|
a1 = y0 - y1 - a0; |
|
a2 = y2 - y0; |
|
a3 = y1; |
|
|
|
return a0 * mu * mu2 + a1 * mu2 + a2 * mu + a3; |
|
} |
|
|
|
StarTrackerWorker::StarTrackerWorker(StarTracker* starTracker, WebAPIAdapterInterface *webAPIAdapterInterface) : |
|
m_starTracker(starTracker), |
|
m_webAPIAdapterInterface(webAPIAdapterInterface), |
|
m_msgQueueToFeature(nullptr), |
|
m_msgQueueToGUI(nullptr), |
|
m_pollTimer(this), |
|
m_tcpServer(nullptr), |
|
m_clientConnection(nullptr), |
|
m_solarFlux(0.0f), |
|
m_jplHorizons(nullptr), |
|
m_requestedEphemeridesLatitude(0.0), |
|
m_requestedEphemeridesLongitude(0.0), |
|
m_chartLatitude(0.0), |
|
m_chartLongitude(0.0), |
|
m_chartL(0.0f), |
|
m_chartB(0.0f) |
|
{ |
|
connect(&m_pollTimer, &QTimer::timeout, this, &StarTrackerWorker::update); |
|
} |
|
|
|
StarTrackerWorker::~StarTrackerWorker() |
|
{ |
|
stopWork(); |
|
m_inputMessageQueue.clear(); |
|
if (m_jplHorizons) |
|
{ |
|
disconnect(m_jplHorizons, &JPLHorizons::ephemeridesUpdated, this, &StarTrackerWorker::horizonsEphemeridesUpdated); |
|
delete m_jplHorizons; |
|
} |
|
} |
|
|
|
void StarTrackerWorker::startWork() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages())); |
|
m_pollTimer.start((int)round(m_settings.m_updatePeriod*1000.0)); |
|
// Handle any messages already on the queue |
|
handleInputMessages(); |
|
} |
|
|
|
void StarTrackerWorker::stopWork() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
m_pollTimer.stop(); |
|
disconnect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages())); |
|
|
|
if (m_settings.m_drawSunOnMap) |
|
removeFromMap("Sun"); |
|
if (m_settings.m_drawMoonOnMap) |
|
removeFromMap("Moon"); |
|
if (m_settings.m_drawStarOnMap && (m_settings.m_target != "Sun") && (m_settings.m_target != "Moon")) |
|
removeFromMap("Star"); |
|
|
|
restartServer(false, 0); |
|
} |
|
|
|
void StarTrackerWorker::handleInputMessages() |
|
{ |
|
Message* message; |
|
|
|
while ((message = m_inputMessageQueue.pop())) |
|
{ |
|
if (!handleMessage(*message)) { |
|
qDebug("%s: unhandled message: %s", Q_FUNC_INFO, message->getIdentifier()); |
|
} |
|
delete message; |
|
} |
|
} |
|
|
|
bool StarTrackerWorker::handleMessage(const Message& cmd) |
|
{ |
|
if (MsgConfigureStarTrackerWorker::match(cmd)) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
MsgConfigureStarTrackerWorker& cfg = (MsgConfigureStarTrackerWorker&) cmd; |
|
|
|
applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce()); |
|
return true; |
|
} |
|
else if (StarTracker::MsgSetSolarFlux::match(cmd)) |
|
{ |
|
StarTracker::MsgSetSolarFlux& msg = (StarTracker::MsgSetSolarFlux&) cmd; |
|
m_solarFlux = msg.getFlux(); |
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
void StarTrackerWorker::applySettings(const StarTrackerSettings& settings, const QList<QString>& settingsKeys, bool force) |
|
{ |
|
qDebug() << "StarTrackerWorker::applySettings:" << settings.getDebugString(settingsKeys, force) << " force: " << force; |
|
|
|
if (settingsKeys.contains("ra") |
|
|| settingsKeys.contains("dec") |
|
|| settingsKeys.contains("latitude") |
|
|| settingsKeys.contains("longitude") |
|
|| settingsKeys.contains("target") |
|
|| settingsKeys.contains("dateTime") |
|
|| settingsKeys.contains("refraction") |
|
|| settingsKeys.contains("pressure") |
|
|| settingsKeys.contains("temperature") |
|
|| settingsKeys.contains("humidity") |
|
|| settingsKeys.contains("heightAboveSeaLevel") |
|
|| settingsKeys.contains("temperatureLapseRate") |
|
|| settingsKeys.contains("frequency") |
|
|| settingsKeys.contains("beamwidth") |
|
|| settingsKeys.contains("azimuth") |
|
|| settingsKeys.contains("elevation") |
|
|| settingsKeys.contains("l") |
|
|| settingsKeys.contains("b") |
|
|| settingsKeys.contains("azimuthOffset") |
|
|| settingsKeys.contains("elevationOffset") |
|
|| settingsKeys.contains("night") |
|
|| settingsKeys.contains("logScale") |
|
|| settingsKeys.contains("utc") |
|
|| settingsKeys.contains("chartSelect") |
|
|| settingsKeys.contains("chartSubSelect") |
|
|| force) |
|
{ |
|
// Recalculate immediately |
|
QTimer::singleShot(1, this, &StarTrackerWorker::update); |
|
m_pollTimer.start((int)round(settings.m_updatePeriod*1000.0)); |
|
} |
|
else if (settingsKeys.contains("updatePeriod") || force) |
|
{ |
|
m_pollTimer.start((int)round(settings.m_updatePeriod*1000.0)); |
|
} |
|
|
|
if (settingsKeys.contains("drawSunOnMap") |
|
|| settingsKeys.contains("drawMoonOnMap") |
|
|| settingsKeys.contains("drawStarOnMap") |
|
|| settingsKeys.contains("target")) |
|
{ |
|
if (!settings.m_drawSunOnMap && m_settings.m_drawSunOnMap) |
|
removeFromMap("Sun"); |
|
if (!settings.m_drawMoonOnMap && m_settings.m_drawMoonOnMap) |
|
removeFromMap("Moon"); |
|
if ((!settings.m_drawStarOnMap && m_settings.m_drawStarOnMap) |
|
|| (((settings.m_target == "Sun") || (settings.m_target == "Moon")) |
|
&& ((m_settings.m_target != "Sun") && (m_settings.m_target != "Moon")))) |
|
removeFromMap("Star"); |
|
} |
|
|
|
if (settingsKeys.contains("serverPort") || |
|
settingsKeys.contains("enableServer") || force) |
|
{ |
|
restartServer(settings.m_enableServer, settings.m_serverPort); |
|
} |
|
|
|
if ((settingsKeys.contains("targetSource") || force) && (settings.m_targetSource == "Horizons")) |
|
{ |
|
if (!m_jplHorizons) |
|
{ |
|
m_jplHorizons = JPLHorizons::create(); |
|
if (m_jplHorizons) { |
|
connect(m_jplHorizons, &JPLHorizons::ephemeridesUpdated, this, &StarTrackerWorker::horizonsEphemeridesUpdated); |
|
} |
|
} |
|
} |
|
|
|
if (force) { |
|
m_settings = settings; |
|
} else { |
|
m_settings.applySettings(settingsKeys, settings); |
|
} |
|
} |
|
|
|
void StarTrackerWorker::restartServer(bool enabled, uint32_t port) |
|
{ |
|
if (m_tcpServer) |
|
{ |
|
if (m_clientConnection) |
|
{ |
|
m_clientConnection->close(); |
|
delete m_clientConnection; |
|
m_clientConnection = nullptr; |
|
} |
|
|
|
disconnect(m_tcpServer, &QTcpServer::newConnection, this, &StarTrackerWorker::acceptConnection); |
|
m_tcpServer->close(); |
|
delete m_tcpServer; |
|
m_tcpServer = nullptr; |
|
} |
|
|
|
if (enabled) |
|
{ |
|
qDebug() << "StarTrackerWorker::restartServer: server enabled on port " << port; |
|
m_tcpServer = new QTcpServer(this); |
|
|
|
if (!m_tcpServer->listen(QHostAddress::Any, port)) { |
|
qWarning("Star Tracker failed to listen on port %u. Check it is not already in use.", port); |
|
} else { |
|
connect(m_tcpServer, &QTcpServer::newConnection, this, &StarTrackerWorker::acceptConnection); |
|
} |
|
} |
|
} |
|
|
|
void StarTrackerWorker::acceptConnection() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
m_clientConnection = m_tcpServer->nextPendingConnection(); |
|
|
|
if (!m_clientConnection) { |
|
return; |
|
} |
|
|
|
connect(m_clientConnection, &QIODevice::readyRead, this, &StarTrackerWorker::readStellariumCommand); |
|
connect(m_clientConnection, SIGNAL(disconnected()), this, SLOT(disconnected())); |
|
#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0) |
|
connect(m_clientConnection, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &StarTrackerWorker::errorOccurred); |
|
#else |
|
connect(m_clientConnection, &QAbstractSocket::errorOccurred, this, &StarTrackerWorker::errorOccurred); |
|
#endif |
|
qDebug() << "StarTrackerWorker::acceptConnection: client connected"; |
|
} |
|
|
|
void StarTrackerWorker::disconnected() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
qDebug() << "StarTrackerWorker::disconnected"; |
|
m_clientConnection->deleteLater(); |
|
m_clientConnection = nullptr; |
|
/*if (m_msgQueueToFeature) |
|
{ |
|
StarTrackerWorker::MsgReportWorker *msg = StarTrackerWorker::MsgReportWorker::create("Disconnected"); |
|
m_msgQueueToFeature->push(msg); |
|
}*/ |
|
} |
|
|
|
void StarTrackerWorker::errorOccurred(QAbstractSocket::SocketError socketError) |
|
{ |
|
qDebug() << "StarTrackerWorker::errorOccurred: " << socketError; |
|
/*if (m_msgQueueToFeature) |
|
{ |
|
StarTrackerWorker::MsgReportWorker *msg = StarTrackerWorker::MsgReportWorker::create(m_socket.errorString() + " " + socketError); |
|
m_msgQueueToFeature->push(msg); |
|
}*/ |
|
} |
|
|
|
// Get RA & Dec from Stellarium |
|
// Protocol described here: |
|
// http://svn.code.sf.net/p/stellarium/code/trunk/telescope_server/stellarium_telescope_protocol.txt |
|
void StarTrackerWorker::readStellariumCommand() |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
unsigned char buf[64]; |
|
qint64 len; |
|
|
|
len = m_clientConnection->read((char *)buf, sizeof(buf)); |
|
if (len != -1) |
|
{ |
|
int msg_len; |
|
int msg_type; |
|
unsigned char *msg; |
|
|
|
// Extract length and message type |
|
msg_len = buf[0] | (buf[1] << 8); |
|
msg_type = buf[2] | (buf[3] << 8); |
|
msg = &buf[4]; |
|
|
|
if (msg_type == 0) // MessageGoto |
|
{ |
|
unsigned ra; |
|
int dec; |
|
|
|
if (msg_len == 20) |
|
{ |
|
// Skip time |
|
msg += 8; |
|
// Extract RA LSB first |
|
ra = msg[0] | (msg[1] << 8) | (msg[2] << 16) | (msg[3] << 24); |
|
msg += 4; |
|
// Extract DEC LSB first |
|
dec = msg[0] | (msg[1] << 8) | (msg[2] << 16) | (msg[3] << 24); |
|
msg += 4; |
|
|
|
// Convert from integer to floating point |
|
double raDeg = ra*(24.0/4294967296.0); // Convert to decimal hours |
|
double decDeg = dec*(360.0/4294967296.0); // Convert to decimal degrees |
|
|
|
// Set as current target |
|
m_settings.m_ra = Units::decimalHoursToHoursMinutesAndSeconds(raDeg); |
|
m_settings.m_dec = Units::decimalDegreesToDegreeMinutesAndSeconds(decDeg); |
|
|
|
qDebug() << "StarTrackerWorker: New target from Stellarum: " << m_settings.m_ra << " " << m_settings.m_dec; |
|
|
|
// Forward to GUI for display |
|
if (getMessageQueueToGUI()) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportRADec::create(raDeg, decDeg, "target")); |
|
} |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker: Unexpected number of bytes received (" << len << ") for message type: " << msg_type; |
|
} |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker: Unsupported Stellarium message type: " << msg_type; |
|
} |
|
} |
|
} |
|
|
|
// Send our target to Stellarium (J2000 epoch) |
|
void StarTrackerWorker::writeStellariumTarget(double ra, double dec) |
|
{ |
|
QMutexLocker mutexLocker(&m_mutex); |
|
|
|
if (m_clientConnection != nullptr) |
|
{ |
|
unsigned char buf[24]; |
|
|
|
// Length |
|
buf[0] = sizeof(buf); |
|
buf[1] = 0; |
|
// Type (MessageCurrentPosition) |
|
buf[2] = 0; |
|
buf[3] = 0; |
|
// Time (unused) |
|
buf[4] = 0; |
|
buf[5] = 0; |
|
buf[6] = 0; |
|
buf[7] = 0; |
|
buf[8] = 0; |
|
buf[9] = 0; |
|
buf[10] = 0; |
|
buf[11] = 0; |
|
// RA |
|
unsigned raInt = ra * (4294967296.0/24.0); |
|
buf[12] = raInt & 0xff; |
|
buf[13] = (raInt >> 8) & 0xff; |
|
buf[14] = (raInt >> 16) & 0xff; |
|
buf[15] = (raInt >> 24) & 0xff; |
|
// Dec |
|
int decInt = dec * (4294967296.0/360.0); |
|
buf[16] = decInt & 0xff; |
|
buf[17] = (decInt >> 8) & 0xff; |
|
buf[18] = (decInt >> 16) & 0xff; |
|
buf[19] = (decInt >> 24) & 0xff; |
|
// Status (OK) |
|
buf[20] = 0; |
|
buf[21] = 0; |
|
buf[22] = 0; |
|
buf[23] = 0; |
|
|
|
m_clientConnection->write((char *)buf, sizeof(buf)); |
|
} |
|
} |
|
|
|
void StarTrackerWorker::removeFromMap(QString id) |
|
{ |
|
QList<ObjectPipe*> mapMessagePipes; |
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_starTracker, "mapitems", mapMessagePipes); |
|
|
|
if (mapMessagePipes.size() > 0) { |
|
sendToMap(mapMessagePipes, id, "", "", 0.0, 0.0); |
|
} |
|
} |
|
|
|
void StarTrackerWorker::sendToMap( |
|
const QList<ObjectPipe*>& mapMessagePipes, |
|
QString name, |
|
QString image, |
|
QString text, |
|
double lat, |
|
double lon, |
|
double rotation |
|
) |
|
{ |
|
for (const auto& pipe : mapMessagePipes) |
|
{ |
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element); |
|
SWGSDRangel::SWGMapItem *swgMapItem = new SWGSDRangel::SWGMapItem(); |
|
swgMapItem->setName(new QString(name)); |
|
swgMapItem->setLatitude(lat); |
|
swgMapItem->setLongitude(lon); |
|
swgMapItem->setImage(new QString(image)); |
|
swgMapItem->setImageRotation(rotation); |
|
swgMapItem->setText(new QString(text)); |
|
|
|
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(m_starTracker, swgMapItem); |
|
messageQueue->push(msg); |
|
} |
|
} |
|
|
|
QString moonPhase(double sunLongitude, double moonLongitude, double observationLatitude, double &rotation) |
|
{ |
|
double difference = sunLongitude - moonLongitude; |
|
if (difference < -180.0) |
|
difference += 360.0; |
|
else if (difference > 180.0) |
|
difference -= 360.0; |
|
|
|
if (difference >= 0.0) |
|
rotation = observationLatitude - 90.0; |
|
else |
|
rotation = 90.0 - observationLatitude; |
|
|
|
// These probably shouldn't be divided equally |
|
if (difference < -157.5) |
|
return "full"; |
|
else if (difference < -112.5) |
|
return "waxing-gibbous"; |
|
else if (difference < -67.5) |
|
return "first-quarter"; |
|
else if (difference < -22.5) |
|
return "waxing-crescent"; |
|
else if (difference < 22.5) |
|
return "new"; |
|
else if (difference < 67.5) |
|
return "waning-crescent"; |
|
else if (difference < 112.5) |
|
return "third-quarter"; |
|
else if (difference < 157.5) |
|
return "waning-gibbous"; |
|
else if (difference < 202.5) |
|
return "full"; |
|
else |
|
return "full"; |
|
} |
|
|
|
bool StarTrackerWorker::getAzElFromSatelliteTracker(double &azimuth, double &elevation) |
|
{ |
|
unsigned int satelliteTrackerFeatureSetIndex,satelliteTrackerFeatureIndex; |
|
|
|
if (MainCore::getFeatureIndexFromId(m_settings.m_target, satelliteTrackerFeatureSetIndex, satelliteTrackerFeatureIndex)) |
|
{ |
|
if (ChannelWebAPIUtils::getFeatureReportValue(satelliteTrackerFeatureSetIndex, satelliteTrackerFeatureIndex, "targetAzimuth", azimuth) |
|
&& ChannelWebAPIUtils::getFeatureReportValue(satelliteTrackerFeatureSetIndex, satelliteTrackerFeatureIndex, "targetElevation", elevation)) |
|
{ |
|
return true; |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker::getAzElFromSatelliteTracker - Failed to get feature report value (targetAzimuth/targetElevation) from" << m_settings.m_target; |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker::getAzElFromSatelliteTracker - Failed to parse feature name" << m_settings.m_target; |
|
return false; |
|
} |
|
} |
|
|
|
bool StarTrackerWorker::getRAFromSkyMap(RADec &rdJ2000) |
|
{ |
|
double ra, dec; |
|
unsigned int featureSetIndex,featureIndex; |
|
|
|
if (MainCore::getFeatureIndexFromId(m_settings.m_target, featureSetIndex, featureIndex)) |
|
{ |
|
if (ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "ra", ra) |
|
&& ChannelWebAPIUtils::getFeatureReportValue(featureSetIndex, featureIndex, "dec", dec)) |
|
{ |
|
rdJ2000.ra = ra; |
|
rdJ2000.dec = dec; |
|
return true; |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker::getRAFromSkyMap - Failed to get feature report value (ra/dec) from" << m_settings.m_target; |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
qDebug() << "StarTrackerWorker::getRAFromSkyMap - Failed to parse feature name" << m_settings.m_target; |
|
return false; |
|
} |
|
} |
|
|
|
bool StarTrackerWorker::getRAFromHorizons(const QDateTime &dateTime, RADec &rdJ2000) |
|
{ |
|
|
|
if ( (m_requestedEphemeridesTarget != m_settings.m_target) |
|
|| (dateTime < m_requestedEphemeridesStartTime) |
|
|| (dateTime > m_requestedEphemeridesStopTime) |
|
|| (m_requestedEphemeridesLatitude != m_settings.m_latitude) |
|
|| (m_requestedEphemeridesLongitude != m_settings.m_longitude) |
|
) |
|
{ |
|
// Clear current data |
|
m_ephemeridesTarget = ""; |
|
m_horizonsEphemerides = {}; |
|
// Request ephemerides |
|
m_requestedEphemeridesTarget = m_settings.m_target; |
|
m_requestedEphemeridesStartTime = QDateTime(dateTime.date(), QTime(0, 0)); |
|
m_requestedEphemeridesStopTime = QDateTime(dateTime.date().addDays(1), QTime(0, 0)); |
|
m_requestedEphemeridesLatitude = m_settings.m_latitude; |
|
m_requestedEphemeridesLongitude = m_settings.m_longitude; |
|
m_jplHorizons->getData(m_requestedEphemeridesTarget, m_requestedEphemeridesStartTime, m_requestedEphemeridesStopTime, m_requestedEphemeridesLatitude, m_requestedEphemeridesLongitude, 0.0f); |
|
} |
|
else if ( (m_settings.m_target == m_ephemeridesTarget) |
|
&& ( !m_horizonsEphemerides.isEmpty() |
|
&& ( (dateTime >= m_horizonsEphemerides[0].m_dateTime) |
|
|| (dateTime < m_horizonsEphemerides[m_horizonsEphemerides.size() - 1].m_dateTime) |
|
) |
|
) |
|
) |
|
{ |
|
// Find closest empheris |
|
for (int i = 0; i < m_horizonsEphemerides.size() - 1; i++) |
|
{ |
|
if ((dateTime >= m_horizonsEphemerides[i].m_dateTime) && (dateTime < m_horizonsEphemerides[i+1].m_dateTime)) |
|
{ |
|
// Interpolate |
|
|
|
qint64 x = dateTime.toMSecsSinceEpoch(); |
|
qint64 x1 = m_horizonsEphemerides[i].m_dateTime.toMSecsSinceEpoch(); |
|
qint64 x2 = m_horizonsEphemerides[i+1].m_dateTime.toMSecsSinceEpoch(); |
|
qint64 diff = x2 - x1; |
|
double mu = (x - x1) / (double) diff; |
|
|
|
if ((i == 0) || (i >= m_horizonsEphemerides.size() - 2)) |
|
{ |
|
rdJ2000.ra = linearInterpolate(m_horizonsEphemerides[i].m_ra, m_horizonsEphemerides[i+1].m_ra, mu); |
|
rdJ2000.dec = linearInterpolate(m_horizonsEphemerides[i].m_dec, m_horizonsEphemerides[i+1].m_dec, mu); |
|
} |
|
else |
|
{ |
|
rdJ2000.ra = cubicInterpolate(m_horizonsEphemerides[i-1].m_ra, m_horizonsEphemerides[i].m_ra, m_horizonsEphemerides[i+1].m_ra, m_horizonsEphemerides[i+2].m_ra, mu); |
|
rdJ2000.dec = cubicInterpolate(m_horizonsEphemerides[i-1].m_dec, m_horizonsEphemerides[i].m_dec, m_horizonsEphemerides[i+1].m_dec, m_horizonsEphemerides[i+2].m_dec, mu); |
|
} |
|
return true; |
|
} |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
void StarTrackerWorker::update() |
|
{ |
|
AzAlt aa{}, sunAA{}, moonAA; |
|
RADec rdJnow, sunRD{}, moonRD; |
|
bool rdJnowValid = false; |
|
double l, b; |
|
bool lbTarget = false; |
|
bool horizonsTarget = false; |
|
QDateTime dt; |
|
|
|
const QStringList raDecTargets = { |
|
"Custom RA/Dec", "PSR B0329+54", "PSR B0833-45", "Sagittarius A", "Cassiopeia A", "Cygnus A", "Taurus A (M1)", "Virgo A (M87)" |
|
}; |
|
const QStringList lbTargets = { |
|
"Custom l/b", "S7", "S8", "S9" |
|
}; |
|
|
|
PROFILER_START(); |
|
|
|
spiceLock(SpiceEphemerides::getEphemeridesFiles(m_settings.m_spiceEphemerides)); |
|
|
|
// Get date and time to calculate position at |
|
dt = m_settings.getDateTime(); |
|
|
|
// Calculate position |
|
if ((m_settings.m_target == "Sun") || m_settings.m_drawSunOnMap || m_settings.m_drawSunOnSkyTempChart) |
|
{ |
|
Astronomy::sunPosition(sunAA, sunRD, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportRADec::create(sunRD.ra, sunRD.dec, "sun")); |
|
} |
|
if ((m_settings.m_target == "Moon") || m_settings.m_drawMoonOnMap || m_settings.m_drawMoonOnSkyTempChart) |
|
{ |
|
Astronomy::moonPosition(moonAA, moonRD, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportRADec::create(moonRD.ra, moonRD.dec, "moon")); |
|
} |
|
|
|
if ((m_settings.m_target == "Sun") && (m_settings.m_targetSource == "SDRangel")) |
|
{ |
|
rdJnow = sunRD; |
|
rdJnowValid = true; |
|
aa = sunAA; |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
else if ((m_settings.m_target == "Moon") && (m_settings.m_targetSource == "SDRangel")) |
|
{ |
|
rdJnow = moonRD; |
|
rdJnowValid = true; |
|
aa = moonAA; |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
else if (m_settings.m_target.contains("SatelliteTracker")) |
|
{ |
|
// Get Az/El from Satellite Tracker |
|
double azimuth, elevation; |
|
if (getAzElFromSatelliteTracker(azimuth, elevation)) |
|
{ |
|
m_settings.m_el = elevation; |
|
m_settings.m_az = azimuth; |
|
// Convert Alt/Az to RA/Dec and l/b |
|
aa.alt = m_settings.m_el; |
|
aa.az = m_settings.m_az; |
|
rdJnow = Astronomy::azAltToRaDec(aa, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
rdJnowValid = true; |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
} |
|
else if (m_settings.m_target == "Custom Az/El") |
|
{ |
|
// Convert Alt/Az to RA/Dec and l/b |
|
aa.alt = m_settings.m_el; |
|
aa.az = m_settings.m_az; |
|
rdJnow = Astronomy::azAltToRaDec(aa, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
rdJnowValid = true; |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
else if (lbTargets.contains(m_settings.m_target)) |
|
{ |
|
// Convert l/b to RA/Dec, then Alt/Az |
|
l = m_settings.m_l; |
|
b = m_settings.m_b; |
|
RADec rdJ2000; |
|
Astronomy::galacticToEquatorial(l, b, rdJ2000.ra, rdJ2000.dec); |
|
aa = Astronomy::raDecToAzAlt(rdJ2000, m_settings.m_latitude, m_settings.m_longitude, dt, true); |
|
lbTarget = true; |
|
rdJnow = Astronomy::precess(rdJ2000, Astronomy::jd_j2000(), Astronomy::julianDate(dt)); |
|
rdJnowValid = true; |
|
} |
|
else if (m_settings.m_targetSource == "SPICE") |
|
{ |
|
// Calculate Alt/Az and RA/Dec with SPICE, then convert to l/b |
|
double et; |
|
|
|
if (dateTimeToET(dt, et)) |
|
{ |
|
getAzElFromSPICE(m_settings.m_target, et, m_settings.m_latitude, m_settings.m_longitude, 0.0, aa.az, aa.alt); |
|
|
|
RADec rdJ2000; |
|
if (getRADecFromSPICE(m_settings.m_target, et, rdJ2000.ra, rdJ2000.dec)) |
|
{ |
|
rdJnow = Astronomy::precess(rdJ2000, Astronomy::jd_j2000(), Astronomy::julianDate(dt)); |
|
rdJnowValid = true; |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
RADec rdJ2000; |
|
if (m_settings.m_target.contains("SkyMap")) |
|
{ |
|
// Get RA/Dec from Sky Map |
|
if (getRAFromSkyMap(rdJ2000)) |
|
{ |
|
m_settings.m_ra = QString::number(rdJ2000.ra, 'f', 10);; |
|
m_settings.m_dec = QString::number(rdJ2000.dec, 'f', 10);; |
|
rdJnow = Astronomy::precess(rdJ2000, Astronomy::jd_j2000(), Astronomy::julianDate(dt)); |
|
rdJnowValid = true; |
|
} |
|
} |
|
else if ((m_settings.m_targetSource == "Horizons") && !raDecTargets.contains(m_settings.m_target)) |
|
{ |
|
// Get RA/Dec from Horizons |
|
if (getRAFromHorizons(dt, rdJ2000)) |
|
{ |
|
m_settings.m_ra = QString::number(rdJ2000.ra, 'f', 10);; |
|
m_settings.m_dec = QString::number(rdJ2000.dec, 'f', 10);; |
|
rdJnow = Astronomy::precess(rdJ2000, Astronomy::jd_j2000(), Astronomy::julianDate(dt)); |
|
rdJnowValid = true; |
|
horizonsTarget = true; |
|
} |
|
} |
|
else if ((m_settings.m_target == "Custom RA/Dec") && m_settings.m_jnow) |
|
{ |
|
rdJnow.ra = Units::raToDecimal(m_settings.m_ra); |
|
rdJnow.dec = Units::decToDecimal(m_settings.m_dec); |
|
rdJnowValid = true; |
|
rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
} |
|
else |
|
{ |
|
rdJ2000.ra = Units::raToDecimal(m_settings.m_ra); |
|
rdJ2000.dec = Units::decToDecimal(m_settings.m_dec); |
|
rdJnowValid = true; |
|
rdJnow = Astronomy::precess(rdJ2000, Astronomy::jd_j2000(), Astronomy::julianDate(dt)); |
|
} |
|
if (rdJnowValid) |
|
{ |
|
aa = Astronomy::raDecToAzAlt(rdJnow, m_settings.m_latitude, m_settings.m_longitude, dt, false); |
|
Astronomy::equatorialToGalactic(rdJ2000.ra, rdJ2000.dec, l, b); |
|
} |
|
} |
|
|
|
if (rdJnowValid) |
|
{ |
|
// Precess to J2000 |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
|
|
// Send to Stellarium |
|
writeStellariumTarget(rdJ2000.ra, rdJ2000.dec); |
|
|
|
// Send to GUI |
|
if ((m_settings.m_target == "Sun") || (m_settings.m_target == "Moon") || (m_settings.m_target == "Custom Az/El") |
|
|| m_settings.m_target.contains("SatelliteTracker") || m_settings.m_target.contains("SkyMap") |
|
|| lbTarget || horizonsTarget || (m_settings.m_targetSource == "SPICE")) |
|
{ |
|
if (getMessageQueueToGUI()) |
|
{ |
|
if (m_settings.m_jnow) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportRADec::create(rdJnow.ra, rdJnow.dec, "target")); |
|
} else { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportRADec::create(rdJ2000.ra, rdJ2000.dec, "target")); |
|
} |
|
} |
|
} |
|
|
|
// Adjust for refraction |
|
if (m_settings.m_refraction == "Positional Astronomy Library") |
|
{ |
|
aa.alt += Astronomy::refractionPAL(aa.alt, m_settings.m_pressure, m_settings.m_temperature, m_settings.m_humidity, |
|
m_settings.m_frequency, m_settings.m_latitude, m_settings.m_heightAboveSeaLevel, |
|
m_settings.m_temperatureLapseRate); |
|
if (aa.alt > 90.0) { |
|
aa.alt = 90.0f; |
|
} |
|
} |
|
else if (m_settings.m_refraction == "Saemundsson") |
|
{ |
|
aa.alt += Astronomy::refractionSaemundsson(aa.alt, m_settings.m_pressure, m_settings.m_temperature); |
|
if (aa.alt > 90.0) { |
|
aa.alt = 90.0f; |
|
} |
|
} |
|
|
|
// Add user-adjustment |
|
aa.alt += m_settings.m_elevationOffset; |
|
aa.az += m_settings.m_azimuthOffset; |
|
|
|
// Send to GUI |
|
if (getMessageQueueToGUI()) |
|
{ |
|
// MsgReportRADec sent in updateRaDec() |
|
if (m_settings.m_target != "Custom Az/El") { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportAzAl::create(aa.az, aa.alt)); |
|
} |
|
if (!lbTarget) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportGalactic::create(l, b)); |
|
} |
|
} |
|
|
|
// Send Az/El to Rotator Controllers |
|
// Unless we're receiving settings to display from a Radio Astronomy plugins |
|
if (!m_settings.m_link) |
|
{ |
|
QList<ObjectPipe*> rotatorPipes; |
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_starTracker, "target", rotatorPipes); |
|
|
|
for (const auto& pipe : rotatorPipes) |
|
{ |
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element); |
|
SWGSDRangel::SWGTargetAzimuthElevation *swgTarget = new SWGSDRangel::SWGTargetAzimuthElevation(); |
|
swgTarget->setName(new QString(m_settings.m_target)); |
|
swgTarget->setAzimuth(aa.az); |
|
swgTarget->setElevation(aa.alt); |
|
messageQueue->push(MainCore::MsgTargetAzimuthElevation::create(m_starTracker, swgTarget)); |
|
} |
|
} |
|
|
|
// Send Az/El, RA/Dec and Galactic b/l to Radio Astronomy plugins |
|
// Unless we're receiving settings to display from a Radio Astronomy plugins |
|
if (!m_settings.m_link) |
|
{ |
|
QList<ObjectPipe*> starTrackerPipes; |
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_starTracker, "startracker.target", starTrackerPipes); |
|
|
|
for (const auto& pipe : starTrackerPipes) |
|
{ |
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element); |
|
SWGSDRangel::SWGStarTrackerTarget *swgTarget = new SWGSDRangel::SWGStarTrackerTarget(); |
|
swgTarget->setName(new QString(m_settings.m_target)); |
|
swgTarget->setAzimuth(aa.az); |
|
swgTarget->setElevation(aa.alt); |
|
swgTarget->setRa(rdJnow.ra); |
|
swgTarget->setDec(rdJnow.dec); |
|
swgTarget->setB(b); |
|
swgTarget->setL(l); |
|
swgTarget->setSolarFlux(m_solarFlux); |
|
swgTarget->setAirTemperature(m_settings.m_temperature); |
|
double temp; |
|
m_starTracker->calcSkyTemperature(m_settings.m_frequency, m_settings.m_beamwidth, rdJnow.ra, rdJnow.dec, temp); |
|
swgTarget->setSkyTemperature(temp); |
|
swgTarget->setHpbw(m_settings.m_beamwidth); |
|
// Calculate velocities |
|
double vRot = Astronomy::earthRotationVelocity(rdJnow, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
swgTarget->setEarthRotationVelocity(vRot); |
|
double vOrbit = Astronomy::earthOrbitVelocityBCRS(rdJnow, dt); |
|
swgTarget->setEarthOrbitVelocityBcrs(vOrbit); |
|
double vLSRK = Astronomy::sunVelocityLSRK(rdJnow); |
|
swgTarget->setSunVelocityLsr(vLSRK); |
|
messageQueue->push(MainCore::MsgStarTrackerTarget::create(m_starTracker, swgTarget)); |
|
} |
|
} |
|
|
|
// Send RA/Dec, position, beamwidth and date to Sky Map |
|
QList<ObjectPipe*> skyMapPipes; |
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_starTracker, "skymap.target", skyMapPipes); |
|
for (const auto& pipe : skyMapPipes) |
|
{ |
|
MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element); |
|
SWGSDRangel::SWGSkyMapTarget *swgTarget = new SWGSDRangel::SWGSkyMapTarget(); |
|
RADec rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
swgTarget->setRa(rdJ2000.ra); |
|
swgTarget->setDec(rdJ2000.dec); |
|
swgTarget->setLatitude(m_settings.m_latitude); |
|
swgTarget->setLongitude(m_settings.m_longitude); |
|
swgTarget->setAltitude(m_settings.m_heightAboveSeaLevel); |
|
swgTarget->setDateTime(new QString(dt.toString(Qt::ISODateWithMs))); |
|
swgTarget->setHpbw(m_settings.m_beamwidth); |
|
messageQueue->push(MainCore::MsgSkyMapTarget::create(m_starTracker, swgTarget)); |
|
} |
|
|
|
// Send to Map |
|
if (m_settings.m_drawSunOnMap || m_settings.m_drawMoonOnMap || m_settings.m_drawStarOnMap) |
|
{ |
|
QList<ObjectPipe*> mapMessagePipes; |
|
MainCore::instance()->getMessagePipes().getMessagePipes(m_starTracker, "mapitems", mapMessagePipes); |
|
|
|
if (mapMessagePipes.size() > 0) |
|
{ |
|
// Different between GMST(Lst at Greenwich) and RA |
|
double lst = Astronomy::localSiderealTime(dt, 0.0); |
|
double sunLongitude; |
|
double sunLatitude; |
|
|
|
if (m_settings.m_drawSunOnMap || m_settings.m_drawMoonOnMap) |
|
{ |
|
sunLongitude = Astronomy::lstAndRAToLongitude(lst, sunRD.ra); |
|
sunLatitude = sunRD.dec; |
|
sendToMap(mapMessagePipes, "Sun", "qrc:///startracker/startracker/sun-40.png", "Sun", sunLatitude, sunLongitude); |
|
} |
|
if (m_settings.m_drawMoonOnMap) |
|
{ |
|
double moonLongitude = Astronomy::lstAndRAToLongitude(lst, moonRD.ra); |
|
double moonLatitude = moonRD.dec; |
|
double moonRotation; |
|
QString phase = moonPhase(sunLongitude, moonLongitude, m_settings.m_latitude, moonRotation); |
|
sendToMap(mapMessagePipes, "Moon", QString("qrc:///startracker/startracker/moon-%1-32").arg(phase), "Moon", |
|
moonLatitude, moonLongitude, moonRotation); |
|
} |
|
if ((m_settings.m_drawStarOnMap) && (m_settings.m_target != "Sun") && (m_settings.m_target != "Moon")) |
|
{ |
|
double starLongitude = Astronomy::lstAndRAToLongitude(lst, rdJnow.ra); |
|
double starLatitude = rdJnow.dec; |
|
QString text = m_settings.m_target.startsWith("Custom") ? "Star" : m_settings.m_target; |
|
sendToMap(mapMessagePipes, "Star", "qrc:///startracker/startracker/pulsar-32.png", text, starLatitude, starLongitude); |
|
} |
|
} |
|
} |
|
|
|
if (m_settings.m_chartSelect == StarTrackerSettings::CHART_SOLAR_SYSTEM) { |
|
calculateSolarSystemPositions(dt); |
|
} |
|
if (m_settings.m_chartSelect == StarTrackerSettings::CHART_JUPITER) { |
|
calculateJupiterParameters(dt); |
|
} |
|
|
|
// Calculate az/el of target over the current day for plotting on chart |
|
// Can't do this for satellite tracker, as we only have current az/el |
|
// Values from SkyMap map not be valid if object is moving (E.g. planets), as ra/dec is for one point in time |
|
|
|
// Start at midnight or noon |
|
QDateTime lt = dt.toLocalTime(); |
|
if (m_settings.m_night) |
|
{ |
|
if (lt.time() < QTime(12, 0)) { |
|
dt = QDateTime(lt.date().addDays(-1), QTime(12, 0)); |
|
} else { |
|
dt = QDateTime(lt.date(), QTime(12, 0)); |
|
} |
|
} |
|
else |
|
{ |
|
dt = QDateTime(lt.date(), QTime(0, 0)); |
|
} |
|
//dt.setTimeZone(QTimeZone::LocalTime()); |
|
|
|
if ( (m_settings.m_target != m_chartTarget) |
|
|| (m_settings.m_latitude != m_chartLatitude) || (m_settings.m_longitude != m_chartLongitude) |
|
|| (dt != m_chartStartTime) |
|
|| (m_settings.m_target.startsWith("Custom")) |
|
|| ( (raDecTargets.contains(m_settings.m_target) || m_settings.m_target.contains("SkyMap")) // When switching these targets, we get separate settings updates for RA and Dec, so need to redraw |
|
&& ((m_settings.m_ra != m_chartRA) || (m_settings.m_dec != m_chartDec)) // We don't want to redraw when RA/Dec for Sun/Moon changes though, as that happens continuously |
|
) |
|
|| ( lbTargets.contains(m_settings.m_target) |
|
&& ((m_settings.m_l != m_chartL) || (m_settings.m_b != m_chartB)) |
|
) |
|
) |
|
{ |
|
m_chartTarget = m_settings.m_target; |
|
m_chartLatitude = m_settings.m_latitude; |
|
m_chartLongitude = m_settings.m_longitude; |
|
m_chartStartTime = dt; |
|
m_chartRA = m_settings.m_ra; |
|
m_chartDec = m_settings.m_dec; |
|
m_chartL = m_settings.m_l; |
|
m_chartB = m_settings.m_b; |
|
|
|
if (!m_settings.m_target.contains("SatelliteTracker")) |
|
{ |
|
int timestep = 5*60; // 5 mins |
|
|
|
QList<double> azimuths; |
|
QList<double> elevations; |
|
QList<QDateTime> dateTimes; |
|
|
|
for (int step = 0; step <= 24*60*60/timestep; step++) |
|
{ |
|
AzAlt aa{}; |
|
RADec rdJnow, rdJ2000; |
|
|
|
// Calculate elevation of desired object |
|
if ((m_settings.m_target == "Sun") && (m_settings.m_targetSource == "SDRangel")) |
|
{ |
|
Astronomy::sunPosition(aa, rdJnow, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
} |
|
else if ((m_settings.m_target == "Moon") && (m_settings.m_targetSource == "SDRangel")) |
|
{ |
|
Astronomy::moonPosition(aa, rdJnow, m_settings.m_latitude, m_settings.m_longitude, dt); |
|
} |
|
else if (m_settings.m_target == "Custom Az/El") |
|
{ |
|
aa.alt = m_settings.m_el; |
|
aa.az = m_settings.m_az; |
|
} |
|
else if (lbTargets.contains(m_settings.m_target)) |
|
{ |
|
Astronomy::galacticToEquatorial(m_settings.m_l, m_settings.m_b, rdJ2000.ra, rdJ2000.dec); |
|
aa = Astronomy::raDecToAzAlt(rdJ2000, m_settings.m_latitude, m_settings.m_longitude, dt, true); |
|
} |
|
else if (m_settings.m_targetSource == "SPICE") |
|
{ |
|
double et; |
|
|
|
if (dateTimeToET(dt, et)) { |
|
getAzElFromSPICE(m_settings.m_target, et, m_settings.m_latitude, m_settings.m_longitude, 0.0, aa.az, aa.alt); |
|
} |
|
} |
|
else |
|
{ |
|
if (m_settings.m_target.contains("SkyMap")) |
|
{ |
|
getRAFromSkyMap(rdJ2000); |
|
} |
|
else if ((m_settings.m_targetSource == "Horizons") && !raDecTargets.contains(m_settings.m_target)) |
|
{ |
|
getRAFromHorizons(dt, rdJ2000); |
|
} |
|
else if ((m_settings.m_target == "Custom RA/Dec") && m_settings.m_jnow) |
|
{ |
|
rdJnow.ra = Units::raToDecimal(m_settings.m_ra); |
|
rdJnow.dec = Units::decToDecimal(m_settings.m_dec); |
|
rdJ2000 = Astronomy::precess(rdJnow, Astronomy::julianDate(dt), Astronomy::jd_j2000()); |
|
} |
|
else |
|
{ |
|
rdJ2000.ra = Units::raToDecimal(m_settings.m_ra); |
|
rdJ2000.dec = Units::decToDecimal(m_settings.m_dec); |
|
} |
|
aa = Astronomy::raDecToAzAlt(rdJ2000, m_settings.m_latitude, m_settings.m_longitude, dt, !m_settings.m_jnow); |
|
} |
|
|
|
azimuths.append(aa.az); |
|
elevations.append(aa.alt); |
|
dateTimes.append(dt); |
|
|
|
dt = dt.addSecs(timestep); // addSecs accounts for daylight savings jumps |
|
} |
|
|
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportAzElVsTime::create(m_settings.m_target, azimuths, elevations, dateTimes)); |
|
} |
|
} |
|
} |
|
|
|
spiceUnlock(); |
|
|
|
PROFILER_STOP("StarTrackerWorker"); |
|
} |
|
|
|
void StarTrackerWorker::calculateSolarSystemPositions(const QDateTime& dateTime) |
|
{ |
|
QStringList bodyNames; |
|
QList<QVector3D> bodyPositions; |
|
QList<QList<QPointF>> orbits; |
|
|
|
static const QStringList planets = { |
|
"MERCURY", "VENUS", "EARTH", "MARS", "JUPITER", "SATURN", "URANUS", "NEPTUNE", |
|
"MERCURY BARYCENTER", "VENUS BARYCENTER", "EARTH BARYCENTER", "MARS BARYCENTER", "JUPITER BARYCENTER", "SATURN BARYCENTER", "URANUS BARYCENTER", "NEPTUNE BARYCENTER" |
|
}; |
|
|
|
double et; |
|
if (!dateTimeToET(dateTime, et)) { |
|
return; |
|
} |
|
|
|
for (const auto& body : m_settings.m_solarSystemBodies) |
|
{ |
|
QVector3D positionKm; |
|
|
|
if (spicePosition(body, et, positionKm)) |
|
{ |
|
QVector3D position(positionKm[0], positionKm[1], positionKm[2]); |
|
|
|
bodyNames.append(body); |
|
bodyPositions.append(position); |
|
|
|
QList<QPointF> orbit; |
|
if (planets.contains(body)) { |
|
spiceOrbit(body, et, orbit); |
|
} |
|
orbits.append(orbit); |
|
} |
|
} |
|
|
|
if (getMessageQueueToGUI()) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportSolarSystemPositions::create(dateTime, bodyNames, bodyPositions, orbits)); |
|
} |
|
} |
|
|
|
void StarTrackerWorker::calculateJupiterParameters(const QDateTime& dateTime) |
|
{ |
|
double cml; |
|
double ioPhase; |
|
double ganymedePhase; |
|
double et; |
|
double az, el; |
|
bool jupiterVisibleNow = false; |
|
QDateTime dt; |
|
bool done; |
|
|
|
QString moon = m_settings.m_chartSubSelect == 0 ? "IO" : "GANYMEDE"; |
|
double moonPhase; |
|
|
|
QList<StarTrackerReport::JupiterData> jupiterData; |
|
QList<StarTrackerReport::JupiterMoonData> moonData; |
|
|
|
PROFILER_START(); |
|
|
|
if (dateTimeToET(dateTime, et)) |
|
{ |
|
// Calculate Alt/El of Jupiter |
|
if (getAzElFromSPICE("JUPITER", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, az, el)) |
|
{ |
|
// Calculate Jupiter CML and phase of Moons |
|
if (spiceJupiterMoonPhase("IO", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, cml, ioPhase)) |
|
{ |
|
if (spiceJupiterMoonPhase("GANYMEDE", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, cml, ganymedePhase)) |
|
{ |
|
if (getMessageQueueToGUI()) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportJupiter::create(dateTime, az, el, cml, ioPhase, ganymedePhase)); |
|
} |
|
} |
|
} |
|
jupiterVisibleNow = el > 0.0; |
|
} |
|
} |
|
|
|
if (jupiterVisibleNow) |
|
{ |
|
// Step backwards in time |
|
dt = dateTime; |
|
dt.setTime(QTime(dateTime.time().hour(), 0)); |
|
done = false; |
|
while (!done) |
|
{ |
|
if (dateTimeToET(dt, et)) |
|
{ |
|
if (getAzElFromSPICE("JUPITER", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, az, el)) |
|
{ |
|
if (el > 0.0) |
|
{ |
|
if (spiceJupiterMoonPhase(moon, et, m_settings.m_latitude, m_settings.m_longitude, 0.0, cml, moonPhase)) |
|
{ |
|
StarTrackerReport::JupiterData jd = {dt, az, el}; |
|
StarTrackerReport::JupiterMoonData md = {cml, moonPhase}; |
|
|
|
jupiterData.push_front(jd); |
|
moonData.push_front(md); |
|
} |
|
} |
|
else |
|
{ |
|
done = true; |
|
} |
|
} |
|
} |
|
dt = dt.addSecs(-60*60); |
|
} |
|
|
|
// Step forwards in time |
|
dt = dateTime; |
|
dt.setTime(QTime(dateTime.time().hour(), 0)); |
|
done = false; |
|
while (!done) |
|
{ |
|
dt = dt.addSecs(60*60); |
|
if (dateTimeToET(dt, et)) |
|
{ |
|
if (getAzElFromSPICE("JUPITER", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, az, el)) |
|
{ |
|
if (el > 0.0) |
|
{ |
|
if (spiceJupiterMoonPhase(moon, et, m_settings.m_latitude, m_settings.m_longitude, 0.0, cml, moonPhase)) |
|
{ |
|
StarTrackerReport::JupiterData jd = {dt, az, el}; |
|
StarTrackerReport::JupiterMoonData id = {cml, moonPhase}; |
|
|
|
jupiterData.push_back(jd); |
|
moonData.push_back(id); |
|
} |
|
} |
|
else |
|
{ |
|
done = true; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// Step forwards in time until Jupiter is visible |
|
dt = dateTime; |
|
dt.setTime(QTime(dateTime.time().hour(), 0)); |
|
done = false; |
|
while (!done) |
|
{ |
|
dt = dt.addSecs(60*60); |
|
if (dateTimeToET(dt, et)) |
|
{ |
|
if (getAzElFromSPICE("JUPITER", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, az, el)) |
|
{ |
|
if (el > 0.0) { |
|
done = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Continue stepping forward until no longer visible |
|
done = false; |
|
while (!done) |
|
{ |
|
if (dateTimeToET(dt, et)) |
|
{ |
|
if (getAzElFromSPICE("JUPITER", et, m_settings.m_latitude, m_settings.m_longitude, 0.0, az, el)) |
|
{ |
|
if (el > 0.0) |
|
{ |
|
if (spiceJupiterMoonPhase(moon, et, m_settings.m_latitude, m_settings.m_longitude, 0.0, cml, moonPhase)) |
|
{ |
|
StarTrackerReport::JupiterData jd = {dt, az, el}; |
|
StarTrackerReport::JupiterMoonData id = {cml, moonPhase}; |
|
|
|
jupiterData.push_back(jd); |
|
moonData.push_back(id); |
|
} |
|
} |
|
else |
|
{ |
|
done = true; |
|
} |
|
} |
|
} |
|
dt = dt.addSecs(60*60); |
|
} |
|
|
|
} |
|
|
|
if (getMessageQueueToGUI()) { |
|
getMessageQueueToGUI()->push(StarTrackerReport::MsgReportJupiterData::create(jupiterData, moonData)); |
|
} |
|
|
|
PROFILER_STOP("calculateJupiterParameters"); |
|
} |
|
|
|
void StarTrackerWorker::horizonsEphemeridesUpdated(const QString &target, const QList<JPLHorizons::Ephemeris>& ephemerides) |
|
{ |
|
m_ephemeridesTarget = target; |
|
m_horizonsEphemerides = ephemerides; |
|
}
|
|
|