Qtcv.cpp

Go to the documentation of this file.

#include <Qtcv.h>
#include <Global.h>

#include <QtGui>

class QPixmap;
class QKeySequence;
class QMouseEvent;
class QTime;

#define PAINT_BUTTON_TEXT "Set Corner"


UserInterface::UserInterface()
{
        QWidget *widget = new QWidget;
        setCentralWidget(widget);
        
        // text displayed in the "About" box
        aboutText = new QString(tr(
                        "<p><b>Recognizing and Drawing Faces with a Humanoid Robot</b> was a "
                        "student project from AIS at the University of Freiburg in winter term 2010/11.</p>"
                        "For detailed information, see manual."
                        "<p><b>Authors:</b> <br/>"
                        "Ina Baumgarten, Nikolaus Mayer, Niklas Meinzer, Christian Schilling, Julian Schmid, Richard Schneider, Fabian Wenzelmann</p>"));
                        
        // text displayed in the "Manual" box
        manualText = new QString(tr(
                        "Taking the pen<br/>"
                         "1. Put the pen standing on a surface in front of the PR2 (should be reachable by right gripper).<br/>"
                         "2. Make sure that no other cylindrical objects are in the surrounding of the PR2.<br/>"
                         "3. Make sure there is enough room around the PR2 (enough so that the arms can't hit anything).<br/>"
                         "4. Press the \"Take Pen\" button on the gui on the basestation and make sure that the arm does not hit anything.<br/>"
                         "5. Wait until the PR2 has taken the pen.<br/><br/>"
                         "Taking a picture<br/>"
                         "1. Press the \"Reset head position\" button<br/>"
                         "2. Let a person stand in front of the cameras<br/>"
                         "3. You should see a rectangle(s) around the found faces in the gui.<br/>"
                         "4. Leftclick on the face you want to use. This configures the laser scanner and head.<br/>"
                         "5. Wait for about 5 seconds, to give the laser scanner time to scan the face. The person in front of the camera must stand still during this period.<br/>"
                         "6. Rightclick on the rectangle to take a picture and calculate a mask. This could take a while, so be patient.<br/>"
                         "7. Check if the mask is ok (it should be black around the area of the face and white everywhere else), otherwise take another picture.<br/>"
                         "8. Now you can press the button \"Compute edges\".<br/><br/>"
                         "Extracting the face contours<br/>"
                         "1. After you have taken a picture press the button \"Compute Edges\".<br/>"
                         "2. Wait until it is done calculating different possibilities.<br/>"
                         "3. Now it should open a gui which shows you different proposals. Click on the proposal you think is the best.<br/>"
                         "4. Now you can play around with the parameters, this is a bit tricky. For further information have a look at the \"face_contour_detector\" on ros.org page.<br/>"
                         "5. You can rate your result, this will improve the third proposal.<br/>"
                         "6. Press \"Commit\" to send the result back to the main gui. Close the window if you want to discard the result.<br/><br/>"
                         "Painting the picture<br/>"
                         "1. Press the button \"Set Corner\"<br/>"
                         "2. Now you have to take the gripper to the top left corner of your canvas, so that the pen is pressed onto the canvas. Then press the button.<br/>"
                         "3. Now the same for the other corners (based on the instructions on the screen)<br/>"
                         "4. Finally press the \"Draw Image\" button and wait until the robot has ended drawing.<br/>"
                        ));
        
        cameraImageLabel = new QLabel("<i>waiting for stereo image...</i>");
        cameraImageLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
        cameraImageLabel->setAlignment(Qt::AlignCenter);
        cameraImageLabel->setMinimumSize(STREAM_X, STREAM_Y);
        cameraImageLabel->setMaximumSize(STREAM_X, STREAM_Y);
        
        photoImageLabel = new QLabel(tr("<i>portrait</i>"));
        photoImageLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
        photoImageLabel->setAlignment(Qt::AlignCenter);
        photoImageLabel->setMaximumSize(PORTRAIT_X, PORTRAIT_Y);
        
        maskImageLabel = new QLabel(tr("<i>mask image</i>"));
        maskImageLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
        maskImageLabel->setAlignment(Qt::AlignCenter);
        maskImageLabel->setMaximumSize(PORTRAIT_X, PORTRAIT_Y);
        
        penButton = new QPushButton(tr("Take Pen"));
        edgeButton = new QPushButton(tr("Compute Edges"));
        cornerButton = new QPushButton(tr(PAINT_BUTTON_TEXT));
        paintButton = new QPushButton(tr("Draw Image"));
        paintButton->setEnabled(false);
        headButton = new QPushButton(tr("Reset head position"));
        abortButton = new QPushButton(tr("Abort and restart"));
        edgeButton->setEnabled(false);
        
        mirrorCBox = new QCheckBox(tr("mirror the pointcloud?"));
        
        penGripperLog = new QTextEdit();
        penGripperLog->setReadOnly(true);
        penGripperLogStarted = false;
        contourDetectorLog = new QTextEdit();
        contourDetectorLog->setReadOnly(true);
        contourDetectorLogStarted = false;
        painterLog = new QTextEdit();
        painterLog->setReadOnly(true);
        painterLogStarted = false;
        
        penLabel = new QLabel(tr("Pen Gripper"));
        edgeLabel = new QLabel(tr("Contour Extractor"));
        paintLabel = new QLabel(tr("Painter"));
        
        QHBoxLayout *layoutImages = new QHBoxLayout();
        layoutImages->addWidget(photoImageLabel);
        layoutImages->addWidget(cameraImageLabel);
        layoutImages->addWidget(maskImageLabel);
        
        QHBoxLayout *layoutControls = new QHBoxLayout();
        layoutControls->addStretch(1);
        layoutControls->addWidget(headButton);
        layoutControls->addSpacing(50);
        layoutControls->addWidget(mirrorCBox);
        layoutControls->addSpacing(50);
        layoutControls->addWidget(abortButton);
        layoutControls->addStretch(1);
        
        QVBoxLayout *layoutLeft = new QVBoxLayout();
        QHBoxLayout *miniLeft = new QHBoxLayout();
        miniLeft->addWidget(penLabel);
        miniLeft->addWidget(penButton);
        layoutLeft->addLayout(miniLeft);
        layoutLeft->addWidget(penGripperLog);
        
        QVBoxLayout *layoutCenter = new QVBoxLayout();
        QHBoxLayout *miniCenter = new QHBoxLayout();
        miniCenter->addWidget(edgeLabel);
        miniCenter->addWidget(edgeButton);
        layoutCenter->addLayout(miniCenter);
        layoutCenter->addWidget(contourDetectorLog);
        
        QVBoxLayout *layoutRight = new QVBoxLayout();
        QHBoxLayout *miniRight = new QHBoxLayout();
        miniRight->addWidget(paintLabel);
        miniRight->addWidget(cornerButton);
        miniRight->addWidget(paintButton);
        layoutRight->addLayout(miniRight);
        layoutRight->addWidget(painterLog);
        
        QHBoxLayout *layoutLog = new QHBoxLayout();
        layoutLog->addLayout(layoutLeft);
        layoutLog->addLayout(layoutCenter);
        layoutLog->addLayout(layoutRight);
        
        QVBoxLayout *layoutMain = new QVBoxLayout();
        layoutMain->addLayout(layoutImages);
        layoutMain->addLayout(layoutControls);
        layoutMain->addLayout(layoutLog);
        
        widget->setLayout(layoutMain);
        
        CreateActions();
        CreateMenus();
        
        statusLabel = new QLabel();
        statusBar()->insertWidget(0, statusLabel, 0);
        QString message = tr("Application started. For manual instructions, use the menu.");
        statusBar()->showMessage(message);
        infoLabel = new QLabel(tr("<i>To take a photo: Left click a face to adjust the head and laser and then right click to take a photo.</i>"));
        infoLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
        infoLabel->setAlignment(Qt::AlignRight);
        statusBar()->addPermanentWidget(infoLabel, 0);
        
        connect(mirrorCBox, SIGNAL(stateChanged(int)), this, SLOT(ChangeMirror(int)));
        connect(penButton, SIGNAL(clicked()), this, SLOT(PenBClick()));
        connect(edgeButton, SIGNAL(clicked()), this, SLOT(EdgeBClick()));
        connect(paintButton, SIGNAL(clicked()), this, SLOT(PaintBClick()));
        connect(cornerButton, SIGNAL(clicked()), this, SLOT(CornerBClick()));
        connect(headButton, SIGNAL(clicked()), this, SLOT(HeadBClick()));
        connect(abortButton, SIGNAL(clicked()), this, SLOT(AbortBClick()));
        
        setWindowTitle(tr("Recognizing and Drawing Faces with a Humanoid Robot"));
        setMinimumSize(STREAM_X + 2 * PORTRAIT_X - 100, STREAM_Y + 230);
        
        setWindowState(windowState() ^ Qt::WindowMaximized);
        
        cameraImageLabel->setMouseTracking(true);
        cameraImageLabel->installEventFilter(this);
        
        drawingAvailable = false;
}


