///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2016 Edouard Griffiths, F4EXB                                   //
// Copyright (C) 2021-2024 Jon Beniston, M7RCE                                   //
//                                                                               //
// 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 <limits>
#include <numeric>
#include <algorithm>
#include <functional>
#include <ctype.h>
#include <QDockWidget>
#include <QMainWindow>
#include <QDebug>
#include <QMessageBox>
#include <QAction>
#include <QRegularExpression>
#include <QClipboard>
#include <QFileDialog>
#include <QImage>
#include <QTimer>

#include "radioastronomygui.h"

#include "device/deviceuiset.h"
#include "dsp/dspengine.h"
#include "dsp/dspcommands.h"
#include "ui_radioastronomygui.h"
#include "plugin/pluginapi.h"
#include "util/db.h"
#include "util/astronomy.h"
#include "util/interpolation.h"
#include "util/png.h"
#include "util/units.h"
#include "gui/basicchannelsettingsdialog.h"
#include "dsp/dspengine.h"
#include "gui/timedelegate.h"
#include "gui/decimaldelegate.h"
#include "gui/dialogpositioner.h"
#include "channel/channelwebapiutils.h"
#include "maincore.h"
#include "feature/feature.h"
#include "webapi/webapiutils.h"

#include "radioastronomy.h"
#include "radioastronomysensordialog.h"
#include "radioastronomycalibrationdialog.h"

#include "SWGStarTrackerTarget.h"
#include "SWGStarTrackerDisplaySettings.h"
#include "SWGStarTrackerDisplayLoSSettings.h"

// Time value is in milliseconds - Displays hh:mm:ss or d hh:mm:ss
class TimeDeltaDelegate : public QStyledItemDelegate {

public:
    TimeDeltaDelegate(QObject *parent = nullptr) :
        QStyledItemDelegate(parent) {}

    virtual QString displayText(const QVariant &value, const QLocale &locale) const override
    {
        (void) locale;
        qint64 v = value.toLongLong(); // In milliseconds
        bool neg = v < 0;
        v = abs(v);
        qint64 days = v / (1000*60*60*24);
        v = v % (1000*60*60*24);
        qint64 hours = v / (1000*60*60);
        v = v % (1000*60*60);
        qint64 minutes = v / (1000*60);
        v = v % (1000*60);
        qint64 seconds = v / (1000);
        //qint64 msec = v % 1000;

        if (days > 0) {
            return QString("%1%2 %3:%4:%5").arg(neg ? "-" : "").arg(days).arg(hours, 2, 10, QChar('0')).arg(minutes, 2, 10, QChar('0')).arg(seconds, 2, 10, QChar('0'));
        } else {
            return QString("%1%2:%3:%4").arg(neg ? "-" : "").arg(hours, 2, 10, QChar('0')).arg(minutes, 2, 10, QChar('0')).arg(seconds, 2, 10, QChar('0'));
        }
    }

private:
    QString m_format;

};

// Delegate for table to display hours, minutes and seconds
class HMSDelegate : public QStyledItemDelegate {

public:
    HMSDelegate(QObject *parent = nullptr) :
        QStyledItemDelegate(parent) {}

    virtual QString displayText(const QVariant &value, const QLocale &locale) const override
    {
        (void) locale;
        return Units::decimalHoursToHoursMinutesAndSeconds(value.toDouble());
    }

};

// Delegate for table to display degrees, minutes and seconds
class DMSDelegate : public QStyledItemDelegate {

public:
    DMSDelegate(QObject *parent = nullptr) :
        QStyledItemDelegate(parent) {}

    virtual QString displayText(const QVariant &value, const QLocale &locale) const override
    {
        (void) locale;
        return Units::decimalDegreesToDegreeMinutesAndSeconds(value.toDouble());
    }

};

void RadioAstronomyGUI::LABData::read(QFile* file, float l, float b)
{
    m_l = l;
    m_b = b;
    m_vlsr.clear();
    m_temp.clear();
    QTextStream in(file);

    while (!in.atEnd())
    {
        QString line = in.readLine().trimmed();
        if (!line.startsWith("%") && (line.size() > 0))  // Lines starting with % are comments
        {
            // 4 cols: v_lsr [km/s], T_B [K], freq. [Mhz], wavel. [cm]
            line = line.simplified();
            QStringList cols = line.split(" ");
            if (cols.size() == 4)
            {
                m_vlsr.append(cols[0].toFloat());
                m_temp.append(cols[1].toFloat());
            }
            else
            {
                qDebug() << "RadioAstronomyGUI::parseLAB: Unexpected number of columns";
            }
        }
    }
}

void RadioAstronomyGUI::LABData::toSeries(QLineSeries *series)
{
    series->clear();
    series->setName(QString("LAB l=%1 b=%2").arg(m_l).arg(m_b));
    for (int i = 0; i < m_vlsr.size(); i++) {
        series->append(m_vlsr[i], m_temp[i]);
    }
}

void RadioAstronomyGUI::SensorMeasurements::init(const QString& name, bool visible)
{
    m_series = new QLineSeries();
    m_series->setName(name);
    m_series->setVisible(visible);
    m_yAxis = new QValueAxis();
    m_yAxis->setTitleText(name);
    m_yAxis->setVisible(visible);
    m_min = std::numeric_limits<double>::max();
    m_max = -std::numeric_limits<double>::max();
}

void RadioAstronomyGUI::SensorMeasurements::setName(const QString& name)
{
    if (m_series) {
        m_series->setName(name);
    }
    if (m_yAxis) {
       m_yAxis->setTitleText(name);
    }
}

void RadioAstronomyGUI::SensorMeasurements::clicked(bool checked)
{
    if (m_series) {
        m_series->setVisible(checked);
    }
    if (m_yAxis) {
        m_yAxis->setVisible(checked);
    }
}

void RadioAstronomyGUI::SensorMeasurements::append(SensorMeasurement *measurement)
{
    m_measurements.append(measurement);
    addToSeries(measurement);
}

void RadioAstronomyGUI::SensorMeasurements::addToSeries(SensorMeasurement *measurement)
{
    m_series->append(measurement->m_dateTime.toMSecsSinceEpoch(), measurement->m_value);

    m_max = std::max(m_max, measurement->m_value);
    m_min = std::min(m_min, measurement->m_value);
    if (m_min == m_max) {
        // Axis isn't drawn properly if min and max are the same
        m_yAxis->setRange(m_min*0.9, m_max*1.1);
    } else {
        m_yAxis->setRange(m_min, m_max);
    }
}

void RadioAstronomyGUI::SensorMeasurements::addAllToSeries()
{
    for (int i = 0; i < m_measurements.size(); i++) {
        addToSeries(m_measurements[i]);
    }
}

void RadioAstronomyGUI::SensorMeasurements::clear()
{
    m_series->clear();
    qDeleteAll(m_measurements);
    m_measurements.clear();
}

void RadioAstronomyGUI::SensorMeasurements::addToChart(QChart* chart, QDateTimeAxis* xAxis)
{
    chart->addSeries(m_series);
    m_series->attachAxis(xAxis);
    m_series->attachAxis(m_yAxis);
}

void RadioAstronomyGUI::SensorMeasurements::setPen(const QPen& pen)
{
    m_series->setPen(pen);
}

QValueAxis* RadioAstronomyGUI::SensorMeasurements::yAxis() const
{
    return m_yAxis;
}

qreal RadioAstronomyGUI::SensorMeasurements::lastValue()
{
    if (m_measurements.size() > 0) {
        return m_measurements.last()->m_value;
    } else {
        return 0.0;
    }
}

void RadioAstronomyGUI::resizePowerTable()
{
    // Fill table with a row of dummy data that will size the columns nicely
    // Trailing spaces are for sort arrow
    int row = ui->powerTable->rowCount();
    ui->powerTable->setRowCount(row + 1);
    ui->powerTable->setItem(row, POWER_COL_DATE, new QTableWidgetItem("15/04/2016"));
    ui->powerTable->setItem(row, POWER_COL_TIME, new QTableWidgetItem("10:17:00"));
    ui->powerTable->setItem(row, POWER_COL_POWER, new QTableWidgetItem("1.235-e5"));
    ui->powerTable->setItem(row, POWER_COL_POWER_DB, new QTableWidgetItem("-100.0"));
    ui->powerTable->setItem(row, POWER_COL_POWER_DBM, new QTableWidgetItem("-100.0"));
    ui->powerTable->setItem(row, POWER_COL_TSYS, new QTableWidgetItem("3000"));
    ui->powerTable->setItem(row, POWER_COL_TSYS0, new QTableWidgetItem("100"));
    ui->powerTable->setItem(row, POWER_COL_TSOURCE, new QTableWidgetItem("300"));
    ui->powerTable->setItem(row, POWER_COL_TB, new QTableWidgetItem("100000"));
    ui->powerTable->setItem(row, POWER_COL_TSKY, new QTableWidgetItem("300"));
    ui->powerTable->setItem(row, POWER_COL_FLUX, new QTableWidgetItem("100000.00"));
    ui->powerTable->setItem(row, POWER_COL_SIGMA_T, new QTableWidgetItem("0.01"));
    ui->powerTable->setItem(row, POWER_COL_SIGMA_S, new QTableWidgetItem("1000.0"));
    ui->powerTable->setItem(row, POWER_COL_OMEGA_A, new QTableWidgetItem("0.000001"));
    ui->powerTable->setItem(row, POWER_COL_OMEGA_S, new QTableWidgetItem("0.000001"));
    ui->powerTable->setItem(row, POWER_COL_RA, new QTableWidgetItem("12h59m59.10s"));
    ui->powerTable->setItem(row, POWER_COL_DEC, new QTableWidgetItem("-90d59\'59.00\""));
    ui->powerTable->setItem(row, POWER_COL_GAL_LAT, new QTableWidgetItem("-90.0"));
    ui->powerTable->setItem(row, POWER_COL_GAL_LON, new QTableWidgetItem("359.0"));
    ui->powerTable->setItem(row, POWER_COL_AZ, new QTableWidgetItem("359.0"));
    ui->powerTable->setItem(row, POWER_COL_EL, new QTableWidgetItem("90.0"));
    ui->powerTable->setItem(row, POWER_COL_VBCRS, new QTableWidgetItem("10.0"));
    ui->powerTable->setItem(row, POWER_COL_VLSR, new QTableWidgetItem("10.0"));
    ui->powerTable->setItem(row, POWER_COL_SOLAR_FLUX, new QTableWidgetItem("60.0"));
    ui->powerTable->setItem(row, POWER_COL_AIR_TEMP, new QTableWidgetItem("20.0"));
    ui->powerTable->setItem(row, POWER_COL_SENSOR_1, new QTableWidgetItem("1.0000000"));
    ui->powerTable->setItem(row, POWER_COL_SENSOR_2, new QTableWidgetItem("1.0000000"));
    ui->powerTable->setItem(row, POWER_COL_UTC, new QTableWidgetItem("15/04/2016 10:17:00"));
    ui->powerTable->setItem(row, POWER_COL_ROT_AZ, new QTableWidgetItem("359.0"));
    ui->powerTable->setItem(row, POWER_COL_ROT_EL, new QTableWidgetItem("-90.0"));
    ui->powerTable->setItem(row, POWER_COL_ROT_AZ_OFF, new QTableWidgetItem("-10.0"));
    ui->powerTable->setItem(row, POWER_COL_ROT_EL_OFF, new QTableWidgetItem("-10.0"));
    ui->powerTable->resizeColumnsToContents();
    ui->powerTable->removeRow(row);
}

void RadioAstronomyGUI::resizePowerMarkerTable()
{
    // Fill table with a row of dummy data that will size the columns nicely
    int row = ui->powerMarkerTable->rowCount();
    ui->powerMarkerTable->setRowCount(row + 1);
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_NAME, new QTableWidgetItem("Max"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DATE, new QTableWidgetItem("15/04/2016"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_TIME, new QTableWidgetItem("10:17:00"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_VALUE, new QTableWidgetItem("1000.0"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_X, new QTableWidgetItem("1 23:59:59"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_Y, new QTableWidgetItem("1000.0"));
    ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_TO, new QTableWidgetItem("Max"));
    ui->powerMarkerTable->resizeColumnsToContents();
    ui->powerMarkerTable->removeRow(row);
}

void RadioAstronomyGUI::resizeSpectrumMarkerTable()
{
    // Fill table with a row of dummy data that will size the columns nicely
    int row = ui->spectrumMarkerTable->rowCount();
    ui->spectrumMarkerTable->setRowCount(row + 1);
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_NAME, new QTableWidgetItem("Max"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_FREQ, new QTableWidgetItem("1420.405000"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_VALUE, new QTableWidgetItem("1000.0"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_X, new QTableWidgetItem("1420.405000"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_Y, new QTableWidgetItem("1000.0"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_TO, new QTableWidgetItem("M1"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_VR, new QTableWidgetItem("-100.0"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_R, new QTableWidgetItem("10.0"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_D, new QTableWidgetItem("10.0/10.0"));
    QTableWidgetItem* check = new QTableWidgetItem();
    check->setFlags(Qt::ItemIsUserCheckable);
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_PLOT_MAX, check);
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_R_MIN, new QTableWidgetItem("10.0"));
    ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_V, new QTableWidgetItem("250.0"));
    ui->spectrumMarkerTable->resizeColumnsToContents();
    ui->spectrumMarkerTable->removeRow(row);
}

void RadioAstronomyGUI::calcSpectrumMarkerDelta()
{
    if (m_spectrumM1Valid && m_spectrumM2Valid)
    {
        qreal dx = m_spectrumM2X - m_spectrumM1X;
        qreal dy = m_spectrumM2Y - m_spectrumM1Y;

        ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_DELTA_X)->setData(Qt::DisplayRole, dx);
        ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_DELTA_Y)->setData(Qt::DisplayRole, dy);
        ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_DELTA_TO)->setData(Qt::DisplayRole, "M1");
    }
}

void RadioAstronomyGUI::calcPowerMarkerDelta()
{
    if (m_powerM1Valid && m_powerM2Valid)
    {
        qreal dx = m_powerM2X - m_powerM1X;
        qreal dy = m_powerM2Y - m_powerM1Y;

        ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_DELTA_X)->setData(Qt::DisplayRole, dx);
        ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_DELTA_Y)->setData(Qt::DisplayRole, dy);
        ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_DELTA_TO)->setData(Qt::DisplayRole, "M1");
    }
}

void RadioAstronomyGUI::calcPowerPeakDelta()
{
    qreal dx = m_powerMaxX - m_powerMinX;
    qreal dy = m_powerMaxY - m_powerMinY;
    ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_X)->setData(Qt::DisplayRole, dx);
    ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_Y)->setData(Qt::DisplayRole, dy);
    ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_TO)->setData(Qt::DisplayRole, "Max");
}

void RadioAstronomyGUI::addToPowerSeries(FFTMeasurement *fft, bool skipCalcs)
{
    if (   ((m_settings.m_powerYUnits == RadioAstronomySettings::PY_DBFS) || fft->m_temp)                 // Only dBFS valid if no temp was calculated
        && !((m_settings.m_powerYUnits == RadioAstronomySettings::PY_DBM) && (fft->m_tSys == 0.0f))  // dBm value not valid if temp is 0
       )
    {
        qreal power;
        switch (m_settings.m_powerYData)
        {
        case RadioAstronomySettings::PY_POWER:
            switch (m_settings.m_powerYUnits)
            {
            case RadioAstronomySettings::PY_DBFS:
                power = fft->m_totalPowerdBFS;
                break;
            case RadioAstronomySettings::PY_DBM:
                power = fft->m_totalPowerdBm;
                break;
            case RadioAstronomySettings::PY_WATTS:
                power = fft->m_totalPowerWatts;
                break;
            default:
                break;
            }
            break;
        case RadioAstronomySettings::PY_TSYS:
            power = fft->m_tSys;
            break;
        case RadioAstronomySettings::PY_TSOURCE:
            power = fft->m_tSource;
            break;
        case RadioAstronomySettings::PY_FLUX:
            switch (m_settings.m_powerYUnits)
            {
            case RadioAstronomySettings::PY_SFU:
                power = Units::wattsPerMetrePerHertzToSolarFluxUnits(fft->m_flux);
                break;
            case RadioAstronomySettings::PY_JANSKY:
                power = Units::wattsPerMetrePerHertzToJansky(fft->m_flux);
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }
        QDateTime dateTime = fft->m_dateTime;

        if (m_powerSeries->count() == 0)
        {
            m_powerMin = power;
            m_powerMax = power;
        }
        else
        {
            m_powerMin = std::min(power, m_powerMin);
            m_powerMax = std::max(power, m_powerMax);
        }
        m_powerSeries->append(dateTime.toMSecsSinceEpoch(), power);
        addToPowerFilter(dateTime.toMSecsSinceEpoch(), power);
        if (!skipCalcs)
        {
            if (m_settings.m_powerAutoscale)
            {
                blockApplySettings(true);
                powerAutoscaleY(false);
                blockApplySettings(false);
            }
        }

        if (m_settings.m_powerYUnits == RadioAstronomySettings::PY_KELVIN) {
            m_powerTsys0Series->append(dateTime.toMSecsSinceEpoch(), fft->m_tSys0);
        } else if (m_settings.m_powerYUnits == RadioAstronomySettings::PY_DBM) {
            m_powerTsys0Series->append(dateTime.toMSecsSinceEpoch(), Astronomy::noisePowerdBm(fft->m_tSys0, fft->m_sampleRate));
        } else if (m_settings.m_powerYUnits == RadioAstronomySettings::PY_WATTS) {
            m_powerTsys0Series->append(dateTime.toMSecsSinceEpoch(), Astronomy::m_boltzmann * fft->m_tSys0 * fft->m_sampleRate);
        }

        if (!m_powerPeakValid)
        {
            m_powerPeakValid = true;
            m_powerMinY = power;
            m_powerMinX = dateTime.toMSecsSinceEpoch();
            m_powerMaxY = power;
            m_powerMaxX = dateTime.toMSecsSinceEpoch();
            m_powerPeakSeries->clear();
            m_powerPeakSeries->append(m_powerMaxX, m_powerMaxY);
            m_powerPeakSeries->append(m_powerMaxX, m_powerMaxY);
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(m_powerMaxX);
            if (!skipCalcs)
            {
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerMaxY);
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerMinY);
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_X)->setData(Qt::DisplayRole, 0.0);
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_Y)->setData(Qt::DisplayRole, 0.0);
                ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DELTA_TO)->setData(Qt::DisplayRole, "Max");
            }
        }

        if (power > m_powerMaxY)
        {
            m_powerMaxY = power;
            m_powerMaxX = dateTime.toMSecsSinceEpoch();
            m_powerPeakSeries->replace(0, m_powerMaxX, m_powerMaxY);
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(m_powerMaxX);
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerMaxY);
            calcPowerPeakDelta();
        }
        else if (power < m_powerMinY)
        {
            m_powerMinY = power;
            m_powerMinX = dateTime.toMSecsSinceEpoch();
            m_powerPeakSeries->replace(1, m_powerMinX, m_powerMinY);
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(m_powerMinX);
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerMinY);
            calcPowerPeakDelta();
        }

        // Update markers (E.g. if scale changes)
        int c = m_powerSeries->count();
        if (c >= 2)
        {
            QPointF p1 = m_powerSeries->at(c-2);
            QPointF p2 = m_powerSeries->at(c-1);
            if (m_powerM1Valid && (m_powerM1X >= p1.x()) && (m_powerM1X < p2.x()))
            {
                m_powerM1Y = Interpolation::interpolate(p1.x(), p1.y(), p2.x(), p2.y(), m_powerM1X);
                m_powerMarkerSeries->insert(0, QPointF(dateTime.toMSecsSinceEpoch(), m_powerM1Y));
                ui->powerMarkerTable->item(POWER_MARKER_ROW_M1, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerM1Y);
                calcPowerMarkerDelta();
            }
            if (m_powerM2Valid && (m_powerM2X >= p1.x()) && (m_powerM2X < p2.x()))
            {
                m_powerM2Y = Interpolation::interpolate(p1.x(), p1.y(), p2.x(), p2.y(), m_powerM2X);
                m_powerMarkerSeries->append(dateTime.toMSecsSinceEpoch(), m_powerM2Y);
                ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerM2Y);
                calcPowerMarkerDelta();
            }
        }

        if (!skipCalcs)
        {
            // Set X axis format to include date if measurements span over different days
            // Seems there's a QT bug here, if we call m_powerXAxis->setFormat, the chart isn't
            // redrawn properly, so we have to redraw the whole thing
            QDateTime minDateTime = m_powerXAxis->min();
            QDateTime maxDateTime = m_powerXAxis->max();
            bool sameDay = minDateTime.date() == maxDateTime.date();
            if (!sameDay && m_powerXAxisSameDay)
            {
                m_powerXAxisSameDay = true;
                QTimer::singleShot(100, this, SLOT(plotPowerChart()));
            }
        }

        if (!skipCalcs && ui->powerShowAvg->isChecked()) {
            calcAverages();
        }
    }
    if (m_powerSeries->count() <= 1)    // Don't check skipCalcs here, as that will be set for first data
    {
        ui->powerStartTime->setMinimumDateTime(fft->m_dateTime);
        ui->powerEndTime->setMinimumDateTime(fft->m_dateTime);
        if (m_settings.m_powerAutoscale)
        {
            ui->powerStartTime->setDateTime(fft->m_dateTime);
            ui->powerEndTime->setDateTime(fft->m_dateTime);
        }
    }
    if (!skipCalcs)
    {
        ui->powerStartTime->setMaximumDateTime(fft->m_dateTime);
        ui->powerEndTime->setMaximumDateTime(fft->m_dateTime);
        if (m_settings.m_powerAutoscale) {
            ui->powerEndTime->setDateTime(fft->m_dateTime);
        }
    }
}

double RadioAstronomyGUI::degreesToSteradian(double deg) const
{
    // https://en.wikipedia.org/wiki/Steradian - Other properties
    double s = sin(Units::degreesToRadians(deg) / 4.0);
    return 4.0 * M_PI * s * s;
}

double RadioAstronomyGUI::hpbwToSteradians(double hpbw) const
{
    // https://www.cv.nrao.edu/~sransom/web/Ch3.html#E118
    double theta = Units::degreesToRadians(hpbw);
    return theta * theta * M_PI / (4.0 * M_LN2);
}

double RadioAstronomyGUI::calcOmegaA() const
{
    return hpbwToSteradians(m_beamWidth);
}

double RadioAstronomyGUI::calcOmegaS() const
{
    if (m_settings.m_sourceType == RadioAstronomySettings::UNKNOWN)
    {
        return 0.0;
    }
    else if (m_settings.m_sourceType == RadioAstronomySettings::EXTENDED)
    {
        return calcOmegaA();
    }
    else
    {
        return m_settings.m_omegaSUnits == RadioAstronomySettings::STERRADIANS ? m_settings.m_omegaS : degreesToSteradian(m_settings.m_omegaS);
    }
}

double RadioAstronomyGUI::beamFillingFactor() const
{
    if (m_settings.m_sourceType == RadioAstronomySettings::EXTENDED)
    {
        return 1.0;
    }
    else
    {
        // https://www.cv.nrao.edu/~sransom/web/Ch3.html#E55
        return calcOmegaS() / calcOmegaA();
    }
}

void RadioAstronomyGUI::powerMeasurementReceived(FFTMeasurement *fft, bool skipCalcs)
{
    ui->powerTable->setSortingEnabled(false);
    int row = ui->powerTable->rowCount();
    ui->powerTable->setRowCount(row + 1);

    QTableWidgetItem* dateItem = new QTableWidgetItem();
    QTableWidgetItem* timeItem = new QTableWidgetItem();
    QTableWidgetItem* powerItem = new QTableWidgetItem();
    QTableWidgetItem* powerDBItem = new QTableWidgetItem();
    QTableWidgetItem* powerdBmItem = new QTableWidgetItem();
    QTableWidgetItem* tSysItem = new QTableWidgetItem();
    QTableWidgetItem* tSys0Item = new QTableWidgetItem();
    QTableWidgetItem* tSourceItem = new QTableWidgetItem();
    QTableWidgetItem* tBItem = new QTableWidgetItem();
    QTableWidgetItem* tSkyItem = new QTableWidgetItem();
    QTableWidgetItem* fluxItem = new QTableWidgetItem();
    QTableWidgetItem* sigmaTItem = new QTableWidgetItem();
    QTableWidgetItem* sigmaSItem = new QTableWidgetItem();
    QTableWidgetItem* omegaAItem = new QTableWidgetItem();
    QTableWidgetItem* omegaSItem = new QTableWidgetItem();
    QTableWidgetItem* raItem = new QTableWidgetItem();
    QTableWidgetItem* decItem = new QTableWidgetItem();
    QTableWidgetItem* lonItem = new QTableWidgetItem();
    QTableWidgetItem* latItem = new QTableWidgetItem();
    QTableWidgetItem* azItem = new QTableWidgetItem();
    QTableWidgetItem* elItem = new QTableWidgetItem();
    QTableWidgetItem* vBCRSItem = new QTableWidgetItem();
    QTableWidgetItem* vLSRItem = new QTableWidgetItem();
    QTableWidgetItem* solarFluxItem = new QTableWidgetItem();
    QTableWidgetItem* airTempItem = new QTableWidgetItem();
    QTableWidgetItem* sensor1Item = new QTableWidgetItem();
    QTableWidgetItem* sensor2Item = new QTableWidgetItem();
    QTableWidgetItem* utcItem = new QTableWidgetItem();
    QTableWidgetItem* rotAzItem = new QTableWidgetItem();
    QTableWidgetItem* rotElItem = new QTableWidgetItem();
    QTableWidgetItem* rotAzOffItem = new QTableWidgetItem();
    QTableWidgetItem* rotElOffItem = new QTableWidgetItem();

    ui->powerTable->setItem(row, POWER_COL_DATE, dateItem);
    ui->powerTable->setItem(row, POWER_COL_TIME, timeItem);
    ui->powerTable->setItem(row, POWER_COL_POWER, powerItem);
    ui->powerTable->setItem(row, POWER_COL_POWER_DB, powerDBItem);
    ui->powerTable->setItem(row, POWER_COL_POWER_DBM, powerdBmItem);
    ui->powerTable->setItem(row, POWER_COL_TSYS, tSysItem);
    ui->powerTable->setItem(row, POWER_COL_TSYS0, tSys0Item);
    ui->powerTable->setItem(row, POWER_COL_TSOURCE, tSourceItem);
    ui->powerTable->setItem(row, POWER_COL_TB, tBItem);
    ui->powerTable->setItem(row, POWER_COL_TSKY, tSkyItem);
    ui->powerTable->setItem(row, POWER_COL_FLUX, fluxItem);
    ui->powerTable->setItem(row, POWER_COL_SIGMA_T, sigmaTItem);
    ui->powerTable->setItem(row, POWER_COL_SIGMA_S, sigmaSItem);
    ui->powerTable->setItem(row, POWER_COL_OMEGA_A, omegaAItem);
    ui->powerTable->setItem(row, POWER_COL_OMEGA_S, omegaSItem);
    ui->powerTable->setItem(row, POWER_COL_RA, raItem);
    ui->powerTable->setItem(row, POWER_COL_DEC, decItem);
    ui->powerTable->setItem(row, POWER_COL_GAL_LON, lonItem);
    ui->powerTable->setItem(row, POWER_COL_GAL_LAT, latItem);
    ui->powerTable->setItem(row, POWER_COL_AZ, azItem);
    ui->powerTable->setItem(row, POWER_COL_EL, elItem);
    ui->powerTable->setItem(row, POWER_COL_VBCRS, vBCRSItem);
    ui->powerTable->setItem(row, POWER_COL_VLSR, vLSRItem);
    ui->powerTable->setItem(row, POWER_COL_SOLAR_FLUX, solarFluxItem);
    ui->powerTable->setItem(row, POWER_COL_AIR_TEMP, airTempItem);
    ui->powerTable->setItem(row, POWER_COL_SENSOR_1, sensor1Item);
    ui->powerTable->setItem(row, POWER_COL_SENSOR_2, sensor2Item);
    ui->powerTable->setItem(row, POWER_COL_UTC, utcItem);
    ui->powerTable->setItem(row, POWER_COL_ROT_AZ, rotAzItem);
    ui->powerTable->setItem(row, POWER_COL_ROT_EL, rotElItem);
    ui->powerTable->setItem(row, POWER_COL_ROT_AZ_OFF, rotAzOffItem);
    ui->powerTable->setItem(row, POWER_COL_ROT_EL_OFF, rotElOffItem);

    ui->powerTable->setSortingEnabled(true);

    QDateTime dateTime = fft->m_dateTime;
    dateItem->setData(Qt::DisplayRole, dateTime.date());
    timeItem->setData(Qt::DisplayRole, dateTime.time());
    utcItem->setData(Qt::DisplayRole, dateTime.toUTC());

    powerItem->setData(Qt::DisplayRole, fft->m_totalPower);
    powerDBItem->setData(Qt::DisplayRole, fft->m_totalPowerdBFS);
    if (fft->m_tSys != 0.0f) {
        powerdBmItem->setData(Qt::DisplayRole, fft->m_totalPowerdBm);
    }
    if (fft->m_temp) {
        updatePowerColumns(row, fft);
    }
    if (fft->m_coordsValid)
    {
        raItem->setData(Qt::DisplayRole, fft->m_ra);
        decItem->setData(Qt::DisplayRole, fft->m_dec);
        latItem->setData(Qt::DisplayRole, fft->m_b);
        lonItem->setData(Qt::DisplayRole, fft->m_l);
        azItem->setData(Qt::DisplayRole, fft->m_azimuth);
        elItem->setData(Qt::DisplayRole, fft->m_elevation);
        vBCRSItem->setData(Qt::DisplayRole, fft->m_vBCRS);
        vLSRItem->setData(Qt::DisplayRole, fft->m_vLSR);
        tSkyItem->setData(Qt::DisplayRole, fft->m_skyTemp);
    }
    solarFluxItem->setData(Qt::DisplayRole, fft->m_solarFlux);
    airTempItem->setData(Qt::DisplayRole, fft->m_airTemp);
    sensor1Item->setData(Qt::DisplayRole, fft->m_sensor[0]);
    sensor2Item->setData(Qt::DisplayRole, fft->m_sensor[1]);
    if (fft->m_rotValid)
    {
        rotAzItem->setData(Qt::DisplayRole, fft->m_rotAz);
        rotElItem->setData(Qt::DisplayRole, fft->m_rotEl);
        rotAzOffItem->setData(Qt::DisplayRole, fft->m_rotAzOff);
        rotElOffItem->setData(Qt::DisplayRole, fft->m_rotElOff);
    }

    addToPowerSeries(fft, skipCalcs);
}

void RadioAstronomyGUI::powerAutoscale()
{
    if (m_settings.m_powerAutoscale)
    {
        on_powerAutoscaleX_clicked();
        on_powerAutoscaleY_clicked();
    }
}

// Scale X and Y axis according to min and max values
void RadioAstronomyGUI::on_powerAutoscale_toggled(bool checked)
{
    m_settings.m_powerAutoscale = checked;
    ui->powerAutoscaleX->setEnabled(!m_settings.m_powerAutoscale);
    ui->powerAutoscaleY->setEnabled(!m_settings.m_powerAutoscale);
    ui->powerReference->setEnabled(!m_settings.m_powerAutoscale);
    ui->powerRange->setEnabled(!m_settings.m_powerAutoscale);
    ui->powerStartTime->setEnabled(!m_settings.m_powerAutoscale);
    ui->powerEndTime->setEnabled(!m_settings.m_powerAutoscale);
    powerAutoscale();
    applySettings();
}

