qticubskinguiplugin.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2009 RobotCub Consortium
 * Author: Alessandro Scalzo alessandro.scalzo@iit.it
 * CopyPolicy: Released under the terms of the GNU GPL v2.0.
 *
 */
 
#include "qticubskinguiplugin.h"
#include <QDebug>
 
using namespace yarp::os;
 
 
QtICubSkinGuiPlugin::QtICubSkinGuiPlugin(QQuickItem *parent):
    QQuickPaintedItem(parent)
{
    // By default, QQuickItem does not draw anything. If you subclass
    // QQuickItem to create a visual item, you will need to uncomment the
    // following line and re-implement updatePaintNode()
 
     setFlag(ItemHasContents, true);
 
     gXpos = 32;
     gYpos = 32;
 
     gWidth = 300;
     gHeight = 300;
     gRowStride = 0;
     gImageArea = 0;
     gImageSize = 0;
     gMapSize = 0;
 
     gpActivationMap = NULL;
     gpImageBuff = NULL;
     gpSkinMeshThreadCan = NULL;
     gpSkinMeshThreadPort = NULL;
 
     window_title = "QtICubSkinGui";
 
 
     TheadType = TYPE_PORT;
     timer.setInterval(50);
     timer.setSingleShot(false);
     connect(&timer,SIGNAL(timeout()),this,SLOT(onTimeout()));
 
}
 
