#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)
{
    ui->setupUi(this);

    initIns();
    ddd;

    initUI();
    ddd;

    initConnect();
    ddd;


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



    on_comboBox_currentIndexChanged(0);

    drawbackground();
}



void MainWindow::drawbackground()
{
    curimage = QPixmap(cols+100,rows+100);
    QPainter painter(&curimage);
    QPen pen(QColor(12,134,156));
    pen.setWidth(2);
    painter.setPen(pen);
    painter.drawLine(50-3,50-3,50-3,rows+50);
    painter.drawLine(50-3,50-3,cols+50,50-3);
    painter.drawText(40,40,QString(u8"0"));

    for(int i = 50;i<=rows;i+=50){
        painter.drawText(20,50+i,QString::number(i));
        painter.drawLine(50-3,50+i,50-3-2,50+i);
    }
    for(int j = 50;j<=cols;j+=50){
        painter.drawText(50+j,40,QString::number(j));
        painter.drawLine(50+j,50-3,50+j,50-3-2);

    }
    ddd<<ui->scrollArea->size()<<"  "<<ui->imagelabel->size();
    ui->imagelabel->resize((cols+100)*imagerate,(rows+100)*imagerate);
    ui->scrollAreaWidgetContents->setMinimumHeight(((rows+100)*imagerate+1>ui->scrollArea->height()-8)?((rows+100)*imagerate+1):(ui->scrollArea->height()-8));
    ui->scrollAreaWidgetContents->setMinimumWidth(((cols+100)*imagerate+1>ui->scrollArea->width()-8)?((cols+100)*imagerate+1):(ui->scrollArea->width()-8));
//    if(cols+100>ui->scrollAreaWidgetContents->height()  )

    ddd<<ui->scrollArea->size()<<"  "<<ui->scrollAreaWidgetContents->size()<<" "<<ui->imagelabel->size();

    if(ui->imagelabel->width()<ui->scrollArea->width() || ui->imagelabel->height()<ui->scrollArea->height()){
        ui->imagelabel->move((ui->scrollArea->width()-ui->imagelabel->width())/2,(ui->scrollArea->height()-ui->imagelabel->height())/2);
//        ui->imagelabel->move(100,100);
        ddd;
    }
    else{
        ui->imagelabel->move(0,0);
    }
//    ui->imagelabel->setPixmap(curimage.scaled(curimage.size()*imagerate));
//    curimage.save("wtf.bmp");
}

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