void RadioAstronomyGUI::powerAutoscaleY(bool adjustAxis)
{
    double min = m_powerMin;
    double max = m_powerMax;
    double range = max - min;
    // Round to 1 or 2 decimal places
    if (range > 1.0)
    {
        min = std::floor(min * 10.0) / 10.0;
        max = std::ceil(max * 10.0) / 10.0;
    }
    else
    {
        min = std::floor(min * 100.0) / 100.0;
        max = std::ceil(max * 100.0) / 100.0;
    }
    range = max - min;
    max += range * 0.2; // Add 20% space for markers
    range = max - min;
    range = std::max(0.1, range);     // Don't be smaller than minimum value we can set in GUI

    if (adjustAxis) {
        m_powerYAxis->setRange(min, max);
    }
    ui->powerRange->setValue(range); // Call before setting reference, so number of decimals are adjusted
    ui->powerReference->setValue(max);
}

// Scale Y axis according to min and max values
void RadioAstronomyGUI::on_powerAutoscaleY_clicked()
{
    if (m_powerYAxis) {
        powerAutoscaleY(true);
    }
}

// Scale X axis according to min and max values in series
void RadioAstronomyGUI::on_powerAutoscaleX_clicked()
{
    if (m_powerSeries && (m_powerSeries->count() > 0))
    {
        QDateTime start = QDateTime::fromMSecsSinceEpoch(m_powerSeries->at(0).x());
        QDateTime end = QDateTime::fromMSecsSinceEpoch(m_powerSeries->at(m_powerSeries->count()-1).x());
        ui->powerStartTime->setDateTime(start);
        ui->powerEndTime->setDateTime(end);
    }
}

void RadioAstronomyGUI::on_powerReference_valueChanged(double value)
{
    m_settings.m_powerReference = value;
    if (m_powerYAxis) {
        m_powerYAxis->setRange(m_settings.m_powerReference - m_settings.m_powerRange, m_settings.m_powerReference);
    }
    applySettings();
}

void RadioAstronomyGUI::on_powerRange_valueChanged(double value)
{
    m_settings.m_powerRange = value;
    if (m_settings.m_powerRange <= 1.0)
    {
        ui->powerRange->setSingleStep(0.1);
        ui->powerRange->setDecimals(2);
        ui->powerReference->setDecimals(2);
    }
    else
    {
        ui->powerRange->setSingleStep(1.0);
        ui->powerRange->setDecimals(1);
        ui->powerReference->setDecimals(1);
    }
    if (m_powerYAxis) {
        m_powerYAxis->setRange(m_settings.m_powerReference - m_settings.m_powerRange, m_settings.m_powerReference);
    }
    applySettings();
}

void RadioAstronomyGUI::on_powerStartTime_dateTimeChanged(QDateTime value)
{
    if (m_powerXAxis) {
        m_powerXAxis->setMin(value);
    }
}

void RadioAstronomyGUI::on_powerEndTime_dateTimeChanged(QDateTime value)
{
    if (m_powerXAxis) {
        m_powerXAxis->setMax(value);
    }
}

// Columns in table reordered
void RadioAstronomyGUI::powerTable_sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)
{
    (void) oldVisualIndex;

    m_settings.m_powerTableColumnIndexes[logicalIndex] = newVisualIndex;
}

// Column in table resized (when hidden size is 0)
void RadioAstronomyGUI::powerTable_sectionResized(int logicalIndex, int oldSize, int newSize)
{
    (void) oldSize;

    m_settings.m_powerTableColumnSizes[logicalIndex] = newSize;
}

// Right click in table header - show column select menu
void RadioAstronomyGUI::powerTableColumnSelectMenu(QPoint pos)
{
    powerTableMenu->popup(ui->powerTable->horizontalHeader()->viewport()->mapToGlobal(pos));
}

// Hide/show column when menu selected
void RadioAstronomyGUI::powerTableColumnSelectMenuChecked(bool checked)
{
    (void) checked;

    QAction* action = qobject_cast<QAction*>(sender());
    if (action != nullptr)
    {
        int idx = action->data().toInt(nullptr);
        ui->powerTable->setColumnHidden(idx, !action->isChecked());
    }
}

// Create column select menu item
QAction *RadioAstronomyGUI::createCheckableItem(QString &text, int idx, bool checked, const char *slot)
{
    QAction *action = new QAction(text, this);
    action->setCheckable(true);
    action->setChecked(checked);
    action->setData(QVariant(idx));
    connect(action, SIGNAL(triggered()), this, slot);
    return action;
}

RadioAstronomyGUI* RadioAstronomyGUI::create(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel)
{
    RadioAstronomyGUI* gui = new RadioAstronomyGUI(pluginAPI, deviceUISet, rxChannel);
    return gui;
}

void RadioAstronomyGUI::destroy()
{
    delete this;
}

void RadioAstronomyGUI::resetToDefaults()
{
    m_settings.resetToDefaults();
    displaySettings();
    applySettings(true);
}

QByteArray RadioAstronomyGUI::serialize() const
{
    return m_settings.serialize();
}

bool RadioAstronomyGUI::deserialize(const QByteArray& data)
{
    if(m_settings.deserialize(data)) {
        displaySettings();
        applySettings(true);
        return true;
    } else {
        resetToDefaults();
        return false;
    }
}

void RadioAstronomyGUI::updateAvailableFeatures(const AvailableChannelOrFeatureList& availableFeatures, const QStringList& renameFrom, const QStringList& renameTo)
{
    // Update starTracker setting if it has been renamed
    if (renameFrom.contains(m_settings.m_starTracker))
    {
        m_settings.m_starTracker = renameTo[renameFrom.indexOf(m_settings.m_starTracker)];
        applySettings();
    }

    ui->starTracker->blockSignals(true);
    ui->starTracker->clear();

    for (const auto& feature : availableFeatures) {
        ui->starTracker->addItem(feature.getLongId());
    }

    int idx = ui->starTracker->findText(m_settings.m_starTracker);
    if (idx >= 0) {
        ui->starTracker->setCurrentIndex(idx);
    } else  {
        ui->starTracker->setCurrentIndex(0);
    }

    ui->starTracker->blockSignals(false);

    QString newText = ui->starTracker->currentText();
    if (m_settings.m_starTracker != newText)
    {
       m_settings.m_starTracker = newText;
       applySettings();
    }
}

bool RadioAstronomyGUI::handleMessage(const Message& message)
{
    if (DSPSignalNotification::match(message))
    {
        DSPSignalNotification& notif = (DSPSignalNotification&) message;
        m_basebandSampleRate = notif.getSampleRate();
        m_centerFrequency = notif.getCenterFrequency();
        ui->deltaFrequency->setValueRange(false, 7, -m_basebandSampleRate/2, m_basebandSampleRate/2);
        ui->deltaFrequencyLabel->setToolTip(tr("Range %1 %L2 Hz").arg(QChar(0xB1)).arg(m_basebandSampleRate/2));
        updateAbsoluteCenterFrequency();

        if (m_settings.m_tempGalLink) {
            calcGalacticBackgroundTemp();
        }

        updateTSys0();

        return true;
    }
    else if (RadioAstronomy::MsgReportAvailableFeatures::match(message))
    {
        qDebug("RadioAstronomyGUI::handleMessage: MsgReportAvailableFeatures");
        RadioAstronomy::MsgReportAvailableFeatures& report = (RadioAstronomy::MsgReportAvailableFeatures&) message;
        updateAvailableFeatures(report.getFeatures(), report.getRenameFrom(), report.getRenameTo());
        return true;
    }
    else if (MainCore::MsgStarTrackerTarget::match(message))
    {
        MainCore::MsgStarTrackerTarget& msg = (MainCore::MsgStarTrackerTarget&)message;
        SWGSDRangel::SWGStarTrackerTarget *target = msg.getSWGStarTrackerTarget();
        m_coordsValid = true;
        m_ra = target->getRa();
        m_dec = target->getDec();
        m_azimuth = target->getAzimuth();
        m_elevation = target->getElevation();
        m_l = target->getL();
        m_b = target->getB();
        m_vBCRS = target->getEarthRotationVelocity() + target->getEarthOrbitVelocityBcrs();
        m_vLSR = target->getSunVelocityLsr() + m_vBCRS;
        m_solarFlux = target->getSolarFlux();
        double airTemp = target->getAirTemperature();
        m_skyTemp = target->getSkyTemperature();
        m_beamWidth = target->getHpbw();

        if (m_settings.m_elevationLink) {
            ui->elevation->setValue(m_elevation);
        }
        if (m_settings.m_tempAirLink) {
            ui->tempAir->setValue(airTemp);
        }
        SensorMeasurement* sm = new SensorMeasurement(QDateTime::currentDateTime(), airTemp);
        m_airTemps.append(sm);
        updateTSys0();
        updateOmegaA();

        return true;
    }
    else if (RadioAstronomy::MsgConfigureRadioAstronomy::match(message))
    {
        const RadioAstronomy::MsgConfigureRadioAstronomy& cfg = (RadioAstronomy::MsgConfigureRadioAstronomy&) message;
        m_settings = cfg.getSettings();
        blockApplySettings(true);
        m_channelMarker.updateSettings(static_cast<const ChannelMarker*>(m_settings.m_channelMarker));
        displaySettings();
        blockApplySettings(false);
        return true;
    }
    else if (RadioAstronomy::MsgMeasurementProgress::match(message))
    {
        RadioAstronomy::MsgMeasurementProgress& progress = (RadioAstronomy::MsgMeasurementProgress&) message;
        ui->measurementProgress->setValue(progress.getPercentComplete());
        return true;
    }
    else if (RadioAstronomy::MsgSweepStatus::match(message))
    {
        RadioAstronomy::MsgSweepStatus& status = (RadioAstronomy::MsgSweepStatus&) message;
        ui->sweepStatus->setText(status.getStatus());
        return true;
    }
    else if (RadioAstronomy::MsgSweepComplete::match(message))
    {
        ui->startStop->blockSignals(true);
        ui->startStop->setChecked(false);
        ui->startStop->blockSignals(false);
        ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
        return true;
    }
    else if (RadioAstronomy::MsgCalComplete::match(message))
    {
        RadioAstronomy::MsgCalComplete& measurement = (RadioAstronomy::MsgCalComplete&) message;
        calCompletetReceived(measurement);
        return true;
    }
    else if (RadioAstronomy::MsgFFTMeasurement::match(message))
    {
        RadioAstronomy::MsgFFTMeasurement& measurement = (RadioAstronomy::MsgFFTMeasurement&) message;
        fftMeasurementReceived(measurement);
        if (m_settings.m_runMode == RadioAstronomySettings::SINGLE)
        {
            ui->startStop->blockSignals(true);
            ui->startStop->setChecked(false);
            ui->startStop->blockSignals(false);
            ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
        }
        return true;
    }
    else if (RadioAstronomy::MsgSensorMeasurement::match(message))
    {
        RadioAstronomy::MsgSensorMeasurement& measurement = (RadioAstronomy::MsgSensorMeasurement&) message;
        sensorMeasurementReceived(measurement);
        return true;
    }
    else if (RadioAstronomy::MsgReportAvailableRotators::match(message))
    {
        RadioAstronomy::MsgReportAvailableRotators& report = (RadioAstronomy::MsgReportAvailableRotators&) message;
        updateRotatorList(report.getFeatures(), report.getRenameFrom(), report.getRenameTo());
        return true;
    }

    return false;
}

void RadioAstronomyGUI::handleInputMessages()
{
    Message* message;

    while ((message = getInputMessageQueue()->pop()) != 0)
    {
        if (handleMessage(*message))
        {
            delete message;
        }
    }
}

void RadioAstronomyGUI::channelMarkerChangedByCursor()
{
    ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
    m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency();
    applySettings();
}

void RadioAstronomyGUI::channelMarkerHighlightedByCursor()
{
    setHighlighted(m_channelMarker.getHighlighted());
}

// Calculate Tsys0 - i.e. receiver noise temperature when there's no source signal, just unwanted noise
void RadioAstronomyGUI::updateTSys0()
{
    double tSys0 = calcTSys0();
    ui->tSys0->setText(QString("%1").arg(round(tSys0)));
    double sigmaT = calcSigmaT(tSys0);
    double sigmaS = calcSigmaS(tSys0);
    ui->sigmaTSys0->setText(QString("%1").arg(sigmaT, 0, 'f', 1));
    ui->sigmaSSys0->setText(QString("%1").arg(sigmaS, 0, 'f', 1));
}

// Estimate of system noise temperature due to all sources of unwanted noise, from user settings
double RadioAstronomyGUI::calcTSys0() const
{
    return m_settings.m_tempRX + m_settings.m_tempCMB + m_settings.m_tempGal + m_settings.m_tempSP + m_settings.m_tempAtm;
}

// Calculate measurement time
double RadioAstronomyGUI::calcTau() const
{
    return m_settings.m_integration / (m_settings.m_sampleRate / (double)m_settings.m_fftSize);
}

double RadioAstronomyGUI::calcTau(const FFTMeasurement* fft) const
{
    return fft->m_integration / (fft->m_sampleRate / (double)fft->m_fftSize);
}

// Calculate variation in Tsys due to random noise fluctuations, including receiver gain variations
// Minimum temp we can reliably detect will be ~5x this
// Uses practical total-power radiometer equation: https://www.cv.nrao.edu/~sransom/web/Ch3.html#E158

double RadioAstronomyGUI::calcSigmaT(double tSys) const
{
    double tau = calcTau();
    return tSys * sqrt(1.0/(m_settings.m_rfBandwidth * tau) + m_settings.m_gainVariation * m_settings.m_gainVariation);
}

double RadioAstronomyGUI::calcSigmaT(const FFTMeasurement* fft) const
{
    double tau = calcTau(fft);
    return fft->m_tSys * sqrt(1.0/(fft->m_rfBandwidth * tau) + m_settings.m_gainVariation * m_settings.m_gainVariation);
}

// Calculate variations in flux due to random noise fluctuations, including receiver gain variations
// Minimum flux we can reliably detect will be ~5x this

double RadioAstronomyGUI::calcSigmaS(double tSys) const
{
    double omegaA = hpbwToSteradians(m_beamWidth);
    double lambda = Astronomy::m_speedOfLight / (double)m_centerFrequency;
    double flux = 2.0 * Astronomy::m_boltzmann * tSys * omegaA / (lambda * lambda); // Should we use Aeff here instead?
    double tau = calcTau();
    double sigma = flux * sqrt(1.0/(m_settings.m_rfBandwidth * tau) + m_settings.m_gainVariation * m_settings.m_gainVariation);
    return Units::wattsPerMetrePerHertzToJansky(sigma);
}

double RadioAstronomyGUI::calcSigmaS(const FFTMeasurement* fft) const
{
    double omegaA = fft->m_omegaA;
    double lambda = Astronomy::m_speedOfLight / (double)fft->m_centerFrequency;
    double flux = 2.0 * Astronomy::m_boltzmann * fft->m_tSys * omegaA / (lambda * lambda); // Should we use Aeff here instead?
    double tau = calcTau(fft);
    double sigma = flux * sqrt(1.0/(fft->m_rfBandwidth * tau) + m_settings.m_gainVariation * m_settings.m_gainVariation);
    return Units::wattsPerMetrePerHertzToJansky(sigma);
}

// Calculate and display how long a single measurement will take
void RadioAstronomyGUI::updateIntegrationTime()
{
    double secs = calcTau();
    if (secs >= 60) {
         ui->integrationTime->setText(QString("%1m").arg(secs/60, 0, 'f', 1));
    } else {
        ui->integrationTime->setText(QString("%1s").arg(secs, 0, 'f', 1));
    }
    updateTSys0();
}

// Limit bandwidth to be less than sample rate
void RadioAstronomyGUI::updateBWLimits()
{
    qint64 sr = (qint64) m_settings.m_sampleRate;
    int digits = ceil(log10(sr+1));
    ui->rfBW->setValueRange(true, digits, 100, sr);
}

void RadioAstronomyGUI::on_deltaFrequency_changed(qint64 value)
{
    m_channelMarker.setCenterFrequency(value);
    m_settings.m_inputFrequencyOffset = m_channelMarker.getCenterFrequency();
    updateAbsoluteCenterFrequency();
    applySettings();
}

void RadioAstronomyGUI::on_sampleRate_changed(qint64 value)
{
    float sr = value;
    m_settings.m_sampleRate = sr;
    updateBWLimits();
    updateIntegrationTime();
    applySettings();
}

void RadioAstronomyGUI::on_rfBW_changed(qint64 value)
{
    float bw = value;
    m_channelMarker.setBandwidth(bw);
    m_settings.m_rfBandwidth = bw;
    applySettings();
}

void RadioAstronomyGUI::on_integration_changed(qint64 value)
{
    m_settings.m_integration = value;
    updateIntegrationTime();
    applySettings();
}

void RadioAstronomyGUI::on_recalibrate_toggled(bool checked)
{
    m_settings.m_recalibrate = checked;
    applySettings();
    if (checked) {
        recalibrate();
    }
}

void RadioAstronomyGUI::on_showCalSettings_clicked()
{
    RadioAstronomyCalibrationDialog dialog(&m_settings);
    if (dialog.exec() == QDialog::Accepted) {
        applySettings();
    }
}

// Start hot calibration
void RadioAstronomyGUI::on_startCalHot_clicked()
{
    if (ui->startStop->isChecked()) {
        ui->startStop->click();
    }
    m_radioAstronomy->getInputMessageQueue()->push(RadioAstronomy::MsgStartCal::create(true));
    ui->startCalHot->setStyleSheet("QToolButton { background-color : green; }");
}

// Start cold calibration
void RadioAstronomyGUI::on_startCalCold_clicked()
{
    if (ui->startStop->isChecked()) {
        ui->startStop->click();
    }
    m_radioAstronomy->getInputMessageQueue()->push(RadioAstronomy::MsgStartCal::create(false));
    ui->startCalCold->setStyleSheet("QToolButton { background-color : green; }");
}

// Clear all measurements (but not calibration data)
void RadioAstronomyGUI::clearData()
{
    ui->powerTable->setRowCount(0);
    m_powerSeries->clear();
    m_powerPeakSeries->clear();
    m_powerMarkerSeries->clear();
    m_powerTsys0Series->clear();
    m_powerFilteredSeries->clear();
    m_airTemps.clear();
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        m_sensors[i].clear();
    }
    for (int row = 0; row < POWER_MARKER_ROWS; row++)
    {
        for (int col = POWER_MARKER_COL_DATE; col <= POWER_MARKER_COL_DELTA_TO; col++)
        {
            ui->powerMarkerTable->item(row, col)->setText("");
        }
    }
    m_powerM1Valid = false;
    m_powerM2Valid = false;

    qDeleteAll(m_fftMeasurements);
    m_fftMeasurements.clear();
    m_fftSeries->clear();
    m_fftPeakSeries->clear();
    m_fftMarkerSeries->clear();
    for (int row = 0; row < SPECTRUM_MARKER_ROWS; row++)
    {
        for (int col = SPECTRUM_MARKER_COL_FREQ; col <= SPECTRUM_MARKER_COL_D; col++)
        {
            ui->spectrumMarkerTable->item(row, col)->setText("");
        }
    }
    m_spectrumM1Valid = false;
    m_spectrumM2Valid = false;
    clearLoSMarker("Max");
    clearLoSMarker("M1");
    clearLoSMarker("M2");

    ui->spectrumIndex->setRange(0, 0);
    ui->spectrumDateTime->setDateTime(QDateTime::currentDateTime());
    ui->powerMean->setText("");
    ui->powerRMS->setText("");
    ui->powerSD->setText("");
    plotPowerVsTimeChart(); // To ensure min/max/peaks are reset

    create2DImage();
    plotPowerChart();

    ui->measurementProgress->setValue(0);
    ui->sweepStatus->setText("");
}

// Clear calibration data
void RadioAstronomyGUI::clearCalData()
{
    delete m_calHot;
    delete m_calCold;
    delete m_calG;
    m_calHot = nullptr;
    m_calCold = nullptr;
    m_calG = nullptr;
    m_calHotSeries->clear();
    m_calColdSeries->clear();
    ui->calAvgDiff->setText("");
}

// deleteRowsComplete should be called after all rows are deleted
// Returns if the row being deleted is the currently displayed FFT
bool RadioAstronomyGUI::deleteRow(int row)
{
    ui->powerTable->removeRow(row);
    delete m_fftMeasurements[row];
    m_fftMeasurements.removeAt(row);
    return row == ui->spectrumIndex->value();
}

// Updates GUI after rows have been deleted
void RadioAstronomyGUI::deleteRowsComplete(bool deletedCurrent, int next)
{
    if (m_fftMeasurements.size() == 0)
    {
        clearData();
    }
    else
    {
        if (deletedCurrent) {
            ui->spectrumIndex->setValue(next);
        }
        plotPowerChart();
        powerAutoscale();
    }
}

// Calculate average difference in hot and cold cal data - so we can easily validate results
void RadioAstronomyGUI::calcCalAvgDiff()
{
    if ((m_calHot && m_calCold) && (m_calHot->m_fftSize == m_calCold->m_fftSize))
    {
        Real sum = 0.0f;
        for (int i = 0; i < m_calHot->m_fftSize; i++) {
            sum += CalcDb::dbPower(m_calHot->m_fftData[i]) - CalcDb::dbPower(m_calCold->m_fftData[i]);
        }
        Real avg = sum / m_calHot->m_fftSize;
        ui->calAvgDiff->setText(QString::number(avg, 'f', 1));
    }
    else
    {
        ui->calAvgDiff->setText("");
    }
}

void RadioAstronomyGUI::calcCalibrationScaleFactors()
{
    if (m_calHot)
    {
        delete[] m_calG;
        m_calG = new double[m_calHot->m_fftSize];
        // Calculate scaling factors from FFT mag to temperature
        // FIXME: This assumes cal hot is fixed reference temp - E.g. 50Ohm term
        for (int i = 0; i < m_calHot->m_fftSize; i++) {
            m_calG[i] = (m_settings.m_tCalHot + m_settings.m_tempRX) / m_calHot->m_fftData[i];
        }
    }
}

void RadioAstronomyGUI::calibrate()
{
    if (m_calHotSeries)
    {
        calcCalibrationScaleFactors();
        calcCalTrx();
        calcCalTsp();

        if (m_settings.m_recalibrate)
        {
            // Apply new calibration to existing measurements
            recalibrate();
        }
    }
}

// Apply calibration to all existing measurements
void RadioAstronomyGUI::recalibrate()
{
    for (int i = 0; i < m_fftMeasurements.size(); i++)
    {
        FFTMeasurement* fft = m_fftMeasurements[i];
        // Recalibrate
        calcFFTTemperatures(fft);
        calcFFTTotalTemperature(fft);
        // Update table
        if (fft->m_tSys != 0.0f) {
            ui->powerTable->item(i, POWER_COL_POWER_DBM)->setData(Qt::DisplayRole, fft->m_totalPowerdBm);
        }
        if (fft->m_temp) {
            updatePowerColumns(i, fft);
        }
    }
    // Update charts
    plotFFTMeasurement();
    plotPowerChart();
}

// Calculate Trx using Y-factor method
void RadioAstronomyGUI::calcCalTrx()
{
    if ((m_calHot && m_calCold) && (m_calHot->m_fftSize == m_calCold->m_fftSize))
    {
        // y=Ph/Pc
        double sumH = 0.0;
        double sumC = 0.0;
        for (int i = 0; i < m_calHot->m_fftSize; i++)
        {
            sumH += m_calHot->m_fftData[i];
            sumC += m_calCold->m_fftData[i];
        }
        double y = sumH/sumC;
        // Use y to calculate Trx, which should be the same for both calibration points
        double Trx = (m_settings.m_tCalHot - (m_settings.m_tCalCold * y)) / (y - 1.0);
        ui->calYFactor->setText(QString::number(y, 'f', 2));
        ui->calTrx->setText(QString::number(Trx, 'f', 1));
    }
    else
    {
        ui->calYFactor->setText("");
        ui->calTrx->setText("");
    }
}

// Estimate spillover temperature (This is typically very Az/El dependent as ground noise will vary)
void RadioAstronomyGUI::calcCalTsp()
{
    if (!ui->calTrx->text().isEmpty() && !ui->calTsky->text().isEmpty() && !ui->calYFactor->text().isEmpty())
    {
        double Trx = ui->calTrx->text().toDouble();
        double Tsky = ui->calTsky->text().toDouble();
        double y = ui->calYFactor->text().toDouble();
        double atmosphericAbsorbtion = std::exp(-m_settings.m_zenithOpacity/cos(Units::degreesToRadians(90.0f - m_settings.m_elevation)));

        double Tsp = (m_settings.m_tCalHot + Trx) / y - (Tsky*atmosphericAbsorbtion) - m_settings.m_tempAtm - Trx;

        ui->calTsp->setText(QString::number(Tsp, 'f', 1));
    }
    else
    {
        ui->calTsp->setText("");
    }
}

void RadioAstronomyGUI::on_clearData_clicked()
{
    clearData();
}

void RadioAstronomyGUI::on_clearCal_clicked()
{
    clearCalData();
}

// Save power data in table to a CSV file
void RadioAstronomyGUI::on_savePowerData_clicked()
{
    // Get filename to save to
    QFileDialog fileDialog(nullptr, "Select file to save data to", "", "*.csv");
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    if (fileDialog.exec())
    {
        QStringList fileNames = fileDialog.selectedFiles();
        if (fileNames.size() > 0)
        {
            QFile file(fileNames[0]);
            if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                QMessageBox::critical(this, "Radio Astronomy", QString("Failed to open file %1").arg(fileNames[0]));
                return;
            }
            QTextStream out(&file);

            // Create a CSV file from the values in the table
            for (int i = 0; i < ui->powerTable->horizontalHeader()->count(); i++)
            {
                QString text = ui->powerTable->horizontalHeaderItem(i)->text();
                out << text << ",";
            }
            out << "\n";
            for (int i = 0; i < ui->powerTable->rowCount(); i++)
            {
                for (int j = 0; j < ui->powerTable->horizontalHeader()->count(); j++)
                {
                    out << ui->powerTable->item(i,j)->data(Qt::DisplayRole).toString() << ",";
                }
                out << "\n";
            }
        }
    }
}

// Create a hash mapping from column name to array index
QHash<QString,int> RadioAstronomyGUI::csvHeadersToHash(QStringList cols)
{
    QHash<QString,int> hash;
    for (int i = 0; i < cols.size(); i++) {
        hash.insert(cols[i], i);
    }
    return hash;
}

// Get data from column with given name, if available
QString RadioAstronomyGUI::csvData(QHash<QString,int> hash, QStringList cols, QString col)
{
    QString s;
    if (hash.contains(col))
    {
        int idx = hash[col];
        if (idx < cols.size()) {
            s = cols[idx];
        }
    }
    return s;
}

bool RadioAstronomyGUI::hasNeededFFTData(QHash<QString,int> hash)
{
    return hash.contains("FFT Size") && hash.contains("Data");
}

// Write FFTMeasurement to a stream
void RadioAstronomyGUI::saveFFT(QTextStream& out, const FFTMeasurement* fft)
{
    out << fft->m_dateTime.toString();
    out << ",";
    out << fft->m_centerFrequency;
    out << ",";
    out << fft->m_sampleRate;
    out << ",";
    out << fft->m_integration;
    out << ",";
    out << fft->m_rfBandwidth;
    out << ",";
    out << fft->m_omegaA;
    out << ",";
    out << fft->m_omegaS;
    out << ",";
    out << fft->m_totalPower;
    out << ",";
    out << fft->m_totalPowerdBFS;
    out << ",";
    out << fft->m_totalPowerdBm;
    out << ",";
    out << fft->m_totalPowerWatts;
    out << ",";
    out << fft->m_tSys;
    out << ",";
    out << fft->m_tSys0;
    out << ",";
    out << fft->m_tSource;
    out << ",";
    out << fft->m_flux;
    out << ",";
    out << fft->m_sigmaT;
    out << ",";
    out << fft->m_sigmaS;
    out << ",";
    out << fft->m_tempMin;
    out << ",";
    out << fft->m_baseline;
    out << ",";
    out << fft->m_ra;
    out << ",";
    out << fft->m_dec;
    out << ",";
    out << fft->m_azimuth;
    out << ",";
    out << fft->m_elevation;
    out << ",";
    out << fft->m_l;
    out << ",";
    out << fft->m_b;
    out << ",";
    out << fft->m_vBCRS;
    out << ",";
    out << fft->m_vLSR;
    out << ",";
    out << fft->m_solarFlux;
    out << ",";
    out << fft->m_airTemp;
    out << ",";
    out << fft->m_skyTemp;
    out << ",";
    out << fft->m_sensor[0];
    out << ",";
    out << fft->m_sensor[1];
    out << ",";
    out << fft->m_fftSize;
    out << ",";
    for (int j = 0; j < fft->m_fftSize; j++)
    {
        out << fft->m_fftData[j];
        out << ",";
    }
    if (fft->m_snr)
    {
        for (int j = 0; j < fft->m_fftSize; j++)
        {
            out << fft->m_snr[j];
            out << ",";
        }
    }
    if (fft->m_temp)
    {
        for (int j = 0; j < fft->m_fftSize; j++)
        {
            out << fft->m_temp[j];
            out << ",";
        }
    }
    out << "\n";
}

// Create a FFTMeasurement from data read from CSV file
RadioAstronomyGUI::FFTMeasurement* RadioAstronomyGUI::loadFFT(QHash<QString,int> hash, QStringList cols)
{
    int fftSize = csvData(hash, cols, "FFT Size").toInt();
    int fftDataIdx = hash["Data"];
    if ((fftSize > 0) && (cols.size() >= fftDataIdx + fftSize))
    {
        FFTMeasurement* fft = new FFTMeasurement();
        fft->m_dateTime = QDateTime::fromString(csvData(hash, cols, "Date Time"));
        fft->m_centerFrequency = csvData(hash, cols, "Centre Freq").toLongLong();
        fft->m_sampleRate = csvData(hash, cols, "Sample Rate").toInt();
        fft->m_integration = csvData(hash, cols, "Integration").toInt();
        fft->m_rfBandwidth = csvData(hash, cols, "Bandwidth").toInt();
        fft->m_omegaA = csvData(hash, cols, "OmegaA").toFloat();
        fft->m_omegaS = csvData(hash, cols, "OmegaS").toFloat();

        fft->m_fftSize = fftSize;
        fft->m_fftData = new Real[fftSize];
        fft->m_db = new Real[fftSize];
        for (int i = 0; i < fftSize; i++)
        {
            fft->m_fftData[i] = cols[fftDataIdx+i].toFloat();
            fft->m_db[i] = (Real)CalcDb::dbPower(fft->m_fftData[i]);
        }
        if (cols.size() >= fftDataIdx + 2*fftSize)
        {
            fft->m_snr = new Real[fftSize];
            for (int i = 0; i < fftSize; i++) {
                fft->m_snr[i] = cols[fftDataIdx+fftSize+i].toFloat();
            }
            if (cols.size() >= fftDataIdx + 3*fftSize)
            {
                fft->m_temp = new Real[fftSize];
                for (int i = 0; i < fftSize; i++) {
                    fft->m_temp[i] = cols[fftDataIdx+2*fftSize+i].toFloat();
                }
            }
        }
        fft->m_totalPower = csvData(hash, cols, "Power (FFT)").toFloat();
        fft->m_totalPowerdBFS = csvData(hash, cols, "Power (dBFS)").toFloat();
        fft->m_totalPowerdBm = csvData(hash, cols, "Power (dBm)").toFloat();
        fft->m_totalPowerWatts = csvData(hash, cols, "Power (Watts)").toFloat();
        fft->m_tSys = csvData(hash, cols, "Tsys").toFloat();
        fft->m_tSys0 = csvData(hash, cols, "Tsys0").toFloat();
        fft->m_tSource = csvData(hash, cols, "Tsource").toFloat();
        fft->m_flux = csvData(hash, cols, "Sv").toFloat();
        fft->m_sigmaT = csvData(hash, cols, "SigmaTsys").toFloat();
        fft->m_sigmaS = csvData(hash, cols, "SigmaSsys").toFloat();
        fft->m_tempMin = csvData(hash, cols, "Min Temp").toFloat();
        fft->m_baseline = (RadioAstronomySettings::SpectrumBaseline)csvData(hash, cols, "Baseline").toInt();


        fft->m_ra = csvData(hash, cols, "RA").toFloat();
        fft->m_dec = csvData(hash, cols, "Dec").toFloat();
        fft->m_azimuth = csvData(hash, cols, "Azimuth").toFloat();
        fft->m_elevation = csvData(hash, cols, "Elevation").toFloat();
        fft->m_l = csvData(hash, cols, "l").toFloat();
        fft->m_b = csvData(hash, cols, "b").toFloat();
        if ((fft->m_ra != 0.0) || (fft->m_dec != 0.0) || (fft->m_azimuth != 0.0) || (fft->m_elevation != 0.0) || (fft->m_l != 0.0) || (fft->m_b != 0.0)) {
            fft->m_coordsValid = true;
        }
        fft->m_vBCRS = csvData(hash, cols, "vBCRS").toFloat();
        fft->m_vLSR = csvData(hash, cols, "vLSR").toFloat();
        fft->m_solarFlux = csvData(hash, cols, "Solar Flux").toFloat();
        fft->m_airTemp = csvData(hash, cols, "Air Temp").toFloat();
        fft->m_skyTemp = csvData(hash, cols, "Sky Temp").toFloat();
        fft->m_sensor[0] = csvData(hash, cols, "Sensor 1").toFloat();
        fft->m_sensor[1] = csvData(hash, cols, "Sensor 2").toFloat();

        if (fft->m_rfBandwidth == 0)
        {
            fft->m_rfBandwidth = 0.9 * fft->m_sampleRate; // Older files don't have this column and we need a value for min
            calcFFTTotalPower(fft);
            /*calcFFTMinTemperature(fft);
            calcFFTTotalTemperature(fft);*/
        }
        return fft;
    }
    else
    {
        return nullptr;
    }
}

