mixercurve.cpp

Go to the documentation of this file.

/*
 * 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; either 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
 * 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 <QWidget>
#include <QResizeEvent>

#include <uavobjectwidgetutils/mixercurvepoint.h>

#include "mixercurve.h"
#include "dblspindelegate.h"

MixerCurve::MixerCurve(QWidget *parent)
    : QFrame(parent)
    , m_mixerUI(new Ui::MixerCurvePlot)
{
    m_mixerUI->setupUi(this);

    // setup some convienence pointers
    m_curve = m_mixerUI->CurveWidget;
    m_settings = m_mixerUI->CurveSettings;

    // by default mixcurve isn't used for curve2source
    m_mixerUI->CBCurve2Source->hide();

    m_mixerUI->SettingsGroup->hide();
    m_curve->showCommands(false);
    m_curve->showCommand("Reset", false);
    m_curve->showCommand("Popup", false);
    m_curve->showCommand("Commands", false);

    // create our spin delegate
    m_spinDelegate = new DoubleSpinDelegate();

    // set the default mixer type
    setMixerType(MixerCurve::MIXERCURVE_THROTTLE);

    // setup and turn off advanced mode
    CommandActivated();

    // paint the ui
    UpdateCurveUI();

    // wire up our signals

    connect(m_mixerUI->CurveType, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
            &MixerCurve::CurveTypeChanged);
    connect(m_mixerUI->ResetCurve, &QAbstractButton::clicked, this, &MixerCurve::ResetCurve);
    connect(m_mixerUI->PopupCurve, &QAbstractButton::clicked, this, &MixerCurve::PopupCurve);
    connect(m_mixerUI->GenerateCurve, &QAbstractButton::clicked, this, &MixerCurve::GenerateCurve);
    connect(m_curve, &MixerCurveWidget::curveUpdated, this, &MixerCurve::UpdateSettingsTable);
    connect(m_curve, &MixerCurveWidget::commandActivated, this, &MixerCurve::CommandActivated);
    connect(m_settings, &QTableWidget::cellChanged, this, &MixerCurve::SettingsTableChanged);
    connect(m_mixerUI->CurveMin, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
            &MixerCurve::CurveMinChanged);
    connect(m_mixerUI->CurveMax, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
            &MixerCurve::CurveMaxChanged);
    connect(m_mixerUI->CurveStep, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this,
            &MixerCurve::GenerateCurve);
}

MixerCurve::~MixerCurve()
{
    delete m_mixerUI;
    delete m_spinDelegate;
}

void MixerCurve::setMixerType(MixerCurveType curveType, bool isCurve1)
{
    m_curveType = curveType;

    m_mixerUI->CurveMin->setMaximum(1.0);
    m_mixerUI->CurveMax->setMaximum(1.0);

    switch (m_curveType) {
    case MixerCurve::MIXERCURVE_THROTTLE: {
        m_mixerUI->SettingsGroup->setTitle("Throttle Curve");
        m_curve->setRange(0.0, 1.0);
        m_mixerUI->CurveMin->setMinimum(0.0);
        m_mixerUI->CurveMax->setMinimum(0.0);
        break;
    }
    case MixerCurve::MIXERCURVE_OTHER: {
        m_mixerUI->SettingsGroup->setTitle("Pitch Curve");
        m_curve->setRange(-1.0, 1.0);
        m_curve->setPositiveColor("#0000aa", "#0000aa");
        m_mixerUI->CurveMin->setMinimum(-1.0);
        m_mixerUI->CurveMax->setMinimum(-1.0);
        break;
    }
    }

    if (!isCurve1) {
        m_mixerUI->CBCurve2Source->show();
        m_mixerUI->inputLabelCurve2Source->setText("Input:");
    } else {
        m_mixerUI->inputLabelCurve2Source->setText("Input: Throttle");
    }

    m_spinDelegate->setRange(m_mixerUI->CurveMin->minimum(), m_mixerUI->CurveMax->maximum());
    for (int i = 0; i < MixerCurveWidget::NODE_NUMELEM; i++) {
        m_settings->setItemDelegateForRow(i, m_spinDelegate);
    }

    ResetCurve();
}

void MixerCurve::ResetCurve()
{
    m_mixerUI->CurveMin->setValue(m_mixerUI->CurveMin->minimum());
    m_mixerUI->CurveMax->setValue(m_mixerUI->CurveMax->maximum());
    m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Linear"));

    initLinearCurve(MixerCurveWidget::NODE_NUMELEM, getCurveMax(), getCurveMin());

    m_curve->activateCommand("Linear");

    UpdateSettingsTable();
}

void MixerCurve::PopupCurve()
{
    if (!m_curve->isCommandActive("Popup")) {

        m_mixerUI->SettingsGroup->show();
        m_mixerUI->PopupCurve->hide();

        PopupWidget *popup = new PopupWidget();
        popup->popUp(this);

        m_mixerUI->SettingsGroup->hide();
        m_mixerUI->PopupCurve->show();
        m_curve->showCommands(false);
    }
}
void MixerCurve::UpdateCurveUI()
{
    // get the user settings
    QString curveType = m_mixerUI->CurveType->currentText();

    m_curve->activateCommand(curveType);
    bool cmdsActive = m_curve->isCommandActive("Commands");

    m_curve->showCommand("StepPlus", cmdsActive && curveType != "Linear");
    m_curve->showCommand("StepMinus", cmdsActive && curveType != "Linear");
    m_curve->showCommand("StepValue", cmdsActive && curveType != "Linear");

    m_mixerUI->CurveStep->setMinimum(0.0);
    m_mixerUI->CurveStep->setMaximum(100.0);
    m_mixerUI->CurveStep->setSingleStep(1.00);

    // set default visible
    m_mixerUI->minLabel->setVisible(true);
    m_mixerUI->CurveMin->setVisible(true);
    m_mixerUI->maxLabel->setVisible(false);
    m_mixerUI->CurveMax->setVisible(false);
    m_mixerUI->stepLabel->setVisible(false);
    m_mixerUI->CurveStep->setVisible(false);

    if (curveType.compare("Flat") == 0) {
        m_mixerUI->minLabel->setVisible(false);
        m_mixerUI->CurveMin->setVisible(false);
        m_mixerUI->stepLabel->setVisible(true);
        m_mixerUI->CurveStep->setVisible(true);
        m_mixerUI->CurveStep->setMinimum(m_mixerUI->CurveMin->minimum());
        m_mixerUI->CurveStep->setMaximum(m_mixerUI->CurveMax->maximum());
        m_mixerUI->CurveStep->setSingleStep(0.01);
        m_mixerUI->CurveStep->setValue(m_mixerUI->CurveMax->value() / 2);
    }
    if (curveType.compare("Linear") == 0) {
        m_mixerUI->maxLabel->setVisible(true);
        m_mixerUI->CurveMax->setVisible(true);
    }
    if (curveType.compare("Step") == 0) {
        m_mixerUI->maxLabel->setVisible(true);
        m_mixerUI->CurveMax->setVisible(true);
        m_mixerUI->stepLabel->setText("Step at");
        m_mixerUI->stepLabel->setVisible(true);
        m_mixerUI->CurveStep->setVisible(true);

        m_mixerUI->CurveStep->setMinimum(1.0);
    }
    if (curveType.compare("Exp") == 0) {
        m_mixerUI->maxLabel->setVisible(true);
        m_mixerUI->CurveMax->setVisible(true);
        m_mixerUI->stepLabel->setText("Power");
        m_mixerUI->stepLabel->setVisible(true);
        m_mixerUI->CurveStep->setVisible(true);

        m_mixerUI->CurveStep->setMinimum(1.0);
    }
    if (curveType.compare("Log") == 0) {
        m_mixerUI->maxLabel->setVisible(true);
        m_mixerUI->CurveMax->setVisible(true);
        m_mixerUI->stepLabel->setText("Power");
        m_mixerUI->stepLabel->setVisible(true);
        m_mixerUI->CurveStep->setVisible(true);
        m_mixerUI->CurveStep->setMinimum(1.0);
    }

    GenerateCurve();
}

void MixerCurve::GenerateCurve()
{
    double scale;
    double newValue;

    // get the user settings
    double value1 = getCurveMin();
    double value2 = getCurveMax();
    double value3 = getCurveStep();

    m_curve->setCommandText("StepValue", QString("%0").arg(value3));

    QString CurveType = m_mixerUI->CurveType->currentText();

    QList<double> points;

    for (int i = 0; i < MixerCurveWidget::NODE_NUMELEM; i++) {
        scale = ((double)i / (double)(MixerCurveWidget::NODE_NUMELEM - 1));

        if (CurveType.compare("Flat") == 0) {
            points.append(value3);
        }
        if (CurveType.compare("Linear") == 0) {
            newValue = value1 + (scale * (value2 - value1));
            points.append(newValue);
        }
        if (CurveType.compare("Step") == 0) {
            if (scale * 100 < value3) {
                points.append(value1);
            } else {
                points.append(value2);
            }
        }
        if (CurveType.compare("Exp") == 0) {
            newValue = value1 + (((exp(scale * (value3 / 10)) - 1)) / (exp((value3 / 10)) - 1)
                                 * (value2 - value1));
            points.append(newValue);
        }
        if (CurveType.compare("Log") == 0) {
            newValue = value1
                + (((log(scale * (value3 * 2) + 1)) / (log(1 + (value3 * 2)))) * (value2 - value1));
            points.append(newValue);
        }
    }

    setCurve(&points);
}

void MixerCurve::initCurve(const QList<double> *points)
{
    m_curve->setCurve(points);
    UpdateSettingsTable();
}
QList<double> MixerCurve::getCurve()
{
    return m_curve->getCurve();
}
void MixerCurve::initLinearCurve(int numPoints, double maxValue, double minValue)
{
    setMin(minValue);
    setMax(maxValue);

    m_curve->initLinearCurve(numPoints, maxValue, minValue);

    if (m_spinDelegate)
        m_spinDelegate->setRange(minValue, maxValue);
}
void MixerCurve::setCurve(const QList<double> *points)
{
    m_curve->setCurve(points);
    UpdateSettingsTable();
}
void MixerCurve::setMin(double value)
{
    // m_curve->setMin(value);
    m_mixerUI->CurveMin->setMinimum(value);
}
double MixerCurve::getMin()
{
    return m_curve->getMin();
}
void MixerCurve::setMax(double value)
{
    // m_curve->setMax(value);
    m_mixerUI->CurveMax->setMaximum(value);
}
double MixerCurve::getMax()
{
    return m_curve->getMax();
}
double MixerCurve::setRange(double min, double max)
{
    return m_curve->setRange(min, max);
}

double MixerCurve::getCurveMin()
{
    return m_mixerUI->CurveMin->value();
}
double MixerCurve::getCurveMax()
{
    return m_mixerUI->CurveMax->value();
}

double MixerCurve::getCurveStep()
{
    return m_mixerUI->CurveStep->value();
}

void MixerCurve::UpdateSettingsTable()
{
    QList<double> points = m_curve->getCurve();
    int ptCnt = points.count();

    for (int i = 0; i < ptCnt; i++) {
        QTableWidgetItem *item = m_settings->item(i, 0);
        if (item)
            item->setText(QString().sprintf("%.2f", points.at((ptCnt - 1) - i)));
    }
}

void MixerCurve::SettingsTableChanged()
{
    QList<double> points;

    for (int i = 0; i < m_settings->rowCount(); i++) {
        QTableWidgetItem *item = m_settings->item(i, 0);

        if (item)
            points.push_front(item->text().toDouble());
    }

    m_mixerUI->CurveMin->setValue(points.first());
    m_mixerUI->CurveMax->setValue(points.last());

    m_curve->setCurve(&points);
}

void MixerCurve::CommandActivated(MixerNode *node)
{
    QString name = (node) ? node->getName() : "Reset";

    if (name == "Reset") {
        ResetCurve();
        m_curve->showCommands(false);
    } else if (name == "Commands") {

    } else if (name == "Popup") {
        PopupCurve();
    } else if (name == "Linear") {
        m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Linear"));
    } else if (name == "Log") {
        m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Log"));
    } else if (name == "Exp") {
        m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Exp"));
    } else if (name == "Flat") {
        m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Flat"));
    } else if (name == "Step") {
        m_mixerUI->CurveType->setCurrentIndex(m_mixerUI->CurveType->findText("Step"));
    } else if (name == "MinPlus") {
        m_mixerUI->CurveMin->stepUp();
    } else if (name == "MinMinus") {
        m_mixerUI->CurveMin->stepDown();
    } else if (name == "MaxPlus") {
        m_mixerUI->CurveMax->stepUp();
    } else if (name == "MaxMinus") {
        m_mixerUI->CurveMax->stepDown();
    } else if (name == "StepPlus") {
        m_mixerUI->CurveStep->stepUp();
        m_curve->setCommandText("StepValue", QString("%0").arg(getCurveStep()));
    } else if (name == "StepMinus") {
        m_mixerUI->CurveStep->stepDown();
        m_curve->setCommandText("StepValue", QString("%0").arg(getCurveStep()));
    }

    GenerateCurve();
}

void MixerCurve::CurveTypeChanged()
{
    // setup the ui for this curvetype
    UpdateCurveUI();
}

void MixerCurve::CurveMinChanged(double value)
{
    QList<double> points = m_curve->getCurve();
    points.removeFirst();
    points.push_front(value);
    setCurve(&points);
}

void MixerCurve::CurveMaxChanged(double value)
{
    // the max changed so redraw the curve
    //  mixercurvewidget::setCurve will trim any points above max
    QList<double> points = m_curve->getCurve();
    points.removeLast();
    points.append(value);
    setCurve(&points);
}

void MixerCurve::showEvent(QShowEvent *event)
{
    Q_UNUSED(event);

    m_settings->resizeColumnsToContents();
    m_settings->setColumnWidth(0, (m_settings->width() - m_settings->verticalHeader()->width()));

    int h =
        (m_settings->height() - m_settings->horizontalHeader()->height()) / m_settings->rowCount();
    for (int i = 0; i < m_settings->rowCount(); i++)
        m_settings->setRowHeight(i, h);

    m_curve->showEvent(event);
}

void MixerCurve::resizeEvent(QResizeEvent *event)
{
    m_settings->resizeColumnsToContents();
    m_settings->setColumnWidth(0, (m_settings->width() - m_settings->verticalHeader()->width()));

    int h =
        (m_settings->height() - m_settings->horizontalHeader()->height()) / m_settings->rowCount();
    for (int i = 0; i < m_settings->rowCount(); i++)
        m_settings->setRowHeight(i, h);

    m_curve->resizeEvent(event);
}