void MainWindow::initUI()
{

    b_af = false;
    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;
    b_bp = false;
    fps = 0;
    fpscount = 0;
    path = QDir::homePath()+"/zxrcfiles/";


    b_noise = false;
    n_noise = -1;
    v_noise.clear();

    ddd<<path;
    QDir d;
    d.mkdir(path);

    ui->spinBox->setEnabled(false);
    ui->spinBox_2->setEnabled(false);

    QSettings st(path+"dir.ini",QSettings::IniFormat);
    if(st.value("path").toString() == ""){

    }
    else{
        path = st.value("path").toString()+"/";
    }
    ddd<<path;

    QString title = QString::fromLocal8Bit("BIT测试系统");
#if CLIENT==0
    title +="SA";
    ui->centralwidget->setStyleSheet("background-color:rgb(230,240,250);");

#else
    //    title +="PC";
    resize(960,800);
    // ui->centralwidget->setStyleSheet("background-color:rgb(250,240,230);");

#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_12);
    ui->toolBar->addWidget(ui->comboBox);
    ui->toolBar->addWidget(ui->label_2);
    ui->toolBar->addWidget(ui->spinBox);
    ui->toolBar->addWidget(ui->label_3);
    ui->toolBar->addWidget(ui->spinBox_2);
    // ui->toolBar->addWidget(ui->pushButton_13);


    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;
    menu7* m7 = new menu7;

    ptest = new TogglePushButton(u8"打开测试系统");
    ui->toolbox->addItem(ptest,u8"测试系统");
    connect(ptest,&TogglePushButton::clicked,[=](){
        if(ptest->isChecked()) {
            m7->show();
        }
        else{
            m7->hide();
        }
    });
    // ui->toolBar->addWidget(ptest);

    //    ui->toolbox->addItem(m6, u8"测温设置");
    // ui->toolbox->addItem(m7,u8"测试系统");
    connect(m6,&menu6::signalSetTemp,[=](double temp){
        b_temp_save = true;
        d_temp = temp;
    });
    connect(m6,&menu6::signalTurnTemp,[=](bool b){
        b_temp = b;
    });
    connect(m7,SIGNAL(signaltest(QStringList)),dthread,SLOT(gendoc(QStringList)));
    connect(m7,SIGNAL(signallowtemp(QString)),this,SLOT(slotsavelow(QString)));
    connect(m7,SIGNAL(signalhightemp(QString)),this,SLOT(slotsavehigh(QString)));

#endif

    type = gray16;
    rows = ui->spinBox->value();
    cols = ui->spinBox_2->value();
    ddd;
    bpimg = cv::Mat(rows,cols,CV_8UC1);
    memset(bpimg.data,0,rows*cols);

    ui->scrollAreaWidgetContents->setMinimumSize(cols+20,rows+20);
    ui->imagelabel->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->imagelabel->installEventFilter(this);

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

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

    ddd;

    ui->imagelabel->setWindowFlags(Qt::SubWindow);
    ui->imagelabel->showNormal();
    ui->imagelabel->setAlignment(Qt::AlignLeft|Qt::AlignTop);
}

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,SIGNAL(signalsetspname(QString)),ucontrol,SLOT(slotsetspname(QString)));
    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);
        }
    });

    connect(usb,SIGNAL(signalGetImage(cv::Mat)),m_af,SLOT(slotprocimg(cv::Mat)));
    connect(m_af,&autoFlash::signalSetIT,[=](double it){
        if(b_af)
            if(d_it -it >0 && d_it-it<=10){
                ucontrol->setIT(d_it-it);
                d_it -=it;
                if(m_mp!=nullptr){
                    //            ddd<<this->deviceid<<it;
                    //            m_mp->loaddata(this->deviceid,it);
                    m_mp->setit(d_it);
                }
            }
    });


    connect(usb,SIGNAL(signalGetImage(cv::Mat)),this,SLOT(slotnoise(cv::Mat)));


#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(m1,SIGNAL(signalsetge(bool)),ucontrol,SLOT(setge(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(m5,SIGNAL(signalrmbld(bool)),m_mp,SLOT(setrmblk(bool)));
    connect(m5,SIGNAL(signalthre(double)),m_mp,SLOT(slotSetThre(double)));


    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->enable = true;
        m_mp->setdevice(path);

        //        m_mp->loaddata();
    });
    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+"/";
            QSettings st(QDir::homePath()+"/zxrcfiles/dir.ini",QSettings::IniFormat);
            st.setValue("path",path);

        }
        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();

    //    ui->pushButton_10->hide();//测试

    ///
    ///
    ///

       ui->pushButton_4->hide();
       ui->pushButton_5->hide();
       ui->pushButton_6->hide();
       ui->pushButton_7->hide();
       ui->pushButton_8->hide();
       ui->pushButton_9->hide();
       ui->pushButton_10->hide();
       ui->pushButton_11->hide();
       ui->pushButton_12->hide();
       ui->pushButton_13->hide();
       ui->pushButton_14->hide();
       ui->pushButton_15->hide();

       ui->spinBox_4->hide();
       ui->spinBox_3->hide();
       ui->lineEdit_9->hide();
       ui->lineEdit_10->hide();
}