void RadioAstronomyGUI::on_saveSpectrumData_clicked()
{
    // Get filename to save to
    QFileDialog fileDialog(nullptr, "Select file to save data to", "", "*.csv");
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    if (fileDialog.exec())
    {
        QStringList fileNames = fileDialog.selectedFiles();
        if (fileNames.size() > 0)
        {
            QFile file(fileNames[0]);
            if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                QMessageBox::critical(this, "Radio Astronomy", QString("Failed to open file %1").arg(fileNames[0]));
                return;
            }
            QTextStream out(&file);

            if (ui->spectrumChartSelect->currentIndex() == 0)
            {
                // Create a CSV file for all the spectrum data
                out << "Date Time,Centre Freq,Sample Rate,Integration,Bandwidth,OmegaA,OmegaS,Power (FFT),Power (dBFS),Power (dBm),Power (Watts),Tsys,Tsys0,Tsource,Sv,SigmaTsys,SigmaSsys,Min Temp,Baseline,RA,Dec,Azimuth,Elevation,l,b,vBCRS,vLSR,Solar Flux,Air Temp,Sky Temp,Sensor 1,Sensor 2,FFT Size,Data\n";
                for (int i = 0; i < m_fftMeasurements.size(); i++) {
                    saveFFT(out, m_fftMeasurements[i]);
                }
            }
            else
            {
                // Create a CSV file for calibration data
                out << "Cal,Cal Temp,Date Time,Centre Freq,Sample Rate,Integration,Bandwidth,OmegaA,OmegaS,Power (FFT),Power (dBFS),Power (dBm),Power (Watts),Tsys,Tsys0,Tsource,Sv,SigmaTsys,SigmaSsys,Min Temp,Baseline,RA,Dec,Azimuth,Elevation,l,b,vBCRS,vLSR,Solar Flux,Air Temp,Sky Temp,Sensor 1,Sensor 2,FFT Size,Data\n";
                if (m_calHot)
                {
                    out << "Hot,";
                    out << m_settings.m_tCalHot;
                    out << ",";
                    saveFFT(out, m_calHot);
                }
                if (m_calCold)
                {
                    out << "Cold,";
                    out << m_settings.m_tCalCold;
                    out << ",";
                    saveFFT(out, m_calCold);
                }
            }
        }
    }
}

void RadioAstronomyGUI::on_loadSpectrumData_clicked()
{
    // Get filename to load from
    QFileDialog fileDialog(nullptr, "Select file to load data from", "", "*.csv");
    fileDialog.setAcceptMode(QFileDialog::AcceptOpen);
    if (fileDialog.exec())
    {
        QStringList fileNames = fileDialog.selectedFiles();
        if (fileNames.size() > 0)
        {
            QFile file(fileNames[0]);
            if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                QMessageBox::critical(this, "Radio Astronomy", QString("Failed to open file %1").arg(fileNames[0]));
                return;
            }

            // Get column names
            QTextStream in(&file);
            QString header = in.readLine();
            QStringList colNames = header.split(",");
            QHash<QString,int> hash = csvHeadersToHash(colNames);

            if (ui->spectrumChartSelect->currentIndex() == 0)
            {
                // Load data from CSV file
                if (hasNeededFFTData(hash))
                {
                    // Remove old data - we could support multiple series for comparison
                    clearData();
                    // Read in FFT data from file
                    ui->spectrumIndex->blockSignals(true); // Prevent every spectrum from being displayed
                    while (!in.atEnd())
                    {
                        QString row = in.readLine();
                        QStringList cols = row.split(",");
                        FFTMeasurement* fft = loadFFT(hash, cols);
                        if (fft) {
                            addFFT(fft, true);
                        }
                    }
                    ui->spectrumIndex->blockSignals(false);
                    // Add data from FFT to sensor measurements
                    for (int i = 0; i < m_fftMeasurements.size(); i++)
                    {
                        SensorMeasurement* sm;
                        sm = new SensorMeasurement(m_fftMeasurements[i]->m_dateTime, m_fftMeasurements[i]->m_airTemp);
                        m_airTemps.append(sm);
                        for (int j = 0; j < RADIOASTRONOMY_SENSORS; j++)
                        {
                            sm = new SensorMeasurement(m_fftMeasurements[i]->m_dateTime, m_fftMeasurements[i]->m_sensor[j]);
                            m_sensors[j].append(sm);
                        }
                    }
                    // If we're loading data from scratch, autoscale both axis
                    if ((ui->spectrumCenterFreq->value() == 0.0) || m_settings.m_spectrumAutoscale)
                    {
                        on_spectrumAutoscaleY_clicked();
                        on_spectrumAutoscaleX_clicked();
                    }
                    // Ensure both charts are redrawn fully, as we've disabled some updates/calcs during load
                    on_spectrumIndex_valueChanged(m_fftMeasurements.size() - 1);   // Don't call setValue, as it already has this value
                    plotPowerChart();
                    // As signals were blocked above, power axis may not match up with GUI. Manually update
                    // Just calling autoscale will not work, as the GUI values may not change
                    on_powerStartTime_dateTimeChanged(ui->powerStartTime->dateTime());
                    on_powerEndTime_dateTimeChanged(ui->powerEndTime->dateTime());
                    on_powerRange_valueChanged(m_settings.m_powerRange);
                    on_powerReference_valueChanged(m_settings.m_powerReference);
                }
            }
            else
            {
                // Load calibration data from CSV file
                if (hasNeededFFTData(hash) && hash.contains("Cal"))
                {
                    while (!in.atEnd())
                    {
                        QString row = in.readLine();
                        QStringList cols = row.split(",");

                        QString calName = csvData(hash, cols, "Cal");

                        FFTMeasurement** calp = nullptr;
                        FFTMeasurement* cal = nullptr;
                        if (calName == "Hot") {
                            calp = &m_calHot;
                        } else if (calName == "Cold") {
                            calp = &m_calCold;
                        } else {
                            qDebug() << "RadioAstronomyGUI::on_loadSpectrumData_clicked: Skipping unknown calibration " << calName;
                        }
                        if (calp)
                        {
                            cal = loadFFT(hash, cols);
                            if (cal)
                            {
                                delete *calp;
                                *calp = cal;
                                qDebug() << "RadioAstronomyGUI::on_loadSpectrumData_clicked: Loaded calibration " << calName;
                                if (calName == "Cold") {
                                    ui->calTsky->setText(QString::number(cal->m_skyTemp, 'f', 1));
                                }
                                QString calTempString = csvData(hash, cols, "Cal Temp");
                                bool ok;
                                double calTemp = calTempString.toDouble(&ok);
                                if (ok)
                                {
                                    if (calName == "Cold")
                                    {
                                        ui->tCalColdSelect->setCurrentIndex(0);
                                        ui->tCalCold->setValue(calTemp);
                                    }
                                    else
                                    {
                                        ui->tCalHotSelect->setCurrentIndex(0);
                                        ui->tCalHot->setValue(calTemp);
                                    }
                                }
                            }
                        }
                    }
                    calcCalAvgDiff();
                    calibrate();
                    plotCalMeasurements();
                }
                else
                {
                    QMessageBox::critical(this, "Radio Astronomy", QString("Missing required columns in file %1").arg(fileNames[0]));
                    return;
                }
            }
        }
    }
}

void RadioAstronomyGUI::on_powerTable_cellDoubleClicked(int row, int column)
{
    if ((column >= POWER_COL_RA) && (column <= POWER_COL_EL))
    {
        // Display target in Star Tracker
        QList<ObjectPipe*> starTrackerPipes;
        MainCore::instance()->getMessagePipes().getMessagePipes(m_radioAstronomy, "startracker.display", starTrackerPipes);

        for (const auto& pipe : starTrackerPipes)
        {
            MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
            SWGSDRangel::SWGStarTrackerDisplaySettings *swgSettings = new SWGSDRangel::SWGStarTrackerDisplaySettings();
            QDateTime dt(ui->powerTable->item(row, POWER_COL_DATE)->data(Qt::DisplayRole).toDate(),
                            ui->powerTable->item(row, POWER_COL_TIME)->data(Qt::DisplayRole).toTime());
            swgSettings->setDateTime(new QString(dt.toString(Qt::ISODateWithMs)));
            swgSettings->setAzimuth(ui->powerTable->item(row, POWER_COL_AZ)->data(Qt::DisplayRole).toFloat());
            swgSettings->setElevation(ui->powerTable->item(row, POWER_COL_EL)->data(Qt::DisplayRole).toFloat());
            messageQueue->push(MainCore::MsgStarTrackerDisplaySettings::create(m_radioAstronomy, swgSettings));
        }
    }
    else
    {
        // Display in Spectrometer
        ui->spectrumIndex->setValue(row);
    }
}

void RadioAstronomyGUI::onWidgetRolled(QWidget* widget, bool rollDown)
{
    (void) widget;
    (void) rollDown;

    getRollupContents()->saveState(m_rollupState);
    applySettings();
}

void RadioAstronomyGUI::onMenuDialogCalled(const QPoint &p)
{
    if (m_contextMenuType == ContextMenuType::ContextMenuChannelSettings)
    {
        BasicChannelSettingsDialog dialog(&m_channelMarker, this);
        dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
        dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
        dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
        dialog.setReverseAPIDeviceIndex(m_settings.m_reverseAPIDeviceIndex);
        dialog.setReverseAPIChannelIndex(m_settings.m_reverseAPIChannelIndex);
        dialog.setDefaultTitle(m_displayedName);

        if (m_deviceUISet->m_deviceMIMOEngine)
        {
            dialog.setNumberOfStreams(m_radioAstronomy->getNumberOfDeviceStreams());
            dialog.setStreamIndex(m_settings.m_streamIndex);
        }

        dialog.move(p);
        new DialogPositioner(&dialog, false);
        dialog.exec();

        m_settings.m_rgbColor = m_channelMarker.getColor().rgb();
        m_settings.m_title = m_channelMarker.getTitle();
        m_settings.m_useReverseAPI = dialog.useReverseAPI();
        m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
        m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
        m_settings.m_reverseAPIDeviceIndex = dialog.getReverseAPIDeviceIndex();
        m_settings.m_reverseAPIChannelIndex = dialog.getReverseAPIChannelIndex();

        setWindowTitle(m_settings.m_title);
        setTitle(m_channelMarker.getTitle());
        setTitleColor(m_settings.m_rgbColor);

        if (m_deviceUISet->m_deviceMIMOEngine)
        {
            m_settings.m_streamIndex = dialog.getSelectedStreamIndex();
            m_channelMarker.clearStreamIndexes();
            m_channelMarker.addStreamIndex(m_settings.m_streamIndex);
            updateIndexLabel();
        }

        applySettings();
    }

    resetContextMenuType();
}

RadioAstronomyGUI::RadioAstronomyGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampleSink *rxChannel, QWidget* parent) :
    ChannelGUI(parent),
    ui(new Ui::RadioAstronomyGUI),
    m_pluginAPI(pluginAPI),
    m_deviceUISet(deviceUISet),
    m_channelMarker(this),
    m_doApplySettings(true),
    m_basebandSampleRate(0),
    m_centerFrequency(0),
    m_tickCount(0),
    m_powerChart(nullptr),
    m_powerSeries(nullptr),
    m_powerXAxis(nullptr),
    m_powerYAxis(nullptr),
    m_powerPeakSeries(nullptr),
    m_powerMarkerSeries(nullptr),
    m_powerTsys0Series(nullptr),
    m_powerGaussianSeries(nullptr),
    m_powerFilteredSeries(nullptr),
    m_powerPeakValid(false),
    m_2DChart(nullptr),
    m_2DXAxis(nullptr),
    m_2DYAxis(nullptr),
    m_2DMapIntensity(nullptr),
    m_sweepIndex(0),
    m_calChart(nullptr),
    m_calXAxis(nullptr),
    m_calYAxis(nullptr),
    m_calHotSeries(nullptr),
    m_calColdSeries(nullptr),
    m_calHot(nullptr),
    m_calCold(nullptr),
    m_calG(nullptr),
    m_fftChart(nullptr),
    m_fftSeries(nullptr),
    m_fftHlineSeries(nullptr),
    m_fftPeakSeries(nullptr),
    m_fftMarkerSeries(nullptr),
    m_fftGaussianSeries(nullptr),
    m_fftLABSeries(nullptr),
    m_fftXAxis(nullptr),
    m_fftYAxis(nullptr),
    m_fftDopplerAxis(nullptr),
    m_powerM1Valid(false),
    m_powerM2Valid(false),
    m_spectrumM1Valid(false),
    m_spectrumM2Valid(false),
    m_coordsValid(false),
    m_ra(0.0f),
    m_dec(0.0f),
    m_azimuth(0.0f),
    m_elevation(0.0f),
    m_l(0.0f),
    m_b(0.0f),
    m_vBCRS(0.0f),
    m_vLSR(0.0f),
    m_solarFlux(0.0f),
    m_beamWidth(5.6f),
    m_lLAB(0.0f),
    m_bLAB(0.0f),
    m_downloadingLAB(false),
    m_window(nullptr),
    m_windowSorted(nullptr),
    m_windowIdx(0),
    m_windowCount(0)
{
    qDebug("RadioAstronomyGUI::RadioAstronomyGUI");
    setAttribute(Qt::WA_DeleteOnClose, true);
    m_helpURL = "plugins/channelrx/radioastronomy/readme.md";
    RollupContents *rollupContents = getRollupContents();
	ui->setupUi(rollupContents);
    setSizePolicy(rollupContents->sizePolicy());
    rollupContents->arrangeRollups();
	connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
    connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));

    m_radioAstronomy = reinterpret_cast<RadioAstronomy*>(rxChannel);
    m_radioAstronomy->setMessageQueueToGUI(getInputMessageQueue());

    connect(&MainCore::instance()->getMasterTimer(), SIGNAL(timeout()), this, SLOT(tick())); // 50 ms

    m_networkManager = new QNetworkAccessManager();
    QObject::connect(
        m_networkManager,
        &QNetworkAccessManager::finished,
        this,
        &RadioAstronomyGUI::networkManagerFinished
    );
    connect(&m_dlm, &HttpDownloadManager::downloadComplete, this, &RadioAstronomyGUI::downloadFinished);

    ui->deltaFrequencyLabel->setText(QString("%1f").arg(QChar(0x94, 0x03)));
    ui->deltaFrequency->setColorMapper(ColorMapper(ColorMapper::GrayGold));
    ui->deltaFrequency->setValueRange(false, 7, -9999999, 9999999);

    // Need to setValue before calling setValueRange, otherwise valueChanged is called
    // overwriting the default settings (could also blockSignals)
    // Also, set bandwidth before sampleRate
    ui->rfBW->setColorMapper(ColorMapper(ColorMapper::GrayGold));
    ui->rfBW->setValue(m_settings.m_rfBandwidth);
    ui->rfBW->setValueRange(true, 8, 100, 99999999);
    ui->sampleRate->setColorMapper(ColorMapper(ColorMapper::GrayGold));
    ui->sampleRate->setValue(m_settings.m_sampleRate);
    ui->sampleRate->setValueRange(true, 8, 1000, 99999999);
    ui->integration->setColorMapper(ColorMapper(ColorMapper::GrayGold));
    ui->integration->setValue(m_settings.m_integration);
    ui->integration->setValueRange(true, 7, 1, 99999999);

    m_channelMarker.blockSignals(true);
    m_channelMarker.setColor(Qt::yellow);
    m_channelMarker.setBandwidth(m_settings.m_rfBandwidth);
    m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
    m_channelMarker.setTitle("Radio Astronomy");
    m_channelMarker.blockSignals(false);
    m_channelMarker.setVisible(true); // activate signal on the last setting only

    setTitleColor(m_channelMarker.getColor());
    m_settings.setChannelMarker(&m_channelMarker);
    m_settings.setRollupState(&m_rollupState);

    m_deviceUISet->addChannelMarker(&m_channelMarker);

    connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
    connect(&m_channelMarker, SIGNAL(highlightedByCursor()), this, SLOT(channelMarkerHighlightedByCursor()));
    connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));

    // Resize the table using dummy data
    resizePowerTable();
    // Allow user to reorder columns
    ui->powerTable->horizontalHeader()->setSectionsMovable(true);
    // Allow user to sort table by clicking on headers
    ui->powerTable->setSortingEnabled(true);
    // Add context menu to allow hiding/showing of columns
    powerTableMenu = new QMenu(ui->powerTable);
    for (int i = 0; i < ui->powerTable->horizontalHeader()->count(); i++)
    {
        QString text = ui->powerTable->horizontalHeaderItem(i)->text();
        powerTableMenu->addAction(createCheckableItem(text, i, true, SLOT(powerTableColumnSelectMenuChecked())));
    }
    ui->powerTable->horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->powerTable->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(powerTableColumnSelectMenu(QPoint)));
    // Get signals when columns change
    connect(ui->powerTable->horizontalHeader(), SIGNAL(sectionMoved(int, int, int)), SLOT(powerTable_sectionMoved(int, int, int)));
    connect(ui->powerTable->horizontalHeader(), SIGNAL(sectionResized(int, int, int)), SLOT(powerTable_sectionResized(int, int, int)));
    ui->powerTable->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(ui->powerTable, SIGNAL(customContextMenuRequested(QPoint)), SLOT(customContextMenuRequested(QPoint)));

    ui->powerTable->setItemDelegateForColumn(POWER_COL_TIME, new TimeDelegate("hh:mm:ss", ui->powerTable));
    //ui->powerTable->setItemDelegateForColumn(POWER_COL_POWER, new DecimalDelegate(6, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_POWER_DB, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_POWER_DBM, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_TSYS, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_TSYS0, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_TSOURCE, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_TB, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_TSKY, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_FLUX, new DecimalDelegate(2, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_SIGMA_T, new DecimalDelegate(2, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_SIGMA_S, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_RA, new HMSDelegate(ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_DEC, new DMSDelegate(ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_GAL_LAT, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_GAL_LON, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_AZ, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_EL, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_VBCRS, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_VLSR, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_AIR_TEMP, new DecimalDelegate(1, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_ROT_AZ, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_ROT_EL, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_ROT_AZ_OFF, new DecimalDelegate(0, ui->powerTable));
    ui->powerTable->setItemDelegateForColumn(POWER_COL_ROT_EL_OFF, new DecimalDelegate(0, ui->powerTable));

    resizeSpectrumMarkerTable();
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_FREQ, new DecimalDelegate(6, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_VALUE, new DecimalDelegate(1, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_DELTA_X, new DecimalDelegate(6, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_DELTA_Y, new DecimalDelegate(1, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_VR, new DecimalDelegate(2, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_R, new DecimalDelegate(1, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_D, new DecimalDelegate(1, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_R_MIN, new DecimalDelegate(1, ui->spectrumMarkerTable));
    ui->spectrumMarkerTable->setItemDelegateForColumn(SPECTRUM_MARKER_COL_V, new DecimalDelegate(1, ui->spectrumMarkerTable));

    // Create blank marker table
    ui->spectrumMarkerTable->setRowCount(SPECTRUM_MARKER_ROWS); // 1 peak and two markers
    for (int row = 0; row < SPECTRUM_MARKER_ROWS; row++)
    {
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_NAME, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_FREQ, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_VALUE, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_X, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_Y, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_DELTA_TO, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_VR, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_R, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_D, new QTableWidgetItem());
        // It seems clearing Qt::ItemIsUserCheckable doesn't remove the checkbox, so once set, we always have it
        QTableWidgetItem* item = new QTableWidgetItem();
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        item->setCheckState(Qt::Unchecked);
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_PLOT_MAX, item);
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_R_MIN, new QTableWidgetItem());
        ui->spectrumMarkerTable->setItem(row, SPECTRUM_MARKER_COL_V, new QTableWidgetItem());
    }
    ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_PEAK, SPECTRUM_MARKER_COL_NAME)->setText("Max");
    ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M1, SPECTRUM_MARKER_COL_NAME)->setText("M1");
    ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_NAME)->setText("M2");
    connect(ui->spectrumMarkerTable, &QTableWidget::itemChanged, this, &RadioAstronomyGUI::spectrumMarkerTableItemChanged);

    resizePowerMarkerTable();
    ui->powerMarkerTable->setItemDelegateForColumn(POWER_MARKER_COL_TIME, new TimeDelegate("hh:mm:ss", ui->powerMarkerTable));
    ui->powerMarkerTable->setItemDelegateForColumn(POWER_MARKER_COL_VALUE, new DecimalDelegate(1, ui->powerMarkerTable));
    ui->powerMarkerTable->setItemDelegateForColumn(POWER_MARKER_COL_DELTA_X, new TimeDeltaDelegate(ui->powerMarkerTable));
    ui->powerMarkerTable->setItemDelegateForColumn(POWER_MARKER_COL_DELTA_Y, new DecimalDelegate(1, ui->powerMarkerTable));

    // Create blank marker table
    ui->powerMarkerTable->setRowCount(POWER_MARKER_ROWS); // 1 peak and two markers
    for (int row = 0; row < POWER_MARKER_ROWS; row++)
    {
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_NAME, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DATE, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_TIME, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_VALUE, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_X, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_Y, new QTableWidgetItem());
        ui->powerMarkerTable->setItem(row, POWER_MARKER_COL_DELTA_TO, new QTableWidgetItem());
    }
    ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MAX, POWER_MARKER_COL_NAME)->setText("Max");
    ui->powerMarkerTable->item(POWER_MARKER_ROW_PEAK_MIN, POWER_MARKER_COL_NAME)->setText("Min");
    ui->powerMarkerTable->item(POWER_MARKER_ROW_M1, POWER_MARKER_COL_NAME)->setText("M1");
    ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_NAME)->setText("M2");

    ui->sweepStartDateTime->setMinimumDateTime(QDateTime::currentDateTime());
    ui->spectrumDateTime->setDateTime(QDateTime::currentDateTime());

    ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");

    displaySettings();
    makeUIConnections();
    applySettings(true);
    m_resizer.enableChildMouseTracking();

    create2DImage();

    plotCalSpectrum();
    plotSpectrum();
    plotPowerChart();

    m_radioAstronomy->getInputMessageQueue()->push(RadioAstronomy::MsgScanAvailableFeatures::create());
}

void RadioAstronomyGUI::customContextMenuRequested(QPoint pos)
{
    QTableWidgetItem *item = ui->powerTable->itemAt(pos);
    if (item)
    {
        QMenu* tableContextMenu = new QMenu(ui->powerTable);
        connect(tableContextMenu, &QMenu::aboutToHide, tableContextMenu, &QMenu::deleteLater);

        // Copy cell contents to clipboard
        QAction* copyAction = new QAction("Copy cell", tableContextMenu);
        const QString text = item->text();
        connect(copyAction, &QAction::triggered, this, [text]()->void {
            QClipboard *clipboard = QGuiApplication::clipboard();
            clipboard->setText(text);
        });
        tableContextMenu->addAction(copyAction);

        // Delete selected rows
        QAction* delAction = new QAction("Delete rows", tableContextMenu);
        connect(delAction, &QAction::triggered, this, [this]()->void {
            QModelIndexList rowIndexes = ui->powerTable->selectionModel()->selectedRows();
            if (rowIndexes.size() > 0)
            {
                // Delete in reverse row order
                std::vector<int> rows;
                foreach (auto rowIndex, rowIndexes) {
                    rows.push_back(rowIndex.row());
                }
                std::sort(rows.begin(), rows.end(), std::greater<int>());
                bool deletedCurrent = false;
                int next;
                foreach (auto row, rows) {
                    next = row - 1;
                    if (deleteRow(row)) {
                        deletedCurrent = true;
                    }
                }
                deleteRowsComplete(deletedCurrent, next);
            }
        });
        tableContextMenu->addAction(delAction);

        // Update rows with new Tsys0 and baseline
        QAction* updateTSysAction = new QAction(QString("Update Tsys0 / baseline / %1").arg(QChar(937)), tableContextMenu);
        connect(updateTSysAction, &QAction::triggered, this, [this]()->void {
            QModelIndexList rowIndexes = ui->powerTable->selectionModel()->selectedRows();
            if (rowIndexes.size() > 0)
            {
                foreach (auto rowIndex, rowIndexes)
                {
                    int row = rowIndex.row();
                    m_fftMeasurements[row]->m_tSys0 = calcTSys0();
                    m_fftMeasurements[row]->m_baseline = m_settings.m_spectrumBaseline;
                    m_fftMeasurements[row]->m_omegaA = calcOmegaA();
                    m_fftMeasurements[row]->m_omegaS = calcOmegaS();
                    calcFFTTotalTemperature(m_fftMeasurements[row]);
                    updatePowerColumns(row, m_fftMeasurements[row]);
                }
                plotFFTMeasurement();
            }
        });
        tableContextMenu->addAction(updateTSysAction);

        tableContextMenu->popup(ui->powerTable->viewport()->mapToGlobal(pos));
    }
}

RadioAstronomyGUI::~RadioAstronomyGUI()
{
    delete m_networkManager;
    delete ui;
    delete m_calHot;
    delete m_calCold;
    qDeleteAll(m_dataLAB);
    m_dataLAB.clear();
    delete[] m_2DMapIntensity;
    delete[] m_window;
    delete[] m_windowSorted;
}

void RadioAstronomyGUI::blockApplySettings(bool block)
{
    m_doApplySettings = !block;
}

void RadioAstronomyGUI::applySettings(bool force)
{
    if (m_doApplySettings)
    {
        RadioAstronomy::MsgConfigureRadioAstronomy* message = RadioAstronomy::MsgConfigureRadioAstronomy::create( m_settings, force);
        m_radioAstronomy->getInputMessageQueue()->push(message);
    }
}

int RadioAstronomyGUI::fftSizeToIndex(int size)
{
    switch (size)
    {
    case 16:
        return 0;
    case 32:
        return 1;
    case 64:
        return 2;
    case 128:
        return 3;
    case 256:
        return 4;
    case 512:
        return 5;
    case 1024:
        return 6;
    case 2048:
        return 7;
    case 4096:
        return 8;
    }
    return 0;
}

