modularization/src/tool/picview/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>

#include <opencv2/imgproc.hpp>

//#include "opencv2/imgcodecs/legacy/constants_c.h"
#include <opencv2/imgproc/types_c.h>

#include "xmlparam.h"

MainWindow * gw;




qint64 xt;

//void Listenpic(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
//{
//    if(nSize<1000)return;
////    qint64 time;
////    memcpy(&time,strdata,sizeof(qint64));
////    int indexraw;
////    memcpy(&indexraw,strdata+sizeof(qint64),sizeof(int));
//    iv::vision::rawpic pic;

//    if(false == pic.ParseFromArray(strdata,nSize))
//    {
//        std::cout<<"picview Listenpic fail."<<std::endl;
//        return;
//    }
//    xt = QDateTime::currentMSecsSinceEpoch();
//    qDebug("latence = %ld ",xt-pic.time());
////    pic.set_time(time);
////    pic.set_index(indexraw);
////    qDebug("hear.");
////    pic.set_picdata(strdata+sizeof(qint64)+sizeof(int),nSize-sizeof(qint64)-sizeof(int));
////    qDebug("hear2.");
//    gw->UpdatePic(pic);
////    qDebug("hear3.");

//}

void Listenpics0(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    if(nSize<1000)return;
    iv::vision::rawpic pic;
    if(false == pic.ParseFromArray(strdata,nSize))
    {
        std::cout<<"picview Listenpic fail."<<std::endl;
        return;
    }
    xt = QDateTime::currentMSecsSinceEpoch();
    qDebug("latence = %ld ",xt-pic.time());
    gw->UpdatePic(pic,0);

}

void Listenpics1(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    if(nSize<1000)return;
    iv::vision::rawpic pic;
    if(false == pic.ParseFromArray(strdata,nSize))
    {
        std::cout<<"picview Listenpic fail."<<std::endl;
        return;
    }
    xt = QDateTime::currentMSecsSinceEpoch();
    qDebug("latence = %ld ",xt-pic.time());
    gw->UpdatePic(pic,1);

}

void Listenpics2(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    if(nSize<1000)return;
    iv::vision::rawpic pic;
    if(false == pic.ParseFromArray(strdata,nSize))
    {
        std::cout<<"picview Listenpic fail."<<std::endl;
        return;
    }
    xt = QDateTime::currentMSecsSinceEpoch();
    qDebug("latence = %ld ",xt-pic.time());
    gw->UpdatePic(pic,2);

}

void Listenpics3(const char * strdata,const unsigned int nSize,const unsigned int index,const QDateTime * dt,const char * strmemname)
{
    if(nSize<1000)return;
    iv::vision::rawpic pic;
    if(false == pic.ParseFromArray(strdata,nSize))
    {
        std::cout<<"picview Listenpic fail."<<std::endl;
        return;
    }
    xt = QDateTime::currentMSecsSinceEpoch();
    qDebug("latence = %ld ",xt-pic.time());
    gw->UpdatePic(pic,3);

}


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


    gw = this;
    mTime.start();
    mnlidarcount = 0;
    mnonepcd = 0;
    mbSaveOne = false;
    mbSave = false;
    mnsave = 0;

    mbOpen = false;

    mstrSavePath = QCoreApplication::applicationDirPath();




    myview = new MyView(this);
    myview->setObjectName(QStringLiteral("graphicsView"));
    myview->setGeometry(QRect(30, 30, 600, 600));

    image = new QImage(2000, 2000, QImage::Format_RGB32);//画布的初始化大小设为300*300，使用32位颜色
    myview->setCacheMode(myview->CacheBackground);

    painter = new QPainter(image);
    painter->end();

    scene = new QGraphicsScene;

    CreateView();

    int i;
    for(i=0;i<MAX_CAMERA;i++)
    {
        mpicindex[i] = 0;
        mpicviewindex[i] = 0;
    }

    mCurCameraIndex = 0;

