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

#include <QDateTime>
#include <QDesktopServices>
#include <QDebug>

#define ddd qDebug()<<__LINE__<<__FUNCTION__

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

    ui->label->setText(QDir::homePath());
    initIns();
    ddd;

    initUI();
    ddd;

    initConnect();
    ddd;


//#if CLIENT==1
    hideui();
//#endif
}

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

void MainWindow::initUI()
{

    b_stat = true;
    ui->pushButton_3->setChecked(true);
    imageX = -10;
    imageY = -10;
    flip0 = false;
    flip1 = false;
    savevideo = false;
    savebin = false;
    savesbin = false;
    shotimg = false;
    shotbin = false;

    fps = 0;
    fpscount = 0;
    path = QDir::homePath()+"/zxrcfiles/";

    QDir d;
    d.mkdir(path);

    QString title = QString::fromLocal8Bit("中芯热成上位机");
#if CLIENT==0
    title +="SA";
#else
    title +="PC";
    resize(960,800);
#endif

    setWindowTitle(title+ QString(ProjectVersion));

    setWindowIcon(QIcon("logo.ico"));

    ui->splitter->setCollapsible(1,false);

    //    QHBoxLayout lout = QHBoxLayout();

    ui->toolBar->addWidget(ui->pushButton);
    ui->toolBar->addWidget(ui->pushButton_2);
    ui->toolBar->addWidget(ui->label_2);
    ui->toolBar->addWidget(ui->spinBox);
    ui->toolBar->addWidget(ui->label_3);
    ui->toolBar->addWidget(ui->spinBox_2);


    m1 = new menu1();
    m2 = new menu2();
    m3 = new menu3();
    m4 = new menu4();
    ddd;

    m5 = new menu5();
    m5_1 = new menu5_1();
    ddd;

    ui->toolbox->addItem(m1,u8"相机设置");
#if CLIENT==2
    ui->toolbox->addItem(m5,u8"图像校正");
#endif
    ui->toolbox->addItem(m2,u8"算法设置");
    ui->toolbox->addItem(m3,u8"显示设置");
    ui->toolbox->addItem(m4,u8"保存设置");
    ddd;



#if CLIENT==0
    ui->toolbox->addItem(m5_1,u8"多点校正");
#endif




#if CLIENT==2
    menu6* m6 =  new menu6;
//    ui->toolbox->addItem(m6, u8"测温设置");
    connect(m6,&menu6::signalSetTemp,[=](double temp){
        b_temp_save = true;
        d_temp = temp;
    });
    connect(m6,&menu6::signalTurnTemp,[=](bool b){
        b_temp = b;
    });

#endif

    type = gray16;
    rows = ui->spinBox->value();
    cols = ui->spinBox_2->value();
    ddd;

    ui->scrollAreaWidgetContents->setMinimumSize(cols+20,rows+20);
    ui->label->resize(cols,rows);
    ddd;

    if(m_mp != nullptr)
        m_mp->setparas(rows,cols);
    ddd;

    ui->tableWidget->horizontalHeader()->hide();
    ui->tableWidget->verticalHeader()->hide();
    ui->tableWidget->setRowCount(5);
    ui->tableWidget->setColumnCount(5);
    ui->tableWidget->resizeColumnsToContents();
    ui->tableWidget->resizeRowsToContents();
    ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    ui->tableWidget->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    ui->label->installEventFilter(this);

    lfps = new QLabel;
    lpath = new HyperlinkLabel;
    lpath->setText(QString::fromLocal8Bit("当前保存路径为")+path);
    lpath->setUrl(QUrl(path));
    ui->statusbar->addWidget(lfps);
    ui->statusbar->addWidget(lpath);
    ddd;

    b_con = false;
    d_con = 1;
    d_con_bright = 0;

    ddd;

}

