#include "rms_dll.h"
#include "QString"

#define SIZE 15    //迭代次数
#define MATSIZE 201 //总宽高
#define EDGE 40     //边
#define HALFMATSIZE 101
#include <QFile>
#include <QFileDialog>
#include <QPainter>

double biggest;
double smallest;
QImage image(450, 450, QImage::Format_RGB32); // 创建一个450x400的QImage对象
QImage imageRGB(MATSIZE,MATSIZE,QImage::Format_RGB32);
QImage imageRGBS(242,242,QImage::Format_RGB32);
int bos = 60;

RMS_Dll::RMS_Dll()
{
    _Socket = new QTcpSocket();
}
RMS_Dll::add(int a, int b)
{
    return a+b;
}

//实现接口连接探头，返回是否连接成功
bool RMS_Dll::RMS_Connect(QString IP, quint16 Port)
{
    //return 1;
    bool ret = false;
    //取消已有的连接
    _Socket->abort();
    //连接服务器
    _Socket->connectToHost(IP, Port);
    bool isconnect = _Socket->waitForConnected();//等待直到连接成功
    //如果连接成功
    if (isconnect)
    {
        ret = true;
        //接收缓冲区（服务器）信息
        //connect(_Socket, &QTcpSocket::readyRead, this, &TCPIPClient::ReadData);
    }

    return ret;
}
void RMS_Dll::RMS_Disconnect()
{
    _Socket->disconnectFromHost();
}

bool RMS_Dll::RMS_Read_Empty()
{
    dataInsert.clear();
    x.clear();
    biggest = 0;
    smallest = 0;
    ave = 0;
    modeImage = 0;
    stdDev = 0;
    image.fill(0);
    imageRGB.fill(0);
    imageRGBS.fill(0);

    QString Cmd = "EQINT,\rMRPMS,1,\r\n";

    bool ret = false;
    QByteArray data = Cmd.toLatin1();
    _Socket->write(data);
    //判断是否写入成功
    bool isWrite = _Socket->waitForBytesWritten();
    if (isWrite)
    {
        //写入成功
        ret = true;
    }else
    {
        return 0;
    }

    if(ret == true)
    {
        QString Str;
        bool isRead = _Socket->waitForReadyRead();
        if(isRead)
        {
            QByteArray Buff = _Socket->readAll();
            if (!Buff.isEmpty())
            {
                Str = QString(Buff);
            }
        }

        return 1;
    }else
    {
        return 0;
    }
}
double RMS_Dll::RMS_Read_Single()
{
    QString Cmd = "EQINT,\rMRPMS,1,\r\n";

    bool ret = false;
    QByteArray data = Cmd.toLatin1();
    _Socket->write(data);
    //判断是否写入成功
    bool isWrite = _Socket->waitForBytesWritten();
    if (isWrite)
    {
        //写入成功
        ret = true;
    }else
    {
        return 0;
    }

    if(ret == true)
    {
        QString Str;
        bool isRead = _Socket->waitForReadyRead();
        if(isRead)
        {
            QByteArray Buff = _Socket->readAll();
            if (!Buff.isEmpty())
            {
                Str = QString(Buff);
            }
        }
        Str.chop(3);
        int StartIndex = Str.lastIndexOf(",");
        int StopIndex = Str.count() - 1;
        QString DisPlayStr = Str.mid(StartIndex + 1, StopIndex);

         return DisPlayStr.toDouble();
    }
}
//实现接口进行读取，并返回是否读取成功
bool RMS_Dll::RMS_Read(int cx, int cy)
{
    QString Cmd = "EQINT,\rMRPMS,1,\r\n";

    bool ret = false;
    QByteArray data = Cmd.toLatin1();
    _Socket->write(data);
    //判断是否写入成功
    bool isWrite = _Socket->waitForBytesWritten();
    if (isWrite)
    {
        //写入成功
        ret = true;
    }else
    {
        return 0;
    }

    if(ret == true)
    {
        QString Str;
        bool isRead = _Socket->waitForReadyRead();
        if(isRead)
        {
            QByteArray Buff = _Socket->readAll();
            if (!Buff.isEmpty())
            {
                Str = QString(Buff);
            }
        }
        Str.chop(3);
        int StartIndex = Str.lastIndexOf(",");
        int StopIndex = Str.count() - 1;
        QString DisPlayStr = Str.mid(StartIndex + 1, StopIndex);
        double A;

        A = DisPlayStr.toDouble();
        //存储所有点
        x.append(A);///QVector<double> x;

        QStringList fields;
        fields.append("1");
        fields.append(QString::number(cx,10));
        fields.append(QString::number(cy,10));
        fields.append(DisPlayStr);
        dataInsert.append(fields);

        return 1;
    }else
    {
        return 0;
    }
}