QtICubSkinGuiPlugin::~QtICubSkinGuiPlugin()
{
    timer.stop();
    mutex.lock();
 
    if(gpSkinMeshThreadCan){
        gpSkinMeshThreadCan->stop();
        delete gpSkinMeshThreadCan;
    }
    if(gpSkinMeshThreadPort){
        gpSkinMeshThreadPort->stop();
        delete gpSkinMeshThreadPort;
    }
 
    mutex.unlock();
}
 
 
void QtICubSkinGuiPlugin::paint(QPainter *painter)
{
 
    if(!timer.isActive()){
        return;
    }
 
    int width=painter->device()->width();
    int height=painter->device()->height();
 
 
   bDrawing=false;
 
   if (bDrawing){
       return;
   }
 
   bDrawing=true;
 
   mutex.lock();
    if (width!=gWidth || height!=gHeight){
        gWidth=width;
        gHeight=height;
 
        gRowStride=3*gWidth;
        gImageSize=gRowStride*gHeight;
        gImageArea=gWidth*gHeight;
        gMapSize=gWidth*gHeight*sizeof(double);
 
        if (gpActivationMap){
            delete [] gpActivationMap;
        }
        if (gpImageBuff){
            delete [] gpImageBuff;
        }
        gpActivationMap = new double[gImageArea];
        gpImageBuff = new uchar[gImageSize];
 
        if(TheadType == TYPE_CAN && gpSkinMeshThreadCan  && gWidth>=180 && gHeight>=180){
            gpSkinMeshThreadCan->resize(gWidth,gHeight);
        } else if (TheadType == TYPE_PORT && gpSkinMeshThreadPort && gWidth>=180 && gHeight>=180){
            gpSkinMeshThreadPort->resize(gWidth,gHeight);
        }
    }
 
    if (TheadType == TYPE_CAN && gpSkinMeshThreadCan){
        memset(gpImageBuff,0,gImageSize);
 
        if (gWidth>=180 && gHeight>=180){
            gpSkinMeshThreadCan->eval(gpImageBuff);
            gpSkinMeshThreadCan->draw(gpImageBuff);
        }
 
        QImage img = QImage(gpImageBuff,gWidth,gHeight,gRowStride,QImage::Format_RGB32);
        painter->beginNativePainting();
        painter->fillRect(0,0,gWidth,gHeight,QColor("black"));
        painter->drawImage(0,0,img);
        painter->endNativePainting();
 
    }else if (TheadType == TYPE_PORT && gpSkinMeshThreadPort) {
        memset(gpImageBuff,0,gImageSize);
 
        if (gWidth>=180 && gHeight>=180)
        {
            gpSkinMeshThreadPort->eval(gpImageBuff);
            gpSkinMeshThreadPort->draw(gpImageBuff);
        }
 
 
        QImage img = QImage(gpImageBuff,gWidth,gHeight,gRowStride,QImage::Format_RGB888);
 
        painter->beginNativePainting();
        painter->fillRect(0,0,gWidth,gHeight,QColor("black"));
        painter->drawImage(0,0,img);
        painter->endNativePainting();
    }
 
    mutex.unlock();
    bDrawing=false;
 
}
 
 
bool QtICubSkinGuiPlugin::parseParameters(QStringList params)
{
    Network yarp;
 
    rf.setDefaultContext("skinGui/skinGui");
    rf.setDefaultConfigFile("left_hand.ini");
 
    // Transform Qt Params array in standard argc & argv
    int c = params.count();
    char **v;
    v = (char**)malloc(sizeof(char*) * c);
    for(int i=0;i<params.count();i++){
        v[i] = (char*)malloc(sizeof(char) * params.at(i).length()+1);
        strcpy(v[i],params.at(i).toLatin1().data());
    }
 
    if(!rf.configure(c, v)){
        free(v);
        return false;
    }
 
    gWidth =rf.find("width" ).asInt32();
    gHeight=rf.find("height").asInt32();
    if (rf.check("xpos")){
        gXpos=rf.find("xpos").asInt32();
    }
    if (rf.check("ypos")){
        gYpos=rf.find("ypos").asInt32();
    }
 
    bool useCan = rf.check("useCan");
    if (useCan==true){
        yInfo("CAN version: Reading data directly from CAN");
        TheadType=TYPE_CAN;
    } else {
        yInfo("YARP version: reading data from a Yarp port");
        TheadType=TYPE_PORT;
    }
 
 
    window_title=QString("SkinGui (part: %1)").arg(rf.find("robotPart").asString().data());
    windowTitleChanged();
    posXChanged();
    posYChanged();
    widthChanged();
    heightChanged();
 
    yDebug("RF: %s",rf.toString().data());
 
    gRowStride=3*gWidth;
    gImageSize=gRowStride*gHeight;
    gMapSize=gWidth*gHeight*sizeof(double);
    gImageArea=gWidth*gHeight;
 
    gpActivationMap=new double[gImageArea];
    gpImageBuff=new uchar[gImageSize];
 
    /***********/
    // TODO
    /***********/
 
    timer.start();
 
    connect(this,SIGNAL(init()),this,SLOT(onInit()),Qt::QueuedConnection);
    init();
 
 
//    if (gpActivationMap) delete [] gpActivationMap;
//    if (gpImageBuff) delete [] gpImageBuff;
 
 
 
    // TODO DESTROY
 
    return true;
}
 
 
void QtICubSkinGuiPlugin::onTimeout()
{
    update();
}
 
void QtICubSkinGuiPlugin::onInit()
{
    int period = rf.check("period")?rf.find("period").asInt32():50;
 
    if (TheadType==TYPE_CAN)
    {
        gpSkinMeshThreadCan=new SkinMeshThreadCan(rf,period);
        gpSkinMeshThreadCan->start();
 
    }
    else if (TheadType==TYPE_PORT)
    {
        gpSkinMeshThreadPort=new SkinMeshThreadPort(rf,period);
        gpSkinMeshThreadPort->start();
    }
 
    done();
}
 
QString QtICubSkinGuiPlugin::windowTitle()
{
    return window_title;
}
 
int QtICubSkinGuiPlugin::posX()
{
    return gXpos;
}
 
int QtICubSkinGuiPlugin::posY()
{
    return gYpos;
}
 
int QtICubSkinGuiPlugin::windowWidth()
{
    return gWidth;
}
 
int QtICubSkinGuiPlugin::windowHeight()
{
    return gHeight;
}