void MainWindow::initConnect()
{


    connect(ucontrol,SIGNAL(signalSendMessage(QString)),this,SLOT(slotlogtext(QString)));
    connect(usb,SIGNAL(signalMessage(QString)),this,SLOT(slotlogtext(QString)));


    connect(m1,SIGNAL(signalsetGPOL(int)),ucontrol,SLOT(setGPOL(int)));
    connect(m1,SIGNAL(signalsetIT(double)),ucontrol,SLOT(setIT(double)));
    connect(m1,&menu1::signalsetIT,[this](double it){
        this->d_it = it;

        if(m_mp!=nullptr){
            ddd<<this->deviceid<<it;
//            m_mp->loaddata(this->deviceid,it);
            m_mp->setit(it);
        }
    });
    connect(m1,SIGNAL(signalopenTEC(bool)),ucontrol,SLOT(tec(bool)));
    connect(m1,SIGNAL(signalset14bit(bool)),ucontrol,SLOT(bit14(bool)));
    connect(m1,&menu1::signalset14bit,[=](bool b){
        if(b){
            type = gray16;
            usb->SetImageInfo(gray16,rows,cols);
        }
        else{
            type = gray8;
            usb->SetImageInfo(gray8,rows,cols);
        }
    });



#if CLIENT == 0 ||  CLIENT==1
    connect(usb,SIGNAL(signalGetImage(cv::Mat)),this,SLOT(slotShowImage(cv::Mat)));


    connect(m1,SIGNAL(signalsavelow()),ucontrol,SLOT(savelow()));
    connect(m1,SIGNAL(signalsavehigh()),ucontrol,SLOT(savehigh()));
    connect(m1,SIGNAL(signalcalck()),ucontrol,SLOT(calck()));
    connect(m1,SIGNAL(signalsavek()),ucontrol,SLOT(savek()));
    connect(m1,SIGNAL(signalopenk(bool)),ucontrol,SLOT(openk(bool)));
    connect(m1,SIGNAL(signalonepoint()),ucontrol,SLOT(onepoint()));
    connect(m1,SIGNAL(signalsaveb()),ucontrol,SLOT(saveb()));
    connect(m1,SIGNAL(signalopenb(bool)),ucontrol,SLOT(openb(bool)));


    connect(m2,SIGNAL(signalsag(bool)),ucontrol,SLOT(setsag(bool)));
    connect(m2,SIGNAL(signalsetDDE(int)),ucontrol,SLOT(setDDE(int)));
    connect(m2,SIGNAL(signalsetkf(int)),ucontrol,SLOT(setkf(int)));
    connect(m2,SIGNAL(signalsethist(int)),ucontrol,SLOT(sethist(int)));


#elif CLIENT==2
//    connect(usb,SIGNAL(signalGetImage(cv::Mat)),m_tp,SLOT(slotprocimg(cv::Mat)));
//    connect(m_tp,SIGNAL(signalsendimg(cv::Mat)),m_avg,SLOT(slotprocimg(cv::Mat)));

    connect(usb,SIGNAL(signalGetImage(cv::Mat)),m_mp,SLOT(runData(cv::Mat)));
    connect(m_mp,SIGNAL(signalsendimg(cv::Mat)),m_avg,SLOT(slotprocimg(cv::Mat)));

    connect(m_avg,SIGNAL(signalsendimg(cv::Mat)),m_bila,SLOT(slotprocimg(cv::Mat)));
    connect(m_bila,SIGNAL(signalsendimg(cv::Mat)),m_sagauss,SLOT(slotprocimg(cv::Mat)));
    connect(m_sagauss,SIGNAL(signalsendimg(cv::Mat)),m_dde,SLOT(slotprocimg(cv::Mat)));
    connect(m_dde,SIGNAL(signalsendimg(cv::Mat)),m_clhe,SLOT(slotprocimg(cv::Mat)));
    connect(m_clhe,SIGNAL(signalsendimg(cv::Mat)),this,SLOT(slotShowImage(cv::Mat)));


    connect(m1,&menu1::signalsavelow,[=](){
        m_tp->savelow();
    });
    connect(m1,&menu1::signalsavehigh,[=](){
        m_tp->savehigh();
    });
    connect(m1,&menu1::signalcalck,[=](){
        m_tp->calc();
    });

    connect(m1,&menu1::signalsavek,[=](){
        m_tp->savek();
    });
    connect(m1,&menu1::signalsaveb,[=](){
        m_tp->saveb();
    });
    connect(m1,&menu1::signalonepoint,[=](){
        m_tp->onepoint();
    });

    connect(m1,&menu1::signalopenk,[=](bool b){
        if(b){
            m_tp->loaddata();
            m_tp->on(cv::Size(cols,rows));
        }
        else{
            m_tp->off();
        }
    });

    connect(m2,&menu2::signalsag,[=](bool b){
        if(b){
            m_sagauss->setpara(3,0);
            m_sagauss->on();
        }
        else{
            m_sagauss->off();
        }
    });

    connect(m2,&menu2::signalbila,[=](bool b){
        if(b){
            m_bila->setparas(5,10000,10);
        }
        else{
            m_bila->off();
        }
    });

    connect(m2,&menu2::signalsetDDE,[=](int value){
        m_dde->setpara(value/512.0);
    });

    connect(m2,&menu2::signalsetkf,[=](int value){
        m_avg->setpara(value);
    });
    connect(m2,&menu2::signalsethist,[=](int value){
        m_clhe->setthreshold(value);
    });

    connect(m5,SIGNAL(signalsave()),m_mp,SLOT(save()));
    connect(m5,SIGNAL(signalcalc(QVector<double>)),m_mp,SLOT(calcData(QVector<double>)));
//    connect(m5,SIGNAL(signalsavedata(QString)),m_mp,SLOT(savedata(QString)));
    connect(m5,&menu5::signalsavedata,[=](QString path){
        m_mp->savedata(path,d_it );
    });

    connect(m_mp,SIGNAL(signalNewFrame(double)),m5,SLOT(slotRefresh(double)));
//    connect(m5,SIGNAL(signalloaddata(QString)),m_mp,SLOT(loaddata(QString)));
    connect(m5,&menu5::signalloaddata,[this](QString path){
//        m_mp->loaddata(path,this->d_it);
        this->deviceid = path;
        m_mp->setdevice(path);
    });
    connect(m5,SIGNAL(signaloff()),m_mp,SLOT(off()));
    connect(m_mp,SIGNAL(signalLog(QString)),this,SLOT(slotlogtext(QString)));
#endif

#if CLIENT==0
    connect(m5_1,&menu5_1::signalSetbase,[=](int index){
        slotlogtext(u8"开始保存第"+QString::number(index)+u8"个背景");
        mpidx = index;
        mpsum = 0;
        mpnum = 16;
    });

    connect(m5_1,&menu5_1::signalFlash,[=](int index){
        ucontrol->mpflash(index);
    });
    connect(m5_1,&menu5_1::signalStatus,[=](bool b){
        ucontrol->mpstatus(b);
    });
    connect(m5_1,&menu5_1::signalPop,[=](int index){
        ucontrol->mppop(index);
    });

    connect(m5_1,&menu5_1::signalscratch,[=](int* value){
        for(int i = 0;i<5;i++){
            ucontrol->mpset1(i+1,value[i]);
        }
    });
#endif

    connect(m2,&menu2::signalsetDE,[=](bool b){
        b_con = b;
    });
    connect(m2,&menu2::signalseterate,[=](double rate){
        d_con = rate;
    });
    connect(m2,&menu2::signalsetbright,[=](int value){
        d_con_bright = value;
    });


    connect(m3,&menu3::signalflip0,[=](bool b){
        flip0 = b;
    });
    connect(m3,&menu3::signalflip1,[=](bool b){
        flip1 = b;
    });
    connect(m3,&menu3::signalturnl,[=](){
        turnl = true;
        turnf = false;
        turnr = false;
    });
    connect(m3,&menu3::signalturnf,[=](){
        turnl = false;
        turnf = true;
        turnr = false;
    });
    connect(m3,&menu3::signalturnr,[=](){
        turnl = false;
        turnf = false;
        turnr = true;
    });

    connect(m3,&menu3::signalcolorgray,[=](){
        colortype =0;//gray
    });
    connect(m3,&menu3::signalcolorsub,[=](){
        colortype = 1;//sub
    });
    connect(m3,&menu3::signalcolorrgb,[=](){
        colortype = 2;
    });
    qDebug()<<__LINE__;


    connect(m4,&menu4::signalsetdir,[=](QString dir){
        if(dir == ""){
            path = QApplication::applicationDirPath()+"/";
        }
        else{
            path = dir+"/";
        }
        lpath->setText(QString::fromLocal8Bit("当前保存路径为")+path);
        lpath->setUrl(QUrl(path));

    });

    connect(m4,&menu4::signalshotimg,[=](){
        shotimg = true;
    });
    connect(m4,&menu4::signalshotbin,[=](){
        shotbin = true;
    });


    connect(m4,&menu4::signalsavevideo,[=](bool b){
        if(b){
            if(fps<10)
                slotlogtext(QDateTime::currentDateTime().toString()+ QString::fromLocal8Bit(":当前帧率不稳定,请确保帧率稳定后再保存视频"));
            QString now = QDateTime::currentDateTime().toString("yyyy_MM_dd_hh_mm_ss");
            std::string filename = path.toStdString()+now.toStdString()+".mp4";
            writer = new cv::VideoWriter(filename,cv::VideoWriter::fourcc('M','P','4','V'),fps,cv::Size(cols,rows),false);
            QString msg = now +QString::fromLocal8Bit( "开始保存视频");
            slotlogtext(msg);
            savevideo =true;
        }
        else{
            if(!savevideo)
                return;
            savevideo = false;
            writer->release();
            QDateTime t = QDateTime::currentDateTime();
            QString msg = t.toString() +QString::fromLocal8Bit( "结束保存视频");
            slotlogtext(msg);
        }
    });
    connect(m4,&menu4::signalsavebin,[=](bool b){
        if(b){
            QString now =  QDateTime::currentDateTime().toString("/yyyy-MM-dd-hh-mm-ss");
            QString filename = path+now;
            if(type == gray8)
                filename += "8bit.bin";
            else if(type == gray16)
                filename += "14bit.bin";
            purefile = new QFile(filename);
            purefile->open(QIODevice::ReadWrite);
            savebin = true;
            QString msg = now +QString::fromLocal8Bit( "开始保存数据");
            slotlogtext(msg);
        }
        else{
            savebin = false;
            purefile->close();
            QString now =  QDateTime::currentDateTime().toString("/yyyy-MM-dd-hh-mm-ss");
            QString msg = now +QString::fromLocal8Bit( "结束保存数据");
            slotlogtext(msg);
        }
    });


    connect(m4,&menu4::signalsavesbin,[=](int frames){
        if(savesbin)
            return;
        QString now =  QDateTime::currentDateTime().toString("/yyyy-MM-dd-hh-mm-ss");
        QString filename = path+now;
        if(type == gray8)
            filename += "8bit.bin";
        else if(type == gray16)
            filename += "14bit.bin";
        spurefile = new QFile(filename);
        spurefile->open(QIODevice::ReadWrite);        sbinnum = frames;
        savesbin = true;

    });






    connect(lpath,&QPushButton::clicked,[=](){
        QDesktopServices::openUrl(QUrl::fromLocalFile(path));
    });

}