void RadioAstronomyGUI::displaySettings()
{
    m_channelMarker.blockSignals(true);
    m_channelMarker.setBandwidth(m_settings.m_rfBandwidth);
    m_channelMarker.setCenterFrequency(m_settings.m_inputFrequencyOffset);
    m_channelMarker.setTitle(m_settings.m_title);
    m_channelMarker.blockSignals(false);
    m_channelMarker.setColor(m_settings.m_rgbColor); // activate signal on the last setting only

    setTitleColor(m_settings.m_rgbColor);
    setWindowTitle(m_channelMarker.getTitle());
    setTitle(m_channelMarker.getTitle());

    blockApplySettings(true);
    ui->deltaFrequency->setValue(m_channelMarker.getCenterFrequency());
    float rfBW = m_settings.m_rfBandwidth; // Save value, as it may be corrupted when setting sampleRate
    ui->sampleRate->setValue(m_settings.m_sampleRate);
    ui->rfBW->setValue(rfBW);
    updateBWLimits();

    ui->integration->setValue(m_settings.m_integration);
    ui->fftSize->setCurrentIndex(fftSizeToIndex(m_settings.m_fftSize));
    ui->fftWindow->setCurrentIndex((int)m_settings.m_fftWindow);
    ui->filterFreqs->setText(m_settings.m_filterFreqs);

    int idx = ui->starTracker->findText(m_settings.m_starTracker);
    if (idx != -1) {
        ui->starTracker->setCurrentIndex(idx);
    }
    idx = ui->rotator->findText(m_settings.m_rotator);
    if (idx != -1) {
        ui->rotator->setCurrentIndex(idx);
    }

    ui->tempRXSelect->setCurrentIndex(0);
    ui->tempRX->setValue(m_settings.m_tempRX);
    ui->tempRXUnitsLabel->setText("K");
    ui->tempCMB->setValue(m_settings.m_tempCMB);
    ui->tempGal->setValue(m_settings.m_tempGal);
    ui->tempGal->setEnabled(!m_settings.m_tempGalLink);
    ui->tempGalLink->setChecked(m_settings.m_tempGalLink);
    ui->tempSP->setValue(m_settings.m_tempSP);
    ui->tempAtm->setValue(m_settings.m_tempAtm);
    ui->tempAtm->setEnabled(!m_settings.m_tempAtmLink);
    ui->tempAtmLink->setChecked(m_settings.m_tempAtmLink);
    ui->tempAir->setValue(m_settings.m_tempAir);
    ui->tempAir->setEnabled(!m_settings.m_tempAirLink);
    ui->tempAirLink->setChecked(m_settings.m_tempAirLink);
    ui->zenithOpacity->setValue(m_settings.m_zenithOpacity);
    ui->elevation->setValue(m_settings.m_elevation);
    ui->elevation->setEnabled(!m_settings.m_elevationLink);
    ui->elevationLink->setChecked(m_settings.m_elevationLink);

    ui->gainVariation->setValue(m_settings.m_gainVariation);
    ui->sourceType->setCurrentIndex((int)m_settings.m_sourceType);
    ui->omegaS->setValue(m_settings.m_omegaS);
    ui->omegaSUnits->setCurrentIndex((int)m_settings.m_omegaSUnits);
    ui->omegaAUnits->setCurrentIndex((int)m_settings.m_omegaAUnits);

    ui->recalibrate->setChecked(m_settings.m_recalibrate);
    ui->tCalHot->setValue(m_settings.m_tCalHot);
    ui->tCalCold->setValue(m_settings.m_tCalCold);

    ui->spectrumAutoscale->setChecked(m_settings.m_spectrumAutoscale);
    ui->spectrumReference->setValue(m_settings.m_spectrumReference);
    ui->spectrumRange->setValue(m_settings.m_spectrumRange);
    FFTMeasurement* fft = currentFFT();
    if (fft) {
        ui->spectrumCenterFreq->setValue(fft->m_centerFrequency/1e6 + m_settings.m_spectrumCenterFreqOffset);
    } else {
        ui->spectrumCenterFreq->setValue(m_centerFrequency/1e6 + m_settings.m_spectrumCenterFreqOffset);
    }
    ui->spectrumSpan->setValue(m_settings.m_spectrumSpan);
    ui->spectrumYUnits->setCurrentIndex((int)m_settings.m_spectrumYScale);
    ui->spectrumBaseline->setCurrentIndex((int)m_settings.m_spectrumBaseline);
    ui->spectrumAutoscaleX->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumAutoscaleY->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumReference->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumRange->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumCenterFreq->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumSpan->setEnabled(!m_settings.m_spectrumAutoscale);

    ui->powerAutoscale->setChecked(m_settings.m_powerAutoscale);
    ui->powerReference->setValue(m_settings.m_powerReference);
    ui->powerRange->setValue(m_settings.m_powerRange);
    ui->powerShowPeak->setChecked(m_settings.m_powerPeaks);
    if (m_powerPeakSeries)
    {
        m_powerPeakSeries->setVisible(m_settings.m_powerPeaks);
        m_powerChart->legend()->markers(m_powerPeakSeries)[0]->setVisible(false);
    }
    ui->powerShowMarker->setChecked(m_settings.m_powerMarkers);
    if (m_powerMarkerSeries)
    {
        m_powerMarkerSeries->setVisible(m_settings.m_powerMarkers);
        m_powerChart->legend()->markers(m_powerMarkerSeries)[0]->setVisible(false);
    }
    ui->powerShowAvg->setChecked(m_settings.m_powerAvg);
    ui->powerChartAvgWidgets->setVisible(m_settings.m_powerAvg);
    ui->powerShowGaussian->setChecked(m_settings.m_powerShowGaussian);
    ui->powerGaussianWidgets->setVisible(m_settings.m_powerShowGaussian);
    if (m_powerGaussianSeries) {
        m_powerGaussianSeries->setVisible(m_settings.m_powerShowGaussian);
    }
    ui->powerShowLegend->setChecked(m_settings.m_powerLegend);
    if (m_powerChart) {
        m_powerChart->legend()->setVisible(m_settings.m_powerLegend);
    }
    ui->powerChartSelect->setCurrentIndex((int)m_settings.m_powerYData);
    ui->powerYUnits->setCurrentIndex(powerYUnitsToIndex(m_settings.m_powerYUnits));
    ui->powerShowTsys0->setChecked(m_settings.m_powerShowTsys0);
    ui->powerShowAirTemp->setChecked(m_settings.m_powerShowAirTemp);
    m_airTemps.clicked(m_settings.m_powerShowAirTemp);
    ui->powerShowSensor1->setChecked(m_settings.m_sensorVisible[0]);
    m_sensors[0].setName(m_settings.m_sensorName[0]);
    m_sensors[0].clicked(m_settings.m_sensorVisible[0]);
    ui->powerShowSensor2->setChecked(m_settings.m_sensorVisible[1]);
    m_sensors[1].setName(m_settings.m_sensorName[1]);
    m_sensors[1].clicked(m_settings.m_sensorVisible[1]);
    ui->powerShowFiltered->setChecked(m_settings.m_powerShowFiltered);
    if (m_powerFilteredSeries) {
        m_powerFilteredSeries->setVisible(m_settings.m_powerShowFiltered);
    }
    ui->powerFilterWidgets->setVisible(m_settings.m_powerShowFiltered);
    ui->powerFilter->setCurrentIndex((int)m_settings.m_powerFilter);
    ui->powerFilterN->setValue(m_settings.m_powerFilterN);
    ui->powerShowMeasurement->setChecked(m_settings.m_powerShowMeasurement);
    if (m_powerSeries) {
        m_powerSeries->setVisible(m_settings.m_powerShowMeasurement);
    }

    ui->power2DLinkSweep->setChecked(m_settings.m_power2DLinkSweep);
    ui->power2DSweepType->setCurrentIndex((int)m_settings.m_power2DSweepType);
    ui->power2DWidth->setValue(m_settings.m_power2DWidth);
    ui->power2DHeight->setValue(m_settings.m_power2DHeight);
    ui->power2DXMin->setValue(m_settings.m_power2DXMin);
    ui->power2DXMax->setValue(m_settings.m_power2DXMax);
    ui->power2DYMin->setValue(m_settings.m_power2DYMin);
    ui->power2DYMax->setValue(m_settings.m_power2DYMax);
    ui->powerColourAutoscale->setChecked(m_settings.m_powerColourAutoscale);
    ui->powerColourScaleMin->setValue(m_settings.m_powerColourScaleMin);
    ui->powerColourScaleMin->setEnabled(!m_settings.m_powerColourAutoscale);
    ui->powerColourScaleMax->setValue(m_settings.m_powerColourScaleMax);
    ui->powerColourScaleMax->setEnabled(!m_settings.m_powerColourAutoscale);
    ui->powerColourPalette->setCurrentIndex(ui->powerColourPalette->findText(m_settings.m_powerColourPalette));

    ui->spectrumReverseXAxis->setChecked(m_settings.m_spectrumReverseXAxis);
    ui->spectrumPeak->setChecked(m_settings.m_spectrumPeaks);
    ui->spectrumMarker->setChecked(m_settings.m_spectrumMarkers);
    ui->spectrumTemp->setChecked(m_settings.m_spectrumTemp);
    if (m_fftGaussianSeries) {
        m_fftGaussianSeries->setVisible(m_settings.m_spectrumTemp);
    }
    ui->spectrumShowRefLine->setChecked(m_settings.m_spectrumRefLine);
    if (m_fftHlineSeries)
    {
        m_fftHlineSeries->setVisible(m_settings.m_spectrumRefLine);
        m_fftDopplerAxis->setVisible(m_settings.m_spectrumRefLine);
    }
    ui->spectrumShowLAB->setChecked(m_settings.m_spectrumLAB);
    if (m_fftLABSeries) {
        m_fftLABSeries->setVisible(m_settings.m_spectrumLAB);
    }
    ui->spectrumShowDistance->setChecked(m_settings.m_spectrumDistance);
    updateDistanceColumns();
    ui->spectrumShowLegend->setChecked(m_settings.m_spectrumLegend);
    if (m_fftChart) {
        m_fftChart->legend()->setVisible(m_settings.m_spectrumLegend);
    }
    if (m_calChart) {
        m_calChart->legend()->setVisible(m_settings.m_spectrumLegend);
    }


    ui->refFrame->setCurrentIndex((int)m_settings.m_refFrame);
    ui->spectrumLine->setCurrentIndex((int)m_settings.m_line);
    ui->sunDistanceToGC->setValue(m_settings.m_sunDistanceToGC);
    ui->sunOrbitalVelocity->setValue(m_settings.m_sunOrbitalVelocity);
    displaySpectrumLineFrequency();
    updateSpectrumSelect();
    updatePowerSelect();

    // Updates visibility of widgets
    updateSpectrumMarkerTableVisibility();
    updatePowerMarkerTableVisibility();
    updatePowerChartWidgetsVisibility();
    updateSpectrumChartWidgetsVisibility();

    updateIntegrationTime();

    ui->runMode->setCurrentIndex((int)m_settings.m_runMode);
    ui->sweepStartAtTime->setCurrentIndex(m_settings.m_sweepStartAtTime ? 1 : 0);
    ui->sweepStartDateTime->setDateTime(m_settings.m_sweepStartDateTime);
    ui->sweepStartDateTime->setVisible(m_settings.m_sweepStartAtTime);
    ui->sweepType->setCurrentIndex((int)m_settings.m_sweepType);
    ui->sweep1Start->setValue(m_settings.m_sweep1Start);
    ui->sweep1Stop->setValue(m_settings.m_sweep1Stop);
    ui->sweep1Step->setValue(m_settings.m_sweep1Step);
    ui->sweep1Delay->setValue(m_settings.m_sweep1Delay);
    ui->sweep2Start->setValue(m_settings.m_sweep2Start);
    ui->sweep2Stop->setValue(m_settings.m_sweep2Stop);
    ui->sweep2Step->setValue(m_settings.m_sweep2Step);
    ui->sweep2Delay->setValue(m_settings.m_sweep2Delay);
    displayRunModeSettings();

    updateIndexLabel();

    // Order and size columns
    QHeaderView *header = ui->powerTable->horizontalHeader();
    for (int i = 0; i < RADIOASTRONOMY_POWERTABLE_COLUMNS; i++)
    {
        bool hidden = m_settings.m_powerTableColumnSizes[i] == 0;
        header->setSectionHidden(i, hidden);
        powerTableMenu->actions().at(i)->setChecked(!hidden);
        if (m_settings.m_powerTableColumnSizes[i] > 0)
            ui->powerTable->setColumnWidth(i, m_settings.m_powerTableColumnSizes[i]);
        header->moveSection(header->visualIndex(i), m_settings.m_powerTableColumnIndexes[i]);
    }

    getRollupContents()->restoreState(m_rollupState);
    updateAbsoluteCenterFrequency();
    blockApplySettings(false);
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::leaveEvent(QEvent* event)
{
    m_channelMarker.setHighlighted(false);
    ChannelGUI::leaveEvent(event);
}

void RadioAstronomyGUI::enterEvent(EnterEventType* event)
{
    m_channelMarker.setHighlighted(true);
    ChannelGUI::enterEvent(event);
}

void RadioAstronomyGUI::tick()
{
    double magsqAvg, magsqPeak;
    int nbMagsqSamples;
    m_radioAstronomy->getMagSqLevels(magsqAvg, magsqPeak, nbMagsqSamples);
    double powDbAvg = CalcDb::dbPower(magsqAvg);

    if (m_tickCount % 4 == 0) {
        ui->channelPower->setText(QString::number(powDbAvg, 'f', 1));
    }

    m_tickCount++;
}

void RadioAstronomyGUI::updateRotatorList(const AvailableChannelOrFeatureList& rotators, const QStringList& renameFrom, const QStringList& renameTo)
{
    // Update rotator setting if it has been renamed
    if (renameFrom.contains(m_settings.m_rotator))
    {
        m_settings.m_rotator = renameTo[renameFrom.indexOf(m_settings.m_rotator)];
        applySettings();
    }

    // Update list of rotators
    ui->rotator->blockSignals(true);
    ui->rotator->clear();
    ui->rotator->addItem("None");

    for (const auto& rotator : rotators) {
        ui->rotator->addItem(rotator.getLongId());
    }

    // Rotator feature can be created after this plugin, so select it
    // if the chosen rotator appears
    int rotatorIndex = ui->rotator->findText(m_settings.m_rotator);

    if (rotatorIndex >= 0)
    {
        ui->rotator->setCurrentIndex(rotatorIndex);
        setColumnPrecisionFromRotator();
    }
    else
    {
        ui->rotator->setCurrentIndex(0); // return to None
    }

    ui->rotator->blockSignals(false);
}

void RadioAstronomyGUI::on_fftSize_currentIndexChanged(int index)
{
    m_settings.m_fftSize = 1 << (4+index);
    applySettings();
    updateIntegrationTime();
}

void RadioAstronomyGUI::on_fftWindow_currentIndexChanged(int index)
{
    m_settings.m_fftWindow = (RadioAstronomySettings::FFTWindow)index;
    applySettings();
}

void RadioAstronomyGUI::on_filterFreqs_editingFinished()
{
    m_settings.m_filterFreqs = ui->filterFreqs->text();
    applySettings();
}

void RadioAstronomyGUI::on_gainVariation_valueChanged(double value)
{
    m_settings.m_gainVariation = value;
    applySettings();
    updateTSys0();
}

// Can we allow user to enter text that is automatically looked up on SIMBAD?
void RadioAstronomyGUI::on_sourceType_currentIndexChanged(int index)
{
    m_settings.m_sourceType = (RadioAstronomySettings::SourceType)index;
    applySettings();
    if (m_settings.m_sourceType == RadioAstronomySettings::SUN)
    {
        // Mean diameter of Sun in degrees from Earth
        ui->omegaS->setValue(0.53);
        ui->omegaSUnits->setCurrentIndex(0);
    }
    else if (m_settings.m_sourceType == RadioAstronomySettings::CAS_A)
    {
        // Diameter of Cas A in degrees http://simbad.u-strasbg.fr/simbad/sim-id?Ident=Cassiopeia+A
        ui->omegaS->setValue(0.08333);
        ui->omegaSUnits->setCurrentIndex(0);
    }
    bool visible = index == 1 || index >= 3;
    ui->omegaS->setVisible(visible);
    ui->omegaSUnits->setVisible(visible);
}

void RadioAstronomyGUI::on_omegaS_valueChanged(double value)
{
    m_settings.m_omegaS = value;
    if ((m_settings.m_sourceType == RadioAstronomySettings::SUN) && (value != 0.53)) {
        ui->sourceType->setCurrentIndex((int)RadioAstronomySettings::COMPACT);
    } else if ((m_settings.m_sourceType == RadioAstronomySettings::CAS_A) && (value != 0.08333)) {
        ui->sourceType->setCurrentIndex((int)RadioAstronomySettings::COMPACT);
    }
    applySettings();
}

void RadioAstronomyGUI::updateOmegaA()
{
    if (m_settings.m_omegaAUnits == RadioAstronomySettings::DEGREES) {
        ui->omegaA->setText(QString("%1").arg(m_beamWidth, 0, 'f', 1));
    } else {
        ui->omegaA->setText(QString("%1").arg(hpbwToSteradians(m_beamWidth), 0, 'f', 4));
    }
}

void RadioAstronomyGUI::on_omegaAUnits_currentIndexChanged(int index)
{
    m_settings.m_omegaAUnits = (RadioAstronomySettings::AngleUnits)index;
    updateOmegaA();
    if (m_settings.m_omegaAUnits == RadioAstronomySettings::DEGREES) {
        ui->omegaALabel->setText("HPBW");
    } else {
        ui->omegaALabel->setText(QString("%1<sub>A</sub>").arg(QChar(937)));
    }
    applySettings();
}

void RadioAstronomyGUI::on_omegaSUnits_currentIndexChanged(int index)
{
    m_settings.m_omegaSUnits = (RadioAstronomySettings::AngleUnits)index;
    if (  (   (m_settings.m_sourceType == RadioAstronomySettings::SUN)
           || (m_settings.m_sourceType == RadioAstronomySettings::CAS_A)
          )
        && (m_settings.m_omegaSUnits != RadioAstronomySettings::DEGREES)
       )
    {
        ui->sourceType->setCurrentIndex((int)RadioAstronomySettings::COMPACT);
    }
    applySettings();
}

void RadioAstronomyGUI::on_starTracker_currentTextChanged(const QString& text)
{
    m_settings.m_starTracker = text;
    applySettings();
}

void RadioAstronomyGUI::on_rotator_currentTextChanged(const QString& text)
{
    m_settings.m_rotator = text;
    applySettings();
    setColumnPrecisionFromRotator();
}

void RadioAstronomyGUI::setColumnPrecisionFromRotator()
{
    // Match rotator precision
    unsigned int featureSetIndex, featureIndex;

    if (MainCore::getFeatureIndexFromId(m_settings.m_rotator, featureSetIndex, featureIndex))
    {
        int precision = 0;
        if (ChannelWebAPIUtils::getFeatureSetting(featureSetIndex, featureIndex, "precision", precision))
        {
            int old = ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_GAL_LAT))->getPrecision();
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_GAL_LAT))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_GAL_LON))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_AZ))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_EL))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_ROT_AZ))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_ROT_EL))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_ROT_AZ_OFF))->setPrecision(precision);
            ((DecimalDelegate *)ui->powerTable->itemDelegateForColumn(POWER_COL_ROT_EL_OFF))->setPrecision(precision);
            if (precision > old)
            {
                ui->powerTable->resizeColumnToContents(POWER_COL_GAL_LAT);
                ui->powerTable->resizeColumnToContents(POWER_COL_GAL_LON);
                ui->powerTable->resizeColumnToContents(POWER_COL_AZ);
                ui->powerTable->resizeColumnToContents(POWER_COL_EL);
                ui->powerTable->resizeColumnToContents(POWER_COL_ROT_AZ);
                ui->powerTable->resizeColumnToContents(POWER_COL_ROT_EL);
                ui->powerTable->resizeColumnToContents(POWER_COL_ROT_AZ_OFF);
                ui->powerTable->resizeColumnToContents(POWER_COL_ROT_EL_OFF);
            }
            ui->powerTable->viewport()->update();
        }
    }
}

void RadioAstronomyGUI::on_showSensors_clicked()
{
    RadioAstronomySensorDialog dialog(&m_settings);
    if (dialog.exec() == QDialog::Accepted)
    {
        m_sensors[0].setName(m_settings.m_sensorName[0]);
        m_sensors[1].setName(m_settings.m_sensorName[1]);
        applySettings();
    }
}

void RadioAstronomyGUI::sensorMeasurementReceived(const RadioAstronomy::MsgSensorMeasurement& measurement)
{
    int sensor = measurement.getSensor();
    double value = measurement.getValue();
    QDateTime dateTime = measurement.getDateTime();
    SensorMeasurement* sm = new SensorMeasurement(dateTime, value);
    m_sensors[sensor].append(sm);
}

void RadioAstronomyGUI::on_powerChartSelect_currentIndexChanged(int index)
{
    m_settings.m_powerYData = (RadioAstronomySettings::PowerYData)index;
    ui->powerYUnits->clear();
    switch (m_settings.m_powerYData)
    {
    case RadioAstronomySettings::PY_POWER:
        ui->powerYUnits->addItem("dBFS");
        ui->powerYUnits->addItem("dBm");
        ui->powerYUnits->addItem("Watts");
        break;
    case RadioAstronomySettings::PY_TSYS:
    case RadioAstronomySettings::PY_TSOURCE:
        ui->powerYUnits->addItem("K");
        break;
    case RadioAstronomySettings::PY_FLUX:
        ui->powerYUnits->addItem("SFU");
        ui->powerYUnits->addItem("Jy");
        break;
    case RadioAstronomySettings::PY_2D_MAP:
        ui->powerYUnits->addItem("dBFS");
        ui->powerYUnits->addItem("dBm");
        //ui->powerYUnits->addItem("Watts"); // No watts for now, as range spin boxes can't handle scientific notation
        ui->powerYUnits->addItem("K");
        break;
    default:
        break;
    }
    updatePowerMarkerTableVisibility();
    updatePowerChartWidgetsVisibility();
    plotPowerChart();
    applySettings();
}

void RadioAstronomyGUI::updatePowerChartWidgetsVisibility()
{
    bool powerChart;
    if (m_settings.m_powerYData != RadioAstronomySettings::PY_2D_MAP) {
        powerChart = true;
    } else {
        powerChart = false;
    }
    ui->powerShowLegend->setVisible(powerChart);
    ui->powerShowSensor2->setVisible(powerChart);
    ui->powerShowSensor1->setVisible(powerChart);
    ui->powerShowAirTemp->setVisible(powerChart);
    ui->powerShowTsys0->setVisible(powerChart);
    ui->powerShowAvg->setVisible(powerChart);
    ui->powerShowGaussian->setVisible(powerChart);
    ui->powerShowMarker->setVisible(powerChart);
    ui->powerShowPeak->setVisible(powerChart);
    ui->powerScaleWidgets->setVisible(powerChart);
    ui->powerGaussianWidgets->setVisible(powerChart && m_settings.m_powerShowGaussian);
    ui->powerMarkerTableWidgets->setVisible(powerChart && (m_settings.m_powerPeaks || m_settings.m_powerMarkers));
    ui->power2DScaleWidgets->setVisible(!powerChart);
    ui->power2DColourScaleWidgets->setVisible(!powerChart);
    getRollupContents()->arrangeRollups();
}

int RadioAstronomyGUI::powerYUnitsToIndex(RadioAstronomySettings::PowerYUnits units)
{
    switch (units)
    {
    case RadioAstronomySettings::PY_DBFS:
        return 0;
    case RadioAstronomySettings::PY_DBM:
        return 1;
    case RadioAstronomySettings::PY_WATTS:
        return 2;
    case RadioAstronomySettings::PY_KELVIN:
        return 0;
    case RadioAstronomySettings::PY_SFU:
        return 0;
    case RadioAstronomySettings::PY_JANSKY:
        return 1;
    }
    return -1;
}

void RadioAstronomyGUI::on_powerYUnits_currentIndexChanged(int index)
{
    (void) index;

    QString text = ui->powerYUnits->currentText();
    if (text == "dBFS")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_DBFS;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Power (dBFS)");
        ui->powerColourScaleMin->setDecimals(2);
        ui->powerColourScaleMax->setDecimals(2);
    }
    else if (text == "dBm")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_DBM;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Power (dBm)");
        ui->powerColourScaleMin->setDecimals(2);
        ui->powerColourScaleMax->setDecimals(2);
    }
    else if (text == "Watts")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_WATTS;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Power (W)");
    }
    else if (text == "K")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_KELVIN;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Temp (K)");
        ui->powerColourScaleMin->setDecimals(0);
        ui->powerColourScaleMax->setDecimals(0);
    }
    else if (text == "SFU")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_SFU;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Flux (SFU)");
    }
    else if (text == "Jy")
    {
        m_settings.m_powerYUnits = RadioAstronomySettings::PY_JANSKY;
        ui->powerMarkerTable->horizontalHeaderItem(POWER_MARKER_COL_VALUE)->setText("Flux (Jy)");
    }
    if (text == "dBFS")
    {
        ui->powerColourScaleMinUnits->setText("dB");
        ui->powerColourScaleMaxUnits->setText("dB");
    }
    else
    {
        ui->powerColourScaleMinUnits->setText(text);
        ui->powerColourScaleMaxUnits->setText(text);
    }
    applySettings();
    plotPowerChart();
}

void RadioAstronomyGUI::on_spectrumChartSelect_currentIndexChanged(int index)
{
    updateSpectrumMarkerTableVisibility();  // If this follows updateSpectrumChartWidgetsVisibility, widgets are not redrawn properly.
    updateSpectrumChartWidgetsVisibility();  // when switching from cal to spectrum if table is visible
    if (index == 0)
    {
        if (m_fftChart) {
            ui->spectrumChart->setChart(m_fftChart);
        }
    }
    else
    {
        if (m_calChart) {
            ui->spectrumChart->setChart(m_calChart);
        }
    }
}

void RadioAstronomyGUI::updateSpectrumChartWidgetsVisibility()
{
    bool fft = ui->spectrumChartSelect->currentIndex() == 0;
    ui->spectrumYUnits->setVisible(fft);
    ui->spectrumScaleWidgets->setVisible(fft);
    ui->spectrumSelectWidgets->setVisible(fft);
    ui->spectrumRefLineWidgets->setVisible(fft && m_settings.m_spectrumRefLine);

    ui->spectrumGaussianWidgets->setVisible(fft && m_settings.m_spectrumTemp);
    ui->calWidgets->setVisible(!fft);
    ui->recalibrate->setVisible(!fft);
    ui->startCalHot->setVisible(!fft);
    ui->startCalCold->setVisible(!fft);
    ui->clearCal->setVisible(!fft);
    ui->showCalSettings->setVisible(!fft);
    ui->spectrumShowRefLine->setVisible(fft);
    ui->spectrumShowDistance->setVisible(fft);
    ui->spectrumShowLAB->setVisible(fft);
    ui->spectrumTemp->setVisible(fft);
    ui->spectrumMarker->setVisible(fft);
    ui->spectrumPeak->setVisible(fft);
    ui->saveSpectrumChartImages->setVisible(fft);

    getRollupContents()->arrangeRollups();
}

// Calculate mean, RMS and standard deviation
// Currently this is for all data - but could make it only for visible data
void RadioAstronomyGUI::calcAverages()
{
    qreal sum = 0.0;
    qreal sumSq = 0.0;
    QVector<QPointF> points = m_powerSeries->pointsVector();
    for (int i = 0; i < points.size(); i++)
    {
        QPointF point = points.at(i);
        qreal y = point.y();
        sum += y;
        sumSq += y * y;
    }
    qreal mean = sum / points.size();
    qreal rms = std::sqrt(sumSq / points.size());
    qreal sumSqDiff = 0.0;
    for (int i = 0; i < points.size(); i++)
    {
        QPointF point = points.at(i);
        qreal y = point.y();
        qreal diff = y - mean;
        sumSqDiff += diff * diff;
    }
    qreal sigma = std::sqrt(sumSqDiff / points.size());

    ui->powerMean->setText(QString::number(mean));
    ui->powerRMS->setText(QString::number(rms));
    ui->powerSD->setText(QString::number(sigma));
}

QRgb RadioAstronomyGUI::intensityToColor(float intensity)
{
    QRgb c1, c2;
    float scale;

    if (std::isnan(intensity)) {
        return qRgb(0, 0, 0);
    }
    // Get in range 0-1
    intensity = (intensity - m_settings.m_powerColourScaleMin) / (m_settings.m_powerColourScaleMax - m_settings.m_powerColourScaleMin);
    intensity = std::min(intensity, 1.0f);
    intensity = std::max(intensity, 0.0f);

    if (m_settings.m_powerColourPalette[0] == 'C')
    {
        // Colour heat map gradient
        if (intensity <= 0.25f)
        {
            c1 = qRgb(0, 0, 0x80); // Navy
            c2 = qRgb(0, 0, 0xff); // Blue
            scale = intensity * 4.0f;
        }
        else if (intensity <= 0.5f)
        {
            c1 = qRgb(0, 0, 0xff); // Blue
            c2 = qRgb(0, 0xff, 0); // Green
            scale = (intensity - 0.25f) * 4.0f;
        }
        else if (intensity <= 0.75f)
        {
            c1 = qRgb(0, 0xff, 0); // Green
            c2 = qRgb(0xff, 0xff, 0); // Yellow
            scale = (intensity - 0.5f) * 4.0f;
        }
        else
        {
            c1 = qRgb(0xff, 0xff, 0); // Yellow
            c2 = qRgb(0xff, 0, 0); // Red
            scale = (intensity - 0.75f) * 4.0f;
        }

        int r, g, b;
        r = (qRed(c2)-qRed(c1))*scale+qRed(c1);
        g = (qGreen(c2)-qGreen(c1))*scale+qGreen(c1);
        b = (qBlue(c2)-qBlue(c1))*scale+qBlue(c1);

        return qRgb(r, g, b);
    }
    else
    {
        // Greyscale
        int g = 255 * intensity;
        return qRgb(g, g, g);
    }
}

void RadioAstronomyGUI::plot2DChart()
{
    // Only plot if visible
    if (ui->powerChartSelect->currentIndex() == 4)
    {
        QChart *oldChart = m_2DChart;

        m_2DChart = new QChart();

        m_2DChart->layout()->setContentsMargins(0, 0, 0, 0);
        m_2DChart->setMargins(QMargins(1, 1, 1, 1));
        m_2DChart->setTheme(QChart::ChartThemeDark);
        m_2DChart->setTitle("");

        m_2DXAxis = new QValueAxis();
        m_2DYAxis = new QValueAxis();

        m_2DXAxis->setGridLineVisible(false);
        m_2DYAxis->setGridLineVisible(false);
        set2DAxisTitles();
        m_2DXAxis->setRange(m_settings.m_power2DXMin, m_settings.m_power2DXMax);
        m_2DYAxis->setRange(m_settings.m_power2DYMin, m_settings.m_power2DYMax);

        m_2DChart->addAxis(m_2DXAxis, Qt::AlignBottom);
        m_2DChart->addAxis(m_2DYAxis, Qt::AlignLeft);

        m_2DMap.fill(qRgb(0, 0, 0));
        for (int i = 0; i < m_fftMeasurements.size(); i++) {
            update2DImage(m_fftMeasurements[i], i < m_fftMeasurements.size() - 1);
        }
        if (m_settings.m_powerColourAutoscale) {
            powerColourAutoscale();
        }

        connect(m_2DChart, SIGNAL(plotAreaChanged(QRectF)), this, SLOT(plotAreaChanged(QRectF)));

        ui->powerChart->setChart(m_2DChart);

        delete oldChart;
    }
}

void RadioAstronomyGUI::set2DAxisTitles()
{
    if (m_settings.m_power2DSweepType == RadioAstronomySettings::SWP_LB)
    {
        m_2DXAxis->setTitleText(QString("Galactic longitude (%1)").arg(QChar(0xb0)));
        m_2DYAxis->setTitleText(QString("Galactic latitude (%1)").arg(QChar(0xb0)));
    }
    else
    {
        m_2DXAxis->setTitleText(QString("Azimuth (%1)").arg(QChar(0xb0)));
        m_2DYAxis->setTitleText(QString("Elevation (%1)").arg(QChar(0xb0)));
    }
}

void RadioAstronomyGUI::update2DSettingsFromSweep()
{
    if (m_settings.m_runMode == RadioAstronomySettings::SWEEP)
    {
        ui->power2DSweepType->setCurrentIndex((int)m_settings.m_sweepType);

        // Calculate width and height of image - 1 pixel per sweep measurement
        float sweep1Start, sweep1Stop;
        sweep1Start = m_settings.m_sweep1Start;
        sweep1Stop = m_settings.m_sweep1Stop;
        // Handle azimuth/l sweep through 0. E.g. 340deg -> 20deg with +vs step, or 20deg -> 340deg with -ve step
        if ((m_settings.m_sweep1Stop < m_settings.m_sweep1Start) && (m_settings.m_sweep1Step > 0)) {
            sweep1Stop = m_settings.m_sweep1Stop + 360.0;
        } else if ((m_settings.m_sweep1Stop > m_settings.m_sweep1Start) && (m_settings.m_sweep1Step < 0)) {
            sweep1Start += 360.0;
        }
        int width = abs((sweep1Stop - sweep1Start) / m_settings.m_sweep1Step) + 1;
        int height = abs((m_settings.m_sweep2Stop - m_settings.m_sweep2Start) / m_settings.m_sweep2Step) + 1;
        ui->power2DWidth->setValue(width);
        ui->power2DHeight->setValue(height);

        // Subtract/add half a step so that pixels are centred on coordinates
        int start1 = m_settings.m_sweep1Start - m_settings.m_sweep1Step / 2;
        int stop1 = m_settings.m_sweep1Stop + m_settings.m_sweep1Step / 2;
        if (start1 < stop1)
        {
            ui->power2DXMin->setValue(start1);
            ui->power2DXMax->setValue(stop1);
        }
        else
        {
            ui->power2DXMin->setValue(stop1);
            ui->power2DXMax->setValue(start1);
        }

        int start2 = m_settings.m_sweep2Start - m_settings.m_sweep2Step / 2;
        int stop2 = m_settings.m_sweep2Stop + m_settings.m_sweep2Step / 2;
        if (start2 < stop2)
        {
            ui->power2DYMin->setValue(start2);
            ui->power2DYMax->setValue(stop2);
        }
        else
        {
            ui->power2DYMin->setValue(stop2);
            ui->power2DYMax->setValue(start2);
        }

        m_sweepIndex = 0;
    }
}

void RadioAstronomyGUI::create2DImage()
{
    // Intensity array holds power/temperature values which are then colourised in to a QImage
    delete m_2DMapIntensity;
    int size = m_settings.m_power2DWidth * m_settings.m_power2DHeight;
    if (size > 0)
    {
        m_2DMapIntensity = new float[size];
        for (int i = 0; i < size; i++) {
            m_2DMapIntensity[i] = NAN;
        }
        m_2DMapMin = std::numeric_limits<float>::max();
        m_2DMapMax = -std::numeric_limits<float>::max();
        QImage map(m_settings.m_power2DWidth, m_settings.m_power2DHeight, QImage::Format_ARGB32);
        map.fill(qRgb(0, 0, 0));
        m_2DMap = map;
    }
    else
    {
        m_2DMapIntensity = nullptr;
        m_2DMap = QImage();
    }
}

