|
|
|
|
@ -19,17 +19,25 @@
@@ -19,17 +19,25 @@
|
|
|
|
|
#include <algorithm> |
|
|
|
|
|
|
|
|
|
#include <QTime> |
|
|
|
|
#include <QBuffer> |
|
|
|
|
#include <QDebug> |
|
|
|
|
|
|
|
|
|
#include "maincore.h" |
|
|
|
|
#include "util/units.h" |
|
|
|
|
|
|
|
|
|
#include "aptdemod.h" |
|
|
|
|
#include "aptdemodimageworker.h" |
|
|
|
|
|
|
|
|
|
#include "SWGMapItem.h" |
|
|
|
|
|
|
|
|
|
MESSAGE_CLASS_DEFINITION(APTDemodImageWorker::MsgConfigureAPTDemodImageWorker, Message) |
|
|
|
|
MESSAGE_CLASS_DEFINITION(APTDemodImageWorker::MsgSaveImageToDisk, Message) |
|
|
|
|
MESSAGE_CLASS_DEFINITION(APTDemodImageWorker::MsgSetSatelliteName, Message) |
|
|
|
|
|
|
|
|
|
APTDemodImageWorker::APTDemodImageWorker() : |
|
|
|
|
APTDemodImageWorker::APTDemodImageWorker(APTDemod *aptDemod) : |
|
|
|
|
m_messageQueueToGUI(nullptr), |
|
|
|
|
m_aptDemod(aptDemod), |
|
|
|
|
m_sgp4(nullptr), |
|
|
|
|
m_running(false), |
|
|
|
|
m_mutex(QMutex::Recursive) |
|
|
|
|
{ |
|
|
|
|
@ -51,6 +59,8 @@ APTDemodImageWorker::~APTDemodImageWorker()
@@ -51,6 +59,8 @@ APTDemodImageWorker::~APTDemodImageWorker()
|
|
|
|
|
delete[] m_image.prow[y]; |
|
|
|
|
delete[] m_tempImage.prow[y]; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
delete m_sgp4; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::reset() |
|
|
|
|
@ -129,6 +139,8 @@ bool APTDemodImageWorker::handleMessage(const Message& cmd)
@@ -129,6 +139,8 @@ bool APTDemodImageWorker::handleMessage(const Message& cmd)
|
|
|
|
|
void APTDemodImageWorker::applySettings(const APTDemodSettings& settings, bool force) |
|
|
|
|
{ |
|
|
|
|
(void) force; |
|
|
|
|
|
|
|
|
|
bool callRecalcCoords = false; |
|
|
|
|
bool callProcessImage = false; |
|
|
|
|
|
|
|
|
|
if ((settings.m_cropNoise != m_settings.m_cropNoise) || |
|
|
|
|
@ -137,14 +149,52 @@ void APTDemodImageWorker::applySettings(const APTDemodSettings& settings, bool f
@@ -137,14 +149,52 @@ void APTDemodImageWorker::applySettings(const APTDemodSettings& settings, bool f
|
|
|
|
|
(settings.m_histogramEqualise != m_settings.m_histogramEqualise) || |
|
|
|
|
(settings.m_precipitationOverlay != m_settings.m_precipitationOverlay) || |
|
|
|
|
(settings.m_flip != m_settings.m_flip) || |
|
|
|
|
(settings.m_channels != m_settings.m_channels)) |
|
|
|
|
(settings.m_channels != m_settings.m_channels) || |
|
|
|
|
(settings.m_transparencyThreshold != m_settings.m_transparencyThreshold) || |
|
|
|
|
(settings.m_opacityThreshold != m_settings.m_opacityThreshold) || |
|
|
|
|
(settings.m_palettes != m_settings.m_palettes) || |
|
|
|
|
(settings.m_palette != m_settings.m_palette) || |
|
|
|
|
(settings.m_horizontalPixelsPerDegree != m_settings.m_horizontalPixelsPerDegree) || |
|
|
|
|
(settings.m_verticalPixelsPerDegree != m_settings.m_verticalPixelsPerDegree)) |
|
|
|
|
{ |
|
|
|
|
// Call after settings have been applied
|
|
|
|
|
callProcessImage = true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if ((settings.m_satTimeOffset != m_settings.m_satTimeOffset) || |
|
|
|
|
(settings.m_satYaw != m_settings.m_satYaw)) |
|
|
|
|
{ |
|
|
|
|
callRecalcCoords = true; |
|
|
|
|
callProcessImage = true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (!settings.m_decodeEnabled && m_settings.m_decodeEnabled) |
|
|
|
|
{ |
|
|
|
|
// Decode complete - make sure we do a full image update
|
|
|
|
|
// so we aren't left we unprocessed lines
|
|
|
|
|
callProcessImage = true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (settings.m_palettes != m_settings.m_palettes) |
|
|
|
|
{ |
|
|
|
|
// Load colour palettes
|
|
|
|
|
m_palettes.clear(); |
|
|
|
|
for (auto palette : settings.m_palettes) |
|
|
|
|
{ |
|
|
|
|
QImage img; |
|
|
|
|
img.load(palette); |
|
|
|
|
if ((img.width() != 256) || (img.height() != 256)) { |
|
|
|
|
qWarning() << "APT colour palette " << palette << " is not 256x256 pixels - " << img.width() << "x" << img.height(); |
|
|
|
|
} |
|
|
|
|
m_palettes.append(img); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
m_settings = settings; |
|
|
|
|
|
|
|
|
|
if (callRecalcCoords) { |
|
|
|
|
recalcCoords(); |
|
|
|
|
} |
|
|
|
|
if (callProcessImage) { |
|
|
|
|
sendImageToGUI(); |
|
|
|
|
} |
|
|
|
|
@ -153,25 +203,234 @@ void APTDemodImageWorker::applySettings(const APTDemodSettings& settings, bool f
@@ -153,25 +203,234 @@ void APTDemodImageWorker::applySettings(const APTDemodSettings& settings, bool f
|
|
|
|
|
void APTDemodImageWorker::resetDecoder() |
|
|
|
|
{ |
|
|
|
|
m_image.nrow = 0; |
|
|
|
|
m_image.zenith = 0; |
|
|
|
|
m_tempImage.nrow = 0; |
|
|
|
|
m_tempImage.zenith = 0; |
|
|
|
|
m_greyImage = QImage(APT_IMG_WIDTH, APT_MAX_HEIGHT, QImage::Format_Grayscale8); |
|
|
|
|
m_greyImage.fill(0); |
|
|
|
|
m_colourImage = QImage(APT_IMG_WIDTH, APT_MAX_HEIGHT, QImage::Format_RGB888); |
|
|
|
|
m_colourImage.fill(0); |
|
|
|
|
m_satelliteName = ""; |
|
|
|
|
m_satCoords.clear(); |
|
|
|
|
m_pixelCoords.clear(); |
|
|
|
|
delete m_sgp4; |
|
|
|
|
m_sgp4 = nullptr; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::processPixels(const float *pixels) |
|
|
|
|
// Convert Qt QDataTime to QGP4 DateTime
|
|
|
|
|
static DateTime qDateTimeToDateTime(QDateTime qdt) |
|
|
|
|
{ |
|
|
|
|
QDateTime utc = qdt.toUTC(); |
|
|
|
|
QDate date = utc.date(); |
|
|
|
|
QTime time = utc.time(); |
|
|
|
|
DateTime dt; |
|
|
|
|
dt.Initialise(date.year(), date.month(), date.day(), time.hour(), time.minute(), time.second(), time.msec() * 1000); |
|
|
|
|
return dt; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Get heading in range [0,360)
|
|
|
|
|
static double normaliseHeading(double heading) |
|
|
|
|
{ |
|
|
|
|
std::copy(pixels, pixels + APT_PROW_WIDTH, m_image.prow[m_image.nrow]); |
|
|
|
|
return fmod(heading + 360.0, 360.0); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (m_image.nrow % 20 == 0) { // send full image only every 20 lines
|
|
|
|
|
sendImageToGUI(); |
|
|
|
|
} else { // else send unprocessed line just to show stg is moving
|
|
|
|
|
sendLineToGUI(); |
|
|
|
|
// Get longitude in range -180,180
|
|
|
|
|
static double normaliseLongitude(double lon) |
|
|
|
|
{ |
|
|
|
|
return fmod(lon + 540.0, 360.0) - 180.0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Calculate heading (azimuth) in degrees
|
|
|
|
|
double APTDemodImageWorker::calcHeading(CoordGeodetic from, CoordGeodetic to) const |
|
|
|
|
{ |
|
|
|
|
// From https://en.wikipedia.org/wiki/Azimuth Section In Geodesy
|
|
|
|
|
double flattening = 1.0 / 298.257223563; // For WGS84 ellipsoid
|
|
|
|
|
double eSq = flattening * (2.0 - flattening); |
|
|
|
|
double oneMinusESq = (1.0 - flattening) * (1.0 - flattening); |
|
|
|
|
|
|
|
|
|
double tl1 = tan(from.latitude); |
|
|
|
|
double tl2 = tan(to.latitude); |
|
|
|
|
double n1 = 1.0 + oneMinusESq * tl2 * tl2; |
|
|
|
|
double d1 = 1.0 + oneMinusESq * tl1 * tl1; |
|
|
|
|
|
|
|
|
|
double l = to.longitude - from.longitude; |
|
|
|
|
|
|
|
|
|
double alpha; |
|
|
|
|
|
|
|
|
|
if (from.latitude == 0.0) |
|
|
|
|
{ |
|
|
|
|
alpha = atan2(sin(l), (oneMinusESq * tan(to.latitude))); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
double lambda = oneMinusESq * tan(to.latitude) / tan(from.latitude) + eSq * sqrt(n1/d1); |
|
|
|
|
|
|
|
|
|
alpha = atan2(sin(l), ((lambda - cos(l)) * sin(from.latitude))); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
double deg = Units::radiansToDegrees(alpha); |
|
|
|
|
if (!m_settings.m_northToSouth) { |
|
|
|
|
deg += 180.0; |
|
|
|
|
} |
|
|
|
|
deg = normaliseHeading(deg); |
|
|
|
|
return deg; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// CoordGeodetic are in radians. Distance in metres. Bearing in radians.
|
|
|
|
|
// https://www.movable-type.co.uk/scripts/latlong.html
|
|
|
|
|
// This approximates Earth as spherical. If we need more accurate algorithm, see:
|
|
|
|
|
// https://www.movable-type.co.uk/scripts/latlong-vincenty.html
|
|
|
|
|
static void calcRadialEndPoint(CoordGeodetic start, double distance, double bearing, CoordGeodetic &end) |
|
|
|
|
{ |
|
|
|
|
double earthRadius = 6378137.0; // At equator
|
|
|
|
|
double delta = distance/earthRadius; |
|
|
|
|
end.latitude = std::asin(sin(start.latitude)*cos(delta) + cos(start.latitude)*sin(delta)*cos(bearing)); |
|
|
|
|
end.longitude = start.longitude + std::atan2(sin(bearing)*sin(delta)*cos(start.latitude), cos(delta) - sin(start.latitude)*sin(end.latitude)); |
|
|
|
|
end.longitude = normaliseLongitude(end.longitude); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::calcPixelCoords(CoordGeodetic centreCoord, double heading) |
|
|
|
|
{ |
|
|
|
|
// Calculate coordinates of each pixel in a row (swath)
|
|
|
|
|
// Assume satellite is at centre pixel, and project +-90 degrees from satellite heading
|
|
|
|
|
// https://www.ncei.noaa.gov/pub/data/satellite/publications/podguides/N-15%20thru%20N-19/pdf/APPENDIX%20J%20Instrument%20Scan%20Properties.pdf
|
|
|
|
|
// Swath for AVHRR/3 of 2926.6km at 833km altitude over spherical Earth
|
|
|
|
|
// Some docs say resolution is 4.0km, but it varies as per fig 4.2.3-1 in:
|
|
|
|
|
// https://www.ncei.noaa.gov/pub/data/satellite/publications/podguides/N-15%20thru%20N-19/pdf/2.1%20Section%204.0%20Real%20Time%20Data%20Systems%20for%20Local%20Users%20.pdf
|
|
|
|
|
// TODO: Could try to adjust for altitude
|
|
|
|
|
|
|
|
|
|
QVector<CoordGeodetic> pixelCoords(APT_CH_WIDTH); |
|
|
|
|
pixelCoords[APT_CH_WIDTH/2] = centreCoord; |
|
|
|
|
double heading1 = Units::degreesToRadians(heading + m_settings.m_satYaw + 90.0); |
|
|
|
|
double heading2 = Units::degreesToRadians(heading + m_settings.m_satYaw - 90.0); |
|
|
|
|
for (int i = 1; i <= APT_CH_WIDTH/2; i++) |
|
|
|
|
{ |
|
|
|
|
double distance = i * 2926600.0/APT_CH_WIDTH; |
|
|
|
|
calcRadialEndPoint(centreCoord, distance, heading1, pixelCoords[APT_CH_WIDTH/2-i]); |
|
|
|
|
calcRadialEndPoint(centreCoord, distance, heading2, pixelCoords[APT_CH_WIDTH/2+i]); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
m_image.nrow++; |
|
|
|
|
if (m_settings.m_northToSouth) { |
|
|
|
|
m_pixelCoords.append(pixelCoords); |
|
|
|
|
} else { |
|
|
|
|
m_pixelCoords.prepend(pixelCoords); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Recalculate all pixel coordiantes as satTimeOffset or satYaw has changed
|
|
|
|
|
void APTDemodImageWorker::recalcCoords() |
|
|
|
|
{ |
|
|
|
|
if (m_sgp4) |
|
|
|
|
{ |
|
|
|
|
m_satCoords.clear(); |
|
|
|
|
m_pixelCoords.clear(); |
|
|
|
|
for (int row = 0; row < m_image.nrow; row++) |
|
|
|
|
{ |
|
|
|
|
QDateTime qdt = m_settings.m_aosDateTime.addMSecs(m_settings.m_satTimeOffset * 1000.0f + row * 500); |
|
|
|
|
calcCoords(qdt, row); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Calculate pixel coordinates for a single row at the given date and time
|
|
|
|
|
void APTDemodImageWorker::calcCoords(QDateTime qdt, int row) |
|
|
|
|
{ |
|
|
|
|
try |
|
|
|
|
{ |
|
|
|
|
DateTime dt = qDateTimeToDateTime(qdt); |
|
|
|
|
|
|
|
|
|
// Calculate satellite position
|
|
|
|
|
Eci eci = m_sgp4->FindPosition(dt); |
|
|
|
|
|
|
|
|
|
// Convert satellite position to geodetic coordinates (lat and long)
|
|
|
|
|
CoordGeodetic geo = eci.ToGeodetic(); |
|
|
|
|
|
|
|
|
|
m_satCoords.append(geo); |
|
|
|
|
|
|
|
|
|
// Calculate satellite heading (Could convert eci.Velocity() instead)
|
|
|
|
|
double heading; |
|
|
|
|
if (m_satCoords.size() == 2) |
|
|
|
|
{ |
|
|
|
|
heading = calcHeading(m_satCoords[0], m_satCoords[1]); |
|
|
|
|
calcPixelCoords(m_satCoords[0], heading); |
|
|
|
|
calcPixelCoords(m_satCoords[1], heading); |
|
|
|
|
} |
|
|
|
|
else if (m_satCoords.size() > 2) |
|
|
|
|
{ |
|
|
|
|
heading = calcHeading(m_satCoords[row-1], m_satCoords[row]); |
|
|
|
|
calcPixelCoords(geo, heading); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
catch (SatelliteException& se) |
|
|
|
|
{ |
|
|
|
|
qDebug() << "APTDemodImageWorker::calcCoord: " << se.what(); |
|
|
|
|
} |
|
|
|
|
catch (DecayedException& de) |
|
|
|
|
{ |
|
|
|
|
qDebug() << "APTDemodImageWorker::calcCoord: " << de.what(); |
|
|
|
|
} |
|
|
|
|
catch (TleException& tlee) |
|
|
|
|
{ |
|
|
|
|
qDebug() << "APTDemodImageWorker::calcCoord: " << tlee.what(); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Calculate satellite's geodetic coordinates and heading
|
|
|
|
|
void APTDemodImageWorker::calcCoord(int row) |
|
|
|
|
{ |
|
|
|
|
if (row == 0) |
|
|
|
|
{ |
|
|
|
|
QStringList tle = m_settings.m_tle.trimmed().split("\n"); |
|
|
|
|
if (tle.size() == 3) |
|
|
|
|
{ |
|
|
|
|
// Initalise SGP4
|
|
|
|
|
Tle tle(tle[0].toStdString(), tle[1].toStdString(), tle[2].toStdString()); |
|
|
|
|
m_sgp4 = new SGP4(tle); |
|
|
|
|
|
|
|
|
|
// Output time so we can check time offset from when AOS is signalled
|
|
|
|
|
qDebug() << "APTDemod: Processing row 0 at " << QDateTime::currentDateTime(); |
|
|
|
|
|
|
|
|
|
calcCoords(m_settings.m_aosDateTime, row); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
qDebug() << "APTDemodImageWorker::calcCoord: No TLE for satellite. Is Satellite Tracker running?"; |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else if (m_sgp4 == nullptr) |
|
|
|
|
{ |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
// Calculate time at which
|
|
|
|
|
// Don't try to use QDateTime::currentDateTime() as processing & scheduling delays mean
|
|
|
|
|
// it's not constant and can sometimes even be 0
|
|
|
|
|
// Lines should be transmitted at 2 per second, so just use number of rows since AOS
|
|
|
|
|
// We add a user-defined delay to account for delays in transferring SDR data and demodulation
|
|
|
|
|
QDateTime qdt = m_settings.m_aosDateTime.addMSecs(m_settings.m_satTimeOffset * 1000.0f + row * 500); |
|
|
|
|
calcCoords(qdt, row); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::processPixels(const float *pixels) |
|
|
|
|
{ |
|
|
|
|
if (m_image.nrow < APT_MAX_HEIGHT) |
|
|
|
|
{ |
|
|
|
|
// Calculate lat and lon of centre of row
|
|
|
|
|
calcCoord(m_image.nrow); |
|
|
|
|
|
|
|
|
|
std::copy(pixels, pixels + APT_PROW_WIDTH, m_image.prow[m_image.nrow]); |
|
|
|
|
m_image.nrow++; |
|
|
|
|
|
|
|
|
|
if (m_image.nrow % m_settings.m_scanlinesPerImageUpdate == 0) { // send full image only every N lines
|
|
|
|
|
sendImageToGUI(); |
|
|
|
|
} else { // else send unprocessed line just to show stg is moving
|
|
|
|
|
sendLineToGUI(); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::sendImageToGUI() |
|
|
|
|
@ -180,8 +439,278 @@ void APTDemodImageWorker::sendImageToGUI()
@@ -180,8 +439,278 @@ void APTDemodImageWorker::sendImageToGUI()
|
|
|
|
|
if (m_messageQueueToGUI) |
|
|
|
|
{ |
|
|
|
|
QStringList imageTypes; |
|
|
|
|
QImage image = processImage(imageTypes); |
|
|
|
|
QImage image = processImage(imageTypes, m_settings.m_channels); |
|
|
|
|
m_messageQueueToGUI->push(APTDemod::MsgImage::create(image, imageTypes, m_satelliteName)); |
|
|
|
|
if (m_sgp4) { |
|
|
|
|
sendImageToMap(image, imageTypes); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Find the value of the pixel closest to the given coordinates
|
|
|
|
|
// If we have previously found a pixel, we constrain the search to be nearby, in order to speed up the search
|
|
|
|
|
QRgb APTDemodImageWorker::findNearest(const QImage &image, double latitude, double longitude, int xPrevious, int yPrevious, int &xNearest, int &yNearest) const |
|
|
|
|
{ |
|
|
|
|
double dmin = 360.0 * 360.0 + 90.0 * 90.0; |
|
|
|
|
xNearest = -1; |
|
|
|
|
yNearest = -1; |
|
|
|
|
QRgb p = qRgba(0, 0, 0, 0); // Transparent
|
|
|
|
|
|
|
|
|
|
int xMin, xMax; |
|
|
|
|
int yMin, yMax; |
|
|
|
|
|
|
|
|
|
int yStartPostCrop; |
|
|
|
|
int yEndPostCrop; |
|
|
|
|
if (m_settings.m_northToSouth) |
|
|
|
|
{ |
|
|
|
|
yStartPostCrop = abs(m_tempImage.zenith); |
|
|
|
|
yEndPostCrop = yStartPostCrop + image.height(); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
yStartPostCrop = m_image.nrow - m_tempImage.nrow - abs(m_tempImage.zenith); |
|
|
|
|
yEndPostCrop = yStartPostCrop + image.height(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (xPrevious == -1) |
|
|
|
|
{ |
|
|
|
|
yMin = yStartPostCrop; |
|
|
|
|
yMax = yEndPostCrop; |
|
|
|
|
xMin = 0; |
|
|
|
|
xMax = m_pixelCoords[0].size(); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
int searchRadius = 4; |
|
|
|
|
yMin = yPrevious - searchRadius; |
|
|
|
|
yMax = yPrevious + searchRadius + 1; |
|
|
|
|
xMin = xPrevious - searchRadius; |
|
|
|
|
xMax = xPrevious + searchRadius + 1; |
|
|
|
|
yMin = std::max(yMin, yStartPostCrop); |
|
|
|
|
yMax = std::min(yMax, yEndPostCrop); |
|
|
|
|
xMin = std::max(xMin, 0); |
|
|
|
|
xMax = std::min(xMax, m_pixelCoords[0].size()); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
const int ySize = yEndPostCrop-1; |
|
|
|
|
const int xSize = m_pixelCoords[0].size()-1; |
|
|
|
|
for (int y = yMin; y < yMax; y++) |
|
|
|
|
{ |
|
|
|
|
for (int x = xMin; x < xMax; x++) |
|
|
|
|
{ |
|
|
|
|
CoordGeodetic coord = m_pixelCoords[y][x]; |
|
|
|
|
double dlat = coord.latitude - latitude; |
|
|
|
|
double dlon = coord.longitude - longitude; |
|
|
|
|
double d = dlat * dlat + dlon * dlon; |
|
|
|
|
if (d < dmin) |
|
|
|
|
{ |
|
|
|
|
dmin = d; |
|
|
|
|
xNearest = x; |
|
|
|
|
yNearest = y; |
|
|
|
|
// Only use color of pixel if we're inside the source image
|
|
|
|
|
if ( ((y != yStartPostCrop) || ((y == yStartPostCrop) && (latitude <= coord.latitude))) |
|
|
|
|
&& ((y != ySize) || ((y == ySize) && (latitude >= coord.latitude))) |
|
|
|
|
&& ((x != 0) || ((x == 0) && (longitude >= coord.longitude))) |
|
|
|
|
&& ((x != xSize) || ((x == xSize) && (longitude <= coord.longitude))) |
|
|
|
|
) |
|
|
|
|
{ |
|
|
|
|
p = image.pixel(x, y - yStartPostCrop); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
p = qRgba(0, 0, 0, 0); // Transparent
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return p; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Calculate bounding box for projected image in terms of latitude and longitude
|
|
|
|
|
// TODO: Handle crossing of anti-meridian
|
|
|
|
|
void APTDemodImageWorker::calcBoundingBox(double &east, double &south, double &west, double &north, const QImage &image) |
|
|
|
|
{ |
|
|
|
|
int start; |
|
|
|
|
if (m_settings.m_northToSouth) { |
|
|
|
|
start = abs(m_tempImage.zenith); |
|
|
|
|
} else { |
|
|
|
|
start = m_image.nrow - m_tempImage.nrow - abs(m_tempImage.zenith); |
|
|
|
|
} |
|
|
|
|
int stop = start + image.height(); |
|
|
|
|
|
|
|
|
|
east = -M_PI; |
|
|
|
|
west = M_PI; |
|
|
|
|
north = -M_PI/2.0; |
|
|
|
|
south = M_PI/2.0; |
|
|
|
|
|
|
|
|
|
//FILE *f = fopen("coords.txt", "w");
|
|
|
|
|
for (int y = start; y < stop; y++) |
|
|
|
|
{ |
|
|
|
|
for (int x = 0; x < m_pixelCoords[y].size(); x++) |
|
|
|
|
{ |
|
|
|
|
double latitude = m_pixelCoords[y][x].latitude; |
|
|
|
|
double longitude = m_pixelCoords[y][x].longitude; |
|
|
|
|
//fprintf(f, "%f,%f ", Units::radiansToDegrees(m_pixelCoords[y][x].latitude), Units::radiansToDegrees(m_pixelCoords[y][x].longitude));
|
|
|
|
|
south = std::min(latitude, south); |
|
|
|
|
north = std::max(latitude, north); |
|
|
|
|
east = std::max(longitude, east); |
|
|
|
|
west = std::min(longitude, west); |
|
|
|
|
} |
|
|
|
|
//fprintf(f, "\n");
|
|
|
|
|
} |
|
|
|
|
//fclose(f);
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Project satellite image to equidistant cyclindrical projection (Plate Carree) for use on 3D Map
|
|
|
|
|
// We've previously computed lat and lon for each pixel in satellite image
|
|
|
|
|
// so we just work through coords in projected image, trying to find closest pixel in satellite image
|
|
|
|
|
// FIXME: How do we handle sat going over the poles?
|
|
|
|
|
QImage APTDemodImageWorker::projectImage(const QImage &image) |
|
|
|
|
{ |
|
|
|
|
double east, south, west, north; |
|
|
|
|
|
|
|
|
|
// Calculate bounding box for image tile
|
|
|
|
|
calcBoundingBox(east, south, west, north, image); |
|
|
|
|
m_tileEast = ceil(Units::radiansToDegrees(east)); |
|
|
|
|
m_tileWest = floor(Units::radiansToDegrees(west)); |
|
|
|
|
m_tileNorth = ceil(Units::radiansToDegrees(north)); |
|
|
|
|
m_tileSouth = floor(Units::radiansToDegrees(south)); |
|
|
|
|
|
|
|
|
|
double widthDeg = m_tileEast - m_tileWest; |
|
|
|
|
double heightDeg = m_tileNorth - m_tileSouth; |
|
|
|
|
|
|
|
|
|
int width = widthDeg * m_settings.m_horizontalPixelsPerDegree; |
|
|
|
|
int height = heightDeg * m_settings.m_verticalPixelsPerDegree; |
|
|
|
|
|
|
|
|
|
//image.save("source.png");
|
|
|
|
|
//FILE *f = fopen("mapping.txt", "w");
|
|
|
|
|
QImage projection(width, height, QImage::Format_ARGB32); |
|
|
|
|
int xNearest, yNearest, xPrevious, yPrevious; |
|
|
|
|
xPrevious = -1; |
|
|
|
|
yPrevious = -1; |
|
|
|
|
for (int y = 0; y < height; y++) |
|
|
|
|
{ |
|
|
|
|
// Calculate geodetic coords of pixel in projected image
|
|
|
|
|
double lat = m_tileNorth - (y / (double)m_settings.m_verticalPixelsPerDegree); |
|
|
|
|
// Reverse search direction in alternate rows, so we are always seaching
|
|
|
|
|
// close to previously found pixel
|
|
|
|
|
if ((y & 1) == 0) |
|
|
|
|
{ |
|
|
|
|
for (int x = 0; x < width; x++) |
|
|
|
|
{ |
|
|
|
|
double lon = m_tileWest + (x / (double)m_settings.m_horizontalPixelsPerDegree); |
|
|
|
|
// Find closest pixel in source image
|
|
|
|
|
QRgb pixel = findNearest(image, Units::degreesToRadians(lat), Units::degreesToRadians(lon), xPrevious, yPrevious, xNearest, yNearest); |
|
|
|
|
xPrevious = xNearest; |
|
|
|
|
yPrevious = yNearest; |
|
|
|
|
projection.setPixel(x, y, pixel); |
|
|
|
|
//fprintf(f, "%f,%f,%d,%d,%d ", lat, lon, xNearest, yNearest, pixel==0);
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
for (int x = width - 1; x >= 0; x--) |
|
|
|
|
{ |
|
|
|
|
double lon = m_tileWest + (x / (double)m_settings.m_horizontalPixelsPerDegree); |
|
|
|
|
// Find closest pixel in source image
|
|
|
|
|
QRgb pixel = findNearest(image, Units::degreesToRadians(lat), Units::degreesToRadians(lon), xPrevious, yPrevious, xNearest, yNearest); |
|
|
|
|
xPrevious = xNearest; |
|
|
|
|
yPrevious = yNearest; |
|
|
|
|
projection.setPixel(x, y, pixel); |
|
|
|
|
//fprintf(f, "%f,%f,%d,%d,%d ", lat, lon, xNearest, yNearest, pixel==0);
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
//fprintf(f, "\n");
|
|
|
|
|
} |
|
|
|
|
//fclose(f);
|
|
|
|
|
|
|
|
|
|
return projection; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Make an image transparent, so when overlaid on 3D map, we can see the underlying terrain
|
|
|
|
|
// Image is full transparent below m_transparencyThreshold and fully opaque above m_opacityThreshold
|
|
|
|
|
void APTDemodImageWorker::makeTransparent(QImage &image) |
|
|
|
|
{ |
|
|
|
|
for (int y = 0; y < image.height(); y++) |
|
|
|
|
{ |
|
|
|
|
for (int x = 0; x < image.width(); x++) |
|
|
|
|
{ |
|
|
|
|
QRgb pixel = image.pixel(x, y); |
|
|
|
|
int grey = qGray(pixel); |
|
|
|
|
if (grey < m_settings.m_transparencyThreshold) |
|
|
|
|
{ |
|
|
|
|
// Make fully transparent
|
|
|
|
|
pixel = qRgba(qRed(pixel), qGreen(pixel), qBlue(pixel), 0); |
|
|
|
|
image.setPixel(x, y, pixel); |
|
|
|
|
} |
|
|
|
|
else if (grey < m_settings.m_opacityThreshold) |
|
|
|
|
{ |
|
|
|
|
// Make slightly transparent
|
|
|
|
|
float opacity = 1.0f - ((m_settings.m_opacityThreshold - grey) / (float)(m_settings.m_opacityThreshold - m_settings.m_transparencyThreshold)); |
|
|
|
|
opacity = opacity * 255.0f; |
|
|
|
|
opacity = std::min(255.0f, opacity); |
|
|
|
|
opacity = std::max(0.0f, opacity); |
|
|
|
|
pixel = qRgba(qRed(pixel), qGreen(pixel), qBlue(pixel), (int)std::round(opacity)); |
|
|
|
|
image.setPixel(x, y, pixel); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::sendImageToMap(QImage image, QStringList imageTypes) |
|
|
|
|
{ |
|
|
|
|
// Send to Map feature
|
|
|
|
|
MessagePipes& messagePipes = MainCore::instance()->getMessagePipes(); |
|
|
|
|
QList<MessageQueue*> *mapMessageQueues = messagePipes.getMessageQueues(m_aptDemod, "mapitems"); |
|
|
|
|
if (mapMessageQueues) |
|
|
|
|
{ |
|
|
|
|
// Only display one channel on map
|
|
|
|
|
QImage selectedChannel; |
|
|
|
|
if (m_settings.m_channels == APTDemodSettings::BOTH_CHANNELS) { |
|
|
|
|
selectedChannel = extractImage(image, APTDemodSettings::CHANNEL_B); |
|
|
|
|
} else { |
|
|
|
|
selectedChannel = image; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Project image to geodetic coords (lat & lon)
|
|
|
|
|
selectedChannel = projectImage(selectedChannel); |
|
|
|
|
//selectedChannel.save("projected.png");
|
|
|
|
|
|
|
|
|
|
// Use alpha channel to remove land & sea
|
|
|
|
|
makeTransparent(selectedChannel); |
|
|
|
|
|
|
|
|
|
// Encode image as base64 PNG
|
|
|
|
|
QByteArray ba; |
|
|
|
|
QBuffer buffer(&ba); |
|
|
|
|
buffer.open(QIODevice::WriteOnly); |
|
|
|
|
selectedChannel.save(&buffer, "PNG"); |
|
|
|
|
QByteArray data = ba.toBase64(); |
|
|
|
|
|
|
|
|
|
// Create name for the image
|
|
|
|
|
QString satName = m_satelliteName; |
|
|
|
|
satName.replace(" ", "_"); |
|
|
|
|
QString name = QString("apt_%1_%2").arg(satName).arg(m_settings.m_aosDateTime.toString("yyyyMMdd_hhmmss")); |
|
|
|
|
|
|
|
|
|
// Send name to GUI
|
|
|
|
|
m_messageQueueToGUI->push(APTDemod::MsgMapImageName::create(name)); |
|
|
|
|
|
|
|
|
|
QList<MessageQueue*>::iterator it = mapMessageQueues->begin(); |
|
|
|
|
for (; it != mapMessageQueues->end(); ++it) |
|
|
|
|
{ |
|
|
|
|
SWGSDRangel::SWGMapItem *swgMapItem = new SWGSDRangel::SWGMapItem(); |
|
|
|
|
swgMapItem->setName(new QString(name)); |
|
|
|
|
swgMapItem->setImage(new QString(data)); |
|
|
|
|
swgMapItem->setAltitude(3000.0); // Typical cloud height - So it appears above objects on the ground
|
|
|
|
|
swgMapItem->setType(1); |
|
|
|
|
swgMapItem->setImageTileEast(m_tileEast); |
|
|
|
|
swgMapItem->setImageTileWest(m_tileWest); |
|
|
|
|
swgMapItem->setImageTileNorth(m_tileNorth); |
|
|
|
|
swgMapItem->setImageTileSouth(m_tileSouth); |
|
|
|
|
|
|
|
|
|
MainCore::MsgMapItem *msg = MainCore::MsgMapItem::create(m_aptDemod, swgMapItem); |
|
|
|
|
(*it)->push(msg); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -189,7 +718,7 @@ void APTDemodImageWorker::sendLineToGUI()
@@ -189,7 +718,7 @@ void APTDemodImageWorker::sendLineToGUI()
|
|
|
|
|
{ |
|
|
|
|
if (m_messageQueueToGUI) |
|
|
|
|
{ |
|
|
|
|
float *pixels = m_image.prow[m_image.nrow]; |
|
|
|
|
float *pixels = m_image.prow[m_image.nrow-1]; |
|
|
|
|
uchar *line; |
|
|
|
|
APTDemod::MsgLine *msg = APTDemod::MsgLine::create(&line); |
|
|
|
|
|
|
|
|
|
@ -219,12 +748,12 @@ void APTDemodImageWorker::sendLineToGUI()
@@ -219,12 +748,12 @@ void APTDemodImageWorker::sendLineToGUI()
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
QImage APTDemodImageWorker::processImage(QStringList& imageTypes) |
|
|
|
|
QImage APTDemodImageWorker::processImage(QStringList& imageTypes, APTDemodSettings::ChannelSelection channels) |
|
|
|
|
{ |
|
|
|
|
copyImage(&m_tempImage, &m_image); |
|
|
|
|
|
|
|
|
|
// Calibrate channels according to wavelength
|
|
|
|
|
if (m_tempImage.nrow >= APT_CALIBRATION_ROWS) |
|
|
|
|
// Calibrate channels according to wavelength (1.7x to stop flickering)
|
|
|
|
|
if (m_tempImage.nrow >= 1.7 * APT_CALIBRATION_ROWS) |
|
|
|
|
{ |
|
|
|
|
m_tempImage.chA = apt_calibrate(m_tempImage.prow, m_tempImage.nrow, APT_CHA_OFFSET, APT_CH_WIDTH); |
|
|
|
|
m_tempImage.chB = apt_calibrate(m_tempImage.prow, m_tempImage.nrow, APT_CHB_OFFSET, APT_CH_WIDTH); |
|
|
|
|
@ -233,9 +762,9 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
@@ -233,9 +762,9 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
|
|
|
|
|
"Visible (0.58-0.68 um)", |
|
|
|
|
"Near-IR (0.725-1.0 um)", |
|
|
|
|
"Near-IR (1.58-1.64 um)", |
|
|
|
|
"Mid-infrared (3.55-3.93 um)", |
|
|
|
|
"Thermal-infrared (10.3-11.3 um)", |
|
|
|
|
"Thermal-infrared (11.5-12.5 um)" |
|
|
|
|
"Thermal-infrared (11.5-12.5 um)", |
|
|
|
|
"Mid-infrared (3.55-3.93 um)" |
|
|
|
|
}); |
|
|
|
|
|
|
|
|
|
imageTypes.append(channelTypes[m_tempImage.chA]); |
|
|
|
|
@ -243,8 +772,9 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
@@ -243,8 +772,9 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Crop noise due to low elevation at top and bottom of image
|
|
|
|
|
if (m_settings.m_cropNoise) |
|
|
|
|
if (m_settings.m_cropNoise) { |
|
|
|
|
m_tempImage.zenith -= apt_cropNoise(&m_tempImage); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Denoise filter
|
|
|
|
|
if (m_settings.m_denoise) |
|
|
|
|
@ -305,10 +835,65 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
@@ -305,10 +835,65 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
|
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return extractImage(m_colourImage); |
|
|
|
|
return extractImage(m_colourImage, channels); |
|
|
|
|
} |
|
|
|
|
else if (channels == APTDemodSettings::TEMPERATURE) |
|
|
|
|
{ |
|
|
|
|
// Temperature calibration
|
|
|
|
|
int satnum = 15; |
|
|
|
|
if (m_satelliteName == "NOAA 18") { |
|
|
|
|
satnum = 18; |
|
|
|
|
} else if (m_satelliteName == "NOAA 19") { |
|
|
|
|
satnum = 19; |
|
|
|
|
} |
|
|
|
|
apt_temperature(satnum, &m_tempImage, APT_CHB_OFFSET, APT_CH_WIDTH); |
|
|
|
|
|
|
|
|
|
// Apply colour palette
|
|
|
|
|
for (int r = 0; r < m_tempImage.nrow; r++) |
|
|
|
|
{ |
|
|
|
|
uchar *l = m_colourImage.scanLine(r); |
|
|
|
|
for (int i = 0; i < APT_CH_WIDTH; i++) |
|
|
|
|
{ |
|
|
|
|
float p = m_tempImage.prow[r][i+APT_CHB_OFFSET]; |
|
|
|
|
uchar q = roundAndClip(p); |
|
|
|
|
l[i*3] = apt_TempPalette[q*3]; |
|
|
|
|
l[i*3+1] = apt_TempPalette[q*3+1]; |
|
|
|
|
l[i*3+2] = apt_TempPalette[q*3+2]; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return m_colourImage.copy(0, 0, APT_CH_WIDTH, m_tempImage.nrow); |
|
|
|
|
} |
|
|
|
|
else if (channels == APTDemodSettings::PALETTE) |
|
|
|
|
{ |
|
|
|
|
if ((m_settings.m_palette >= 0) && (m_settings.m_palette < m_palettes.size())) |
|
|
|
|
{ |
|
|
|
|
// Apply colour palette
|
|
|
|
|
for (int r = 0; r < m_tempImage.nrow; r++) |
|
|
|
|
{ |
|
|
|
|
uchar *l = m_colourImage.scanLine(r); |
|
|
|
|
for (int i = 0; i < APT_CH_WIDTH; i++) |
|
|
|
|
{ |
|
|
|
|
float pA = m_tempImage.prow[r][i+APT_CHA_OFFSET]; |
|
|
|
|
float pB = m_tempImage.prow[r][i+APT_CHB_OFFSET]; |
|
|
|
|
uchar qA = roundAndClip(pA); |
|
|
|
|
uchar qB = roundAndClip(pB); |
|
|
|
|
QRgb rgb = m_palettes[m_settings.m_palette].pixel(qA, qB); |
|
|
|
|
l[i*3] = qRed(rgb); |
|
|
|
|
l[i*3+1] = qGreen(rgb); |
|
|
|
|
l[i*3+2] = qBlue(rgb); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return m_colourImage.copy(0, 0, APT_CH_WIDTH, m_tempImage.nrow); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
qDebug() << "APTDemodImageWorker::processImage - Illegal palette number: " << m_settings.m_palette; |
|
|
|
|
return QImage(); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
// Extract grey-scale image
|
|
|
|
|
for (int r = 0; r < m_tempImage.nrow; r++) |
|
|
|
|
{ |
|
|
|
|
uchar *l = m_greyImage.scanLine(r); |
|
|
|
|
@ -319,43 +904,92 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
@@ -319,43 +904,92 @@ QImage APTDemodImageWorker::processImage(QStringList& imageTypes)
|
|
|
|
|
l[i] = roundAndClip(p); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
return extractImage(m_greyImage); |
|
|
|
|
return extractImage(m_greyImage, channels); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
QImage APTDemodImageWorker::extractImage(QImage image) |
|
|
|
|
QImage APTDemodImageWorker::extractImage(QImage image, APTDemodSettings::ChannelSelection channels) |
|
|
|
|
{ |
|
|
|
|
if (m_settings.m_channels == APTDemodSettings::BOTH_CHANNELS) { |
|
|
|
|
if (channels == APTDemodSettings::BOTH_CHANNELS) { |
|
|
|
|
return image.copy(0, 0, APT_IMG_WIDTH, m_tempImage.nrow); |
|
|
|
|
} else if (m_settings.m_channels == APTDemodSettings::CHANNEL_A) { |
|
|
|
|
} else if (channels == APTDemodSettings::CHANNEL_A) { |
|
|
|
|
return image.copy(APT_CHA_OFFSET, 0, APT_CH_WIDTH, m_tempImage.nrow); |
|
|
|
|
} else { |
|
|
|
|
return image.copy(APT_CHB_OFFSET, 0, APT_CH_WIDTH, m_tempImage.nrow); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::prependPath(QString &filename) |
|
|
|
|
{ |
|
|
|
|
if (!m_settings.m_autoSavePath.isEmpty()) |
|
|
|
|
{ |
|
|
|
|
if (m_settings.m_autoSavePath.endsWith('/')) { |
|
|
|
|
filename = m_settings.m_autoSavePath + filename; |
|
|
|
|
} else { |
|
|
|
|
filename = m_settings.m_autoSavePath + '/' + filename; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void APTDemodImageWorker::saveImageToDisk() |
|
|
|
|
{ |
|
|
|
|
QStringList imageTypes; |
|
|
|
|
QImage image = processImage(imageTypes); |
|
|
|
|
QImage image = processImage(imageTypes, APTDemodSettings::BOTH_CHANNELS); |
|
|
|
|
|
|
|
|
|
if (image.height() >= m_settings.m_autoSaveMinScanLines) |
|
|
|
|
{ |
|
|
|
|
QString filename; |
|
|
|
|
QDateTime datetime = QDateTime::currentDateTime(); |
|
|
|
|
filename = QString("apt_%1_%2.png").arg(m_satelliteName.replace(" ", "_")).arg(datetime.toString("yyyyMMdd_hhmm")); |
|
|
|
|
QDateTime dateTime; |
|
|
|
|
QString dt; |
|
|
|
|
if (m_settings.m_aosDateTime.isValid()) { |
|
|
|
|
dateTime = m_settings.m_aosDateTime; |
|
|
|
|
} else { |
|
|
|
|
dateTime = QDateTime::currentDateTime(); |
|
|
|
|
} |
|
|
|
|
dt = dateTime.toString("yyyyMMdd_hhmm"); |
|
|
|
|
QString sat = m_satelliteName; |
|
|
|
|
sat.replace(" ", "_"); |
|
|
|
|
|
|
|
|
|
if (!m_settings.m_autoSavePath.isEmpty()) |
|
|
|
|
if (m_settings.m_saveCombined) |
|
|
|
|
{ |
|
|
|
|
if (m_settings.m_autoSavePath.endsWith('/')) { |
|
|
|
|
filename = m_settings.m_autoSavePath + filename; |
|
|
|
|
} else { |
|
|
|
|
filename = m_settings.m_autoSavePath + '/' + filename; |
|
|
|
|
filename = QString("apt_%1_%2.png").arg(sat).arg(dt); |
|
|
|
|
prependPath(filename); |
|
|
|
|
if (!image.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (!image.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
QImage chA = extractImage(image, APTDemodSettings::CHANNEL_A); |
|
|
|
|
QImage chB = extractImage(image, APTDemodSettings::CHANNEL_B); |
|
|
|
|
|
|
|
|
|
if (m_settings.m_saveSeparate) |
|
|
|
|
{ |
|
|
|
|
filename = QString("apt_%1_%2_cha.png").arg(sat).arg(dt); |
|
|
|
|
prependPath(filename); |
|
|
|
|
if (!chA.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
} |
|
|
|
|
filename = QString("apt_%1_%2_chb.png").arg(sat).arg(dt); |
|
|
|
|
prependPath(filename); |
|
|
|
|
if (!chB.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (m_settings.m_saveProjection) |
|
|
|
|
{ |
|
|
|
|
filename = QString("apt_%1_%2_cha_eqi_cylindrical.png").arg(sat).arg(dt); |
|
|
|
|
prependPath(filename); |
|
|
|
|
QImage chAProj = projectImage(chA); |
|
|
|
|
if (!chAProj.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
} |
|
|
|
|
filename = QString("apt_%1_%2_chb_eqi_cylindrical.png").arg(sat).arg(dt); |
|
|
|
|
prependPath(filename); |
|
|
|
|
QImage chBProj = projectImage(chB); |
|
|
|
|
if (!chBProj.save(filename)) { |
|
|
|
|
qCritical() << "Failed to save APT image to: " << filename; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|