tmp_osc/EyeMap/GlobalInfo/OscDataInfo.cpp

#include "OscDataInfo.h"

#include "EyeMapInfo.h"
#include "OneOsc.h"


/* OscData使用的眼图矩阵 */
// EyeDataMatrix g_eyeDataMatrix;
/* OscWidget使用的眼图矩阵 */
// EyeMapMatrix g_eyeMapMatrix;





void EyeDataMatrix::initEyeData()
{
    mutexEyeData.lock();
    // dataMatrix.clear();

    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            dataMatrix[i][j].fCnt = 0.0;
            dataMatrix[i][j].data = 0;
            dataMatrix[i][j].Cnt = 0;
        }
    }
    mutexEyeData.unlock();
}


/* 给一个采样点添加个数，为啥使用浮点数，添加0.99，不直接添加正数呢 */
void EyeDataMatrix::addData(int x, int y) 
{
    if(dataMatrix[x][y].fCnt < 79999.0)
    {
        dataMatrix[x][y].fCnt += eyenWeightCoefficient;
    }
}

/**
 * @brief 比重统计，点数大于79999的个数 比 点数大于0的个数的比重超过0.25，就开始减慢颜色变化的速度
 * 
 */
void EyeDataMatrix::eyeStatisticalWeight()
{
    eyeIsLessenTheBurden = true;
    if (eyenWeightCoefficient <= eyenWeightCoefficientMIN)
    {
        return;
    }
    int num = 0;            /* 点数大于0的个数 */
    int num2 = 0;           /* 点数大于79999的个数 */
    double num3 = 0.0;
    double numMax = 79999.0;
    for (int i = 0; i < g_HorPixel; i++)
    {
        for (int j = 0; j < g_VerPixel; j++)
        {
            if (dataMatrix[i][j].fCnt > 0.0)
            {
                num++;
                if (dataMatrix[i][j].fCnt >= numMax)
                {
                    num2++;
                }
            }
        }
    }
    if (num2 > 0)
    {
        num3 = (double)num2 / (double)num;
    }
    if (num3 >= 0.25)
    {
        eyeIsLessenTheBurden = false;
    }
}

/**
 * @brief 眼图减慢颜色变化的速度
 * 
 */
void EyeDataMatrix::eyeLessenTheBurden()
{
	if (eyeIsLessenTheBurden)
	{
		return;
	}
	int num = 0;
	for (int i = 0; i < g_HorPixel; i++)
	{
		for (int j = 0; j < g_VerPixel; j++)
		{
			if (dataMatrix[i][j].fCnt > 0.0)
			{
				num = (int)(dataMatrix[i][j].fCnt * 0.05);
				dataMatrix[i][j].fCnt -= num;
			}
		}
	}
	eyenWeightCoefficient *= eyenWeightCoefficient;


}


std::shared_ptr<Vec2D> EyeDataMatrix::eyeZoomOut()
{
	std::shared_ptr<Vec2D> array = std::make_shared<Vec2D>(g_HorPixel, std::vector<EyeDataSample>(g_VerPixel));
	for (int i = 0; i < g_HorPixel; i++)
	{
		for (int j = 0; j < g_VerPixel; j++)
		{
			EyeDataSample pEyeData2;
			pEyeData2.x = dataMatrix[i][j].x;
			pEyeData2.y = dataMatrix[i][j].y;
			pEyeData2.fCnt = dataMatrix[i][j].fCnt;
			pEyeData2.data = dataMatrix[i][j].data;
			if (dataMatrix[i][j].fCnt > 0.0) 
            {
				pEyeData2.fCnt /= 100.0;
				pEyeData2.Cnt = (int)pEyeData2.fCnt;
                // dataMatrix[i][j].fCnt /= 100.0;
                // dataMatrix[i][j].Cnt = (int)dataMatrix[i][j].fCnt;
			}
			(*array)[i][j] = pEyeData2;
		}
	}

	return array;
}


/**
 * @brief 初始化数据点
 * 
 * @param width 显示范围的宽
 * @param height 显示范围的高
 */