void RadioAstronomyGUI::update2DImage(FFTMeasurement* fft, bool skipCalcs)
{
    if (m_2DMap.width() > 0)
    {
        int x, y;
        if (m_settings.m_power2DSweepType == RadioAstronomySettings::SWP_OFFSET)
        {
            y = fft->m_sweepIndex / m_2DMap.width();
            x = fft->m_sweepIndex % m_2DMap.width();

            if (m_settings.m_sweep2Step >= 0) {
                y = m_2DMap.height() - 1 - y;
            }
            if (m_settings.m_sweep1Step < 0) {
                x = m_2DMap.width() - 1 - x;
            }
        }
        else
        {
            if (m_settings.m_power2DSweepType == RadioAstronomySettings::SWP_LB)
            {
                x = (int)round(fft->m_l);
                y = (int)round(fft->m_b);
            }
            else
            {
                x = (int)round(fft->m_azimuth);
                y = (int)round(fft->m_elevation);
            }

            // Map coordinates to pixels
            float xRange = m_settings.m_power2DXMax - m_settings.m_power2DXMin;
            float yRange = m_settings.m_power2DYMax - m_settings.m_power2DYMin;

            x = (x - m_settings.m_power2DXMin) * m_settings.m_power2DWidth / xRange;
            y = (y - m_settings.m_power2DYMin) * m_settings.m_power2DHeight / yRange;

            if (yRange >= 0) {
                y = m_2DMap.height() - 1 - y;
            }
            if (xRange < 0) {
                x = m_2DMap.width() - 1 - x;
            }
        }

        if ((x >= 0) && (x < m_2DMap.width()) && (y >= 0) && (y < m_2DMap.height()))
        {
            float intensity;
            switch (m_settings.m_powerYUnits)
            {
            case RadioAstronomySettings::PY_DBFS:
                intensity = fft->m_totalPowerdBFS;
                break;
            case RadioAstronomySettings::PY_DBM:
                intensity = fft->m_totalPowerdBm;
                break;
            case RadioAstronomySettings::PY_WATTS:
                intensity = fft->m_totalPowerWatts;
                break;
            case RadioAstronomySettings::PY_KELVIN:
                intensity = fft->m_tSys;
                break;
            default:
                break;
            }

            float newMin = std::min(m_2DMapMin, intensity);
            float newMax = std::max(m_2DMapMax, intensity);
            bool rescale = false;
            if ((newMin != m_2DMapMin) || (newMax != m_2DMapMax)) {
                rescale = m_settings.m_powerColourAutoscale;
            }
            m_2DMapMin = newMin;
            m_2DMapMax = newMax;
            m_2DMapIntensity[y*m_2DMap.width()+x] = intensity;
            m_2DMap.setPixel(x, y, intensityToColor(intensity));
            if (rescale && !skipCalcs) {
                powerColourAutoscale();
            }
            if (m_2DChart && !skipCalcs) {
                plotAreaChanged(m_2DChart->plotArea());
            }
        }
    }
}

void RadioAstronomyGUI::recolour2DImage()
{
    for (int y = 0; y < m_2DMap.height(); y++)
    {
        for (int x = 0; x < m_2DMap.width(); x++) {
            m_2DMap.setPixel(x, y, intensityToColor(m_2DMapIntensity[y*m_2DMap.width()+x]));
        }
    }
    if (m_2DChart) {
        plotAreaChanged(m_2DChart->plotArea());
    }
}

void RadioAstronomyGUI::plotAreaChanged(const QRectF& plotArea)
{
    if (ui->powerChartSelect->currentIndex() == 4)
    {
        int width = static_cast<int>(plotArea.width());
        int height = static_cast<int>(plotArea.height());
        int viewW = static_cast<int>(ui->powerChart->width());
        int viewH = static_cast<int>(ui->powerChart->height());

        // Scale the image to fit plot area
        QImage image = m_2DMap.scaled(QSize(width, height), Qt::IgnoreAspectRatio);
        QImage translated(viewW, viewH, QImage::Format_ARGB32);
        translated.fill(Qt::black);
        QPainter painter(&translated);
        painter.drawImage(plotArea.topLeft(), image);

        m_2DChart->setPlotAreaBackgroundBrush(translated);
        m_2DChart->setPlotAreaBackgroundVisible(true);
    }
}

// Find min and max coordinates from existing data
void RadioAstronomyGUI::power2DAutoscale()
{
    if (m_fftMeasurements.size() > 0)
    {
        float minX = std::numeric_limits<float>::max();
        float maxX = -std::numeric_limits<float>::max();
        float minY = std::numeric_limits<float>::max();
        float maxY = -std::numeric_limits<float>::max();

        for (int i = 0; i < m_fftMeasurements.size(); i++)
        {
            FFTMeasurement* fft = m_fftMeasurements[i];
            float x, y;
            if (m_settings.m_power2DSweepType == RadioAstronomySettings::SWP_LB)
            {
                x = fft->m_l;
                y = fft->m_b;
            }
            else
            {
                x = fft->m_azimuth;
                y = fft->m_elevation;
            }
            minX = std::min(minX, x);
            maxX = std::max(maxX, x);
            minY = std::min(minY, y);
            maxY = std::max(maxY, y);
        }

        // Adjust so pixels are centered
        float xAdjust = (maxX - minX) / m_2DMap.width() / 2;
        float yAdjust = (maxY - minY) / m_2DMap.height() / 2;

        ui->power2DXMin->setValue(minX - xAdjust);
        ui->power2DXMax->setValue(maxX + xAdjust);
        ui->power2DYMin->setValue(minY - yAdjust);
        ui->power2DYMax->setValue(maxY + xAdjust);
    }
}

void RadioAstronomyGUI::on_power2DAutoscale_clicked()
{
    power2DAutoscale();
    plot2DChart();
}

void RadioAstronomyGUI::on_power2DLinkSweep_toggled(bool checked)
{
    m_settings.m_power2DLinkSweep = checked;
    applySettings();
}

void RadioAstronomyGUI::on_power2DSweepType_currentIndexChanged(int index)
{
    m_settings.m_power2DSweepType = (RadioAstronomySettings::SweepType)index;
    applySettings();
    plot2DChart();
}

void RadioAstronomyGUI::on_power2DWidth_valueChanged(int value)
{
    m_settings.m_power2DWidth = value;
    applySettings();
    create2DImage();
    plot2DChart();
}

void RadioAstronomyGUI::on_power2DHeight_valueChanged(int value)
{
    m_settings.m_power2DHeight = value;
    applySettings();
    create2DImage();
    plot2DChart();
}

void RadioAstronomyGUI::on_power2DXMin_valueChanged(double value)
{
    m_settings.m_power2DXMin = value;
    applySettings();
    if (m_2DXAxis)
    {
        m_2DXAxis->setMin(m_settings.m_power2DXMin);
        plot2DChart();
    }
}

void RadioAstronomyGUI::on_power2DXMax_valueChanged(double value)
{
    m_settings.m_power2DXMax = value;
    applySettings();
    if (m_2DXAxis)
    {
        m_2DXAxis->setMax(m_settings.m_power2DXMax);
        plot2DChart();
    }
}

void RadioAstronomyGUI::on_power2DYMin_valueChanged(double value)
{
    m_settings.m_power2DYMin = value;
    applySettings();
    if (m_2DYAxis)
    {
        m_2DYAxis->setMin(m_settings.m_power2DYMin);
        plot2DChart();
    }
}

void RadioAstronomyGUI::on_power2DYMax_valueChanged(double value)
{
    m_settings.m_power2DYMax = value;
    applySettings();
    if (m_2DYAxis)
    {
        m_2DYAxis->setMax(m_settings.m_power2DYMax);
        plot2DChart();
    }
}

void RadioAstronomyGUI::powerColourAutoscale()
{
    int width = m_2DMap.width();
    int height = m_2DMap.height();
    float newMin = std::numeric_limits<float>::max();
    float newMax = -std::numeric_limits<float>::max();
    for (int i = 0; i < width * height; i++)
    {
        if (!std::isnan(m_2DMapIntensity[i]))
        {
            newMin = std::min(newMin, m_2DMapIntensity[i]);
            newMax = std::max(newMax, m_2DMapIntensity[i]);
        }
    }

    if ((newMin != ui->powerColourScaleMin->value()) || (newMax != ui->powerColourScaleMax->value()))
    {
        ui->powerColourScaleMin->setValue(std::floor(newMin * 10.0) / 10.0);
        ui->powerColourScaleMax->setValue(std::ceil(newMax * 10.0) / 10.0);
    }
}

void RadioAstronomyGUI::on_powerColourAutoscale_toggled(bool checked)
{
    m_settings.m_powerColourAutoscale = checked;
    applySettings();
    if (m_settings.m_powerColourAutoscale) {
        powerColourAutoscale();
    }
    ui->powerColourScaleMin->setEnabled(!m_settings.m_powerColourAutoscale);
    ui->powerColourScaleMax->setEnabled(!m_settings.m_powerColourAutoscale);
}

void RadioAstronomyGUI::updatePowerColourScaleStep()
{
    float diff = abs(m_settings.m_powerColourScaleMax - m_settings.m_powerColourScaleMin);
    double step = (diff <= 1.0f) ? 0.1 : 1.0f;
    ui->powerColourScaleMin->setSingleStep(step);
    ui->powerColourScaleMax->setSingleStep(step);
}

void RadioAstronomyGUI::on_powerColourScaleMin_valueChanged(double value)
{
    m_settings.m_powerColourScaleMin = value;
    updatePowerColourScaleStep();
    applySettings();
    recolour2DImage();
}

void RadioAstronomyGUI::on_powerColourScaleMax_valueChanged(double value)
{
    m_settings.m_powerColourScaleMax = value;
    updatePowerColourScaleStep();
    applySettings();
    recolour2DImage();
}

void RadioAstronomyGUI::on_powerColourPalette_currentIndexChanged(int index)
{
    (void) index;
    m_settings.m_powerColourPalette = ui->powerColourPalette->currentText();
    applySettings();
    recolour2DImage();
}

void RadioAstronomyGUI::plotPowerChart()
{
    if (ui->powerChartSelect->currentIndex() == 4) {
        plot2DChart();
    } else {
        plotPowerVsTimeChart();
    }
}

void RadioAstronomyGUI::plotPowerVsTimeChart()
{
    QChart *oldChart = m_powerChart;

    m_powerChart = new QChart();

    m_powerChart->layout()->setContentsMargins(0, 0, 0, 0);
    m_powerChart->setMargins(QMargins(1, 1, 1, 1));
    m_powerChart->setTheme(QChart::ChartThemeDark);

    m_powerChart->legend()->setAlignment(Qt::AlignRight);
    m_powerChart->legend()->setVisible(m_settings.m_powerLegend);

    // Create measurement data series
    m_powerSeries = new QLineSeries();
    m_powerSeries->setVisible(m_settings.m_powerShowMeasurement);
    connect(m_powerSeries, &QXYSeries::clicked, this, &RadioAstronomyGUI::powerSeries_clicked);

    // Plot peak info
    m_powerPeakSeries = new QScatterSeries();
    m_powerPeakSeries->setName("Peak");
    m_powerPeakSeries->setPointLabelsVisible(true);
    m_powerPeakSeries->setPointLabelsFormat("@yPoint"); // Qt can't display dates, so omit @xPoint
    m_powerPeakSeries->setMarkerSize(5);
    m_powerPeakSeries->setVisible(m_settings.m_powerPeaks);

    // Markers
    m_powerMarkerSeries = new QScatterSeries();
    m_powerMarkerSeries->setName("Marker");
    m_powerMarkerSeries->setPointLabelsVisible(true);
    m_powerMarkerSeries->setPointLabelsFormat("@yPoint");
    m_powerMarkerSeries->setMarkerSize(5);
    m_powerMarkerSeries->setVisible(m_settings.m_powerMarkers);

    // Noise
    m_powerTsys0Series = new QLineSeries();
    m_powerTsys0Series->setName("Tsys0");
    m_powerTsys0Series->setVisible(m_settings.m_powerShowTsys0);

    // Air temperature
    m_airTemps.init("Air temp", m_settings.m_powerShowAirTemp);

    // Gaussian
    m_powerGaussianSeries = new QLineSeries();
    m_powerGaussianSeries->setName("Gaussian fit");
    m_powerGaussianSeries->setVisible(m_settings.m_powerShowGaussian);

    // Filtered measurement
    m_powerFilteredSeries = new QLineSeries();
    m_powerFilteredSeries->setName("Filtered");
    m_powerFilteredSeries->setVisible(m_settings.m_powerShowFiltered);
    plotPowerFiltered();

    // Sensors
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        m_sensors[i].init(m_settings.m_sensorName[i], m_settings.m_sensorVisible[i]);
    }

    // Reset min/max and peaks
    m_powerMin = std::numeric_limits<double>::max();
    m_powerMax = -std::numeric_limits<double>::max();
    m_powerPeakValid = false;

    // Create X axis
    m_powerXAxis = new QDateTimeAxis();
    int rows = ui->powerTable->rowCount();
    QString dateTimeFormat = "hh:mm:ss";
    m_powerXAxisSameDay = true;
    if (rows > 1)
    {
        QDate start = ui->powerTable->item(0, POWER_COL_DATE)->data(Qt::DisplayRole).toDate();
        QDate end = ui->powerTable->item(rows-1, POWER_COL_DATE)->data(Qt::DisplayRole).toDate();
        if (start != end)
        {
            dateTimeFormat = QString("%1 hh:mm").arg(QLocale::system().dateFormat(QLocale::ShortFormat));
            m_powerXAxisSameDay = false;
        }
    }
    m_powerXAxis->setFormat(dateTimeFormat);
    m_powerXAxis->setRange(ui->powerStartTime->dateTime(), ui->powerEndTime->dateTime());
    ui->powerStartTime->setDisplayFormat(dateTimeFormat);
    ui->powerEndTime->setDisplayFormat(dateTimeFormat);

    // Create Y axis
    m_powerYAxis = new QValueAxis();

    m_powerXAxis->setTitleText("Time");
    calcPowerChartTickCount(size().width());
    switch (m_settings.m_powerYData)
    {
    case RadioAstronomySettings::PY_POWER:
        m_powerSeries->setName("Measurement");
        switch (m_settings.m_powerYUnits)
        {
        case RadioAstronomySettings::PY_DBFS:
            m_powerYAxis->setTitleText("Power (dBFS)");
            break;
        case RadioAstronomySettings::PY_DBM:
            m_powerYAxis->setTitleText("Power (dBm)");
            break;
        case RadioAstronomySettings::PY_WATTS:
            m_powerYAxis->setTitleText("Power (Watts)");
            break;
        default:
            break;
        }
        break;
    case RadioAstronomySettings::PY_TSYS:
        m_powerSeries->setName("Tsys");
        m_powerYAxis->setTitleText("Tsys (K)");
        break;
    case RadioAstronomySettings::PY_TSOURCE:
        m_powerSeries->setName("Tsource");
        m_powerYAxis->setTitleText("Tsource (K)");
        break;
    case RadioAstronomySettings::PY_FLUX:
        m_powerSeries->setName("Flux density");
        switch (m_settings.m_powerYUnits)
        {
        case RadioAstronomySettings::PY_SFU:
            m_powerYAxis->setTitleText("Flux density (SFU)");
            break;
        case RadioAstronomySettings::PY_JANSKY:
            m_powerYAxis->setTitleText("Flux density (Jy)");
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }

    m_powerChart->addAxis(m_powerXAxis, Qt::AlignBottom);
    m_powerChart->addAxis(m_powerYAxis, Qt::AlignLeft);
    m_powerChart->addAxis(m_airTemps.yAxis(), Qt::AlignRight);
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        m_powerChart->addAxis(m_sensors[i].yAxis(), Qt::AlignRight);
    }

    // Add data to series and calculate peaks
    for (int i = 0; i < m_fftMeasurements.size(); i++) {
        addToPowerSeries(m_fftMeasurements[i], i < (m_fftMeasurements.size() - 1));
    }
    m_airTemps.addAllToSeries();
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        m_sensors[i].addAllToSeries();
    }

    m_powerChart->addSeries(m_powerSeries);
    m_powerSeries->attachAxis(m_powerXAxis);
    m_powerSeries->attachAxis(m_powerYAxis);

    m_powerChart->addSeries(m_powerTsys0Series);
    m_powerTsys0Series->attachAxis(m_powerXAxis);
    m_powerTsys0Series->attachAxis(m_powerYAxis);

    m_powerChart->addSeries(m_powerGaussianSeries);
    m_powerGaussianSeries->attachAxis(m_powerXAxis);
    m_powerGaussianSeries->attachAxis(m_powerYAxis);

    m_airTemps.addToChart(m_powerChart, m_powerXAxis);
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        m_sensors[i].addToChart(m_powerChart, m_powerXAxis);
    }

    m_powerChart->addSeries(m_powerFilteredSeries);
    m_powerFilteredSeries->attachAxis(m_powerXAxis);
    m_powerFilteredSeries->attachAxis(m_powerYAxis);

    m_powerChart->addSeries(m_powerPeakSeries);
    m_powerPeakSeries->attachAxis(m_powerXAxis);
    m_powerPeakSeries->attachAxis(m_powerYAxis);

    m_powerChart->addSeries(m_powerMarkerSeries);
    m_powerMarkerSeries->attachAxis(m_powerXAxis);
    m_powerMarkerSeries->attachAxis(m_powerYAxis);

    // Dark theme only has 5 colours for series, so use an extra unique colour (purple)
    QPen pen(QColor(qRgb(146, 65, 146)), 2, Qt::SolidLine);
    m_sensors[1].setPen(pen);

    // Don't have peaks and markers in legend
    m_powerChart->legend()->markers(m_powerPeakSeries)[0]->setVisible(false);
    m_powerChart->legend()->markers(m_powerMarkerSeries)[0]->setVisible(false);

    ui->powerChart->setChart(m_powerChart);

    delete oldChart;
}

void RadioAstronomyGUI::calCompletetReceived(const RadioAstronomy::MsgCalComplete& measurement)
{
    bool hot = measurement.getHot();
    int size = measurement.getSize();
    Real* data = measurement.getCal();

    FFTMeasurement* fft = new FFTMeasurement();
    if (hot)
    {
        delete m_calHot;
        m_calHot = fft;
        ui->startCalHot->setStyleSheet("QToolButton { background: none; }");
    }
    else
    {
        delete m_calCold;
        m_calCold = fft;
        ui->startCalCold->setStyleSheet("QToolButton { background: none; }");
    }
    fft->m_fftData = data;
    fft->m_fftSize = size;
    fft->m_dateTime = measurement.getDateTime();
    fft->m_centerFrequency = m_centerFrequency;
    fft->m_sampleRate = m_settings.m_sampleRate;
    fft->m_integration = m_settings.m_integration;
    fft->m_rfBandwidth = m_settings.m_rfBandwidth;
    fft->m_omegaA = calcOmegaA();
    fft->m_omegaS = calcOmegaS();
    fft->m_coordsValid = m_coordsValid;
    fft->m_ra = m_ra;
    fft->m_dec = m_dec;
    fft->m_azimuth = m_azimuth;
    fft->m_elevation = m_elevation;
    fft->m_l = m_l;
    fft->m_b = m_b;
    fft->m_vBCRS = m_vBCRS;
    fft->m_vLSR = m_vLSR;
    fft->m_solarFlux = m_solarFlux;
    fft->m_airTemp = m_airTemps.lastValue();
    fft->m_skyTemp = m_skyTemp;
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        fft->m_sensor[i] = m_sensors[i].lastValue();
    }
    fft->m_tSys0 = calcTSys0();
    fft->m_baseline = m_settings.m_spectrumBaseline;
    getRotatorData(fft);


    if (!hot) {
        ui->calTsky->setText(QString::number(m_skyTemp, 'f', 1));
    }

    calcFFTTotalPower(fft);
    calcCalAvgDiff();
    calibrate();
    calcFFTTemperatures(fft);
    calcFFTTotalTemperature(fft);
    plotCalMeasurements();
}

void RadioAstronomyGUI::plotCalMeasurements()
{
    m_calHotSeries->clear();
    m_calColdSeries->clear();

    if (m_calHot || m_calCold)
    {
        float minVal = std::numeric_limits<float>::max();
        float maxVal = -std::numeric_limits<float>::max();

        double size;
        double sampleRate;
        double centerFrequency;
        if (m_calCold && m_calHot)
        {
            size = (double)std::min(m_calCold->m_fftSize, m_calHot->m_fftSize);
            sampleRate = (double)m_calCold->m_sampleRate;
            centerFrequency = (double)m_calCold->m_centerFrequency;
        }
        else if (m_calCold)
        {
            size = (double)m_calCold->m_fftSize;
            sampleRate = (double)m_calCold->m_sampleRate;
            centerFrequency = (double)m_calCold->m_centerFrequency;
        }
        else
        {
            size = (double)m_calHot->m_fftSize;
            sampleRate = (double)m_calHot->m_sampleRate;
            centerFrequency = (double)m_calHot->m_centerFrequency;
        }

        double binRes = sampleRate / size;
        double startFreq = centerFrequency - sampleRate / 2.0;
        double freq = startFreq;
        for (int i = 0; i < size; i++)
        {
            float value;
            bool hotValid = m_calHot && (i < m_calHot->m_fftSize);
            bool coldValid = m_calCold && (i < m_calCold->m_fftSize);

            if (hotValid)
            {
                value = CalcDb::dbPower(m_calHot->m_fftData[i]);
                m_calHotSeries->append(freq / 1e6, value);
                minVal = std::min(minVal, value);
                maxVal = std::max(maxVal, value);
            }
            if (coldValid)
            {
                value = CalcDb::dbPower(m_calCold->m_fftData[i]);
                m_calColdSeries->append(freq / 1e6, value);
                minVal = std::min(minVal, value);
                maxVal = std::max(maxVal, value);
            }
            freq += binRes;
        }

        m_calYAxis->setRange(minVal, maxVal);

        double startFreqMHz = centerFrequency/1e6 - sampleRate/ 1e6 / 2.0;
        double endFreqMHz = centerFrequency/1e6 + sampleRate/ 1e6 / 2.0;
        m_calXAxis->setRange(startFreqMHz, endFreqMHz);
        m_calXAxis->setReverse(m_settings.m_spectrumReverseXAxis);
    }
}

void RadioAstronomyGUI::plotCalSpectrum()
{
    QChart *oldChart = m_calChart;

    m_calChart = new QChart();

    m_calChart->layout()->setContentsMargins(0, 0, 0, 0);
    m_calChart->setMargins(QMargins(1, 1, 1, 1));
    m_calChart->setTheme(QChart::ChartThemeDark);

    m_calChart->legend()->setAlignment(Qt::AlignRight);
    m_calChart->legend()->setVisible(m_settings.m_spectrumLegend);

    m_calHotSeries = new QLineSeries();
    m_calHotSeries->setName("Hot");
    m_calColdSeries = new QLineSeries();
    m_calColdSeries->setName("Cold");

    m_calXAxis = new QValueAxis();
    m_calYAxis = new QValueAxis();

    m_calChart->addAxis(m_calXAxis, Qt::AlignBottom);
    m_calChart->addAxis(m_calYAxis, Qt::AlignLeft);

    m_calXAxis->setTitleText("Frequency (MHz)");
    calcSpectrumChartTickCount(m_calXAxis, size().width());
    m_calYAxis->setTitleText("Power (dBFS)");

    m_calChart->addSeries(m_calHotSeries);
    m_calHotSeries->attachAxis(m_calXAxis);
    m_calHotSeries->attachAxis(m_calYAxis);

    m_calChart->addSeries(m_calColdSeries);
    m_calColdSeries->attachAxis(m_calXAxis);
    m_calColdSeries->attachAxis(m_calYAxis);

    plotCalMeasurements();

    ui->spectrumChart->setChart(m_calChart);

    delete oldChart;
}

void RadioAstronomyGUI::on_spectrumReference_valueChanged(double value)
{
    m_settings.m_spectrumReference = value;
    spectrumUpdateYRange();
    if (!m_settings.m_spectrumAutoscale) {
        applySettings();
    }
}

void RadioAstronomyGUI::on_spectrumRange_valueChanged(double value)
{
    m_settings.m_spectrumRange = value;
    if (m_settings.m_spectrumRange <= 1.0)
    {
        ui->spectrumRange->setSingleStep(0.1);
        ui->spectrumRange->setDecimals(2);
        ui->spectrumReference->setDecimals(2);
    }
    else
    {
        ui->spectrumRange->setSingleStep(1.0);
        ui->spectrumRange->setDecimals(1);
        ui->spectrumReference->setDecimals(1);
    }
    spectrumUpdateYRange();
    if (!m_settings.m_spectrumAutoscale) {
        applySettings();
    }
}

void RadioAstronomyGUI::on_spectrumSpan_valueChanged(double value)
{
    m_settings.m_spectrumSpan = value;
    spectrumUpdateXRange();
    applySettings();
}

void RadioAstronomyGUI::on_spectrumCenterFreq_valueChanged(double value)
{
    double offset;
    FFTMeasurement* fft = currentFFT();
    if (fft) {
        offset = value - fft->m_centerFrequency/1e6;
    } else {
        offset = value - m_centerFrequency/1e6;
    }
    m_settings.m_spectrumCenterFreqOffset = offset;
    spectrumUpdateXRange();
    applySettings();
}

void RadioAstronomyGUI::spectrumUpdateXRange(FFTMeasurement* fft)
{
    if (!fft) {
        fft = currentFFT();
    }
    if (m_fftXAxis && fft)
    {
        double startFreqMHz = fft->m_centerFrequency/1e6 - m_settings.m_spectrumSpan / 2.0;
        double endFreqMHz = fft->m_centerFrequency/1e6 + m_settings.m_spectrumSpan / 2.0;
        m_fftXAxis->setRange(startFreqMHz + m_settings.m_spectrumCenterFreqOffset, endFreqMHz + m_settings.m_spectrumCenterFreqOffset);
        double lineFreqMHz = ui->spectrumLineFrequency->value();
        double lineFreq = lineFreqMHz * 1e6;
        double startFreq = fft->m_centerFrequency + m_settings.m_spectrumSpan*1e6 / 2.0 + m_settings.m_spectrumCenterFreqOffset*1e6;
        double endFreq = fft->m_centerFrequency - m_settings.m_spectrumSpan*1e6 / 2.0 + m_settings.m_spectrumCenterFreqOffset*1e6;
        m_fftDopplerAxis->setRange(dopplerToVelocity(lineFreq, startFreq, fft),
                                   dopplerToVelocity(lineFreq, endFreq, fft));
    }
}

void RadioAstronomyGUI::spectrumUpdateYRange(FFTMeasurement* fft)
{
    if (!fft) {
        fft = currentFFT();
    }
    if (m_fftYAxis && fft) {
        m_fftYAxis->setRange(m_settings.m_spectrumReference - m_settings.m_spectrumRange, m_settings.m_spectrumReference);
    }
}

void RadioAstronomyGUI::spectrumAutoscale()
{
    if (m_settings.m_spectrumAutoscale)
    {
        on_spectrumAutoscaleX_clicked();
        on_spectrumAutoscaleY_clicked();
    }
}

// Scale Y axis according to min and max values
void RadioAstronomyGUI::on_spectrumAutoscale_toggled(bool checked)
{
    m_settings.m_spectrumAutoscale = checked;
    ui->spectrumAutoscaleX->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumAutoscaleY->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumReference->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumRange->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumCenterFreq->setEnabled(!m_settings.m_spectrumAutoscale);
    ui->spectrumSpan->setEnabled(!m_settings.m_spectrumAutoscale);
    spectrumAutoscale();
    applySettings();
}

// Get minimum and maximum values in a series
// Assumes minVal and maxVal are initialised
static bool seriesMinAndMax(QLineSeries* series, qreal& minVal, qreal& maxVal)
{
    QVector<QPointF> points = series->pointsVector();
    for (int i = 0; i < points.size(); i++)
    {
        qreal power = points[i].y();
        minVal = std::min(minVal, power);
        maxVal = std::max(maxVal, power);
    }
    return points.size() > 0;
}

// Scale Y axis according to min and max values
void RadioAstronomyGUI::on_spectrumAutoscaleY_clicked()
{
    double minVal = std::numeric_limits<double>::max();
    double maxVal = -std::numeric_limits<double>::max();
    bool v0 = false, v1 = false;
    if (m_fftSeries) {
        v0 = seriesMinAndMax(m_fftSeries, minVal, maxVal);
    }
    if (m_fftLABSeries && m_settings.m_spectrumLAB) {
        v1 = seriesMinAndMax(m_fftLABSeries, minVal, maxVal);
    }
    if (v0 || v1)
    {
        double range = (maxVal - minVal) * 1.2; // 20% wider than signal range, for space for markers
        range = std::max(0.1, range);     // Don't be smaller than minimum value we can set in GUI
        ui->spectrumRange->setValue(range); // Call before setting reference, so number of decimals are adjusted
        ui->spectrumReference->setValue(maxVal + range * 0.15);
    }
}

// Scale X axis according to min and max values
void RadioAstronomyGUI::on_spectrumAutoscaleX_clicked()
{
    FFTMeasurement* fft = currentFFT();
    if (fft)
    {
        ui->spectrumSpan->setValue(fft->m_sampleRate/1e6);
        ui->spectrumCenterFreq->setValue(fft->m_centerFrequency/1e6);
    }
    else
    {
        ui->spectrumSpan->setValue(m_basebandSampleRate/1e6);
        ui->spectrumCenterFreq->setValue(m_centerFrequency/1e6);
    }
}

RadioAstronomyGUI::FFTMeasurement* RadioAstronomyGUI::currentFFT()
{
    int index = ui->spectrumIndex->value();
    if ((index >= 0) && (index < m_fftMeasurements.size())) {
        return m_fftMeasurements[index];
    } else {
        return nullptr;
    }
}

void RadioAstronomyGUI::on_spectrumYUnits_currentIndexChanged(int index)
{
    (void) index;

    QString text = ui->spectrumYUnits->currentText();
    if (text == "dBFS")
    {
        m_settings.m_spectrumYScale = RadioAstronomySettings::SY_DBFS;
        ui->spectrumMarkerTable->horizontalHeaderItem(SPECTRUM_MARKER_COL_VALUE)->setText("Power (dBFS)");
    }
    else if (text == "SNR")
    {
        m_settings.m_spectrumYScale = RadioAstronomySettings::SY_SNR;
        ui->spectrumMarkerTable->horizontalHeaderItem(SPECTRUM_MARKER_COL_VALUE)->setText("SNR");
    }
    else if (text == "dBm")
    {
        m_settings.m_spectrumYScale = RadioAstronomySettings::SY_DBM;
        ui->spectrumMarkerTable->horizontalHeaderItem(SPECTRUM_MARKER_COL_VALUE)->setText("Power (dBm)");
    }
    else if (text == "Tsys K")
    {
        m_settings.m_spectrumYScale = RadioAstronomySettings::SY_TSYS;
        ui->spectrumMarkerTable->horizontalHeaderItem(SPECTRUM_MARKER_COL_VALUE)->setText("Tsys (K)");
    }
    else
    {
        m_settings.m_spectrumYScale = RadioAstronomySettings::SY_TSOURCE;
        ui->spectrumMarkerTable->horizontalHeaderItem(SPECTRUM_MARKER_COL_VALUE)->setText("Tsource (K)");
    }
    plotFFTMeasurement();
    applySettings();
}