void MainWindow::hideui()
{
    m1->hideui();
    m2->hideui();
}


void MainWindow::on_pushButton_clicked()// 开启传输
{
    if(ui->pushButton->isChecked()){
        QTimer *t = new QTimer;
        connect(t,&QTimer::timeout,[=](){
            on_pushButton_2_clicked();
            usb->SetImageInfo(type,rows,cols);
            usb->setStatu(true);
            usb->start();
            ui->pushButton->setText(u8"停止传输");
            t->stop();
            ucontrol->setIT(5.00);
            on_pushButton_2_clicked();
            d_it = 5.00;
        });
        t->start(2000);
        ui->label->setText(QString::fromLocal8Bit("开启传输中,请等待"));
    }
    else{
        usb->setStatu(false);
        usb->stopProcessData();
        ui->pushButton->setText(u8"开始传输");
    }


}


void MainWindow::on_pushButton_2_clicked()
{
    ucontrol->bit14(true);

    usb->SetImageInfo(type,rows,cols);

    m1->opentec();
    ucontrol->tec(true);


#if CLIENT == 0 || CLIENT == 1
    ucontrol->setIT(5.0);
    ucontrol->setGPOL(800);
    ucontrol->openk(true);
    ucontrol->openb(true);




#elif CLIENT == 2


    ucontrol->openk(false);
    ucontrol->openb(false);
#endif



}


