AgentSimulator/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

// #include <iostream>
#include <QtCharts/QLineSeries>
#include <QTimer>
#include <QIcon>
#include <QFile>
#include "UIcommon.h"
#include <QJsonObject>
#include <QScatterSeries>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    InitUI();
    InitEnv();



    //timer->start(800);

    // updateUi();
    // connect(series1, &QLineSeries::clicked, chart, &UChart::keepCallout);
    // connect(series1, &QLineSeries::hovered, chart, &UChart::tooltip);
    // connect(series2, &QLineSeries::clicked, chart, &UChart::keepCallout);
    // connect(series2, &QLineSeries::hovered, chart, &UChart::tooltip);

}

MainWindow::~MainWindow()
{
    delete ui;
}

//设置初始环境变量
void MainWindow::InitEnv()
{
    std::vector<AgentState> init_states {{1, 2, M_PI/2},
                                        {2, 2, M_PI/2},
                                        {3, 2, M_PI/2},
                                        {3.1, 2, M_PI/2}};
    std::vector<double> raduis = {RADUIS, RADUIS, RADUIS, RADUIS};
    std::vector<double> blind_angle = {BLIND_ANGLE, BLIND_ANGLE, BLIND_ANGLE, BLIND_ANGLE};

    multi_agent = std::vector<Agent *>();
    Agent::InitMultiAgent(&multi_agent, init_states, raduis, blind_angle);

    env = new Enviroment(&multi_agent, 50, 50);
    env->Observe();
    DispEnvNow();
}

//初始化ui
void MainWindow::InitUI()
{
    step_now = 0;
    play_flag = false;
    data = new QJsonObject();
    chart = ui->displayer;

    ui->back_botton->setIcon(QIcon(":/control_bar/img/icon/rewind_mini_fill.png"));
    ui->back_botton->setIconSize(QSize(50, 50));
    ui->next_botton->setIcon(QIcon(":/control_bar/img/icon/speed_mini_fill.png"));
    ui->next_botton->setIconSize(QSize(50, 50));
    ui->start_botton->setIcon(QIcon(":/control_bar/img/icon/play_fill.png"));
    ui->start_botton->setIconSize(QSize(50, 50));

    ui->start_botton->setEnabled(false);
    ui->back_botton->setEnabled(false);
    ui->next_botton->setEnabled(false);

    connect(timer, &QTimer::timeout, this, &MainWindow::UpdateUI);
}

void MainWindow::PaintAgent(QLineSeries* serial, AgentState state, double r, double blind_angle)
{
    int arc_sample = 180;
    int line_sample = 10;
    double x0 = state.x;
    double y0 = state.y;
    double header = state.head;
    double start_angle = header - (2*M_PI - blind_angle)/2;
    double end_angle = header + (2*M_PI - blind_angle)/2;
    QPointF p_start(x0+r*cos(start_angle), y0+r*sin(start_angle));
    QPointF p_end(x0+r*cos(end_angle), y0+r*sin(end_angle));


    double step_x = (p_start.x() - x0) / line_sample;
    double step_y = (p_start.y() - y0) / line_sample;
    double x = x0;
    double y = y0;
    serial->append(x, y);
    for(int i=0; i<line_sample; i++)
    {
        x += step_x;
        y += step_y;
        serial->append(x, y);
    }

    double step = (2*M_PI - blind_angle) / arc_sample;
    double angle = start_angle;

    while(angle < end_angle)
    {
        angle += step;
        serial->append(x0+r*cos(angle), y0+r*sin(angle));
    }

    step_x = (x0 - serial->at(serial->count()-1).x()) / line_sample;
    step_y = (y0 - serial->at(serial->count()-1).y()) / line_sample;
    x = serial->at(serial->count()-1).x();
    y = serial->at(serial->count()-1).y();
    for(int i=0; i<line_sample; i++)
    {
        x += step_x;
        y += step_y;
        serial->append(x, y);
    }

}

void MainWindow::UpdateUI()
{
    if(step_now <= data->size()) //在数据步数内则++，否则返回第0步
    {
        PlayByStep(step_now);
        step_now++;
    }
    else
    {
        step_now = 0;
        PlayByStep(step_now);
        timer->stop();
        ui->start_botton->setIcon(QIcon(":/control_bar/img/icon/play_fill.png"));
        play_flag = false;
    }
}


void MainWindow::UpdateUIDebug()
{
    if(step_now <= ui->set_step_lineEdit->text().toInt()) //在数据步数内则++，否则返回第0步
    {
        env->RunOnce();
        step_now++;
    }
    else
    {
        step_now = 0;
        env->RunOnce();
        timer->stop();
        ui->start_botton->setIcon(QIcon(":/control_bar/img/icon/play_fill.png"));
        play_flag = false;
    }
    env->Observe();
    DispEnvNow();
}

/*play指定步数数据*/
void MainWindow::PlayByStep(int step)
{
    chart->clear_serials();

    QString str_index = QString::fromStdString((std::to_string(step)));
    if(data->contains(str_index)&&(*data)[str_index].isObject())
    {
        QJsonArray coor = (*data)[str_index].toObject()["coor"].toArray();
        env->ObserveFromData(ConvertToVec(coor));
    }

    DispEnvNow();
}