//    myview->scale(0.3,0.3);
//    myview->show();

    QString strpath = QCoreApplication::applicationDirPath();


        strpath = strpath + "/picview.xml";

    std::cout<<strpath.toStdString()<<std::endl;
    iv::xmlparam::Xmlparam xp(strpath.toStdString());

    std::string strxmlmsgname0 = xp.GetParam("msgname0","image00");
    std::string strxmlmsgname1 = xp.GetParam("msgname1","image01");
    std::string strxmlmsgname2 = xp.GetParam("msgname2","image02");
    std::string strxmlmsgname3 = xp.GetParam("msgname3","image03");

 //   mpa = iv::modulecomm::RegisterRecv(xmlmsgname.data(),Listenpic);

    void * pa[4];
    pa[0] =iv::modulecomm::RegisterRecv(strxmlmsgname0.data(),Listenpics0);
    pa[1] =iv::modulecomm::RegisterRecv(strxmlmsgname1.data(),Listenpics1);
    pa[2] =iv::modulecomm::RegisterRecv(strxmlmsgname2.data(),Listenpics2);
    pa[3] =iv::modulecomm::RegisterRecv(strxmlmsgname3.data(),Listenpics3);

    connect(&mTimer,SIGNAL(timeout()),this,SLOT(onTimer()));
    connect(this,SIGNAL(updatepic()),this,SLOT(onTimer()));
#ifdef Q_OS_WIN32
    mTimer.start(1000);
#else
    mTimer.start(300);
#endif

    setWindowTitle("picview");

}

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



void MainWindow::UpdatePic(iv::vision::rawpic pic,int index)
{
    mMutex.lock();
    mrectime = QDateTime::currentMSecsSinceEpoch();
    mrawpics[index].CopyFrom(pic);
 //   qDebug("timex is %ld ",mrawpic.time());


    mpicindex[index]++;
    mMutex.unlock();

    if((mbSaveOne)&&(index == mCurCameraIndex))
    {
        QString strpath = mstrSavePath;
        strpath = strpath+"/";
        strpath = strpath + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz") + ".jpg";
   //     pcl::io::loadPCDFile<pcl::PointXYZRGBA>("table_scene_lms400.pcd", *cloud
        SaveOnePic(strpath,index);
        mbSaveOne = false;
        mnonepcd++;

    }

    if((mbSave)&&(index == mCurCameraIndex))
    {
        QString strpath = mstrSavePath;
        strpath = strpath+"/";
        strpath = strpath + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz") + ".jpg";
        SaveOnePic(strpath,index);
        mnsave++;

    }
    mnlidarcount++;

    emit updatepic();



}

void MainWindow::UpdatePointCloud(pcl::PointCloud<pcl::PointXYZI>::Ptr pc)
{
    if(mbSaveOne)
    {
        QString strpath = mstrSavePath;
        strpath = strpath+"/";
        strpath = strpath + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz") + "-1.pcd";
   //     pcl::io::loadPCDFile<pcl::PointXYZRGBA>("table_scene_lms400.pcd", *cloud
    }

    if(mbSave)
    {
        QString strpath = mstrSavePath;
        strpath = strpath+"/";
        strpath = strpath + QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss-zzz") + ".pcd";

    }
    mMutex.lock();
    mMutex.unlock();
    mnlidarcount++;
    mpLE_lidarcount->setText(QString::number(mnlidarcount));


//    if(!pc->empty())update();
}


void MainWindow::on_checkBox_clicked()
{

}


void MainWindow::onTimer()
{
    update();

}