void RadioAstronomyGUI::on_spectrumBaseline_currentIndexChanged(int index)
{
    m_settings.m_spectrumBaseline = (RadioAstronomySettings::SpectrumBaseline)index;
    plotFFTMeasurement();
    if ((m_settings.m_powerYData == RadioAstronomySettings::PY_TSOURCE) || (m_settings.m_powerYData == RadioAstronomySettings::PY_FLUX)) {
        plotPowerChart();
    }
    applySettings();
}

// Convert frequency shift to velocity in km/s (+ve approaching)
static double lineDopplerVelocity(double centre, double f)
{
    return Astronomy::dopplerToVelocity(f, centre) / 1000.0f;
}

// Convert frequency shift to velocity (+ve receding - which seems to be the astronomical convention)
double RadioAstronomyGUI::dopplerToVelocity(double centre, double f, FFTMeasurement *fft)
{
    double v = lineDopplerVelocity(centre, f);
    // Adjust in to selected reference frame
    switch (m_settings.m_refFrame)
    {
    case RadioAstronomySettings::BCRS:
        v -= fft->m_vBCRS;
        break;
    case RadioAstronomySettings::LSR:
        v -= fft->m_vLSR;
        break;
    default:
        break;
    }
    // Make +ve receding
    return -v;
}

// Replot current FFT
void RadioAstronomyGUI::plotFFTMeasurement()
{
    plotFFTMeasurement(ui->spectrumIndex->value());
}

// Plot FFT with specified index
void RadioAstronomyGUI::plotFFTMeasurement(int index)
{
    if (index < m_fftMeasurements.size())
    {
        FFTMeasurement *fft = m_fftMeasurements[index];

        m_fftSeries->clear();
        m_fftHlineSeries->clear();
        m_fftGaussianSeries->clear();
        m_fftLABSeries->clear();
        m_fftPeakSeries->clear();

        double binRes = fft->m_sampleRate / (double)fft->m_fftSize;
        double startFreq = fft->m_centerFrequency - fft->m_sampleRate / 2.0;

        // Plot reference spectral line and Doppler axis
        plotRefLine(fft);

        // Plot Gaussian for temp estimation
        plotTempGaussian(startFreq, binRes, fft->m_fftSize);

        // Plot LAB reference data
        if (   fft->m_coordsValid && m_settings.m_spectrumLAB
            && (   (m_settings.m_spectrumYScale == RadioAstronomySettings::SY_TSYS)
                || (m_settings.m_spectrumYScale == RadioAstronomySettings::SY_TSOURCE)
               )
           )
        {
            plotLAB(fft->m_l, fft->m_b, m_beamWidth);
        }

        if (   ((m_settings.m_spectrumYScale == RadioAstronomySettings::SY_SNR) && !fft->m_snr)
            || ((m_settings.m_spectrumYScale == RadioAstronomySettings::SY_DBM) && !fft->m_temp)
            || ((m_settings.m_spectrumYScale == RadioAstronomySettings::SY_TSYS) && !fft->m_temp)
            || ((m_settings.m_spectrumYScale == RadioAstronomySettings::SY_TSOURCE) && !fft->m_temp)
           )
        {
            m_fftChart->setTitle("No cal data: Run calibration or set units to dBFS.");
        }
        else
        {
            m_fftChart->setTitle("");

            if (fft->m_coordsValid)
            {
                m_fftChart->setTitle(QString("RA: %1 Dec: %2 l: %3%7 b: %4%7 Az: %5%7 El: %6%7")
                                            .arg(Units::decimalHoursToHoursMinutesAndSeconds(fft->m_ra))
                                            .arg(Units::decimalDegreesToDegreeMinutesAndSeconds(fft->m_dec))
                                            .arg(QString::number(fft->m_l, 'f', 1))
                                            .arg(QString::number(fft->m_b, 'f', 1))
                                            .arg(QString::number(fft->m_azimuth, 'f', 0))
                                            .arg(QString::number(fft->m_elevation, 'f', 0))
                                            .arg(QChar(0xb0)));
            }

            int peakIdx = 0;
            double peakValue = -std::numeric_limits<double>::max();

            double freq = startFreq;   // Main spectrum seems to use bin midpoint - this uses lowest frequency, so we're tone at centre freq appears in centre of plot

            // Plot power/temp
            for (int i = 0; i < fft->m_fftSize; i++)
            {
                qreal value;
                switch (m_settings.m_spectrumYScale)
                {
                case RadioAstronomySettings::SY_DBFS:
                    value = fft->m_db[i];
                    break;
                case RadioAstronomySettings::SY_SNR:
                    value = fft->m_snr[i];
                    break;
                case RadioAstronomySettings::SY_DBM:
                    value = Astronomy::noisePowerdBm(fft->m_temp[i], fft->m_sampleRate/(double)fft->m_fftSize);
                    break;
                case RadioAstronomySettings::SY_TSYS:
                    value = fft->m_temp[i];
                    break;
                case RadioAstronomySettings::SY_TSOURCE:
                    switch (m_settings.m_spectrumBaseline)
                    {
                    case RadioAstronomySettings::SBL_TSYS0:
                        value = fft->m_temp[i] - fft->m_tSys0;
                        break;
                    case RadioAstronomySettings::SBL_TMIN:
                        value = fft->m_temp[i] - fft->m_tempMin;
                        break;
                    case RadioAstronomySettings::SBL_CAL_COLD:
                        if (m_calCold) {
                            value = m_calG[i] * (fft->m_fftData[i] - m_calCold->m_fftData[i]);
                        } else {
                            value = 0.0;
                        }
                        break;
                    }
                    break;
                }
                if (value > peakValue)
                {
                    peakValue = value;
                    peakIdx = i;
                }

                m_fftSeries->append(freq / 1e6, value);
                freq += binRes;
            }

            double startFreqMHz = fft->m_centerFrequency/1e6 - m_settings.m_spectrumSpan / 2.0;

            spectrumUpdateXRange(fft);
            spectrumUpdateYRange(fft);
            m_fftXAxis->setReverse(m_settings.m_spectrumReverseXAxis);

            switch (m_settings.m_spectrumYScale)
            {
            case RadioAstronomySettings::SY_DBFS:
                m_fftYAxis->setTitleText("Power (dBFS)");
                break;
            case RadioAstronomySettings::SY_SNR:
                m_fftYAxis->setTitleText("SNR");
                break;
            case RadioAstronomySettings::SY_DBM:
                m_fftYAxis->setTitleText("Power (dBm)");
                break;
            case RadioAstronomySettings::SY_TSYS:
                m_fftYAxis->setTitleText("Tsys (K)");
                break;
            case RadioAstronomySettings::SY_TSOURCE:
                m_fftYAxis->setTitleText("Tsource (K)");
                break;
            }

            // Plot peaks
            if (m_settings.m_spectrumPeaks)
            {
                double peakFreqMHz = (startFreq + peakIdx * binRes) / 1e6;
                double peakFreq = peakFreqMHz * 1e6;

                m_fftPeakSeries->append(peakFreqMHz, peakValue);

                ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_PEAK, SPECTRUM_MARKER_COL_FREQ)->setData(Qt::DisplayRole, peakFreqMHz);
                ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_PEAK, SPECTRUM_MARKER_COL_VALUE)->setData(Qt::DisplayRole, peakValue);

                calcVrAndDistanceToPeak(peakFreq, fft, SPECTRUM_MARKER_ROW_PEAK);
            }

            // Update markers to track current data
            if (m_spectrumM1Valid)
            {
                m_fftMarkerSeries->clear();
                int idx;
                idx = (m_spectrumM1X - startFreqMHz) / (binRes/1e6);
                if ((idx >= 0) && (idx < m_fftSeries->count()))
                {
                    m_spectrumM1Y = m_fftSeries->at(idx).y();
                    ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M1, SPECTRUM_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_spectrumM1Y);
                    m_fftMarkerSeries->append(m_spectrumM1X, m_spectrumM1Y);
                    calcVrAndDistanceToPeak(m_spectrumM1X*1e6, fft, SPECTRUM_MARKER_ROW_M1);
                }
                if (m_spectrumM2Valid)
                {
                    idx = (m_spectrumM2X - startFreqMHz) / (binRes/1e6);
                    if (idx < m_fftSeries->count())
                    {
                        m_spectrumM2Y = m_fftSeries->at(idx).y();
                        ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_spectrumM2Y);
                        m_fftMarkerSeries->append(m_spectrumM2X, m_spectrumM2Y);
                        calcVrAndDistanceToPeak(m_spectrumM2X*1e6, fft, SPECTRUM_MARKER_ROW_M2);
                        calcSpectrumMarkerDelta();
                    }
                }
            }

            spectrumAutoscale();
        }
    }
}

bool RadioAstronomyGUI::losMarkerEnabled(const QString& name)
{
    if (m_settings.m_spectrumDistance && m_settings.m_spectrumRefLine)
    {
        if (name == "Max") {
            return m_settings.m_spectrumPeaks;
        } else if (name == "M1") {
            return m_settings.m_spectrumMarkers;
        } else {
            return m_settings.m_spectrumMarkers;
        }
    }
    return false;
}

void RadioAstronomyGUI::showLoSMarker(const QString& name)
{
    if (losMarkerEnabled(name))
    {
        if (name == "Max") {
            showLoSMarker(SPECTRUM_MARKER_ROW_PEAK);
        } else if (name == "M1") {
            showLoSMarker(SPECTRUM_MARKER_ROW_M1);
        } else {
            showLoSMarker(SPECTRUM_MARKER_ROW_M2);
        }
    }
}

void RadioAstronomyGUI::showLoSMarker(int row)
{
    bool ok;
    float d = ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_D)->data(Qt::DisplayRole).toFloat(&ok);
    if (ok)
    {
        FFTMeasurement *fft = currentFFT();
        if (fft)
        {
            QString name = ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_NAME)->text();
            updateLoSMarker(name, fft->m_l, fft->m_b, d);
        }
    }
}

void RadioAstronomyGUI::updateLoSMarker(const QString& name, float l, float b, float d)
{
    // Send to Star Tracker
    QList<ObjectPipe*> starTrackerPipes;
    MainCore::instance()->getMessagePipes().getMessagePipes(m_radioAstronomy, "startracker.display", starTrackerPipes);

    for (const auto& pipe : starTrackerPipes)
    {
        MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
        SWGSDRangel::SWGStarTrackerDisplayLoSSettings *swgSettings = new SWGSDRangel::SWGStarTrackerDisplayLoSSettings();
        swgSettings->setName(new QString(name));
        swgSettings->setL(l);
        swgSettings->setB(b);
        swgSettings->setD(d);
        messageQueue->push(MainCore::MsgStarTrackerDisplayLoSSettings::create(m_radioAstronomy, swgSettings));
    }
}

void RadioAstronomyGUI::clearLoSMarker(const QString& name)
{
    // Set d to 0 to clear
    updateLoSMarker(name, 0.0f, 0.0f, 0.0f);
}

void RadioAstronomyGUI::calcVrAndDistanceToPeak(double freq, FFTMeasurement *fft, int row)
{
    double lineFreq = ui->spectrumLineFrequency->value() * 1e6;

    // Calculate radial velocity (along line-of-sight) from Doppler shift
    double vR = dopplerToVelocity(lineFreq, freq, fft);
    ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_VR)->setData(Qt::DisplayRole, vR);

    // Tangent point method only valid for Galactic quadrants I (0-90) and IV (270-360)
    if ((fft->m_l < 90.0) || (fft->m_l > 270.0))
    {
        // Calculate minimum distance to Galactic centre along line of sight (tangential radius)
        double rMin = m_settings.m_sunDistanceToGC * sin(Units::degreesToRadians(fft->m_l));
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_R_MIN)->setData(Qt::DisplayRole, rMin);

        // Calculate orbital velocity at tangent/minimum point
        // This is the velocity to plot for the rotation curve
        double w0 = m_settings.m_sunOrbitalVelocity / m_settings.m_sunDistanceToGC;
        double vOrb = vR + rMin * w0;
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_V)->setData(Qt::DisplayRole, vOrb);
    }
    else
    {
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_R_MIN)->setText("");
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_V)->setText("");
    }

    // Calculate distance of HI cloud (as indicated by a peak) to Sun and Galactic center
    double r, d1, d2;
    int solutions = calcDistanceToPeak(vR, fft->m_l, fft->m_b, r, d1, d2);
    if (solutions == 0)
    {
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_R)->setText("");
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_D)->setText("");
    }
    else if (solutions == 1)
    {
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_R)->setData(Qt::DisplayRole, r);
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_D)->setData(Qt::DisplayRole, d1);
    }
    else
    {
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_R)->setData(Qt::DisplayRole, r);
        ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_D)->setText(QString("%1/%2").arg(QString::number(d1, 'f', 1)).arg(QString::number(d2, 'f', 1)));
    }

    // Send to Star Tracker
    QString name = ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_NAME)->text();
    if (losMarkerEnabled(name))
    {
        if ((solutions == 0) || std::isnan(d1))
        {
            updateLoSMarker(name, fft->m_l, fft->m_b, 0.0f);
        }
        else if (solutions == 1)
        {
            updateLoSMarker(name, fft->m_l, fft->m_b, d1);
        }
        else
        {
            bool plotMax = ui->spectrumMarkerTable->item(row, SPECTRUM_MARKER_COL_PLOT_MAX)->checkState() == Qt::Checked;
            if ((plotMax && (d1 > d2)) || (!plotMax && (d1 < d2))) {
                updateLoSMarker(name, fft->m_l, fft->m_b, d1);
            } else {
                updateLoSMarker(name, fft->m_l, fft->m_b, d2);
            }
        }
    }
}

int RadioAstronomyGUI::calcDistanceToPeak(double vr, float l, float b, double& r, double &d1, double &d2)
{
    // Radio Astronomy 4th edition - Burke - p343
    double r0 = m_settings.m_sunDistanceToGC; // Distance of Sun to Galactic centre in kpc
    double v0 = m_settings.m_sunOrbitalVelocity; // Orbital velocity of the Sun around Galactic centre in km/s
    double w0 = v0/r0;   // Angular velocity of the Sun
    double gl = Units::degreesToRadians(l);
    double gb = Units::degreesToRadians(b);
    double w = vr/(r0*sin(gl)*cos(gb))+w0;
    r = v0/w; // Assume constant v, regardless of distance from GC - Dark matter magic - Not valid <1kpc from GC
    if (r < 0) {
        return 0;
    }
    // https://en.wikipedia.org/wiki/Solution_of_triangles#Two_sides_and_non-included_angle_given_(SSA)
    double beta = gl;
    double d = sin(beta)*r0/r;
    if (d > 1.0) {
        // No solutions
        return 0;
    }
    if ((r <= r0) && (beta >= M_PI/2.0)) {
        return 0;
    }
    double gamma = asin(d);
    double alpha1 = M_PI - beta - gamma;
    d1 = r * sin(alpha1)/sin(beta); // Distance from Sun to peak
    if (r < r0)
    {
        double alpha2 = M_PI - beta - (M_PI-gamma);
        d2 = r * sin(alpha2)/sin(beta); // Distance from Sun to peak
        return 2;
    }
    else
    {
        return 1;
    }
}

void RadioAstronomyGUI::spectrumMarkerTableItemChanged(QTableWidgetItem *item)
{
    if (item->column() == SPECTRUM_MARKER_COL_PLOT_MAX) {
        // Plot max checkbox clicked
        calcDistances();
    }
}

void RadioAstronomyGUI::calcDistances()
{
    double freq;
    bool ok;
    FFTMeasurement* fft = currentFFT();
    if (fft)
    {
        freq = ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_PEAK, SPECTRUM_MARKER_COL_FREQ)->data(Qt::DisplayRole).toDouble(&ok);
        if (ok) {
            calcVrAndDistanceToPeak(freq*1e6, fft, SPECTRUM_MARKER_ROW_PEAK);
        }
        freq = ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M1, SPECTRUM_MARKER_COL_FREQ)->data(Qt::DisplayRole).toDouble(&ok);
        if (ok) {
            calcVrAndDistanceToPeak(freq*1e6, fft, SPECTRUM_MARKER_ROW_M1);
        }
        freq = ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_FREQ)->data(Qt::DisplayRole).toDouble(&ok);
        if (ok) {
            calcVrAndDistanceToPeak(freq*1e6, fft, SPECTRUM_MARKER_ROW_M2);
        }
    }
}

void RadioAstronomyGUI::plotRefLine(FFTMeasurement *fft)
{
    double lineFreqMHz = ui->spectrumLineFrequency->value();
    double lineFreq = lineFreqMHz * 1e6;
    QString refFrame[] = {"Topocentric", "Barycentric", "LSR"};
    m_fftDopplerAxis->setTitleText(QString("%1 radial velocity (km/s - +ve receding)").arg(refFrame[m_settings.m_refFrame]));
    m_fftHlineSeries->setName(QString("%1 line").arg(ui->spectrumLine->currentText()));
    m_fftHlineSeries->append(0.0f, -200.0f); // For dB
    m_fftHlineSeries->append(0.0f, 10000.0f); // For temp can be >1e6?
    double startFreq = fft->m_centerFrequency + m_settings.m_spectrumSpan*1e6 / 2.0 + m_settings.m_spectrumCenterFreqOffset*1e6;
    double endFreq = fft->m_centerFrequency - m_settings.m_spectrumSpan*1e6 / 2.0 + m_settings.m_spectrumCenterFreqOffset*1e6;
    m_fftDopplerAxis->setRange(dopplerToVelocity(lineFreq, startFreq, fft),
                               dopplerToVelocity(lineFreq, endFreq, fft));
    m_fftDopplerAxis->setReverse(!m_settings.m_spectrumReverseXAxis);
    m_fftDopplerAxis->setVisible(m_settings.m_spectrumRefLine);
}

void RadioAstronomyGUI::plotTempGaussian(double startFreq, double freqStep, int steps)
{
    m_fftGaussianSeries->clear();
    double f0 = ui->spectrumGaussianFreq->value() * 1e6;
    double a = ui->spectrumGaussianAmp->value();
    double floor = ui->spectrumGaussianFloor->value();
    double fwhm = ui->spectrumGaussianFWHM->value();
    double fwhm_sq = fwhm*fwhm;
    double freq = startFreq;
    for (int i = 0; i < steps; i++)
    {
        double fd = freq - f0;
        double g = a * std::exp(-4.0*M_LN2*fd*fd/fwhm_sq) + floor;
        m_fftGaussianSeries->append(freq/1e6, g);
        freq += freqStep;
    }
}

void RadioAstronomyGUI::calcFFTPower(FFTMeasurement* fft)
{
    // Convert linear to dB
    for (int i = 0; i < fft->m_fftSize; i++) {
        fft->m_db[i] = CalcDb::dbPower(fft->m_fftData[i]);
    }
}

void RadioAstronomyGUI::calcFFTTotalPower(FFTMeasurement* fft)
{
    double total = 0.0;
    for (int i = 0; i < fft->m_fftSize; i++) {
        total += fft->m_fftData[i];
    }
    fft->m_totalPower = total;
    fft->m_totalPowerdBFS = CalcDb::dbPower(total);
}

void RadioAstronomyGUI::calcFFTTemperatures(FFTMeasurement* fft)
{
    if (m_calCold && !fft->m_snr) {
        fft->m_snr = new Real[fft->m_fftSize];
    }
    if (m_calG && !fft->m_temp) {
        fft->m_temp = new Real[fft->m_fftSize];
    }
    for (int i = 0; i < fft->m_fftSize; i++)
    {
        if (fft->m_snr && m_calCold)
        {
            // Calculate SNR (relative to cold cal)
            fft->m_snr[i] = fft->m_fftData[i] / m_calCold->m_fftData[i];
        }
        if (m_calG)
        {
            // Calculate temperature using scaling from hot cal
            fft->m_temp[i] = m_calG[i] * fft->m_fftData[i];
            // Calculate temperature using linear interpolation from hot/cold cal
            //fft->m_temp[i] = m_calG[i] * (fft->m_fftData[i] - m_calCold->m_fftData[i]) + m_settings.m_tCalCold;
            //fft->m_temp[i] = std::max(fft->m_temp[i], 0.0f); // Can't have negative temperatures
        }
    }
    calcFFTMinTemperature(fft);
}

void RadioAstronomyGUI::calcFFTMinTemperature(FFTMeasurement* fft)
{
    fft->m_tempMin = 0;
    if (fft->m_temp)
    {
        // Select minimum from within band. 95% of that to account for a little bit of inband rolloff
        float tempMin = std::numeric_limits<float>::max();
        double pc = 0.95 * fft->m_rfBandwidth / (double)fft->m_sampleRate;
        int count = (int)(pc * fft->m_fftSize);
        int start = (fft->m_fftSize - count) / 2;
        for (int i = 0; i < count; i++)
        {
            int idx = i + start;
            tempMin = std::min(tempMin, fft->m_temp[idx]);
        }
        if (tempMin != std::numeric_limits<float>::max()) {
            fft->m_tempMin = tempMin;
        }
    }
}

// Estimate Tsource by subtracting selected baseline
double RadioAstronomyGUI::calcTSource(FFTMeasurement *fft) const
{
    switch (fft->m_baseline)
    {
    case RadioAstronomySettings::SBL_TSYS0:
        return fft->m_tSys - fft->m_tSys0;
    case RadioAstronomySettings::SBL_TMIN:
        return fft->m_tSys - fft->m_tempMin;
    case RadioAstronomySettings::SBL_CAL_COLD:
        if (m_calCold) {
            return fft->m_tSys - m_calCold->m_tSys;
        }
        break;
    }
    return fft->m_tSys;
}

// Calculate spectral flux density of source
double RadioAstronomyGUI::calcFlux(double Ta, const FFTMeasurement *fft) const
{
    // Factor of 2 here assumes single polarization
    // See equation 5.13 and 5.20 in Radio Astronomy 4th edition - Burke
    double lambda = Astronomy::m_speedOfLight / (double)fft->m_centerFrequency;
    return 2.0 * Astronomy::m_boltzmann * Ta * fft->m_omegaA / (lambda * lambda);
}

void RadioAstronomyGUI::calcFFTTotalTemperature(FFTMeasurement* fft)
{
    if (fft->m_temp)
    {
        double tempSum = 0.0;
        for (int i = 0; i < fft->m_fftSize; i++) {
            tempSum += fft->m_temp[i];
        }

        // Convert from temperature to power in Watts and dBm
        Real bw = fft->m_sampleRate/(Real)fft->m_fftSize;
        fft->m_totalPowerWatts = Astronomy::m_boltzmann * tempSum * bw;
        fft->m_totalPowerdBm = Astronomy::noisePowerdBm(tempSum, bw);
        fft->m_tSys = tempSum/fft->m_fftSize;

        // Estimate source temperature
        fft->m_tSource = calcTSource(fft);

        // Calculate error due to thermal noise and gain variation
        fft->m_sigmaT = calcSigmaT(fft);
        fft->m_sigmaS = calcSigmaS(fft);

        // Calculate spectral flux density of source
        fft->m_flux = calcFlux(fft->m_tSource, fft);
    }
}

void RadioAstronomyGUI::updatePowerColumns(int row, FFTMeasurement* fft)
{
    ui->powerTable->item(row, POWER_COL_TSYS)->setData(Qt::DisplayRole, fft->m_tSys);
    ui->powerTable->item(row, POWER_COL_TSYS0)->setData(Qt::DisplayRole, fft->m_tSys0);
    ui->powerTable->item(row, POWER_COL_TSOURCE)->setData(Qt::DisplayRole, fft->m_tSource);
    if (m_settings.m_sourceType != RadioAstronomySettings::UNKNOWN) {
        ui->powerTable->item(row, POWER_COL_TB)->setData(Qt::DisplayRole, fft->m_tSource/beamFillingFactor());
    } else {
        ui->powerTable->item(row, POWER_COL_TB)->setText("");
    }
    ui->powerTable->item(row, POWER_COL_FLUX)->setData(Qt::DisplayRole, Units::wattsPerMetrePerHertzToJansky(fft->m_flux));
    ui->powerTable->item(row, POWER_COL_SIGMA_T)->setData(Qt::DisplayRole, fft->m_sigmaT);
    ui->powerTable->item(row, POWER_COL_SIGMA_S)->setData(Qt::DisplayRole, fft->m_sigmaS);
    ui->powerTable->item(row, POWER_COL_OMEGA_A)->setData(Qt::DisplayRole, fft->m_omegaA);
    ui->powerTable->item(row, POWER_COL_OMEGA_S)->setData(Qt::DisplayRole, fft->m_omegaS);
}

void RadioAstronomyGUI::addFFT(FFTMeasurement *fft, bool skipCalcs)
{
    m_fftMeasurements.append(fft);

    powerMeasurementReceived(fft, skipCalcs); // Call before ui->spectrumIndex->setValue, so table row is valid
    update2DImage(fft, skipCalcs);

    ui->spectrumIndex->setRange(0, m_fftMeasurements.size() - 1);
    if ((ui->spectrumIndex->value() == m_fftMeasurements.size() - 2) || (m_fftMeasurements.size() == 1)) {
        ui->spectrumIndex->setValue(m_fftMeasurements.size() - 1);
    }
    if ( m_fftMeasurements.size() == 1)
    {
        // Force drawing for first measurement
        on_spectrumIndex_valueChanged(0);
    }
}

void RadioAstronomyGUI::getRotatorData(FFTMeasurement *fft)
{
    unsigned int rotatorFeatureSetIndex, rotatorFeatureIndex;

    if (MainCore::getFeatureIndexFromId(m_settings.m_rotator, rotatorFeatureSetIndex, rotatorFeatureIndex))
    {
        SWGSDRangel::SWGFeatureReport featureReport;
        double value;
        qDebug() << m_settings.m_rotator << rotatorFeatureSetIndex << rotatorFeatureIndex;

        if (ChannelWebAPIUtils::getFeatureReport(rotatorFeatureSetIndex, rotatorFeatureIndex, featureReport))
        {
            QJsonObject *jsonObj = featureReport.asJsonObject();
            qDebug() << *jsonObj;
            if (WebAPIUtils::getSubObjectDouble(*jsonObj, "currentAzimuth", value)) {
                fft->m_rotAz = value;
            } else {
                qDebug() << "RadioAstronomyGUI::getRotatorData: getSubObjectDouble currentAzimuth failed";
            }
            if (WebAPIUtils::getSubObjectDouble(*jsonObj, "currentElevation", value)) {
                fft->m_rotEl = value;
            } else {
                qDebug() << "RadioAstronomyGUI::getRotatorData: getSubObjectDouble currentElevation failed";
            }
        }
        else
        {
            qDebug() << "RadioAstronomyGUI::getRotatorData: getFeatureReport failed";
        }

        SWGSDRangel::SWGFeatureSettings featureSettingsResponse;
        Feature *feature;
        if (ChannelWebAPIUtils::getFeatureSettings(rotatorFeatureSetIndex, rotatorFeatureIndex, featureSettingsResponse, feature))
        {
            QJsonObject *jsonObj = featureSettingsResponse.asJsonObject();
            qDebug() << *jsonObj;
            if (WebAPIUtils::getSubObjectDouble(*jsonObj, "azimuthOffset", value)) {
                fft->m_rotAzOff = value;
            } else {
                qDebug() << "RadioAstronomyGUI::getRotatorData: getSubObjectDouble azimuthOffset failed";
            }
            if (WebAPIUtils::getSubObjectDouble(*jsonObj, "elevationOffset", value)) {
                fft->m_rotElOff = value;
            } else {
                qDebug() << "RadioAstronomyGUI::getRotatorData: getSubObjectDouble elevationOffset ";
            }
        }
        else
        {
            qDebug() << "RadioAstronomyGUI::getRotatorData: getFeatureSettings failed";
        }

        fft->m_rotValid = true;
    }
    else
        qDebug() << "Couldn't parse rotator feature " << m_settings.m_rotator;
}

void RadioAstronomyGUI::fftMeasurementReceived(const RadioAstronomy::MsgFFTMeasurement& measurement)
{
    FFTMeasurement *fft = new FFTMeasurement();
    fft->m_fftData = measurement.getFFT();
    fft->m_fftSize = measurement.getSize();
    fft->m_dateTime = measurement.getDateTime();
    fft->m_centerFrequency = m_centerFrequency;
    fft->m_sampleRate = m_settings.m_sampleRate;
    fft->m_integration = m_settings.m_integration;
    fft->m_rfBandwidth = m_settings.m_rfBandwidth;
    fft->m_omegaA = calcOmegaA();
    fft->m_omegaS = calcOmegaS();
    fft->m_coordsValid = m_coordsValid;
    fft->m_ra = m_ra;
    fft->m_dec = m_dec;
    fft->m_azimuth = m_azimuth;
    fft->m_elevation = m_elevation;
    fft->m_l = m_l;
    fft->m_b = m_b;
    fft->m_vBCRS = m_vBCRS;
    fft->m_vLSR = m_vLSR;
    fft->m_solarFlux = m_solarFlux;
    fft->m_airTemp = m_airTemps.lastValue();
    fft->m_skyTemp = m_skyTemp;
    for (int i = 0; i < RADIOASTRONOMY_SENSORS; i++) {
        fft->m_sensor[i] = m_sensors[i].lastValue();
    }
    fft->m_db = new Real[fft->m_fftSize];
    fft->m_sweepIndex = m_sweepIndex++;
    fft->m_tSys0 = calcTSys0();
    fft->m_baseline = m_settings.m_spectrumBaseline;
    getRotatorData(fft);

    calcFFTPower(fft);
    calcFFTTotalPower(fft);
    calcFFTTemperatures(fft);
    calcFFTTotalTemperature(fft);
    addFFT(fft);
}

void RadioAstronomyGUI::on_spectrumIndex_valueChanged(int value)
{
    if (value < m_fftMeasurements.size())
    {
        plotFFTMeasurement(value);

        // Highlight in table
        ui->powerTable->selectRow(value);
        ui->powerTable->scrollTo(ui->powerTable->model()->index(value, 0));
        ui->spectrumDateTime->setDateTime(m_fftMeasurements[value]->m_dateTime);

        // Display target in Star Tracker
        QList<ObjectPipe*> starTrackerPipes;
        MainCore::instance()->getMessagePipes().getMessagePipes(m_radioAstronomy, "startracker.display", starTrackerPipes);

        for (const auto& pipe : starTrackerPipes)
        {
            MessageQueue *messageQueue = qobject_cast<MessageQueue*>(pipe->m_element);
            SWGSDRangel::SWGStarTrackerDisplaySettings *swgSettings = new SWGSDRangel::SWGStarTrackerDisplaySettings();
            swgSettings->setDateTime(new QString(m_fftMeasurements[value]->m_dateTime.toString(Qt::ISODateWithMs)));
            swgSettings->setAzimuth(m_fftMeasurements[value]->m_azimuth);
            swgSettings->setElevation(m_fftMeasurements[value]->m_elevation);
            messageQueue->push(MainCore::MsgStarTrackerDisplaySettings::create(m_radioAstronomy, swgSettings));
        }
    }
}