void UserInterface::SetLeftImage(QImage qimage)
{
        if(cameraImageLabel->isVisible())
                cameraImageLabel->setPixmap(QPixmap::fromImage(qimage));
}


void UserInterface::SetCenterImage(QImage qimage)
{
        if(photoImageLabel->isVisible())
                photoImageLabel->setPixmap(QPixmap::fromImage(qimage));
}


void UserInterface::SetRightImage(QImage qimage)
{
        if(maskImageLabel->isVisible())
                maskImageLabel->setPixmap(QPixmap::fromImage(qimage));
}


void UserInterface::SetStatus(QString message)
{
        statusBar()->showMessage(message);
}

void UserInterface::SetInfo(QString message)
{
        infoLabel->setText(message);
}


void UserInterface::ChangeMirror(int state)
{
        Q_EMIT mirror();
        
        QString message;
        if (state == 0)
                message = tr("Deactivated mirroring the point cloud.");
        else
                message = tr("Activated mirroring the point cloud.");
        statusBar()->showMessage(message);
}


bool UserInterface::eventFilter(QObject *obj, QEvent *event)
{
        if (obj == cameraImageLabel)
        {
                if (event->type() == QEvent::MouseMove)
                {
                        QPointF p = (static_cast<QMouseEvent *>(event))->pos();
                        p = p.toPoint();
                        
                        Q_EMIT sendMouseEvent((int)p.x(), (int)p.y(), 0);
                }
                else if (event->type() == QEvent::MouseButtonPress)
                {
                        QPointF p = (static_cast<QMouseEvent *>(event))->pos();
                        p = p.toPoint();
                        
                        if((static_cast<QMouseEvent *>(event))->button() == Qt::LeftButton) {
                                Q_EMIT sendMouseEvent((int)p.x(), (int)p.y(), 1);
                        } else if((static_cast<QMouseEvent *>(event))->button() == Qt::RightButton) {
                                Q_EMIT sendMouseEvent((int)p.x(), (int)p.y(), 2);
                        }
                }
        }
        
        return QMainWindow::eventFilter(obj, event);
}