void MainWindow::on_pushButton_3_clicked()
{
    b_stat = ui->pushButton_3->isChecked();
    if(b_stat){
        ui->pushButton_3->setText(u8"暂停统计");
    }
    else{
        ui->pushButton_3->setText(u8"开始统计");
    }

}

void MainWindow::slotShowImage(cv::Mat img)
{



    fpscount +=1;
    if(flip0){
        cv::flip(img,img,0);
    }

    if(flip1){
        cv::flip(img,img,1);
    }


    if(savebin){
        purefile->write((char*)img.data,img.total()*img.elemSize());
        purefile->flush();
    }

    if(savesbin){
        if(sbinnum>0){
            spurefile->write((char*)img.data,img.total()*img.elemSize());
            spurefile->flush();
        }
        sbinnum -=1;


        if(sbinnum == 0){
            spurefile->close();
            savesbin = false;
        }
    }


    if(b_temp_save){
        m_temp[img.at<ushort>(imageY,imageX)/4] = d_temp;
        b_temp_save = false;
    }




    if(b_con && (!b_temp)){
        cv::Mat image;


        img.convertTo(image,CV_32SC1);

        double avg = cv::mean(image).val[0];

        cv::Mat dst = cv::Mat(rows,cols,CV_16UC1);

        int  s,d;

        for(int i = 0;i<image.rows;i++){
            for (int j = 0; j< image.cols;j++){
                s = image.at<int>(i,j) - avg;
                d = s*d_con+avg+d_con_bright*4;
                if(d<0)d = 0;
                if(d>65535) d = 65535;
                dst.at<ushort>(i,j) = d;
            }
        }
        img = dst;
    }


    if(b_stat ){
        if(img.type() == CV_16UC1)
            lastimage = img/4;
        else
            lastimage = img;

        if( imageX>=0 && imageX<img.cols && imageY>=0 && imageY< img.rows){
            int r = 2;
            int lmask[25] = {0};
            int ldata[25] = {0};
            for (int i = -r;i<=r;i++){
                for (int j = -r;j<=r;j++){
                    int row = i+imageY;
                    int col = j+imageX;
                    if(row<0 || row>=lastimage.rows|| col<0 || col>=lastimage.cols){
                        ui->tableWidget->setItem(i+r,j+r,new QTableWidgetItem());

                    }
                    else{
                        lmask[(i+r)*(2*r+1)+(j+r)] = 1;
                        if(lastimage.type() == CV_16UC1){

                            QTableWidgetItem *item;
                            if(b_temp && m_temp.size()>2){
                                double t0 = lastimage.at<ushort>(row,col);
                                QList<double> temps =  m_temp.keys();
                                int len = temps.size();
                                if(t0<temps[1])
                                    t0 = (t0-temps[0])/(temps[1]-temps[0])*(m_temp[temps[1]]-m_temp[temps[0]]) + m_temp[temps[0]];
                                else if(t0>temps[temps.size()-2]){
                                    t0 = (t0-temps[len-2])/(temps[len-1]-temps[len-2])*(m_temp[temps[len-1]]-m_temp[temps[len-2]]) + m_temp[temps[len-2]];
                                }
                                else for(int k = 0;k<temps.size()-1;k++){
                                    if(t0>temps[k] && t0<temps[k+1])
                                        t0 = (t0-temps[k])/(temps[k+1]-temps[k])*(m_temp[temps[k+1]]-m_temp[temps[k]]) + m_temp[temps[k]];
                                }

                                item= new QTableWidgetItem(QString::number(t0));
                            }
                            else
                                item= new QTableWidgetItem(QString::number(lastimage.at<ushort>(row,col)));
                            int gray = lastimage.at<ushort>(row,col)/64/2+64;
                            item->setBackground(QColor(gray,gray,gray));
                            ui->tableWidget->setItem(i+r,j+r,item);
                            ldata[(i+r)*(2*r+1)+(j+r)] = lastimage.at<ushort>(row,col);
                        }
                        else{
                            QTableWidgetItem *item = new QTableWidgetItem(QString::number(lastimage.at<uchar>(row,col)));
                            int gray = lastimage.at<uchar>(row,col)/2+64;
                            item->setBackground(QColor(gray,gray,gray));
                            ui->tableWidget->setItem(i+r,j+r,item);
                            ldata[(i+r)*(2*r+1)+(j+r)] = lastimage.at<uchar>(row,col);
                        }

                    }
                }
            }
            double sum = 0;
            double msum = 0;
            double sum2 = 0;

            for(int i = 0; i< 25;i++){
                sum+= lmask[i]*ldata[i];
                msum += lmask[i];
                sum2 += lmask[i]*ldata[i]*ldata[i];
            }
            if(msum!=0){
                double avg = sum/msum;
                double SIGMA = sum2/msum - avg*avg;
                double sigma = sqrt(SIGMA);
                ui->lineEdit->setText(QString::number(imageX));
                ui->lineEdit_2->setText(QString::number(imageY));
                ui->lineEdit_3->setText(QString::number(avg,'f',2));
                ui->lineEdit_4->setText(QString::number(sigma,'f',2));
            }
        }
        else{
            ui->lineEdit->setText("");
            ui->lineEdit_2->setText("");
            ui->lineEdit_3->setText("");
            ui->lineEdit_4->setText("");
        }

        int lows = 0;
        int highs = 0;
        double sum = 0;
        double sum2 = 0;
        double sigma = 0;

        if(lastimage.type() == CV_16UC1){
            for(int i = 0;i<lastimage.rows;i++){
                for(int j = 0; j<lastimage.cols;j++){
                    int temp;
                    temp =lastimage.at<ushort>(i,j);
                    if(temp == 0){
                        lows+=1;
                    }
                    if(temp == 16383){
                        highs +=1;
                    }
                    sum += temp;
                    sum2+=temp*temp;
                }
            }
        }
        else{
            for(int i = 0;i<lastimage.rows;i++){
                for(int j = 0; j<lastimage.cols;j++){
                    int temp;
                    temp =lastimage.at<uchar>(i,j);
                    sum += temp;
                    sum2+=temp*temp;
                }
            }
        }
        int avg = sum/rows/cols;
        sigma = sqrt( sum2/rows/cols -avg*avg);

        if(mpnum>0){
            mpsum += avg;
            if(mpnum == 1){
                mpsum = mpsum/16;
                ucontrol->mpset(mpidx,mpsum);
                m5_1->slotGetavg(mpsum);
            }
            mpnum --;
        }

        if(lastimage.type() == CV_16UC1){
            ui->lineEdit_5->setText(QString::number(lows));
            ui->lineEdit_6->setText(QString::number(highs));
        }
        else{
            ui->lineEdit_5->setText("");
            ui->lineEdit_6->setText("");
        }
        ui->lineEdit_7->setText(QString::number(avg,'f',2));
        ui->lineEdit_8->setText(QString::number(sigma,'f',2));
    }
    if(img.type() == CV_16UC1)
    {
    img.convertTo(img,CV_8UC1,1.0/257);
    }
    QImage image(img.data,img.cols,img.rows,img.cols,QImage::Format_Grayscale8);
    QPixmap pix = QPixmap::fromImage(image);
    if(shotimg){
        QString now = QDateTime::currentDateTime().toString("yyyy_MM_dd_hh_mm_ss");
        QString  imgfile = path+ now+".png";
        cv::imwrite(imgfile.toLocal8Bit().toStdString(),img);
        QString t  =path+now+".tiff";
        cv::imwrite(t.toLocal8Bit().toStdString(),img);

        QString filename = path+now+".bin";

        QFile file(filename);
        file.open(QIODevice::NewOnly);
        file.write((char*)img.data,img.total()*img.elemSize());
        file.flush();
        file.close();
        shotimg  = false;
    }
    if(shotbin){
        QDateTime t = QDateTime::currentDateTime();
        QString filename = path+ t.toString("yyyy-MM-dd-hh-mm-ss");
        if(type == gray8)
            filename+= "-8bit.bin";
        else if(type == gray16)
            filename+= "-14bit.bin";
        QFile file(filename);
        file.open(QIODevice::NewOnly);
        file.write((char*)img.data,img.total()*img.elemSize());
        file.flush();
        file.close();
        shotbin = false;
    }

    if(savevideo){
        writer->write(img);
    }



    if(b_stat &(!b_fullscreen)){
        QPainter p(&pix);
        QPen pen = p.pen();
        QPen npen(QColor(0xad,0x14,0x53));
        npen.setWidth(4);
        p.setPen(npen);
        if(imageX>=0 && imageX<img.cols && imageY>=0 && imageY< img.rows){
            p.drawLine(imageX-10,imageY,imageX+10,imageY);
            p.drawLine(imageX,imageY-10,imageX,imageY+10);
        }
        p.setPen(pen);
    }
    if(b_fullscreen)
        ui->label->setPixmap(pix.scaled(ui->label->size(),Qt::KeepAspectRatio,Qt::SmoothTransformation));
    else
        ui->label->setPixmap(pix);

}