//所有点读取完成，调用此接口，进行最大最小值计算并返回
void RMS_Dll::RMS_ACQ(double *max,double *min,double *med,double *mode)
{
    auto max1 = std::max_element(std::begin(x), std::end(x));//最小值表示
    auto min1 = std::min_element(std::begin(x), std::end(x));//直接赋值表示
    *max = *max1;
    *min = *min1;

    int size = x.size();
    std::sort(x.begin(), x.end()); // 对QVector进行排序
    if (size % 2 == 0)
    {
        *med = (x[size / 2 - 1] + x[size / 2]) / 2; // 如果QVector长度为偶数，则返回中间两个数的平均值
    } else {
        *med = x[size / 2]; // 如果QVector长度为奇数，则返回中间的数
    }

    QMap<double, int> countMap;
    int maxCount = 0;
    // 统计每个元素出现的次数
    for (int i = 0; i < x.size(); i++) {
        double key = x.at(i);
        if (countMap.contains(key)) {
            countMap[key]++;
        } else {
            countMap.insert(key, 1);
        }
    }
    // 找出出现次数最多的元素
    QMapIterator<double, int> iter(countMap);
    while (iter.hasNext()) {
        iter.next();
        if (iter.value() > maxCount) {
            maxCount = iter.value();
            *mode = iter.key();
            modeImage = *mode;
        }
    }

    return;
}
#include "cmath"
void RMS_Dll::RMS_P(double mode,double *Pt,double *Ps,double Pm,double Po)
{
    double t1 = 0.59;
    double t2 = 59.49;
    double s1 = 1.48;
    double s2 = 0.47;
    *Pt = Pm*(t1*exp(t2/(mode*1000))) + Po;
    *Ps = s1*(*Pt)+s2;
}