void MainWindow::on_pushButton_clicked()// 开启传输
{
    if(ui->pushButton->isChecked()){
        ui->spinBox->setEnabled(false);
        ui->spinBox_2->setEnabled(false);
        QTimer *t = new QTimer;
        connect(t,&QTimer::timeout,[=](){
            on_pushButton_2_clicked();
            usb->SetImageInfo(type,rows,cols);
            if(ui->comboBox->currentIndex() == 0){
                usb->settest();
            }
            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->imagelabel->setText(QString::fromLocal8Bit("开启传输中,请等待"));
    }
    else{
        ui->spinBox->setEnabled(true);
        ui->spinBox_2->setEnabled(true);
        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)
{

    if(savelowtemp | savehightemp){
        if(lowcount>0){
            lowcount--;
            tf->write((char*)img.data,img.total()*img.elemSize());
            tf->flush();
            if(lowcount ==0){
                savelowtemp = false;
                tf->close();
                slotlogtext(u8"保存测试用低温背景完成");
            }
        }
        else{
            highcount--;
            tf->write((char*)img.data,img.total()*img.elemSize());
            tf->flush();
            if(highcount ==0){
                savehightemp = false;
                tf->close();
                slotlogtext(u8"保存测试用高温背景完成");
            }
        }
    }


    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;
                if(d<0)d = 0;
                if(d>65535) d = 65535;
                dst.at<ushort>(i,j) = d;
            }
        }
        img = dst;
    }

    if(b_bp){
        for(int i = 0;i< rows;i++){
            for(int j = 0;j<cols;j++){
                if(bpimg.at<uchar>(i,j) == 1){
                    int n = 8- (bpimg.at<uchar>(i+1,j)+
                                bpimg.at<uchar>(i-1,j)+
                                bpimg.at<uchar>(i+1,j-1)+
                                bpimg.at<uchar>(i-1,j-1)+
                                bpimg.at<uchar>(i+1,j+1)+
                                bpimg.at<uchar>(i-1,j+1)+
                                bpimg.at<uchar>(i,j+1)+
                                bpimg.at<uchar>(i,j-1));
                    int sum = (1-bpimg.at<uchar>(i+1,j))*img.at<ushort>(i+1,j)+
                            (1-bpimg.at<uchar>(i-1,j))*img.at<ushort>(i-1,j)+
                            (1-bpimg.at<uchar>(i+1,j+1))*img.at<ushort>(i+1,j+1)+
                            (1-bpimg.at<uchar>(i-1,j+1))*img.at<ushort>(i-1,j+1)+
                            (1-bpimg.at<uchar>(i+1,j-1))*img.at<ushort>(i+1,j-1)+
                            (1-bpimg.at<uchar>(i-1,j-1))*img.at<ushort>(i-1,j-1)+
                            (1-bpimg.at<uchar>(i,j+1))*img.at<ushort>(i,j+1)+
                            (1-bpimg.at<uchar>(i,j-1))*img.at<ushort>(i,j-1);
                    if(n>0)
                        img.at<ushort>(i,j) = sum/n;
                    else img.at<ushort>(i,j) = 0;
                }
            }
        }
    }

    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.0);
    }
    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_testmode)
        // {
        //     writer->write(img);
        //     writer->write(img);
        // }
    }



    if(b_stat &(!b_fullscreen) &(!ui->pushButton_13->isChecked())){
        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->imagelabel->setPixmap(pix.scaled(ui->imagelabel->size(),Qt::KeepAspectRatio,Qt::SmoothTransformation));
    else
    {
        QPainter painter(&curimage);
        painter.drawPixmap(50,50,pix);
        ui->imagelabel->setPixmap(curimage.scaled(curimage.size()*imagerate));

        // if(ui->pushButton_13->isChecked()){
        //     if(ui->scrollArea->size() - QSize(20,20) != ui->imagelabel->size()){
        //         ui->imagelabel->resize(ui->scrollArea->size() - QSize(30,30));
        //         ui->imagelabel->move(10,10);
        //         ui->imagelabel->setAlignment(Qt::AlignLeft|Qt::AlignTop);

        //     }
        //     ui->imagelabel->setPixmap(pix.scaled(ui->scrollArea->size() - QSize(30,30),Qt::KeepAspectRatio,Qt::SmoothTransformation));

        // }
        // else{
        //     if(ui->imagelabel->size() != QSize(cols,rows)){
        //         ui->imagelabel->resize(cols,rows);
        //         ui->imagelabel->move(10,10);
        //         ui->imagelabel->setAlignment(Qt::AlignLeft|Qt::AlignTop);

        //     }
        //     ui->imagelabel->setPixmap(pix);
        // }
    }
}

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