void MainWindow::slotlogtext(QString msg)
{
    ui->textBrowser->append(msg);
}

void MainWindow::slotlogstatus()
{


    lfps->setText(QString::fromLocal8Bit("当前帧率为")+QString::number(fps));


}

bool MainWindow::eventFilter(QObject *obj, QEvent *e)
{
    if(obj == ui->label && e->type() == QEvent::MouseButtonPress){
        QMouseEvent* ev = static_cast<QMouseEvent*>(e);
        imageX = ev->x();
        imageY =ev->y();
        return true;
    }

    if(obj == ui->label && e->type()== QEvent::MouseButtonDblClick){
        b_fullscreen = !b_fullscreen;
        if(b_fullscreen){
            ui->label->setWindowFlag(Qt::Window);
            ui->label->showFullScreen();
            ui->label->setAlignment(Qt::AlignHCenter);
        }
        else{
            ui->label->setWindowFlags(Qt::SubWindow);
            ui->label->showNormal();
            ui->label->setAlignment(Qt::AlignLeft|Qt::AlignTop);
        }
        return true;
    }


    return false;
}

void MainWindow::keyPressEvent(QKeyEvent *ev)
{

    if(ev->key() == Qt::Key_A){
        imageX-=1;
    }
    if(ev->key() == Qt::Key_D){
        imageX+=1;
    }
    if(ev->key() == Qt::Key_W){
        imageY-=1;
    }
    if(ev->key() == Qt::Key_S){
        imageY+=1;
    }

    if((ev->modifiers() == Qt::ControlModifier) && (ev->key()== Qt::Key_A)){
        passwd* pswd = new passwd();
        pswd->show();
        connect(pswd,&QDialog::accepted,[=](){
//            m1->showui();
            if(m5!=nullptr)
            m5->showui();

        });
    }
    if((ev->modifiers() == Qt::ControlModifier) && (ev->key()== Qt::Key_Q)){
//        m1->hideui();
        if(m5!=nullptr)
            m5->hideui();
    }

}