void trans(float arr[][MATSIZE][MATSIZE])//按真实值排序，范围界定真实值
{

    std::vector<float> seg;
    for (int i = EDGE; i < MATSIZE-EDGE; ++i)
    {
        for (int j = EDGE; j < MATSIZE-EDGE; ++j)
        {
            seg.push_back(arr[SIZE%2][i][j]);
        }
    }
    sort(seg.begin(), seg.end());//按升序排序

#if 1
    float small = (float)smallest;
    float big = (float)biggest;
#else if
    float small = seg[0];
    float big = seg[seg.size()-1];
#endif


    float eighth = (big - small)/8;
    //qDebug()<< "small:"<<small<<"biggest:"<<big;


    for (int ix = EDGE; ix < MATSIZE-EDGE; ix++)
    {
        for (int iy = EDGE; iy < MATSIZE-EDGE; iy++)
        {
            if (arr[SIZE%2][ix][iy] >= small && arr[SIZE%2][ix][iy]< small+eighth)
            {
                //qDebug() <<"blue";
                imageRGB.setPixel(iy,ix,qRgb(23,8,255));

                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(23,8,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(23,8,255));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(23,8,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(23,8,255));

            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth && arr[SIZE%2][ix][iy]<small+eighth*2)
            {
                imageRGB.setPixel(iy,ix,qRgb(80,90,255));

                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(80,90,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(80,90,255));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(80,90,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(80,90,255));
            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth*2 && arr[SIZE%2][ix][iy]<small+eighth*3)
            {
                imageRGB.setPixel(iy,ix,qRgb(98,162,255));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(98,162,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(98,162,255));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(98,162,255));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(98,162,255));
            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth*3 && arr[SIZE%2][ix][iy]<small+eighth*4)
            {
                imageRGB.setPixel(iy,ix,qRgb(73, 255, 173));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(73, 255, 173));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(73, 255, 173));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(73, 255, 173));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(73, 255, 173));
            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth*4 && arr[SIZE%2][ix][iy]<small+eighth*5)
            {
                imageRGB.setPixel(iy,ix,qRgb(177, 255, 70));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(177, 255, 70));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(177, 255, 70));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(177, 255, 70));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(177, 255, 70));
            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth*5 && arr[SIZE%2][ix][iy]<small+eighth*6)
            {
                imageRGB.setPixel(iy,ix,qRgb(255, 208, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(255, 208, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(255, 208, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(255, 208, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(255, 208, 0));
            }
            else if (arr[SIZE%2][ix][iy] >= small+eighth*6 && arr[SIZE%2][ix][iy]<small+eighth*7)
            {
                imageRGB.setPixel(iy,ix,qRgb(255, 89, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(255, 89, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(255, 89, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(255, 89, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(255, 89, 0));
            }
            else// if (arr[SIZE%2][ix][iy] >= small+eighth*7 && arr[SIZE%2][ix][iy]<=big)
            {
                imageRGB.setPixel(iy,ix,qRgb(196, 0, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2,qRgb(196, 0, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2,qRgb(196, 0, 0));
                imageRGBS.setPixel((iy-40)*2,(ix-40)*2+1,qRgb(196, 0, 0));
                imageRGBS.setPixel((iy-40)*2+1,(ix-40)*2+1,qRgb(196, 0, 0));
            }
        }
    }
}
//基函数
float bpline_w_f(float x)//函数返回权重，W(d)
{
    if (x <= 1)//x是d
    {
        return 2.0/3.0 - (1.0 - x/2.0)*x*x;
    }
    else if (x > 1 && x <= 2)
    {
        return (2.0 - x) * (2.0 - x) * (2.0 - x) / 6.0;
    }


    return 0.0;
}

//计算权重系数
void cal_bpline_coeff(float x, float y, float* coeff)//旧float传入
{
    float u = x - floor(x) + 1;//留小数部分+1
    float v = y - floor(y) + 1;


    float A[4];//计算出四个绝对值，4个d，得出x方向权重保存在数组A
    A[0] = bpline_w_f(abs(u));//传入距离，传出权重
    A[1] = bpline_w_f(abs(u - 1));
    A[2] = bpline_w_f(abs(u - 2));
    A[3] = bpline_w_f(abs(u - 3));


    for (int s = 0; s < 4; s++)
    {
        float C = bpline_w_f(abs(v - s));//同理计算y方向权重
        coeff[s * 4] = A[0] * C;
        coeff[s * 4 + 1] = A[1] * C;
        coeff[s * 4 + 2] = A[2] * C;
        coeff[s * 4 + 3] = A[3] * C;
    }
    //得到的coeff即周围16个点各自的权重（x*y）
}
//三次B样条插值，得到加权总值//传入新转旧float，得到了其周围16个点的权重，进而得到加权总值
float bpline_inner(float arr[][MATSIZE][MATSIZE], int k ,float x_float, float y_float)
{
    float coeff[16];
    cal_bpline_coeff(x_float, y_float, coeff);  //计算权重系数


    float sum = 0.0;
    int x0 = floor(x_float) - 1;
    int y0 = floor(y_float) - 1;//向下取整再减一


    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            sum += coeff[i * 4 + j] * arr[k%2][x0 + i][y0 + j];//周围16个点的权重乘以各自的值，加总
        }
    }

    return sum;//精度的核心就在于这个强转
}
float nearst_inner(float arr[][MATSIZE][MATSIZE], int k , float x_float, float y_float)
{

    //若自身不是255，则维持，若自身是255，则选取周围任意非空点

    if(arr[k%2][(int)(x_float)][(int)(y_float)] != 255)
    {
        return arr[k%2][(int)(x_float)][(int)(y_float)];
    }else
    {
        if(arr[k%2][(int)(x_float-1)][(int)(y_float-1)] != 255)return arr[k%2][(int)(x_float-1)][(int)(y_float-1)];
        if(arr[k%2][(int)(x_float-1)][(int)(y_float)] != 255)return arr[k%2][(int)(x_float-1)][(int)(y_float)];
        if(arr[k%2][(int)(x_float-1)][(int)(y_float+1)] != 255)return arr[k%2][(int)(x_float-1)][(int)(y_float+1)];
        if(arr[k%2][(int)(x_float+1)][(int)(y_float-1)] != 255)return arr[k%2][(int)(x_float+1)][(int)(y_float-1)];
        if(arr[k%2][(int)(x_float+1)][(int)(y_float)] != 255)return arr[k%2][(int)(x_float+1)][(int)(y_float)];
        if(arr[k%2][(int)(x_float+1)][(int)(y_float+1)] != 255)return arr[k%2][(int)(x_float+1)][(int)(y_float+1)];
        if(arr[k%2][(int)(x_float)][(int)(y_float-1)] != 255)return arr[k%2][(int)(x_float)][(int)(y_float-1)];
        if(arr[k%2][(int)(x_float)][(int)(y_float+1)] != 255)return arr[k%2][(int)(x_float)][(int)(y_float+1)];
    }


    return arr[k%2][(int)(x_float)][(int)(y_float)];
}
void RMS_Dll::dotToImg()
{
    /***************************************************************
     * dotToImg()
     dotToImg，将点数据转化成热力图
     * 输入：
     *      无
     * 输出：
     *      无
     * 描述：
     *      根据接收到的所有电阻率点的数据进行热力图绘制，数据于dataRecv中
     *      逐点读取，生成的热力图保存于imageRGBS
     **************************************************************/

    float Arr[2][MATSIZE][MATSIZE];

    //-------------------把src矩阵赋给堆[0]------------------------------
    int rows = dataInsert.size();///有几条QStringList，即几个点

    for (int x = 0; x < MATSIZE; x++)
    {
        for (int y = 0; y < MATSIZE; y++)
        {
            Arr[0][x][y] = 255;
            Arr[1][x][y] = 255;
            //txtOutput<< "X:"<<Arr[0][x][y]<<"y:"<<Arr[0][x][y];
        }
    }
    for (int i = 0; i < rows; i++)///出问题的原因在于忽略了Mat的255初始化
    {
        int num1,num2;
        //对坐标进行缩放
        if(bos == 60)
        {
            num1 = (int)(dataInsert[i][1].toFloat()+HALFMATSIZE);
            num2 = (int)(dataInsert[i][2].toFloat()+HALFMATSIZE);
        }
        else if(bos == 80)
        {
            num1 = (int)((dataInsert[i][1].toFloat()*60/89+HALFMATSIZE));
            num2 = (int)((dataInsert[i][2].toFloat()*60/89+HALFMATSIZE));
        }
        else if(bos == 40)
        {
            num1 = (int)((dataInsert[i][1].toFloat()*60/45+HALFMATSIZE));
            num2 = (int)((dataInsert[i][2].toFloat()*60/45+HALFMATSIZE));
        }
        Arr[0][num1][num2] = (dataInsert[i][3].toFloat()*10000);
        Arr[1][num1][num2] = (dataInsert[i][3].toFloat()*10000);
        //Arr[0][dataInsert[i][1].toInt()+HALFMATSIZE][dataInsert[i][2].toInt()+HALFMATSIZE] = (dataInsert[i][3].toFloat()*10000);
        //Arr[1][dataInsert[i][1].toInt()+HALFMATSIZE][dataInsert[i][2].toInt()+HALFMATSIZE] = (dataInsert[i][3].toFloat()*10000);
    }
    //-----------------------------------------------------------------


    for(int k = 0;k<SIZE;k++)
    {
        for (int x = 5; x < MATSIZE-5; x++)
        {
            for (int y = 5; y < MATSIZE-5; y++)
            {

                if(k%2 == 0)
                {
                    //Arr[1][x][y] = bpline_inner(Arr, k, x, y);//k是偶数，则数据源为 Arr0
                    Arr[1][x][y] = nearst_inner(Arr, k, x, y);
                    //if(isnan(Arr[1][x][y]) == 1 || Arr[1][x][y]>255 || Arr[1][x][y] == 0) Arr[1][x][y] = 255;
                }
                else
                {
                    //Arr[0][x][y] = bpline_inner(Arr, k, x, y);
                    Arr[0][x][y] = nearst_inner(Arr, k, x, y);
                    //if(isnan(Arr[0][x][y]) == 1 || Arr[0][x][y]>255 || Arr[0][x][y] == 0) Arr[0][x][y] = 255;
                }
            }
        }
    }
    for(int k = 0;k<4;k++)
    {
        for (int x = 5; x < MATSIZE-5; x++)
        {
            for (int y = 5; y < MATSIZE-5; y++)
            {

                if(k%2 == 0)
                {
                    Arr[1][x][y] = bpline_inner(Arr, k, x, y);//k是偶数，则数据源为 Arr0
                    //if(isnan(Arr[1][x][y]) == 1 || Arr[1][x][y]>255 || Arr[1][x][y] == 0) Arr[1][x][y] = 255;
                }
                else
                {
                    Arr[0][x][y] = bpline_inner(Arr, k, x, y);
                    //if(isnan(Arr[0][x][y]) == 1 || Arr[0][x][y]>255 || Arr[0][x][y] == 0) Arr[0][x][y] = 255;
                }
            }
        }
    }

    float ary90[MATSIZE][MATSIZE];

    //旋转数组
    for (int i = 0; i < MATSIZE; i++)
    {
        for (int j = 0; j < MATSIZE; j++)
        {
            //ary90[j][MATSIZE - i - 1] = Arr[SIZE%2][i][j];//顺时针90度
            ary90[MATSIZE - j - 1][i] = Arr[SIZE%2][i][j];//逆时针90度
        }
    }

    for (int i = 0; i < MATSIZE; i++)
    {
        for (int j = 0; j < MATSIZE; j++)
        {
            Arr[SIZE%2][i][j] = ary90[i][j];
        }
    }

    trans(Arr);

}
void RMS_Dll::Algo()
{
/***************************************************************
 * 名称：Algo()
 * 功能：将热力图绘制在窗口上
 * 输入：
 *      无
 * 输出：
 *      无
 * 描述：
 *      根据imageRGBS进行热力图的显示，并画出坐标系
 *
 **************************************************************/

    biggest*=10000;
    smallest*=10000;

    //qDebug()<<biggest<<smallest;

    //float multiple = (float)256/scope;//放大系数
    //点值减最小值乘以放大系数

    dotToImg();

    //image.fill(Qt::white); // 将背景填充为白色
    //背景填充
    if(bos == 60)
    {
        QImage scaledImage = imageRGBS.scaled(242/75*86, 242/75*86, Qt::KeepAspectRatio, Qt::SmoothTransformation);
        for(int x = 0;x<242/75*86;x++)
        {
            for(int y = 0;y<242/75*86;y++)
            {
                image.setPixel(x+82,y+82,scaledImage.pixel(x,y));
            }
        }
        for(int x = 0;x < 450;x++)
        {
            for(int y = 0;y < 450;y++)
            {
                if (pow(x-210, 2) + pow(y-210, 2) <= pow(129, 2))
                {
                    //cout << "点(" << x << "," << y << ")在圆内" << endl;
                } else
                {
                    //cout << "点(" << x << "," << y << ")不在圆内" << endl;
                    image.setPixel(x,y,qRgb(240,240,240));
                }
            }
        }
    }
    else if(bos == 80)
    {
        QImage scaledImage = imageRGBS.scaled(242/75*94, 242/75*94, Qt::KeepAspectRatio, Qt::SmoothTransformation);
        for(int x = 0;x<242/75*94;x++)
        {
            for(int y = 0;y<242/75*94;y++)
            {
                image.setPixel(x+70,y+70,scaledImage.pixel(x,y));
            }
        }
        for(int x = 0;x < 450;x++)
        {
            for(int y = 0;y < 450;y++)
            {
                if (pow(x-210, 2) + pow(y-210, 2) <= pow(141, 2))
                {
                    //cout << "点(" << x << "," << y << ")在圆内" << endl;
                } else
                {
                    //cout << "点(" << x << "," << y << ")不在圆内" << endl;
                    image.setPixel(x,y,qRgb(240,240,240));
                }
            }
        }
    }
    else if(bos == 40)
    {
        QImage scaledImage = imageRGBS.scaled(242/75*94, 242/75*94, Qt::KeepAspectRatio, Qt::SmoothTransformation);
        for(int x = 0;x<242/75*94;x++)
        {
            for(int y = 0;y<242/75*94;y++)
            {
                //贴图左上角
                image.setPixel(x+70,y+70,scaledImage.pixel(x,y));
            }
        }
        for(int x = 0;x < 450;x++)
        {
            for(int y = 0;y < 450;y++)
            {
                if (pow(x-210, 2) + pow(y-210, 2) <= pow(141, 2))
                {
                    //cout << "点(" << x << "," << y << ")在圆内" << endl;
                } else
                {
                    //cout << "点(" << x << "," << y << ")不在圆内" << endl;
                    image.setPixel(x,y,qRgb(240,240,240));
                }
            }
        }
    }

    QPainter painter(&image); // 创建一个QPainter对象，用于绘制图形
    painter.setRenderHint(QPainter::Antialiasing); // 设置抗锯齿

    int n = 5; // 坐标范围为-n到n
    int x0 = 210, y0 = 210; // 坐标原点在图像中心
    int len = 160; // 坐标轴长度为180像素
    int fontSize = 10; // 字体大小为12
    QFont font("微软雅黑", fontSize); // 创建字体对象
    QPen pen(Qt::black, 0.5); // 创建画笔对象，颜色为黑色，线宽为2像素

    //painter.translate(width() / 2, height() / 2);
    QRect rect1(50, 50, 320, 320);
    painter.drawArc(rect1, 294 * 16, 312 * 16);

    int interval = 15;
    if(bos == 60) interval = 15;
    else if(bos == 80)interval = 20;
    else if(bos == 40)interval = 10;

    // 绘制x轴
    painter.setPen(pen);
    painter.drawLine(x0 - len, y0 + len, x0 + len, y0 + len);
    painter.drawLine(x0 - len, y0 - len, x0 + len, y0 - len);
    painter.drawLine(x0 - len, y0, x0 + len, y0);
    painter.drawLine(x0 - 64, y0 +146, x0 + 64, y0+146);
    for (int i = -n; i <= n; i++) {
        int x = x0 + i * len / n;
        painter.drawLine(x, y0 + len, x, y0 + 5 + len);//小竖杠
        painter.setFont(font);
        if(i==1||i==2||i==3||i==4||i==5)painter.drawText(x-fontSize/2 - 5, y0+len+fontSize+12, QString::number(i*interval));
        else if(i==-1||i==-2||i==-3||i==-4||i==-5)
            painter.drawText( x-fontSize/2-10 , y0+len+fontSize+12 , QString::number(i*interval));
        else painter.drawText( x-fontSize/2 , y0+len+fontSize+12 , QString::number(i*interval));
    }

    // 绘制y轴
    painter.setPen(pen);
    painter.drawLine(x0-len, y0 - len, x0-len, y0 + len);
    painter.drawLine(x0+len, y0 - len, x0+len, y0 + len);
    painter.drawLine(x0, y0 - len, x0, y0 + len -14);
    for (int i = -n; i <= n; i++) {
        int y = y0 - i * len / n;
        painter.drawLine(x0-len-5, y, x0-len, y);
        painter.setFont(font);

        if(i == 0) painter.drawText(x0-len-22, y + fontSize / 2, QString::number(i*interval));
        else if(i==1||i==2||i==3||i==4||i==5) painter.drawText(x0-len-31, y + fontSize / 2, QString::number(i*interval));
        else painter.drawText(x0-len-37, y + fontSize / 2, QString::number(i*interval));
    }

    for(int x = 370;x < 395;x++)
    {
        for(int y = 0; y < 40;y++)image.setPixel(x,49+y,qRgb(196, 0, 0));
        for(int y = 40; y < 80;y++)image.setPixel(x,49+y,qRgb(255, 89, 0));
        for(int y = 80; y < 120;y++)image.setPixel(x,49+y,qRgb(255, 208, 0));
        for(int y = 120; y < 160;y++)image.setPixel(x,49+y,qRgb(177, 255, 70));
        for(int y = 160; y < 200;y++)image.setPixel(x,49+y,qRgb(73, 255, 173));
        for(int y = 200; y < 240;y++)image.setPixel(x,49+y,qRgb(98,162,255));
        for(int y = 240; y < 280;y++)image.setPixel(x,49+y,qRgb(80,90,255));
        for(int y = 280; y < 321;y++)image.setPixel(x,49+y,qRgb(23,8,255));
    }
    double small = smallest/=10;
    double big = biggest/=10;
    double eig = (big - small)/8;
    painter.drawText(400,53,QString::number(big,'f',2));
    painter.drawText(400,93,QString::number(small+eig*7,'f',2));
    painter.drawText(400,133,QString::number(small+eig*6,'f',2));
    painter.drawText(400,173,QString::number(small+eig*5,'f',2));
    painter.drawText(400,213,QString::number(small+eig*4,'f',2));
    painter.drawText(400,253,QString::number(small+eig*3,'f',2));
    painter.drawText(400,293,QString::number(small+eig*2,'f',2));
    painter.drawText(400,333,QString::number(small+eig,'f',2));
    painter.drawText(400,373,QString::number(small,'f',2));

    painter.drawText(50,420,"平均数："+QString::number(ave*1000,'f',2));
    painter.drawText(170,420,"众数："+QString::number(modeImage*1000,'f',2));
    painter.drawText(290,420,"标准差："+QString::number(stdDev,'f',4));

    //image
}


double calculate_mean(const QVector<double>& data)
{
    double sum = 0.0;
    for (double value : data) {
        sum += value;
    }
    return sum / data.size();
}

double calculate_standard_deviation(const QVector<double>& data)
{
    if (data.size() < 2) {
        return 0;  // 如果数据点少于两个，则标准差为 0
    }

    double mean = calculate_mean(data);
    double variance = 0.0;
    for (double value : data) {
        variance += std::pow(value*1000 - mean*1000, 2);//为了放大标准差*1000
    }
    variance /= data.size();

    return std::sqrt(variance);
}

QImage RMS_Dll::RMS_Image(int size)
{

//    QString fileName = "D:/PYpro/002-NSC-6-230501.csv";
//    QFile file(fileName); // 新建QFile对象
//    if (!file.open(QFile::ReadOnly | QFile::Text))
//    {
//    }

//    QTextStream in(&file);///文件流in
//    while (!in.atEnd())
//    {
//        QString line = in.readLine();///一行一行的读取
//        QStringList fields;
//        fields.append("1");
//        fields.append(line.split(","));///逗号分隔123元素

//        double A = (fields.at(3)).toDouble();//获取该行第3个单元格内容
//        x.append(A);///QVector<double> x;

//        dataInsert.append(fields);
//    }

    ave = calculate_mean(x);
    stdDev = calculate_standard_deviation(x);

    bos = size;

    auto max = std::max_element(std::begin(x), std::end(x));//最小值表示
    auto min = std::min_element(std::begin(x), std::end(x));//直接赋值表示
    biggest = *max;
    smallest = *min;


    Algo();

    //file.close();
    return image;
}