//更新显示当前数据
void MainWindow::DispEnvNow()
{
    chart->clear_serials();
    for(auto agent:multi_agent)
    {
        QLineSeries *series = new QLineSeries;
        PaintAgent(series, agent->GetState(), RADUIS, BLIND_ANGLE);
        chart->add_serials(series);
    }
    QScatterSeries *scatter = new QScatterSeries;
    for(auto target: env->GetTargets())
    {
        scatter->append(target.x, target.y);
    }
    chart->add_serials(scatter);

    std::vector<std::vector<int>> adj_mat = env->GetAdjMat();
    ui->neighbor_textEdit->setText(QString::fromStdString(vec2str(adj_mat)));

    std::vector<AgentState> coor_mat = env->GetCoorMat();
    ui->coordinat_textEdit->setText(QString::fromStdString(vec2str(coor_mat)));

    ui->step_label->setText("Step:" + QString::fromStdString(std::to_string(step_now)) + "/" +
                            ui->set_step_lineEdit->text());
}

void MainWindow::on_start_botton_clicked()
{

    if(!play_flag)
    {
        timer->start(800);
        ui->start_botton->setIcon(QIcon(":/control_bar/img/icon/pause_fill.png"));
        play_flag = true;
    }
    else
    {
        timer->stop();
        ui->start_botton->setIcon(QIcon(":/control_bar/img/icon/play_fill.png"));
        play_flag = false;
    }
}


void MainWindow::on_calculate_pushButton_clicked()
{
    int step = ui->set_step_lineEdit->text().toInt();
    if(step == 0)
    {
        qDebug() << "step number error";
        return ;
    }
    if(ui->debug_checkBox->isChecked())
    {
        ui->start_botton->setEnabled(true);
    }
    else
    {
        Calculator cal(env, data, step);
        cal.run();

        ui->file_name_lineEdit->setText(QDateTime::currentDateTime().toString("yyyy_MM_dd_HH_mm_ss") + ".json");
        ui->start_botton->setEnabled(true);
        ui->back_botton->setEnabled(true);
        ui->next_botton->setEnabled(true);
    }

}


void MainWindow::on_next_botton_clicked()
{
    if(play_flag == false)
    {
        step_now++;
        if(step_now <= data->size()) //在数据步数内则++，否则返回第0步
        {
            PlayByStep(step_now);
        }
        else
        {
            step_now = 0;
            PlayByStep(step_now);
        }
    }
}


void MainWindow::on_back_botton_clicked()
{
    if(play_flag == false)
    {
        step_now--;
        if(step_now >= 0) //在数据步数内则++，否则返回第0步
        {
            PlayByStep(step_now);
        }
        else
        {
            step_now = 0;
            PlayByStep(step_now);
        }
    }
}


void MainWindow::on_save_pushButton_clicked()
{
    QJsonDocument jsonDoc(*data);
    // 3. 写入文件
    QFile file("./data/" + ui->file_name_lineEdit->text());
    if (file.open(QIODevice::WriteOnly)) {
        file.write(jsonDoc.toJson()); // 使用缩进格式
        file.close();
        qDebug() << "配置文件已保存。";
    } else {
        qDebug() << "错误：文件保存失败。";
    }
}


void MainWindow::on_debug_checkBox_checkStateChanged(const Qt::CheckState &arg1)
{
    if(arg1 == Qt::Unchecked)
    {
        connect(timer, &QTimer::timeout, this, &MainWindow::UpdateUI);
        disconnect(timer, &QTimer::timeout, this, &MainWindow::UpdateUIDebug);
        ui->calculate_pushButton->setEnabled(true);
        ui->start_botton->setEnabled(false);
        ui->back_botton->setEnabled(false);
        ui->next_botton->setEnabled(false);
    }
    else if(arg1 == Qt::Checked)
    {
        disconnect(timer, &QTimer::timeout, this, &MainWindow::UpdateUI);
        connect(timer, &QTimer::timeout, this, &MainWindow::UpdateUIDebug);
        ui->calculate_pushButton->setEnabled(false);
        ui->start_botton->setEnabled(true);
        ui->back_botton->setEnabled(false);
        ui->next_botton->setEnabled(false);
    }
}


void MainWindow::on_reset_pushButton_clicked()
{
    step_now = 0;
    if(ui->debug_checkBox->isChecked())
    {
        std::vector<AgentState> init_states {{1, 2, M_PI/2},
                                            {2, 2, M_PI/2},
                                            {3, 2, M_PI/2},
                                            {3.1, 2, M_PI/2}};
        std::vector<double> raduis = {RADUIS, RADUIS, RADUIS, RADUIS};
        std::vector<double> blind_angle = {BLIND_ANGLE, BLIND_ANGLE, BLIND_ANGLE, BLIND_ANGLE};

        multi_agent = std::vector<Agent *>();
        Agent::InitMultiAgent(&multi_agent, init_states, raduis, blind_angle);
        env->Observe();
        DispEnvNow();
    }
    else
    {
        PlayByStep(step_now);
    }
}