void UserInterface::PenBClick()
{
        SetStatus(QString("Sending signal to pen gripper."));
        
        Q_EMIT penButtonClick();
}

void UserInterface::EdgeBClick()
{
        SetStatus(QString("Sending signal to contour detector."));
        
        Q_EMIT edgeButtonClick();
}


void UserInterface::CornerBClick()
{
        SetStatus(QString("Sending signal to painter."));
        
        Q_EMIT cornerButtonClick();
}

void UserInterface::PaintBClick()
{
        SetStatus(QString("Sending signal to painter."));
        
        Q_EMIT paintButtonClick();
}


void UserInterface::HeadBClick()
{
        SetStatus(QString("Resetting the head position."));
        
        Q_EMIT headButtonClick();
}


void UserInterface::AbortBClick()
{
        penButton->setEnabled(true);
        
        //paintButton->setText(QString(PAINT_BUTTON_TEXT));
        paintButton->setEnabled(false);
        
        Q_EMIT abortButtonClick();
}


void UserInterface::ActivateButton(int buttonID)
{
        switch (buttonID)
        {
                case 1: // pen button (here it deactivates the button!)
                        penButton->setEnabled(false);
                case 2: // edge button
                        edgeButton->setEnabled(true);
                        break;
                case 3: // corner button
                        drawingAvailable = true;
                        //if (paintButton->text() != QString(PAINT_BUTTON_TEXT)) {
                        //      paintButton->setEnabled(true);
                        //}
                        break;
                case 4: // paint button
                        //paintButton->setText(QString("Draw Image"));
                        paintButton->setEnabled(drawingAvailable);
                        break;
                default:
                        SetStatus(QString("ERROR: Wrong parameter!"));
                        break;
        }
}

void UserInterface::loadEdgeImageButton() {
    QString filename = QFileDialog::getOpenFileName(this, "Load Contour Image from File", "", tr("Images (*.png *.xpm *.jpg);;All Files (*)"));
    if(!filename.isEmpty()) Q_EMIT loadEdgeImage(qPrintable(filename));
}
void UserInterface::loadPhotoButton() {
    QString filename = QFileDialog::getOpenFileName(this, "Load Photo from File", "", tr("Images (*.png *.xpm *.jpg);;All Files (*)"));
    QString filename2 = QFileDialog::getOpenFileName(this, "Load Mask from File", "", tr("Images (*.png *.xpm *.jpg);;All Files (*)"));
    if(!filename2.isEmpty() && !filename.isEmpty()) 
      Q_EMIT loadPhoto(qPrintable(filename), qPrintable(filename2));
}