void EyeColorMatrix::initEyeMapData(int width, int height)
{
    mutexEyeData.lock();
    /*先清空 */
    // dataMatrix.clear();

    double saH = height * 1.0 / g_VerPixel;
    double saW = width * 1.0 / g_HorPixel;
    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            dataMatrix[i][j].isDraw = false;
            dataMatrix[i][j].x = (i * saW);
            dataMatrix[i][j].y = (j * saH);
            dataMatrix[i][j].rect = QRectF(dataMatrix[i][j].x, dataMatrix[i][j].y, saW, saH);
            dataMatrix[i][j].brush = QBrush(QColor(0, 0, 0));
        }
    }
    mutexEyeData.unlock();
}

/* 只清空颜色，其他不需要 */
void EyeColorMatrix::initEyeMapData()
{
    mutexEyeData.lock();
    /*先清空 */
    // dataMatrix.clear();

    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            dataMatrix[i][j].isDraw = false;
            dataMatrix[i][j].Count = 0;
            dataMatrix[i][j].brush = QBrush(QColor(0, 0, 0));
        }
    }
    mutexEyeData.unlock();
}

/* 拷贝数据到数组中 */
void EyeColorMatrix::copyDataMatrix(Vec2D& data)
{
    /* 拷贝数据 */
    // SPDLOG_INFO("data.size = {}, data[0].size = {}", data.size(), data[0].size());
    for (int i = 0; i < g_HorPixel; i++)
    {
        for (int j = 0; j < g_VerPixel; j++)
        {
            /* 判断相较以前累积的数据有没有变化,有变化就新增设置为true */
            if (dataMatrix[i][j].Count != data[i][j].Cnt)
            {
                if (data[i][j].fCnt > 799.0)
                {
                    dataMatrix[i][j].Count = 799;
                }
                else
                {
                    dataMatrix[i][j].Count = data[i][j].Cnt;
                }
                dataMatrix[i][j].isDraw = true;
            }else {
                /* 添加这一句，会实时清空之前残留的颜色 */
                // dataMatrix[i][j].isDraw = false;
            }
            // SPDLOG_DEBUG("Count = {}, Cnt = {}", dataMatrix[i][j].Count, data[i][j].Cnt);
        }
    }
}

/* 将Count数值与颜色对应 */
void EyeColorMatrix::addColorBySample()
{
    int r = 0;
    int g = 0;
    int b = 0;
    // double dec = 255 / 100.0;
    // int dec = 2;
    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            if(dataMatrix[i][j].isDraw == false)
            {
                continue;
            }
            int count = dataMatrix[i][j].Count;
            // SPDLOG_WARN("color");
            if(count <= 0)
            {
                dataMatrix[i][j].Count = 0;
                continue;
            }
            if(count > 799)
            {
                dataMatrix[i][j].Count = 799;
            }

            /* 0~150，从蓝色往青色那边走 */
            if(count > 0 && count <= 150)
            {
                r = 0;
                g = 100 + count;
                b = 255;
            }
            /* 150~400，往绿色方向走 */
            else if(count > 150 && count <= 400)
            {
                r = 0;
                g = 255;
                b = 255 - (count - 150);
            }
            /* 400~650，增加红色，往黄色方向走 */
            else if (count > 400 && count <= 650)
            {
                r = count - 400;
                g = 255;
                b = 0;
            }
            /* 650~799，减少绿色，往红色方向走 */
            else if (count > 650 && count <= 799)
            {
                r = 255;
                g = 255 - (count - 650);
                b = 0;
            }
            else {
                r = 255;
                g = 100;
                b = 0;
            }
            dataMatrix[i][j].brush = QBrush(QColor(r, g, b));


            // /* 1~100，RGB开始减G，往紫色方向走，为显示清楚，G直接从200开始减 */
            // if(dataMatrix[i][j].Count >= 1 && dataMatrix[i][j].Count <= 100)
            // {
            //     r = 255;
            //     g = 200 - dataMatrix[i][j].Count * 2;
            //     b = 255;
            // }
            // /* 101~200，R0B开始减R，往蓝色方向走，这里开始100分成255份 */
            // else if(dataMatrix[i][j].Count >= 101 && dataMatrix[i][j].Count <= 200)
            // {
            //     r = 255 - (dataMatrix[i][j].Count - 100) * dec;
            //     g = 0;
            //     b = 255;
            // }
            // /* 201~300，00B开始增加G，往青色方向走 */
            // else if (dataMatrix[i][j].Count >= 201 && dataMatrix[i][j].Count <= 300)
            // {
            //     r = 0;
            //     g = (dataMatrix[i][j].Count - 200) * dec;
            //     b = 255;
            // }
            // /* 301~400，0GB开始减B，往绿色方向走 */
            // else if (dataMatrix[i][j].Count >= 301 && dataMatrix[i][j].Count <= 400)
            // {
            //     r = 0;
            //     g = 255;
            //     b = 255 - (dataMatrix[i][j].Count - 300) * dec;
            // }
            // /* 401~500，0G0开始增加R，往黄色方向走 */
            // else if (dataMatrix[i][j].Count >= 401 && dataMatrix[i][j].Count <= 500)
            // {
            //     r = (dataMatrix[i][j].Count - 400) * dec;
            //     g = 255;
            //     b = 0;
            // }
            // /* 501~600，RG0开始减G，往红色方向走 */
            // else if (dataMatrix[i][j].Count >= 501 && dataMatrix[i][j].Count <= 600)
            // {
            //     r = 255;
            //     g = 255 - (dataMatrix[i][j].Count - 500) * dec;
            //     b = 0;
            // }
            // /* 601~700，R00开始减R，往黑色方向走 */
            // else if (dataMatrix[i][j].Count >= 601 && dataMatrix[i][j].Count <= 700)
            // {
            //     r = 255 - (dataMatrix[i][j].Count - 600) * dec;
            //     g = 0;
            //     b = 0;
            // }
            // /* 大于700，直接显示黑色 */
            // else
            // {
            //     r = 0;
            //     g = 0;
            //     b = 0;
            // }
            // dataMatrix[i][j].brush = QBrush(QColor(r, g, b));
        }
    }
}