//刷新
void MainWindow::paintEvent(QPaintEvent *)
{


    if(mpicviewindex[mCurCameraIndex] == mpicindex[mCurCameraIndex])return;

    mpicviewindex[mCurCameraIndex] = mpicindex[mCurCameraIndex];


    mpLE_onepcd->setText(QString::number(mnonepcd));
    mpLE_savepcd->setText(QString::number(mnsave));
    mpLE_lidarcount->setText(QString::number(mnlidarcount));

 //   qDebug("hear4.");
    iv::vision::rawpic pic;
    qint64 rectime;
    mMutex.lock();
    pic.CopyFrom(mrawpics[mCurCameraIndex]);
    rectime = mrectime;
    mMutex.unlock();

//    qDebug("hear5.");


    painter->begin(image);

    image->fill(QColor(255, 255, 255));//对画布进行填充
//    std::vector<iv::GPSData> navigation_data = brain->navigation_data;
    painter->setRenderHint(QPainter::Antialiasing, true);//设置反锯齿模式，好看一点

    painter->translate(1000,1000);


 //   std::string strpic = pic.picdata();

//    int rows,cols,type;
//    const char * pstr = strpic.data();
//    memcpy(&rows,pstr+2,sizeof(int));
//    memcpy(&cols,pstr+6,sizeof(int));
//    memcpy(&type,pstr+10,sizeof(int));


    
    cv::Mat mat(pic.height(),pic.width(),pic.mattype());
    
    if(pic.type() == 1)
        memcpy(mat.data,pic.picdata().data(),mat.rows*mat.cols*mat.elemSize());
    else
    {

        qDebug("jpg");
        std::vector<unsigned char> buff(pic.picdata().data(),pic.picdata().data()+pic.picdata().size());
        mat = cv::imdecode(buff,1);
    }
 //   qDebug("pic len is %d ",strpic.length());




    cv::cvtColor(mat, mat, CV_BGR2RGB);
    QImage image2 = QImage((uchar*)(mat.data), mat.cols, mat.rows,  QImage::Format_RGB888);



//    QImage image2 = QImage((uchar*)(mat.data), mat.cols, mat.rows,  QImage::Format_ARGB32);

 //   QImage image2 = QImage((uchar*)(mat.data), mat.cols, mat.rows,  QImage::Format_RGBA8888);






//    QColor x;
//    x.setHsl(200,255,120);
//    painter->setPen(x);
//    painter->drawText(-300,-300,40,40,Qt::AlignHCenter | Qt::AlignTop,"hello");
    painter->end();
    scene->clear();
    scene->addPixmap(QPixmap::fromImage(image2));
    myview->setScene(scene);
    myview->show();

    mpLE_capturetime->setText(QString::number(pic.time()));

 //   qint64 timediff = rectime - pic.time();
    qint64 timediff = xt - pic.time();


    mpLE_rectime->setText(QString::number(xt));
    mpLE_timediff->setText(QString::number(timediff));


    mat.release();
}

void MainWindow::resizeEvent(QResizeEvent *event)
{
    qDebug("resize");
    QSize sizemain = ui->centralWidget->size();
    qDebug("size x = %d y=%d",sizemain.width(),sizemain.height());

    AdjustWPos(sizemain);

}

void MainWindow::AdjustWPos(QSize sizemain)
{
    myview->setGeometry(20,30,sizemain.width()-400,sizemain.height());
    mgplidar->setGeometry(sizemain.width()-350,30,320,400);
}

