mainwindow.cpp

Go to the documentation of this file.

/* Author: Constantinos Chamzas, Zachary Kingston */

#include <iostream>
#include <chrono>

#include <QTimer>

#include <se2ez/core/log.h>
#include <se2ez/core/io.h>
#include <se2ez/core/robot.h>
#include <se2ez/core/state.h>
#include <se2ez/core/joint.h>

#include <se2ez/gui/panel.h>
#include <se2ez/gui/renderarea.h>
#include <se2ez/gui/mainwindow.h>

#include "ui_mainwindow.h"

using namespace se2ez;

// TODO make renderArea accept mainWindow as parent and use that
gui::MainWindow::MainWindow(QWidget *parent)
  : QMainWindow(parent), ui_(new Ui::MainWindow), panels_(std::make_shared<PanelMap>())
{
    ui_->setupUi(this);
    canvas_ = new gui::RenderArea(this, this);

    ui_->vbox->insertWidget(0, canvas_);

    connect(ui_->xSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateOriginX(double)));
    connect(ui_->ySpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateOriginY(double)));
    connect(ui_->zoomSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateScale(double)));
    connect(ui_->grid, SIGNAL(stateChanged(int)), this, SLOT(updateState()));

    connect(ui_->record, SIGNAL(clicked()), this, SLOT(record()));
    connect(ui_->screenshot, SIGNAL(clicked()), this, SLOT(screenshot()));

    QTimer::singleShot(1. / ui_->fps->value() * 1000, this, SLOT(process()));
    last_ = io::getDate();
}

void gui::MainWindow::process()
{
    auto now = io::getDate();
    for (const auto &panel : *panels_)
        panel.second->update(last_, now);

    updateMutex_.lock();

    if (!canvas_->didPaint() && didUpdate_)
        canvas_->paint(true);

    if (update_)
        canvas_->paint();

    didUpdate_ = update_;

    if (screen_)
    {
        const std::string name = log::format("./screen_%1%.png", now);
        canvas_->takeScreenshot(name);

        SE2EZ_INFORM("Screenshot saved to %1%", io::resolvePath(name));
        screen_ = false;
    }

    if (record_)
        canvas_->takeScreenshot(log::format("%1%/%2$08d.png", directory_, shotnum_++));

    update_ = false;
    last_ = now;

    updateMutex_.unlock();
    QTimer::singleShot(1. / ui_->fps->value() * 1000, this, SLOT(process()));
}

gui::MainWindow::~MainWindow()
{
    if (camera_)
    {
        camera_->join();
        delete camera_;
    }

    delete ui_;
}

void gui::MainWindow::resizeEvent(QResizeEvent *e)
{
    std::unique_lock<std::mutex> lock(updateMutex_);
    QWidget::resizeEvent(e);
}

void gui::MainWindow::addPanel(Panel *panel)
{
    ui_->tabWidget->addTab(panel, panel->name);
    panels_->emplace(panel->name.toStdString(), panel);
    // Register the shared panelMap for this panel
    panel->initialize(panels_);

    connect(panel, SIGNAL(stateChanged()), this, SLOT(updateState()));
}

void gui::MainWindow::updateState()
{
    std::unique_lock<std::mutex> lock(updateMutex_);
    update_ = true;
}

void gui::MainWindow::updateOriginX(double x)
{
    std::unique_lock<std::mutex> lock(updateMutex_);
    canvas_->setOriginX(x);

    update_ = true;
}

void gui::MainWindow::updateOriginY(double y)
{
    std::unique_lock<std::mutex> lock(updateMutex_);
    canvas_->setOriginY(y);

    update_ = true;
}
void gui::MainWindow::updateScale(double scale)
{
    std::unique_lock<std::mutex> lock(updateMutex_);
    canvas_->setScale(scale);

    update_ = true;
}

void gui::MainWindow::draw(QPainter &painter, RenderArea *canvas)
{
    for (int i = ui_->tabWidget->count() - 1; i >= 0; --i)
    {
        const std::string &name = ui_->tabWidget->tabText(i).toStdString();
        panels_->find(name)->second->draw(painter, canvas);
    }
}

void gui::MainWindow::click(QMouseEvent *event, double x, double y, int sx, int sy)
{
    const std::string &name = ui_->tabWidget->tabText(ui_->tabWidget->currentIndex()).toUtf8().constData();
    auto it = panels_->find(name);
    if (it != panels_->end() && it->second->click(event, x, y, sx, sy))
        return;

    for (int i = 0; i < ui_->tabWidget->count(); ++i)
    {
        const std::string &name = ui_->tabWidget->tabText(i).toUtf8().constData();

        auto it = panels_->find(name);
        if (it != panels_->end() && it->second->click(event, x, y, sx, sy))
            return;
    }

}

void gui::MainWindow::record()
{
    if (!record_)
    {
        ui_->record->setText(QString("Recording..."));
        ui_->record->setDown(true);

        record_ = true;
        directory_ = log::format("./record_%1%", io::getDate());
        io::createDirectory(directory_);

        SE2EZ_INFORM("Recording to %1%...", directory_);

        shotnum_ = 0;
    }
    else
    {
        record_ = false;
        ui_->record->setText(QString("Record"));
        ui_->record->setDown(false);

        SE2EZ_INFORM("Recorded %1% frames. Compiling video...", shotnum_ + 1);

        if (camera_)
        {
            camera_->join();
            delete camera_;
        }

        camera_ = new std::thread([&]() {
            io::runCommand(  //
                log::format("ffmpeg -framerate %2% -i \"%1%/%%08d.png\" "
                            "-pix_fmt rgb24 -c:v qtrle \"%1%/%1%.mov\"",  //
                            directory_, ui_->fps->value() / 2));

            io::runCommand(  //
                log::format("ffmpeg -i \"%1%/%1%.mov\" -c:v libx264 -preset slow -crf 22 \"%1%/%1%.mkv\"",
                            directory_));

            SE2EZ_INFORM("Video compiled to %1%/%1%.{mov,mkv}", directory_);
        });
    }
}

void gui::MainWindow::screenshot()
{
    screen_ = true;
}