tmp_osc/EyeMap/GlobalInfo/OscDataInfo.cpp

#include "OscDataInfo.h"

#include "EyeMapInfo.h"
#include "OneOscData.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;
    int numMax = 79999;
    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 >= (double)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;
			}
			(*array)[i][j] = pEyeData2;
		}
	}
	return array;
}


/**
 * @brief 初始化数据点
 * 
 * @param width 显示范围的宽
 * @param height 显示范围的高
 */
void EyeMapMatrix::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].x = (int)(i * saW);
            dataMatrix[i][j].y = (int)(j * saH);
            dataMatrix[i][j].rect = QRect(dataMatrix[i][j].x, dataMatrix[i][j].y, (int)saW, (int)saH);
            dataMatrix[i][j].brush = QBrush(QColor(255, 255, 255));
        }
    }
    mutexEyeData.unlock();
}

/* 拷贝数据到数组中 */
void EyeMapMatrix::copyDataMatrix(Vec2D& data)
{
    for (int i = 0; i < g_HorPixel; i++)
    {
        for (int j = 0; j < g_VerPixel; j++)
        {
            if (dataMatrix[i][j].Count != data[i][j].fCnt)
            {
                if (data[i][j].fCnt > 799.0)
                {
                    dataMatrix[i][j].Count = 799;
                }
                else
                {
                    dataMatrix[i][j].Count = data[i][j].fCnt;
                }
                dataMatrix[i][j].isDraw = true;
            }
        }
    }
}

/* 将Count数值与颜色对应 */
void EyeMapMatrix::addColorBySample()
{
    int r = 0;
    int g = 0;
    int b = 0;
    double dec = 255 / 100.0;
    for(int i = 0; i < g_HorPixel; i++)
    {
        for(int j = 0; j < g_VerPixel; j++)
        {
            if(dataMatrix[i][j].isDraw == false)
            {
                continue;
            }
            if(dataMatrix[i][j].Count <= 0)
            {
                dataMatrix[i][j].Count = 0;
                continue;
            }
            if(dataMatrix[i][j].Count > 799)
            {
                dataMatrix[i][j].Count = 799;
            }
            /* 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].color = QColor(r, g, b);
            dataMatrix[i][j].brush = QBrush(QColor(r, g, b));
        }
    }
}

/**
 * @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()
{

    /* 创建数据矩阵，根据实际的通道个数来创建 */
    auto listChn = GEyeMapInfo.getChannelInfo();
    for(auto chn : listChn)
    {
        EyeDataMatrix* pEyeDataMatrix = new EyeDataMatrix();
        pEyeDataMatrix->initEyeData();
        mapEyeDataMatrix.insert(chn.channel, pEyeDataMatrix);

        EyeMapMatrix* pEyeMapMatrix = new EyeMapMatrix();
        pEyeMapMatrix->initEyeMapData(g_HorPixel, g_VerPixel);
        mapEyeMapMatrix.insert(chn.channel, pEyeMapMatrix);
    }

    /* 加载示波器动态库，初始化示波器相关内容，这里只是初始化完成了，并为开始采集 */
    for(int i = 1; i <= 4; i++)
    {
        OneOscilloscopeData* pOscData = new OneOscilloscopeData();
        pOscData->initOSC(i);
        if(!pOscData->openOSC())
        {
            
            continue;
        }
        /* 获取零电压值 */
        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 */
EyeMapMatrix* OscilloscopeData::findEyeMapMatrix(OscChnNum channel)
{
    auto it = mapEyeMapMatrix.find(channel);
    if(it != mapEyeMapMatrix.end())
    {
        return it.value();
    }
    return nullptr;
}

/* 根据通道号查找示波器 */
OneOscilloscopeData* 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::resetDataMatrix()
{
    for(auto it = mapEyeDataMatrix.begin(); it != mapEyeDataMatrix.end(); ++it)
    {
        it.value()->initEyeData();
    }
}

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

/* 暂停所有的采集 */
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();
        }
    }
}