void MainWindow::CreateStatusView(QGridLayout *gl)
{
    gl->setSpacing(10);
    int iRow = 0;

    QLabel * pl = new QLabel(this);
    pl->setText("Count");
    pl->setFixedWidth(150);

    QLineEdit * ple = new QLineEdit(this);
    ple->setFixedWidth(150);

    gl->addWidget(pl,iRow,0);
    gl->addWidget(ple,iRow,1);
    iRow++;

    mpLE_lidarcount = ple;

    QPushButton * pb2 = new QPushButton(this);
    pb2->setText("Save One");
    pb2->setFixedWidth(80);

    QLineEdit * ple2 = new QLineEdit(this);
    ple2->setFixedWidth(150);

    gl->addWidget(pb2,iRow,0);
    gl->addWidget(ple2,iRow,1);
    iRow++;

    mpPB_saveonepcd = pb2;
    mpLE_onepcd = ple2;
    connect(mpPB_saveonepcd,SIGNAL(clicked(bool)),this,SLOT(onSaveOnePCD()));

    QPushButton * pb3 = new QPushButton(this);
    pb3->setText("Start Save");
    pb3->setFixedWidth(80);

    QLineEdit * ple3 = new QLineEdit(this);
    ple3->setFixedWidth(150);

    gl->addWidget(pb3,iRow,0);
    gl->addWidget(ple3,iRow,1);
    iRow++;

    mpPB_savepcd = pb3;
    mpLE_savepcd = ple3;
    connect(mpPB_savepcd,SIGNAL(clicked(bool)),this,SLOT(onSavePCD()));

    QPushButton * pb4 = new QPushButton(this);
    pb4->setText("Set Folder");
    pb4->setFixedWidth(80);

    QLineEdit * ple4 = new QLineEdit(this);
    ple4->setFixedWidth(150);

    gl->addWidget(pb4,iRow,0);
    gl->addWidget(ple4,iRow,1);
    iRow++;

    mpLE_savefolder = ple4;
    connect(pb4,SIGNAL(clicked(bool)),this,SLOT(onSelectFolder()));

    QLabel * pl5 = new QLabel(this);
    pl5->setText("capture time");
    pl5->setFixedWidth(150);

    QLineEdit * ple5 = new QLineEdit(this);
    ple5->setFixedWidth(150);

    gl->addWidget(pl5,iRow,0);
    gl->addWidget(ple5,iRow,1);
    iRow++;

    mpLE_capturetime = ple5;

    QLabel * pl6 = new QLabel(this);
    pl6->setText("receive time");
    pl6->setFixedWidth(150);

    QLineEdit * ple6 = new QLineEdit(this);
    ple6->setFixedWidth(150);

    gl->addWidget(pl6,iRow,0);
    gl->addWidget(ple6,iRow,1);
    iRow++;

    mpLE_rectime = ple6;


    QLabel * pl7 = new QLabel(this);
    pl7->setText("latence time");
    pl7->setFixedWidth(150);

    QLineEdit * ple7 = new QLineEdit(this);
    ple7->setFixedWidth(150);

    gl->addWidget(pl7,iRow,0);
    gl->addWidget(ple7,iRow,1);
    iRow++;

    mpLE_timediff = ple7;

    QComboBox * pcb = new QComboBox(this);
    pcb->setFixedWidth(150);
    gl->addWidget(pcb,iRow,0);
    iRow++;

    pcb->addItem("camera1");
    pcb->addItem("camera2");
    pcb->addItem("camera3");
    pcb->addItem("camera4");
    pcb->setCurrentIndex(0);
    connect(pcb,SIGNAL(currentIndexChanged(int)),this,SLOT(onSelectCamera(int)));




    QSpacerItem * xpsi2 = new QSpacerItem(400,1000,QSizePolicy::Maximum);

    gl->addItem(xpsi2,iRow,0);
}

void MainWindow::CreateView()
{
    QGroupBox * gp1 = new QGroupBox(ui->centralWidget);
    gp1->setTitle(QStringLiteral("IMAGE Status"));
    gp1->setGeometry(QRect(10,100,400,600));
    QGridLayout * gll1 = new QGridLayout(ui->centralWidget);
    gp1->setLayout(gll1);

    CreateStatusView(gll1);

    mgplidar = gp1;
}

void MainWindow::onSaveOnePCD()
{
    mbSaveOne = true;
}

void MainWindow::onSavePCD()
{
    if(mbSave)
    {
        mbSave = false;
        mpPB_savepcd->setText("Start Save");
    }
    else
    {
        mbSave = true;
        mpPB_savepcd->setText("Stop Save");
    }
}

void MainWindow::onSelectFolder()
{
    QString str = QFileDialog::getExistingDirectory(this, tr("Set PCD Save Directory"), mstrSavePath, QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
    if(!str.isEmpty())
    {
        mstrSavePath = str;
        mpLE_savefolder->setText(mstrSavePath);

    }
    else
    {
        qDebug("not change dir.");
    }
}

void MainWindow::SaveOnePic(QString strpath,int index)
{
    mMutex.lock();

    cv::Mat mat(mrawpics[index].height(),mrawpics[index].width(),mrawpics[index].mattype());
    if(mrawpics[index].type() == 1)
        memcpy(mat.data,mrawpics[index].picdata().data(),mat.rows*mat.cols*mat.elemSize());
    else
    {

        qDebug("save jpg");
        std::vector<unsigned char> buff(mrawpics[index].picdata().data(),mrawpics[index].picdata().data()+mrawpics[index].picdata().size());
        mat = cv::imdecode(buff,1);//mat = cv::imdecode(buff,CV_LOAD_IMAGE_COLOR);
    }

    cv::imwrite(strpath.toStdString(),mat);

    mMutex.unlock();
}

void MainWindow::onSelectCamera(int index)
{
    mCurCameraIndex = index;
}