void RadioAstronomyGUI::plotSpectrum()
{
    QChart *oldChart = m_fftChart;

    m_fftChart = new QChart();

    m_fftChart->layout()->setContentsMargins(0, 0, 0, 0);
    m_fftChart->setMargins(QMargins(1, 1, 1, 1));
    m_fftChart->setTheme(QChart::ChartThemeDark);

    m_fftChart->legend()->setAlignment(Qt::AlignRight);
    m_fftChart->legend()->setVisible(m_settings.m_spectrumLegend);

    m_fftSeries = new QLineSeries();
    m_fftSeries->setName("Measurement");
    connect(m_fftSeries, &QXYSeries::clicked, this, &RadioAstronomyGUI::spectrumSeries_clicked);

    // Plot vertical reference spectral line
    m_fftHlineSeries = new QLineSeries();
    m_fftHlineSeries->setName(QString("%1 line").arg(ui->spectrumLine->currentText()));
    m_fftHlineSeries->setVisible(m_settings.m_spectrumRefLine);

    // Plot peak info
    m_fftPeakSeries = new QScatterSeries();
    m_fftPeakSeries->setPointLabelsVisible(true);
    m_fftPeakSeries->setMarkerSize(5);
    m_fftPeakSeries->setName("Max");

    // Markers
    m_fftMarkerSeries = new QScatterSeries();
    m_fftMarkerSeries->setPointLabelsVisible(true);
    m_fftMarkerSeries->setMarkerSize(5);
    m_fftMarkerSeries->setName("Markers");

    // Gaussian
    m_fftGaussianSeries = new QLineSeries();
    m_fftGaussianSeries->setName("Gaussian fit");
    m_fftGaussianSeries->setVisible(m_settings.m_spectrumTemp);

    m_fftLABSeries  = new QLineSeries();
    m_fftLABSeries->setName("LAB reference");
    m_fftLABSeries->setVisible(m_settings.m_spectrumLAB);

    m_fftXAxis = new QValueAxis();
    m_fftYAxis = new QValueAxis();
    m_fftDopplerAxis = new QValueAxis();

    m_fftChart->addAxis(m_fftXAxis, Qt::AlignBottom);
    m_fftChart->addAxis(m_fftYAxis, Qt::AlignLeft);
    m_fftChart->addAxis(m_fftDopplerAxis, Qt::AlignTop);

    m_fftXAxis->setTitleText("Frequency (MHz)");
    calcSpectrumChartTickCount(m_fftXAxis, size().width());
    calcSpectrumChartTickCount(m_fftDopplerAxis, size().width());
    m_fftYAxis->setTitleText("Power");

    m_fftChart->addSeries(m_fftSeries);
    m_fftSeries->attachAxis(m_fftXAxis);
    m_fftSeries->attachAxis(m_fftYAxis);

    m_fftChart->addSeries(m_fftHlineSeries);
    //m_fftHlineSeries->attachAxis(m_fftXAxis);
    m_fftHlineSeries->attachAxis(m_fftDopplerAxis);
    m_fftHlineSeries->attachAxis(m_fftYAxis);

    m_fftChart->addSeries(m_fftGaussianSeries);
    m_fftGaussianSeries->attachAxis(m_fftXAxis);
    m_fftGaussianSeries->attachAxis(m_fftYAxis);

    m_fftChart->addSeries(m_fftLABSeries);
    //m_fftLABSeries->attachAxis(m_fftXAxis);
    m_fftLABSeries->attachAxis(m_fftDopplerAxis);
    m_fftLABSeries->attachAxis(m_fftYAxis);

    m_fftChart->addSeries(m_fftPeakSeries);
    m_fftPeakSeries->attachAxis(m_fftXAxis);
    m_fftPeakSeries->attachAxis(m_fftYAxis);

    m_fftChart->addSeries(m_fftMarkerSeries);
    m_fftMarkerSeries->attachAxis(m_fftXAxis);
    m_fftMarkerSeries->attachAxis(m_fftYAxis);

    // Don't have peaks and markers in legend
    m_fftChart->legend()->markers(m_fftPeakSeries)[0]->setVisible(false);
    m_fftChart->legend()->markers(m_fftMarkerSeries)[0]->setVisible(false);

    ui->spectrumChart->setChart(m_fftChart);

    delete oldChart;
}

// Calculate galactic background temperature based on center frequency
void RadioAstronomyGUI::calcGalacticBackgroundTemp()
{
    // https://arxiv.org/ftp/arxiv/papers/1912/1912.12699.pdf - page 6
    // 17.1, 25.2 and 54.8 K for the 10th, 50th and 90th percentile of the all-sky distribution
    // See also ITU-R P.372-7 section 6
    // If this is used for cold calibration, we don't want to use the higher value
    double temp = 25.2 * std::pow(m_centerFrequency/408000000.0, -2.75);
    ui->tempGal->setValue(temp);
}

// Calculate athmospheric noise temperature based on air temperature, zenith opacity and elevation
void RadioAstronomyGUI::calcAtmosphericTemp()
{
    float el = m_settings.m_elevation;
    if (m_settings.m_elevation < 1.0f) {
        el = 1.0f; // Avoid divide by 0 and limit max value to match ITU-R P.372-7 figure 5
    }
    double temp = Units::celsiusToKelvin(m_settings.m_tempAir) * (1.0 - std::exp(-m_settings.m_zenithOpacity/cos(Units::degreesToRadians(90.0f - el))));
    ui->tempAtm->setValue(temp);
}

void RadioAstronomyGUI::on_tempRXSelect_currentIndexChanged(int value)
{
    if (value == 0)
    {
        // T_RX
        ui->tempRX->setValue(m_settings.m_tempRX);
        ui->tempRXUnitsLabel->setText("K");
    }
    else
    {
        // NF
        ui->tempRX->setValue(Units::noiseTempToNoiseFigureTo(m_settings.m_tempRX));
        ui->tempRXUnitsLabel->setText("dB");
    }
}

void RadioAstronomyGUI::on_tempRX_valueChanged(double value)
{
    if (ui->tempRXSelect->currentIndex() == 0) {
        m_settings.m_tempRX = value;
    } else {
        m_settings.m_tempRX = Units::noiseFigureToNoiseTemp(value);
    }
    updateTSys0();
    applySettings();
}

void RadioAstronomyGUI::on_tempCMB_valueChanged(double value)
{
    m_settings.m_tempCMB = value;
    updateTSys0();
    applySettings();
}

void RadioAstronomyGUI::on_tempGal_valueChanged(double value)
{
    m_settings.m_tempGal = value;
    updateTSys0();
    applySettings();
}

void RadioAstronomyGUI::on_tempSP_valueChanged(double value)
{
    m_settings.m_tempSP = value;
    updateTSys0();
    applySettings();
}

void RadioAstronomyGUI::on_tempAtm_valueChanged(double value)
{
    m_settings.m_tempAtm = value;
    updateTSys0();
    applySettings();
}

void RadioAstronomyGUI::on_tempAir_valueChanged(double value)
{
    m_settings.m_tempAir = value;
    if (m_settings.m_tempAtmLink) {
        calcAtmosphericTemp();
    }
    applySettings();
}

void RadioAstronomyGUI::on_zenithOpacity_valueChanged(double value)
{
    m_settings.m_zenithOpacity = value;
    if (m_settings.m_tempAtmLink) {
        calcAtmosphericTemp();
    }
    applySettings();
}

void RadioAstronomyGUI::on_elevation_valueChanged(double value)
{
    m_settings.m_elevation = value;
    if (m_settings.m_tempAtmLink) {
        calcAtmosphericTemp();
    }
    applySettings();
}

void RadioAstronomyGUI::on_elevationLink_toggled(bool checked)
{
    m_settings.m_elevationLink = checked;
    ui->elevation->setValue(m_elevation);
    ui->elevation->setEnabled(!m_settings.m_elevationLink);
    applySettings();
}

void RadioAstronomyGUI::on_tempAtmLink_toggled(bool checked)
{
    m_settings.m_tempAtmLink = checked;
    ui->tempAtm->setEnabled(!m_settings.m_tempAtmLink);
    if (checked) {
        calcAtmosphericTemp();
    }
    applySettings();
}

void RadioAstronomyGUI::on_tempAirLink_toggled(bool checked)
{
    m_settings.m_tempAirLink = checked;
    ui->tempAir->setEnabled(!m_settings.m_tempAirLink);
    if (checked)
    {
        ui->tempAir->setValue(m_airTemps.lastValue());
        calcAtmosphericTemp();
    }
    applySettings();
}

void RadioAstronomyGUI::on_tempGalLink_toggled(bool checked)
{
    m_settings.m_tempGalLink = checked;
    if (checked) {
        calcGalacticBackgroundTemp();
    }
    ui->tempGal->setEnabled(!m_settings.m_tempGalLink);
    applySettings();
}

void RadioAstronomyGUI::on_tCalHotSelect_currentIndexChanged(int value)
{
    if (value == 0)
    {
        // Thot
        ui->tCalHot->setValue(m_settings.m_tCalHot);
        ui->tCalHotUnitsLabel->setText("K");
    }
    else
    {
        // Phot
        double power = Astronomy::noisePowerdBm(m_settings.m_tCalHot, m_settings.m_sampleRate);
        ui->tCalHot->setValue(power);
        ui->tCalHotUnitsLabel->setText("dBm");
    }
}

void RadioAstronomyGUI::on_tCalHot_valueChanged(double value)
{
    double temp;
    if (ui->tCalHotSelect->currentIndex() == 0) {
        temp = value;
    } else {
        temp = Astronomy::noiseTemp(value, m_settings.m_sampleRate);
    }
    m_settings.m_tCalHot = (float)temp;
    calibrate();
    applySettings();
}

void RadioAstronomyGUI::on_tCalColdSelect_currentIndexChanged(int value)
{
    if (value == 0)
    {
        // Tcold
        ui->tCalCold->setValue(m_settings.m_tCalCold);
        ui->tCalColdUnitsLabel->setText("K");
    }
    else
    {
        // Pcold
        double power = Astronomy::noisePowerdBm(m_settings.m_tCalCold, m_settings.m_sampleRate);
        ui->tCalCold->setValue(power);
        ui->tCalColdUnitsLabel->setText("dBm");
    }
}

void RadioAstronomyGUI::on_tCalCold_valueChanged(double value)
{
    double temp;
    if (ui->tCalColdSelect->currentIndex() == 0) {
        temp = value;
    } else {
        temp = Astronomy::noiseTemp(value, m_settings.m_sampleRate);
    }
    m_settings.m_tCalCold = (float)temp;
    calibrate();
    applySettings();
}

void RadioAstronomyGUI::on_spectrumLine_currentIndexChanged(int value)
{
    m_settings.m_line = (RadioAstronomySettings::Line)value;
    displaySpectrumLineFrequency();
    plotFFTMeasurement();
    applySettings();
}

void RadioAstronomyGUI::displaySpectrumLineFrequency()
{
    switch (m_settings.m_line)
    {
    case RadioAstronomySettings::HI:
        ui->spectrumLineFrequency->setValue(Astronomy::m_hydrogenLineFrequency / 1e6);
        ui->spectrumLineFrequency->setEnabled(false);
        break;
    case RadioAstronomySettings::OH:
        ui->spectrumLineFrequency->setValue(Astronomy::m_hydroxylLineFrequency / 1e6);
        ui->spectrumLineFrequency->setEnabled(false);
        break;
    case RadioAstronomySettings::DI:
        ui->spectrumLineFrequency->setValue(Astronomy::m_deuteriumLineFrequency / 1e6);
        ui->spectrumLineFrequency->setEnabled(false);
        break;
    case RadioAstronomySettings::CUSTOM_LINE:
        ui->spectrumLineFrequency->setValue(m_settings.m_lineCustomFrequency / 1e6);
        ui->spectrumLineFrequency->setEnabled(true);
        break;
    }
}

void RadioAstronomyGUI::on_spectrumLineFrequency_valueChanged(double value)
{
    m_settings.m_lineCustomFrequency = value * 1e6;
    plotFFTMeasurement();
    applySettings();
}

void RadioAstronomyGUI::on_refFrame_currentIndexChanged(int value)
{
    m_settings.m_refFrame = (RadioAstronomySettings::RefFrame)value;
    plotFFTMeasurement();
    applySettings();
}

void RadioAstronomyGUI::on_sunDistanceToGC_valueChanged(double value)
{
    m_settings.m_sunDistanceToGC = value;
    applySettings();
    calcDistances();
}

void RadioAstronomyGUI::on_sunOrbitalVelocity_valueChanged(double value)
{
    m_settings.m_sunOrbitalVelocity = value;
    applySettings();
    calcDistances();
}

void RadioAstronomyGUI::on_savePowerChartImage_clicked()
{
    QFileDialog fileDialog(nullptr, "Select file to save image to", "", "*.png *.jpg *.jpeg *.bmp *.ppm *.xbm *.xpm");
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    if (fileDialog.exec())
    {
        QStringList fileNames = fileDialog.selectedFiles();
        if (fileNames.size() > 0)
        {
            QImage image(ui->powerChart->size(), QImage::Format_ARGB32);
            image.fill(Qt::transparent);
            QPainter painter(&image);
            ui->powerChart->render(&painter);
            if (!image.save(fileNames[0])) {
                QMessageBox::critical(this, "Radio Astronomy", QString("Failed to save image to %1").arg(fileNames[0]));
            }
        }
    }
}

void RadioAstronomyGUI::on_saveSpectrumChartImage_clicked()
{
    QFileDialog fileDialog(nullptr, "Select file to save image to", "", "*.png *.jpg *.jpeg *.bmp *.ppm *.xbm *.xpm");
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    if (fileDialog.exec())
    {
        QStringList fileNames = fileDialog.selectedFiles();
        if (fileNames.size() > 0)
        {
            QImage image(ui->spectrumChart->size(), QImage::Format_ARGB32);
            image.fill(Qt::transparent);
            QPainter painter(&image);
            ui->spectrumChart->render(&painter);
            if (!image.save(fileNames[0])) {
                QMessageBox::critical(this, "Radio Astronomy", QString("Failed to save image to %1").arg(fileNames[0]));
            }
        }
    }
}

void RadioAstronomyGUI::on_saveSpectrumChartImages_clicked()
{
    if (m_fftMeasurements.size() > 1)
    {
        // Get filename of animation file
        QFileDialog fileDialog(nullptr, "Select file to save animation to", "", "*.png");
        fileDialog.setAcceptMode(QFileDialog::AcceptSave);
        if (fileDialog.exec())
        {
            QStringList fileNames = fileDialog.selectedFiles();
            if (fileNames.size() > 0)
            {
                // Create animation file
                APNG apng(m_fftMeasurements.size());

                // Plot each FFT to a temp .png file (in memory) then append to animation file
                for (int i = 0; i < m_fftMeasurements.size(); i++)
                {
                    plotFFTMeasurement(i);
                    QApplication::processEvents(); // To get chart title to be updated
                    QImage image(ui->spectrumChart->size(), QImage::Format_ARGB32);
                    image.fill(Qt::transparent);
                    QPainter painter(&image);
                    ui->spectrumChart->render(&painter);
                    apng.addImage(image);
                }
                if (!apng.save(fileNames[0])) {
                    QMessageBox::critical(this, "Radio Astronomy", QString("Failed to write to file %1").arg(fileNames[0]));
                }
            }
        }
    }
}

void RadioAstronomyGUI::on_spectrumReverseXAxis_toggled(bool checked)
{
    m_settings.m_spectrumReverseXAxis = checked;
    applySettings();
    if (ui->spectrumChartSelect->currentIndex() == 0) {
        plotFFTMeasurement();
    } else {
        m_calXAxis->setReverse(m_settings.m_spectrumReverseXAxis);
    }
}

void RadioAstronomyGUI::on_powerShowPeak_toggled(bool checked)
{
    m_settings.m_powerPeaks = checked;
    updatePowerMarkerTableVisibility();
    applySettings();
    if (m_powerPeakSeries)
    {
        m_powerPeakSeries->setVisible(checked);
        if (checked) {
            m_powerChart->legend()->markers(m_powerPeakSeries)[0]->setVisible(false);
        }
    }
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_spectrumPeak_toggled(bool checked)
{
    m_settings.m_spectrumPeaks = checked;
    updateSpectrumMarkerTableVisibility();
    plotFFTMeasurement();
    applySettings();
    if (m_fftChart)
    {
        if (checked) {
            m_fftChart->legend()->markers(m_fftPeakSeries)[0]->setVisible(false);
            showLoSMarker("Max");
        } else {
            clearLoSMarker("Max");
        }
    }
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_powerShowMarker_toggled(bool checked)
{
    m_settings.m_powerMarkers = checked;
    updatePowerMarkerTableVisibility();
    applySettings();
    if (m_powerMarkerSeries)
    {
        m_powerMarkerSeries->setVisible(checked);
        if (checked) {
            m_powerChart->legend()->markers(m_powerMarkerSeries)[0]->setVisible(false);
        }
    }
    updatePowerSelect();
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_powerShowAvg_toggled(bool checked)
{
    m_settings.m_powerAvg = checked;
    applySettings();
    ui->powerChartAvgWidgets->setVisible(checked);
    getRollupContents()->arrangeRollups();
    if (checked) {
        calcAverages();
    }
}

void RadioAstronomyGUI::on_powerShowLegend_toggled(bool checked)
{
    m_settings.m_powerLegend = checked;
    applySettings();
    if (m_powerChart)
    {
        if (checked) {
            m_powerChart->legend()->show();
        } else {
            m_powerChart->legend()->hide();
        }
    }
}

void RadioAstronomyGUI::on_powerShowTsys0_toggled(bool checked)
{
    m_settings.m_powerShowTsys0 = checked;
    applySettings();
    if (m_powerTsys0Series) {
        m_powerTsys0Series->setVisible(checked);
    }
}

void RadioAstronomyGUI::on_powerShowAirTemp_toggled(bool checked)
{
    m_settings.m_powerShowAirTemp = checked;
    applySettings();
    m_airTemps.clicked(checked);
}

void RadioAstronomyGUI::on_powerShowSensor1_toggled(bool checked)
{
    m_settings.m_sensorVisible[0] = checked;
    applySettings();
    m_sensors[0].clicked(checked);
}

void RadioAstronomyGUI::on_powerShowSensor2_toggled(bool checked)
{
    m_settings.m_sensorVisible[1] = checked;
    applySettings();
    m_sensors[1].clicked(checked);
}

void RadioAstronomyGUI::updatePowerMarkerTableVisibility()
{
    ui->powerMarkerTableWidgets->setVisible(m_settings.m_powerPeaks || m_settings.m_powerMarkers);
    if (m_settings.m_powerPeaks)
    {
        ui->powerMarkerTable->showRow(POWER_MARKER_ROW_PEAK_MAX);
        ui->powerMarkerTable->showRow(POWER_MARKER_ROW_PEAK_MIN);
    }
    else
    {
        ui->powerMarkerTable->hideRow(POWER_MARKER_ROW_PEAK_MAX);
        ui->powerMarkerTable->hideRow(POWER_MARKER_ROW_PEAK_MIN);
    }
    if (m_settings.m_powerMarkers)
    {
        ui->powerMarkerTable->showRow(POWER_MARKER_ROW_M1);
        ui->powerMarkerTable->showRow(POWER_MARKER_ROW_M2);
    }
    else
    {
        ui->powerMarkerTable->hideRow(POWER_MARKER_ROW_M1);
        ui->powerMarkerTable->hideRow(POWER_MARKER_ROW_M2);
    }
    ui->powerMarkerTableWidgets->updateGeometry(); // Without this, widgets aren't resized properly
}

void RadioAstronomyGUI::updateSpectrumMarkerTableVisibility()
{
    bool fft = ui->spectrumChartSelect->currentIndex() == 0;
    ui->spectrumMarkerTableWidgets->setVisible(fft && (m_settings.m_spectrumPeaks || m_settings.m_spectrumMarkers));
    if (m_settings.m_spectrumPeaks)
    {
        ui->spectrumMarkerTable->showRow(SPECTRUM_MARKER_ROW_PEAK);
    }
    else
    {
        ui->spectrumMarkerTable->hideRow(SPECTRUM_MARKER_ROW_PEAK);
    }
    if (m_settings.m_spectrumMarkers)
    {
        ui->spectrumMarkerTable->showRow(SPECTRUM_MARKER_ROW_M1);
        ui->spectrumMarkerTable->showRow(SPECTRUM_MARKER_ROW_M2);
    }
    else
    {
        ui->spectrumMarkerTable->hideRow(SPECTRUM_MARKER_ROW_M1);
        ui->spectrumMarkerTable->hideRow(SPECTRUM_MARKER_ROW_M2);
    }
    ui->spectrumMarkerTableWidgets->updateGeometry(); // Without this, widgets aren't resized properly
}

void RadioAstronomyGUI::on_spectrumMarker_toggled(bool checked)
{
    m_settings.m_spectrumMarkers = checked;
    applySettings();
    updateSpectrumMarkerTableVisibility();
    m_fftMarkerSeries->setVisible(checked);
    if (checked)
    {
        m_fftChart->legend()->markers(m_fftMarkerSeries)[0]->setVisible(false);
        showLoSMarker("M1");
        showLoSMarker("M2");
    }
    else
    {
        clearLoSMarker("M1");
        clearLoSMarker("M2");
    }
    updateSpectrumSelect();
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_spectrumTemp_toggled(bool checked)
{
    m_settings.m_spectrumTemp = checked;
    applySettings();
    ui->spectrumGaussianWidgets->setVisible(checked);
    m_fftGaussianSeries->setVisible(checked);
    updateSpectrumSelect();
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_spectrumShowLegend_toggled(bool checked)
{
    m_settings.m_spectrumLegend = checked;
    applySettings();
    if (m_fftChart)
    {
        m_fftChart->legend()->setVisible(checked);
        m_calChart->legend()->setVisible(checked);
    }
}

void RadioAstronomyGUI::on_spectrumShowRefLine_toggled(bool checked)
{
    m_settings.m_spectrumRefLine = checked;
    applySettings();
    ui->spectrumRefLineWidgets->setVisible(checked);
    if (m_fftHlineSeries)
    {
        m_fftHlineSeries->setVisible(m_settings.m_spectrumRefLine);
        m_fftDopplerAxis->setVisible(m_settings.m_spectrumRefLine);
    }
    updateDistanceColumns();
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_spectrumShowLAB_toggled(bool checked)
{
    m_settings.m_spectrumLAB = checked;
    applySettings();
    m_fftLABSeries->setVisible(m_settings.m_spectrumLAB);
    if (m_settings.m_spectrumLAB) {
        plotLAB(); // Replot in case data needs to be downloaded
    }
    spectrumAutoscale();
}

void RadioAstronomyGUI::updateDistanceColumns()
{
    if (m_settings.m_spectrumDistance && m_settings.m_spectrumRefLine)
    {
        ui->spectrumMarkerTable->showColumn(SPECTRUM_MARKER_COL_R);
        ui->spectrumMarkerTable->showColumn(SPECTRUM_MARKER_COL_D);
        ui->spectrumMarkerTable->showColumn(SPECTRUM_MARKER_COL_PLOT_MAX);
        ui->spectrumMarkerTable->showColumn(SPECTRUM_MARKER_COL_R_MIN);
        ui->spectrumMarkerTable->showColumn(SPECTRUM_MARKER_COL_V);
        showLoSMarker("Max");
        showLoSMarker("M1");
        showLoSMarker("M2");
        ui->sunDistanceToGCLine->setVisible(true);
        ui->sunDistanceToGCLabel->setVisible(true);
        ui->sunDistanceToGC->setVisible(true);
        ui->sunDistanceToGCUnits->setVisible(true);
        ui->sunOrbitalVelocityLine->setVisible(true);
        ui->sunOrbitalVelocityLabel->setVisible(true);
        ui->sunOrbitalVelocity->setVisible(true);
        ui->sunOrbitalVelocityUnits->setVisible(true);
    }
    else
    {
        ui->spectrumMarkerTable->hideColumn(SPECTRUM_MARKER_COL_R);
        ui->spectrumMarkerTable->hideColumn(SPECTRUM_MARKER_COL_D);
        ui->spectrumMarkerTable->hideColumn(SPECTRUM_MARKER_COL_PLOT_MAX);
        ui->spectrumMarkerTable->hideColumn(SPECTRUM_MARKER_COL_R_MIN);
        ui->spectrumMarkerTable->hideColumn(SPECTRUM_MARKER_COL_V);
        clearLoSMarker("Max");
        clearLoSMarker("M1");
        clearLoSMarker("M2");
        ui->sunDistanceToGCLine->setVisible(false);
        ui->sunDistanceToGCLabel->setVisible(false);
        ui->sunDistanceToGC->setVisible(false);
        ui->sunDistanceToGCUnits->setVisible(false);
        ui->sunOrbitalVelocityLine->setVisible(false);
        ui->sunOrbitalVelocityLabel->setVisible(false);
        ui->sunOrbitalVelocity->setVisible(false);
        ui->sunOrbitalVelocityUnits->setVisible(false);
    }
}

void RadioAstronomyGUI::on_spectrumShowDistance_toggled(bool checked)
{
    m_settings.m_spectrumDistance = checked;
    applySettings();
    if (m_settings.m_spectrumDistance && !m_settings.m_spectrumRefLine) {
        ui->spectrumShowRefLine->setChecked(true);
    }
    updateDistanceColumns();
}

// point isn't necessarily a point in the series - may be interpolated
void RadioAstronomyGUI::powerSeries_clicked(const QPointF &point)
{
    QString selection = ui->powerSelect->currentText();
    if (selection.startsWith("M"))
    {
        if (selection == "M1")
        {
            // Place marker 1
            m_powerM1X = point.x();
            m_powerM1Y = point.y();
            if (m_powerM1Valid) {
                m_powerMarkerSeries->replace(0, m_powerM1X, m_powerM1Y);
            } else {
                m_powerMarkerSeries->insert(0, QPointF(m_powerM1X, m_powerM1Y));
            }
            m_powerM1Valid = true;
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(m_powerM1X);
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M1, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M1, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M1, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerM1Y);
            calcPowerMarkerDelta();
        }
        else if (selection == "M2")
        {
            // Place marker 2
            m_powerM2X = point.x();
            m_powerM2Y = point.y();
            if (m_powerM2Valid) {
                m_powerMarkerSeries->replace(1, m_powerM2X, m_powerM2Y);
            } else {
                m_powerMarkerSeries->insert(1, QPointF(m_powerM2X, m_powerM2Y));
            }
            m_powerM2Valid = true;
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(m_powerM2X);
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_DATE)->setData(Qt::DisplayRole, dt.date());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_TIME)->setData(Qt::DisplayRole, dt.time());
            ui->powerMarkerTable->item(POWER_MARKER_ROW_M2, POWER_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_powerM2Y);
            calcPowerMarkerDelta();
        }
    }
    else if (selection == "Gaussian")
    {
        // Fit a Gaussian assuming point clicked is the peak
        ui->powerGaussianCenter->setDateTime(QDateTime::fromMSecsSinceEpoch(point.x()));
        // Calculate noise floor - take average of lowest 10%
        qreal floor = calcSeriesFloor(m_powerSeries);
        ui->powerGaussianFloor->setValue(floor);
        // Set amplitude to achieve selected point
        ui->powerGaussianAmp->setValue(point.y() - floor);
    }
    else
    {
        if (m_fftMeasurements.size() > 1)
        {
            // Select row closest to clicked data
            QDateTime dt = QDateTime::fromMSecsSinceEpoch(point.x());
            int i = 0;
            while ((i < m_fftMeasurements.size()) && (dt > m_fftMeasurements[i]->m_dateTime)) {
                i++;
            }
            if (i < m_fftMeasurements.size()) {
                ui->spectrumIndex->setValue(i);
            }
        }
    }
}

qreal RadioAstronomyGUI::calcSeriesFloor(QXYSeries *series, int percent)
{
    QList<qreal> minValues;
    double count = series->count() * percent / 100.0;
    for (int i = 0; i < series->count(); i++)
    {
        qreal y = series->at(i).y();
        if (minValues.size() < count)
        {
            minValues.append(y);
            std::sort(minValues.begin(), minValues.end());
        }
        else if (y < minValues.last())
        {
            minValues.append(y);
            std::sort(minValues.begin(), minValues.end());
        }
    }
    qreal sum = std::accumulate(minValues.begin(), minValues.end(), 0.0);
    return sum / minValues.size();
}

void RadioAstronomyGUI::updateSpectrumSelect()
{
    ui->spectrumSelect->clear();
    if (m_settings.m_spectrumMarkers)
    {
        ui->spectrumSelect->addItem("M1");
        ui->spectrumSelect->addItem("M2");
    }
    if (m_settings.m_spectrumTemp)
    {
        ui->spectrumSelect->addItem("Gaussian");
    }
    bool visible = ui->spectrumSelect->count() != 0;
    ui->spectrumSelectLabel->setVisible(visible);
    ui->spectrumSelect->setVisible(visible);
}

void RadioAstronomyGUI::updatePowerSelect()
{
    ui->powerSelect->clear();
    if (m_settings.m_powerMarkers || m_settings.m_powerShowGaussian) {
        ui->powerSelect->addItem("Row");
    }
    if (m_settings.m_powerMarkers)
    {
        ui->powerSelect->addItem("M1");
        ui->powerSelect->addItem("M2");
    }
    if (m_settings.m_powerShowGaussian) {
        ui->powerSelect->addItem("Gaussian");
    }
    bool visible = ui->powerSelect->count() != 0;
    ui->powerSelectLabel->setVisible(visible);
    ui->powerSelect->setVisible(visible);
}

void RadioAstronomyGUI::spectrumSeries_clicked(const QPointF &point)
{
    QString selection = ui->spectrumSelect->currentText();
    if (selection.startsWith("M"))
    {
        FFTMeasurement *fft = currentFFT();
        if (selection == "M1")
        {
            m_spectrumM1X = point.x();
            m_spectrumM1Y = point.y();
            m_spectrumM1Valid = true;
            ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M1, SPECTRUM_MARKER_COL_FREQ)->setData(Qt::DisplayRole, m_spectrumM1X);
            ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M1, SPECTRUM_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_spectrumM1Y);
            calcVrAndDistanceToPeak(m_spectrumM1X*1e6, fft, SPECTRUM_MARKER_ROW_M1);
        }
        else if (selection == "M2")
        {
            m_spectrumM2X = point.x();
            m_spectrumM2Y = point.y();
            m_spectrumM2Valid = true;
            ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_FREQ)->setData(Qt::DisplayRole, m_spectrumM2X);
            ui->spectrumMarkerTable->item(SPECTRUM_MARKER_ROW_M2, SPECTRUM_MARKER_COL_VALUE)->setData(Qt::DisplayRole, m_spectrumM2Y);
            calcVrAndDistanceToPeak(m_spectrumM2X*1e6, fft, SPECTRUM_MARKER_ROW_M2);
        }
        calcSpectrumMarkerDelta();

        m_fftMarkerSeries->clear();
        if (m_spectrumM1Valid) {
            m_fftMarkerSeries->append(m_spectrumM1X, m_spectrumM1Y);
        }
        if (m_spectrumM2Valid) {
            m_fftMarkerSeries->append(m_spectrumM2X, m_spectrumM2Y);
        }
    }
    else if (selection == "Gaussian")
    {
        ui->spectrumGaussianFreq->setValue(point.x());
        // Calculate noise floor - take average of lowest 10%
        qreal floor = calcSeriesFloor(m_fftSeries);
        ui->spectrumGaussianFloor->setValue(floor);
        // Set amplitude to achieve selected point
        ui->spectrumGaussianAmp->setValue(point.y() - floor);
        plotFFTMeasurement();
    }
}

void RadioAstronomyGUI::on_spectrumGaussianFreq_valueChanged(double value)
{
    (void) value;
    calcFWHM();
    plotFFTMeasurement();
}

void RadioAstronomyGUI::on_spectrumGaussianAmp_valueChanged(double value)
{
    (void) value;
    plotFFTMeasurement();
    calcColumnDensity();
}

void RadioAstronomyGUI::on_spectrumGaussianFloor_valueChanged(double value)
{
    (void) value;
    plotFFTMeasurement();
}

void RadioAstronomyGUI::on_spectrumGaussianFWHM_valueChanged(double fFWHM)
{
    double c = Astronomy::m_speedOfLight;
    double k = Astronomy::m_boltzmann;
    double m = Astronomy::m_hydrogenMass;
    double f0 = ui->spectrumGaussianFreq->value() * 1e6;
    double vTurb = ui->spectrumGaussianTurb->value() * 1e3; // RSM turbulent velocties - Convert to m/s
    const double bf = 2.0*sqrt(M_LN2);  // Convert from Doppler parameter to FWHM

    double fr = fFWHM * c / (bf*f0);
    double frs = fr*fr;

    double T = m * (frs-vTurb*vTurb) / (2.0*k);

    ui->spectrumTemperature->blockSignals(true);
    ui->spectrumTemperature->setValue(T);
    ui->spectrumTemperature->blockSignals(false);
    plotFFTMeasurement();
    calcColumnDensity();
}