void MainWindow::slotlogstatus()
{


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


}

void MainWindow::slotsavelow(QString id)
{
    if(savelowtemp || savehightemp){
        slotlogtext(u8"正在保存背景数据");
        return;
    }
    QDir d;
    if(!d.exists("reportGen/"+id))
        if(! d.mkdir("reportGen/"+id)){
            slotlogtext(u8"无法新建数据文件夹, 请重新安装软件, 注意安装路径的权限问题");
        }
    lowfilename ="low"+ QDateTime::currentDateTime().toString("yyyy_MM_dd_hh_mm_ss")+".bin";
    tf = new QFile("reportGen/"+id+"/"+lowfilename);
    tf->open(QIODevice::ReadWrite);
    lowcount =100;
    savelowtemp = true;
    dthread->slotsetlow(lowfilename);
}

void MainWindow::slotsavehigh(QString id)
{
    if(savelowtemp || savehightemp){
        slotlogtext(u8"正在保存背景数据");
        return;
    }
    QDir d;
    if(!d.exists("reportGen/"+id))
        if(! d.mkdir("reportGen/"+id)){
            slotlogtext(u8"无法新建数据文件夹, 请重新安装软件, 注意安装路径的权限问题");
        }
    highfilename ="high"+ QDateTime::currentDateTime().toString("yyyy_MM_dd_hh_mm_ss")+".bin";
    tf = new QFile("reportGen/"+id+"/"+highfilename);
    tf->open(QIODevice::ReadWrite);
    highcount =100;
    savehightemp = true;
    dthread->slotsethigh(highfilename);
}

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

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

    if( e->type() == QEvent::Wheel){
          if(QApplication::keyboardModifiers() == Qt::Modifier::CTRL){
              if(obj == ui->imagelabel){
                  imagerate += (static_cast<QWheelEvent*>(e)->delta()>0)?0.05:-0.05;

  //                qDebug()<<"ok"<<imagerate;
                  ddd<<ui->scrollArea->size()<<"  "<<ui->imagelabel->size();
                  ui->imagelabel->resize((cols+100)*imagerate,(rows+100)*imagerate);
                  ui->scrollAreaWidgetContents->setMinimumHeight(((rows+100)*imagerate+1>ui->scrollArea->height()-8)?((rows+100)*imagerate+1):(ui->scrollArea->height()-8));
                  ui->scrollAreaWidgetContents->setMinimumWidth(((cols+100)*imagerate+1>ui->scrollArea->width()-8)?((cols+100)*imagerate+1):(ui->scrollArea->width()-8));
                  //    if(cols+100>ui->scrollAreaWidgetContents->height()  )

                  ddd<<ui->scrollArea->size()<<"  "<<ui->scrollAreaWidgetContents->size()<<" "<<ui->imagelabel->size();

                  if(ui->imagelabel->width()<ui->scrollArea->width() || ui->imagelabel->height()<ui->scrollArea->height()){
                      ui->imagelabel->move((ui->scrollArea->width()-ui->imagelabel->width())/2,(ui->scrollArea->height()-ui->imagelabel->height())/2);
                      //        ui->imagelabel->move(100,100);
                      ddd;
                  }
                  else{
                      ui->imagelabel->move(0,0);
                  }                return true;
              }
          }
          return false;
      }

    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();
            m1->showui();

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

}

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

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

    m_af = new autoFlash();
    imagerate = 1.0;

    QTimer* t = new QTimer(this);
    connect(t,&QTimer::timeout,[=](){

        if(ui->comboBox->currentIndex() == 0 && fpscount>0)
            fps = int(fpscount*3.51) + (rand()%4);
        else
            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");


    savelowtemp = false;
    savehightemp =false;
    lowcount = 0;
    highcount = 0;
    dthread = new docthread;
}


void MainWindow::on_spinBox_valueChanged(int arg1)
{
    rows = arg1;
    ui->scrollAreaWidgetContents->setMinimumHeight(rows+20);
    ui->imagelabel->resize(cols,rows);
    ui->imagelabel->move(10,10);
    ui->imagelabel->setAlignment(Qt::AlignLeft|Qt::AlignTop);

    qDebug()<<__LINE__<<ui->scrollArea->width()<<" "<<ui->scrollArea->height();
    qDebug()<<ui->imagelabel->width()<<" "<<ui->imagelabel->height();
#if CLIENT==2
    m_mp->setparas(rows,cols);

#endif

    bpimg = cv::Mat(rows,cols,CV_8UC1);
    memset(bpimg.data,0,rows*cols);
    drawbackground();

}


void MainWindow::on_spinBox_2_valueChanged(int arg1)
{
    cols = arg1;
    ui->scrollAreaWidgetContents->setMinimumWidth(cols+20);
    ui->imagelabel->resize(cols,rows);
    ui->imagelabel->move(10,10);
    ui->imagelabel->setAlignment(Qt::AlignLeft|Qt::AlignTop);

#if CLIENT == 2
    m_mp->setparas(rows,cols);
#endif
    bpimg = cv::Mat(rows,cols,CV_8UC1);
    memset(bpimg.data,0,rows*cols);
    drawbackground();
}


void MainWindow::on_pushButton_4_clicked()//标记为盲元

{
    if( imageX>=0 && imageX<cols && imageY>=0 && imageY< rows){
        bpimg.at<uchar>(imageY,imageX) = 1 ;
    }
}


void MainWindow::on_pushButton_5_clicked() //取消标记
{
    if( imageX>=0 && imageX<cols && imageY>=0 && imageY< rows){
        bpimg.at<uchar>(imageY,imageX) = 0 ;
    }
}


void MainWindow::on_pushButton_6_clicked() //打开盲元替换
{
    b_bp = true;
}


void MainWindow::on_pushButton_7_clicked() //关闭盲元替换
{
    b_bp = false;
}

#include <QFileDialog>
void MainWindow::on_pushButton_8_clicked()
{
    if(!bpimg.empty()){
        QString p = QFileDialog::getSaveFileName(nullptr,QString::fromLocal8Bit("保存盲元图"),path,"(*.bmp)");
        if(!p.isEmpty())
            cv::imwrite(p.toStdString(),bpimg);
    }
    /*
    QFile f(path+ QString::fromLocal8Bit("/盲元表.txt"));
    f.open(QIODevice::ReadWrite|QIODevice::Truncate);
    for(int i = 0;i<rows;i++){
        for(int j = 0;j< cols; j++){
            if(bpimg.at<uchar>(i,j) == 1){
                QString msg = "rows:"+ QString::number(i)+",cols"+QString::number(j)+"\n";
                f.write(msg.toUtf8());
            }
        }
    }
    f.close();
*/
}


void MainWindow::on_pushButton_9_clicked()
{
    QString p = QFileDialog::getOpenFileName(nullptr,QString::fromLocal8Bit("打开盲元图"),path,"(*.bmp)");
    //    cv::imwrite(p.toStdString(),bpimg);
    if(!p.isEmpty())
        bpimg = cv::imread(p.toStdString());
}

#include <QRandomGenerator64>

void MainWindow::on_pushButton_10_clicked()
{
    if(n_noise<0){
        b_noise = true;
        n_noise = ui->spinBox_4->value();
    }
    else{
        slotlogtext(u8"已经在执行计算时域噪声操作");
    }
}


void MainWindow::on_comboBox_currentIndexChanged(int index)
{
    qDebug()<<"WTF";
    switch (index) {
    case 0:
        rows = 2048;
        cols = 2560;
        ui->spinBox->setValue(2048);
        ui->spinBox_2->setValue(2560);
        ui->spinBox->setEnabled(false);
        ui->spinBox_2->setEnabled(false);
        dthread->settestmode(true);
        b_testmode =true;
        break;
    case 1:
        rows = 512;
        cols = 640;
        ui->spinBox->setValue(512);
        ui->spinBox_2->setValue(640);
        ui->spinBox->setEnabled(false);
        ui->spinBox_2->setEnabled(false);
        dthread->settestmode(false);
        b_testmode =false;
        //    ui->label_2->setVisible(false);
        //    ui->label_3->setVisible(false);
        break;
    case 2:
        rows = 1024;
        cols = 1280;
        ui->spinBox->setValue(1024);
        ui->spinBox_2->setValue(1280);
        ui->spinBox->setEnabled(false);
        ui->spinBox_2->setEnabled(false);
        dthread->settestmode(false);
        b_testmode = false;
        //    ui->spinBox->setVisible(false);
        //    ui->spinBox_2->setVisible(false);
        //    ui->label_2->setVisible(false);
        //    ui->label_3->setVisible(false);

        qDebug()<<2;
        break;
    case 3:
        dthread->settestmode(false);
        ui->spinBox->setEnabled(true);
        ui->spinBox_2->setEnabled(true);
        b_testmode =false;
        break;
    default:
        break;
    }

    drawbackground();
}


void MainWindow::on_spinBox_3_valueChanged(int arg1)
{
}


void MainWindow::on_pushButton_11_clicked()
{
    m_af->slotsetshre(ui->spinBox_3->value());

}


void MainWindow::on_pushButton_12_clicked()
{
    b_af =!b_af;
    if(b_af){
        slotlogtext(u8"开始自动曝光");
    }
    else{
        slotlogtext(u8"关闭自动曝光");
    }
}


void MainWindow::on_pushButton_13_clicked()
{
    if(ui->pushButton_13->isChecked()){
        ui->pushButton_13->setText(u8"适应屏幕");
    }
    else{
        ui->pushButton_13->setText(u8"原始大小");
    }
}


void MainWindow::on_pushButton_14_clicked()
{
    ui->lineEdit_9->setText(usb->getid());
}


void MainWindow::on_pushButton_15_clicked()
{
    ucontrol->setid(ui->lineEdit_10->text());
}

void MainWindow::slotnoise(Mat src)
{
    if(n_noise>0){
        cv::Mat tmp;
        src.convertTo(tmp,CV_64FC1);
        v_noise.push_back(tmp/4);
        n_noise --;
        //        cv::imshow("tmp",tmp/65535.0);
    }
    if(n_noise == 0){
        int n = v_noise.length();
        qDebug()<<__LINE__<<"n = "<<n;
        cv::Mat s = cv::Mat::zeros(rows,cols,CV_64FC1);
        cv::Mat ss = cv::Mat::zeros(rows,cols,CV_64FC1);

        for(int i = 0;i<n;i++){
            s += v_noise.at(i);
        }
        //        cv::imwrite("s.tiff",s);
        s = s/n;
        //        cv::imwrite("savg.tiff",s);
        for(int i = 0;i<n;i++){
            cv::Mat temp = v_noise.at(i) - s;
            cv::Mat pow;
            cv::pow(temp,2,pow);
            ss += pow;
        }
        //        s = s.mul(s);
        //        cv::imwrite("s.tiff",s);
        cv::imwrite("ss.tiff",ss);
        cv::Mat noise;
        cv::sqrt( ss/(n-1),noise);
        slotlogtext( QDateTime::currentDateTime().toString() + u8"前"+QString::number(n)+u8"帧计算得到的均方根的平均值为" + QString::number(cv::mean(noise).val[0]));
        std::string filename = "noise"+ QDateTime::currentDateTime().toString("yyyy-MM-dd-hh-mm-ss").toStdString()+".tiff";
        cv::imwrite(filename,noise);
        n_noise = -1;
        v_noise.clear();
    }
}