/**
 * @brief 拷贝颜色数据到数组中，这里只拷贝颜色数据
 * 
 * @param data 
 */
void EyeColorMatrix::copyColorMatrix(Vec2DMap& data)
{
    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            dataMatrix[i][j].brush = data[i][j].brush;
            dataMatrix[i][j].isDraw = data[i][j].isDraw;
        }
    }
}

/**
 * @brief Destroy the Oscilloscope Data:: Oscilloscope Data object
 * 
 */
OscilloscopeData::~OscilloscopeData()
{
    // for(auto it = mapEyeDataMatrix.begin(); it != mapEyeDataMatrix.end(); ++it)
    // {
    //     delete it.value();
    // }
    // for(auto it = mapEyeMapMatrix.begin(); it != mapEyeMapMatrix.end(); ++it)
    // {
    //     delete it.value();
    // }
    for(auto it = mapOsc.begin(); it != mapOsc.end(); ++it)
    {
        delete it.value();
    }
}


/* 初始化示波器参数 */
void OscilloscopeData::initOscData()
{
    /* 加载示波器动态库，初始化示波器相关内容，这里只是初始化完成了，并未开始采集
     * 编号从1开始，1是主设备，2、3、4是辅设备 */
    for(int i = 1; i <= 4; i++)
    {
        OneOscilloscope* pOscData = new OneOscilloscope();
        pOscData->initOSC(i);
        pOscData->openOSC();
        /* 获取零电压值 */
        pOscData->getZeroVoltage();
        /* 获取电压校准系数 */
        pOscData->getVoltageCalibration();

        mapOsc.insert(i, pOscData);
    }
    /* 设置示波器参数 */
    for(const auto &it : GEyeMapInfo.listInitEyeMapInfo)
    {
        auto pOsc = GOscDataInfo.findOsc(it.channelInfo.channel);
        if(pOsc == nullptr)
        {
            continue;
        }
        /* 设置采样率 */
        pOsc->setSampleRate(OscSampleRate::SR_100MHZ);
        /* 设置电压等级 */
        if(static_cast<int>(it.channelInfo.channel) % 2 == 1)
        {
            pOsc->setChannelARange(it.voltageRange);
        } else {
            pOsc->setChannelBRange(it.voltageRange);
        }
    }
}