void RadioAstronomyGUI::on_spectrumGaussianTurb_valueChanged(double value)
{
    (void) value;
    calcFWHM();
    plotFFTMeasurement();
}

void RadioAstronomyGUI::on_spectrumTemperature_valueChanged(double value)
{
   (void) value;
   calcFWHM();
   plotFFTMeasurement();
}

void RadioAstronomyGUI::calcFWHM()
{
    double c = Astronomy::m_speedOfLight;
    double k = Astronomy::m_boltzmann;
    double m = Astronomy::m_hydrogenMass;
    double f0 = ui->spectrumGaussianFreq->value() * 1e6;
    double vTurb = ui->spectrumGaussianTurb->value() * 1e3; // RSM turbulent velocties - Convert to m/s
    double T = ui->spectrumTemperature->value();
    const double bf = 2.0*sqrt(M_LN2);  // Convert from Doppler parameter to FWHM

    double fFWHM = bf * f0/c * sqrt((2*k*T)/m + vTurb * vTurb);

    ui->spectrumGaussianFWHM->blockSignals(true);
    ui->spectrumGaussianFWHM->setValue(fFWHM);
    ui->spectrumGaussianFWHM->blockSignals(false);
    calcColumnDensity();
}

// Assumes optically thin
void RadioAstronomyGUI::calcColumnDensity()
{
    double f0 = ui->spectrumLineFrequency->value() * 1e6;
    double f = f0 + ui->spectrumGaussianFWHM->value() / 2.0;
    double v = lineDopplerVelocity(f0, f) * 2.0;
    double a = ui->spectrumGaussianAmp->value();
    double integratedIntensity = v * a;
    double columnDensity = 1.81e18 * integratedIntensity;
    ui->columnDensity->setText(QString::number(columnDensity, 'g', 2));
}

void RadioAstronomyGUI::on_powerShowGaussian_clicked(bool checked)
{
    m_settings.m_powerShowGaussian = checked;
    applySettings();
    ui->powerGaussianWidgets->setVisible(checked);
    m_powerGaussianSeries->setVisible(checked);
    updatePowerSelect();
    getRollupContents()->arrangeRollups();
    update();
}

void RadioAstronomyGUI::plotPowerGaussian()
{
    m_powerGaussianSeries->clear();
    double dt0 = ui->powerGaussianCenter->dateTime().toMSecsSinceEpoch();
    double a = ui->powerGaussianAmp->value();
    double floor = ui->powerGaussianFloor->value();
    double fwhm = ui->powerGaussianFWHM->value() * 1000; // Convert from s to ms
    double fwhm_sq = fwhm*fwhm;
    qint64 dt = m_powerXAxis->min().toMSecsSinceEpoch();
    qint64 end = m_powerXAxis->max().toMSecsSinceEpoch();
    int steps = 256;
    qint64 step = (end - dt) / steps;
    for (int i = 0; i < steps; i++)
    {
        double fd = dt - dt0;
        double g = a * std::exp(-4.0*M_LN2*fd*fd/fwhm_sq) + floor;
        m_powerGaussianSeries->append(dt, g);
        dt += step;
    }
}

// Calculate antenna HPBW from Sun's FWHM time
void RadioAstronomyGUI::calcHPBWFromFWHM()
{
    double fwhmSeconds = ui->powerGaussianFWHM->value();
    double sunDegPerSecond = 360.0/(24.0*60.0*60.0);
    double hpbwDeg = fwhmSeconds * sunDegPerSecond;
    ui->powerGaussianHPBW->setValue(hpbwDeg);
}

// Calculate Sun's FWHM time for anntena HPBW
void RadioAstronomyGUI::calcFHWMFromHPBW()
{
    double hpwmDeg = ui->powerGaussianHPBW->value();
    double sunDegPerSecond = 360.0/(24.0*60.0*60.0);
    double fwhmSeconds = hpwmDeg / sunDegPerSecond;
    ui->powerGaussianFWHM->setValue(fwhmSeconds);
}

void RadioAstronomyGUI::on_powerGaussianCenter_dateTimeChanged(QDateTime dateTime)
{
    (void) dateTime;
    plotPowerGaussian();
}

void RadioAstronomyGUI::on_powerGaussianAmp_valueChanged(double value)
{
    (void) value;
    plotPowerGaussian();
}

void RadioAstronomyGUI::on_powerGaussianFloor_valueChanged(double value)
{
    (void) value;
    plotPowerGaussian();
}

void RadioAstronomyGUI::on_powerGaussianFWHM_valueChanged(double value)
{
    (void) value;
    plotPowerGaussian();
    ui->powerGaussianHPBW->blockSignals(true);
    calcHPBWFromFWHM();
    ui->powerGaussianHPBW->blockSignals(false);
}

void RadioAstronomyGUI::on_powerGaussianHPBW_valueChanged(double value)
{
    (void) value;
    calcFHWMFromHPBW();
    ui->powerGaussianFWHM->blockSignals(true);
    plotPowerGaussian();
    ui->powerGaussianFWHM->blockSignals(false);
}

void RadioAstronomyGUI::addToPowerFilter(qreal x, qreal y)
{
    // Add data to circular buffer
    m_window[m_windowIdx] = y;
    m_windowIdx = (m_windowIdx + 1) % m_settings.m_powerFilterN;
    if (m_windowCount < m_settings.m_powerFilterN) {
        m_windowCount++;
    }

    // Filter
    if (m_settings.m_powerFilter == RadioAstronomySettings::FILT_MOVING_AVERAGE)
    {
        // Moving average
        qreal sum = 0.0;
        for (int i = 0; i < m_windowCount; i++) {
            sum += m_window[i];
        }
        qreal mean = sum / m_windowCount;
        y = mean;
    }
    else
    {
        // Median
        std::partial_sort_copy(m_window, m_window + m_windowCount, m_windowSorted, m_windowSorted + m_windowCount);
        qreal median;
        if ((m_windowCount & 1) == 1) {
            median = m_windowSorted[m_windowCount / 2];
        } else {
            median = (m_windowSorted[m_windowCount / 2 - 1] + m_windowSorted[m_windowCount / 2]) / 2.0;
        }
        y = median;
    }

    // Add to series for chart
    m_powerFilteredSeries->append(x, y);
}

void RadioAstronomyGUI::plotPowerFiltered()
{
    delete[] m_window;
    delete[] m_windowSorted;
    m_window = new qreal[m_settings.m_powerFilterN];
    m_windowSorted = new qreal[m_settings.m_powerFilterN];
    m_windowIdx = 0;
    m_windowCount = 0;

    m_powerFilteredSeries->clear();
    QVector<QPointF> powerSeries = m_powerSeries->pointsVector();
    for (int i = 0; i < powerSeries.size(); i++)
    {
        QPointF point = powerSeries.at(i);
        addToPowerFilter(point.x(), point.y());
    }
}

void RadioAstronomyGUI::on_powerShowFiltered_clicked(bool checked)
{
    m_settings.m_powerShowFiltered = checked;
    applySettings();
    ui->powerFilterWidgets->setVisible(checked);
    m_powerFilteredSeries->setVisible(checked);
    getRollupContents()->arrangeRollups();
    update();
}

void RadioAstronomyGUI::on_powerFilter_currentIndexChanged(int index)
{
    m_settings.m_powerFilter = (RadioAstronomySettings::PowerFilter)index;
    applySettings();
    plotPowerFiltered();
}

void RadioAstronomyGUI::on_powerFilterN_valueChanged(int value)
{
    m_settings.m_powerFilterN = value;
    applySettings();
    plotPowerFiltered();
}

void RadioAstronomyGUI::on_powerShowMeasurement_clicked(bool checked)
{
    m_settings.m_powerShowMeasurement = checked;
    applySettings();
    m_powerSeries->setVisible(checked);
}

RadioAstronomyGUI::LABData* RadioAstronomyGUI::parseLAB(QFile* file, float l, float b)
{
    LABData *data = new LABData();
    data->read(file, l, b);
    m_dataLAB.append(data);
    return data;
}

void RadioAstronomyGUI::plotLAB()
{
    int index = ui->spectrumIndex->value();
    if (index < m_fftMeasurements.size())
    {
        FFTMeasurement *fft = m_fftMeasurements[index];
        plotLAB(fft->m_l, fft->m_b, m_beamWidth);
    }
}

void RadioAstronomyGUI::plotLAB(float l, float b, float beamWidth)
{
    // Assume a beamwidth >1deg
    l = round(l);
    b = round(b);

    // Check if we already have the data in memory
    LABData* data = nullptr;
    for (int i = 0; i < m_dataLAB.size(); i++)
    {
        if ((m_dataLAB[i]->m_l == l) && (m_dataLAB[i]->m_b == b))
        {
            data = m_dataLAB[i];
            break;
        }
    }

    if (!data)
    {
        // Try to open previously downloaded data
        QString filenameLAB = HttpDownloadManager::downloadDir() + "/" + QString("lab_l_%1_b_%2.txt").arg(l).arg(b);
        QFile file(filenameLAB);
        if (file.open(QIODevice::ReadOnly))
        {
            qDebug() << "RadioAstronomyGUI::plotLAB: Using cached file: " << filenameLAB;
            data = parseLAB(&file, l, b);
        }
        else
        {
            // Only download one file at a time, so we don't overload the server
            if (!m_downloadingLAB)
            {
                m_downloadingLAB = true;
                m_lLAB = l;
                m_bLAB = b;
                m_filenameLAB = filenameLAB;

                // Request data be generated via web server
                QNetworkRequest request(QUrl("https://www.astro.uni-bonn.de/hisurvey/euhou/LABprofile/index.php"));
                request.setRawHeader("Content-Type", "application/x-www-form-urlencoded");

                QUrlQuery params;
                params.addQueryItem("coordinates", "lb");
                params.addQueryItem("ral", QString::number(l));
                params.addQueryItem("decb",  QString::number(b));
                params.addQueryItem("beam",  QString::number(beamWidth));
                params.addQueryItem("vmin", "-100.0" );
                params.addQueryItem("vmax", "100.0" );
                params.addQueryItem("search", "Search data" );

                m_networkManager->post(request, params.query(QUrl::FullyEncoded).toUtf8());
            }
        }
    }

    if (data)
    {
        data->toSeries(m_fftLABSeries);
        spectrumAutoscale();
    }
}

void RadioAstronomyGUI::networkManagerFinished(QNetworkReply *reply)
{
    QNetworkReply::NetworkError replyError = reply->error();

    if (replyError)
    {
        qWarning() << "RadioAstronomyGUI::networkManagerFinished:"
                << " error(" << (int) replyError
                << "): " << replyError
                << ": " << reply->errorString();
        m_downloadingLAB = false;
    }
    else
    {
        QString answer = reply->readAll();
        QRegularExpression re("a href=\\\"download.php([^\"]*)\"");
        QRegularExpressionMatch match = re.match(answer);
        if (match.hasMatch())
        {
            QString filename = match.capturedTexts()[1];
            qDebug() << "RadioAstronomyGUI: Downloading LAB reference data: " << filename;
            m_dlm.download(QUrl("https://www.astro.uni-bonn.de/hisurvey/euhou/LABprofile/download.php" + filename), m_filenameLAB);
        }
        else
        {
            qDebug() << "RadioAstronomyGUI::networkManagerFinished - No filename found: " << answer;
            m_downloadingLAB = false;
        }
    }

    reply->deleteLater();
}

void RadioAstronomyGUI::downloadFinished(const QString& filename, bool success)
{
    if (success)
    {
        QFile file(filename);
        if (file.open(QIODevice::ReadOnly))
        {
            LABData *data = parseLAB(&file, m_lLAB, m_bLAB);
            file.close();
            // Check if the data we've downloaded is for the current FFT being displayed
            int index = ui->spectrumIndex->value();
            if (index < m_fftMeasurements.size())
            {
                FFTMeasurement *fft = m_fftMeasurements[index];
                if (m_lLAB == fft->m_l && m_bLAB == fft->m_b)
                {
                    data->toSeries(m_fftLABSeries);
                    spectrumAutoscale();
                    m_downloadingLAB = false;
                }
                else
                {
                    // Try plotting for current FFT (as we only allow one download at a time, so may have been skipped)
                    m_downloadingLAB = false;
                    plotLAB(fft->m_l, fft->m_b, m_beamWidth);
                    // Don't clear m_downloadingLAB after this point
                }
            }
        } else {
            qDebug() << "RadioAstronomyGUI::downloadFinished: Failed to open downloaded file: " << filename;
            m_downloadingLAB = false;
        }
    }
    else
    {
        qDebug() << "RadioAstronomyGUI::downloadFinished: Failed to download: " << filename;
        m_downloadingLAB = false;
    }
}

void RadioAstronomyGUI::displayRunModeSettings()
{
    bool sweep = m_settings.m_runMode == RadioAstronomySettings::SWEEP;
    ui->sweep1CoordLabel->setVisible(sweep);
    ui->sweepType->setVisible(sweep);
    ui->sweep1StartLabel->setVisible(sweep);
    ui->sweep1Start->setVisible(sweep);
    ui->sweep1StopLabel->setVisible(sweep);
    ui->sweep1Stop->setVisible(sweep);
    ui->sweep1StepLabel->setVisible(sweep);
    ui->sweep1Step->setVisible(sweep);
    ui->sweep1DelayLabel->setVisible(sweep);
    ui->sweep1Delay->setVisible(sweep);
    ui->sweep2CoordLabel->setVisible(sweep);
    ui->sweep2StartLabel->setVisible(sweep);
    ui->sweep2Start->setVisible(sweep);
    ui->sweep2StopLabel->setVisible(sweep);
    ui->sweep2Stop->setVisible(sweep);
    ui->sweep2StepLabel->setVisible(sweep);
    ui->sweep2Step->setVisible(sweep);
    ui->sweep2DelayLabel->setVisible(sweep);
    ui->sweep2Delay->setVisible(sweep);
    ui->sweepStatus->setVisible(sweep);
    ui->runLayout->activate();         // Needed otherwise height of rollup doesn't seem to be reduced
    ui->statusLayout->activate();      // going from sweep to single/continuous
    getRollupContents()->arrangeRollups();
}

void RadioAstronomyGUI::on_runMode_currentIndexChanged(int index)
{
    m_settings.m_runMode = (RadioAstronomySettings::RunMode)index;
    applySettings();
    displayRunModeSettings();
}

void RadioAstronomyGUI::on_sweepType_currentIndexChanged(int index)
{
    m_settings.m_sweepType = (RadioAstronomySettings::SweepType)index;
    if ((index == 0) || (index == 2))
    {
        ui->sweep1CoordLabel->setText("Az");
        ui->sweep2CoordLabel->setText("El");
    }
    else if (index == 1)
    {
        ui->sweep1CoordLabel->setText("l");
        ui->sweep2CoordLabel->setText("b");
    }
}

void RadioAstronomyGUI::on_sweep1Start_valueChanged(double value)
{
    m_settings.m_sweep1Start = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep1Stop_valueChanged(double value)
{
    m_settings.m_sweep1Stop = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep1Step_valueChanged(double value)
{
    m_settings.m_sweep1Step = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep1Delay_valueChanged(double value)
{
    m_settings.m_sweep1Delay = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep2Start_valueChanged(double value)
{
    m_settings.m_sweep2Start = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep2Stop_valueChanged(double value)
{
    m_settings.m_sweep2Stop = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep2Step_valueChanged(double value)
{
    m_settings.m_sweep2Step = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweep2Delay_valueChanged(double value)
{
    m_settings.m_sweep2Delay = value;
    applySettings();
}

void RadioAstronomyGUI::on_sweepStartAtTime_currentIndexChanged(int index)
{
    m_settings.m_sweepStartAtTime = ui->sweepStartAtTime->currentIndex() == 1;
    ui->sweepStartDateTime->setVisible(index == 1);
    getRollupContents()->arrangeRollups();
    applySettings();
}

void RadioAstronomyGUI::on_sweepStartDateTime_dateTimeChanged(const QDateTime& dateTime)
{
    m_settings.m_sweepStartDateTime = dateTime;
    applySettings();
}

void RadioAstronomyGUI::on_startStop_clicked(bool checked)
{
    if (checked)
    {
        ui->startStop->setStyleSheet("QToolButton { background-color : green; }");
        applySettings();
        if (m_settings.m_power2DLinkSweep)
        {
            update2DSettingsFromSweep();
            create2DImage();
        }
        m_radioAstronomy->getInputMessageQueue()->push(RadioAstronomy::MsgStartSweep::create());
    }
    else
    {
        m_radioAstronomy->getInputMessageQueue()->push(RadioAstronomy::MsgStopSweep::create());
        if (m_settings.m_runMode != RadioAstronomySettings::SWEEP) {
            ui->startStop->setStyleSheet("QToolButton { background-color : blue; }");
        }
    }
}

void RadioAstronomyGUI::calcPowerChartTickCount(int width)
{
    // These values should probably be dependent on the font used
    if (m_powerXAxis) {
        if (m_powerXAxisSameDay) {
            m_powerXAxis->setTickCount(width > 700 ? 10 : 5);
        } else {
            m_powerXAxis->setTickCount(width > 1200 ? 10 : 5);
        }
    }
}

void RadioAstronomyGUI::calcSpectrumChartTickCount(QValueAxis *axis, int width)
{
    if (axis) {
        axis->setTickCount(width > 700 ? 10 : 5);
    }
}

void RadioAstronomyGUI::resizeEvent(QResizeEvent* size)
{
    int width = size->size().width();
    calcPowerChartTickCount(width);
    calcSpectrumChartTickCount(m_fftXAxis, width);
    calcSpectrumChartTickCount(m_fftDopplerAxis, width);
    calcSpectrumChartTickCount(m_calXAxis, width);
    ChannelGUI::resizeEvent(size);
}

void RadioAstronomyGUI::makeUIConnections()
{
    QObject::connect(ui->deltaFrequency, &ValueDialZ::changed, this, &RadioAstronomyGUI::on_deltaFrequency_changed);
    QObject::connect(ui->sampleRate, &ValueDialZ::changed, this, &RadioAstronomyGUI::on_sampleRate_changed);
    QObject::connect(ui->rfBW, &ValueDialZ::changed, this, &RadioAstronomyGUI::on_rfBW_changed);
    QObject::connect(ui->integration, &ValueDialZ::changed, this, &RadioAstronomyGUI::on_integration_changed);
    QObject::connect(ui->fftSize, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_fftSize_currentIndexChanged);
    QObject::connect(ui->fftWindow, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_fftWindow_currentIndexChanged);
    QObject::connect(ui->filterFreqs, &QLineEdit::editingFinished, this, &RadioAstronomyGUI::on_filterFreqs_editingFinished);
    QObject::connect(ui->starTracker, &QComboBox::currentTextChanged, this, &RadioAstronomyGUI::on_starTracker_currentTextChanged);
    QObject::connect(ui->rotator, &QComboBox::currentTextChanged, this, &RadioAstronomyGUI::on_rotator_currentTextChanged);
    QObject::connect(ui->showSensors, &QToolButton::clicked, this, &RadioAstronomyGUI::on_showSensors_clicked);
    QObject::connect(ui->tempRXSelect, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_tempRXSelect_currentIndexChanged);
    QObject::connect(ui->tempRX, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempRX_valueChanged);
    QObject::connect(ui->tempCMB, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempCMB_valueChanged);
    QObject::connect(ui->tempGal, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempGal_valueChanged);
    QObject::connect(ui->tempSP, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempSP_valueChanged);
    QObject::connect(ui->tempAtm, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempAtm_valueChanged);
    QObject::connect(ui->tempAir, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tempAir_valueChanged);
    QObject::connect(ui->zenithOpacity, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_zenithOpacity_valueChanged);
    QObject::connect(ui->elevation, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_elevation_valueChanged);
    QObject::connect(ui->tempAtmLink, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_tempAtmLink_toggled);
    QObject::connect(ui->tempAirLink, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_tempAirLink_toggled);
    QObject::connect(ui->tempGalLink, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_tempGalLink_toggled);
    QObject::connect(ui->elevationLink, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_elevationLink_toggled);
    QObject::connect(ui->gainVariation, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_gainVariation_valueChanged);
    QObject::connect(ui->omegaAUnits, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_omegaAUnits_currentIndexChanged);
    QObject::connect(ui->sourceType, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_sourceType_currentIndexChanged);
    QObject::connect(ui->omegaS, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_omegaS_valueChanged);
    QObject::connect(ui->omegaSUnits, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_omegaSUnits_currentIndexChanged);
    QObject::connect(ui->spectrumChartSelect, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_spectrumChartSelect_currentIndexChanged);
    QObject::connect(ui->showCalSettings, &QToolButton::clicked, this, &RadioAstronomyGUI::on_showCalSettings_clicked);
    QObject::connect(ui->startCalHot, &QToolButton::clicked, this, &RadioAstronomyGUI::on_startCalHot_clicked);
    QObject::connect(ui->startCalCold, &QToolButton::clicked, this, &RadioAstronomyGUI::on_startCalCold_clicked);
    QObject::connect(ui->recalibrate, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_recalibrate_toggled);
    QObject::connect(ui->spectrumShowLegend, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumShowLegend_toggled);
    QObject::connect(ui->spectrumShowRefLine, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumShowRefLine_toggled);
    QObject::connect(ui->spectrumTemp, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumTemp_toggled);
    QObject::connect(ui->spectrumMarker, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumMarker_toggled);
    QObject::connect(ui->spectrumPeak, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumPeak_toggled);
    QObject::connect(ui->spectrumReverseXAxis, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumReverseXAxis_toggled);
    QObject::connect(ui->savePowerData, &QToolButton::clicked, this, &RadioAstronomyGUI::on_savePowerData_clicked);
    QObject::connect(ui->savePowerChartImage, &QToolButton::clicked, this, &RadioAstronomyGUI::on_savePowerChartImage_clicked);
    QObject::connect(ui->saveSpectrumData, &QToolButton::clicked, this, &RadioAstronomyGUI::on_saveSpectrumData_clicked);
    QObject::connect(ui->loadSpectrumData, &QToolButton::clicked, this, &RadioAstronomyGUI::on_loadSpectrumData_clicked);
    QObject::connect(ui->saveSpectrumChartImage, &QToolButton::clicked, this, &RadioAstronomyGUI::on_saveSpectrumChartImage_clicked);
    QObject::connect(ui->saveSpectrumChartImages, &QToolButton::clicked, this, &RadioAstronomyGUI::on_saveSpectrumChartImages_clicked);
    QObject::connect(ui->clearData, &QToolButton::clicked, this, &RadioAstronomyGUI::on_clearData_clicked);
    QObject::connect(ui->clearCal, &QToolButton::clicked, this, &RadioAstronomyGUI::on_clearCal_clicked);
    QObject::connect(ui->spectrumAutoscale, &QToolButton::toggled, this, &RadioAstronomyGUI::on_spectrumAutoscale_toggled);
    QObject::connect(ui->spectrumAutoscaleX, &QToolButton::clicked, this, &RadioAstronomyGUI::on_spectrumAutoscaleX_clicked);
    QObject::connect(ui->spectrumAutoscaleY, &QToolButton::clicked, this, &RadioAstronomyGUI::on_spectrumAutoscaleY_clicked);
    QObject::connect(ui->spectrumReference, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumReference_valueChanged);
    QObject::connect(ui->spectrumRange, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumRange_valueChanged);
    QObject::connect(ui->spectrumCenterFreq, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumCenterFreq_valueChanged);
    QObject::connect(ui->spectrumSpan, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumSpan_valueChanged);
    QObject::connect(ui->spectrumYUnits, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_spectrumYUnits_currentIndexChanged);
    QObject::connect(ui->spectrumBaseline, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_spectrumBaseline_currentIndexChanged);
    QObject::connect(ui->spectrumIndex, &QSlider::valueChanged, this, &RadioAstronomyGUI::on_spectrumIndex_valueChanged);
    QObject::connect(ui->spectrumLine, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_spectrumLine_currentIndexChanged);
    QObject::connect(ui->spectrumLineFrequency, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumLineFrequency_valueChanged);
    QObject::connect(ui->refFrame, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_refFrame_currentIndexChanged);
    QObject::connect(ui->sunDistanceToGC, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sunDistanceToGC_valueChanged);
    QObject::connect(ui->sunOrbitalVelocity, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sunOrbitalVelocity_valueChanged);
    QObject::connect(ui->spectrumGaussianFreq, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumGaussianFreq_valueChanged);
    QObject::connect(ui->spectrumGaussianAmp, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumGaussianAmp_valueChanged);
    QObject::connect(ui->spectrumGaussianFloor, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumGaussianFloor_valueChanged);
    QObject::connect(ui->spectrumGaussianFWHM, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumGaussianFWHM_valueChanged);
    QObject::connect(ui->spectrumGaussianTurb, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumGaussianTurb_valueChanged);
    QObject::connect(ui->spectrumTemperature, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_spectrumTemperature_valueChanged);
    QObject::connect(ui->spectrumShowLAB, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumShowLAB_toggled);
    QObject::connect(ui->spectrumShowDistance, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_spectrumShowDistance_toggled);
    QObject::connect(ui->tCalHotSelect, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_tCalHotSelect_currentIndexChanged);
    QObject::connect(ui->tCalHot, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tCalHot_valueChanged);
    QObject::connect(ui->tCalColdSelect, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_tCalColdSelect_currentIndexChanged);
    QObject::connect(ui->tCalCold, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_tCalCold_valueChanged);
    QObject::connect(ui->powerChartSelect, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_powerChartSelect_currentIndexChanged);
    QObject::connect(ui->powerYUnits, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_powerYUnits_currentIndexChanged);
    QObject::connect(ui->powerShowMarker, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowMarker_toggled);
    QObject::connect(ui->powerShowAirTemp, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowAirTemp_toggled);
    QObject::connect(ui->powerShowPeak, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowPeak_toggled);
    QObject::connect(ui->powerShowAvg, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowAvg_toggled);
    QObject::connect(ui->powerShowLegend, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowLegend_toggled);
    QObject::connect(ui->powerAutoscale, &QToolButton::toggled, this, &RadioAstronomyGUI::on_powerAutoscale_toggled);
    QObject::connect(ui->powerAutoscaleY, &QToolButton::clicked, this, &RadioAstronomyGUI::on_powerAutoscaleY_clicked);
    QObject::connect(ui->powerAutoscaleX, &QToolButton::clicked, this, &RadioAstronomyGUI::on_powerAutoscaleX_clicked);
    QObject::connect(ui->powerReference, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerReference_valueChanged);
    QObject::connect(ui->powerRange, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerRange_valueChanged);
    QObject::connect(ui->powerStartTime, &WrappingDateTimeEdit::dateTimeChanged, this, &RadioAstronomyGUI::on_powerStartTime_dateTimeChanged);
    QObject::connect(ui->powerEndTime, &WrappingDateTimeEdit::dateTimeChanged, this, &RadioAstronomyGUI::on_powerEndTime_dateTimeChanged);
    QObject::connect(ui->powerShowGaussian, &ButtonSwitch::clicked, this, &RadioAstronomyGUI::on_powerShowGaussian_clicked);
    QObject::connect(ui->powerGaussianCenter, &WrappingDateTimeEdit::dateTimeChanged, this, &RadioAstronomyGUI::on_powerGaussianCenter_dateTimeChanged);
    QObject::connect(ui->powerGaussianAmp, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerGaussianAmp_valueChanged);
    QObject::connect(ui->powerGaussianFloor, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerGaussianFloor_valueChanged);
    QObject::connect(ui->powerGaussianFWHM, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerGaussianFWHM_valueChanged);
    QObject::connect(ui->powerGaussianHPBW, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerGaussianHPBW_valueChanged);
    QObject::connect(ui->runMode, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_runMode_currentIndexChanged);
    QObject::connect(ui->sweepType, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_sweepType_currentIndexChanged);
    QObject::connect(ui->sweep1Start, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep1Start_valueChanged);
    QObject::connect(ui->sweep1Stop, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep1Stop_valueChanged);
    QObject::connect(ui->sweep1Step, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep1Step_valueChanged);
    QObject::connect(ui->sweep1Delay, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep1Delay_valueChanged);
    QObject::connect(ui->sweep2Start, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep2Start_valueChanged);
    QObject::connect(ui->sweep2Stop, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep2Stop_valueChanged);
    QObject::connect(ui->sweep2Step, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep2Step_valueChanged);
    QObject::connect(ui->sweep2Delay, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_sweep2Delay_valueChanged);
    QObject::connect(ui->sweepStartAtTime, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_sweepStartAtTime_currentIndexChanged);
    QObject::connect(ui->sweepStartDateTime, &QDateTimeEdit::dateTimeChanged, this, &RadioAstronomyGUI::on_sweepStartDateTime_dateTimeChanged);
    QObject::connect(ui->startStop, &ButtonSwitch::clicked, this, &RadioAstronomyGUI::on_startStop_clicked);
    QObject::connect(ui->power2DAutoscale, &QToolButton::clicked, this, &RadioAstronomyGUI::on_power2DAutoscale_clicked);
    QObject::connect(ui->power2DLinkSweep, &ButtonSwitch::clicked, this, &RadioAstronomyGUI::on_power2DLinkSweep_toggled);
    QObject::connect(ui->power2DSweepType, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_power2DSweepType_currentIndexChanged);
    QObject::connect(ui->power2DWidth, QOverload<int>::of(&QSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DWidth_valueChanged);
    QObject::connect(ui->power2DHeight, QOverload<int>::of(&QSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DHeight_valueChanged);
    QObject::connect(ui->power2DXMin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DXMin_valueChanged);
    QObject::connect(ui->power2DXMax, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DXMax_valueChanged);
    QObject::connect(ui->power2DYMin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DYMin_valueChanged);
    QObject::connect(ui->power2DYMax, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_power2DYMax_valueChanged);
    QObject::connect(ui->powerShowSensor1, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowSensor1_toggled);
    QObject::connect(ui->powerShowSensor2, &ButtonSwitch::toggled, this, &RadioAstronomyGUI::on_powerShowSensor1_toggled);
    QObject::connect(ui->powerShowFiltered, &ButtonSwitch::clicked, this, &RadioAstronomyGUI::on_powerShowFiltered_clicked);
    QObject::connect(ui->powerFilter, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_powerFilter_currentIndexChanged);
    QObject::connect(ui->powerFilterN, QOverload<int>::of(&QSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerFilterN_valueChanged);
    QObject::connect(ui->powerShowMeasurement, &ButtonSwitch::clicked, this, &RadioAstronomyGUI::on_powerShowMeasurement_clicked);
    QObject::connect(ui->powerColourAutoscale, &QToolButton::toggled, this, &RadioAstronomyGUI::on_powerColourAutoscale_toggled);
    QObject::connect(ui->powerColourScaleMin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerColourScaleMin_valueChanged);
    QObject::connect(ui->powerColourScaleMax, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &RadioAstronomyGUI::on_powerColourScaleMax_valueChanged);
    QObject::connect(ui->powerColourPalette, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RadioAstronomyGUI::on_powerColourPalette_currentIndexChanged);
    QObject::connect(ui->powerTable, &QTableWidget::cellDoubleClicked, this, &RadioAstronomyGUI::on_powerTable_cellDoubleClicked);
}

void RadioAstronomyGUI::updateAbsoluteCenterFrequency()
{
    setStatusFrequency(m_centerFrequency + m_settings.m_inputFrequencyOffset);
}