void MainWindow::initIns()
{
    qRegisterMetaType<cv::Mat>("cv::Mat");
    qRegisterMetaType<QVector<double>>("QVector<double>");

    usb = new usbthread();
    ucontrol = new usbcontrol();


    QTimer* t = new QTimer(this);
    connect(t,&QTimer::timeout,[=](){
        fps = fpscount;
        fpscount = 0;
        slotlogstatus();
    });
    t->start(1000);


#if CLIENT == 2
    m_avg = new avgfilter();
    m_bila = new bila();
    m_dde = new dde();
    m_sagauss = new sagauss();
    m_tp = new twoPoint();
    m_clhe = new clhe();
    m_mp = new MultiPoint();
#else
    m_mp = nullptr;
    mpnum = 0;

#endif

    b_temp = false;
    b_temp_save = false;
    QDir d;

    if(!d.exists("datas"))
        if(! d.mkdir("datas")){
            slotlogtext(u8"无法新建数据文件夹, 请重新安装软件, 注意安装路径的权限问题");
    }
    d.mkdir("files");
}


void MainWindow::on_spinBox_valueChanged(int arg1)
{
    rows = arg1;
    ui->scrollAreaWidgetContents->setMinimumHeight(rows+20);
    ui->label->resize(cols,rows);
    m_mp->setparas(rows,cols);
}


void MainWindow::on_spinBox_2_valueChanged(int arg1)
{
    cols = arg1;
    ui->scrollAreaWidgetContents->setMinimumWidth(cols+20);
    ui->label->resize(cols,rows);
    m_mp->setparas(rows,cols);

}