BOE_FOG_DETECT/ConfigModule/src/ConfigInstance.cpp

/*
 * @Author: your name
 * @Date: 2022-04-20 15:50:00
 * @LastEditTime: 2025-09-25 09:15:15
 * @LastEditors: xiewenji 527774126@qq.com
 * @Description: 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 * @FilePath: /ZCXD_MonitorPlatform/src/CoreLogicModule/src/CamDeal.cpp
 */
#include "ConfigInstance.h"

ConfigInstance::ConfigInstance()
{
    m_ErrorValue = ERROR_Type_Ok;
    m_nCurIdx = 0;
}

ConfigInstance::~ConfigInstance()
{
}

int ConfigInstance::GetConfigIdx()
{
    std::lock_guard<std::mutex> lock(mtx_GetIdx);
    int reidx = m_nCurIdx;
    if (reidx < 0)
    {
        reidx = 0;
    }
    m_nCurIdx++;
    if (m_nCurIdx >= MAX_USER_COUNT)
    {
        m_nCurIdx = MAX_USER_COUNT - 1;
    }

    return reidx;
}

bool ConfigInstance::GetConfigUpdataStatus(int nConfigType, int nidx)
{
    std::lock_guard<std::mutex> lock(mutex_status);

    if (nConfigType >= 0 && nConfigType < ConfigType_Count && nidx >= 0 && nidx < MAX_USER_COUNT)
    {
        m_ErrorValue = ERROR_Type_Ok;
        bool status = m_USER_ConfigUpdataStatusList[nConfigType][nidx];
        m_USER_ConfigUpdataStatusList[nConfigType][nidx] = false;
        return status;
    }
    m_ErrorValue = ERROR_Type_ConfigType;
    return false;
}

int ConfigInstance::GetConfig(int nConfigType, void *pconfig)
{
    if (nConfigType >= 0 && nConfigType < ConfigType_Count)
    {
    }
    else
    {
        m_ErrorValue = ERROR_Type_ConfigType;
        return m_ErrorValue;
    }
    AnalysisyConfigST *p = (AnalysisyConfigST *)pconfig;
    CheckConfigST *p1 = (CheckConfigST *)pconfig;
    ImageInfo *pimg = (ImageInfo *)pconfig;
    switch (nConfigType)
    {
    case ConfigType_Analysisy_Common_XL:
        p->copy(m_AnalysisyConfig);
        break;
    case ConfigType_Check_XL:
        p1->copy(m_CheckConfig);
        break;
    case ConfigType_Image_In:
        pimg->copy(m_CheckConfig.Srcimg_in);
        break;
    case ConfigType_Image_out:
        pimg->copy(m_CheckConfig.resultimg_out);
        break;
    }

    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}

int ConfigInstance::UpdateConfig(void *pconfig, int nConfigType)
{

    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}

int ConfigInstance::UpdateJSONConfig(void *pconfig, int nConfigType)
{
    if (pconfig == NULL)
    {
        m_ErrorValue = ERROR_Type_JsonNull;
        return m_ErrorValue;
    }
    if (nConfigType < 0 || nConfigType >= ConfigType_Count)
    {
        m_ErrorValue = ERROR_Type_ConfigType;
        return m_ErrorValue;
    }

    Json::Value *pJsonConfig = (Json::Value *)pconfig;
    switch (nConfigType)
    {
    case ConfigType_Analysisy_Common_XL:
        Updata_analysis(*pJsonConfig);
        /* code */
        break;
    case ConfigType_Check_XL:
        /* code */
        Updata_Check(*pJsonConfig);
        break;
    default:
        break;
    }

    // getchar();
    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}

std::string ConfigInstance::GetVersion()
{
    m_ErrorValue = ERROR_Type_Ok;
    return std::string();
}

std::string ConfigInstance::GetErrorInfo()
{
    return ERROR_TYPE_Names[m_ErrorValue];
}

int ConfigInstance::Updata_analysis(Json::Value json_value)
{

    // std::cout << json_value << std::endl;
    CommonParamJson configJson;
    configJson.toObjectFromValue(json_value);
    CommonParamST config;
    configJson.GetConfig(config);

    printf("------config.skuName %s \n", config.skuName.c_str());

    // 解析成对应的 参数
    CommonParamToCheckConfigJson tp;
    tp.toObjectFromValue(config.value);

    tp.GetConfig(m_AnalysisyConfig.commonCheckConfig);
    m_AnalysisyConfig.strSkuName = config.skuName;

    int img_W = 0;
    int img_H = 0;

    for (int i = 0; i < m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.size(); i++)
    {
        if (i == 0)
        {
            img_W = m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(i).nodebasicConfog.img_width;
            img_H = m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(i).nodebasicConfog.img_height;
        }
        // m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(i).ToMaskImg();
        // std::string strpath = "mask_" + std::to_string(i) + ".jpg";
        // if (!m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(i).mask.empty())
        // {
        //     cv::imwrite(strpath, m_AnalysisyConfig.commonCheckConfig.nodeConfigArr.at(i).mask);
        // }
    }

    // 解析成对应的 参数
    ChannelFuntonConfigJson jxjason;
    jxjason.toObjectFromValue(config.value);

    jxjason.GetConfig(m_AnalysisyConfig.checkFunction);
    for (int i = 0; i < m_AnalysisyConfig.checkFunction.channelFunctionArr.size(); i++)
    {
        m_AnalysisyConfig.checkFunction.channelFunctionArr.at(i).function.f_ShieldRegion.ToMaskImg(img_W, img_H);
        m_AnalysisyConfig.checkFunction.channelFunctionArr.at(i).function.f_EdgeROI.ToMaskImg(img_W, img_H);
        m_AnalysisyConfig.checkFunction.channelFunctionArr.at(i).function.f_Image_Align.ToMaskImg(img_W, img_H);
    }

    BaseFuntonConfigJson basefjason;
    basefjason.toObjectFromValue(config.value);

    basefjason.GetConfig(m_AnalysisyConfig.baseFunction);

    // m_AnalysisyConfig.checkFunction.print("------------ChannelFunction---------------");
    //  getchar();

    // 更新所有状态
    SetStatus(ConfigType_Analysisy_Common_XL);
    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}

int ConfigInstance::Updata_Check(Json::Value json_value)
{
    std::cout << json_value << std::endl;

    // 解析成对应的 参数
    CheckConfigJson tp;
    tp.toObjectFromValue(json_value);
    tp.GetConfig(m_CheckConfig);
    // 更新所有状态
    SetStatus(ConfigType_Check_XL);

    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}

int ConfigInstance::SetStatus(int nConfigType)
{
    std::lock_guard<std::mutex> lock(mutex_status);
    for (int i = 0; i < MAX_USER_COUNT; i++)
    {
        m_USER_ConfigUpdataStatusList[nConfigType][i] = true;
    }
    m_ErrorValue = ERROR_Type_Ok;
    return 0;
}