void UserInterface::About()
{
        QMessageBox::about(this, tr("About"), *aboutText);
}


void UserInterface::Manual()
{
        QWidget* qmb = new QWidget();
        QVBoxLayout* l = new QVBoxLayout();
        QTextEdit* t = new QTextEdit();
        t->setText(*manualText);
        l->addWidget(t);
        qmb->setLayout(l);
        qmb->setWindowTitle(tr("Manual"));
        qmb->setMinimumWidth(600);
        qmb->setMinimumHeight(480);
        QRect desk( QApplication::desktop()->availableGeometry( ) );
        qmb->move( (desk.width() - 600) / 2, (desk.height() - 480) / 2 );
        qmb->show();
}


void UserInterface::CreateActions()
{
        exitAct = new QAction(tr("E&xit"), this);
        exitAct->setShortcuts(QKeySequence::Close);
        exitAct->setStatusTip(tr("Exit the application."));
        connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

  loadEdgeAct = new QAction(tr("&Open Edge Image..."), this);
  loadEdgeAct->setShortcut(QString("Strg+E"));
  loadEdgeAct->setStatusTip(tr("Load edge image"));
  connect(loadEdgeAct, SIGNAL(triggered()), this, SLOT(loadEdgeImageButton()));

  loadPhotoAct = new QAction(tr("&Open Photo and Mask..."), this);
  loadPhotoAct->setShortcuts(QKeySequence::Open);
  loadPhotoAct->setStatusTip(tr("Load Photo and Mask"));
  connect(loadPhotoAct, SIGNAL(triggered()), this, SLOT(loadPhotoButton()));
        
        manualAct = new QAction(tr("&Manual"), this);
        manualAct->setShortcuts(QKeySequence::HelpContents);
        manualAct->setStatusTip(tr("Show the manual."));
        connect(manualAct, SIGNAL(triggered()), this, SLOT(Manual()));
        
        aboutAct = new QAction(tr("&About"), this);
        aboutAct->setShortcuts(QKeySequence::WhatsThis);
        aboutAct->setStatusTip(tr("Show information about this program."));
        connect(aboutAct, SIGNAL(triggered()), this, SLOT(About()));
}


void UserInterface::CreateMenus()
{
        fileMenu = menuBar()->addMenu(tr("&File"));
        fileMenu->addAction(loadPhotoAct);
        fileMenu->addAction(loadEdgeAct);
        fileMenu->addAction(exitAct);

        helpMenu = menuBar()->addMenu(tr("&Help"));
        helpMenu->addAction(manualAct);
        helpMenu->addAction(aboutAct);
}


void UserInterface::UpdateStatusMessage(int ID, QString message) 
{
        QString timePrefix = QString("[").append(QString(QTime::currentTime().toString(QString("mm:ss"))).append(QString("] ")));
        message = timePrefix.append(message).append(QString("\n"));
        
        switch (ID)
        {
                case 1: {
                        if (!penGripperLogStarted)
                        {
                                penGripperLog->setHtml(penGripperLog->toPlainText().append(message));
                                penGripperLogStarted = true;
                        }
                        else
                                penGripperLog->setHtml(penGripperLog->toHtml().append(message));
                        QTextCursor c1 =  penGripperLog->textCursor();
                        c1.movePosition(QTextCursor::End);
                        penGripperLog->setTextCursor(c1);
                        break;
                }
                case 2: {
                        if (!contourDetectorLogStarted)
                        {
                                contourDetectorLog->setHtml(contourDetectorLog->toPlainText().append(message));
                                contourDetectorLogStarted = true;
                        }
                        else
                                contourDetectorLog->setHtml(contourDetectorLog->toHtml().append(message));
                        QTextCursor c2 =  contourDetectorLog->textCursor();
                        c2.movePosition(QTextCursor::End);
                        contourDetectorLog->setTextCursor(c2);
                        break;
                }
                case 3: {
                        if (!painterLogStarted)
                        {
                                painterLog->setHtml(painterLog->toPlainText().append(message));
                                painterLogStarted = true;
                        }
                        else
                                painterLog->setHtml(painterLog->toHtml().append(message));
                        QTextCursor c3 =  painterLog->textCursor();
                        c3.movePosition(QTextCursor::End);
                        painterLog->setTextCursor(c3);
                        break;
                }
                default: {
                        SetStatus("Error: UpdateStatusMessage() called with wrong ID");
                }
        }
}