/* 查找EyeDataMatrix */
// EyeDataMatrix* OscilloscopeData::findEyeDataMatrix(OscChnNum channel)
// {
//     auto it = mapEyeDataMatrix.find(channel);
//     if(it != mapEyeDataMatrix.end())
//     {
//         return it.value();
//     }
//     return nullptr;
// }

/* 查找EyeMapMatrix */
// EyeColorMatrix* OscilloscopeData::findEyeMapMatrix(OscChnNum channel)
// {
//     auto it = mapEyeMapMatrix.find(channel);
//     if(it != mapEyeMapMatrix.end())
//     {
//         // SPDLOG_DEBUG("findEyeMapMatrix: {}", (int)it.key());
//         return it.value();
//     }
//     return nullptr;
// }

/* 根据通道号查找示波器 */
OneOscilloscope* OscilloscopeData::findOsc(OscChnNum oscNum)
{
    int num = 0;
    switch (oscNum)
    {
        case OscChnNum::Osc1_CHA:
            num = 1;
            break;
        case OscChnNum::Osc1_CHB:
            num = 1;
            break;
        case OscChnNum::Osc2_CHA:
            num = 2;
            break;
        case OscChnNum::Osc2_CHB:
            num = 2;
            break;
        case OscChnNum::Osc3_CHA:
            num = 3;
            break;
        case OscChnNum::Osc3_CHB:
            num = 3;
            break;
        case OscChnNum::Osc4_CHA:
            num = 4;
            break;
        case OscChnNum::Osc4_CHB:
            num = 4;
            break;
        default:
            break;
    }
    auto it = mapOsc.find(num);
    if(it != mapOsc.end())
    {
        return it.value();
    }
    return nullptr;
}

/* 根据通道号设置电压范围 */
void OscilloscopeData::setVoltageRange(OscChnNum oscNum, OscVoltageRange range)
{
    auto pOsc = findOsc(oscNum);
    if(pOsc == nullptr)
    {
        return;
    }
    if(static_cast<int>(oscNum) % 2 == 1)
    {
        pOsc->setChannelARange(range);
    }
    else
    {
        pOsc->setChannelBRange(range);
    }
}

/* 根据通道号设置时间刻度值 */
void OscilloscopeData::setTimeGridValue(OscChnNum oscNum, OscTimeGridValue value)
{
    auto pOsc = findOsc(oscNum);
    if(pOsc == nullptr)
    {
        return;
    }
    pOsc->setTimeGridValue(value);
}


/* 清空数据矩阵 */
void OscilloscopeData::resetDevMatrix()
{
    /* 重新设置每个眼图的数据矩阵 */
    for(auto it = mapOsc.begin(); it != mapOsc.end(); ++it)
    {
        it.value()->resetData();
    }
}

/* 清空颜色矩阵，重新初始化 */
// void OscilloscopeData::resetColorMatrix(int width, int height)
// {
//     /* 清空全局的颜色矩阵 */
//     // for(auto it = mapEyeMapMatrix.begin(); it != mapEyeMapMatrix.end(); ++it)
//     // {
//     //     it.value()->initEyeMapData(width, height);
//     // }
// }
/* 只清空颜色 */
void OscilloscopeData::resetColorMatrix()
{
    /* 清空全局的颜色矩阵 */
    // for(auto it = mapEyeMapMatrix.begin(); it != mapEyeMapMatrix.end(); ++it)
    // {
    //     it.value()->initEyeMapData();
    // }
}

/* 暂停所有的采集 */
void OscilloscopeData::stopAllCapture()
{
    for(const auto& it : getOsc())
    {
        it->stopCapture();
    }
}

/* 开启所有的采集 */
void OscilloscopeData::startAllCapture()
{
    for(const auto& it : getOsc())
    {
        /* 判断是否显示的眼图，示波器对应的两个眼图都不显示则不开启采集 */
        // if(GEyeMapInfo.hasShowEyeMap(it->getOscNum()))
        // {
        //     it->startCapture();
        // }
        /* 判断示波器是否已经打开 */
        if(!it->isOpen())
        {
            it->openOSC();
        }
        it->startCaptureWithCondition();
    }
}